แชทที่ทำงานด้วยระบบ Generative AI กับผู้ใช้และเอกสารใน Java ด้วย PaLM และ LangChain4J

1. บทนำ

อัปเดตล่าสุด:05-02-2024

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 เอง และยังมีเครื่องมืออื่นๆ เช่น ฐานข้อมูลเวกเตอร์ (สำหรับการค้นหาความหมาย) ตัวโหลดและตัวแยกเอกสาร (เพื่อวิเคราะห์และเรียนรู้จากเอกสาร) โปรแกรมแยกวิเคราะห์เอาต์พุต และอื่นๆ

c6d7f7c3fd0d2951.png

สิ่งที่คุณจะได้เรียนรู้

  • วิธีตั้งค่าโปรเจ็กต์ Java เพื่อใช้ PaLM และ LangChain4J
  • วิธีดึงข้อมูลที่เป็นประโยชน์จากเนื้อหาที่ไม่มีโครงสร้าง (การแยกเอนทิตีหรือคีย์เวิร์ดออกในรูปแบบ JSON)
  • วิธีสร้างการสนทนากับผู้ใช้
  • วิธีใช้รูปแบบแชทเพื่อถามคำถามในเอกสารของคุณเอง

สิ่งที่คุณต้องมี

  • ความรู้เกี่ยวกับภาษาโปรแกรม Java
  • โปรเจ็กต์ Google Cloud
  • เบราว์เซอร์ เช่น Chrome หรือ Firefox

2. การตั้งค่าและข้อกำหนด

การตั้งค่าสภาพแวดล้อมตามเวลาที่สะดวก

  1. ลงชื่อเข้าใช้ Google Cloud Console และสร้างโปรเจ็กต์ใหม่หรือใช้โปรเจ็กต์ที่มีอยู่ซ้ำ หากยังไม่มีบัญชี Gmail หรือ Google Workspace คุณต้องสร้างบัญชี

295004821bab6a87.png

37d264871000675d.png

96d86d3d5655cdbe.png

  • ชื่อโครงการคือชื่อที่แสดงของผู้เข้าร่วมโปรเจ็กต์นี้ เป็นสตริงอักขระที่ Google APIs ไม่ได้ใช้ โดยคุณจะอัปเดตวิธีการชำระเงินได้ทุกเมื่อ
  • รหัสโปรเจ็กต์จะไม่ซ้ำกันในทุกโปรเจ็กต์ของ Google Cloud และจะเปลี่ยนแปลงไม่ได้ (เปลี่ยนแปลงไม่ได้หลังจากตั้งค่าแล้ว) Cloud Console จะสร้างสตริงที่ไม่ซ้ำกันโดยอัตโนมัติ ปกติแล้วคุณไม่สนว่าอะไรเป็นอะไร ใน Codelab ส่วนใหญ่ คุณจะต้องอ้างอิงรหัสโปรเจ็กต์ (โดยปกติจะระบุเป็น PROJECT_ID) หากคุณไม่ชอบรหัสที่สร้างขึ้น คุณสามารถสร้างรหัสแบบสุ่มอื่นได้ หรือคุณจะลองดำเนินการเองแล้วดูว่าพร้อมให้ใช้งานหรือไม่ คุณจะเปลี่ยนแปลงหลังจากขั้นตอนนี้ไม่ได้และจะยังคงอยู่ตลอดระยะเวลาของโปรเจ็กต์
  • สำหรับข้อมูลของคุณ ค่าที่ 3 คือหมายเลขโปรเจ็กต์ ซึ่ง API บางตัวใช้ ดูข้อมูลเพิ่มเติมเกี่ยวกับค่าทั้ง 3 ค่าได้ในเอกสารประกอบ
  1. ถัดไป คุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร/API ของระบบคลาวด์ การใช้งาน Codelab นี้จะไม่มีค่าใช้จ่ายใดๆ หากมี หากต้องการปิดทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินที่นอกเหนือจากบทแนะนำนี้ คุณสามารถลบทรัพยากรที่คุณสร้างหรือลบโปรเจ็กต์ได้ ผู้ใช้ Google Cloud ใหม่มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรี$300 USD

เริ่มต้น Cloud Shell

แม้ว่าคุณจะดำเนินการ Google Cloud จากระยะไกลได้จากแล็ปท็อป แต่คุณจะใช้ Cloud Shell ใน Codelab ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานในระบบคลาวด์

เปิดใช้งาน Cloud Shell

  1. คลิกเปิดใช้งาน Cloud Shell d1264ca30785e435.png จาก Cloud Console

cb81e7c8e34bc8d.png

หากเริ่มต้นใช้งาน Cloud Shell เป็นครั้งแรก คุณจะเห็นหน้าจอตรงกลางที่อธิบายว่านี่คืออะไร หากระบบแสดงหน้าจอตรงกลาง ให้คลิกต่อไป

d95252b003979716.png

การจัดสรรและเชื่อมต่อกับ Cloud Shell ใช้เวลาเพียงไม่กี่นาที

7833d5e1c5d18f54.png

เครื่องเสมือนนี้โหลดด้วยเครื่องมือการพัฒนาทั้งหมดที่จำเป็น โดยมีไดเรกทอรีหลักขนาด 5 GB ถาวรและทำงานใน 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

เปิดใช้ Vertex AI API

  1. ในคอนโซล Google Cloud ให้ตรวจสอบว่าชื่อโปรเจ็กต์ปรากฏที่ด้านบนของคอนโซล Google Cloud หากไม่มี ให้คลิกเลือกโปรเจ็กต์เพื่อเปิดตัวเลือกโปรเจ็กต์ แล้วเลือกโปรเจ็กต์ที่ต้องการ
  2. หากไม่ได้ใช้ส่วน Vertex AI ของคอนโซล Google Cloud ให้ทำดังนี้
  3. ใน Search ให้ป้อน Vertex AI แล้วกลับมาที่หน้านี้
  4. ในผลการค้นหา ให้คลิก Vertex AI แดชบอร์ด Vertex AI ปรากฏขึ้น
  5. คลิก เปิดใช้ 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

สร้างชั้นเรียนใหม่ชื่อ ChatPrompts.java ในไดเรกทอรี app/src/main/java/palm/workshop (พร้อมด้วยคลาส App.java เริ่มต้น) และพิมพ์เนื้อหาต่อไปนี้

package palm.workshop;

import dev.langchain4j.model.vertexai.VertexAiChatModel;
import dev.langchain4j.chain.ConversationalChain;

public class ChatPrompts {
    public static void main(String[] args) {
        VertexAiChatModel model = VertexAiChatModel.builder()
            .endpoint("us-central1-aiplatform.googleapis.com:443")
            .project("YOUR_PROJECT_ID")
            .location("us-central1")
            .publisher("google")
            .modelName("chat-bison@001")
            .maxOutputTokens(400)
            .maxRetries(3)
            .build();

        ConversationalChain chain = ConversationalChain.builder()
            .chatLanguageModel(model)
            .build();

        String message = "What are large language models?";
        String answer = chain.execute(message);
        System.out.println(answer);

        System.out.println("---------------------------");

        message = "What can you do with them?";
        answer = chain.execute(message);
        System.out.println(answer);

        System.out.println("---------------------------");

        message = "Can you name some of them?";
        answer = chain.execute(message);
        System.out.println(answer);
    }
}

ในตัวอย่างแรกนี้ คุณต้องนำเข้าคลาส VertexAiChatModel และ LangChain4J ConversationalChain เพื่อให้สามารถจัดการการสนทนาแบบหลายมุมมองได้ง่ายขึ้น

จากนั้นในเมธอด main คุณจะกำหนดค่าโมเดลภาษาแชทโดยใช้เครื่องมือสร้างสำหรับ VertexAiChatModel เพื่อระบุสิ่งต่อไปนี้

  • ปลายทาง
  • สำหรับโครงการ
  • ภูมิภาค
  • ผู้เผยแพร่โฆษณา
  • และชื่อของโมเดล (chat-bison@001)

ตอนนี้โมเดลภาษาพร้อมแล้ว คุณก็เตรียม ConversationalChain ได้เลย นี่คือ Abstraction ระดับที่สูงกว่าที่นำเสนอโดย LangChain4J เพื่อกำหนดค่าองค์ประกอบต่างๆ ร่วมกันเพื่อจัดการกับการสนทนา เช่น ตัวโมเดลภาษาการแชท แต่อาจเป็นคอมโพเนนต์อื่นสำหรับจัดการประวัติของการสนทนาแชท หรือเพื่อเชื่อมต่อเครื่องมืออื่นๆ เช่น รีทรีฟเวอร์ เพื่อดึงข้อมูลจากฐานข้อมูลเวกเตอร์ แต่ไม่ต้องกังวล เราจะกลับมาพูดคุยกันอีกครั้งใน Codelab นี้

จากนั้น คุณจะต้องสนทนาแบบผลัดกันเล่นกับโมเดลแชท เพื่อถามคำถามที่เกี่ยวข้องหลายข้อ ก่อนอื่นคุณสงสัยเกี่ยวกับ LLM จากนั้นจึงถามว่าจะทำอะไรได้บ้างและดูตัวอย่าง LLM ได้อย่างไรบ้าง สังเกตได้ว่าคุณไม่ต้องพูดซ้ำ แล้ว LLM จะรู้ว่า "พวกเขา" เอง หมายถึง LLM ในบริบทของการสนทนานั้น

หากต้องการดำเนินการสนทนาหลายรายการ เพียงเรียกใช้เมธอด execute() ในเชน โดยโมเดลจะเพิ่มลงในบริบทของการสนทนา โมเดลแชทจะสร้างการตอบกลับและเพิ่มลงในประวัติการแชทด้วย

หากต้องการเรียกใช้คลาสนี้ ให้เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล Cloud Shell

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

คุณควรจะเห็นผลลัพธ์ที่คล้ายกับวิดีโอนี้

$ ./gradlew run -DjavaMainClass=palm.workshop.ChatPrompts
Starting a Gradle Daemon, 2 incompatible and 2 stopped Daemons could not be reused, use --status for details

> Task :app:run
Large language models (LLMs) are artificial neural networks that are trained on massive datasets of text and code. They are designed to understand and generate human language, and they can be used for a variety of tasks, such as machine translation, question answering, and text summarization.
---------------------------
LLMs can be used for a variety of tasks, such as:

* Machine translation: LLMs can be used to translate text from one language to another.
* Question answering: LLMs can be used to answer questions posed in natural language.
* Text summarization: LLMs can be used to summarize text into a shorter, more concise form.
* Code generation: LLMs can be used to generate code, such as Python or Java code.
* Creative writing: LLMs can be used to generate creative text, such as poems, stories, and scripts.

LLMs are still under development, but they have the potential to revolutionize a wide range of industries. For example, LLMs could be used to improve customer service, create more personalized marketing campaigns, and develop new products and services.
---------------------------
Some of the most well-known LLMs include:

* GPT-3: Developed by OpenAI, GPT-3 is a large language model that can generate text, translate languages, write different kinds of creative content, and answer your questions in an informative way.
* LaMDA: Developed by Google, LaMDA is a large language model that can chat with you in an open-ended way, answering your questions, telling stories, and providing different kinds of creative content.
* PaLM 2: Developed by Google, PaLM 2 is a large language model that can perform a wide range of tasks, including machine translation, question answering, and text summarization.
* T5: Developed by Google, T5 is a large language model that can be used for a variety of tasks, including text summarization, question answering, and code generation.

These are just a few examples of the many LLMs that are currently being developed. As LLMs continue to improve, they are likely to play an increasingly important role in our lives.

BUILD SUCCESSFUL in 25s
2 actionable tasks: 2 executed

PaLM ได้ตอบคำถามที่เกี่ยวข้องของคุณ 3 ข้อแล้ว

เครื่องมือสร้าง VertexAIChatModel ให้คุณกำหนดพารามิเตอร์ที่ไม่บังคับซึ่งมีค่าเริ่มต้นบางส่วนที่คุณลบล้างได้อยู่แล้ว ตัวอย่างเช่น

  • .temperature(0.2) — เพื่อกำหนดความคิดสร้างสรรค์ที่คุณต้องการคำตอบ (0 หมายถึงความคิดสร้างสรรค์ต่ำและมักเป็นข้อเท็จจริงมากกว่า ส่วน 1 คือสำหรับเอาต์พุตครีเอทีฟโฆษณามากกว่า)
  • .maxOutputTokens(50) — ในตัวอย่างนี้มีการขอโทเค็น 400 รายการ (โทเค็น 3 รายการโดยประมาณจะเท่ากับคำ 4 คำ) ขึ้นอยู่กับระยะเวลาที่คุณต้องการให้คำตอบที่สร้างขึ้น
  • .topK(20) — เพื่อสุ่มเลือกคำจากจำนวนคำที่เป็นไปได้สูงสุดสำหรับการเติมข้อความ (ตั้งแต่ 1 ถึง 40)
  • .topP(0.95) — เพื่อเลือกคำที่เป็นไปได้ซึ่งความน่าจะเป็นทั้งหมดรวมกันได้จำนวนทศนิยมดังกล่าว (ระหว่าง 0 ถึง 1)
  • .maxRetries(3) — ในกรณีที่คุณเรียกใช้คำขอเกินโควต้าต่อโควต้า คุณสามารถให้โมเดลลองเรียกใช้อีกครั้งได้ 3 ครั้ง เช่น

5. แชทบ็อตที่มีประโยชน์พร้อมตัวตน

ในส่วนก่อนหน้านี้ คุณเริ่มถามคำถามกับแชทบ็อต LLM ได้ทันทีโดยไม่ได้ให้บริบทใดๆ เป็นพิเศษ แต่คุณสามารถทำให้แชทบ็อตมีความเชี่ยวชาญได้ เพื่อให้เป็นผู้เชี่ยวชาญในงานใดงานหนึ่งหรือหัวข้อใดหัวข้อหนึ่ง

คุณจะทำอย่างไร กำหนดการทำงาน: อธิบายงานที่ทำอยู่ บริบท ยกตัวอย่าง 2-3 อย่างของสิ่งที่ต้องทำ ลักษณะตัวตน รูปแบบที่คุณต้องการรับคำตอบ และอาจเป็นน้ำเสียงก็ได้หากคุณต้องการให้แชทบ็อตทำงานในลักษณะใดลักษณะหนึ่ง

บทความเกี่ยวกับการสร้างพรอมต์แสดงวิธีการนี้เป็นอย่างดีด้วยกราฟิกนี้

8a4c67679dcbd085.png

https://medium.com/@eldatero/master-the-perfect-chatgpt-prompt-formula-c776adae8f19

ในการอธิบายประเด็นนี้ ลองหาแรงบันดาลใจจากเว็บไซต์ prompts.chat ที่แสดงรายการไอเดียดีๆ และสนุกๆ มากมายของแชทบ็อตที่กำหนดเองเพื่อให้พวกเขาทำสิ่งต่างๆ ได้ดังนี้

มีตัวอย่างหนึ่งในการเปลี่ยนแชทบ็อต LLM ให้เป็นนักหมากรุก! เรามาดูกันเลย

อัปเดตชั้นเรียน ChatPrompts ดังนี้

package palm.workshop;

import dev.langchain4j.chain.ConversationalChain;
import dev.langchain4j.data.message.SystemMessage;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.vertexai.VertexAiChatModel;
import dev.langchain4j.store.memory.chat.InMemoryChatMemoryStore;

public class ChatPrompts {
    public static void main(String[] args) {
        VertexAiChatModel model = VertexAiChatModel.builder()
            .endpoint("us-central1-aiplatform.googleapis.com:443")
            .project("YOUR_PROJECT_ID")
            .location("us-central1")
            .publisher("google")
            .modelName("chat-bison@001")
            .maxOutputTokens(7)
            .maxRetries(3)
            .build();

        InMemoryChatMemoryStore chatMemoryStore = new InMemoryChatMemoryStore();

        MessageWindowChatMemory chatMemory = MessageWindowChatMemory.builder()
            .chatMemoryStore(chatMemoryStore)
            .maxMessages(200)
            .build();

        chatMemory.add(SystemMessage.from("""
            You're an expert chess player with a high ELO ranking.
            Use the PGN chess notation to reply with the best next possible move.
            """
        ));


        ConversationalChain chain = ConversationalChain.builder()
            .chatLanguageModel(model)
            .chatMemory(chatMemory)
            .build();

        String pgn = "";
        String[] whiteMoves = { "Nf3", "c4", "Nc3", "e3", "Dc2", "Cd5"};
        for (int i = 0; i < whiteMoves.length; i++) {
            pgn += " " + (i+1) + ". " + whiteMoves[i];
            System.out.println("Playing " + whiteMoves[i]);
            pgn = chain.execute(pgn);
            System.out.println(pgn);
        }
    }
}

เรามาดูรายละเอียดกันทีละขั้นตอน

  • ต้องนำเข้าใหม่บางรายการเพื่อจัดการความทรงจำของแชท
  • คุณสร้างโมเดลแชทขึ้นมา แต่ด้วยจำนวนโทเค็นสูงสุดจำนวนไม่มาก (สูงสุด 7 โทเค็น) เนื่องจากเราเพียงต้องการสร้างบทสนทนาต่อไป ไม่ใช่วิทยานิพนธ์เกี่ยวกับหมากรุกทั้งเรื่อง
  • ขั้นต่อไป คุณจะต้องสร้างที่เก็บความทรงจำของแชทเพื่อบันทึกการสนทนาผ่านแชท
  • คุณสร้างความทรงจำจริงของแชทในโหมดหน้าต่างเพื่อเก็บการย้ายครั้งล่าสุด
  • คุณเพิ่ม "ระบบ" ในความทรงจำของแชท ที่ให้คำแนะนำโมเดลการแชทเกี่ยวกับผู้ที่ควรจะเป็น (เช่น นักเล่นหมากรุกผู้เชี่ยวชาญ) "ระบบ" ข้อความจะเพิ่มบริบทบางอย่าง ในขณะที่ "ผู้ใช้" และ "AI" ข้อความคือการสนทนาที่แท้จริง
  • คุณสร้างห่วงโซ่การสนทนาที่รวมความทรงจำและรูปแบบการแชทเข้าด้วยกัน
  • แล้วเราก็มีมาตรการสำหรับคนผิวขาว ซึ่งคุณกำลังทำซ้ำ ห่วงโซ่จะดำเนินการกับการเคลื่อนไหวสีขาวถัดไปทุกครั้ง และโมเดลการแชทจะตอบกลับด้วยการเคลื่อนไหวที่ดีที่สุดครั้งต่อไป

เมื่อเรียกใช้คลาสนี้ด้วยการย้ายดังกล่าว คุณควรเห็นผลลัพธ์ต่อไปนี้

$ ./gradlew run -DjavaMainClass=palm.workshop.ChatPrompts
Starting a Gradle Daemon (subsequent builds will be faster)

> Task :app:run
Playing Nf3
1... e5
Playing c4
2... Nc6
Playing Nc3
3... Nf6
Playing e3
4... Bb4
Playing Dc2
5... O-O
Playing Cd5
6... exd5

ว้าว PaLM รู้วิธีเล่นหมากรุกไหม ก็ไม่ได้เหมือนกันหรอก แต่ระหว่างการฝึก โมเดลต้องเห็นการแสดงความคิดเห็นเกี่ยวกับเกมหมากรุก หรือแม้แต่ไฟล์ PGN (Portable Game Notation) ของเกมในอดีตด้วย แชทบ็อตนี้ไม่น่าจะชนะ AlphaZero (AI ที่เอาชนะผู้เล่น Go, Shogi และ Chess ที่เก่งที่สุด) และบทสนทนาอาจตกลงไปในทิศทางอื่นๆ โดยโมเดลจะจำสถานะจริงของเกมไม่ได้เลย

รูปแบบการแชทมีประสิทธิภาพมากและสร้างการโต้ตอบที่สมบูรณ์กับผู้ใช้ และจัดการงานตามบริบทต่างๆ ได้ ในส่วนถัดไป เราจะพูดถึงงานที่มีประโยชน์ นั่นคือการดึงข้อมูลที่มีโครงสร้างออกจากข้อความ

6. การดึงข้อมูลจากข้อความที่ไม่มีโครงสร้าง

ในส่วนก่อนหน้านี้ คุณสร้างการสนทนาระหว่างผู้ใช้กับโมเดลภาษาแชท แต่เมื่อใช้ LangChain4J คุณจะสามารถใช้โมเดลการแชทเพื่อดึงข้อมูลที่มีโครงสร้างจากข้อความที่ไม่มีโครงสร้างได้

สมมติว่าคุณต้องการแยกชื่อและอายุของบุคคลหนึ่งจากประวัติหรือคำอธิบายของบุคคลนั้น คุณสามารถสั่งให้โมเดลภาษาขนาดใหญ่สร้างโครงสร้างข้อมูล JSON ได้ด้วยพรอมต์ที่ปรับแต่งอย่างชาญฉลาด (เรียกกันโดยทั่วไปว่า "prompt Engineering")

คุณจะอัปเดตชั้นเรียน ChatPrompts ดังนี้

package palm.workshop;

import dev.langchain4j.model.vertexai.VertexAiChatModel;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.service.UserMessage;

public class ChatPrompts {

    static class Person {
        String name;
        int age;
    }

    interface PersonExtractor {
        @UserMessage("""
            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:
            ---
            {{it}}
            ---
            JSON: 
            """)
        Person extractPerson(String text);
    }

    public static void main(String[] args) {
        VertexAiChatModel model = VertexAiChatModel.builder()
            .endpoint("us-central1-aiplatform.googleapis.com:443")
            .project("YOUR_PROJECT_ID")
            .location("us-central1")
            .publisher("google")
            .modelName("chat-bison@001")
            .maxOutputTokens(300)
            .build();
        
        PersonExtractor extractor = AiServices.create(PersonExtractor.class, model);

        Person person = extractor.extractPerson("""
            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.    
            """
        );

        System.out.println(person.name);
        System.out.println(person.age);
    }
}

มาดูขั้นตอนต่างๆ ในไฟล์นี้กัน

  • ชั้นเรียน Person ได้รับการกำหนดให้แสดงรายละเอียดที่อธิบายบุคคล (ชื่อและอายุ)
  • อินเทอร์เฟซ PersonExtractor สร้างขึ้นด้วยเมธอดที่ส่งกลับอินสแตนซ์ Person ที่สร้างอินสแตนซ์แล้วเมื่อมีสตริงข้อความที่ไม่มีโครงสร้าง
  • extractPerson() มีคำอธิบายประกอบด้วยคำอธิบายประกอบ @UserMessage ที่เชื่อมโยงพรอมต์เข้ากับคำอธิบายประกอบ นั่นคือพรอมต์ที่โมเดลจะใช้เพื่อดึงข้อมูลและแสดงผลรายละเอียดในรูปแบบของเอกสาร JSON ซึ่งจะมีการแยกวิเคราะห์ให้คุณและยกเลิกการกำหนดค่าเป็นอินสแตนซ์ Person

คราวนี้มาดูเนื้อหาของเมธอด main() กัน

  • ระบบจะสร้างอินสแตนซ์โมเดลแชท
  • ออบเจ็กต์ PersonExtractor สร้างขึ้นด้วยคลาส AiServices ของ LangChain4J
  • จากนั้นคุณจะเรียกใช้ Person person = extractor.extractPerson(...) เพื่อดึงรายละเอียดของบุคคลดังกล่าวจากข้อความที่ไม่มีโครงสร้างได้ และเรียกอินสแตนซ์ Person ที่มีชื่อและอายุกลับมา

จากนั้นเรียกใช้คลาสด้วยคำสั่งต่อไปนี้

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

> Task :app:run
Anna
23

ได้ ฉันชื่อแอนนา อายุ 23 ปี

สิ่งที่น่าสนใจเป็นพิเศษสำหรับแนวทาง AiServices นี้คือคุณดำเนินการกับออบเจ็กต์ที่มีการพิมพ์อย่างเข้มงวด คุณไม่ได้โต้ตอบกับ LLM ของแชทโดยตรง แต่คุณจะทำงานกับคลาสที่เป็นรูปธรรม เช่น คลาส Person เพื่อแสดงข้อมูลส่วนบุคคลที่ดึงมา และคุณมีคลาส PersonExtractor ที่มีเมธอด extractPerson() ซึ่งแสดงผลอินสแตนซ์ Person แนวคิดของ LLM หายไป และในฐานะนักพัฒนาซอฟต์แวร์ Java คุณเพียงแค่ต้องคอยจัดการคลาสและออบเจ็กต์ปกติ

7. ดึงข้อมูล Augmented Generation: แชทกับเอกสาร

กลับมาที่การสนทนาต่อ ครั้งนี้คุณจะสามารถถามคำถามเกี่ยวกับเอกสารของคุณ คุณจะสร้างแชทบ็อตที่สามารถเรียกข้อมูลที่เกี่ยวข้องจากฐานข้อมูลของข้อมูลที่ดึงมาจากเอกสารของคุณ และโมเดลจะใช้ข้อมูลนั้นเพื่อ "บด" คำตอบ แทนการพยายามสร้างคำตอบที่มาจากการฝึก รูปแบบนี้เรียกว่า RAG หรือ Retrieval Augmented Generation

ในการดึงข้อมูล Augmented Generation โดยสังเขปจะแบ่งเป็น 2 ระยะ ดังนี้

  1. ระยะการส่งผ่านข้อมูล - ระบบจะโหลดเอกสาร แยกส่วนเล็กๆ และแสดงเวกเตอร์ ("การฝังเวกเตอร์") ใน "ฐานข้อมูลเวกเตอร์" ที่ใช้ค้นหาเชิงความหมายได้

6c5bb5cb2e3b8088.png

  1. ระยะการค้นหา - ตอนนี้ผู้ใช้สามารถถามคำถามแชทบ็อตเกี่ยวกับเอกสารประกอบได้ ระบบจะแปลงคำถามเป็นเวกเตอร์ด้วย และเปรียบเทียบกับเวกเตอร์อื่นๆ ทั้งหมดในฐานข้อมูล เวกเตอร์ที่คล้ายกันมากที่สุดมักจะเกี่ยวข้องกันในเชิงความหมาย และจะแสดงโดยฐานข้อมูลเวกเตอร์ จากนั้น LLM จะได้รับบริบทของการสนทนา ตัวอย่างข้อความที่สอดคล้องกับเวกเตอร์ที่ฐานข้อมูลแสดงผล และระบบจะขอให้ระบบพิจารณาคำตอบด้วยการดูที่ตัวอย่างข้อมูลเหล่านั้น

2c279c506d7606cd.png

การเตรียมเอกสาร

ในการสาธิตใหม่นี้ คุณจะได้ถามคำถามเกี่ยวกับสถาปัตยกรรมโครงข่ายระบบประสาทเทียม "Transformer" ที่ Google เป็นผู้บุกเบิก และการนำโมเดลภาษาขนาดใหญ่ที่ทันสมัยทั้งหมดมาใช้ในปัจจุบัน

คุณสามารถเรียกดูเอกสารงานวิจัยที่อธิบายสถาปัตยกรรมนี้ ("Attention is all you need") โดยใช้คำสั่ง wget เพื่อดาวน์โหลดไฟล์ PDF จากอินเทอร์เน็ต

wget -O attention-is-all-you-need.pdf \
    https://proceedings.neurips.cc/paper_files/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf

การใช้เชนการดึงข้อมูลแบบบทสนทนา

เราจะมาสำรวจวิธีสร้างแนวทางแบบ 2 ระยะทีละส่วน โดยเริ่มจากการนำเข้าเอกสาร แล้วจึงตามด้วยเวลาสืบค้นเมื่อผู้ใช้ถามคำถามเกี่ยวกับเอกสาร

การนำเข้าเอกสาร

ขั้นตอนแรกสุดของการนำเข้าเอกสารคือการค้นหาไฟล์ PDF ที่เราดาวน์โหลดไว้ และเตรียม PdfParser ไว้อ่านเอกสาร โดยดำเนินการดังนี้

PdfDocumentParser pdfParser = new PdfDocumentParser();
Document document = pdfParser.parse(
    new FileInputStream(new File("/home/YOUR_USER_NAME/palm-workshop/attention-is-all-you-need.pdf")));

ก่อนหน้านี้ คุณจะต้องสร้างอินสแตนซ์ของโมเดล "การฝัง" แทนที่จะสร้างโมเดลภาษาแชทตามปกติ ซึ่งเป็นโมเดลและปลายทางเฉพาะที่มีบทบาทในการสร้างการแสดงเวกเตอร์ของส่วนข้อความ (คำ ประโยค หรือแม้แต่ย่อหน้า)

VertexAiEmbeddingModel embeddingModel = VertexAiEmbeddingModel.builder()
    .endpoint("us-central1-aiplatform.googleapis.com:443")
    .project("YOUR_PROJECT_ID")
    .location("us-central1")
    .publisher("google")
    .modelName("textembedding-gecko@001")
    .maxRetries(3)
    .build();

ถัดไป คุณจะต้องมีชั้นเรียนต่างๆ เพื่อทำงานร่วมกันเพื่อทำสิ่งต่อไปนี้

  • โหลดและแบ่งเอกสาร PDF เป็นกลุ่ม
  • สร้างการฝังเวกเตอร์สำหรับกลุ่มเหล่านี้ทั้งหมด
InMemoryEmbeddingStore<TextSegment> embeddingStore = 
    new InMemoryEmbeddingStore<>();

EmbeddingStoreIngestor storeIngestor = EmbeddingStoreIngestor.builder()
    .documentSplitter(DocumentSplitters.recursive(500, 100))
    .embeddingModel(embeddingModel)
    .embeddingStore(embeddingStore)
    .build();
storeIngestor.ingest(document);

EmbeddingStoreRetriever retriever = EmbeddingStoreRetriever.from(embeddingStore, embeddingModel);

อินสแตนซ์ของ InMemoryEmbeddingStore ซึ่งเป็นฐานข้อมูลเวกเตอร์ในหน่วยความจำ สร้างขึ้นเพื่อจัดเก็บการฝังเวกเตอร์

เอกสารจะแบ่งออกเป็นส่วนๆ จากชั้นเรียน DocumentSplitters ไฟล์ PDF จะแยกข้อความในไฟล์ PDF เป็นตัวอย่างอักขระ 500 ตัว โดยมีอักขระซ้อนทับกัน 100 ตัว (โดยแบ่งส่วนต่อๆ ไปเพื่อหลีกเลี่ยงการตัดคำหรือประโยคทีละส่วน)

"ผู้นำเข้า" ของร้านค้า จะลิงก์ตัวแยกเอกสาร โมเดลที่ฝังเพื่อคำนวณเวกเตอร์ และฐานข้อมูลเวกเตอร์ในหน่วยความจำ จากนั้นเมธอด ingest() จะดำเนินการนำเข้า

ในตอนนี้ระยะแรกได้จบลงแล้ว เอกสารจะถูกเปลี่ยนรูปแบบให้เป็นกลุ่มข้อความซึ่งมีการฝังเวกเตอร์ที่เกี่ยวข้อง และจัดเก็บไว้ในฐานข้อมูลเวกเตอร์

การถามคำถาม

ได้เวลาเตรียมพร้อมถามคำถามแล้ว คุณสร้างรูปแบบแชทปกติเพื่อเริ่มการสนทนาได้ ดังนี้

VertexAiChatModel model = VertexAiChatModel.builder()
    .endpoint("us-central1-aiplatform.googleapis.com:443")
    .project("YOUR_PROJECT_ID")
    .location("us-central1")
    .publisher("google")
    .modelName("chat-bison@001")
    .maxOutputTokens(1000)
    .build();

นอกจากนี้ คุณจะต้องมีคลาส "retriever" ที่จะลิงก์ฐานข้อมูลเวกเตอร์ (ในตัวแปร embeddingStore) และโมเดลการฝัง หน้าที่ของมันคือการค้นหาฐานข้อมูลเวกเตอร์ด้วยการคำนวณเวกเตอร์ที่ฝังสำหรับการค้นหาของผู้ใช้ เพื่อค้นหาเวกเตอร์ที่คล้ายกันในฐานข้อมูล

EmbeddingStoreRetriever retriever = 
    EmbeddingStoreRetriever.from(embeddingStore, embeddingModel);

ณ จุดนี้ คุณสามารถสร้างอินสแตนซ์ ConversationalRetrievalChain คลาส (ซึ่งเป็นชื่ออื่นสำหรับรูปแบบ Retrieval Augmented Generation):

ConversationalRetrievalChain rag = ConversationalRetrievalChain.builder()
    .chatLanguageModel(model)
    .retriever(retriever)
    .promptTemplate(PromptTemplate.from("""
        Answer to the following query the best as you can: {{question}}
        Base your answer on the information provided below:
        {{information}}
        """
    ))
    .build();

"เชน" นี้ จะเชื่อมโยงกัน:

  • โมเดลภาษาการแชทที่คุณกำหนดค่าไว้ก่อนหน้านี้
  • รีทรีฟเวอร์จะเปรียบเทียบการค้นหาที่ฝังเวกเตอร์กับเวกเตอร์ในฐานข้อมูล
  • เทมเพลตพรอมต์บอกอย่างชัดเจนว่าโมเดลแชทควรตอบกลับโดยอ้างอิงคำตอบจากข้อมูลที่ระบุ (เช่น ข้อความที่เกี่ยวข้องซึ่งตัดตอนมาจากเอกสารซึ่งมีการฝังเวกเตอร์ที่คล้ายกับเวกเตอร์ของคำถามของผู้ใช้)

ในที่สุดคุณก็พร้อมจะถามคำถามแล้ว

String result = rag.execute("What neural network architecture can be used for language models?");
System.out.println(result);
System.out.println("------------");

result = rag.execute("What are the different components of a transformer neural network?");
System.out.println(result);
System.out.println("------------");

result = rag.execute("What is attention in large language models?");
System.out.println(result);
System.out.println("------------");

result = rag.execute("What is the name of the process that transforms text into vectors?");
System.out.println(result);

เรียกใช้โปรแกรมด้วย

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

คุณจะเห็นคําตอบในเอาต์พุตดังนี้

The Transformer is a neural network architecture that can be used for 
language models. It is based solely on attention mechanisms, dispensing 
with recurrence and convolutions. The Transformer has been shown to 
outperform recurrent neural networks and convolutional neural networks on 
a variety of language modeling tasks.
------------
The Transformer is a neural network architecture that can be used for 
language models. It is based solely on attention mechanisms, dispensing 
with recurrence and convolutions. The Transformer has been shown to 
outperform recurrent neural networks and convolutional neural networks on a 
variety of language modeling tasks. The Transformer consists of an encoder 
and a decoder. The encoder is responsible for encoding the input sequence 
into a fixed-length vector representation. The decoder is responsible for 
decoding the output sequence from the input sequence. The decoder uses the 
attention mechanism to attend to different parts of the input sequence when 
generating the output sequence.
------------
Attention is a mechanism that allows a neural network to focus on specific 
parts of an input sequence. In the context of large language models, 
attention is used to allow the model to focus on specific words or phrases 
in a sentence when generating output. This allows the model to generate 
more relevant and informative output.
------------
The process of transforming text into vectors is called word embedding. 
Word embedding is a technique that represents words as vectors in a 
high-dimensional space. The vectors are typically learned from a large 
corpus of text, and they capture the semantic and syntactic relationships 
between words. Word embedding has been shown to be effective for a variety 
of natural language processing tasks, such as machine translation, question 
answering, and sentiment analysis.

โซลูชันครบวงจร

ต่อไปนี้เป็นเนื้อหาทั้งหมดของชั้นเรียน ChatPrompts เพื่ออำนวยความสะดวกในการคัดลอกและวาง

package palm.workshop;

import dev.langchain4j.chain.ConversationalRetrievalChain;
import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.document.parser.PdfDocumentParser;
import dev.langchain4j.data.document.splitter.DocumentSplitters;
import dev.langchain4j.data.segment.TextSegment; 
import dev.langchain4j.model.input.PromptTemplate;
import dev.langchain4j.model.vertexai.VertexAiChatModel;
import dev.langchain4j.model.vertexai.VertexAiEmbeddingModel;
import dev.langchain4j.retriever.EmbeddingStoreRetriever;
import dev.langchain4j.store.embedding.EmbeddingStoreIngestor;
import dev.langchain4j.store.embedding.inmemory.InMemoryEmbeddingStore;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class ChatPrompts {
    public static void main(String[] args) throws IOException {
        PdfDocumentParser pdfParser = new PdfDocumentParser();
        Document document = pdfParser.parse(new FileInputStream(new File("/ABSOLUTE_PATH/attention-is-all-you-need.pdf")));

        VertexAiEmbeddingModel embeddingModel = VertexAiEmbeddingModel.builder()
            .endpoint("us-central1-aiplatform.googleapis.com:443")
            .project("YOUR_PROJECT_ID")
            .location("us-central1")
            .publisher("google")
            .modelName("textembedding-gecko@001")
            .maxRetries(3)
            .build();

        InMemoryEmbeddingStore<TextSegment> embeddingStore = 
            new InMemoryEmbeddingStore<>();

        EmbeddingStoreIngestor storeIngestor = EmbeddingStoreIngestor.builder()
            .documentSplitter(DocumentSplitters.recursive(500, 100))
            .embeddingModel(embeddingModel)
            .embeddingStore(embeddingStore)
            .build();
        storeIngestor.ingest(document);

        EmbeddingStoreRetriever retriever = EmbeddingStoreRetriever.from(embeddingStore, embeddingModel);

        VertexAiChatModel model = VertexAiChatModel.builder()
            .endpoint("us-central1-aiplatform.googleapis.com:443")
            .project("genai-java-demos")
            .location("us-central1")
            .publisher("google")
            .modelName("chat-bison@001")
            .maxOutputTokens(1000)
            .build();

        ConversationalRetrievalChain rag = ConversationalRetrievalChain.builder()
            .chatLanguageModel(model)
            .retriever(retriever)
            .promptTemplate(PromptTemplate.from("""
                Answer to the following query the best as you can: {{question}}
                Base your answer on the information provided below:
                {{information}}
                """
            ))
            .build();

        String result = rag.execute("What neural network architecture can be used for language models?");
        System.out.println(result);
        System.out.println("------------");

        result = rag.execute("What are the different components of a transformer neural network?");
        System.out.println(result);
        System.out.println("------------");

        result = rag.execute("What is attention in large language models?");
        System.out.println(result);
        System.out.println("------------");

        result = rag.execute("What is the name of the process that transforms text into vectors?");
        System.out.println(result);
    }
}

8. ขอแสดงความยินดี

ขอแสดงความยินดี คุณได้สร้างแอปพลิเคชันแชท Generative AI แอปแรกใน Java โดยใช้ LangChain4J และ PaLM API เรียบร้อยแล้ว ระหว่างทางคุณได้ค้นพบว่าโมเดลการแชทภาษาขนาดใหญ่นั้นมีประสิทธิภาพและสามารถจัดการงานต่างๆ ได้ เช่น การถาม/การตอบคำถาม แม้แต่ในเอกสารประกอบ การดึงข้อมูล และบางครั้งก็ยังเล่นหมากรุกได้อีกด้วย

สิ่งที่ต้องทำต่อไป

ลองดู Codelab ต่อไปนี้เพื่อศึกษาเพิ่มเติมเกี่ยวกับ PaLM ใน Java

อ่านเพิ่มเติม

เอกสารอ้างอิง