Acessar modelos da Vertex AI em um fluxo de trabalho

---

A IA generativa na Vertex AI (também conhecida como genAI ou gen AI) oferece acesso aos modelos de IA generativa do Google para várias modalidades (texto, código, imagens, fala). É possível testar e ajustar esses modelos de linguagem grandes (LLMs) e, em seguida, 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 vários modelos de base de IA generativa que podem ser acessados por uma API, incluindo os modelos usados nos exemplos a seguir:

• O Gemini Pro foi projetado para lidar com tarefas de linguagem natural, chat de código e texto com vários turnos e geração de código.
• O Gemini Pro Vision oferece suporte a 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. Por isso, não é necessário implantar o modelo de fundação, a menos que você precise ajustá-lo para um caso de uso específico. Você pode enviar uma solicitação para o endpoint do editor. Um comando é uma solicitação de linguagem natural enviada a um LLM para receber uma resposta.

Este tutorial demonstra fluxos de trabalho que geram respostas de modelos da Vertex AI enviando comandos de texto para os endpoints do editor usando um conector de fluxos de trabalho ou uma solicitação HTTP POST. Para mais informações, consulte a Visão geral do conector da API Vertex AI e Fazer uma solicitação HTTP.

É possível implantar e executar cada fluxo de trabalho de forma independente.

Objetivos

Neste tutorial, você vai:

1. 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 o acesso à maioria dos recursos da Vertex AI. Para mais informações sobre a configuração da Vertex AI, consulte Configurar a Google Cloud.
2. Implante e execute um fluxo de trabalho que solicita que um modelo da Vertex AI (Gemini Pro Vision) descreva uma imagem disponível publicamente no Cloud Storage. Para mais informações, consulte Tornar os dados públicos.
3. Implante e execute um fluxo de trabalho que percorre uma lista de países em paralelo e solicita que um modelo da Vertex AI (Gemini Pro) gere e retorne os históricos dos países. O uso de ramos paralelos permite reduzir o tempo total de execução iniciando as chamadas para o 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.
4. 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.
5. Implante um fluxo de trabalho que possa resumir um documento grande. Como há um limite para a janela de contexto, que define o período de deslocamento do modelo durante o treinamento (e as previsões), o fluxo de trabalho divide o documento em partes menores e solicita que um modelo da Vertex AI (Gemini Pro) resuma cada parte em paralelo. Para mais informações, consulte Instruções de resumo e Horizonte de previsão, janela de contexto e janela de previsão.

Custos

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

• Vertex AI
• Workflows

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 neste tutorial, verifique se você concluiu as seguintes etapas.

Console

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Vertex AI and Workflows APIs.

   Enable the APIs

5. Create a service account:

   1. In the Google Cloud console, go to the Create service account page.

      Go to Create service account
   2. Select your project.

   3. In the Service account name field, enter a name. The Google Cloud console fills in the Service account ID field based on this name.

      In the Service account description field, enter a description. For example, Service account for quickstart.

   4. Click Create and continue.

   5. Grant the Vertex AI > Vertex AI User role to the service account.

      To grant the role, find the Select a role list, then select Vertex AI > Vertex AI User.

      Note: The Role field affects which resources the service account can access in your project. You can revoke these roles or grant additional roles later.
   6. Click Continue.

   7. Click Done to finish creating the service account.

6. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

7. Make sure that billing is enabled for your Google Cloud project.

8. Enable the Vertex AI and Workflows APIs.

   Enable the APIs

9. Create a service account:

   1. In the Google Cloud console, go to the Create service account page.

      Go to Create service account
   2. Select your project.

   3. In the Service account name field, enter a name. The Google Cloud console fills in the Service account ID field based on this name.

      In the Service account description field, enter a description. For example, Service account for quickstart.

   4. Click Create and continue.

   5. Grant the Vertex AI > Vertex AI User role to the service account.

      To grant the role, find the Select a role list, then select Vertex AI > Vertex AI User.

      Note: The Role field affects which resources the service account can access in your project. You can revoke these roles or grant additional roles later.
   6. Click Continue.

   7. Click Done to finish creating the service account.

gcloud

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
2. Install the Google Cloud CLI.

3. To initialize the gcloud CLI, run the following command:

   gcloud init

4. Create or select a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   • Create a Google Cloud project:

     gcloud projects create PROJECT_ID

     Replace PROJECT_ID with a name for the Google Cloud project you are creating.

   • Select the Google Cloud project that you created:

     gcloud config set project PROJECT_ID

     Replace PROJECT_ID with your Google Cloud project name.

5. Make sure that billing is enabled for your Google Cloud project.

6. Enable the Vertex AI and Workflows APIs:

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

7. Set up authentication:

   1. Create the service account:

      gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

      Replace SERVICE_ACCOUNT_NAME with a name for the service account.

   2. Grant the roles/aiplatform.user IAM role to the service account:

      gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com" --role=roles/aiplatform.user

      Replace the following:

      • SERVICE_ACCOUNT_NAME: the name of the service account
      • PROJECT_ID: the project ID where you created the service account
      Note: The --role flag affects which resources the service account can access in your project. You can revoke these roles or grant additional roles later.
8. Install the Google Cloud CLI.

9. To initialize the gcloud CLI, run the following command:

   gcloud init

10. Create or select a Google Cloud project.

    Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

    • Create a Google Cloud project:

      gcloud projects create PROJECT_ID

      Replace PROJECT_ID with a name for the Google Cloud project you are creating.

    • Select the Google Cloud project that you created:

      gcloud config set project PROJECT_ID

      Replace PROJECT_ID with your Google Cloud project name.

11. Make sure that billing is enabled for your Google Cloud project.

12. Enable the Vertex AI and Workflows APIs:

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

13. Set up authentication:

    1. Create the service account:

       gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

       Replace SERVICE_ACCOUNT_NAME with a name for the service account.

    2. Grant the roles/aiplatform.user IAM role to the service account:

       gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com" --role=roles/aiplatform.user

       Replace the following:

       • SERVICE_ACCOUNT_NAME: the name of the service account
       • PROJECT_ID: the project ID where you created the service account
       Note: The --role flag affects which resources the service account can access in your project. You can revoke these roles or grant additional roles later.

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

Implante um fluxo de trabalho que use um método de conector (generateContent) para fazer uma solicitação a um endpoint de editor do Gemini Pro Vision. O método oferece suporte à geração de conteúdo com entradas multimodais.

O fluxo de trabalho fornece um comando 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, ver os detalhes do objeto.

O fluxo de trabalho retorna uma descrição da imagem da resposta gerada pelo 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 Gemini.

Console

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

   Acessar fluxos de trabalho

2. Clique em Criar.

3. Insira um nome para o novo fluxo de trabalho: describe-image.

4. Na lista Região, selecione us-central1 (Iowa).

5. Em Conta de serviço, selecione a conta de serviço que você criou anteriormente.

6. Clique em Próxima.

7. No editor de fluxo de trabalho, insira a seguinte definição:

   main:
       params: [args]
       steps:
       - init:
           assign:
               - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
               - location: "us-central1"
               - model: "gemini-1.0-pro-vision"
               - text_combined: ""
       - ask_llm:
           call: googleapis.aiplatform.v1.projects.locations.endpoints.generateContent
           args:
               model: ${"projects/" + project + "/locations/" + location + "/publishers/google/models/" + model}
               region: ${location}
               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.candidates[0].content.parts[0].text}

8. Clique em Implantar.

gcloud

1. Crie um arquivo de código-fonte para seu fluxo de trabalho:

   touch describe-image.yaml

2. Em um editor de texto, copie o seguinte fluxo de trabalho para o 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"
               - text_combined: ""
       - ask_llm:
           call: googleapis.aiplatform.v1.projects.locations.endpoints.generateContent
           args:
               model: ${"projects/" + project + "/locations/" + location + "/publishers/google/models/" + model}
               region: ${location}
               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.candidates[0].content.parts[0].text}

3. 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

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

   Acessar fluxos de trabalho

2. Na página Fluxos de trabalho, selecione o fluxo de trabalho describe-image para acessar a página de detalhes dele.

3. Na página Detalhes do fluxo de trabalho, clique em Executar.

4. Em Entrada, insira o seguinte:

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

5. Clique em Executar novamente.

6. Confira 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

1. Abra um terminal.

2. 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 a estes:

     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 gera históricos de países (Gemini Pro)

Implante um fluxo de trabalho que percorre uma lista de entrada de países em paralelo e usa um método de conector (generateContent) para fazer uma solicitação a um endpoint de editor do Gemini Pro. O método oferece suporte para a geração de conteúdo com entradas multimodais.

O fluxo de trabalho retorna os históricos de 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 Gemini.

Console

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

   Acessar fluxos de trabalho

2. Clique em Criar.

3. Insira um nome para o novo fluxo de trabalho: gemini-pro-country-histories.

4. Na lista Região, selecione us-central1 (Iowa).

5. Em Conta de serviço, selecione a conta de serviço que você criou anteriormente.

6. Clique em Próxima.

7. No editor de fluxo de trabalho, insira a seguinte definição:

   main:
       params: [args]
       steps:
       - init:
           assign:
               - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
               - location: "us-central1"
               - model: "gemini-1.0-pro"
               - histories: {}
       - loop_over_countries:
           parallel:
               shared: [histories]
               for:
                   value: country
                   in: ${args.countries}
                   steps:
                       - ask_llm:
                           call: googleapis.aiplatform.v1.projects.locations.endpoints.generateContent
                           args:
                               model: ${"projects/" + project + "/locations/" + location + "/publishers/google/models/" + model}
                               region: ${location}
                               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.candidates[0].content.parts[0].text}
       - return_result:
           return: ${histories}

8. Clique em Implantar.

gcloud

1. Crie um arquivo de código-fonte para seu fluxo de trabalho:

   touch gemini-pro-country-histories.yaml

2. Em um editor de texto, copie o seguinte fluxo de trabalho para o 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"
               - histories: {}
       - loop_over_countries:
           parallel:
               shared: [histories]
               for:
                   value: country
                   in: ${args.countries}
                   steps:
                       - ask_llm:
                           call: googleapis.aiplatform.v1.projects.locations.endpoints.generateContent
                           args:
                               model: ${"projects/" + project + "/locations/" + location + "/publishers/google/models/" + model}
                               region: ${location}
                               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.candidates[0].content.parts[0].text}
       - return_result:
           return: ${histories}

3. 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

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

   Acessar fluxos de trabalho

2. Na página Fluxos de trabalho, selecione o fluxo de trabalho gemini-pro-country-histories para acessar a página de detalhes dele.

3. Na página Detalhes do fluxo de trabalho, clique em Executar.

4. Em Entrada, insira o seguinte:

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

5. Clique em Executar novamente.

6. Confira 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

1. Abra um terminal.

2. 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 a estes:

     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 gera 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, ele usa um método de conector (predict) para fazer uma solicitação a um endpoint do editor de texto do PaLM 2. O método realiza uma previsão on-line.

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 PaLM 2 para texto.

Console

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

   Acessar fluxos de trabalho

2. Clique em Criar.

3. Insira um nome para o novo fluxo de trabalho: text-bison-country-histories.

4. Na lista Região, selecione us-central1 (Iowa).

5. Em Conta de serviço, selecione a conta de serviço que você criou anteriormente.

6. Clique em Próxima.

7. No editor de fluxo de trabalho, insira a seguinte definição:

   main:
       params: [args]
       steps:
       - init:
           assign:
               - project: ${sys.get_env("GOOGLE_CLOUD_PROJECT_ID")}
               - location: "us-central1"
               - model: "text-bison"
               - histories: {}
       - loop_over_countries:
           parallel:
               shared: [histories]
               for:
                   value: country
                   in: ${args.countries}
                   steps:
                       - ask_llm:
                           call: googleapis.aiplatform.v1.projects.locations.endpoints.predict
                           args:
                               endpoint: ${"projects/" + project + "/locations/" + location + "/publishers/google/models/" + model }
                               region: ${location}
                               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.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.

8. Clique em Implantar.

gcloud

1. Crie um arquivo de código-fonte para seu fluxo de trabalho:

   touch text-bison-country-histories.yaml

2. Em um editor de texto, copie o seguinte fluxo de trabalho para o 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"
               - histories: {}
       - loop_over_countries:
           parallel:
               shared: [histories]
               for:
                   value: country
                   in: ${args.countries}
                   steps:
                       - ask_llm:
                           call: googleapis.aiplatform.v1.projects.locations.endpoints.predict
                           args:
                               endpoint: ${"projects/" + project + "/locations/" + location + "/publishers/google/models/" + model }
                               region: ${location}
                               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.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.

3. 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

Implantar um fluxo de trabalho que resuma um documento grande (Gemini Pro)

Implante um fluxo de trabalho que divida um documento grande em partes menores, fazendo solicitações de http.post para um endpoint de editor do Gemini Pro em paralelo para que o modelo possa resumir cada parte simultaneamente. O fluxo de trabalho, por fim, combina todos os resumos parciais em um resumo 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 Gemini.

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

Depois de implantar o fluxo de trabalho, você pode executá-lo criando um acionador do Eventarc adequado e fazendo upload de um arquivo para o bucket. Para mais informações, consulte Encaminhar eventos do Cloud Storage para o Workflows. Outras APIs precisam ser ativadas e outros papéis precisam ser concedidos, incluindo o papel de usuário do objeto de armazenamento (roles/storage.objectUser) que oferece suporte ao uso de objetos do Cloud Storage. Para mais informações, consulte a seção Preparar-se para criar um gatilho.

Console

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

   Acessar fluxos de trabalho

2. Clique em Criar.

3. Insira um nome para o novo fluxo de trabalho: gemini-pro-summaries.

4. Na lista Região, selecione us-central1 (Iowa).

5. Em Conta de serviço, selecione a conta de serviço que você criou anteriormente.

6. Clique em Próxima.

7. No editor de fluxo de trabalho, insira a seguinte definição:

   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}

8. Clique em Implantar.

gcloud

1. Crie um arquivo de código-fonte para seu fluxo de trabalho:

   touch gemini-pro-summaries.yaml

2. Em um editor de texto, copie o seguinte fluxo de trabalho para o 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}

3. 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.

Excluir 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.

1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

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.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Excluir recursos individuais

Exclua os fluxos de trabalho criados neste tutorial.

A seguir

• Saiba mais sobre os conectores do Workflows.
• Saiba mais sobre o método generateContent da Vertex AI.
• Saiba mais sobre o método predict da Vertex AI.