יצירת טקסט של בינה מלאכותית גנרטיבית ב-Java באמצעות PaLM ו-LangChain4J

יצירת טקסט של בינה מלאכותית גנרטיבית ב-Java באמצעות PaLM ו-LangChain4J

מידע על Codelab זה

subjectהעדכון האחרון: דצמ׳ 4, 2023
account_circleנכתב על ידי Guillaume Laforge

1.‏ מבוא

עדכון אחרון: 27.11.2023

בינה מלאכותית גנרטיבית או בינה מלאכותית (AI) גנרטיבית היא שימוש ב-AI ליצירת תוכן חדש, כמו טקסטים, תמונות, מוזיקה, אודיו וסרטונים.

בינה מלאכותית גנרטיבית מבוססת על מודלים בסיסיים (מודלים גדולים של בינה מלאכותית) שיכולים לבצע כמה משימות בו-זמנית ולבצע משימות שונות, כולל סיכום, שאלות ותשובות, סיווג ועוד. בנוסף, הודות לאימון מינימלי, ניתן להתאים מודלים בסיסיים לתרחישים לדוגמה ממוקדים, עם מעט מאוד נתוני דוגמה.

איך עובדת בינה מלאכותית גנרטיבית?

בינה מלאכותית גנרטיבית משתמשת במודל למידת מכונה (ML) כדי ללמוד את הדפוסים והקשרים במערך נתונים של תוכן שנוצר על ידי בני אדם. לאחר מכן היא משתמשת בדפוסים שנלמדו כדי ליצור תוכן חדש.

הדרך הנפוצה ביותר לאמן מודל של בינה מלאכותית גנרטיבית היא להשתמש בלמידה מונחית – נותנים למודל קבוצה של תוכן שנוצר על ידי בני אדם ותוויות תואמות. לאחר מכן, היא לומדת ליצור תוכן שדומה לתוכן שנוצר על ידי בני אדם ומתויג עם אותן תוויות.

מהן אפליקציות נפוצות של בינה מלאכותית גנרטיבית?

AI גנרטיבי מעבד תוכן נרחב, ויוצר תובנות ותשובות באמצעות טקסטים, תמונות ופורמטים ידידותיים למשתמש. אפשר להשתמש ב-AI גנרטיבי כדי:

  • משפרים את האינטראקציה עם הלקוחות בעזרת חוויות משופרות בצ'אט ובחיפוש
  • לחקור כמויות עצומות של נתונים לא מובנים באמצעות ממשקים שיחה וסיכומים
  • סיוע במשימות שחוזרות על עצמן, כמו מענה לבקשות להצעות (RFP), לוקליזציה של תוכן שיווקי בחמש שפות, ובדיקת חוזים של לקוחות כדי לוודא שהם עומדים בדרישות ועוד.

אילו פתרונות של בינה מלאכותית גנרטיבית יש ל-Google Cloud?

ב-Vertex AI תוכלו לתקשר עם מודלים בסיסיים, להתאים אותם אישית ולהטמיע אותם באפליקציות שלכם – אין צורך במומחיות או במומחיות בכלל בלמידת מכונה. ב-Model Garden אפשר לגשת למודלים בסיסיים, לכוונן מודלים דרך ממשק משתמש פשוט ב-Generative AI Studio או להשתמש במודלים ב-notebook של מדעי נתונים.

חיפוש ושיחות על בסיס Vertex AI הם הדרך המהירה ביותר לפתח מנועי חיפוש וצ'אט בוטים שמבוססים על בינה מלאכותית גנרטיבית.

בנוסף, Duet AI הוא שותף מבוסס-AI, שזמין ב-Google Cloud ובסביבות פיתוח משולבות (IDE) כדי לעזור לך להספיק יותר, מהר יותר.

במה מתמקדים ב-Codelab?

ה-Codelab הזה מתמקד ב-PaLM 2 Large Language Model (LLM), שמתארח ב-Google Cloud Vertex AI, ומקיף את כל המוצרים והשירותים של למידת מכונה.

תשתמשו ב-Java כדי לנהל אינטראקציה עם PaLM API, בשילוב עם LangChain4J framework LLM, מתזמר. תקבלו דוגמאות קונקרטיות שונות כדי לנצל את ה-LLM למענה על שאלות, ליצירת רעיונות, לחילוץ תוכן מובנה ולחילוץ תוכן מובנה.

Tell me more about the LangChain4J framework!

ה-framework של LangChain4J הוא ספריית קוד פתוח לשילוב מודלים גדולים של שפה באפליקציות Java שלכם, על ידי תזמור רכיבים שונים, כמו ה-LLM עצמו, אלא גם כלים אחרים כמו מסדי נתונים וקטוריים (לחיפושים סמנטיים), מטענים ומפצלי מסמכים (כדי לנתח מסמכים וללמוד מהם), לנתחי פלט ועוד.

c6d7f7c3fd0d2951.png

מה תלמדו

  • איך להגדיר פרויקט Java כדי להשתמש ב-PaLM וב-LangChain4J
  • איך לבצע את הקריאה הראשונה למודל הטקסט של PaLM כדי ליצור תוכן ולענות על שאלות
  • איך לחלץ מידע שימושי מתוכן לא מובנה (חילוץ ישות או מילת מפתח, פלט ב-JSON)
  • איך לבצע סיווג תוכן או ניתוח סנטימנטים באמצעות כמה שוטים, כדי להנחות אותם

מה צריך להכין

  • ידע בשפת התכנות Java
  • פרויקט ב-Google Cloud
  • דפדפן, כמו Chrome או Firefox

2.‏ הגדרה ודרישות

הגדרת סביבה בקצב עצמאי

  1. נכנסים למסוף Google Cloud ויוצרים פרויקט חדש או עושים שימוש חוזר בפרויקט קיים. אם אין לכם עדיין חשבון Gmail או חשבון Google Workspace, עליכם ליצור חשבון.

295004821bab6a87.png

37d264871000675d.png

96d86d3d5655cdbe.png

  • Project name הוא השם המוצג של המשתתפים בפרויקט. זו מחרוזת תווים שלא משמשת את Google APIs. תמיד אפשר לעדכן.
  • Project ID הוא ייחודי בכל הפרויקטים ב-Google Cloud ואי אפשר לשנות אותו (אי אפשר לשנות אותו אחרי שמגדירים אותו). מסוף Cloud יוצר מחרוזת ייחודית באופן אוטומטי; בדרך כלל לא מעניין אותך מה זה. ברוב ה-codelabs תצטרכו להפנות למזהה הפרויקט שלכם (בדרך כלל מזוהה כ-PROJECT_ID). אם המזהה שנוצר לא מוצא חן בעיניכם, אתם יכולים ליצור מזהה אקראי אחר. לחלופין, אפשר לנסות שם משלך ולראות אם הוא זמין. לא ניתן לשנות אותו אחרי השלב הזה, והוא נשאר למשך הפרויקט.
  • לידיעתך, יש ערך שלישי, Project Number, שבו משתמשים בחלק מממשקי ה-API. מידע נוסף על כל שלושת הערכים האלה זמין במסמכי התיעוד.
  1. בשלב הבא צריך להפעיל את החיוב במסוף Cloud כדי להשתמש במשאבים או בממשקי API של Cloud. מעבר ב-Codelab הזה לא יעלה הרבה כסף, אם בכלל. כדי להשבית משאבים ולא לצבור חיובים מעבר למדריך הזה, אתם יכולים למחוק את המשאבים שיצרתם או למחוק את הפרויקט. משתמשים חדשים ב-Google Cloud זכאים להשתתף בתוכנית תקופת ניסיון בחינם בשווי 1,200 ש"ח.

הפעלת Cloud Shell

אומנם אפשר להפעיל את Google Cloud מרחוק מהמחשב הנייד, אבל ב-Codelab הזה משתמשים ב-Cloud Shell, סביבת שורת הפקודה שפועלת ב-Cloud.

הפעלת Cloud Shell

  1. במסוף Cloud, לוחצים על Activate Cloud Shell d1264ca30785e435.png.

cb81e7c8e34bc8d.png

אם זו הפעם הראשונה שאתם מפעילים את Cloud Shell, יוצג לכם מסך ביניים שמתוארת בו. אם הוצג לכם מסך ביניים, לוחצים על המשך.

d95252b003979716.png

ההקצאה וההתחברות ל-Cloud Shell נמשכת כמה דקות.

7833d5e1c5d18f54.png

במכונה הווירטואלית הזו נמצאים כל כלי הפיתוח הדרושים. יש בה ספריית בית בנפח מתמיד של 5GB והיא פועלת ב-Google Cloud, מה שמשפר משמעותית את ביצועי הרשת והאימות. אם לא את כולן, ניתן לבצע חלק גדול מהעבודה ב-Codelab הזה באמצעות דפדפן.

אחרי ההתחברות ל-Cloud Shell, אתם אמורים לראות שהפרויקט מאומת ושהפרויקט מוגדר לפי מזהה הפרויקט שלכם.

  1. מריצים את הפקודה הבאה ב-Cloud Shell כדי לוודא שהאימות בוצע:
gcloud auth list

פלט הפקודה

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

To set the active account, run:
    $ gcloud config set account `ACCOUNT`
  1. מריצים את הפקודה הבאה ב-Cloud Shell כדי לוודא שהפקודה ב-gcloud יודעת על הפרויקט שלכם:
gcloud config list project

פלט הפקודה

[core]
project = <PROJECT_ID>

אם היא לא נמצאת שם, תוכלו להגדיר אותה באמצעות הפקודה הבאה:

gcloud config set project <PROJECT_ID>

פלט הפקודה

Updated property [core/project].

3.‏ הכנת סביבת הפיתוח

ב-Codelab הזה תשתמשו בטרמינל של Cloud Shell ובעורך הקוד כדי לפתח את תוכנות Java.

הפעלת ממשקי API של Vertex AI

  1. במסוף Google Cloud, מוודאים ששם הפרויקט מוצג בחלק העליון של מסוף Google Cloud. אם לא, לוחצים על Select a project כדי לפתוח את Project Selector ובוחרים את הפרויקט הרצוי.
  2. אם אתם לא נמצאים בחלק של Vertex AI במסוף Google Cloud, עליכם לבצע את הפעולות הבאות:
  3. בקטע Search (חיפוש), מזינים Vertex AI, ואז מחזירים
  4. בתוצאות החיפוש, לוחצים על Vertex AI לוח הבקרה של Vertex AI.
  5. לוחצים על Enable AllRecommended APIs (הפעלת כל ממשקי ה-API המומלצים) במרכז הבקרה של Vertex AI.

הפעולה הזו תפעיל כמה ממשקי API, אבל המפתח החשוב ביותר ב-Codelab הוא aiplatform.googleapis.com, ואפשר להפעיל אותו גם בשורת הפקודה בטרמינל של Cloud Shell באמצעות הפקודה הבאה:

$ gcloud services enable aiplatform.googleapis.com

יצירת מבנה הפרויקט באמצעות Gradle

כדי לבנות את הדוגמאות לקוד Java, משתמשים בכלי ה-build של Gradle ובגרסה 17 של Java. כדי להגדיר את הפרויקט באמצעות Gradle, יוצרים ספרייה בטרמינל של Cloud Shell (כאן, palm-workshop) ומריצים את הפקודה 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

מפתחים אפליקציה (אפשרות 2), באמצעות שפת Java (אפשרות 3), בלי להשתמש בפרויקטים משניים (אפשרות 1), באמצעות התחביר של Groovy לקובץ ה-build (אפשרות 1), לא להשתמש בתכונות build חדשות (אפשרות לא), ליצור בדיקות באמצעות JUnit Jupiter (אפשרות 4) ולשם הפרויקט אפשר להשתמש ב-palm-workshop, ובדומה לחבילה.ניתן להשתמש ב-palm-workshop.

מבנה הפרויקט ייראה כך:

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

נעדכן את הקובץ app/build.gradle כדי להוסיף את יחסי התלות הנדרשים. ניתן להסיר את התלות של guava אם היא קיימת, ולהחליף אותה ביחסי התלות של פרויקט LangChain4J, ואת ספריית הרישום ביומן כדי למנוע מצב של הודעות יומן חסרות:

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

יש 2 יחסי תלות ל-LangChain4J:

  • בפרויקט הליבה,
  • והשני למודול הייעודי של Vertex AI.

כדי להשתמש ב-Java 17 להידור ולהפעלה של התוכנות שלנו, צריך להוסיף את הבלוק הבא מתחת לבלוק plugins {}:

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

שינוי נוסף לביצוע: מעדכנים את הבלוק application של app/build.gradle, כדי שמשתמשים יוכלו לשנות את המחלקה הראשית שתרוץ בשורת הפקודה כשמפעילים את כלי ה-build:

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

כדי לבדוק שקובץ ה-build מוכן להרצת האפליקציה, אפשר להריץ את המחלקה הראשית שמוגדרת כברירת מחדל, שמדפיסה הודעת Hello World! פשוטה:

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

> Task :app:run
Hello World!

BUILD SUCCESSFUL in 3s
2 actionable tasks: 2 executed

עכשיו אתם מוכנים לתכנת את מודל השפה הגדול של PaLM באמצעות הפרויקט LangChain4J!

לידיעתך, קובץ ה-build המלא של 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.‏ ביצוע הקריאה הראשונה למודל הטקסט של PaLM

עכשיו, כשהפרויקט מוגדר כראוי, הגיע הזמן לקרוא ל-PaLM API.

יוצרים מחלקה חדשה בשם TextPrompts.java בספרייה app/src/main/java/palm/workshop (לצד כיתת ברירת המחדל App.java), ומקלידים את התוכן הבא:

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

בדוגמה הראשונה הזו, צריך לייבא את המחלקה Response, ואת מודל השפה של Vertex AI עבור PaLM.

בשלב הבא, בשיטה main מגדירים את מודל השפה באמצעות ה-builder של VertexAiLanguageModel, כדי לציין:

  • נקודת הקצה,
  • את הפרויקט,
  • את האזור,
  • את בעל האתר,
  • ושם המודל (text-bison@001).

עכשיו, כשמודל השפה מוכן, אפשר לקרוא לשיטה generate() ולהעביר את "הבקשה" (כלומר, השאלה או ההוראות שצריך לשלוח ל-LLM). כאן אפשר לשאול שאלה פשוטה מהם מודלים מסוג LLM. עם זאת, אפשר לשנות את ההנחיה הזו כדי לנסות שאלות או משימות אחרות.

כדי להריץ את הכיתה הזו, מריצים את הפקודה הבאה בטרמינל של Cloud Shell:

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

הפלט אמור להיראות כך:

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.

ה-builder של VertexAILanguageModel מאפשר להגדיר פרמטרים אופציונליים שכבר יש להם כמה ערכי ברירת מחדל שאפשר לשנות. הנה כמה דוגמאות:

  • .temperature(0.2) — כדי להגדיר את מידת היצירתיות הרצויה לתשובה (0 אם הקריאייטיב שלך נמוך ולרוב תהיה עובדתית יותר, והערך 1 מייצג פלט של יותר קריאייטיב).
  • .maxOutputTokens(50) – בדוגמה הזו, נשלחו בקשות ל-500 אסימונים (3 אסימונים הם בערך שווי ערך ל-4 מילים), בהתאם למשך הזמן שבו רוצים שהתשובה שנוצרה תהיה
  • .topK(20) — בחירה אקראית של מילה מתוך מספר מקסימלי של מילים בסבירות גבוהה להשלמת הטקסט (מ-1 עד 40)
  • .topP(0.95) - כדי לבחור את המילים האפשריות שההסתברות הכוללת שלהן מסתכמת במספר הנקודה הצפה (בין 0 ל-1)
  • .maxRetries(3) — במקרה שחורגים ממכסת הזמן של הבקשה, אפשר לבקש מהמודל לנסות לבצע שוב את הקריאה 3 פעמים.

מודלים גדולים של שפה (LLM) הם חזקים מאוד, ויכולים לספק תשובות לשאלות מורכבות ויכולים להתמודד עם מגוון גדול של משימות מעניינות. בקטע הבא נבחן משימה שימושית: חילוץ נתונים מובְנים מטקסט.

5.‏ חילוץ מידע מטקסט לא מובנה

בקטע הקודם יצרתם פלט טקסט. זה בסדר אם רוצים להציג את הפלט ישירות למשתמשי הקצה. אבל אם רוצים לאחזר את הנתונים שמוזכרים בפלט הזה, איך מחלצים את המידע מהטקסט הלא מובנה?

נניח שאתם רוצים לחלץ את השם והגיל של אדם כלשהו, על סמך הביוגרפיה או התיאור שלו. אפשר להורות למודל השפה הגדול (LLM) ליצור מבני נתונים של JSON על ידי התאמת ההנחיה לפעולה הבאה (שנקראת בדרך כלל 'הנדסת הנחיות'):

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: 

משנים את הקריאה model.generate() בכיתה TextPrompts כדי להעביר אליה את כל הנחיית הטקסט שלמעלה:

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

);

אם מריצים את ההנחיה הזו במחלקה TextPrompts, היא אמורה להחזיר את מחרוזת ה-JSON הבאה, שאותה אפשר לנתח באמצעות מנתח JSON כמו ספריית 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

כן! אנה בת 23!

6.‏ תבניות של הנחיות והנחיות מובנות

מעבר למענה לשאלות

מודלים גדולים של שפה, כמו PaLM, הם כלים יעילים מאוד למענה על שאלות, אבל אפשר להשתמש בהם לביצוע משימות נוספות רבות. לדוגמה, אתם יכולים לנסות את ההנחיות הבאות ב-Generative AI Studio (או לשנות את המחלקה TextPrompts). אפשר לשנות את המילים באותיות רישיות ברעיונות שלכם ולבדוק את הפלט שלהן:

  • Translation — "תרגום המשפט הבא בצרפתית: YOUR_SENTENCE_HERE"
  • סיכום — "יש לספק סיכום של המסמך הבא: PASTE_YOUR_DOC"
  • יצירת קריאייטיב — "כתיבת שיר על TOPIC_OF_THE_POEM"
  • תכנות — "How to Write a Fibonacci function in PROGRAMMING_LANGUAGE? "

תבניות של הנחיות

אם ניסיתם את ההנחיות שלמעלה לתרגום, לסיכום, ליצירת נכסי קריאייטיב או למשימות תכנות, החלפתם את הערכים הזמניים לשמירת מקום ברעיונות שלכם. אבל במקום לבצע קצת ניהול מחרוזות, אפשר גם לנצל את היתרונות של 'תבניות ההנחיות', שמאפשרות להגדיר את הערכים הזמניים האלו, ולמלא את החסר מאוחר יותר בנתונים שלך.

בואו נראה הנחיה יצירתית וטעימה. אנחנו מחליפים את כל התוכן של השיטה main() בקוד הבא:

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

על ידי הוספת פריטי הייבוא הבאים:

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

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

לאחר מכן, מריצים שוב את האפליקציה. הפלט אמור להיראות ככה:

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

טעים!

בעזרת תבניות של הנחיות, אפשר להזין את הפרמטרים הנדרשים לפני קריאה לשיטת יצירת הטקסט. זו דרך מצוינת להעביר נתונים ולהתאים אישית הנחיות לערכים שונים שהמשתמשים סיפקו.

בהתאם לשם הכיתה, הכיתה PromptTemplate יוצרת הנחיה לתבנית, ואפשר להקצות ערכים לרכיבי ה-placeholder באמצעות מפה של שמות וערכים של placeholder.

הנחיות מובנות (אופציונלי)

אם רוצים להשתמש בגישה עשירה יותר שממוקדת באובייקטים, יש עוד דרך לבנות את ההנחיות באמצעות ההערה @StructuredPrompt. מוסיפים הערות לכיתה עם ההערה הזו, והשדות שלה תואמים ל-placeholders שמוגדרים בהנחיה. נראה את זה בפעולה.

קודם כל, נצטרך לבצע כמה ייבואים חדשים:

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

לאחר מכן נוכל ליצור מחלקה סטטית פנימית בתוך המחלקה TextPrompts, שאוספת את הנתונים הנדרשים להעברת ה-placeholders בהנחיה שמתוארת בהערה @StructuredPrompt:

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

לאחר מכן יוצרים מופע של הכיתה החדשה ומזינים לה את המנה והמרכיבים של המתכון, יוצרים את ההנחיה ומעבירים אותה ל-method 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);

במקום למלא את הפערים באמצעות מפה, אתם יכולים להשתמש באובייקט Java עם שדות שאפשר למלא באופן אוטומטי על ידי סביבת הפיתוח המשולבת (IDE), בדרך שלא פוגעת בהקלדה.

הנה הקוד המלא כדי להדביק בקלות רבה יותר את השינויים האלה בכיתה 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.‏ סיווג טקסטים וניתוח סנטימנטים

בדומה למה שלמדתם בקטע הקודם, כאן תגלו שיטה נוספת של 'הנדסת הנחיות' שמאפשרת למודל PaLM לסווג טקסט או לנתח סנטימנטים. בואו נדבר על "יצירת הנחיות מכמה דוגמאות". זו דרך לשפר את ההנחיות בעזרת כמה דוגמאות שיעזרו לכוון את מודל השפה לכיוון הרצוי, ולהבין טוב יותר את הכוונה שלכם.

נשמח לשנות את הכיתה TextPrompts כדי לנצל את התבניות של הנחיות:

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

שימו לב לגישה של הצעת כמה דוגמאות לקלט ולפלט בהנחיה. אלה "הכמה צילומים" שעוזרת ל-LLM לעקוב אחרי אותו מבנה. כאשר המודל מקבל קלט, הוא ירצה להחזיר פלט שתואם לדפוס הקלט/פלט.

הרצת התוכנית צריכה להחזיר רק את המילה POSITIVE, כי גם תותים זה טעים!

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

> Task :app:run
POSITIVE

ניתוח סנטימנטים הוא גם תרחיש של סיווג תוכן. אפשר ליישם את אותה גישה של הנחיות מכמה דוגמאות כדי לסווג מסמכים שונים לקטגוריות שונות.

8.‏ מזל טוב

מזל טוב, פיתחת בהצלחה את אפליקציית בינה מלאכותית גנרטיבית הראשונה שלך ב-Java באמצעות LangChain4J ו-PaLM API! בדרך גיליתם שמודלים גדולים של שפה הם די חזקים ומסוגלים לטפל במשימות שונות כמו שאלות/מענה, חילוץ נתונים, סיכום, סיווג טקסט, ניתוח סנטימנטים ועוד.

מה השלב הבא?

עיינו בכמה שיעורי Lab הבאים כדי להתקדם עוד יותר עם PaLM ב-Java:

קריאה נוספת

מסמכי עזר