1. Pengantar
Terakhir Diperbarui: 05-02-2024
Apa itu AI Generatif
AI generatif atau kecerdasan buatan generatif mengacu pada penggunaan AI untuk membuat konten baru, seperti teks, gambar, musik, audio, dan video.
AI generatif didukung oleh model dasar (model AI besar) yang dapat melakukan beberapa tugas sekaligus dan melakukan tugas siap pakai, termasuk perangkuman, tanya jawab, klasifikasi, dan sebagainya. Selain itu, dengan sedikit pelatihan, model dasar dapat diadaptasikan untuk kasus penggunaan tertarget dengan data contoh yang sangat sedikit.
Bagaimana cara kerja AI Generatif?
AI generatif bekerja menggunakan model ML (Machine Learning) untuk mempelajari pola dan hubungan dalam set data yang terdiri dari konten buatan manusia. Sistem ini kemudian menggunakan pola-pola yang telah dipelajarinya untuk membuat konten baru.
Cara yang paling umum digunakan untuk melatih model AI generatif adalah dengan menggunakan pembelajaran yang diawasi atau supervised learning, yakni model AI generatif diberi satu set konten buatan manusia dan label yang sesuai. AI generatif kemudian belajar membuat konten yang serupa dengan konten buatan manusia tersebut dan diberi label yang sama.
Apa saja penerapan umum AI Generatif?
AI generatif memproses konten yang sangat banyak, membuat insight dan jawaban melalui teks, gambar, dan format yang mudah digunakan. AI generatif dapat digunakan untuk:
- Meningkatkan interaksi pelanggan melalui chat dan pengalaman penelusuran yang ditingkatkan kualitasnya
- Menjelajahi jumlah data tak terstruktur yang sangat banyak melalui antarmuka percakapan dan perangkuman
- Membantu pelaksanaan tugas berulang, seperti membalas permintaan proposal (RFP), melokalkan konten pemasaran dalam lima bahasa, dan memeriksa kontrak pelanggan terkait kepatuhan, dan lainnya
Penawaran AI Generatif seperti apa yang dimiliki Google Cloud?
Dengan Vertex AI, Anda dapat berinteraksi dengan model dasar, menyesuaikannya, dan menyematkannya ke aplikasi Anda tanpa memerlukan keahlian ML. Anda dapat mengakses model dasar di Model Garden, menyesuaikan berbagai model melalui UI yang sederhana di Generative AI Studio, atau menggunakan model dalam notebook data science.
Vertex AI Search and Conversation menawarkan cara tercepat bagi para developer untuk membangun mesin telusur dan chatbot yang didukung teknologi AI generatif.
Selain itu, Duet AI adalah kolaborator yang didukung teknologi AI yang tersedia di seluruh Google Cloud dan IDE untuk membantu Anda menyelesaikan lebih banyak pekerjaan dengan lebih cepat.
Apa yang menjadi fokus codelab ini?
Codelab ini berfokus pada Model Bahasa Besar (LLM) PaLM 2, yang dihosting di Vertex AI Google Cloud yang mencakup semua produk dan layanan machine learning.
Anda akan menggunakan Java untuk berinteraksi dengan PaLM API, bersama dengan orkestrator framework LLM LangChain4J. Anda akan mempelajari berbagai contoh konkret untuk memanfaatkan LLM dalam menjawab pertanyaan, menghasilkan ide, mengekstrak konten terstruktur dan entitas, serta melakukan peringkasan.
Beri tahu saya lebih lanjut tentang framework LangChain4J.
Framework LangChain4J adalah library open source untuk mengintegrasikan model bahasa besar dalam aplikasi Java Anda, dengan mengatur berbagai komponen, seperti LLM itu sendiri, tetapi juga alat lain seperti database vektor (untuk penelusuran semantik), loader dan splitter dokumen (untuk menganalisis dokumen dan mempelajarinya), parser output, dan banyak lagi.
Yang akan Anda pelajari
- Cara menyiapkan project Java untuk menggunakan PaLM dan LangChain4J
- Cara mengekstrak informasi yang berguna dari konten tidak terstruktur (ekstraksi entitas atau kata kunci, output dalam JSON)
- Cara membuat percakapan dengan pengguna
- Cara menggunakan model chat untuk mengajukan pertanyaan tentang dokumentasi Anda sendiri
Yang Anda butuhkan
- Pengetahuan tentang bahasa pemrograman Java
- Project Google Cloud
- Browser, seperti Chrome atau Firefox
2. Penyiapan dan persyaratan
Penyiapan lingkungan mandiri
- Login ke Google Cloud Console dan buat project baru atau gunakan kembali project yang sudah ada. Jika belum memiliki akun Gmail atau Google Workspace, Anda harus membuatnya.
- Project name adalah nama tampilan untuk peserta project ini. String ini adalah string karakter yang tidak digunakan oleh Google API. Anda dapat memperbaruinya kapan saja.
- Project ID bersifat unik di semua project Google Cloud dan tidak dapat diubah (tidak dapat diubah setelah ditetapkan). Cloud Console otomatis membuat string unik; biasanya Anda tidak mementingkan kata-katanya. Di sebagian besar codelab, Anda harus merujuk Project ID-nya (umumnya diidentifikasi sebagai
PROJECT_ID). Jika tidak suka dengan ID yang dibuat, Anda dapat membuat ID acak lainnya. Atau, Anda dapat mencobanya sendiri, dan lihat apakah ID tersebut tersedia. ID tidak dapat diubah setelah langkah ini dan tersedia selama durasi project. - Sebagai informasi, ada nilai ketiga, Project Number, yang digunakan oleh beberapa API. Pelajari lebih lanjut ketiga nilai ini di dokumentasi.
- Selanjutnya, Anda harus mengaktifkan penagihan di Konsol Cloud untuk menggunakan resource/API Cloud. Menjalankan operasi dalam codelab ini tidak akan memakan banyak biaya, bahkan mungkin tidak sama sekali. Guna mematikan resource agar tidak menimbulkan penagihan di luar tutorial ini, Anda dapat menghapus resource yang dibuat atau menghapus project-nya. Pengguna baru Google Cloud memenuhi syarat untuk mengikuti program Uji Coba Gratis senilai $300 USD.
Mulai Cloud Shell
Meskipun Google Cloud dapat dioperasikan dari jarak jauh menggunakan laptop Anda, dalam codelab ini, Anda akan menggunakan Cloud Shell, lingkungan command line yang berjalan di Cloud.
Mengaktifkan Cloud Shell
- Dari Cloud Console, klik Aktifkan Cloud Shell
.
Jika ini adalah pertama kalinya Anda memulai Cloud Shell, Anda akan melihat layar perantara yang menjelaskan apa itu Cloud Shell. Jika Anda melihat layar perantara, klik Continue.
Perlu waktu beberapa saat untuk menyediakan dan terhubung ke Cloud Shell.
Virtual machine ini dilengkapi dengan semua alat pengembangan yang diperlukan. VM ini menawarkan direktori beranda tetap sebesar 5 GB dan beroperasi di Google Cloud, sehingga sangat meningkatkan performa dan autentikasi jaringan. Sebagian besar pekerjaan Anda dalam codelab ini dapat dilakukan dengan browser.
Setelah terhubung ke Cloud Shell, Anda akan melihat bahwa Anda telah diautentikasi dan project telah ditetapkan ke project ID Anda.
- Jalankan perintah berikut di Cloud Shell untuk mengonfirmasi bahwa Anda telah diautentikasi:
gcloud auth list
Output perintah
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Jalankan perintah berikut di Cloud Shell untuk mengonfirmasi bahwa perintah gcloud mengetahui project Anda:
gcloud config list project
Output perintah
[core] project = <PROJECT_ID>
Jika tidak, Anda dapat menyetelnya dengan perintah ini:
gcloud config set project <PROJECT_ID>
Output perintah
Updated property [core/project].
3. Menyiapkan lingkungan pengembangan Anda
Dalam codelab ini, Anda akan menggunakan terminal dan editor kode Cloud Shell untuk mengembangkan program Java.
Mengaktifkan Vertex AI API
- Di konsol Google Cloud, pastikan nama project Anda ditampilkan di bagian atas konsol Google Cloud. Jika tidak, klik Pilih project untuk membuka Pemilih Project, lalu pilih project yang Anda inginkan.
- Jika Anda tidak berada di bagian Vertex AI pada konsol Google Cloud, lakukan hal berikut:
- Di bagian Penelusuran, masukkan Vertex AI, lalu tekan enter
- Di hasil penelusuran, klik Vertex AI. Dasbor Vertex AI akan muncul.
- Klik Enable All Recommended APIs di dasbor Vertex AI.
Tindakan ini akan mengaktifkan beberapa API, tetapi yang paling penting untuk codelab ini adalah aiplatform.googleapis.com, yang juga dapat Anda aktifkan di command line, di terminal Cloud Shell, dengan menjalankan perintah berikut:
$ gcloud services enable aiplatform.googleapis.com
Membuat struktur project dengan Gradle
Untuk membuat contoh kode Java, Anda akan menggunakan alat build Gradle dan Java versi 17. Untuk menyiapkan project dengan Gradle, di terminal Cloud Shell, buat direktori (di sini, palm-workshop), jalankan perintah gradle init di direktori tersebut:
$ 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
Anda akan mem-build aplikasi (opsi 2), menggunakan bahasa Java (opsi 3), tanpa menggunakan subproject (opsi 1), menggunakan sintaksis Groovy untuk file build (opsi 1), tidak menggunakan fitur build baru (opsi tidak), membuat pengujian dengan JUnit Jupiter (opsi 4), dan untuk nama project, Anda dapat menggunakan palm-workshop, dan begitu juga untuk paket sumber, Anda dapat menggunakan palm.workshop.
Struktur project akan terlihat seperti berikut:
├── gradle
│ └── ...
├── gradlew
├── gradlew.bat
├── settings.gradle
└── app
├── build.gradle
└── src
├── main
│ └── java
│ └── palm
│ └── workshop
│ └── App.java
└── test
└── ...
Mari perbarui file app/build.gradle untuk menambahkan beberapa dependensi yang diperlukan. Anda dapat menghapus dependensi guava jika ada, dan menggantinya dengan dependensi untuk project LangChain4J, dan library logging untuk menghindari pesan logger yang hilang:
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'
}
Ada 2 dependensi untuk LangChain4J:
- satu di project inti,
- dan satu untuk modul Vertex AI khusus.
Untuk menggunakan Java 17 dalam mengompilasi dan menjalankan program, tambahkan blok berikut di bawah blok plugins {}:
java {
toolchain {
languageVersion = JavaLanguageVersion.of(17)
}
}
Satu perubahan lagi yang perlu dilakukan: perbarui blok application dari app/build.gradle, agar pengguna dapat mengganti class utama untuk dijalankan di command line saat memanggil alat build:
application {
mainClass = providers.systemProperty('javaMainClass')
.orElse('palm.workshop.App')
}
Untuk memeriksa apakah file build Anda siap menjalankan aplikasi, Anda dapat menjalankan class utama default yang mencetak pesan Hello World! sederhana:
$ ./gradlew run -DjavaMainClass=palm.workshop.App > Task :app:run Hello World! BUILD SUCCESSFUL in 3s 2 actionable tasks: 2 executed
Sekarang Anda siap memprogram dengan model teks bahasa besar PaLM, menggunakan project LangChain4J.
Sebagai referensi, berikut tampilan file build app/build.gradle lengkap sekarang:
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. Melakukan panggilan pertama ke model chat PaLM
Setelah project disiapkan dengan benar, saatnya memanggil PaLM API.
Buat class baru bernama ChatPrompts.java di direktori app/src/main/java/palm/workshop (bersama class App.java default), lalu ketik konten berikut:
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);
}
}
Dalam contoh pertama ini, Anda perlu mengimpor class VertexAiChatModel, dan ConversationalChain LangChain4J untuk mempermudah penanganan aspek multi-turn dalam percakapan.
Selanjutnya, dalam metode main, Anda akan mengonfigurasi model bahasa chat, dengan menggunakan builder untuk VertexAiChatModel, untuk menentukan:
- endpoint,
- proyek,
- wilayah,
- penerbit,
- dan nama model (
chat-bison@001).
Setelah model bahasa siap, Anda dapat menyiapkan ConversationalChain. Ini adalah abstraksi tingkat yang lebih tinggi yang ditawarkan oleh LangChain4J untuk mengonfigurasi berbagai komponen bersama-sama untuk menangani percakapan, seperti model bahasa chat itu sendiri, tetapi berpotensi komponen lain untuk menangani histori percakapan chat, atau untuk menghubungkan alat lain seperti pengambil untuk mengambil informasi dari database vektor. Namun, jangan khawatir, kita akan membahasnya lagi nanti dalam codelab ini.
Kemudian, Anda akan melakukan percakapan multi-turn dengan model chat, untuk mengajukan beberapa pertanyaan yang saling terkait. Pertama, Anda bertanya-tanya tentang LLM, lalu Anda bertanya apa yang dapat Anda lakukan dengan LLM, dan apa saja contohnya. Perhatikan bagaimana Anda tidak perlu mengulangi diri sendiri, LLM tahu bahwa "mereka" berarti LLM, dalam konteks percakapan tersebut.
Untuk melakukan percakapan multi-giliran tersebut, Anda cukup memanggil metode execute() pada rangkaian, yang akan menambahkannya ke konteks percakapan, model chat akan membuat balasan dan menambahkannya ke histori chat juga.
Untuk menjalankan class ini, jalankan perintah berikut di terminal Cloud Shell:
./gradlew run -DjavaMainClass=palm.workshop.ChatPrompts
Anda akan melihat output yang mirip dengan ini:
$ ./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 membalas 3 pertanyaan terkait Anda.
Builder VertexAIChatModel memungkinkan Anda menentukan parameter opsional yang sudah memiliki beberapa nilai default yang dapat Anda ganti. Berikut beberapa contohnya:
.temperature(0.2)— untuk menentukan seberapa kreatif respons yang Anda inginkan (0 berarti kreativitas rendah dan sering kali lebih faktual, sedangkan 1 berarti output yang lebih kreatif).maxOutputTokens(50)— dalam contoh, 400 token diminta (3 token kira-kira setara dengan 4 kata), bergantung pada panjang jawaban yang ingin Anda hasilkan.topK(20)— untuk memilih kata secara acak dari jumlah maksimum kata yang mungkin untuk penyelesaian teks (dari 1 hingga 40).topP(0.95)— untuk memilih kemungkinan kata yang total probabilitasnya sama dengan angka floating point tersebut (antara 0 dan 1).maxRetries(3)— jika Anda melampaui kuota permintaan per waktu, Anda dapat meminta model mencoba kembali panggilan 3 kali, misalnya
5. Chatbot yang berguna dan memiliki kepribadian.
Di bagian sebelumnya, Anda langsung mengajukan pertanyaan kepada chatbot LLM tanpa memberikan konteks tertentu. Namun, Anda dapat mengkhususkan chatbot tersebut untuk menjadi pakar dalam tugas tertentu, atau dalam topik tertentu.
Bagaimana Anda melakukannya? Dengan menyiapkan konteks: dengan menjelaskan tugas yang harus dilakukan LLM, konteksnya, mungkin memberikan beberapa contoh tentang apa yang harus dilakukan, persona yang harus dimiliki, format respons yang Anda inginkan, dan mungkin gaya bahasa, jika Anda ingin chatbot berperilaku dengan cara tertentu.
Artikel tentang membuat perintah ini mengilustrasikan pendekatan ini dengan baik menggunakan grafik ini:
https://medium.com/@eldatero/master-the-perfect-chatgpt-prompt-formula-c776adae8f19
Untuk menggambarkan hal ini, mari kita dapatkan beberapa inspirasi dari situs prompts.chat, yang mencantumkan banyak ide hebat dan menarik tentang chatbot yang dibuat khusus untuk bertindak sebagai:
- penerjemah emoji — untuk menerjemahkan pesan pengguna menjadi emoji
- pengoptimal perintah — untuk membuat perintah yang lebih baik
- peninjau jurnal — untuk membantu meninjau makalah penelitian
- penata gaya pribadi — untuk mendapatkan saran gaya pakaian
Ada satu contoh untuk mengubah chatbot LLM menjadi pemain catur. Mari kita terapkan.
Update class ChatPrompts sebagai berikut:
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);
}
}
}
Mari kita uraikan langkah demi langkah:
- Beberapa impor baru diperlukan untuk menangani memori chat.
- Anda membuat instance model chat, tetapi dengan jumlah token maksimum yang kecil (di sini 7), karena kita hanya ingin membuat langkah berikutnya, bukan seluruh disertasi tentang catur.
- Selanjutnya, Anda membuat penyimpanan memori chat untuk menyimpan percakapan chat.
- Anda membuat memori chat berjendela yang sebenarnya, untuk mempertahankan langkah terakhir.
- Di memori chat, Anda menambahkan pesan "sistem", yang menginstruksikan model chat tentang siapa yang seharusnya ia tiru (yaitu, pemain catur ahli). Pesan "sistem" menambahkan beberapa konteks, sedangkan pesan "pengguna" dan "AI" adalah diskusi yang sebenarnya.
- Anda membuat rangkaian percakapan yang menggabungkan memori dan model chat.
- Kemudian, kita memiliki daftar langkah untuk putih, yang Anda lakukan iterasi. Rantai ini dieksekusi dengan langkah putih berikutnya setiap kali, dan model chat membalas dengan langkah terbaik berikutnya.
Saat menjalankan class ini dengan langkah-langkah tersebut, Anda akan melihat output berikut:
$ ./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
Woh! PaLM tahu cara bermain catur? Sebenarnya tidak, tetapi selama pelatihannya, model tersebut pasti telah melihat beberapa komentar pertandingan catur, atau bahkan file PGN (Portable Game Notation) dari pertandingan sebelumnya. Namun, chatbot ini kemungkinan tidak akan menang melawan AlphaZero (AI yang mengalahkan pemain Go, Shogi, dan Catur terbaik) dan percakapan mungkin akan terhenti di kemudian hari, karena model tidak benar-benar mengingat status game yang sebenarnya.
Model chat sangat canggih, dapat menciptakan interaksi yang kaya dengan pengguna Anda, dan menangani berbagai tugas kontekstual. Di bagian berikutnya, kita akan melihat tugas yang berguna: mengekstraksi data terstruktur dari teks.
6. Mengekstrak informasi dari teks tidak terstruktur
Di bagian sebelumnya, Anda membuat percakapan antara pengguna dan model bahasa chat. Namun, dengan LangChain4J, Anda juga dapat menggunakan model chat untuk mengekstrak informasi terstruktur dari teks tidak terstruktur.
Misalkan Anda ingin mengekstrak nama dan usia seseorang, berdasarkan biografi atau deskripsi orang tersebut. Anda dapat menginstruksikan model bahasa besar untuk membuat struktur data JSON dengan perintah yang disesuaikan secara cerdas (ini biasanya disebut "rekayasa perintah").
Anda akan memperbarui class ChatPrompts sebagai berikut:
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);
}
}
Mari kita lihat berbagai langkah dalam file ini:
- Class
Personditentukan untuk merepresentasikan detail yang menjelaskan seseorang (nama dan usianya). - Antarmuka
PersonExtractordibuat dengan metode yang, jika diberi string teks tidak terstruktur, akan menampilkan instancePersonyang di-instansiasi. extractPerson()dianotasi dengan anotasi@UserMessageyang mengaitkan perintah dengannya. Itulah perintah yang akan digunakan model untuk mengekstrak informasi, dan menampilkan detail dalam bentuk dokumen JSON, yang akan diuraikan untuk Anda, dan di-unmarshal ke dalam instancePerson.
Sekarang, mari kita lihat konten metode main():
- Model chat di-instantiate.
- Objek
PersonExtractordibuat berkat classAiServicesLangChain4J. - Kemudian, Anda cukup memanggil
Person person = extractor.extractPerson(...)untuk mengekstrak detail orang tersebut dari teks tidak terstruktur, dan mendapatkan kembali instancePersondengan nama dan usia.
Sekarang, jalankan class ini dengan perintah berikut:
$ ./gradlew run -DjavaMainClass=palm.workshop.ChatPrompts > Task :app:run Anna 23
Ya. Ini Anna, dia berusia 23 tahun.
Yang menarik dari pendekatan AiServices ini adalah Anda beroperasi dengan objek yang sangat diketik. Anda tidak berinteraksi langsung dengan LLM chat. Sebagai gantinya, Anda bekerja dengan class konkret, seperti class Person untuk merepresentasikan informasi pribadi yang diekstrak, dan Anda memiliki class PersonExtractor dengan metode extractPerson() yang menampilkan instance Person. Konsep LLM diabstraksi, dan sebagai developer Java, Anda hanya memanipulasi class dan objek normal.
7. Retrieval-Augmented Generation: melakukan percakapan dengan dokumen Anda
Mari kembali ke percakapan. Kali ini, Anda dapat mengajukan pertanyaan tentang dokumen Anda. Anda akan membuat chatbot yang dapat mengambil informasi yang relevan dari database ekstrak dokumen Anda, dan informasi tersebut akan digunakan oleh model untuk "menemukan" jawabannya, bukan mencoba menghasilkan respons yang berasal dari pelatihannya. Pola ini disebut RAG, atau Retrieval-Augmented Generation.
Secara singkat, dalam Retrieval-Augmented Generation, ada dua fase:
- Fase penyerapan — Dokumen dimuat, dibagi menjadi potongan yang lebih kecil, dan representasi vektornya ("embedding vektor") disimpan dalam "database vektor" yang mampu melakukan penelusuran semantik.
- Fase kueri — Pengguna kini dapat mengajukan pertanyaan tentang dokumentasi kepada chatbot Anda. Pertanyaan juga akan diubah menjadi vektor, dan dibandingkan dengan semua vektor lain dalam database. Vektor yang paling mirip biasanya terkait secara semantik, dan ditampilkan oleh database vektor. Kemudian, LLM diberi konteks percakapan, cuplikan teks yang sesuai dengan vektor yang ditampilkan oleh database, dan diminta untuk mendasarkan jawabannya dengan melihat cuplikan tersebut.
Menyiapkan dokumen Anda
Untuk demo baru ini, Anda akan mengajukan pertanyaan tentang arsitektur jaringan neural "transformer", yang dipelopori oleh Google, yang merupakan cara semua model bahasa besar modern diimplementasikan saat ini.
Anda dapat mengambil makalah penelitian yang menjelaskan arsitektur ini ("Attention is all you need"), dengan menggunakan perintah wget untuk mendownload PDF dari internet:
wget -O attention-is-all-you-need.pdf \
https://proceedings.neurips.cc/paper_files/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf
Menerapkan rantai pengambilan percakapan
Mari kita pelajari langkah demi langkah cara membangun pendekatan 2 fase, pertama dengan penyerapan dokumen, lalu waktu kueri saat pengguna mengajukan pertanyaan tentang dokumen.
Penyerapan dokumen
Langkah pertama dalam fase penyerapan dokumen adalah menemukan file PDF yang kita download, dan menyiapkan PdfParser untuk membacanya:
PdfDocumentParser pdfParser = new PdfDocumentParser();
Document document = pdfParser.parse(
new FileInputStream(new File("/home/YOUR_USER_NAME/palm-workshop/attention-is-all-you-need.pdf")));
Sebelum membuat model bahasa chat biasa, Anda akan membuat instance model "embedding" terlebih dahulu. Model dan endpoint ini memiliki peran untuk membuat representasi vektor dari potongan teks (kata, kalimat, atau bahkan paragraf).
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();
Selanjutnya, Anda memerlukan beberapa kelas untuk berkolaborasi bersama untuk:
- Muat dan pisahkan dokumen PDF menjadi beberapa bagian.
- Buat embedding vektor untuk semua potongan ini.
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);
Instance InMemoryEmbeddingStore, database vektor dalam memori, dibuat untuk menyimpan embedding vektor.
Dokumen dibagi menjadi beberapa bagian berkat class DocumentSplitters. Teks file PDF akan dibagi menjadi cuplikan 500 karakter, dengan tumpang-tindih 100 karakter (dengan potongan berikutnya, untuk menghindari pemotongan kata atau kalimat, menjadi beberapa bagian).
"Ingestor" penyimpanan menautkan pemisah dokumen, model embedding untuk menghitung vektor, dan database vektor dalam memori. Kemudian, metode ingest() akan menangani penyerapan.
Sekarang, fase pertama telah selesai, dokumen telah diubah menjadi potongan teks dengan embedding vektor terkait, dan disimpan dalam database vektor.
Mengajukan pertanyaan
Saatnya bersiap untuk mengajukan pertanyaan. Model chat biasa dapat dibuat untuk memulai percakapan:
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();
Anda juga akan memerlukan class "pengambil" yang akan menautkan database vektor (dalam variabel embeddingStore) dan model embedding. Tugasnya adalah membuat kueri database vektor dengan menghitung embedding vektor untuk kueri pengguna, guna menemukan vektor serupa dalam database:
EmbeddingStoreRetriever retriever =
EmbeddingStoreRetriever.from(embeddingStore, embeddingModel);
Pada tahap ini, Anda dapat membuat instance class ConversationalRetrievalChain (ini hanyalah nama lain untuk pola 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();
"Rantai" ini mengikat:
- Model bahasa chat yang Anda konfigurasi sebelumnya.
- Pengambil membandingkan kueri embedding vektor dengan vektor dalam database.
- Template perintah secara eksplisit menyatakan bahwa model chat harus membalas dengan mendasarkan responsnya pada informasi yang diberikan (yaitu kutipan dokumentasi yang relevan yang embedding vektornya mirip dengan vektor pertanyaan pengguna).
Sekarang Anda siap mengajukan pertanyaan.
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);
Jalankan program dengan:
$ ./gradlew run -DjavaMainClass=palm.workshop.ChatPrompts
Dalam output, Anda akan melihat jawaban atas pertanyaan Anda:
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.
Solusi lengkap
Untuk mempermudah penyalinan dan penempelan, berikut konten lengkap class 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. Selamat
Selamat, Anda telah berhasil membuat aplikasi chat AI Generatif pertama Anda di Java menggunakan LangChain4J dan PaLM API. Selama prosesnya, Anda menemukan bahwa model chat bahasa besar cukup canggih dan mampu menangani berbagai tugas seperti tanya jawab, bahkan pada dokumentasi Anda sendiri, ekstraksi data, dan sampai batas tertentu, model ini bahkan mampu bermain Catur.
Apa selanjutnya?
Lihat beberapa codelab berikut untuk mempelajari lebih lanjut PaLM di Java:
Bacaan lebih lanjut
- Kasus penggunaan umum AI generatif
- Materi pelatihan tentang AI Generatif
- Berinteraksi dengan PaLM melalui Generative AI Studio
- Responsible AI