1. Introducción
Última actualización: 27/11/2023
¿Qué es la IA generativa?
La IA generativa o inteligencia artificial generativa hace referencia al uso de la IA para crear contenido nuevo, como texto, imágenes, música, audio y videos.
La IA generativa usa modelos de base (modelos de IA grandes) que pueden realizar varias tareas a la vez y de manera predeterminada, como resúmenes, preguntas y respuestas, clasificación y mucho más. Además, con el entrenamiento mínimo necesario, los modelos de base se pueden adaptar a casos de uso segmentados con muy pocos ejemplos de datos.
¿Cómo funciona la IA generativa?
La IA generativa usa un modelo de AA (aprendizaje automático) para aprender los patrones y las relaciones en un conjunto de datos de contenido creado por humanos. Luego, usa los patrones aprendidos para generar contenido nuevo.
La forma más común de entrenar un modelo generativo de IA es usar el aprendizaje supervisado, en el que el modelo recibe un conjunto de contenido creado por humanos y las etiquetas correspondientes. Luego, aprende a generar contenido similar al creado por humanos y etiquetado con las mismas etiquetas.
¿Cuáles son las aplicaciones comunes de la IA generativa?
La IA generativa procesa mucho contenido, lo que crea estadísticas y respuestas a través de texto, imágenes y formatos fáciles de usar. Estos son algunos usos de la IA generativa:
- Mejorar las interacciones con los clientes a través de experiencias de chat y búsqueda mejoradas
- Explorar grandes cantidades de datos no estructurados a través de interfaces y resúmenes coloquiales
- Ayudar con tareas repetitivas, como responder solicitudes de propuestas (RFP), localizar contenido de marketing en cinco idiomas y verificar los contratos de los clientes para garantizar el cumplimiento, entre otras
¿Qué ofertas de IA generativa tiene Google Cloud?
Con Vertex AI, puedes interactuar con modelos de base, incorporarlos y personalizarlos en tus aplicaciones sin necesidad de tener experiencia en AA. Accede a los modelos base en Model Garden, ajústalos mediante una IU simple en Generative AI Studio o usa modelos en un notebook de ciencia de datos.
Vertex AI Search and Conversation ofrece a los desarrolladores la forma más rápida de compilar motores de búsqueda y chatbots con tecnología de IA generativa.
Además, Duet AI es tu colaborador potenciado por IA disponible en IDE y Google Cloud para ayudarte a realizar más tareas con mayor rapidez.
¿En qué se enfoca este codelab?
En este codelab, nos enfocaremos en el modelo de lenguaje grande (LLM) PaLM 2, alojado en Vertex AI de Google Cloud, que abarca todos los productos y servicios de aprendizaje automático.
Usarás Java para interactuar con la API de PaLM, junto con el orquestador del framework de LLM LangChain4J. Verás diferentes ejemplos concretos para aprovechar el LLM en la respuesta de preguntas, la generación de ideas, la extracción de entidades y contenido estructurado, y la generación de resúmenes.
Más información sobre el framework de LangChain4j
El framework LangChain4J es una biblioteca de código abierto para integrar modelos de lenguaje grandes en tus aplicaciones de Java, ya que organiza varios componentes, como el LLM en sí, pero también otras herramientas, como bases de datos vectoriales (para búsquedas semánticas), cargadores y divisores de documentos (para analizar documentos y aprender de ellos), analizadores de resultados y mucho más.
Qué aprenderás
- Cómo configurar un proyecto de Java para usar PaLM y LangChain4j
- Cómo realizar tu primera llamada al modelo de texto de PaLM para generar contenido y responder preguntas
- Cómo extraer información útil de contenido no estructurado (extracción de entidades o palabras clave, salida en JSON)
- Cómo realizar la clasificación de contenido o el análisis de opiniones con instrucciones con pocos ejemplos
Requisitos
- Conocimiento del lenguaje de programación Java
- Un proyecto de Google Cloud
- Un navegador, como Chrome o Firefox
2. Configuración y requisitos
Configuración del entorno de autoaprendizaje
- Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.
- El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla cuando quieras.
- El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID de tu proyecto (suele identificarse como
PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usa el mismo durante todo el proyecto. - Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.
- A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no costará mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de $300.
Inicia Cloud Shell
Si bien Google Cloud se puede operar de manera remota desde tu laptop, en este codelab usarás Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.
Activar Cloud Shell
- En la consola de Cloud, haz clic en Activar Cloud Shell
.
Si es la primera vez que inicias Cloud Shell, aparecerá una pantalla intermedia en la que se describirá qué es. Si apareció una pantalla intermedia, haz clic en Continuar.
El aprovisionamiento y la conexión a Cloud Shell solo tomará unos minutos.
Esta máquina virtual está cargada con todas las herramientas de desarrollo necesarias. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Gran parte de tu trabajo en este codelab, si no todo, se puede hacer con un navegador.
Una vez que te conectes a Cloud Shell, deberías ver que te autenticaste y que el proyecto se configuró con tu ID del proyecto.
- En Cloud Shell, ejecuta el siguiente comando para confirmar que tienes la autenticación:
gcloud auth list
Resultado del comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- En Cloud Shell, ejecuta el siguiente comando para confirmar que el comando gcloud conoce tu proyecto:
gcloud config list project
Resultado del comando
[core] project = <PROJECT_ID>
De lo contrario, puedes configurarlo con el siguiente comando:
gcloud config set project <PROJECT_ID>
Resultado del comando
Updated property [core/project].
3. Cómo preparar tu entorno de desarrollo
En este codelab, usarás la terminal y el editor de código de Cloud Shell para desarrollar tus programas en Java.
Habilita las APIs de Vertex AI
- En la consola de Google Cloud, asegúrate de que el nombre del proyecto se muestre en la parte superior de la consola de Google Cloud. Si no es así, haz clic en Selecciona un proyecto para abrir el Selector de proyectos y selecciona el proyecto que desees.
- Si no estás en la parte de Vertex AI de la consola de Google Cloud, haz lo siguiente:
- En Búsqueda, ingresa Vertex AI y, luego, muestra lo siguiente:
- En los resultados de la búsqueda, haz clic en Vertex AI. Aparecerá el panel de Vertex AI.
- Haz clic en Habilitar todas las APIs recomendadas en el panel de Vertex AI.
Esto habilitará varias APIs, pero la más importante para el codelab es aiplatform.googleapis.com, que también puedes habilitar en la línea de comandos, en la terminal de Cloud Shell, con el siguiente comando:
$ gcloud services enable aiplatform.googleapis.com
Cómo crear la estructura del proyecto con Gradle
Para compilar tus ejemplos de código Java, usarás la herramienta de compilación Gradle y la versión 17 de Java. Para configurar tu proyecto con Gradle, en la terminal de Cloud Shell, crea un directorio (aquí, palm-workshop) y ejecuta el comando gradle init en ese directorio:
$ mkdir palm-workshop $ cd palm-workshop $ gradle init Select type of project to generate: 1: basic 2: application 3: library 4: Gradle plugin Enter selection (default: basic) [1..4] 2 Select implementation language: 1: C++ 2: Groovy 3: Java 4: Kotlin 5: Scala 6: Swift Enter selection (default: Java) [1..6] 3 Split functionality across multiple subprojects?: 1: no - only one application project 2: yes - application and library projects Enter selection (default: no - only one application project) [1..2] 1 Select build script DSL: 1: Groovy 2: Kotlin Enter selection (default: Groovy) [1..2] 1 Generate build using new APIs and behavior (some features may change in the next minor release)? (default: no) [yes, no] Select test framework: 1: JUnit 4 2: TestNG 3: Spock 4: JUnit Jupiter Enter selection (default: JUnit Jupiter) [1..4] 4 Project name (default: palm-workshop): Source package (default: palm.workshop): > Task :init Get more help with your project: https://docs.gradle.org/7.4/samples/sample_building_java_applications.html BUILD SUCCESSFUL in 51s 2 actionable tasks: 2 executed
Compilarás una aplicación (opción 2) con el lenguaje Java (opción 3), sin usar subproyectos (opción 1), con la sintaxis de Groovy para el archivo de compilación (opción 1), sin usar nuevas funciones de compilación (opción no), generar pruebas con JUnit Jupiter (opción 4) y, para el nombre del proyecto, puedes usar palm-workshop y, de manera similar, para el paquete fuente, puedes usar palm.workshop.
La estructura del proyecto se verá de la siguiente manera:
├── gradle
│ └── ...
├── gradlew
├── gradlew.bat
├── settings.gradle
└── app
├── build.gradle
└── src
├── main
│ └── java
│ └── palm
│ └── workshop
│ └── App.java
└── test
└── ...
Actualicemos el archivo app/build.gradle para agregar algunas dependencias necesarias. Puedes quitar la dependencia de guava si está presente y reemplazarla por las dependencias del proyecto LangChain4J y la biblioteca de registro para evitar mensajes molestos sobre la falta de un registrador:
dependencies {
// Use JUnit Jupiter for testing.
testImplementation 'org.junit.jupiter:junit-jupiter:5.8.1'
// Logging library
implementation 'org.slf4j:slf4j-jdk14:2.0.9'
// This dependency is used by the application.
implementation 'dev.langchain4j:langchain4j-vertex-ai:0.24.0'
implementation 'dev.langchain4j:langchain4j:0.24.0'
}
LangChain4j tiene 2 dependencias:
- uno en el proyecto principal
- y uno para el módulo dedicado de Vertex AI.
Para usar Java 17 para compilar y ejecutar nuestros programas, agrega el siguiente bloque debajo del bloque plugins {}:
java {
toolchain {
languageVersion = JavaLanguageVersion.of(17)
}
}
Un cambio más que debes realizar: actualiza el bloque application de app/build.gradle para permitir que los usuarios anulen la clase principal que se ejecutará en la línea de comandos cuando se invoque la herramienta de compilación:
application {
mainClass = providers.systemProperty('javaMainClass')
.orElse('palm.workshop.App')
}
Para verificar que tu archivo de compilación esté listo para ejecutar tu aplicación, puedes ejecutar la clase principal predeterminada que imprime un mensaje Hello World! simple:
$ ./gradlew run -DjavaMainClass=palm.workshop.App > Task :app:run Hello World! BUILD SUCCESSFUL in 3s 2 actionable tasks: 2 executed
Ahora puedes programar con el modelo de texto de lenguaje grande de PaLM usando el proyecto LangChain4j.
Como referencia, así debería verse el archivo de compilación app/build.gradle completo ahora:
plugins {
// Apply the application plugin to add support for building a CLI application in Java.
id 'application'
}
java {
toolchain {
// Ensure we compile and run on Java 17
languageVersion = JavaLanguageVersion.of(17)
}
}
repositories {
// Use Maven Central for resolving dependencies.
mavenCentral()
}
dependencies {
// Use JUnit Jupiter for testing.
testImplementation 'org.junit.jupiter:junit-jupiter:5.8.1'
// This dependency is used by the application.
implementation 'dev.langchain4j:langchain4j-vertex-ai:0.24.0'
implementation 'dev.langchain4j:langchain4j:0.24.0'
implementation 'org.slf4j:slf4j-jdk14:2.0.9'
}
application {
mainClass = providers.systemProperty('javaMainClass').orElse('palm.workshop.App')
}
tasks.named('test') {
// Use JUnit Platform for unit tests.
useJUnitPlatform()
}
4. Cómo hacer tu primera llamada al modelo de texto de PaLM
Ahora que el proyecto está configurado correctamente, es momento de llamar a la API de PaLM.
Crea una clase nueva llamada TextPrompts.java en el directorio app/src/main/java/palm/workshop (junto con la clase App.java predeterminada) y escribe el siguiente contenido:
package palm.workshop;
import dev.langchain4j.model.output.Response;
import dev.langchain4j.model.vertexai.VertexAiLanguageModel;
public class TextPrompts {
public static void main(String[] args) {
VertexAiLanguageModel model = VertexAiLanguageModel.builder()
.endpoint("us-central1-aiplatform.googleapis.com:443")
.project("YOUR_PROJECT_ID")
.location("us-central1")
.publisher("google")
.modelName("text-bison@001")
.maxOutputTokens(500)
.build();
Response<String> response = model.generate("What are large language models?");
System.out.println(response.content());
}
}
En este primer ejemplo, debes importar la clase Response y el modelo de lenguaje de Vertex AI para PaLM.
A continuación, en el método main, configurarás el modelo de lenguaje con el compilador de VertexAiLanguageModel para especificar lo siguiente:
- el extremo
- el proyecto,
- la región,
- el publicador,
- y el nombre del modelo (
text-bison@001).
Ahora que el modelo de lenguaje está listo, puedes llamar al método generate() y pasar tu "instrucción" (es decir, tu pregunta o las instrucciones para enviar al LLM). Aquí, haces una pregunta simple sobre qué son los LLM. Sin embargo, puedes cambiar esta instrucción para probar diferentes preguntas o tareas.
Para ejecutar esta clase, ejecuta el siguiente comando en la terminal de Cloud Shell:
./gradlew run -DjavaMainClass=palm.workshop.TextPrompts
Deberías ver un resultado similar al siguiente:
Large language models (LLMs) are artificial intelligence systems that can understand and generate human language. They are trained on massive datasets of text and code, and can learn to perform a wide variety of tasks, such as translating languages, writing different kinds of creative content, and answering your questions in an informative way. LLMs are still under development, but they have the potential to revolutionize many industries. For example, they could be used to create more accurate and personalized customer service experiences, to help doctors diagnose and treat diseases, and to develop new forms of creative expression. However, LLMs also raise a number of ethical concerns. For example, they could be used to create fake news and propaganda, to manipulate people's behavior, and to invade people's privacy. It is important to carefully consider the potential risks and benefits of LLMs before they are widely used. Here are some of the key features of LLMs: * They are trained on massive datasets of text and code. * They can learn to perform a wide variety of tasks, such as translating languages, writing different kinds of creative content, and answering your questions in an informative way. * They are still under development, but they have the potential to revolutionize many industries. * They raise a number of ethical concerns, such as the potential for fake news, propaganda, and invasion of privacy.
El compilador VertexAILanguageModel te permite definir parámetros opcionales que ya tienen algunos valores predeterminados que puedes anular. Estos son algunos ejemplos:
.temperature(0.2): Para definir qué tan creativa quieres que sea la respuesta (0 es poco creativa y, a menudo, más fáctica, mientras que 1 es para resultados más creativos).maxOutputTokens(50): En el ejemplo, se solicitaron 500 tokens (3 tokens equivalen aproximadamente a 4 palabras), según la longitud que desees para la respuesta generada..topK(20): Para seleccionar aleatoriamente una palabra entre una cantidad máxima de palabras probables para la función de completar texto (de 1 a 40).topP(0.95): Para seleccionar las palabras posibles cuya probabilidad total sume ese número de punto flotante (entre 0 y 1).maxRetries(3): En caso de que superes la cuota de solicitudes por período, puedes hacer que el modelo vuelva a intentar la llamada 3 veces, por ejemplo.
Los modelos de lenguaje grandes son muy potentes y pueden proporcionar respuestas a preguntas complejas, además de realizar una gran variedad de tareas interesantes. En la siguiente sección, veremos una tarea útil: extraer datos estructurados del texto.
5. Extracción de información de texto no estructurado
En la sección anterior, generaste algunos resultados de texto. Esto es adecuado si deseas mostrar directamente este resultado a tus usuarios finales. Pero si quieres recuperar los datos que se mencionan en este resultado, ¿cómo extraes esa información del texto no estructurado?
Supongamos que deseas extraer el nombre y la edad de una persona a partir de su biografía o descripción. Puedes indicarle al modelo de lenguaje grande que genere estructuras de datos JSON modificando la instrucción de la siguiente manera (esto se conoce comúnmente como "ingeniería de instrucciones"):
Extract the name and age of the person described below.
Return a JSON document with a "name" and an "age" property,
following this structure: {"name": "John Doe", "age": 34}
Return only JSON, without any markdown markup surrounding it.
Here is the document describing the person:
---
Anna is a 23 year old artist based in Brooklyn, New York. She was
born and raised in the suburbs of Chicago, where she developed a
love for art at a young age. She attended the School of the Art
Institute of Chicago, where she studied painting and drawing.
After graduating, she moved to New York City to pursue her art career.
Anna's work is inspired by her personal experiences and observations
of the world around her. She often uses bright colors and bold lines
to create vibrant and energetic paintings. Her work has been
exhibited in galleries and museums in New York City and Chicago.
---
JSON:
Modifica la llamada a model.generate() en la clase TextPrompts para pasarle todo el mensaje de texto anterior:
Response<String> response = model.generate("""
Extract the name and age of the person described below.
Return a JSON document with a "name" and an "age" property, \
following this structure: {"name": "John Doe", "age": 34}
Return only JSON, without any markdown markup surrounding it.
Here is the document describing the person:
---
Anna is a 23 year old artist based in Brooklyn, New York. She was born and
raised in the suburbs of Chicago, where she developed a love for art at a
young age. She attended the School of the Art Institute of Chicago, where
she studied painting and drawing. After graduating, she moved to New York
City to pursue her art career. Anna's work is inspired by her personal
experiences and observations of the world around her. She often uses bright
colors and bold lines to create vibrant and energetic paintings. Her work
has been exhibited in galleries and museums in New York City and Chicago.
---
JSON:
"""
);
Si ejecutas esta instrucción en nuestra clase TextPrompts, debería devolver la siguiente cadena JSON, que podrías analizar con un analizador JSON como la biblioteca GSON:
$ ./gradlew run -DjavaMainClass=palm.workshop.TextPrompts
> Task :app:run
{"name": "Anna", "age": 23}
BUILD SUCCESSFUL in 24s
2 actionable tasks: 1 executed, 1 up-to-date
Sí. ¡Anna cumple 23 años!
6. Plantillas de instrucciones y estructuradas
Más allá de la búsqueda de respuestas
Los modelos de lenguaje grandes, como PaLM, son potentes para responder preguntas, pero puedes usarlos para muchas más tareas. Por ejemplo, prueba las siguientes instrucciones en Generative AI Studio (o modificando la clase TextPrompts). Cambia las palabras en mayúsculas por tus propias ideas y examina el resultado:
- Traducción: "Traduce la siguiente oración al francés: YOUR_SENTENCE_HERE".
- Resumen: "Proporciona un resumen del siguiente documento: PEGA_TU_DOC"
- Generación creativa: "Escribe un poema sobre TOPIC_OF_THE_POEM".
- Programación: "¿Cómo escribir una función de Fibonacci en PROGRAMMING_LANGUAGE?"
Plantillas de instrucciones
Si probaste las instrucciones anteriores para tareas de traducción, resumen, generación creativa o programación, reemplazaste los valores de marcador de posición por tus propias ideas. Sin embargo, en lugar de manipular cadenas, también puedes aprovechar las "plantillas de instrucciones", que te permiten definir esos valores de marcador de posición y completar los espacios en blanco después con tus datos.
Reemplaza todo el contenido del método main() por el siguiente código para ver un mensaje delicioso y creativo:
VertexAiLanguageModel model = VertexAiLanguageModel.builder()
.endpoint("us-central1-aiplatform.googleapis.com:443")
.project("YOUR_PROJECT_ID")
.location("us-central1")
.publisher("google")
.modelName("text-bison@001")
.maxOutputTokens(300)
.build();
PromptTemplate promptTemplate = PromptTemplate.from("""
Create a recipe for a {{dish}} with the following ingredients: \
{{ingredients}}, and give it a name.
"""
);
Map<String, Object> variables = new HashMap<>();
variables.put("dish", "dessert");
variables.put("ingredients", "strawberries, chocolate, whipped cream");
Prompt prompt = promptTemplate.apply(variables);
Response<String> response = model.generate(prompt);
System.out.println(response.content());
Y agregando las siguientes importaciones:
import dev.langchain4j.model.input.Prompt;
import dev.langchain4j.model.input.PromptTemplate;
import java.util.HashMap;
import java.util.Map;
Luego, vuelve a ejecutar la aplicación. El resultado debería ser similar al siguiente:
$ ./gradlew run -DjavaMainClass=palm.workshop.TextPrompts > Task :app:run **Strawberry Shortcake** Ingredients: * 1 pint strawberries, hulled and sliced * 1/2 cup sugar * 1/4 cup cornstarch * 1/4 cup water * 1 tablespoon lemon juice * 1/2 cup heavy cream, whipped * 1/4 cup confectioners' sugar * 1/4 teaspoon vanilla extract * 6 graham cracker squares, crushed Instructions: 1. In a medium saucepan, combine the strawberries, sugar, cornstarch, water, and lemon juice. Bring to a boil over medium heat, stirring constantly. Reduce heat and simmer for 5 minutes, or until the sauce has thickened. 2. Remove from heat and let cool slightly. 3. In a large bowl, combine the whipped cream, confectioners' sugar, and vanilla extract. Beat until soft peaks form. 4. To assemble the shortcakes, place a graham cracker square on each of 6 dessert plates. Top with a scoop of whipped cream, then a spoonful of strawberry sauce. Repeat layers, ending with a graham cracker square. 5. Serve immediately. **Tips:** * For a more elegant presentation, you can use fresh strawberries instead of sliced strawberries. * If you don't have time to make your own whipped cream, you can use store-bought whipped cream.
¡Deliciosas!
Con las plantillas de instrucciones, puedes proporcionar los parámetros obligatorios antes de llamar al método de generación de texto. Esta es una excelente manera de pasar datos y personalizar mensajes para diferentes valores que proporcionan los usuarios.
Como sugiere el nombre de la clase, la clase PromptTemplate crea una instrucción de plantilla, y puedes asignar valores a los elementos de marcador de posición aplicando un mapa de nombres y valores de marcadores de posición.
Instrucciones estructuradas (OPCIONAL)
Otra forma de estructurar tus instrucciones es con la anotación @StructuredPrompt, si deseas usar un enfoque más enriquecido orientado a objetos. Anota una clase con esta anotación, y sus campos corresponden a los marcadores de posición definidos en la instrucción. Veamos cómo funciona.
Primero, necesitaremos algunas importaciones nuevas:
import java.util.Arrays;
import java.util.List;
import dev.langchain4j.model.input.structured.StructuredPrompt;
import dev.langchain4j.model.input.structured.StructuredPromptProcessor;
Luego, podemos crear una clase estática interna dentro de nuestra clase TextPrompts que recopile los datos necesarios para pasar los marcadores de posición en la instrucción descrita en la anotación @StructuredPrompt:
@StructuredPrompt("Create a recipe of a {{dish}} that can be prepared using only {{ingredients}}")
static class RecipeCreationPrompt {
String dish;
List<String> ingredients;
}
Luego, crea una instancia de esa nueva clase y pásale el plato y los ingredientes de nuestra receta, crea y pasa la instrucción al método generate() como antes:
RecipeCreationPrompt createRecipePrompt = new RecipeCreationPrompt();
createRecipePrompt.dish = "salad";
createRecipePrompt.ingredients = Arrays.asList("cucumber", "tomato", "feta", "onion", "olives");
Prompt prompt = StructuredPromptProcessor.toPrompt(createRecipePrompt);
Response<String> response = model.generate(prompt);
En lugar de completar los espacios a través de un mapa, puedes usar un objeto Java con campos que tu IDE puede autocompletar, de una manera más segura en cuanto a los tipos.
Aquí tienes todo el código si quieres pegar esos cambios con más facilidad en tu clase TextPrompts:
package palm.workshop;
import java.util.Arrays;
import java.util.List;
import dev.langchain4j.model.input.Prompt;
import dev.langchain4j.model.output.Response;
import dev.langchain4j.model.vertexai.VertexAiLanguageModel;
import dev.langchain4j.model.input.structured.StructuredPrompt;
import dev.langchain4j.model.input.structured.StructuredPromptProcessor;
public class TextPrompts {
@StructuredPrompt("Create a recipe of a {{dish}} that can be prepared using only {{ingredients}}")
static class RecipeCreationPrompt {
String dish;
List<String> ingredients;
}
public static void main(String[] args) {
VertexAiLanguageModel model = VertexAiLanguageModel.builder()
.endpoint("us-central1-aiplatform.googleapis.com:443")
.project("YOUR_PROJECT_ID")
.location("us-central1")
.publisher("google")
.modelName("text-bison@001")
.maxOutputTokens(300)
.build();
RecipeCreationPrompt createRecipePrompt = new RecipeCreationPrompt();
createRecipePrompt.dish = "salad";
createRecipePrompt.ingredients = Arrays.asList("cucumber", "tomato", "feta", "onion", "olives");
Prompt prompt = StructuredPromptProcessor.toPrompt(createRecipePrompt);
Response<String> response = model.generate(prompt);
System.out.println(response.content());
}
}
7. Clasificación de texto y análisis de opiniones
De manera similar a lo que aprendiste en la sección anterior, descubrirás otra técnica de "ingeniería de instrucciones" para que el modelo de PaLM clasifique texto o analice opiniones. Hablemos sobre la instrucción con pocos ejemplos". Es una forma de mejorar tus instrucciones con algunos ejemplos que ayudarán a dirigir el modelo de lenguaje en la dirección que deseas, para que comprenda mejor tu intención.
Reelaboremos nuestra clase TextPrompts para aprovechar las plantillas de mensajes:
package palm.workshop;
import java.util.Map;
import dev.langchain4j.model.output.Response;
import dev.langchain4j.model.vertexai.VertexAiLanguageModel;
import dev.langchain4j.model.input.Prompt;
import dev.langchain4j.model.input.PromptTemplate;
public class TextPrompts {
public static void main(String[] args) {
VertexAiLanguageModel model = VertexAiLanguageModel.builder()
.endpoint("us-central1-aiplatform.googleapis.com:443")
.project("YOUR_PROJECT_ID")
.location("us-central1")
.publisher("google")
.modelName("text-bison@001")
.maxOutputTokens(10)
.build();
PromptTemplate promptTemplate = PromptTemplate.from("""
Analyze the sentiment of the text below. Respond only with one word to describe the sentiment.
INPUT: This is fantastic news!
OUTPUT: POSITIVE
INPUT: Pi is roughly equal to 3.14
OUTPUT: NEUTRAL
INPUT: I really disliked the pizza. Who would use pineapples as a pizza topping?
OUTPUT: NEGATIVE
INPUT: {{text}}
OUTPUT:
""");
Prompt prompt = promptTemplate.apply(
Map.of("text", "I love strawberries!"));
Response<String> response = model.generate(prompt);
System.out.println(response.content());
}
}
Observa el enfoque de ofrecer algunos ejemplos de entradas y salidas en la instrucción. Estos son los "pocos ejemplos" que ayudan al LLM a seguir la misma estructura. Cuando el modelo recibe una entrada, querrá devolver una salida que coincida con el patrón de entrada/salida.
Al ejecutar el programa, solo debería mostrarse la palabra POSITIVE, ya que las frutillas también son deliciosas.
$ ./gradlew run -DjavaMainClass=palm.workshop.TextPrompts
> Task :app:run
POSITIVE
El análisis de opiniones también es un caso de clasificación de contenido. Puedes aplicar el mismo enfoque de "indicaciones con pocos ejemplos" para categorizar diferentes documentos en diferentes categorías.
8. Felicitaciones
¡Felicitaciones! Compilaste con éxito tu primera aplicación de IA generativa en Java con LangChain4j y la API de PaLM. En el camino, descubriste que los modelos de lenguaje grandes son bastante potentes y capaces de manejar varias tareas, como preguntas y respuestas, extracción de datos, resumen, clasificación de texto, análisis de opiniones y mucho más.
¿Qué sigue?
Consulta los siguientes codelabs para profundizar en PaLM en Java:
Lecturas adicionales
- Casos de uso comunes de la IA generativa
- Recursos de capacitación sobre IA generativa
- Interactúa con PaLM a través de Generative AI Studio
- IA responsable