1. บทนำ
อัปเดตล่าสุด 27-11-2023
Generative AI คืออะไร
Generative AI หรือปัญญาประดิษฐ์แบบ Generative (Generative AI) คือการใช้ AI เพื่อสร้างเนื้อหาใหม่ๆ เช่น ข้อความ รูปภาพ เพลง เสียง และวิดีโอ
Generative AI ขับเคลื่อนโดยโมเดลพื้นฐาน (โมเดล AI ขนาดใหญ่) ที่สามารถทํางานหลายอย่างพร้อมกันและทํางานได้ทันที ซึ่งรวมถึงการสรุป ถามและตอบ การแยกประเภท และอีกมากมาย นอกจากนี้ โมเดลพื้นฐานยังใช้ได้กับกรณีการใช้งานแบบกำหนดเป้าหมายที่มีข้อมูลตัวอย่างน้อยมาก เนื่องจากอาศัยการฝึกเพียงเล็กน้อย
Generative AI ทำงานอย่างไร
Generative AI ทำงานโดยใช้โมเดล ML (แมชชีนเลิร์นนิง) เพื่อเรียนรู้รูปแบบและความสัมพันธ์ในชุดข้อมูลของเนื้อหาที่มนุษย์สร้างขึ้น จากนั้นใช้รูปแบบที่เรียนรู้เพื่อสร้างเนื้อหาใหม่
วิธีที่พบบ่อยที่สุดในการฝึกโมเดล Generative AI คือการใช้การเรียนรู้ภายใต้การควบคุมดูแล โดยโมเดลจะได้รับชุดเนื้อหาที่มนุษย์สร้างขึ้นและป้ายกำกับที่เกี่ยวข้อง จากนั้นจะเรียนรู้การสร้างเนื้อหาที่คล้ายกับเนื้อหาที่มนุษย์สร้างขึ้นและติดป้ายกำกับด้วยป้ายกำกับเดียวกัน
แอปพลิเคชัน Generative AI ทั่วไปคืออะไร
Generative AI ประมวลผลเนื้อหาจำนวนมาก สร้างข้อมูลเชิงลึกและคำตอบผ่านข้อความ รูปภาพ และในรูปแบบที่ใช้งานง่าย Generative AI สามารถใช้เพื่อวัตถุประสงค์ต่อไปนี้
- ปรับปรุงการโต้ตอบของลูกค้าผ่านการแชทและการค้นหาที่ดีขึ้น
- สำรวจข้อมูลจำนวนมากที่ไม่มีโครงสร้างผ่านอินเทอร์เฟซการสนทนาและการสรุป
- ช่วยเหลืองานที่ต้องทำซ้ำๆ เช่น การตอบกลับคำขอข้อเสนอ (RFP), การแปลเนื้อหาการตลาดเป็น 5 ภาษา และการตรวจสอบสัญญาของลูกค้าว่าสอดคล้องกับนโยบายหรือไม่ และอีกมากมาย
Google Cloud มีข้อเสนอ Generative AI ใดบ้าง
Vertex AI ช่วยให้คุณโต้ตอบ ปรับแต่ง และฝังโมเดลพื้นฐานลงในแอปพลิเคชันได้ ซึ่งต้องอาศัยความเชี่ยวชาญด้าน ML เพียงเล็กน้อยหรือไม่มีเลย เข้าถึงโมเดลพื้นฐานใน Model Garden ปรับแต่งโมเดลผ่าน UI แบบง่ายใน Generative AI Studio หรือใช้โมเดลในสมุดบันทึกเกี่ยวกับวิทยาศาสตร์ข้อมูล
Vertex AI Search and Conversation ช่วยให้นักพัฒนาแอปสร้างเครื่องมือค้นหาและแชทบ็อตที่ทำงานด้วย Generative AI ได้อย่างรวดเร็วที่สุด
นอกจากนี้ Duet AI เป็นผู้ช่วยที่ทำงานด้วยระบบ AI ซึ่งพร้อมใช้งานใน Google Cloud และ IDE เพื่อช่วยให้คุณทำสิ่งต่างๆ ได้มากขึ้นและรวดเร็วยิ่งขึ้น
Codelab นี้มุ่งเน้นไปที่อะไร
Codelab นี้มุ่งเน้นไปที่ PaLM 2 Large Language Model (LLM) ซึ่งโฮสต์บน Vertex AI ของ Google Cloud ที่ครอบคลุมผลิตภัณฑ์และบริการแมชชีนเลิร์นนิงทั้งหมด
คุณจะใช้ Java เพื่อโต้ตอบกับ PaLM API ร่วมกับ Orchestrator เฟรมเวิร์ก LLM ของ LangChain4J คุณจะได้ยกตัวอย่างที่เป็นรูปธรรมต่างๆ เพื่อใช้ประโยชน์จาก LLM ในการตอบคำถาม การสร้างไอเดีย การแยกเอนทิตีและเนื้อหาที่มีโครงสร้าง ตลอดจนการสรุป
บอกข้อมูลเพิ่มเติมเกี่ยวกับเฟรมเวิร์ก LangChain4J
เฟรมเวิร์ก LangChain4J เป็นไลบรารีโอเพนซอร์สสำหรับผสานรวมโมเดลภาษาขนาดใหญ่ในแอปพลิเคชัน Java โดยจัดการคอมโพเนนต์ต่างๆ เช่น LLM เอง และยังมีเครื่องมืออื่นๆ เช่น ฐานข้อมูลเวกเตอร์ (สำหรับการค้นหาความหมาย) ตัวโหลดและตัวแยกเอกสาร (เพื่อวิเคราะห์และเรียนรู้จากเอกสาร) โปรแกรมแยกวิเคราะห์เอาต์พุต และอื่นๆ
สิ่งที่คุณจะได้เรียนรู้
- วิธีตั้งค่าโปรเจ็กต์ Java เพื่อใช้ PaLM และ LangChain4J
- วิธีเรียกใช้โมเดลข้อความ PaLM เป็นครั้งแรกเพื่อสร้างเนื้อหาและตอบคำถาม
- วิธีดึงข้อมูลที่เป็นประโยชน์จากเนื้อหาที่ไม่มีโครงสร้าง (การแยกเอนทิตีหรือคีย์เวิร์ดออกในรูปแบบ JSON)
- วิธีจำแนกประเภทเนื้อหาหรือวิเคราะห์ความเห็นด้วยการแสดงหน้าต่างเพียง 2-3 ช็อต
สิ่งที่คุณต้องมี
- ความรู้เกี่ยวกับภาษาโปรแกรม Java
- โปรเจ็กต์ Google Cloud
- เบราว์เซอร์ เช่น Chrome หรือ Firefox
2. การตั้งค่าและข้อกำหนด
การตั้งค่าสภาพแวดล้อมตามเวลาที่สะดวก
- ลงชื่อเข้าใช้ Google Cloud Console และสร้างโปรเจ็กต์ใหม่หรือใช้โปรเจ็กต์ที่มีอยู่ซ้ำ หากยังไม่มีบัญชี Gmail หรือ Google Workspace คุณต้องสร้างบัญชี
- ชื่อโครงการคือชื่อที่แสดงของผู้เข้าร่วมโปรเจ็กต์นี้ เป็นสตริงอักขระที่ Google APIs ไม่ได้ใช้ โดยคุณจะอัปเดตวิธีการชำระเงินได้ทุกเมื่อ
- รหัสโปรเจ็กต์จะไม่ซ้ำกันในทุกโปรเจ็กต์ของ Google Cloud และจะเปลี่ยนแปลงไม่ได้ (เปลี่ยนแปลงไม่ได้หลังจากตั้งค่าแล้ว) Cloud Console จะสร้างสตริงที่ไม่ซ้ำกันโดยอัตโนมัติ ปกติแล้วคุณไม่สนว่าอะไรเป็นอะไร ใน Codelab ส่วนใหญ่ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ (โดยปกติจะระบุเป็น
PROJECT_ID) หากคุณไม่ชอบรหัสที่สร้างขึ้น คุณสามารถสร้างรหัสแบบสุ่มอื่นได้ หรือคุณจะลองดำเนินการเองแล้วดูว่าพร้อมให้ใช้งานหรือไม่ คุณจะเปลี่ยนแปลงหลังจากขั้นตอนนี้ไม่ได้และจะยังคงอยู่ตลอดระยะเวลาของโปรเจ็กต์ - สำหรับข้อมูลของคุณ ค่าที่ 3 คือหมายเลขโปรเจ็กต์ ซึ่ง API บางตัวใช้ ดูข้อมูลเพิ่มเติมเกี่ยวกับค่าทั้ง 3 ค่าได้ในเอกสารประกอบ
- ถัดไป คุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร/API ของระบบคลาวด์ การใช้งาน Codelab นี้จะไม่มีค่าใช้จ่ายใดๆ หากมี หากต้องการปิดทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินที่นอกเหนือจากบทแนะนำนี้ คุณสามารถลบทรัพยากรที่คุณสร้างหรือลบโปรเจ็กต์ได้ ผู้ใช้ Google Cloud ใหม่มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรี$300 USD
เริ่มต้น Cloud Shell
แม้ว่าคุณจะดำเนินการ Google Cloud จากระยะไกลได้จากแล็ปท็อป แต่คุณจะใช้ Cloud Shell ใน Codelab ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานในระบบคลาวด์
เปิดใช้งาน Cloud Shell
- คลิกเปิดใช้งาน Cloud Shell
จาก Cloud Console
หากเริ่มต้นใช้งาน Cloud Shell เป็นครั้งแรก คุณจะเห็นหน้าจอตรงกลางที่อธิบายว่านี่คืออะไร หากระบบแสดงหน้าจอตรงกลาง ให้คลิกต่อไป
การจัดสรรและเชื่อมต่อกับ Cloud Shell ใช้เวลาเพียงไม่กี่นาที
เครื่องเสมือนนี้โหลดด้วยเครื่องมือการพัฒนาทั้งหมดที่จำเป็น โดยมีไดเรกทอรีหลักขนาด 5 GB ถาวรและทำงานใน 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 ให้ทำดังนี้
- ใน Search ให้ป้อน Vertex AI แล้วกลับมาที่หน้านี้
- ในผลการค้นหา ให้คลิก Vertex AI แดชบอร์ด Vertex AI ปรากฏขึ้น
- คลิก เปิดใช้ API ที่แนะนำทั้งหมดในแดชบอร์ด Vertex AI
การดำเนินการนี้จะเปิดใช้ API หลายรายการ แต่ API ที่สำคัญที่สุดสำหรับ Codelab คือ aiplatform.googleapis.com ซึ่งคุณสามารถเปิดใช้ในบรรทัดคำสั่งในเทอร์มินัล Cloud Shell ได้เช่นกันโดยเรียกใช้คำสั่งต่อไปนี้
$ gcloud services enable aiplatform.googleapis.com
การสร้างโครงสร้างโปรเจ็กต์ด้วย Gradle
ในการสร้างตัวอย่างโค้ด Java คุณจะต้องใช้เครื่องมือสร้าง Gradle และ Java เวอร์ชัน 17 ในการตั้งค่าโปรเจ็กต์ด้วย 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 สำหรับไฟล์บิลด์ (ตัวเลือกที่ 1) อย่าใช้ฟีเจอร์บิลด์ใหม่ (ตัวเลือกไม่) สร้างการทดสอบด้วย 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 เพื่อเพิ่มทรัพยากร Dependency ที่จำเป็น คุณสามารถนำทรัพยากร Dependency guava ออกหากมีอยู่ และแทนที่ด้วยทรัพยากร Dependency สำหรับโปรเจ็กต์ 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'
}
มีทรัพยากร Dependency สำหรับ LangChain4J อยู่ 2 รายการดังนี้
- เกี่ยวกับโปรเจ็กต์หลัก
- และอีกส่วนหนึ่งสำหรับโมดูล Vertex AI โดยเฉพาะ
ในการใช้ Java 17 ในการคอมไพล์และเรียกใช้โปรแกรมของเรา ให้เพิ่มบล็อคต่อไปนี้ใต้บล็อก plugins {}:
java {
toolchain {
languageVersion = JavaLanguageVersion.of(17)
}
}
การเปลี่ยนแปลงเพิ่มเติมอีกรายการหนึ่งที่ต้องทำคือ อัปเดตบล็อก application ของ app/build.gradle เพื่อให้ผู้ใช้ลบล้างคลาสหลักเพื่อเรียกใช้ในบรรทัดคำสั่งเมื่อเรียกใช้เครื่องมือสร้างได้
application {
mainClass = providers.systemProperty('javaMainClass')
.orElse('palm.workshop.App')
}
หากต้องการตรวจสอบว่าไฟล์บิลด์พร้อมที่จะเรียกใช้แอปพลิเคชันแล้ว คุณสามารถเรียกใช้คลาสหลักเริ่มต้นซึ่งจะพิมพ์ข้อความ Hello World! แบบง่ายดังนี้
$ ./gradlew run -DjavaMainClass=palm.workshop.App > Task :app:run Hello World! BUILD SUCCESSFUL in 3s 2 actionable tasks: 2 executed
ตอนนี้คุณพร้อมที่จะเขียนโปรแกรมด้วยโมเดลข้อความภาษาขนาดใหญ่ PaLM โดยใช้โปรเจ็กต์ LangChain4J แล้ว
เพื่อเป็นข้อมูลอ้างอิง ไฟล์บิลด์ 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 ครั้ง เช่น
โมเดลภาษาขนาดใหญ่มีประสิทธิภาพมาก สามารถให้คำตอบสำหรับคำถามที่ซับซ้อน และจัดการกับงานที่น่าสนใจจำนวนมากได้ ในส่วนถัดไป เราจะพูดถึงงานที่มีประโยชน์ นั่นคือการดึงข้อมูลที่มีโครงสร้างออกจากข้อความ
5. การดึงข้อมูลจากข้อความที่ไม่มีโครงสร้าง
ในส่วนก่อนหน้านี้ คุณได้สร้างเอาต์พุตข้อความบางอย่าง ซึ่งสามารถทำได้หากต้องการแสดงเอาต์พุตนี้ต่อผู้ใช้ปลายทางโดยตรง แต่หากคุณต้องการดึงข้อมูลที่กล่าวถึงในผลลัพธ์นี้ คุณจะดึงข้อมูลนั้นออกจากข้อความที่ไม่มีโครงสร้างอย่างไร
สมมติว่าคุณต้องการแยกชื่อและอายุของบุคคลหนึ่งจากประวัติหรือคำอธิบายของบุคคลนั้น คุณสามารถสั่งให้โมเดลภาษาขนาดใหญ่สร้างโครงสร้างข้อมูล JSON ได้โดยปรับแต่งพรอมต์ดังนี้ (โดยทั่วไปจะเรียกว่า "prompt Engineering")
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"
- การสรุป — "โปรดระบุข้อมูลสรุปของเอกสารต่อไปนี้ PASTE_YOUR_DOC"
- การสร้างครีเอทีฟโฆษณา — "เขียนกลอนเกี่ยวกับ TOPIC_OF_THE_POEM"
- การเขียนโปรแกรม — "วิธีเขียนฟังก์ชัน Fibonacci ในภาษาPROGRAMMING_LANGUAGE"
เทมเพลตพรอมต์
หากลองทำตามพรอมต์ข้างต้นสำหรับงานแปล การสรุป การสร้างผลงานสร้างสรรค์ หรืองานเขียนโปรแกรม คุณได้แทนที่ค่าตัวยึดตำแหน่งด้วยแนวคิดของคุณเอง แต่แทนที่จะทำการจัดการสตริงบางส่วน คุณอาจใช้ประโยชน์จาก "prompt template" ซึ่งจะช่วยให้คุณกำหนดค่าตัวยึดตำแหน่งและใส่ข้อมูลลงในช่องว่างหลังจากนั้นได้ด้วย
มาดูพรอมต์สุดสร้างสรรค์และน่าอร่อย โดยแทนที่เนื้อหาทั้งหมดของเมธอด 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 จะสร้างพรอมต์เทมเพลต และคุณสามารถกำหนดค่าให้กับองค์ประกอบตัวยึดตำแหน่งได้โดยใช้แผนที่ของชื่อตัวยึดตำแหน่งและค่า
ข้อความแจ้งที่มีโครงสร้าง (ไม่บังคับ)
อีกวิธีหนึ่งในการกำหนดโครงสร้างพรอมต์คือการใช้คำอธิบายประกอบ @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. การแยกประเภทข้อความและการวิเคราะห์ความเห็น
เช่นเดียวกับที่คุณได้เรียนรู้ในส่วนก่อนหน้านี้ คุณจะได้ค้นพบเทคนิค "prompt Engineering" อีกเทคนิคหนึ่งในการสร้างโมเดล PaLM เพื่อแยกข้อความหรือวิเคราะห์ความเห็น เรามาพูดถึง "ข้อความแจ้งเพียง 2-3 ช่วง" กัน ซึ่งจะช่วยเพิ่มประสิทธิภาพพรอมต์ของคุณด้วยตัวอย่าง 2-3 ตัวอย่างที่จะช่วยกำหนดโมเดลภาษาให้ไปในทิศทางที่คุณต้องการเพื่อให้เข้าใจความตั้งใจของคุณได้ดียิ่งขึ้น
มาทบทวนชั้นเรียน 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());
}
}
สังเกตวิธีการให้ตัวอย่างอินพุตและเอาต์พุต 2-3 ตัวอย่างในพรอมต์ นี่คือ "ภาพถ่าย 2-3 ภาพ" ซึ่งช่วยให้ LLM ดำเนินการตามโครงสร้างเดียวกัน เมื่อโมเดลได้รับอินพุตแล้ว ก็จะต้องแสดงผลเอาต์พุตที่ตรงกับรูปแบบอินพุต/เอาต์พุต
การดำเนินรายการควรส่งคืนแค่คำว่า POSITIVE เพราะสตรอเบอร์รี่ก็อร่อยเช่นกัน
$ ./gradlew run -DjavaMainClass=palm.workshop.TextPrompts
> Task :app:run
POSITIVE
การวิเคราะห์ความเห็นก็เป็นสถานการณ์จำลองการจัดประเภทเนื้อหาด้วยเช่นกัน คุณสามารถใช้วิธี "ข้อความแจ้งเพียง 2-3 ช็อต" แบบเดียวกันเพื่อจัดหมวดหมู่เอกสารต่างๆ ให้เป็นที่เก็บข้อมูลหมวดหมู่ต่างๆ ได้
8. ขอแสดงความยินดี
ยินดีด้วย คุณสร้างแอปพลิเคชัน Generative AI แรกใน Java โดยใช้ LangChain4J และ PaLM API เรียบร้อยแล้ว ที่ผ่านมา คุณได้พบว่าโมเดลภาษาขนาดใหญ่นั้นมีประสิทธิภาพและสามารถจัดการงานต่างๆ ได้มากมาย เช่น การถาม/ตอบคำถาม การดึงข้อมูล การสรุป การแยกประเภทข้อความ การวิเคราะห์ความเห็น และอื่นๆ
สิ่งที่ต้องทำต่อไป
ลองดู Codelab ต่อไปนี้เพื่อศึกษาเพิ่มเติมเกี่ยวกับ PaLM ใน Java
อ่านเพิ่มเติม
- กรณีการใช้งานทั่วไปของ Generative AI
- แหล่งข้อมูลการฝึกอบรมเกี่ยวกับ Generative AI
- โต้ตอบกับ PaLM ผ่าน Generative AI Studio
- AI ที่มีความรับผิดชอบ