Se usó la API de Cloud Translation para traducir esta página.

Accede a los modelos de Vertex AI desde un flujo de trabajo

La IA generativa en Vertex AI (también conocida como genAI o genAI) te brinda acceso a los modelos de IA generativa de Google para múltiples modalidades (texto, código, imágenes y voz). Puedes probar y ajustar estos modelos grandes de lenguaje (LLM) y, luego, implementarlos para usarlos en tus aplicaciones con tecnología de IA. Para obtener más información, consulta la Descripción general de la IA generativa en Vertex AI.

Vertex AI tiene una variedad de modelos de base de IA generativa a los que se puede acceder a través de una API, incluidos los modelos que se usan en los siguientes ejemplos:

Gemini Pro se diseñó para manejar tareas de lenguaje natural, chat de código y texto de varios turnos, y generación de código.
Gemini Pro Vision admite instrucciones multimodales. Puedes incluir texto, imágenes y video en las solicitudes de prompts y obtener respuestas de texto o código.
Pathways Language Model 2 (PaLM 2) para texto se ajusta bien a las tareas de lenguaje, como la clasificación, el resumen y la extracción de entidades.

Cada modelo se expone a través de un extremo de publicador específico para tu proyecto de Google Cloud, por lo que no es necesario implementar el modelo de base, a menos que necesites ajustarlo para un caso práctico específico. Puedes enviar un mensaje al extremo del publicador. Una instrucción es una solicitud en lenguaje natural que se envía a un LLM para provocar una respuesta.

En este instructivo, se muestran flujos de trabajo que generan respuestas de modelos de Vertex AI mediante el envío de mensajes de texto a los extremos del publicador mediante un conector de Workflows o una solicitud HTTP POST. Para obtener más información, consulta la descripción general del conector a la API de Vertex AI y Realiza una solicitud HTTP.

Ten en cuenta que puedes implementar y ejecutar cada flujo de trabajo de forma independiente.

Objetivos

En este instructivo, harás lo siguiente:

Habilita las APIs de Vertex AI y Workflows, y otorga el rol de usuario de Vertex AI (roles/aiplatform.user) a tu cuenta de servicio. Este rol permite acceder a la mayoría de las capacidades de Vertex AI. Si quieres obtener más información para configurar Vertex AI, consulta Comienza a usar Google Cloud.
Implementa y ejecuta un flujo de trabajo que solicite a un modelo de Vertex AI (Gemini Pro Vision) que describa una imagen que está disponible de forma pública a través de Cloud Storage. Para obtener más información, consulta Haz públicos los datos.
Implementa y ejecuta un flujo de trabajo que recorra en bucle una lista de países en paralelo y que solicite a un modelo de Vertex AI (Gemini Pro) que genere y muestre las historias de los países. El uso de ramas paralelas te permite reducir el tiempo total de ejecución iniciando las llamadas al LLM al mismo tiempo y esperando a que todas se completen antes de combinar los resultados. Para obtener más información, consulta Ejecuta pasos del flujo de trabajo en paralelo.
Implementa un flujo de trabajo similar al anterior; sin embargo, solicita un modelo de Vertex AI (PaLM 2 para texto) que genere y muestre las historias de los países. Para obtener más información sobre cómo elegir un modelo, consulta Información del modelo.
Implementa un flujo de trabajo que pueda resumir un documento grande. Debido a que hay un límite en la ventana de contexto que establece qué tan lejos se ve el modelo durante el entrenamiento (y para las previsiones), el flujo de trabajo divide el documento en partes más pequeñas y, luego, le indica a un modelo de Vertex AI (Gemini Pro) que resuma cada parte en paralelo. Para obtener más información, consulta Mensajes de resumen y Horizonte de previsión, ventana de contexto y ventana de previsión.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

Antes de probar los ejemplos de este instructivo, asegúrate de haber completado lo siguiente.

Console

Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

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

Go to project selector

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

Habilita las API de Vertex AI and Workflows.

Habilita las API

Create a service account:

In the Google Cloud console, go to the Create service account page.
Go to Create service account
Select your project.
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.
Click Create and continue.
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. In production environments, do not grant the Owner, Editor, or Viewer roles. Instead, grant a predefined role or custom role that meets your needs.
Click Continue.
Click Done to finish creating the service account.

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

Go to project selector

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

Habilita las API de Vertex AI and Workflows.

Habilita las API

Create a service account:

In the Google Cloud console, go to the Create service account page.
Go to Create service account
Select your project.
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.
Click Create and continue.
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. In production environments, do not grant the Owner, Editor, or Viewer roles. Instead, grant a predefined role or custom role that meets your needs.
Click Continue.
Click Done to finish creating the service account.

gcloud

Instala Google Cloud CLI.

Para inicializar la CLI de gcloud, ejecuta el siguiente comando:

gcloud init

Create or select a Google Cloud 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.

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

Habilita las APIs de Vertex AI and Workflows:

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

Set up authentication:

Create the service account:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
Replace SERVICE_ACCOUNT_NAME with a name for the service account.
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. In production environments, do not grant the Owner, Editor, or Viewer roles. Instead, grant a predefined role or custom role that meets your needs.

Instala Google Cloud CLI.

Para inicializar la CLI de gcloud, ejecuta el siguiente comando:

gcloud init

Create or select a Google Cloud 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.

Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

Habilita las APIs de Vertex AI and Workflows:

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

Set up authentication:

Create the service account:
```
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
```
Replace SERVICE_ACCOUNT_NAME with a name for the service account.
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. In production environments, do not grant the Owner, Editor, or Viewer roles. Instead, grant a predefined role or custom role that meets your needs.

Implementa un flujo de trabajo que describa una imagen (Gemini Pro Vision)

Implementa un flujo de trabajo que use un método conector (generateContent) para realizar una solicitud a un extremo del publicador de Gemini Pro Vision. El método proporciona compatibilidad para la generación de contenido con entradas multimodales.

El flujo de trabajo proporciona una instrucción de texto y el URI de una imagen que está disponible de forma pública en un bucket de Cloud Storage. Puedes ver la imagen y, en la consola de Google Cloud, puedes ver los detalles del objeto.

El flujo de trabajo muestra una descripción de la imagen a partir de la respuesta generada del modelo.

Para obtener más información sobre los parámetros del cuerpo de la solicitud HTTP que se usan cuando se solicita al LLM y los elementos del cuerpo de respuesta, consulta la referencia de la API de Gemini.

Console

En la consola de Google Cloud, ve a la página Flujos de trabajo.

Ir a Workflows
Haz clic en Crear.
Ingresa un nombre para el flujo de trabajo nuevo: describe-image.
En la lista Región, selecciona us-central1 (Iowa).
Para la Cuenta de servicio, selecciona la cuenta de servicio que creaste antes.
Haz clic en Siguiente.

En el editor de flujos de trabajo, ingresa la siguiente definición para tu flujo de trabajo:

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}

Haz clic en Implementar.

gcloud

Crea un archivo de código fuente para tu flujo de trabajo:
```
touch describe-image.yaml
```

En un editor de texto, copia el siguiente flujo de trabajo en tu archivo de código fuente:

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}

Para implementar el flujo de trabajo, ingresa el siguiente comando:

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

Ejecuta el flujo de trabajo

Cuando se ejecuta un flujo de trabajo, se ejecuta la definición del flujo de trabajo actual asociada con este.

Console

En la consola de Google Cloud, ve a la página Flujos de trabajo.

Ir a Workflows
En la página Flujos de trabajo, selecciona el flujo de trabajo describe-image para ir a la página de detalles.
En la página Detalles del flujo de trabajo, haz clic en Ejecutar.

En Input, ingresa lo siguiente:

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

Haz clic de nuevo en Ejecutar.

Observa los resultados del flujo de trabajo en el panel Output.

El resultado debería ser similar al siguiente ejemplo:

{
  "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

Abre una terminal.

Ejecuta el flujo de trabajo:

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

Los resultados de la ejecución deberían ser similares a los siguientes:

  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

Implementa un flujo de trabajo que genere historiales de países (Gemini Pro)

Implementa un flujo de trabajo que recorra en bucle una lista de entrada de países en parallel y use un método conector (generateContent) para realizar una solicitud a un extremo de publicador de Gemini Pro. El método proporciona compatibilidad para la generación de contenido con entradas multimodales.

El flujo de trabajo muestra los historiales de países que generó el modelo y los combina en un mapa.

Console

En la consola de Google Cloud, ve a la página Flujos de trabajo.

Ir a Workflows
Haz clic en Crear.
Ingresa un nombre para el flujo de trabajo nuevo: gemini-pro-country-histories.
En la lista Región, selecciona us-central1 (Iowa).
Para la Cuenta de servicio, selecciona la cuenta de servicio que creaste antes.
Haz clic en Siguiente.

En el editor de flujos de trabajo, ingresa la siguiente definición para tu flujo de trabajo:

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}

Haz clic en Implementar.

gcloud

Crea un archivo de código fuente para tu flujo de trabajo:
```
touch gemini-pro-country-histories.yaml
```

En un editor de texto, copia el siguiente flujo de trabajo en tu archivo de código fuente:

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}

Para implementar el flujo de trabajo, ingresa el siguiente 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

Ejecuta el flujo de trabajo

Cuando se ejecuta un flujo de trabajo, se ejecuta la definición del flujo de trabajo actual asociada con este.

Console

En la consola de Google Cloud, ve a la página Flujos de trabajo.

Ir a Workflows
En la página Flujos de trabajo, selecciona el flujo de trabajo gemini-pro-country-histories para ir a su página de detalles.
En la página Detalles del flujo de trabajo, haz clic en Ejecutar.

En Input, ingresa lo siguiente:

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

Haz clic de nuevo en Ejecutar.

Observa los resultados del flujo de trabajo en el panel Output.

El resultado debería ser similar al siguiente ejemplo:

{
  "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

Abre una terminal.

Ejecuta el flujo de trabajo:

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

Los resultados de la ejecución deberían ser similares a los siguientes:

  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

Implementa un flujo de trabajo que genere historiales de países (PaLM 2 para textos).

Es posible que no quieras usar Gemini Pro como modelo. En el siguiente ejemplo, se usa un flujo de trabajo similar al anterior. Sin embargo, se usa un método conector (predict) para realizar una solicitud a PaLM 2 para el extremo del publicador de texto. El método realiza una predicción en línea.

Para obtener más información sobre los parámetros del cuerpo de la solicitud HTTP que se usan cuando se solicita al LLM y los elementos del cuerpo de la respuesta, consulta la referencia de la API de PaLM 2 para texto.

Console

En la consola de Google Cloud, ve a la página Flujos de trabajo.

Ir a Workflows
Haz clic en Crear.
Ingresa un nombre para el flujo de trabajo nuevo: text-bison-country-histories.
En la lista Región, selecciona us-central1 (Iowa).
Para la Cuenta de servicio, selecciona la cuenta de servicio que creaste antes.
Haz clic en Siguiente.

En el editor de flujos de trabajo, ingresa la siguiente definición para tu flujo de trabajo:

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}

Ten en cuenta que, según el modelo que se use, es posible que debas quitar cualquier espacio en blanco innecesario de la respuesta.

Haz clic en Implementar.

gcloud

Crea un archivo de código fuente para tu flujo de trabajo:
```
touch text-bison-country-histories.yaml
```

En un editor de texto, copia el siguiente flujo de trabajo en tu archivo de código fuente:

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}

Ten en cuenta que, según el modelo que se use, es posible que debas quitar cualquier espacio en blanco innecesario de la respuesta.

Para implementar el flujo de trabajo, ingresa el siguiente 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

Implementa un flujo de trabajo que resuma un documento grande (Gemini Pro)

Implementa un flujo de trabajo que divida un documento grande en partes más pequeñas y realice solicitudes http.post a un extremo del publicador de Gemini Pro en parallel para que el modelo pueda resumir cada parte de forma simultánea. Finalmente, el flujo de trabajo combina todos los resúmenes parciales en uno completo.

La definición del flujo de trabajo supone que creaste un bucket de Cloud Storage al que puedes subir un archivo de texto. Si deseas obtener más información sobre el conector de Workflows (googleapis.storage.v1.objects.get) que se usa para recuperar objetos del bucket de Cloud Storage, consulta la Referencia de conectores.

Después de implementar el flujo de trabajo, puedes ejecutarlo. Para ello, crea un activador de Eventarc adecuado y, luego, sube un archivo al bucket. Para obtener más información, consulta Enruta eventos de Cloud Storage a flujos de trabajo. Ten en cuenta que se deben habilitar las APIs adicionales y se deben otorgar roles adicionales, como otorgar a tu cuenta de servicio la función de Usuario de objetos de Storage (roles/storage.objectUser) que admite el uso de objetos de Cloud Storage. Si deseas obtener más información, consulta la sección Prepárate para crear un activador.

Console

En la consola de Google Cloud, ve a la página Flujos de trabajo.

Ir a Workflows
Haz clic en Crear.
Ingresa un nombre para el flujo de trabajo nuevo: gemini-pro-summaries.
En la lista Región, selecciona us-central1 (Iowa).
Para la Cuenta de servicio, selecciona la cuenta de servicio que creaste antes.
Haz clic en Siguiente.

En el editor de flujos de trabajo, ingresa la siguiente definición para tu flujo de trabajo:

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}

Haz clic en Implementar.

gcloud

Crea un archivo de código fuente para tu flujo de trabajo:
```
touch gemini-pro-summaries.yaml
```

En un editor de texto, copia el siguiente flujo de trabajo en tu archivo de código fuente:

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}

Para implementar el flujo de trabajo, ingresa el siguiente 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

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

Console

Precaución: Borrar un proyecto tiene estas consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

En la consola de Google Cloud, ve a la página Administrar recursos.
Ir a Administrar recursos
En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

gcloud

Precaución: Borrar un proyecto tiene estas consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

Borra un proyecto de Google Cloud:

gcloud projects delete PROJECT_ID

Borra los recursos individuales

Borra los flujos de trabajo que creaste en este instructivo.

¿Qué sigue?

Obtén más información sobre los conectores de flujos de trabajo.
Obtén más información sobre el método generateContent de Vertex AI.
Obtén más información sobre el método predict de Vertex AI.