Acessar modelos da Vertex AI de um fluxo de trabalho

A IA generativa na Vertex AI, também conhecida como genAI ou genAI, oferece acesso aos modelos de IA generativa do Google em várias modalidades (texto, código, imagens, fala). É possível testar e ajustar esses modelos de linguagem grandes (LLM) e implantá-los para uso em aplicativos com tecnologia de IA. Para mais informações, consulte a Visão geral da IA generativa na Vertex AI.

A Vertex AI tem uma variedade de modelos de fundação de IA generativa que podem ser acessados por uma API, incluindo os modelos usados nos exemplos a seguir:

O Gemini Pro foi criado para processar tarefas de linguagem natural, chat de código e texto com várias interações e geração de código.
O Gemini Pro Vision é compatível com comandos multimodais. É possível incluir texto, imagens e vídeo nas solicitações e receber respostas de texto ou código.
O Pathways Language Model 2 (PaLM 2) para texto é ajustado para tarefas de linguagem, como classificação, resumo e extração de entidades.

Cada modelo é exposto por meio de um endpoint do editor específico para seu projeto do Google Cloud. Portanto, não é necessário implantar o modelo de fundação, a menos que você precise ajustá-lo para um caso de uso específico. É possível enviar um prompt ao endpoint do editor. Um prompt é uma solicitação de linguagem natural enviada a um LLM para receber uma resposta de resposta.

Neste tutorial, demonstramos quatro fluxos de trabalho que geram respostas usando modelos da Vertex AI ao enviar solicitações de texto por solicitações HTTP POST para os endpoints do editor. É possível implantar e executar cada fluxo de trabalho de maneira independente.

Objetivos

Neste tutorial, você vai fazer o seguinte:

Ative as APIs Vertex AI e Workflows e conceda o papel de usuário da Vertex AI (roles/aiplatform.user) à sua conta de serviço. Esse papel permite acesso à maioria dos recursos da Vertex AI. Para mais informações sobre como configurar a Vertex AI, consulte Configurar no Google Cloud.
Implantar e executar um fluxo de trabalho que solicite um modelo da Vertex AI (Gemini Pro Vision) para descrever uma imagem disponível publicamente no Cloud Storage. Para mais informações, consulte Tornar os dados públicos.
Implantar e executar um fluxo de trabalho que percorre uma lista de países em paralelo e solicita um modelo da Vertex AI (Gemini Pro) para gerar e retornar os históricos dos países. O uso de ramificações paralelas permite reduzir o tempo total de execução iniciando as chamadas ao LLM ao mesmo tempo e aguardando a conclusão de todas elas antes de combinar os resultados. Para mais informações, consulte Executar etapas do fluxo de trabalho em paralelo.
Implante um fluxo de trabalho semelhante ao anterior. No entanto, solicite um modelo da Vertex AI (PaLM 2 para texto) para gerar e retornar os históricos dos países. Para mais informações sobre como escolher um modelo, consulte Informações do modelo.
Implante um fluxo de trabalho que possa resumir um documento grande. Como há um limite para a janela de contexto que define até onde o modelo analisa durante o treinamento (e para previsões), o fluxo de trabalho divide o documento em partes menores e, em seguida, solicita um modelo da Vertex AI (Gemini Pro) para resumir cada parte em paralelo. Para mais informações, consulte Prompts de resumo e Horizonte da previsão, janela de contexto e janela de previsão.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

Antes de testar os exemplos deste tutorial, verifique se você concluiu as seguintes etapas.

Console

Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs Vertex AI and Workflows.

Ative as APIs

Crie uma conta de serviço:

No Console do Google Cloud, acesse a página Criar conta de serviço.
Acesse "Criar conta de serviço"
Selecione o projeto.
No campo Nome da conta de serviço, insira um nome. O Console do Google Cloud preenche o campo ID da conta de serviço com base nesse nome.

No campo Descrição da conta de serviço, insira uma descrição. Por exemplo, Service account for quickstart.
Clique em Criar e continuar.
Conceda o papel Vertex AI > Vertex AI User à conta de serviço do.

Para conceder o papel, encontre a lista Selecionar um papel e clique em Vertex AI > Vertex AI User.

Observação: o campo Papel afeta quais recursos a conta de serviço pode acessar no projeto. É possível revogar esses papéis ou conceder outros papéis posteriormente. Em ambientes de produção, não conceda os papéis de proprietário, editor ou visualizador. Em vez disso, conceda um papel predefinido ou um papel personalizado que atenda às suas necessidades.
Clique em Continuar.
Clique em Concluído para terminar a criação da conta de serviço.

No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Acessar o seletor de projetos

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs Vertex AI and Workflows.

Ative as APIs

Crie uma conta de serviço:

No Console do Google Cloud, acesse a página Criar conta de serviço.
Acesse "Criar conta de serviço"
Selecione o projeto.
No campo Nome da conta de serviço, insira um nome. O Console do Google Cloud preenche o campo ID da conta de serviço com base nesse nome.

No campo Descrição da conta de serviço, insira uma descrição. Por exemplo, Service account for quickstart.
Clique em Criar e continuar.
Conceda o papel Vertex AI > Vertex AI User à conta de serviço do.

Para conceder o papel, encontre a lista Selecionar um papel e clique em Vertex AI > Vertex AI User.

Observação: o campo Papel afeta quais recursos a conta de serviço pode acessar no projeto. É possível revogar esses papéis ou conceder outros papéis posteriormente. Em ambientes de produção, não conceda os papéis de proprietário, editor ou visualizador. Em vez disso, conceda um papel predefinido ou um papel personalizado que atenda às suas necessidades.
Clique em Continuar.
Clique em Concluído para terminar a criação da conta de serviço.

gcloud

Instale a CLI do Google Cloud.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Crie ou selecione um projeto do Google Cloud.

Crie um projeto do Google Cloud:
```
gcloud projects create PROJECT_ID
```
Substitua PROJECT_ID por um nome para o projeto do Google Cloud que você está criando.
Selecione o projeto do Google Cloud que você criou:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo nome do projeto do Google Cloud.

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs Vertex AI and Workflows:

gcloud services enable aiplatform.googleapis.com workflows.googleapis.com

Configure a autenticação:

Crie a conta de serviço:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
Substitua SERVICE_ACCOUNT_NAME por um nome para a conta de serviço.
Conceda o papel do IAM roles/aiplatform.user à conta de serviço:
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com" --role=roles/aiplatform.user
```
Substitua:
- SERVICE_ACCOUNT_NAME: o nome da conta de serviço.
- PROJECT_ID: o ID do projeto em que você criou a conta de serviço
Observação: a flag --role afeta quais recursos sua conta de serviço pode acessar no projeto. É possível revogar esses papéis ou conceder outros papéis posteriormente. Em ambientes de produção, não conceda os papéis de proprietário, editor ou visualizador. Em vez disso, conceda um papel predefinido ou um papel personalizado que atenda às suas necessidades.

Instale a CLI do Google Cloud.

Para inicializar a CLI gcloud, execute o seguinte comando:

gcloud init

Crie ou selecione um projeto do Google Cloud.

Crie um projeto do Google Cloud:
```
gcloud projects create PROJECT_ID
```
Substitua PROJECT_ID por um nome para o projeto do Google Cloud que você está criando.
Selecione o projeto do Google Cloud que você criou:
```
gcloud config set project PROJECT_ID
```
Substitua PROJECT_ID pelo nome do projeto do Google Cloud.

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Ative as APIs Vertex AI and Workflows:

gcloud services enable aiplatform.googleapis.com workflows.googleapis.com

Configure a autenticação:

Crie a conta de serviço:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
Substitua SERVICE_ACCOUNT_NAME por um nome para a conta de serviço.
Conceda o papel do IAM roles/aiplatform.user à conta de serviço:
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com" --role=roles/aiplatform.user
```
Substitua:
- SERVICE_ACCOUNT_NAME: o nome da conta de serviço.
- PROJECT_ID: o ID do projeto em que você criou a conta de serviço
Observação: a flag --role afeta quais recursos sua conta de serviço pode acessar no projeto. É possível revogar esses papéis ou conceder outros papéis posteriormente. Em ambientes de produção, não conceda os papéis de proprietário, editor ou visualizador. Em vez disso, conceda um papel predefinido ou um papel personalizado que atenda às suas necessidades.

Implantar um fluxo de trabalho que descreva uma imagem (Gemini Pro Vision)

Implantar um fluxo de trabalho que faça uma solicitação http.post para um endpoint do editor do Gemini Pro Vision.

O fluxo de trabalho fornece uma solicitação de texto e o URI de uma imagem disponível publicamente em um bucket do Cloud Storage. É possível visualizar a imagem e, no console do Google Cloud, visualizar os detalhes do objeto.

O fluxo de trabalho retorna uma descrição da imagem a partir da resposta gerada do modelo.

Para mais informações sobre os parâmetros do corpo da solicitação HTTP usados ao solicitar o LLM, e os elementos do corpo da resposta, consulte a referência da API Genmini.

Console

No console do Google Cloud, abra a página Workflows.

Acessar fluxos de trabalho
Clique em Criar.
Insira um nome para o novo fluxo de trabalho: describe-image.
Na lista Região, selecione us-central1 (Iowa).
Em Conta de serviço, selecione a conta de serviço criada anteriormente.
Clique em Próxima.

No editor de fluxo de trabalho, insira a seguinte definição para seu fluxo de trabalho:

main:
    params: [args]
    steps:
    - init:
        assign:
            - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
            - location: "us-central1"
            - model: "gemini-1.0-pro-vision"
            - method: "generateContent"
            - llm_api_endpoint: ${"https://" + location + "-aiplatform.googleapis.com" + "/v1/projects/" + project + "/locations/" + location + "/publishers/google/models/" + model + ":" + method}
            - text_combined: ""
    - ask_llm:
        call: http.post
        args:
            url: ${llm_api_endpoint}
            auth:
                type: OAuth2
            body:
                contents:
                    role: user
                    parts:
                    - fileData:
                        mimeType: image/jpeg
                        fileUri: ${args.image_url}
                    - text: Describe this picture in detail
                generation_config:
                    temperature: 0.4
                    max_output_tokens: 2048
                    top_p: 1
                    top_k: 32
        result: llm_response
    - return_result:
        return:
            image_url: ${args.image_url}
            image_description: ${llm_response.body.candidates[0].content.parts[0].text}

Dependendo do modelo usado, talvez seja necessário remover espaços em branco desnecessários da resposta.

Selecione Implantar.

gcloud

Crie um arquivo de código-fonte para seu fluxo de trabalho:
```
touch describe-image.yaml
```

Em um editor de texto, copie o fluxo de trabalho a seguir para seu arquivo de código-fonte:

main:
    params: [args]
    steps:
    - init:
        assign:
            - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
            - location: "us-central1"
            - model: "gemini-1.0-pro-vision"
            - method: "generateContent"
            - llm_api_endpoint: ${"https://" + location + "-aiplatform.googleapis.com" + "/v1/projects/" + project + "/locations/" + location + "/publishers/google/models/" + model + ":" + method}
            - text_combined: ""
    - ask_llm:
        call: http.post
        args:
            url: ${llm_api_endpoint}
            auth:
                type: OAuth2
            body:
                contents:
                    role: user
                    parts:
                    - fileData:
                        mimeType: image/jpeg
                        fileUri: ${args.image_url}
                    - text: Describe this picture in detail
                generation_config:
                    temperature: 0.4
                    max_output_tokens: 2048
                    top_p: 1
                    top_k: 32
        result: llm_response
    - return_result:
        return:
            image_url: ${args.image_url}
            image_description: ${llm_response.body.candidates[0].content.parts[0].text}

Dependendo do modelo usado, talvez seja necessário remover espaços em branco desnecessários da resposta.

Implante o fluxo de trabalho digitando o seguinte comando:

gcloud workflows deploy describe-image \
    --source=describe-image.yaml \
    --location=us-central1 \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Executar o fluxo de trabalho

Quando um fluxo de trabalho é executado, a definição atual associada a ele também é.

Console

No console do Google Cloud, abra a página Workflows.

Acessar fluxos de trabalho
Na página Fluxos de trabalho, selecione describe-image para acessar a página de detalhes.
Na página Detalhes do fluxo de trabalho, clique em Executar.

Em Entrada, insira o seguinte:

{"image_url":"gs://generativeai-downloads/images/scones.jpg"}

Clique em Executar novamente.

Veja os resultados do fluxo de trabalho no painel Saída.

A saída será semelhante a esta:

{
  "image_description": "There are three pink peony flowers on the right side of the picture[]...]There is a white napkin on the table.",
  "image_url": "gs://generativeai-downloads/images/scones.jpg"
}

gcloud

Abra um terminal.

Execute o fluxo de trabalho:

gcloud workflows run describe-image \
    --data='{"image_url":"gs://generativeai-downloads/images/scones.jpg"}'

Os resultados da execução serão semelhantes aos seguintes:

  Waiting for execution [258b530e-a093-46d7-a4ff-cbf5392273c0] to complete...done.
  argument: '{"image_url":"gs://generativeai-downloads/images/scones.jpg"}'
  createTime: '2024-02-09T13:59:32.166409938Z'
  duration: 4.174708484s
  endTime: '2024-02-09T13:59:36.341118422Z'
  name: projects/1051295516635/locations/us-central1/workflows/describe-image/executions/258b530e-a093-46d7-a4ff-cbf5392273c0
  result: "{\"image_description\":\"The picture shows a rustic table with a white surface,\
    \ on which there are several scones with blueberries, as well as two cups of coffee\
    [...]
    \ on the table. The background of the table is a dark blue color.\",\"image_url\"\
    :\"gs://generativeai-downloads/images/scones.jpg\"}"
  startTime: '2024-02-09T13:59:32.166409938Z'
  state: SUCCEEDED

Implantar um fluxo de trabalho que gere históricos dos países (Gemini Pro)

Implante um fluxo de trabalho que passa por uma lista de entrada de países em parallel, fazendo uma solicitação http.post para um endpoint de editor do Gemini Pro.

O fluxo de trabalho retorna os históricos dos países gerados pelo modelo, combinando-os em um mapa.

Para mais informações sobre os parâmetros do corpo da solicitação HTTP usados ao solicitar o LLM, e os elementos do corpo da resposta, consulte a referência da API Genmini.

Console

No console do Google Cloud, abra a página Workflows.

Acessar fluxos de trabalho
Clique em Criar.
Insira um nome para o novo fluxo de trabalho: gemini-pro-country-histories.
Na lista Região, selecione us-central1 (Iowa).
Em Conta de serviço, selecione a conta de serviço criada anteriormente.
Clique em Próxima.

No editor de fluxo de trabalho, insira a seguinte definição para seu fluxo de trabalho:

main:
    params: [args]
    steps:
    - init:
        assign:
            - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
            - location: "us-central1"
            - model: "gemini-1.0-pro"
            - method: "generateContent"
            - llm_api_endpoint: ${"https://" + location + "-aiplatform.googleapis.com" + "/v1/projects/" + project + "/locations/" + location + "/publishers/google/models/" + model + ":" + method}
            - histories: {}
    - loop_over_countries:
        parallel:
            shared: [histories]
            for:
                value: country
                in: ${args.countries}
                steps:
                    - ask_llm:
                        call: http.post
                        args:
                            url: ${llm_api_endpoint}
                            auth:
                                type: OAuth2
                            body:
                                contents:
                                    role: "USER"
                                    parts:
                                        text: ${"Can you tell me about the history of " + country}
                                generation_config:
                                    temperature: 0.5
                                    max_output_tokens: 2048
                                    top_p: 0.8
                                    top_k: 40
                        result: llm_response
                    - add_to_histories:
                        assign:
                            - histories[country]: ${llm_response.body.candidates[0].content.parts[0].text}
    - return_result:
        return: ${histories}

Selecione Implantar.

gcloud

Crie um arquivo de código-fonte para seu fluxo de trabalho:
```
touch gemini-pro-country-histories.yaml
```

Em um editor de texto, copie o fluxo de trabalho a seguir para seu arquivo de código-fonte:

main:
    params: [args]
    steps:
    - init:
        assign:
            - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
            - location: "us-central1"
            - model: "gemini-1.0-pro"
            - method: "generateContent"
            - llm_api_endpoint: ${"https://" + location + "-aiplatform.googleapis.com" + "/v1/projects/" + project + "/locations/" + location + "/publishers/google/models/" + model + ":" + method}
            - histories: {}
    - loop_over_countries:
        parallel:
            shared: [histories]
            for:
                value: country
                in: ${args.countries}
                steps:
                    - ask_llm:
                        call: http.post
                        args:
                            url: ${llm_api_endpoint}
                            auth:
                                type: OAuth2
                            body:
                                contents:
                                    role: "USER"
                                    parts:
                                        text: ${"Can you tell me about the history of " + country}
                                generation_config:
                                    temperature: 0.5
                                    max_output_tokens: 2048
                                    top_p: 0.8
                                    top_k: 40
                        result: llm_response
                    - add_to_histories:
                        assign:
                            - histories[country]: ${llm_response.body.candidates[0].content.parts[0].text}
    - return_result:
        return: ${histories}

Implante o fluxo de trabalho digitando o seguinte comando:

gcloud workflows deploy gemini-pro-country-histories \
    --source=gemini-pro-country-histories.yaml \
    --location=us-central1 \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Executar o fluxo de trabalho

Quando um fluxo de trabalho é executado, a definição atual associada a ele também é.

Console

No console do Google Cloud, abra a página Workflows.

Acessar fluxos de trabalho
Na página Fluxos de trabalho, selecione o fluxo de trabalho gemini-pro-country-histories para acessar a página de detalhes.
Na página Detalhes do fluxo de trabalho, clique em Executar.

Em Entrada, insira o seguinte:

{"countries":["Argentina", "Bhutan", "Cyprus", "Denmark", "Ethiopia"]}

Clique em Executar novamente.

Veja os resultados do fluxo de trabalho no painel Saída.

A saída será semelhante a esta:

{
  "Argentina": "The history of Argentina is a complex and fascinating one, marked by periods of prosperity and decline, political [...]
  "Bhutan": "The history of Bhutan is a rich and fascinating one, dating back to the 7th century AD. Here is a brief overview: [...]
  "Cyprus": "The history of Cyprus is a long and complex one, spanning over 10,000 years. The island has been ruled by a succession [...]
  "Denmark": "1. **Prehistory and Early History (c. 12,000 BC - 800 AD)**\\n   - The earliest evidence of human habitation in Denmark [...]
  "Ethiopia": "The history of Ethiopia is a long and complex one, stretching back to the earliest human civilizations. The country is [...]
}

gcloud

Abra um terminal.

Execute o fluxo de trabalho:

gcloud workflows run gemini-pro-country-histories \
    --data='{"countries":["Argentina", "Bhutan", "Cyprus", "Denmark", "Ethiopia"]}' \
    --location=us-central1

Os resultados da execução serão semelhantes aos seguintes:

  Waiting for execution [7ae1ccf1-29b7-4c2c-99ec-7a12ae289391] to complete...done.
  argument: '{"countries":["Argentina","Bhutan","Cyprus","Denmark","Ethiopia"]}'
  createTime: '2024-02-09T16:25:16.742349156Z'
  duration: 12.075968673s
  endTime: '2024-02-09T16:25:28.818317829Z'
  name: projects/1051295516635/locations/us-central1/workflows/gemini-pro-country-histories/executions/7ae1ccf1-29b7-4c2c-99ec-7a12ae289391
  result: "{\"Argentina\":\"The history of Argentina can be traced back to the arrival\
    [...]
    n* 2015: Argentina elects Mauricio Macri as president.\",\"Bhutan\":\"The history\
    [...]
    \ natural beauty, ancient monasteries, and friendly people.\",\"Cyprus\":\"The history\
    [...]
    ,\"Denmark\":\"The history of Denmark can be traced back to the Stone Age, with\
    [...]
    \ a high standard of living.\",\"Ethiopia\":\"The history of Ethiopia is long and\
    [...]
  startTime: '2024-02-09T16:25:16.742349156Z'
  state: SUCCEEDED

Implantar um fluxo de trabalho que gere históricos de países (PaLM 2 para texto)

Talvez você não queira usar o Gemini Pro como modelo. O exemplo a seguir usa um fluxo de trabalho semelhante ao anterior. No entanto, a solicitação http.post é feita para um PaLM 2 para endpoint do editor de texto.

Para mais informações sobre os parâmetros do corpo da solicitação HTTP usados ao solicitar o LLM, e os elementos do corpo da resposta, consulte PaLM 2 para referência da API de texto.

Console

No console do Google Cloud, abra a página Workflows.

Acessar fluxos de trabalho
Clique em Criar.
Insira um nome para o novo fluxo de trabalho: text-bison-country-histories.
Na lista Região, selecione us-central1 (Iowa).
Em Conta de serviço, selecione a conta de serviço criada anteriormente.
Clique em Próxima.

No editor de fluxo de trabalho, insira a seguinte definição para seu fluxo de trabalho:

main:
    params: [args]
    steps:
    - init:
        assign:
            - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
            - location: "us-central1"
            - model: "text-bison"
            - method: "predict"
            - llm_api_endpoint: ${"https://" + location + "-aiplatform.googleapis.com" + "/v1/projects/" + project + "/locations/" + location + "/publishers/google/models/" + model + ":" + method}
            - histories: {}
    - loop_over_countries:
        parallel:
            shared: [histories]
            for:
                value: country
                in: ${args.countries}
                steps:
                    - ask_llm:
                        call: http.post
                        args:
                            url: ${llm_api_endpoint}
                            auth:
                                type: OAuth2
                            body:
                                instances:
                                    - prompt: '${"Can you tell me about the history of " + country}'
                                parameters:
                                    temperature: 0.5
                                    maxOutputTokens: 2048
                                    topP: 0.8
                                    topK: 40
                        result: llm_response
                    - add_to_histories:
                        assign:
                            - history: ${llm_response.body.predictions[0].content}
                            # Remove leading whitespace from start of text
                            - history: ${text.substring(history, 1, len(history))}
                            - histories[country]: ${history}
    - return_result:
        return: ${histories}

Dependendo do modelo usado, talvez seja necessário remover espaços em branco desnecessários da resposta.

Selecione Implantar.

gcloud

Crie um arquivo de código-fonte para seu fluxo de trabalho:
```
touch text-bison-country-histories.yaml
```

Em um editor de texto, copie o fluxo de trabalho a seguir para seu arquivo de código-fonte:

main:
    params: [args]
    steps:
    - init:
        assign:
            - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
            - location: "us-central1"
            - model: "text-bison"
            - method: "predict"
            - llm_api_endpoint: ${"https://" + location + "-aiplatform.googleapis.com" + "/v1/projects/" + project + "/locations/" + location + "/publishers/google/models/" + model + ":" + method}
            - histories: {}
    - loop_over_countries:
        parallel:
            shared: [histories]
            for:
                value: country
                in: ${args.countries}
                steps:
                    - ask_llm:
                        call: http.post
                        args:
                            url: ${llm_api_endpoint}
                            auth:
                                type: OAuth2
                            body:
                                instances:
                                    - prompt: '${"Can you tell me about the history of " + country}'
                                parameters:
                                    temperature: 0.5
                                    maxOutputTokens: 2048
                                    topP: 0.8
                                    topK: 40
                        result: llm_response
                    - add_to_histories:
                        assign:
                            - history: ${llm_response.body.predictions[0].content}
                            # Remove leading whitespace from start of text
                            - history: ${text.substring(history, 1, len(history))}
                            - histories[country]: ${history}
    - return_result:
        return: ${histories}

Dependendo do modelo usado, talvez seja necessário remover espaços em branco desnecessários da resposta.

Implante o fluxo de trabalho digitando o seguinte comando:

gcloud workflows deploy text-bison-country-histories \
    --source=text-bison-country-histories.yaml \
    --location=us-central1 \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Implante um fluxo de trabalho que resume um grande documento (Gemini Pro)

Implante um fluxo de trabalho que divida um documento grande em partes menores, fazendo solicitações http.post para um endpoint do editor do Gemini Pro em parallel para que o modelo possa resumir cada parte simultaneamente. O fluxo de trabalho finalmente combina todos os resumos parciais em um completo.

Para mais informações sobre os parâmetros do corpo da solicitação HTTP usados ao solicitar o LLM, e os elementos do corpo da resposta, consulte a referência da API Genmini.

A definição do fluxo de trabalho pressupõe que você criou um bucket do Cloud Storage para o qual é possível fazer upload de um arquivo de texto. Para mais informações sobre o conector do Workflows (googleapis.storage.v1.objects.get) usado para recuperar objetos do bucket do Cloud Storage, consulte a Referência de conectores.

Depois de implantar o fluxo de trabalho, é possível executá-lo criando um gatilho apropriado do Eventarc e, em seguida, fazendo upload de um arquivo para o bucket. Para mais informações, consulte Rotear eventos do Cloud Storage para fluxos de trabalho. É necessário ativar outras APIs e conceder outros papéis, inclusive conceder à sua conta de serviço o papel de Usuário do objeto do Storage (roles/storage.objectUser) compatível com o uso de objetos do Cloud Storage. Para mais informações, consulte a seção Preparar para criar um gatilho.

Console

No console do Google Cloud, abra a página Workflows.

Acessar fluxos de trabalho
Clique em Criar.
Insira um nome para o novo fluxo de trabalho: gemini-pro-summaries.
Na lista Região, selecione us-central1 (Iowa).
Em Conta de serviço, selecione a conta de serviço criada anteriormente.
Clique em Próxima.

No editor de fluxo de trabalho, insira a seguinte definição para seu fluxo de trabalho:

main:
    params: [input]
    steps:
    - assign_file_vars:
        assign:
            - file_size: ${int(input.data.size)}
            - chunk_size: 64000
            - n_chunks: ${int(file_size / chunk_size)}
            - summaries: []
            - all_summaries_concatenated: ""
    - loop_over_chunks:
        parallel:
            shared: [summaries]
            for:
                value: chunk_idx
                range: ${[0, n_chunks]}
                steps:
                    - assign_bounds:
                        assign:
                            - lower_bound: ${chunk_idx * chunk_size}
                            - upper_bound: ${(chunk_idx + 1) * chunk_size}
                            - summaries: ${list.concat(summaries, "")}
                    - dump_file_content:
                        call: http.get
                        args:
                            url: ${"https://storage.googleapis.com/storage/v1/b/" + input.data.bucket + "/o/" + input.data.name + "?alt=media"}
                            auth:
                                type: OAuth2
                            headers:
                                Range: ${"bytes=" + lower_bound + "-" + upper_bound}
                        result: file_content
                    - assign_chunk:
                        assign:
                            - chunk: ${file_content.body}
                    - generate_chunk_summary:
                        call: ask_gemini_for_summary
                        args:
                            textToSummarize: ${chunk}
                        result: summary
                    - assign_summary:
                        assign:
                            - summaries[chunk_idx]: ${summary}
    - concat_summaries:
        for:
            value: summary
            in: ${summaries}
            steps:
                - append_summaries:
                    assign:
                        - all_summaries_concatenated: ${all_summaries_concatenated + "\n" + summary}
    - reduce_summary:
        call: ask_gemini_for_summary
        args:
            textToSummarize: ${all_summaries_concatenated}
        result: final_summary
    - return_result:
        return:
            - summaries: ${summaries}
            - final_summary: ${final_summary}

ask_gemini_for_summary:
    params: [textToSummarize]
    steps:
        - init:
            assign:
                - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
                - location: "us-central1"
                - model: "gemini-pro"
                - summary: ""
        - call_gemini:
            call: http.post
            args:
                url: ${"https://" + location + "-aiplatform.googleapis.com" + "/v1/projects/" + project + "/locations/" + location + "/publishers/google/models/" + model + ":generateContent"}
                auth:
                    type: OAuth2
                body:
                    contents:
                        role: user
                        parts:
                            - text: '${"Make a summary of the following text:\n\n" + textToSummarize}'
                    generation_config:
                        temperature: 0.2
                        maxOutputTokens: 2000
                        topK: 10
                        topP: 0.9
            result: gemini_response
        # Sometimes, there's no text, for example, due to safety settings
        - check_text_exists:
            switch:
            - condition: ${not("parts" in gemini_response.body.candidates[0].content)}
              next: return_summary
        - extract_text:
            assign:
                - summary: ${gemini_response.body.candidates[0].content.parts[0].text}
        - return_summary:
            return: ${summary}

Selecione Implantar.

gcloud

Crie um arquivo de código-fonte para seu fluxo de trabalho:
```
touch gemini-pro-summaries.yaml
```

Em um editor de texto, copie o fluxo de trabalho a seguir para seu arquivo de código-fonte:

main:
    params: [input]
    steps:
    - assign_file_vars:
        assign:
            - file_size: ${int(input.data.size)}
            - chunk_size: 64000
            - n_chunks: ${int(file_size / chunk_size)}
            - summaries: []
            - all_summaries_concatenated: ""
    - loop_over_chunks:
        parallel:
            shared: [summaries]
            for:
                value: chunk_idx
                range: ${[0, n_chunks]}
                steps:
                    - assign_bounds:
                        assign:
                            - lower_bound: ${chunk_idx * chunk_size}
                            - upper_bound: ${(chunk_idx + 1) * chunk_size}
                            - summaries: ${list.concat(summaries, "")}
                    - dump_file_content:
                        call: http.get
                        args:
                            url: ${"https://storage.googleapis.com/storage/v1/b/" + input.data.bucket + "/o/" + input.data.name + "?alt=media"}
                            auth:
                                type: OAuth2
                            headers:
                                Range: ${"bytes=" + lower_bound + "-" + upper_bound}
                        result: file_content
                    - assign_chunk:
                        assign:
                            - chunk: ${file_content.body}
                    - generate_chunk_summary:
                        call: ask_gemini_for_summary
                        args:
                            textToSummarize: ${chunk}
                        result: summary
                    - assign_summary:
                        assign:
                            - summaries[chunk_idx]: ${summary}
    - concat_summaries:
        for:
            value: summary
            in: ${summaries}
            steps:
                - append_summaries:
                    assign:
                        - all_summaries_concatenated: ${all_summaries_concatenated + "\n" + summary}
    - reduce_summary:
        call: ask_gemini_for_summary
        args:
            textToSummarize: ${all_summaries_concatenated}
        result: final_summary
    - return_result:
        return:
            - summaries: ${summaries}
            - final_summary: ${final_summary}

ask_gemini_for_summary:
    params: [textToSummarize]
    steps:
        - init:
            assign:
                - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
                - location: "us-central1"
                - model: "gemini-pro"
                - summary: ""
        - call_gemini:
            call: http.post
            args:
                url: ${"https://" + location + "-aiplatform.googleapis.com" + "/v1/projects/" + project + "/locations/" + location + "/publishers/google/models/" + model + ":generateContent"}
                auth:
                    type: OAuth2
                body:
                    contents:
                        role: user
                        parts:
                            - text: '${"Make a summary of the following text:\n\n" + textToSummarize}'
                    generation_config:
                        temperature: 0.2
                        maxOutputTokens: 2000
                        topK: 10
                        topP: 0.9
            result: gemini_response
        # Sometimes, there's no text, for example, due to safety settings
        - check_text_exists:
            switch:
            - condition: ${not("parts" in gemini_response.body.candidates[0].content)}
              next: return_summary
        - extract_text:
            assign:
                - summary: ${gemini_response.body.candidates[0].content.parts[0].text}
        - return_summary:
            return: ${summary}

Implante o fluxo de trabalho digitando o seguinte comando:

gcloud workflows deploy gemini-pro-summaries \
    --source=gemini-pro-summaries.yaml \
    --location=us-central1 \
    --service-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Exclua o projeto

Console

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

No Console do Google Cloud, acesse a página Gerenciar recursos.
Acessar "Gerenciar recursos"
Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

gcloud

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

Exclua um projeto do Google Cloud:

gcloud projects delete PROJECT_ID

Excluir recursos individuais

Exclua os fluxos de trabalho criados neste tutorial.

A seguir

Saiba mais sobre como fazer uma solicitação HTTP.
Saiba mais sobre o método streamGenerateContent da Vertex AI.
Saiba mais sobre o método predict da Vertex AI.