Generative AI-Textgenerierung in Java mit PaLM und LangChain4J

1. Einführung

Zuletzt aktualisiert: 27.11.2023

Was ist generative KI?

Bei der generativen KI (der generativen künstlichen Intelligenz) wird KI verwendet, um neue Inhalte wie Text, Bilder, Musik, Audio und Videos zu erstellen.

Die Generative AI basiert auf Fundamentmodellen (große KI-Modelle), die Multitaskingfähig sind und vordefinierte Aufgaben ausführen, darunter Zusammenfassungen, Fragen-/Antworten-Sessions, Klassifizierung und mehr. Außerdem können mit nur minimalem Training Fundamentmodelle an ausgewählte Anwendungsfälle mit sehr wenigen Beispieldaten angepasst werden.

Wie funktioniert generative KI?

Generative KI nutzt ein ML-Modell (Machine Learning), um die Muster und Beziehungen in einem Dataset aus von Menschen erstellten Inhalten zu ermitteln. Anschließend werden anhand der erlernten Muster neue Inhalte generiert.

Die gängigste Methode zum Trainieren eines generativen KI-Modells ist die Verwendung von überwachtem Lernen. Das Modell erhält eine Reihe von Inhalten, die von Menschen erstellt wurden, sowie zugehörige Labels. Anschließend lernt es, Inhalte zu erstellen, die den von Menschen erstellten Inhalten ähneln und mit denselben Labels gekennzeichnet sind.

Was sind gängige Anwendungen für generative KI?

Generative AI verarbeitet umfangreiche Inhalte und stellt über Texte, Bilder und nutzerfreundliche Formate Erkenntnisse und Antworten bereit. Mit generativer KI können Sie:

  • Kundeninteraktionen durch erweiterte Chat- und Suchfunktionen verbessern
  • Über Konversationsschnittstellen und Zusammenfassungen große Mengen unstrukturierter Daten untersuchen
  • Unterstützung bei sich wiederholenden Aufgaben erhalten, wie der Beantwortung von Angebotsanfragen, der Lokalisierung von Marketinginhalten in fünf Sprachen, der Prüfung von Kundenverträgen auf Compliance, etc.

Welche Angebote für generative KI hat Google Cloud?

Mit Vertex AI können Sie Grundmodelle verwenden, anpassen und in Ihre Anwendungen einbetten – ganz ohne ML-Fachwissen. Greifen Sie über Model Garden auf Fundamentmodelle zu, passen Sie die Modelle über eine einfache Benutzeroberfläche in Generative AI Studio an oder verwenden Sie Modelle in einem Data-Science-Notebook.

Vertex AI Search and Conversation bietet Entwicklern die schnellste Möglichkeit, generative KI-gestützte Suchmaschinen und Chatbots zu erstellen.

Duet AI ist ein KI-gestütztes Tool, das in Google Cloud und IDEs genutzt werden kann, um in kürzerer Zeit mehr zu erledigen.

Worum geht es in diesem Codelab?

In diesem Codelab geht es um das Large Language Model (LLM) PaLM 2, das in Google Cloud Vertex AI gehostet wird und alle Produkte und Dienste für maschinelles Lernen umfasst.

Sie verwenden Java, um mit der PaLM API zu interagieren, in Verbindung mit dem LangChain4J LLM-Framework-Orchestrator. Sie sehen sich verschiedene konkrete Beispiele an, um das LLM für die Beantwortung von Fragen, die Ideengenerierung, die Extraktion von Entitäten und strukturierten Inhalten sowie die Zusammenfassung zu nutzen.

Erzähl mir mehr über das LangChain4J-Framework.

Das Framework LangChain4J ist eine Open-Source-Bibliothek zum Einbinden von Large Language Models in Ihre Java-Anwendungen. Dazu werden verschiedene Komponenten wie das LLM selbst, aber auch andere Tools wie Vektordatenbanken (für semantische Suchanfragen), Dokumentlader und ‑splitter (zum Analysieren und Lernen aus Dokumenten) sowie Ausgabeparser orchestriert.

c6d7f7c3fd0d2951.png

Lerninhalte

  • Ein Java-Projekt für die Verwendung von PaLM und LangChain4J einrichten
  • So führen Sie Ihren ersten Aufruf des PaLM-Textmodells aus, um Inhalte zu generieren und Fragen zu beantworten
  • Nützliche Informationen aus unstrukturierten Inhalten extrahieren (Entitäts- oder Keyword-Extraktion, Ausgabe in JSON)
  • Inhaltsklassifizierung oder Sentimentanalyse mit Few-Shot-Prompting durchführen

Voraussetzungen

  • Kenntnisse der Programmiersprache Java
  • Ein Google Cloud-Projekt
  • Ein Browser, z. B. Chrome oder Firefox

2. Einrichtung und Anforderungen

Umgebung zum selbstbestimmten Lernen einrichten

  1. Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.

295004821bab6a87.png

37d264871000675d.png

96d86d3d5655cdbe.png

  • Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es handelt sich um einen String, der nicht von Google APIs verwendet wird. Sie können sie jederzeit aktualisieren.
  • Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich (kann nach dem Festlegen nicht mehr geändert werden). In der Cloud Console wird automatisch ein eindeutiger String generiert. Normalerweise ist es nicht wichtig, wie dieser String aussieht. In den meisten Codelabs müssen Sie auf Ihre Projekt-ID verweisen (in der Regel als PROJECT_ID angegeben). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige ID generieren. Alternativ können Sie es mit einem eigenen Namen versuchen und sehen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen.
  • Zur Information: Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten
  1. Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs zu verwenden. Die Durchführung dieses Codelabs kostet wenig oder gar nichts. Wenn Sie Ressourcen herunterfahren möchten, um Kosten zu vermeiden, die über diese Anleitung hinausgehen, können Sie die erstellten Ressourcen oder das Projekt löschen. Neue Google Cloud-Nutzer können am kostenlosen Testzeitraum mit einem Guthaben von 300$ teilnehmen.

Cloud Shell starten

Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, wird in diesem Codelab Cloud Shell verwendet, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Cloud Shell aktivieren

  1. Klicken Sie in der Cloud Console auf Cloud Shell aktivieren d1264ca30785e435.png.

cb81e7c8e34bc8d.png

Wenn Sie die Cloud Shell zum ersten Mal starten, wird ein Fenster mit einer Beschreibung eingeblendet. Klicken Sie in diesem Fall einfach auf Weiter.

d95252b003979716.png

Das Herstellen der Verbindung mit der Cloud Shell sollte nur wenige Augenblicke dauern.

7833d5e1c5d18f54.png

Auf dieser virtuellen Maschine sind alle erforderlichen Entwicklungstools installiert. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Die meisten, wenn nicht sogar alle Aufgaben in diesem Codelab können mit einem Browser erledigt werden.

Sobald die Verbindung mit der Cloud Shell hergestellt ist, sehen Sie, dass Sie authentifiziert sind und für das Projekt Ihre Projekt-ID eingestellt ist.

  1. Führen Sie in der Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Sie authentifiziert sind:
gcloud auth list

Befehlsausgabe

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`
  1. Führen Sie den folgenden Befehl in Cloud Shell aus, um zu bestätigen, dass der gcloud-Befehl Ihr Projekt kennt:
gcloud config list project

Befehlsausgabe

[core]
project = <PROJECT_ID>

Ist dies nicht der Fall, können Sie die Einstellung mit diesem Befehl vornehmen:

gcloud config set project <PROJECT_ID>

Befehlsausgabe

Updated property [core/project].

3. Entwicklungsumgebung vorbereiten

In diesem Codelab verwenden Sie das Cloud Shell-Terminal und den Code-Editor, um Ihre Java-Programme zu entwickeln.

Vertex AI APIs aktivieren

  1. Prüfen Sie in der Google Cloud Console, ob Ihr Projektname oben in der Google Cloud Console angezeigt wird. Falls nicht, klicken Sie auf Projekt auswählen, um die Projektauswahl zu öffnen, und wählen Sie das gewünschte Projekt aus.
  2. Wenn Sie sich nicht im Bereich „Vertex AI“ der Google Cloud Console befinden, gehen Sie so vor:
  3. Geben Sie unter Suche Vertex AI ein und drücken Sie die Eingabetaste.
  4. Klicken Sie in den Suchergebnissen auf Vertex AI. Das Vertex AI-Dashboard wird angezeigt.
  5. Klicken Sie im Vertex AI-Dashboard auf Alle empfohlenen APIs aktivieren.

Dadurch werden mehrere APIs aktiviert. Die wichtigste für das Codelab ist jedoch die aiplatform.googleapis.com, die Sie auch über die Befehlszeile im Cloud Shell-Terminal mit dem folgenden Befehl aktivieren können:

$ gcloud services enable aiplatform.googleapis.com

Projektstruktur mit Gradle erstellen

Zum Erstellen Ihrer Java-Codebeispiele verwenden Sie das Build-Tool Gradle und Java 17. Wenn Sie Ihr Projekt mit Gradle einrichten möchten, erstellen Sie im Cloud Shell-Terminal ein Verzeichnis (hier palm-workshop) und führen Sie den Befehl gradle init in diesem Verzeichnis aus:

$ 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

Sie erstellen eine Anwendung (Option 2) in der Java-Sprache (Option 3) ohne Unterprojekte (Option 1) mit der Groovy-Syntax für die Build-Datei (Option 1). Sie verwenden keine neuen Build-Funktionen (Option 0) und generieren Tests mit JUnit Jupiter (Option 4). Als Projektname können Sie palm-workshop und als Quellpaket palm.workshop verwenden.

Die Projektstruktur sieht so aus:

├── gradle 
│   └── ...
├── gradlew 
├── gradlew.bat 
├── settings.gradle 
└── app
    ├── build.gradle 
    └── src
        ├── main
        │   └── java 
        │       └── palm
        │           └── workshop
        │               └── App.java
        └── test
            └── ...

Aktualisieren wir die Datei app/build.gradle, um einige erforderliche Abhängigkeiten hinzuzufügen. Sie können die guava-Abhängigkeit entfernen, falls sie vorhanden ist, und durch die Abhängigkeiten für das LangChain4J-Projekt und die Logging-Bibliothek ersetzen, um fehlende Logger-Meldungen zu vermeiden:

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

Es gibt zwei Abhängigkeiten für LangChain4J:

  • eines für das Kernprojekt,
  • und eines für das dedizierte Vertex AI-Modul.

Wenn Sie Java 17 zum Kompilieren und Ausführen Ihrer Programme verwenden möchten, fügen Sie den folgenden Block unter dem Block plugins {} ein:

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

Eine weitere Änderung: Aktualisieren Sie den application-Block von app/build.gradle, damit Nutzer die Hauptklasse überschreiben können, die in der Befehlszeile ausgeführt werden soll, wenn das Build-Tool aufgerufen wird:

application {
    mainClass = providers.systemProperty('javaMainClass')
                         .orElse('palm.workshop.App')
}

Um zu prüfen, ob Ihre Build-Datei bereit ist, Ihre Anwendung auszuführen, können Sie die Standard-Hauptklasse ausführen, die eine einfache Hello World!-Meldung ausgibt:

$ ./gradlew run -DjavaMainClass=palm.workshop.App

> Task :app:run
Hello World!

BUILD SUCCESSFUL in 3s
2 actionable tasks: 2 executed

Jetzt können Sie mit dem PaLM Large Language Text Model programmieren, indem Sie das LangChain4J-Projekt verwenden.

Die vollständige app/build.gradle-Build-Datei sollte jetzt so aussehen:

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. Erster Aufruf des Textmodells von PaLM

Nachdem das Projekt richtig eingerichtet ist, können Sie die PaLM API aufrufen.

Erstellen Sie im Verzeichnis app/src/main/java/palm/workshop (neben der Standardklasse App.java) eine neue Klasse mit dem Namen TextPrompts.java und geben Sie den folgenden Inhalt ein:

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());
    }
}

In diesem ersten Beispiel müssen Sie die Klasse Response und das Vertex AI-Sprachmodell für PaLM importieren.

Als Nächstes konfigurieren Sie in der Methode main das Sprachmodell. Dazu verwenden Sie den Builder für VertexAiLanguageModel, um Folgendes anzugeben:

  • den Endpunkt,
  • das Projekt,
  • die Region,
  • der Verlag,
  • und den Namen des Modells (text-bison@001).

Das Sprachmodell ist nun bereit. Sie können die Methode generate() aufrufen und Ihren „Prompt“ (Ihre Frage oder Anweisungen, die an das LLM gesendet werden sollen) übergeben. Hier stellen Sie eine einfache Frage dazu, was LLMs sind. Sie können diesen Prompt aber auch ändern, um andere Fragen oder Aufgaben auszuprobieren.

Führen Sie zum Ausführen dieser Klasse im Cloud Shell-Terminal den folgenden Befehl aus:

./gradlew run -DjavaMainClass=palm.workshop.TextPrompts

Die Ausgabe sollte in etwa so aussehen:

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.

Mit dem VertexAILanguageModel-Builder können Sie optionale Parameter definieren, für die bereits Standardwerte festgelegt sind, die Sie überschreiben können. Hier einige Beispiele:

  • .temperature(0.2): Damit legen Sie fest, wie kreativ die Antwort sein soll. Bei 0 ist die Kreativität gering und die Antwort ist oft sachlicher, während bei 1 kreativere Ausgaben erzielt werden.
  • .maxOutputTokens(50) – im Beispiel wurden 500 Tokens angefordert (3 Tokens entsprechen etwa 4 Wörtern), je nachdem, wie lang die generierte Antwort sein soll
  • .topK(20): Damit wird ein Wort aus einer maximalen Anzahl wahrscheinlicher Wörter für die Vervollständigung des Texts zufällig ausgewählt (1 bis 40).
  • .topP(0.95) – um die möglichen Wörter auszuwählen, deren Gesamtwahrscheinlichkeit dieser Gleitkommazahl (zwischen 0 und 1) entspricht.
  • .maxRetries(3): Wenn Sie das Kontingent für Anfragen pro Zeit überschreiten, kann das Modell den Aufruf beispielsweise dreimal wiederholen.

Large Language Models sind sehr leistungsstark und können Antworten auf komplexe Fragen liefern und eine Vielzahl interessanter Aufgaben bewältigen. Im nächsten Abschnitt sehen wir uns eine nützliche Aufgabe an: strukturierte Daten aus Text extrahieren.

5. Informationen aus unstrukturiertem Text extrahieren

Im vorherigen Abschnitt haben Sie eine Textausgabe generiert. Das ist in Ordnung, wenn Sie diese Ausgabe direkt Ihren Endnutzern präsentieren möchten. Wenn Sie die in dieser Ausgabe genannten Daten abrufen möchten, wie extrahieren Sie diese Informationen aus dem unstrukturierten Text?

Angenommen, Sie möchten den Namen und das Alter einer Person anhand einer Biografie oder Beschreibung dieser Person extrahieren. Sie können das große Sprachmodell anweisen, JSON-Datenstrukturen zu generieren, indem Sie den Prompt wie folgt anpassen (dies wird häufig als Prompt-Engineering bezeichnet):

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:

Ändern Sie den model.generate()-Aufruf in der TextPrompts-Klasse, um den gesamten Text-Prompt oben zu übergeben:

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: 
    """
);

Wenn Sie diesen Prompt in unserer Klasse TextPrompts ausführen, sollte der folgende JSON-String zurückgegeben werden, den Sie mit einem JSON-Parser wie der GSON-Bibliothek parsen können:

$ ./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

Ja. Anna ist 23 Jahre alt.

6. Prompt-Vorlagen und strukturierte Prompts

Über das Beantworten von Fragen hinaus

Large Language Models wie PaLM eignen sich hervorragend zum Beantworten von Fragen, aber Sie können sie auch für viele andere Aufgaben verwenden. Probieren Sie beispielsweise die folgenden Prompts in Generative AI Studio aus (oder durch Ändern der Klasse TextPrompts). Ersetzen Sie die in Großbuchstaben geschriebenen Wörter durch Ihre eigenen Ideen und sehen Sie sich die Ausgabe an:

  • Übersetzung: „Übersetze den folgenden Satz ins Französische: YOUR_SENTENCE_HERE“
  • Zusammenfassung: „Fasse das folgende Dokument zusammen: PASTE_YOUR_DOC“
  • Creative-Generierung – „Schreibe ein Gedicht über TOPIC_OF_THE_POEM“
  • Programmierung: „Wie schreibe ich eine Fibonacci-Funktion in PROGRAMMING_LANGUAGE?“

Prompt-Vorlagen

Wenn Sie die oben genannten Prompts für Übersetzungs-, Zusammenfassungs-, Creative-Generierungs- oder Programmieraufgaben ausprobiert haben, haben Sie die Platzhalterwerte durch Ihre eigenen Ideen ersetzt. Anstatt Zeichenfolgen zu bearbeiten, können Sie auch Prompt-Vorlagen verwenden, mit denen Sie diese Platzhalterwerte definieren und die Lücken anschließend mit Ihren Daten füllen können.

Sehen wir uns einen ansprechenden und kreativen Prompt an, indem wir den gesamten Inhalt der main()-Methode durch den folgenden Code ersetzen:

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());

Fügen Sie die folgenden Importe hinzu:

import dev.langchain4j.model.input.Prompt;
import dev.langchain4j.model.input.PromptTemplate;

import java.util.HashMap;
import java.util.Map;

Führen Sie die Anwendung dann noch einmal aus. Die Ausgabe sollte in etwa so aussehen:

$ ./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.

Köstlich!

Mit Prompt-Vorlagen können Sie die erforderlichen Parameter eingeben, bevor Sie die Methode zur Texterstellung aufrufen. So können Sie Daten übergeben und Prompts für verschiedene Werte anpassen, die von Ihren Nutzern bereitgestellt werden.

Wie der Name der Klasse schon sagt, wird mit der Klasse PromptTemplate ein Vorlagenprompt erstellt. Sie können den Platzhalterelementen Werte zuweisen, indem Sie eine Zuordnung von Platzhalternamen und ‑werten anwenden.

Strukturierte Prompts (OPTIONAL)

Eine weitere Möglichkeit, Ihre Prompts zu strukturieren, ist die Annotation @StructuredPrompt, wenn Sie einen umfassenderen objektorientierten Ansatz verwenden möchten. Sie versehen eine Klasse mit dieser Annotation und ihre Felder entsprechen den im Prompt definierten Platzhaltern. Sehen wir uns das einmal an.

Zuerst benötigen wir einige neue Importe:

import java.util.Arrays;
import java.util.List;
import dev.langchain4j.model.input.structured.StructuredPrompt;
import dev.langchain4j.model.input.structured.StructuredPromptProcessor;

Anschließend können wir eine innere statische Klasse in unserer TextPrompts-Klasse erstellen, die die Daten erfasst, die zum Übergeben der Platzhalter im Prompt benötigt werden, der in der @StructuredPrompt-Annotation beschrieben wird:

@StructuredPrompt("Create a recipe of a {{dish}} that can be prepared using only {{ingredients}}")
static class RecipeCreationPrompt {
    String dish;
    List<String> ingredients;
}

Instanziieren Sie dann die neue Klasse und übergeben Sie ihr das Gericht und die Zutaten unseres Rezepts. Erstellen Sie wie zuvor die Aufforderung und übergeben Sie sie an die Methode generate():

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);

Anstatt die Lücken über eine Karte zu füllen, können Sie ein Java-Objekt mit Feldern verwenden, die von Ihrer IDE auf typsichere Weise automatisch vervollständigt werden können.

Hier ist der gesamte Code, damit Sie die Änderungen leichter in Ihre TextPrompts-Klasse einfügen können:

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. Text klassifizieren und Sentiment analysieren

Ähnlich wie im vorherigen Abschnitt lernen Sie eine weitere Prompt-Engineering-Technik kennen, mit der Sie das PaLM-Modell Text klassifizieren oder Stimmungen analysieren lassen können. Sprechen wir über Few-Shot-Prompts. So können Sie Ihre Prompts mit einigen Beispielen ergänzen, um das Sprachmodell in die gewünschte Richtung zu lenken und Ihre Absicht besser zu verstehen.

Wir überarbeiten die Klasse TextPrompts, um Prompt-Vorlagen zu nutzen:

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());
    }
}

Beachten Sie, dass im Prompt einige Beispiele für Ein- und Ausgaben enthalten sind. Das sind die „wenigen Beispiele“, die dem LLM helfen, derselben Struktur zu folgen. Wenn das Modell dann eine Eingabe erhält, wird es versuchen, eine Ausgabe zurückzugeben, die dem Eingabe-/Ausgabemuster entspricht.

Wenn Sie das Programm ausführen, sollte nur das Wort POSITIVE zurückgegeben werden, da Erdbeeren auch lecker sind.

$ ./gradlew run -DjavaMainClass=palm.workshop.TextPrompts

> Task :app:run
POSITIVE

Die Sentimentanalyse ist auch ein Szenario für die Inhaltsklassifizierung. Sie können denselben Few-Shot-Prompting-Ansatz verwenden, um verschiedene Dokumente in verschiedene Kategorie-Buckets einzuordnen.

8. Glückwunsch

Herzlichen Glückwunsch! Sie haben Ihre erste Anwendung für generative KI in Java mit LangChain4J und der PaLM API erstellt. Sie haben festgestellt, dass Large Language Models sehr leistungsstark sind und verschiedene Aufgaben wie Fragen und Antworten, Datenextraktion, Zusammenfassung, Textklassifizierung und Stimmungsanalyse bewältigen können.

Nächste Schritte

In den folgenden Codelabs finden Sie weitere Informationen zu PaLM in Java:

Weitere Informationen

Referenzdokumente