Generowanie tekstu przez generatywną AI w języku Java za pomocą PaLM i LangChain4J

1. Wprowadzenie

Ostatnia aktualizacja: 27.11.2023

Czym jest generatywna AI

Generatywna AI lub generatywna sztuczna inteligencja to wykorzystywanie AI do tworzenia nowych treści, takich jak tekst, obrazy, muzyka, dźwięki i filmy.

Generatywna AI jest oparta na modelach podstawowych (dużych modelach AI), które mogą wykonywać wiele zadań i działać od razu po wyjęciu z pudełka, m.in. podsumowywać, odpowiadać na pytania i klasyfikować. Modele podstawowe wymagają minimalnego trenowania i można je dostosowywać do konkretnych przypadków użycia przy użyciu bardzo małej ilości danych przykładowych.

Jak działa generatywna AI?

Generatywna AI działa na podstawie modelu uczenia maszynowego, który rozpoznaje wzorce i zależności w zbiorze danych zawierającym treści utworzone przez ludzi. Następnie wykorzystuje wyuczone wzorce do generowania nowych treści.

Najczęstszym sposobem trenowania modelu generatywnej AI jest uczenie nadzorowane – model otrzymuje zestaw treści utworzonych przez człowieka i odpowiadające im etykiety. Następnie uczy się generować treści podobne do tych utworzonych przez człowieka i oznaczonych tymi samymi etykietami.

Jakie są typowe zastosowania generatywnej AI?

Generatywna AI przetwarza ogromne ilości treści, tworząc statystyki i odpowiedzi w formie tekstu, obrazów i przyjaznych dla użytkownika formatów. Generatywna AI może służyć do:

  • Ulepszanie interakcji z klientami dzięki ulepszonym funkcjom czatu i wyszukiwania
  • Przeglądanie ogromnych ilości nieuporządkowanych danych za pomocą interfejsów konwersacyjnych i podsumowań
  • pomagać w powtarzalnych zadaniach, takich jak odpowiadanie na zapytania ofertowe, lokalizowanie treści marketingowych w 5 językach i sprawdzanie zgodności umów z klientami z przepisami;

Jakie oferty generatywnej AI są dostępne w Google Cloud?

Dzięki Vertex AI możesz wchodzić w interakcje z modelami podstawowymi, dostosowywać je i osadzać w aplikacjach – nie musisz mieć przy tym specjalistycznej wiedzy z zakresu uczenia maszynowego. Uzyskaj dostęp do modeli podstawowych w Model Garden, dostrajaj modele za pomocą prostego interfejsu w Generative AI Studio lub używaj modeli w notatniku do obsługi danych.

Vertex AI Search and Conversation to najszybszy sposób na tworzenie wyszukiwarek i chatbotów opartych na generatywnej AI.

Duet AI to oparta na AI usługa wspomagająca dostępna w Google Cloud i IDE pomagająca wydajniej i szybciej pracować.

Na czym skupiają się te ćwiczenia?

Te warsztaty skupiają się na dużym modelu językowym PaLM 2, który jest hostowany w usłudze Google Cloud Vertex AI obejmującej wszystkie produkty i usługi związane z uczeniem maszynowym.

Do interakcji z interfejsem PaLM API będziesz używać języka Java w połączeniu z orkiestratorem platformy LLM LangChain4J. Poznasz różne konkretne przykłady wykorzystania LLM do odpowiadania na pytania, generowania pomysłów, wyodrębniania jednostek i treści strukturalnych oraz tworzenia podsumowań.

Chcę się dowiedzieć więcej o platformie LangChain4J.

Platforma LangChain4J to biblioteka open source do integrowania dużych modeli językowych z aplikacjami w języku Java. Umożliwia ona koordynowanie różnych komponentów, takich jak sam LLM, ale także inne narzędzia, np. bazy danych wektorowych (do wyszukiwania semantycznego), moduły do wczytywania i dzielenia dokumentów (do analizowania dokumentów i uczenia się na ich podstawie), parsery danych wyjściowych i inne.

c6d7f7c3fd0d2951.png

Czego się nauczysz

  • Jak skonfigurować projekt Java do korzystania z PaLM i LangChain4J
  • Jak wykonać pierwsze wywołanie modelu tekstowego PaLM, aby generować treści i odpowiadać na pytania
  • Jak wyodrębniać przydatne informacje z nieuporządkowanych treści (wyodrębnianie jednostek lub słów kluczowych, dane wyjściowe w formacie JSON)
  • Jak przeprowadzić klasyfikację treści lub analizę nastawienia za pomocą promptów typu „few-shot”

Czego potrzebujesz

  • Znajomość języka programowania Java
  • projekt Google Cloud,
  • przeglądarka, np. Chrome lub Firefox;

2. Konfiguracja i wymagania

Samodzielne konfigurowanie środowiska

  1. Zaloguj się w konsoli Google Cloud i utwórz nowy projekt lub użyj istniejącego. Jeśli nie masz jeszcze konta Gmail ani Google Workspace, musisz je utworzyć.

295004821bab6a87.png

37d264871000675d.png

96d86d3d5655cdbe.png

  • Nazwa projektu to wyświetlana nazwa uczestników tego projektu. Jest to ciąg znaków, który nie jest używany przez interfejsy API Google. Zawsze możesz ją zaktualizować.
  • Identyfikator projektu jest unikalny we wszystkich projektach Google Cloud i nie można go zmienić po ustawieniu. Konsola Cloud automatycznie generuje unikalny ciąg znaków. Zwykle nie musisz się tym przejmować. W większości ćwiczeń z programowania musisz odwoływać się do identyfikatora projektu (zwykle oznaczanego jako PROJECT_ID). Jeśli wygenerowany identyfikator Ci się nie podoba, możesz wygenerować inny losowy identyfikator. Możesz też spróbować własnej nazwy i sprawdzić, czy jest dostępna. Po tym kroku nie można go zmienić i pozostaje on taki przez cały czas trwania projektu.
  • Warto wiedzieć, że istnieje trzecia wartość, numer projektu, której używają niektóre interfejsy API. Więcej informacji o tych 3 wartościach znajdziesz w dokumentacji.
  1. Następnie musisz włączyć płatności w konsoli Cloud, aby korzystać z zasobów i interfejsów API Google Cloud. Wykonanie tego laboratorium nie będzie kosztować dużo, a może nawet nic. Aby wyłączyć zasoby i uniknąć naliczania opłat po zakończeniu tego samouczka, możesz usunąć utworzone zasoby lub projekt. Nowi użytkownicy Google Cloud mogą skorzystać z bezpłatnego okresu próbnego, w którym mają do dyspozycji środki w wysokości 300 USD.

Uruchamianie Cloud Shell

Z Google Cloud można korzystać zdalnie na laptopie, ale w tym module użyjemy Cloud Shell, czyli środowiska wiersza poleceń działającego w chmurze.

Aktywowanie Cloud Shell

  1. W konsoli Cloud kliknij Aktywuj Cloud Shell d1264ca30785e435.png.

cb81e7c8e34bc8d.png

Jeśli uruchamiasz Cloud Shell po raz pierwszy, zobaczysz ekran pośredni z opisem tego środowiska. Jeśli pojawił się ekran pośredni, kliknij Dalej.

d95252b003979716.png

Uzyskanie dostępu do środowiska Cloud Shell i połączenie się z nim powinno zająć tylko kilka chwil.

7833d5e1c5d18f54.png

Ta maszyna wirtualna zawiera wszystkie potrzebne narzędzia dla programistów. Zawiera również stały katalog domowy o pojemności 5 GB i działa w Google Cloud, co znacznie zwiększa wydajność sieci i usprawnia proces uwierzytelniania. Większość zadań w tym module, a być może wszystkie, możesz wykonać w przeglądarce.

Po połączeniu z Cloud Shell zobaczysz, że uwierzytelnianie zostało już przeprowadzone, a projekt jest już ustawiony na Twój identyfikator projektu.

  1. Aby potwierdzić, że uwierzytelnianie zostało przeprowadzone, uruchom w Cloud Shell to polecenie:
gcloud auth list

Wynik polecenia

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

To set the active account, run:
    $ gcloud config set account `ACCOUNT`
  1. Aby potwierdzić, że polecenie gcloud zna Twój projekt, uruchom w Cloud Shell to polecenie:
gcloud config list project

Wynik polecenia

[core]
project = <PROJECT_ID>

Jeśli nie, możesz go ustawić za pomocą tego polecenia:

gcloud config set project <PROJECT_ID>

Wynik polecenia

Updated property [core/project].

3. Przygotowywanie środowiska programistycznego

W tym ćwiczeniu programistycznym do tworzenia programów w Javie będziesz używać terminala i edytora kodu Cloud Shell.

Włączanie interfejsów API Vertex AI

  1. W konsoli Google Cloud upewnij się, że nazwa projektu jest wyświetlana u góry konsoli Google Cloud. Jeśli nie, kliknij Wybierz projekt, aby otworzyć selektor projektów, i wybierz odpowiedni projekt.
  2. Jeśli nie jesteś w sekcji Vertex AI w konsoli Google Cloud, wykonaj te czynności:
  3. W polu Wyszukaj wpisz Vertex AI, a następnie naciśnij Enter.
  4. W wynikach wyszukiwania kliknij Vertex AI. Pojawi się panel Vertex AI.
  5. W panelu Vertex AI kliknij Włącz wszystkie zalecane interfejsy API.

Włączy to kilka interfejsów API, ale najważniejszy w tym samouczku jest interfejs aiplatform.googleapis.com, który możesz też włączyć w wierszu poleceń w terminalu Cloud Shell, uruchamiając to polecenie:

$ gcloud services enable aiplatform.googleapis.com

Tworzenie struktury projektu za pomocą Gradle

Do tworzenia przykładowych kodów w języku Java będziesz używać narzędzia do kompilacji Gradle i Javy w wersji 17. Aby skonfigurować projekt za pomocą Gradle, w terminalu Cloud Shell utwórz katalog (w tym przypadku palm-workshop) i uruchom w nim polecenie gradle init:

$ 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

Utworzysz aplikację (opcja 2) w języku Java (opcja 3) bez użycia podprojektów (opcja 1) z syntaktyką Groovy w pliku kompilacji (opcja 1), bez użycia nowych funkcji kompilacji (opcja 0), generując testy za pomocą JUnit Jupiter (opcja 4). Jako nazwę projektu możesz użyć palm-workshop, a jako pakiet źródłowy – palm.workshop.

Struktura projektu będzie wyglądać tak:

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

Zaktualizujmy plik app/build.gradle, aby dodać potrzebne zależności. Możesz usunąć zależność guava, jeśli jest obecna, i zastąpić ją zależnościami projektu LangChain4J oraz biblioteki logowania, aby uniknąć irytujących komunikatów o braku rejestratora:

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 ma 2 zależności:

  • jeden w projekcie podstawowym,
  • i jeden dla dedykowanego modułu Vertex AI.

Aby używać Javy 17 do kompilowania i uruchamiania programów, dodaj ten blok poniżej bloku plugins {}:

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

Kolejna zmiana do wprowadzenia: zaktualizuj blok application w app/build.gradle, aby umożliwić użytkownikom zastąpienie głównej klasy do uruchomienia w wierszu poleceń podczas wywoływania narzędzia do kompilacji:

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

Aby sprawdzić, czy plik kompilacji jest gotowy do uruchomienia aplikacji, możesz uruchomić domyślną klasę główną, która wyświetla prosty komunikat Hello World!:

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

> Task :app:run
Hello World!

BUILD SUCCESSFUL in 3s
2 actionable tasks: 2 executed

Możesz już programować za pomocą dużego modelu językowego PaLM, korzystając z projektu LangChain4J.

Oto jak powinien teraz wyglądać pełny plik kompilacji app/build.gradle:

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. Wykonywanie pierwszego połączenia z modelem tekstowym PaLM

Teraz, gdy projekt jest już prawidłowo skonfigurowany, możesz wywołać interfejs PaLM API.

Utwórz w katalogu app/src/main/java/palm/workshop nową klasę o nazwie TextPrompts.java (obok domyślnej klasy App.java) i wpisz ten kod:

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

W tym pierwszym przykładzie musisz zaimportować klasę Response i model językowy Vertex AI dla PaLM.

Następnie w metodzie main skonfigurujesz model językowy, używając narzędzia do tworzenia VertexAiLanguageModel, aby określić:

  • punkt końcowy,
  • projektu,
  • region,
  • wydawca,
  • i nazwę modelu (text-bison@001).

Gdy model językowy będzie gotowy, możesz wywołać metodę generate() i przekazać „prompt” (czyli pytanie lub instrukcje do wysłania do LLM). Zadaj proste pytanie o to, czym są duże modele językowe. Możesz jednak zmienić ten prompt, aby wypróbować inne pytania lub zadania.

Aby uruchomić tę klasę, wpisz w terminalu Cloud Shell to polecenie:

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

Powinny pojawić się dane wyjściowe podobne do tych:

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.

Narzędzie do tworzenia VertexAILanguageModel umożliwia zdefiniowanie parametrów opcjonalnych, które mają już wartości domyślne, które możesz zastąpić. Oto przykłady:

  • .temperature(0.2) – określa, jak kreatywna ma być odpowiedź (0 – mało kreatywna i często bardziej oparta na faktach, 1 – bardziej kreatywna).
  • .maxOutputTokens(50) – w tym przykładzie poproszono o 500 tokenów (3 tokeny to w przybliżeniu 4 słowa), w zależności od tego, jak długa ma być wygenerowana odpowiedź.
  • .topK(20) – losowe wybranie słowa z maksymalnej liczby prawdopodobnych słów do dokończenia tekstu (od 1 do 40).
  • .topP(0.95) – aby wybrać możliwe słowa, których łączne prawdopodobieństwo wynosi tę liczbę zmiennoprzecinkową (od 0 do 1).
  • .maxRetries(3) – jeśli przekraczasz limit żądań na określony czas, możesz na przykład poprosić model o 3-krotne ponowienie wywołania.

Duże modele językowe są bardzo zaawansowane i potrafią odpowiadać na złożone pytania oraz wykonywać wiele interesujących zadań. W następnej sekcji przyjrzymy się przydatnemu zadaniu: wyodrębnianiu uporządkowanych danych z tekstu.

5. Wyodrębnianie informacji z nieustrukturyzowanego tekstu

W poprzedniej sekcji wygenerowaliśmy tekstowe dane wyjściowe. Jest to w porządku, jeśli chcesz bezpośrednio wyświetlać te dane wyjściowe użytkownikom. Jeśli jednak chcesz pobrać dane, o których mowa w tym wyniku, jak wyodrębnić te informacje z nieustrukturyzowanego tekstu?

Załóżmy, że chcesz wyodrębnić imię i wiek osoby na podstawie jej biografii lub opisu. Możesz poinstruować duży model językowy, aby generował struktury danych JSON, dostosowując prompt w ten sposób (jest to powszechnie nazywane „inżynierią promptów”):

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:

Zmodyfikuj wywołanie model.generate() w klasie TextPrompts, aby przekazać mu cały powyższy prompt tekstowy:

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

Jeśli uruchomisz ten prompt w naszej klasie TextPrompts, powinien on zwrócić ten ciąg znaków w formacie JSON, który możesz przeanalizować za pomocą parsera JSON, np. biblioteki 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

Tak. Anna ma 23 lata.

6. Szablony promptów i prompty strukturalne

Nie tylko odpowiadanie na pytania

Duże modele językowe, takie jak PaLM, świetnie sprawdzają się w odpowiadaniu na pytania, ale można ich używać do wielu innych zadań. Na przykład wypróbuj te prompty w Generative AI Studio (lub zmodyfikuj klasę TextPrompts). Zastąp słowa pisane wielkimi literami własnymi pomysłami i sprawdź wyniki:

  • Tłumaczenie – „Przetłumacz następujące zdanie na język francuski: YOUR_SENTENCE_HERE”.
  • Podsumowanie – „Podsumuj ten dokument: WKLEJ_SWÓJ_DOKUMENT”
  • Generowanie kreacji – „Napisz wiersz o TOPIC_OF_THE_POEM”
  • Programowanie – „Jak napisać funkcję Fibonacciego w PROGRAMMING_LANGUAGE?”

Szablony promptów

Jeśli wypróbujesz powyższe prompty do tłumaczenia, podsumowywania, generowania treści kreatywnych lub programowania, zastąp wartości zmiennych własnymi pomysłami. Zamiast jednak manipulować ciągami znaków możesz skorzystać z szablonów promptów, które umożliwiają zdefiniowanie wartości zastępczych, a następnie wypełnienie pustych pól danymi.

Przyjrzyjmy się ciekawemu i smacznemu promptowi. W tym celu zastąp całą zawartość metody main() tym kodem:

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

oraz dodając te instrukcje importu:

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

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

Następnie ponownie uruchom aplikację. Dane wyjściowe powinny wyglądać mniej więcej tak:

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

Pycha!

Dzięki szablonom promptów możesz przekazywać wymagane parametry przed wywołaniem metody generowania tekstu. To świetny sposób na przekazywanie danych i dostosowywanie promptów do różnych wartości podawanych przez użytkowników.

Zgodnie z nazwą klasy klasa PromptTemplate tworzy prompt szablonu, a wartości do elementów zastępczych możesz przypisywać, stosując mapę nazw i wartości elementów zastępczych.

Prompty strukturalne (OPCJONALNE)

Innym sposobem na tworzenie promptów jest użycie adnotacji @StructuredPrompt, jeśli chcesz zastosować bardziej rozbudowane podejście obiektowe. Klasę oznaczysz tą adnotacją, a jej pola będą odpowiadać symbolom zastępczym zdefiniowanym w prompcie. Zobaczmy, jak to działa.

Najpierw musimy dodać kilka nowych importów:

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

Następnie możemy utworzyć w klasie TextPrompts wewnętrzną klasę statyczną, która zbiera dane potrzebne do przekazania do symboli zastępczych w prompcie opisanym w adnotacji @StructuredPrompt:

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

Następnie utwórz instancję tej nowej klasy i przekaż jej danie oraz składniki przepisu, utwórz prompt i przekaż go do metody generate() jak poprzednio:

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

Zamiast wypełniać luki za pomocą mapy, możesz użyć obiektu Java z polami, które mogą być automatycznie uzupełniane przez IDE w bezpieczniejszy sposób.

Oto cały kod, który ułatwi Ci wklejenie tych zmian do klasy 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. klasyfikowanie tekstu i analizowanie nastawienia,

Podobnie jak w poprzedniej sekcji, poznasz kolejną technikę „inżynierii promptów”, która umożliwia klasyfikowanie tekstu lub analizowanie nastrojów przez model PaLM. Porozmawiajmy o „tworzeniu promptów few-shot”. To sposób na ulepszenie promptów za pomocą kilku przykładów, które pomogą skierować model językowy w odpowiednim kierunku, aby lepiej zrozumieć Twoje intencje.

Zmodyfikujmy klasę TextPrompts, aby wykorzystać szablony promptów:

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

Zwróć uwagę na podejście polegające na podaniu w prompcie kilku przykładów danych wejściowych i wyjściowych. Są to „przykłady”, które pomagają modelowi LLM zachować tę samą strukturę. Gdy model otrzyma dane wejściowe, będzie chciał zwrócić dane wyjściowe, które pasują do wzorca danych wejściowych i wyjściowych.

Uruchomienie programu powinno zwrócić tylko słowo POSITIVE, ponieważ truskawki też są pyszne.

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

> Task :app:run
POSITIVE

Analiza nastawienia to również scenariusz klasyfikacji treści. Możesz zastosować to samo podejście „tworzenie promptów few-shot”, aby podzielić różne dokumenty na różne kategorie.

8. Gratulacje

Gratulacje! Udało Ci się utworzyć pierwszą aplikację generatywnej AI w języku Java przy użyciu LangChain4J i interfejsu PaLM API. Po drodze odkrywasz, że duże modele językowe są dość zaawansowane i mogą wykonywać różne zadania, takie jak odpowiadanie na pytania, wyodrębnianie danych, podsumowywanie, klasyfikowanie tekstu, analiza nastawienia i inne.

Co dalej?

Aby dowiedzieć się więcej o PaLM w Javie, zapoznaj się z tymi ćwiczeniami:

Więcej informacji

Dokumentacja