Acessar modelos da Vertex AI em um fluxo de trabalho

A IA generativa na Vertex AI (também conhecida como genAI ou genAI) dá acesso a 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 (LLM) e, em seguida, implantá-los para uso nos seus aplicativos com tecnologia de IA. Para mais informações, consulte o Informações gerais de IA generativa na Vertex AI.

Vertex AI. tem uma variedade de modelos de fundação de IA generativa que são acessíveis por uma API, incluindo os modelos usados nos exemplos a seguir:

  • O Gemini Pro foi criado para processar linguagem natural tarefas, texto com várias interações, chat de código e geração de código.
  • O Gemini Pro Vision dá 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 como classificação, resumo e extração de entidades.

Cada modelo é exposto por meio de um endpoint do editor específico para sua projeto do Google Cloud, portanto, não é necessário implantar o modelo de fundação, a menos que você ou necessário ajustá-lo para um caso de uso específico. Envie uma solicitação ao editor endpoint do Google Cloud. Um comando é uma solicitação de linguagem natural enviada a um LLM para receber uma responder de volta.

Este tutorial demonstra fluxos de trabalho que geram respostas Modelos da Vertex AI enviando comandos de texto ao editor endpoints que usam um conector do Workflows ou um HTTP POST solicitação. 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 maneira independente.

Objetivos

Neste tutorial, você vai fazer o seguinte:

  1. Ativar as APIs Vertex AI e Workflows e conceder o papel de Usuário da Vertex AI (roles/aiplatform.user) ao seu serviço do Compute Engine. Esse papel permite o acesso à maioria recursos. Para mais informações sobre como configurar a Vertex AI, ver Configurar o Google Cloud.
  2. Implantar e executar um fluxo de trabalho que solicita um modelo da Vertex AI (Gemini Pro Vision) para descrever uma imagem publicamente disponíveis no Cloud Storage. Para mais informações, consulte Tornar os dados públicos.
  3. Implantar e executar um fluxo de trabalho que percorre uma lista de países em paralelo e envia um modelo da Vertex AI (Gemini Pro) para gerar e mostrar a história dos países. Como usar ramificações paralelas permite reduzir o tempo total de execução iniciando as chamadas para o LLM ao mesmo tempo e aguardando a conclusão de todos antes de combinar as resultados. Para mais informações, consulte Execute as etapas do fluxo de trabalho em paralelo.
  4. Implantar um fluxo de trabalho semelhante ao anterior. No entanto, solicite um modelo da Vertex AI (PaLM 2 para texto) para gerar e retornar a história dos países. Para mais informações sobre como escolher um modelo, consulte Informações do modelo.
  5. Implante um fluxo de trabalho capaz de resumir um documento grande. Como existe limitado à janela de contexto, que define o período de visualização do modelo durante (e para previsões), o fluxo de trabalho divide o documento em e, em seguida, solicita um modelo da Vertex AI (Gemini Pro) para resumir cada parte em paralelo. Para mais informações, consulte Comandos de resumo e Horizonte, 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, certifique-se de ter concluído o seguinte.

Console

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

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

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

  4. Ative as APIs Vertex AI and Workflows.

    Ative as 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.

    6. Click Continue.

    7. Click Done to finish creating the service account.

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

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

  8. Ative as APIs Vertex AI and Workflows.

    Ative as 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.

    6. Click Continue.

    7. Click Done to finish creating the service account.

gcloud

  1. 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.
  2. Install the Google Cloud CLI.

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

    gcloud init

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

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

  6. Ative as APIs Vertex AI and Workflows: 

    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
    8.
  8. Install the Google Cloud CLI.

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

    gcloud init

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

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

  12. Ative as APIs Vertex AI and Workflows: 

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

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

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

O fluxo de trabalho fornece um comando de texto e o URI de uma imagem que é publicamente disponíveis em um bucket do Cloud Storage. Você pode ver a imagem e, no console do Google Cloud, confira os detalhes do objeto.

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

Para mais informações sobre os parâmetros do corpo da solicitação HTTP usados na solicitação 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. Digite 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ê criados.

  6. Clique em Next.

  7. 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"
            - 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 fluxo de trabalho a seguir 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 describe-image para acessar a página de detalhes.

  3. Na página Detalhes do fluxo de trabalho, clique em Execução.

  4. Em Entrada, insira o seguinte:

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

  5. Clique em Executar novamente.

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

  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 vão ser semelhantes aos mostrados a seguir:

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

Implantar um fluxo de trabalho que percorre uma lista de entrada de países na paralelo e usa um método de conexão (generateContent) para fazer um pedido para um Gemini Pro endpoint do editor. O método oferece suporte à geração de conteúdo com multimodais.

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

Para mais informações sobre os parâmetros do corpo da solicitação HTTP usados na solicitação 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. Digite 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ê criados.

  6. Clique em Next.

  7. 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"
            - 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 fluxo de trabalho a seguir 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 gemini-pro-country-histories acessar a página de detalhes.

  3. Na página Detalhes do fluxo de trabalho, clique em Execução.

  4. Em Entrada, insira o seguinte:

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

  5. Clique em Executar novamente.

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

  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 vão ser semelhantes aos mostrados a seguir:

      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 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 PaLM 2. para o endpoint do editor de texto. O método realiza uma previsão on-line.

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

Console

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

    Acessar fluxos de trabalho

  2. Clique em Criar.

  3. Digite 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ê criados.

  6. Clique em Next.

  7. 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"
            - 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, pode ser necessário remover quaisquer espaços 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 fluxo de trabalho a seguir 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, pode ser necessário remover quaisquer espaços 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 documentos grandes (Gemini Pro)

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

Para mais informações sobre os parâmetros do corpo da solicitação HTTP usados na solicitação 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 bucket em que é possível fazer upload de um arquivo de texto. Para mais informações sobre o conector do Workflows (googleapis.storage.v1.objects.get) usados 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 do Eventarc e faz upload de um arquivo para o bucket. Para mais informações, consulte Rotear eventos do Cloud Storage para fluxos de trabalho. Outras APIs precisam ser ativadas e outros papéis precisam ser concedido, incluindo a concessão do conta de serviço Usuário do objeto do Storage (roles/storage.objectUser) compatível com o uso do Cloud Storage objetos. Para mais informações, consulte a Prepare-se para criar um acionador.

Console

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

    Acessar fluxos de trabalho

  2. Clique em Criar.

  3. Digite 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ê criados.

  6. Clique em Next.

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

  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 fluxo de trabalho a seguir 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.

Exclua o projeto

Console

  1. No Console do Google Cloud, acesse a página Gerenciar recursos.

    Acessar "Gerenciar recursos"

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
  3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

gcloud

Exclua um projeto do Google Cloud:

gcloud projects delete PROJECT_ID

Excluir recursos individuais

Excluir os fluxos de trabalho que você criou neste tutorial.

A seguir