1. Introdução
Última atualização:27/11/2023
O que é IA generativa?
IA generativa ou inteligência artificial generativa se refere ao uso de IA para criar novos conteúdos, como texto, imagens, música, áudio e vídeos.
Ela usa modelos de fundação (modelos de IA grandes) capazes de realizar várias tarefas ao mesmo tempo, além de resumos, perguntas e respostas, classificações e muito mais. Além disso, com o mínimo de treinamento necessário, os modelos de fundação podem ser adaptados para casos de uso específicos com poucos dados de exemplo.
Como funciona a IA generativa?
A IA generativa usa um modelo de ML (machine learning) para aprender os padrões e as relações em um conjunto de dados de conteúdo criado por humanos. Em seguida, ela usa os padrões aprendidos para gerar novo conteúdo.
A maneira mais comum de treinar um modelo de IA generativa é usar o aprendizado supervisionado, que recebe um conjunto de conteúdo criado por humanos e rótulos correspondentes. Em seguida, ele aprende a gerar conteúdo semelhante ao criado por humanos e rotulado com os mesmos rótulos.
Quais são as aplicações comuns da IA generativa?
A IA generativa processa um vasto conteúdo, criando insights e respostas por meio de texto, imagens e formatos amigáveis. A IA generativa pode ser usada para:
- Melhore as interações com os clientes usando experiências aprimoradas de chat e pesquisa
- Explore grandes quantidades de dados não estruturados usando interfaces de conversa e resumos
- Ajude com tarefas repetitivas, como responder a pedidos de propostas (RFPs), localizar conteúdo de marketing para cinco idiomas, verificar compliance de contratos com clientes e muito mais
Quais ofertas de IA generativa o Google Cloud tem?
Com a Vertex AI, é possível interagir, personalizar e incorporar modelos de fundação nos seus aplicativos com pouca ou nenhuma experiência em ML. Acesse modelos de fundação no Model Garden, ajuste modelos com uma interface simples no Generative AI Studio ou use modelos em um notebook de ciência de dados.
O Vertex AI para Pesquisa e Conversação oferece aos desenvolvedores a maneira mais rápida de criar mecanismos de pesquisa e chatbots com tecnologia de IA generativa.
Além disso, a Duet AI é uma colaboradora com tecnologia de IA disponível no Google Cloud e em ambientes de desenvolvimento integrado para ajudar você a fazer mais em menos tempo.
Qual é o foco deste codelab?
Este codelab se concentra no modelo de linguagem grande (LLM) do PaLM 2, hospedado na Vertex AI do Google Cloud, que abrange todos os produtos e serviços de machine learning.
Você vai usar o Java para interagir com a API PaLM, junto com o orquestrador do framework de LLM LangChain4J. Você vai ver diferentes exemplos concretos para usar o LLM para responder perguntas, gerar ideias, extrair conteúdo estruturado e de entidades e fazer resumos.
Fale mais sobre o framework do LangChain4J.
O framework LangChain4J é uma biblioteca de código aberto para integrar modelos de linguagem grandes nos seus aplicativos Java, orquestrando vários componentes, como o próprio LLM, além de outras ferramentas, como bancos de dados vetoriais (para pesquisas semânticas), carregadores de documentos e divisores (para analisar documentos e aprender com eles), analisadores de saída e muito mais.
O que você vai aprender
- Como configurar um projeto Java para usar PaLM e LangChain4J.
- Como fazer a primeira chamada ao modelo de texto do PaLM para gerar conteúdo e responder a perguntas
- Como extrair informações úteis de conteúdo não estruturado (extração de entidade ou palavra-chave, saída em JSON)
- Como fazer classificação de conteúdo ou análise de sentimento com poucas cenas de comandos
O que é necessário
- Conhecimento da linguagem de programação Java.
- um projeto do Google Cloud;
- Um navegador, como o Chrome ou o Firefox
2. Configuração e requisitos
Configuração de ambiente autoguiada
- Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.
- O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google e pode ser atualizada quando você quiser.
- O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como
PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto. - Para sua informação, há um terceiro valor, um Número do projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.
- Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não vai ser muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou exclua o projeto. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.
Inicie o Cloud Shell
Embora o Google Cloud possa ser operado remotamente em um laptop, neste codelab você vai usar o Cloud Shell, um ambiente de linha de comando executado no Cloud.
Ativar o Cloud Shell
- No Console do Cloud, clique em Ativar o Cloud Shell
.
Se você estiver iniciando o Cloud Shell pela primeira vez, verá uma tela intermediária com a descrição dele. Se aparecer uma tela intermediária, clique em Continuar.
Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.
Essa máquina virtual tem todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Grande parte do trabalho neste codelab, se não todo, pode ser feito em um navegador.
Depois de se conectar ao Cloud Shell, você verá sua autenticação e o projeto estará configurado com o ID do seu projeto.
- Execute o seguinte comando no Cloud Shell para confirmar se a conta está autenticada:
gcloud auth list
Resposta ao comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Execute o seguinte comando no Cloud Shell para confirmar que o comando gcloud sabe sobre seu projeto:
gcloud config list project
Resposta ao comando
[core] project = <PROJECT_ID>
Se o projeto não estiver configurado, configure-o usando este comando:
gcloud config set project <PROJECT_ID>
Resposta ao comando
Updated property [core/project].
3. Como preparar seu ambiente para desenvolvedores
Neste codelab, você vai usar o terminal do Cloud Shell e o editor de código para desenvolver programas em Java.
Ativar as APIs Vertex AI
- No console do Google Cloud, verifique se o nome do projeto é exibido na parte de cima do console do Google Cloud. Se não for, clique em Selecionar um projeto para abrir o Seletor de projetos e escolha o que você quer.
- Se você não estiver na parte da Vertex AI do console do Google Cloud, faça o seguinte:
- Em Pesquisa, digite Vertex AI e retorne
- Nos resultados da pesquisa, clique em Vertex AI. O painel da Vertex AI vai aparecer.
- Clique em Ativar todas as APIs recomendadas no painel da Vertex AI.
Isso vai ativar várias APIs, mas a mais importante para este codelab é a aiplatform.googleapis.com, que também pode ser ativada na linha de comando, no terminal do Cloud Shell, executando o seguinte comando:
$ gcloud services enable aiplatform.googleapis.com
Como criar a estrutura do projeto com o Gradle
Para criar seus exemplos de código Java, você vai usar a ferramenta de build Gradle e a versão 17 do Java. Para configurar seu projeto com o Gradle, no terminal do Cloud Shell, crie um diretório (aqui, palm-workshop) e execute o comando gradle init nesse diretório:
$ 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
Você vai criar um application (opção 2), usando a linguagem Java (opção 3), sem usar subprojetos (opção 1), usando a sintaxe Groovy para o arquivo de build (opção 1), não usar novos recursos de build (opção 1), gerar testes com JUnit Jupiter (opção 4) e, para o nome do projeto, usar palm-workshopm. Da mesma forma, use palm-workshop. Da mesma forma, use palm-workshop.
A estrutura do projeto será semelhante a esta:
├── gradle
│ └── ...
├── gradlew
├── gradlew.bat
├── settings.gradle
└── app
├── build.gradle
└── src
├── main
│ └── java
│ └── palm
│ └── workshop
│ └── App.java
└── test
└── ...
Vamos atualizar o arquivo app/build.gradle para adicionar algumas dependências necessárias. Você pode remover a dependência guava, se ela estiver presente, e substituí-la pelas dependências do projeto LangChain4J e a biblioteca de geração de registros para evitar mensagens de logger ausentes:
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'
}
Há duas dependências para o LangChain4J:
- um no projeto principal,
- e outra para o módulo dedicado da Vertex AI.
Se quiser usar o Java 17 para compilar e executar nossos programas, adicione o seguinte bloco abaixo do bloco plugins {}:
java {
toolchain {
languageVersion = JavaLanguageVersion.of(17)
}
}
Mais uma mudança a ser feita: atualize o bloco application de app/build.gradle para permitir que os usuários substituam a classe principal a ser executada na linha de comando ao invocar a ferramenta de build:
application {
mainClass = providers.systemProperty('javaMainClass')
.orElse('palm.workshop.App')
}
Para verificar se o arquivo de build está pronto para executar seu aplicativo, execute a classe principal padrão, que mostra uma mensagem Hello World! simples:
$ ./gradlew run -DjavaMainClass=palm.workshop.App > Task :app:run Hello World! BUILD SUCCESSFUL in 3s 2 actionable tasks: 2 executed
Agora você já pode programar com o modelo de texto de linguagem grande do PaLM usando o projeto LangChain4J.
Para referência, o arquivo de build app/build.gradle completo vai ficar assim:
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. Fazer sua primeira chamada para o modelo de texto do PaLM
Agora que o projeto está configurado corretamente, é hora de chamar a API PaLM.
Crie uma nova classe com o nome TextPrompts.java no diretório app/src/main/java/palm/workshop (ao lado da classe App.java padrão) e digite o seguinte conteúdo:
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());
}
}
Neste primeiro exemplo, você precisa importar a classe Response e o modelo de linguagem da Vertex AI para o PaLM.
Em seguida, no método main, você vai configurar o modelo de linguagem usando o builder do VertexAiLanguageModel para especificar:
- o endpoint,
- o projeto,
- da região,
- o editor,
- e o nome do modelo (
text-bison@001).
Agora que o modelo de linguagem está pronto, é possível chamar o método generate() e transmitir seu "comando" Ou seja, sua pergunta ou instruções para enviar ao LLM. Aqui, você faz uma pergunta simples sobre o que são LLMs. Mas fique à vontade para mudar essa instrução para tentar outras perguntas ou tarefas.
Para executar essa classe, execute o seguinte comando no terminal do Cloud Shell:
./gradlew run -DjavaMainClass=palm.workshop.TextPrompts
O resultado deve ser parecido com este:
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.
O builder VertexAILanguageModel permite definir parâmetros opcionais que já têm alguns valores padrão que você pode substituir. Veja alguns exemplos:
.temperature(0.2): para definir o nível de criatividade que você quer que a resposta seja. Zero significa que ela é baixa e muitas vezes mais factual, enquanto 1 é para resultados mais criativos..maxOutputTokens(50): no exemplo, 500 tokens foram solicitados (três tokens são aproximadamente equivalentes a quatro palavras), dependendo de quanto tempo você quer que a resposta gerada seja..topK(20): para selecionar aleatoriamente uma palavra de um número máximo de palavras prováveis para o preenchimento do texto (de 1 a 40).topP(0.95): para selecionar as palavras possíveis cuja probabilidade total se soma ao número de ponto flutuante (entre 0 e 1).maxRetries(3): caso a cota esteja ultrapassada de solicitação por tempo, o modelo poderá repetir a chamada três vezes, por exemplo.
Modelos de linguagem grandes são muito poderosos e podem fornecer respostas para perguntas complexas, além de lidar com uma grande variedade de tarefas interessantes. Na próxima seção, vamos conhecer uma tarefa útil: extrair dados estruturados do texto.
5. Extração de informações de texto não estruturado
Na seção anterior, você gerou uma saída de texto. Isso não é um problema se você quer mostrar essa saída diretamente para os usuários finais. Mas se você quiser recuperar os dados mencionados nesta saída, como extraí-las do texto não estruturado?
Digamos que você queira extrair o nome e a idade de uma pessoa com base na biografia ou descrição dela. Você pode instruir o modelo de linguagem grande a gerar estruturas de dados JSON ajustando o comando da seguinte maneira (geralmente chamado de "engenharia de comando"):
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:
Modifique a chamada model.generate() na classe TextPrompts para transmitir todo o comando de texto acima:
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:
"""
);
Se você executar esse comando na nossa classe TextPrompts, ele retornará a seguinte string JSON, que pode ser analisada com um analisador JSON como a 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
Sim. Ana tem 23 anos!
6. Modelos de comandos e comandos estruturados
Além de responder a perguntas
Modelos de linguagem grandes como o PaLM são poderosos para responder a perguntas, mas podem ser usados para muitas outras tarefas. Por exemplo, tente usar os comandos a seguir no Generative AI Studio (ou modificando a classe TextPrompts). Mude as palavras em maiúsculas com suas próprias ideias e examine o resultado:
- Tradução — "Traduza a seguinte frase em francês: YOUR_SENTENCE_HERE"
- Resumo: "Forneça um resumo do seguinte documento: PASTE_YOUR_DOC"
- Geração de criativos: "Escreva um poema sobre TOPIC_OF_THE_POEM"
- Programação — "Como escrever uma função Fibonacci em PROGRAMMING_LANGUAGE?"
Modelos de comando
Se você testou as instruções acima para tarefas de tradução, resumo, geração de criativos ou programação, substituiu os valores dos marcadores por suas próprias ideias. Mas, em vez de fazer algumas manglings de string, você também pode usar os "modelos de comando", que permitem definir esses valores de marcador e preencher a lacuna com seus dados.
Vamos dar uma olhada em uma instrução deliciosa e criativa, substituindo todo o conteúdo do método main() pelo seguinte código:
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());
Adicione estas importações:
import dev.langchain4j.model.input.Prompt;
import dev.langchain4j.model.input.PromptTemplate;
import java.util.HashMap;
import java.util.Map;
Em seguida, execute o aplicativo novamente. A saída será semelhante a esta:
$ ./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.
Delicioso!
Com os modelos de comandos, é possível alimentar os parâmetros necessários antes de chamar o método de geração de texto. Essa é uma ótima maneira de transmitir dados e personalizar comandos para valores diferentes fornecidos pelos usuários.
Como o nome da classe sugere, a classe PromptTemplate cria um comando de modelo, e você pode atribuir valores aos elementos de marcador aplicando um mapa de nomes e valores de marcadores de posição.
Comandos estruturados (OPCIONAL)
Outra maneira de estruturar seus comandos é com a anotação @StructuredPrompt, se você quiser usar uma abordagem orientada a objetos mais avançada. Você adiciona essa anotação a uma classe, e os campos dela correspondem aos marcadores de posição definidos no comando. Vamos ver isso na prática.
Primeiro, precisamos de algumas novas importações:
import java.util.Arrays;
import java.util.List;
import dev.langchain4j.model.input.structured.StructuredPrompt;
import dev.langchain4j.model.input.structured.StructuredPromptProcessor;
Em seguida, podemos criar uma classe estática interna na classe TextPrompts, que coleta os dados necessários para transmitir os marcadores de posição no comando descrito na anotação @StructuredPrompt:
@StructuredPrompt("Create a recipe of a {{dish}} that can be prepared using only {{ingredients}}")
static class RecipeCreationPrompt {
String dish;
List<String> ingredients;
}
Em seguida, instancie essa nova classe e alimente o prato e os ingredientes da nossa receita. Crie e transmita o comando para o 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);
Em vez de preencher as lacunas com um mapa, use um objeto Java com campos que podem ser preenchidos automaticamente pelo ambiente de desenvolvimento integrado, de uma maneira com mais segurança de tipo.
Confira o código completo caso você queira colar mais facilmente essas mudanças na classe 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. classificar textos e analisar sentimentos
Assim como na seção anterior, você vai descobrir outra técnica de engenharia de comando para fazer o modelo PaLM classificar texto ou analisar sentimentos. Vamos falar sobre comandos few-shot. É uma forma de aprimorar seus comandos com alguns exemplos que ajudam a direcionar o modelo de linguagem na direção desejada para entender melhor sua intenção.
Vamos reformular a classe TextPrompts para aproveitar os modelos de comando:
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());
}
}
Observe a abordagem que inclui alguns exemplos de entradas e saídas no comando. Essas são as "poucas jogadas" que ajudam o LLM a seguir a mesma estrutura. Quando o modelo receber uma entrada, ele vai querer retornar uma saída que corresponda ao padrão de entrada/saída.
A execução do programa retornará apenas a palavra POSITIVE, porque morangos também são uma delícia.
$ ./gradlew run -DjavaMainClass=palm.workshop.TextPrompts
> Task :app:run
POSITIVE
A análise de sentimento também é um cenário de classificação de conteúdo. É possível usar a mesma abordagem de comandos few-shot para categorizar documentos diferentes em buckets de categoria diferentes.
8. Parabéns
Parabéns, você criou seu primeiro aplicativo de IA generativa em Java usando o LangChain4J e a API PaLM. Você descobriu ao longo do caminho que modelos de linguagem grandes são muito poderosos e capazes de lidar com várias tarefas, como perguntas/respostas, extração de dados, resumo, classificação de texto, análise de sentimento e muito mais.
Qual é a próxima etapa?
Confira alguns dos codelabs abaixo para saber mais sobre o PaLM em Java:
Leia mais
- Casos de uso comuns da IA generativa
- Recursos de treinamento sobre IA generativa
- Interagir com o PaLM usando o Generative AI Studio
- IA responsável