1. מבוא
העדכון האחרון: 27 בנובמבר 2023
מהי בינה מלאכותית גנרטיבית
בינה מלאכותית גנרטיבית היא שימוש ב-AI כדי ליצור תוכן חדש, כמו טקסט, תמונות, מוזיקה, אודיו וסרטונים.
ה-AI הגנרטיבי מבוסס על מודלים בסיסיים (מודלים גדולים של AI) שיכולים לבצע כמה משימות בו-זמנית ומשימות מוכנות לשימוש, כולל סיכום, שאלות ותשובות, סיווג ועוד. בנוסף, מודלי בסיס דורשים אימון מינימלי, ולכן אפשר להתאים אותם לתרחישי שימוש ממוקדים עם מעט מאוד נתונים לדוגמה.
איך פועלת בינה מלאכותית גנרטיבית?
בינה מלאכותית גנרטיבית פועלת באמצעות מודל ML (למידת מכונה) כדי ללמוד את הדפוסים והקשרים במערך נתונים של תוכן שנוצר על ידי בני אדם. לאחר מכן היא משתמשת בדפוסים שנלמדו כדי ליצור תוכן חדש.
הדרך הנפוצה ביותר לאמן מודל AI גנרטיבי היא באמצעות למידה מפוקחת – המודל מקבל קבוצה של תוכן שנוצר על ידי בני אדם ותוויות תואמות. לאחר מכן, היא לומדת ליצור תוכן שדומה לתוכן שנוצר על ידי בני אדם וסומן באותן תוויות.
מהם יישומים נפוצים של AI גנרטיבי?
AI גנרטיבי מעבד כמויות גדולות של תוכן, ויוצר תובנות ותשובות באמצעות טקסט, תמונות ופורמטים ידידותיים למשתמש. אפשר להשתמש ב-AI גנרטיבי כדי:
- שיפור האינטראקציות עם הלקוחות באמצעות חוויות משופרות בצ'אט ובחיפוש
- עיון בכמויות גדולות של נתונים לא מובנים באמצעות ממשקי שיחה וסיכומים
- עזרה במשימות חוזרות כמו מענה לבקשות להצעות מחיר (RFP), התאמת תוכן שיווקי לשוק המקומי בחמש שפות, בדיקת חוזים עם לקוחות לצורך עמידה בדרישות ועוד
אילו מוצרים מבוססי-AI גנרטיבי זמינים ב-Google Cloud?
עם Vertex AI, אתם יכולים ליצור אינטראקציה עם מודלים בסיסיים, להתאים אותם אישית ולהטמיע אותם באפליקציות שלכם – בלי צורך בידע רב בלמידת מכונה. אפשר לגשת למודלים בסיסיים ב-Model Garden, לכוונן מודלים באמצעות ממשק משתמש פשוט ב-Generative AI Studio או להשתמש במודלים במחברת של מדעי הנתונים.
חיפוש ושיחות על בסיס Vertex AI מציע למפתחים את הדרך המהירה ביותר ליצור מנועי חיפוש וצ'אטבוטים שמבוססים על AI גנרטיבי.
בנוסף, Duet AI הוא שותף מבוסס-AI שזמין ב-Google Cloud ובסביבות פיתוח משולבות (IDE), ועוזר לכם לבצע יותר משימות מהר יותר.
מה הנושא המרכזי של ה-Codelab הזה?
ה-codelab הזה מתמקד במודל השפה הגדול (LLM) PaLM 2, שמארח ב-Google Cloud Vertex AI את כל מוצרי למידת המכונה והשירותים.
תשתמשו ב-Java כדי ליצור אינטראקציה עם PaLM API, בשילוב עם כלי התזמור של LangChain4J LLM framework. תעברו על דוגמאות קונקרטיות שונות כדי ללמוד איך להשתמש ב-LLM למענה על שאלות, ליצירת רעיונות, לחילוץ ישויות ותוכן מובנה ולסיכום.
אני רוצה עוד פרטים על המסגרת LangChain4J
המסגרת LangChain4J היא ספרייה בקוד פתוח לשילוב מודלים גדולים של שפה באפליקציות Java. היא מאפשרת לתזמן רכיבים שונים, כמו מודל שפה גדול, אבל גם כלים אחרים כמו מסדי נתונים וקטוריים (לחיפושים סמנטיים), טוענים ומפצלים של מסמכים (לניתוח מסמכים ולמידה מהם), מנתחי פלט ועוד.
מה תלמדו
- איך מגדירים פרויקט Java לשימוש ב-PaLM וב-LangChain4J
- איך מבצעים את הקריאה הראשונה למודל הטקסט של PaLM כדי ליצור תוכן ולענות על שאלות
- איך לחלץ מידע שימושי מתוכן לא מובנה (חילוץ ישויות או מילות מפתח, פלט בפורמט JSON)
- איך מבצעים סיווג תוכן או ניתוח סנטימנט באמצעות הנחיות עם מעט דוגמאות
מה תצטרכו
- ידע בשפת התכנות Java
- פרויקט ב-Google Cloud
- דפדפן, כמו Chrome או Firefox
2. הגדרה ודרישות
הגדרת סביבה בקצב אישי
- נכנסים ל-מסוף Google Cloud ויוצרים פרויקט חדש או משתמשים בפרויקט קיים. אם עדיין אין לכם חשבון Gmail או Google Workspace, אתם צריכים ליצור חשבון.
- שם הפרויקט הוא השם המוצג של הפרויקט הזה למשתתפים. זו מחרוזת תווים שלא נמצאת בשימוש ב-Google APIs. תמיד אפשר לעדכן את המיקום.
- מזהה הפרויקט הוא ייחודי לכל הפרויקטים ב-Google Cloud ואי אפשר לשנות אותו אחרי שהוא מוגדר. מסוף Cloud יוצר באופן אוטומטי מחרוזת ייחודית, ובדרך כלל לא צריך לדעת מה היא. ברוב ה-Codelabs, תצטרכו להפנות למזהה הפרויקט (בדרך כלל מסומן כ-
PROJECT_ID). אם אתם לא אוהבים את המזהה שנוצר, אתם יכולים ליצור מזהה אקראי אחר. אפשר גם לנסות שם משתמש משלכם ולבדוק אם הוא זמין. אי אפשר לשנות את ההגדרה הזו אחרי השלב הזה, והיא תישאר לאורך הפרויקט. - לידיעתכם, יש ערך שלישי, מספר פרויקט, שחלק מממשקי ה-API משתמשים בו. במאמרי העזרה מפורט מידע נוסף על שלושת הערכים האלה.
- בשלב הבא, תצטרכו להפעיל את החיוב במסוף Cloud כדי להשתמש במשאבי Cloud או בממשקי API של Cloud. השלמת ה-codelab הזה לא תעלה לכם הרבה, אם בכלל. כדי להשבית את המשאבים ולמנוע חיובים נוספים אחרי שתסיימו את המדריך הזה, תוכלו למחוק את המשאבים שיצרתם או למחוק את הפרויקט. משתמשים חדשים ב-Google Cloud זכאים לתוכנית תקופת ניסיון בחינם בשווי 300$.
מפעילים את Cloud Shell
אפשר להפעיל את Google Cloud מרחוק מהמחשב הנייד, אבל ב-codelab הזה תשתמשו ב-Cloud Shell, סביבת שורת פקודה שפועלת בענן.
הפעלת Cloud Shell
- ב-Cloud Console, לוחצים על Activate Cloud Shell
.
אם זו הפעם הראשונה שאתם מפעילים את Cloud Shell, יוצג לכם מסך ביניים עם תיאור של השירות. אם הוצג לכם מסך ביניים, לחצו על המשך.
הקצאת המשאבים והחיבור ל-Cloud Shell נמשכים רק כמה רגעים.
המכונה הווירטואלית הזו כוללת את כל הכלים הדרושים למפתחים. יש בה ספריית בית בנפח מתמיד של 5GB והיא פועלת ב-Google Cloud, מה שמשפר מאוד את הביצועים והאימות ברשת. אפשר לבצע את רוב העבודה ב-codelab הזה, אם לא את כולה, באמצעות דפדפן.
אחרי שמתחברים ל-Cloud Shell, אמור להופיע אימות ושהפרויקט מוגדר לפי מזהה הפרויקט.
- מריצים את הפקודה הבאה ב-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`
- מריצים את הפקודה הבאה ב-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.
הפעלת ממשקי Vertex AI API
- במסוף Google Cloud, מוודאים ששם הפרויקט מוצג בראש מסוף Google Cloud. אם לא, לוחצים על בחירת פרויקט כדי לפתוח את בורר הפרויקטים, ובוחרים את הפרויקט הרצוי.
- אם אתם לא בחלק של Vertex AI במסוף Google Cloud, מבצעים את הפעולות הבאות:
- בקטע חיפוש, מזינים Vertex AI ולוחצים על Return.
- בתוצאות החיפוש, לוחצים על Vertex AI. לוח הבקרה של Vertex AI מופיע.
- לוחצים על Enable All Recommended APIs (הפעלת כל ממשקי ה-API המומלצים) במרכז הבקרה של Vertex AI.
הפעולה הזו תפעיל כמה ממשקי API, אבל החשוב ביותר מביניהם ל-codelab הוא aiplatform.googleapis.com, שאפשר להפעיל גם בשורת הפקודה, במסוף Cloud Shell, על ידי הפעלת הפקודה הבאה:
$ gcloud services enable aiplatform.googleapis.com
יצירת מבנה הפרויקט באמצעות Gradle
כדי ליצור את דוגמאות הקוד של Java, תשתמשו בכלי הבנייה Gradle ובגרסה 17 של Java. כדי להגדיר את הפרויקט באמצעות Gradle, יוצרים ספרייה (במקרה הזה, palm-workshop) בטרמינל של Cloud Shell ומריצים את הפקודה 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 לקובץ הבנייה (אפשרות 1), בלי להשתמש בתכונות חדשות של בנייה (אפשרות no), יצירת בדיקות באמצעות 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, כדי לאפשר למשתמשים לעקוף את המחלקה הראשית ולהריץ אותה בשורת הפקודה כשמפעילים את כלי הבנייה:
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, תגדירו את מודל השפה באמצעות הכלי ליצירת 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.
הכלי ליצירת 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. חילוץ מידע מטקסט לא מובנה
בסעיף הקודם יצרתם פלט טקסט. זה בסדר אם רוצים להציג את הפלט הזה ישירות למשתמשי הקצה. אבל אם רוצים לאחזר את הנתונים שמוזכרים בפלט הזה, איך אפשר לחלץ את המידע הזה מהטקסט הלא מובנה?
נניח שאתם רוצים לחלץ את השם והגיל של אדם מסוים, מתוך ביוגרפיה או תיאור של אותו אדם. אפשר לתת למודל שפה גדול הוראה ליצור מבני נתונים בפורמט 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). מחליפים את המילים באותיות רישיות ברעיונות משלכם, ובודקים את הפלט:
- תרגום – "תרגם את המשפט הבא לצרפתית: YOUR_SENTENCE_HERE"
- סיכום – "תספק סיכום של המסמך הבא: הדבק את המסמך"
- יצירה יצירתית – "תכתוב שיר על TOPIC_OF_THE_POEM"
- תכנות – "איך כותבים פונקציית פיבונאצ'י ב-PROGRAMMING_LANGUAGE?"
תבניות של הנחיות
אם ניסיתם את ההנחיות שלמעלה לתרגום, לסיכום, ליצירת קריאייטיב או למשימות תכנות, החלפתם את ערכי ה-placeholder ברעיונות משלכם. אבל במקום לבצע מניפולציה של מחרוזות, אפשר גם להשתמש בתבניות של הנחיות, שמאפשרות להגדיר את ערכי ה-placeholder האלה ולמלא את החסר אחר כך בנתונים שלכם.
בואו נסתכל על הנחיה טעימה ויצירתית, על ידי החלפת כל התוכן של שיטת 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, אם רוצים להשתמש בגישה עשירה יותר של תכנות מונחה-עצמים. אתם מוסיפים הערה לכיתה עם ההערה הזו, והשדות שלה תואמים למחזיקי המקום שהוגדרו בהנחיה. בואו נראה את זה בפעולה.
קודם כול, צריך לייבא כמה דברים חדשים:
import java.util.Arrays;
import java.util.List;
import dev.langchain4j.model.input.structured.StructuredPrompt;
import dev.langchain4j.model.input.structured.StructuredPromptProcessor;
לאחר מכן, אפשר ליצור מחלקה סטטית פנימית בתוך המחלקה TextPrompts, שאוספת את הנתונים שצריך להעביר במחזיקי המקום בהנחיה שמתוארת בהערה @StructuredPrompt:
@StructuredPrompt("Create a recipe of a {{dish}} that can be prepared using only {{ingredients}}")
static class RecipeCreationPrompt {
String dish;
List<String> ingredients;
}
לאחר מכן יוצרים מופע של המחלקה החדשה ומזינים לו את המנה והמרכיבים של המתכון, יוצרים את ההנחיה ומעבירים אותה לשיטת 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! במהלך הדרך גיליתם שמודלים גדולים של שפה הם די חזקים ויכולים להתמודד עם משימות שונות כמו מענה לשאלות, חילוץ נתונים, סיכום, סיווג טקסט, ניתוח סנטימנטים ועוד.
מה השלב הבא?
כדי להמשיך ללמוד על PaLM ב-Java, אפשר לעיין ב-Codelabs הבאים:
קריאה נוספת
- תרחישים נפוצים לשימוש ב-AI גנרטיבי
- מקורות מידע להדרכה בנושא AI גנרטיבי
- איך מתקשרים עם PaLM באמצעות Generative AI Studio
- אתיקה של בינה מלאכותית