1. परिचय
पिछली बार अपडेट किए जाने की तारीख: 05-02-2024
जनरेटिव एआई क्या है
जनरेटिव एआई या जनरेटिव आर्टिफ़िशियल इंटेलिजेंस का मतलब है, एआई का इस्तेमाल करके नया कॉन्टेंट बनाना. जैसे, टेक्स्ट, इमेज, संगीत, ऑडियो, और वीडियो.
जनरेटिव एआई, फ़ाउंडेशन मॉडल (बड़े एआई मॉडल) की मदद से काम करता है. ये एक साथ कई तरह के काम कर सकते हैं. साथ ही, ये कई तरह के काम कर सकते हैं. जैसे, खास जानकारी देना, सवाल और जवाब देना, अलग-अलग कैटगरी बनाना वगैरह. साथ ही, आपको कम से कम ट्रेनिंग की ज़रूरत होती है. ऐसे में, फ़ाउंडेशन मॉडल को टारगेट किए गए उन उदाहरणों के मुताबिक ढाला जा सकता है जिनका इस्तेमाल सिर्फ़ उदाहरण के तौर पर किया जा सकता है.
जनरेटिव एआई कैसे काम करता है?
जनरेटिव एआई, एमएल (मशीन लर्निंग) मॉडल का इस्तेमाल करके, लोगों के बनाए गए कॉन्टेंट के डेटासेट के पैटर्न और संबंधों के बारे में बताता है. इसके बाद, वह सीखे गए पैटर्न का इस्तेमाल करके नया कॉन्टेंट जनरेट करता है.
जनरेटिव एआई मॉडल को ट्रेनिंग देने का सबसे सामान्य तरीका है, निगरानी में रखी गई लर्निंग का इस्तेमाल करना. इस मॉडल को इंसानों के बनाए गए कॉन्टेंट और उनसे जुड़े लेबल का एक सेट दिया जाता है. इसके बाद, वह ऐसा कॉन्टेंट जनरेट करना सीखता है जो इंसानों के बनाए गए कॉन्टेंट से मिलता-जुलता हो और जिसे एक जैसे लेबल के साथ लेबल किया गया हो.
जनरेटिव एआई का इस्तेमाल करने वाले आम ऐप्लिकेशन क्या हैं?
जनरेटिव एआई, बड़े पैमाने पर बनाया गया कॉन्टेंट प्रोसेस करता है. इस तरह, यह टेक्स्ट, इमेज, और लोगों के लिए आसान फ़ॉर्मैट के ज़रिए अहम जानकारी और जवाब तैयार करता है. जनरेटिव एआई का इस्तेमाल इन कामों के लिए किया जा सकता है:
- बेहतर चैट और खोज के अनुभव की मदद से, ग्राहकों के इंटरैक्शन को बेहतर बनाएं
- बातचीत वाले इंटरफ़ेस और खास जानकारी की मदद से, कई तरह के अनस्ट्रक्चर्ड डेटा को एक्सप्लोर करें
- यह सेवा बार-बार किए जाने वाले कामों में मदद करती है. जैसे, प्रस्तावों (आरएफ़पी) के अनुरोधों का जवाब देना, मार्केटिंग कॉन्टेंट को पांच भाषाओं में स्थानीय भाषा में उपलब्ध कराना, ग्राहक से कानूनी समझौते की शर्तों के पालन की जांच करना वगैरह
Google Cloud में जनरेटिव एआई की कौनसी सुविधाएं उपलब्ध हैं?
Vertex AI की मदद से, अपने ऐप्लिकेशन में बुनियादी मॉडल के साथ इंटरैक्ट करें, उन्हें पसंद के मुताबिक बनाएं, और एम्बेड करें — इसके लिए, मशीन लर्निंग की विशेषज्ञता की ज़रूरत नहीं होती है. मॉडल गार्डन पर फ़ाउंडेशन के मॉडल ऐक्सेस करें, जनरेटिव एआई Studio पर आसान यूआई से मॉडल ट्यून करें या डेटा साइंस नोटबुक में मॉडल इस्तेमाल करें.
Vertex AI Search and Conversation की मदद से डेवलपर, जनरेटिव एआई की मदद से काम करने वाले सर्च इंजन और चैटबॉट तेज़ी से बना सकते हैं.
Duet AI, एआई की मदद से काम करने वाला आपका सहयोगी है. यह Google Cloud और IDEs में इस्तेमाल किया जा सकता है. इससे आपको ज़्यादा तेज़ी से काम करने में मदद मिलती है.
यह कोडलैब किस पर फ़ोकस कर रहा है?
यह कोडलैब, Google Cloud Vertex AI पर होस्ट किए जाने वाले PaLM 2 लार्ज लैंग्वेज मॉडल (एलएलएम) पर फ़ोकस करता है. इसमें मशीन लर्निंग से जुड़े सभी प्रॉडक्ट और सेवाएं शामिल हैं.
आपको LangChain4J एलएलएम फ़्रेमवर्क ऑर्केस्ट्रेटर के साथ मिलकर, PaLM API के साथ इंटरैक्ट करने के लिए Java का इस्तेमाल करना होगा. एलएलएम का इस्तेमाल करके, आपको सवालों के जवाब देने, आइडिया जनरेट करने, कोई इकाई और स्ट्रक्चर्ड कॉन्टेंट निकालने, और खास जानकारी पाने में मदद करने के लिए, अलग-अलग तरह के सटीक उदाहरणों के बारे में बताया जाएगा.
मुझे LangChain4J फ़्रेमवर्क के बारे में और बताएं!
LangChain4J फ़्रेमवर्क एक ओपन सोर्स लाइब्रेरी है. इसकी मदद से, Java ऐप्लिकेशन में बड़े लैंग्वेज मॉडल इंटिग्रेट किए जाते हैं. इसके लिए, एलएलएम जैसे कई कॉम्पोनेंट को ऑर्केस्ट्रा किया जाता है. साथ ही, वेक्टर डेटाबेस (सिमेंटिक खोजों के लिए), दस्तावेज़ लोडर और स्प्लिटर (दस्तावेज़ों का विश्लेषण करने और उनसे सीखने के लिए), आउटपुट पार्सर वगैरह को व्यवस्थित किया जाता है.
आपको इनके बारे में जानकारी मिलेगी
- PaLM और LangChain4J का इस्तेमाल करने के लिए, Java प्रोजेक्ट कैसे सेट अप करें
- बिना स्ट्रक्चर वाले कॉन्टेंट (इकाई या कीवर्ड निकालने की सुविधा, JSON में आउटपुट) से काम की जानकारी निकालने का तरीका
- उपयोगकर्ताओं के साथ बातचीत शुरू करने का तरीका
- अपने दस्तावेज़ की मदद से सवाल पूछने के लिए, चैट मॉडल का इस्तेमाल करने का तरीका
आपको इन चीज़ों की ज़रूरत होगी
- Java प्रोग्रामिंग भाषा की जानकारी
- Google Cloud प्रोजेक्ट
- Chrome या Firefox जैसा कोई ब्राउज़र
2. सेटअप और ज़रूरी शर्तें
अपने हिसाब से एनवायरमेंट सेटअप करना
- Google Cloud Console में साइन इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास पहले से Gmail या Google Workspace खाता नहीं है, तो आपको नया खाता बनाना होगा.
- प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों का डिसप्ले नेम होता है. यह एक वर्ण स्ट्रिंग है, जिसका इस्तेमाल Google API नहीं करता. इसे कभी भी अपडेट किया जा सकता है.
- प्रोजेक्ट आईडी, Google Cloud के सभी प्रोजेक्ट के लिए यूनीक होता है. साथ ही, इसे बदला नहीं जा सकता. इसे सेट करने के बाद बदला नहीं जा सकता. Cloud Console, एक यूनीक स्ट्रिंग अपने-आप जनरेट करता है; आम तौर पर, आपको उसके होने की कोई परवाह नहीं होती. ज़्यादातर कोडलैब में, आपको अपना प्रोजेक्ट आईडी बताना होगा. आम तौर पर, इसकी पहचान
PROJECT_IDके रूप में की जाती है. अगर आपको जनरेट किया गया आईडी पसंद नहीं है, तो किसी भी क्रम में एक और आईडी जनरेट किया जा सकता है. दूसरा तरीका यह है कि आप खुद भी आज़माकर देखें कि वह उपलब्ध है या नहीं. इस चरण के बाद, इसे बदला नहीं जा सकता. साथ ही, यह प्रोजेक्ट के खत्म होने तक बना रहता है. - आपकी जानकारी के लिए, प्रोजेक्ट नंबर नाम की एक तीसरी वैल्यू दी गई है. इसका इस्तेमाल कुछ एपीआई करते हैं. दस्तावेज़ में इन तीनों वैल्यू के बारे में ज़्यादा जानें.
- इसके बाद, आपको क्लाउड संसाधनों/एपीआई का इस्तेमाल करने के लिए, Cloud Console में बिलिंग चालू करनी होगी. इस कोडलैब का इस्तेमाल करने पर, आपको ज़्यादा पैसे नहीं चुकाने होंगे. इस ट्यूटोरियल के अलावा, बिलिंग से बचने के लिए संसाधनों को बंद करें. इसके लिए, अपने बनाए गए संसाधनों को मिटाएं या प्रोजेक्ट को मिटाएं. Google Cloud के नए उपयोगकर्ता, 300 डॉलर के मुफ़्त ट्रायल वाले प्रोग्राम में हिस्सा ले सकते हैं.
Cloud Shell शुरू करना
Google Cloud को आपके लैपटॉप से, कहीं से भी ऑपरेट किया जा सकता है. हालांकि, इस कोडलैब में Cloud Shell का इस्तेमाल किया जा रहा है. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.
Cloud Shell चालू करें
- Cloud Console में, Cloud Shell चालू करें
पर क्लिक करें.
अगर आपने Cloud Shell का इस्तेमाल पहली बार किया है, तो आपको बीच में आने वाली स्क्रीन दिखेगी. इसमें यह बताया जाएगा कि यह क्या है. अगर आपको बीच के लेवल पर मिलने वाली स्क्रीन दिखती है, तो जारी रखें पर क्लिक करें.
प्रावधान करने और Cloud Shell से कनेक्ट होने में कुछ ही समय लगेगा.
इस वर्चुअल मशीन में डेवलपमेंट के सभी ज़रूरी टूल मौजूद हैं. इसमें लगातार पांच जीबी की होम डायरेक्ट्री मिलती है और यह Google Cloud में काम करती है. यह नेटवर्क की परफ़ॉर्मेंस और ऑथेंटिकेशन को बेहतर बनाने में मदद करती है. अगर सभी नहीं, तो इस कोडलैब में आपका बहुत सारा काम ब्राउज़र से किया जा सकता है.
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. डेवलपमेंट एनवायरमेंट को तैयार किया जा रहा है
इस कोडलैब में, Java प्रोग्राम डेवलप करने के लिए, Cloud Shell टर्मिनल और कोड एडिटर का इस्तेमाल किया जा रहा है.
Vertex AI API को चालू करें
- पक्का करें कि Google Cloud Console में, आपके प्रोजेक्ट का नाम Google Cloud Console में सबसे ऊपर दिख रहा हो. अगर ऐसा नहीं है, तो प्रोजेक्ट सिलेक्टर खोलने के लिए, कोई प्रोजेक्ट चुनें पर क्लिक करें और अपनी पसंद का प्रोजेक्ट चुनें.
- अगर आप Google Cloud Console के Vertex AI वर्शन में शामिल नहीं हैं, तो ये काम करें:
- Search में, Vertex AI डालें और वापस आएं
- खोज के नतीजों में, Vertex AI The Vertex AI डैशबोर्ड दिखेगा.
- Vertex AI डैशबोर्ड में, सुझाए गए सभी एपीआई चालू करें पर क्लिक करें.
ऐसा करने से कई एपीआई चालू हो जाएंगे, लेकिन कोडलैब के लिए सबसे ज़रूरी aiplatform.googleapis.com है. इसे Cloud Shell टर्मिनल में कमांड-लाइन पर भी चालू किया जा सकता है. इसके लिए, यह कमांड इस्तेमाल किया जा सकता है:
$ gcloud services enable aiplatform.googleapis.com
Gredle की मदद से प्रोजेक्ट स्ट्रक्चर बनाना
अपने 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
आपको ऐप्लिकेशन (दूसरा विकल्प), सब-प्रोजेक्ट का इस्तेमाल किए बिना (तीसरा विकल्प), सब-प्रोजेक्ट का इस्तेमाल किए बिना (पहला विकल्प), बिल्ड फ़ाइल के लिए ग्रूवी सिंटैक्स (विकल्प 1) का इस्तेमाल करके, नई बिल्ड सुविधाओं का इस्तेमाल न करें (विकल्प नंबर), JUnit Jupiter की मदद से टेस्ट जनरेट करना होगा.साथ ही, चौथे प्रोजेक्ट के नाम के लिए भी palm-workshop का इस्तेमाल करना होगा.
प्रोजेक्ट का स्ट्रक्चर इस तरह दिखेगा:
├── gradle
│ └── ...
├── gradlew
├── gradlew.bat
├── settings.gradle
└── app
├── build.gradle
└── src
├── main
│ └── java
│ └── palm
│ └── workshop
│ └── App.java
└── test
└── ...
कुछ ज़रूरी डिपेंडेंसी जोड़ने के लिए, app/build.gradle फ़ाइल को अपडेट करते हैं. अगर guava डिपेंडेंसी मौजूद है, तो उसे हटाया जा सकता है. साथ ही, इसे LangChain4J प्रोजेक्ट और लॉगिंग लाइब्रेरी डिपेंडेंसी से बदला जा सकता है, ताकि आपको लॉगर मैसेज न मिलें:
dependencies {
// Use JUnit Jupiter for testing.
testImplementation 'org.junit.jupiter:junit-jupiter:5.8.1'
// Logging library
implementation 'org.slf4j:slf4j-jdk14:2.0.9'
// This dependency is used by the application.
implementation 'dev.langchain4j:langchain4j-vertex-ai:0.24.0'
implementation 'dev.langchain4j:langchain4j:0.24.0'
}
LangChain4J के लिए दो डिपेंडेंसी होती हैं:
- पहला चरण है,
- इनमें से एक ख़ास तौर पर Vertex AI मॉड्यूल के लिए किया जाएगा.
हमारे प्रोग्राम को कंपाइल और चलाने के लिए Java 17 का इस्तेमाल करने के लिए, plugins {} ब्लॉक के नीचे यह ब्लॉक जोड़ें:
java {
toolchain {
languageVersion = JavaLanguageVersion.of(17)
}
}
आपको एक और बदलाव करना है: app/build.gradle के application ब्लॉक को अपडेट करें, ताकि उपयोगकर्ता बिल्ड टूल को शुरू करते समय मुख्य क्लास को कमांड-लाइन पर चला सकें:
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
अब आप LangChain4J प्रोजेक्ट का इस्तेमाल करके, PaLM के बड़े लैंग्वेज टेक्स्ट मॉडल की मदद से प्रोग्राम करने के लिए तैयार हैं!
रेफ़रंस के लिए, यहां देखें कि पूरी 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 को कॉल करें.
app/src/main/java/palm/workshop डायरेक्ट्री (डिफ़ॉल्ट App.java क्लास के साथ) में, ChatPrompts.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 तैयार किया जा सकता है. यह एक उच्च स्तर का एब्स्ट्रैक्ट है, जो LangChain4J से मिलता है. इससे किसी बातचीत को मैनेज करने के लिए, अलग-अलग कॉम्पोनेंट को एक साथ कॉन्फ़िगर किया जाता है. जैसे, चैट लैंग्वेज मॉडल. हालांकि, चैट के इतिहास को मैनेज करने के लिए अन्य कॉम्पोनेंट को कॉन्फ़िगर किया जा सकता है. इसके अलावा, वेक्टर डेटाबेस से जानकारी फ़ेच करने के लिए रिट्रीवर जैसे अन्य टूल प्लग किए जा सकते हैं. लेकिन चिंता न करें, हम बाद में इस कोडलैब में आपसे बात करेंगे.
इसके बाद, आपको चैट मॉडल के साथ अलग-अलग तरह के सवाल पूछने होंगे. सबसे पहले एलएलएम के बारे में पूछा जाता है. इसके बाद, पूछा जाता है कि इनकी मदद से क्या-क्या किया जा सकता है और उनके कुछ उदाहरण क्या हैं. ध्यान दें कि आपको खुद को बार-बार दोहराने की ज़रूरत नहीं है. एलएलएम को पता है कि "उन्हें" का मतलब एलएलएम है.
एक के बाद एक बातचीत शुरू करने के लिए, आपको चेन में 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 ने इससे जुड़े आपके तीन सवालों का जवाब दिया!
VertexAIChatModel बिल्डर की मदद से, ऐसे वैकल्पिक पैरामीटर तय किए जा सकते हैं जिनमें पहले से ही कुछ डिफ़ॉल्ट वैल्यू मौजूद होती हैं. इन्हें बदला जा सकता है. यहां कुछ उदाहरण दिए गए हैं:
.temperature(0.2)— इससे यह पता चलता है कि जवाब कितना क्रिएटिव होना चाहिए (0 का मतलब है कम क्रिएटिव होना और ज़्यादातर मामलों में तथ्य भी, जबकि 1 का मतलब ज़्यादा क्रिएटिव आउटपुट के लिए होना चाहिए).maxOutputTokens(50)— उदाहरण में, 400 टोकन का अनुरोध किया गया था (तीन टोकन करीब 4 शब्दों के बराबर होते हैं). यह इस बात पर निर्भर करता है कि जनरेट किए गए जवाब को कितने समय के लिए सेट करना है.topK(20)— पूरे टेक्स्ट के लिए, तय किए गए ज़्यादा से ज़्यादा शब्दों में से किसी भी क्रम में कोई शब्द चुना जा सकता है. यह संख्या 1 से 40 तक हो सकती है.topP(0.95)— ऐसे संभावित शब्दों को चुनने के लिए जिनकी कुल संभावना को उस फ़्लोटिंग पॉइंट नंबर (0 और 1 के बीच) में जोड़ा जाता है.maxRetries(3)— अगर आपने हर बार अनुरोध करने का कोटा खत्म कर दिया है, तो मॉडल को तीन बार कॉल करने की कोशिश करें. उदाहरण के लिए
5. आपकी शख्सियत के हिसाब से काम आने वाला चैटबॉट!
पिछले सेक्शन में, आपने जवाब दिए बिना ही एलएलएम चैटबॉट से सवाल पूछना शुरू किया. हालांकि, ऐसे चैटबॉट को किसी काम या विषय के विशेषज्ञ बनने में महारत हासिल है.
आपको ऐसा कैसे करना है? स्टेज सेट करके: एलएलएम को टास्क के बारे में समझाकर, कॉन्टेक्स्ट के बारे में बताकर, कुछ उदाहरण देकर बताया जा सकता है कि इसे क्या करना है, इसमें क्या पर्सोना होना चाहिए, आपको किस फ़ॉर्मैट में जवाब चाहिए, और अगर आपकी इच्छा है कि चैटबॉट सही तरीके से काम करे, तो एक टोन भी हो सकती है.
क्राफ़्ट करने से जुड़े प्रॉम्प्ट के बारे में इस लेख में, इस ग्राफ़िक के साथ इस तरीके को अच्छी तरह से समझाया गया है:
https://medium.com/@eldatero/master-the-perfect-chatgpt-prompt-formula-c776adae8f19
इस बात को समझाने के लिए, चलिए prompts.chat वेबसाइटों से कुछ प्रेरणा लेते हैं, जिसमें पसंद के मुताबिक बनाए गए चैटबॉट के बहुत सारे बेहतरीन और मज़ेदार आइडिया दिए गए हैं, ताकि वे इस तरह से काम कर सकें:
- इमोजी का अनुवाद करने वाला — उपयोगकर्ता के मैसेज का इमोजी में अनुवाद करने के लिए
- प्रॉम्प्ट एन्हैंसर — इससे बेहतर प्रॉम्प्ट बनाएँ
- जर्नल समीक्षक — रिसर्च पेपर की समीक्षा में मदद करने के लिए
- निजी स्टाइलिस्ट — कपड़ों की स्टाइल के सुझाव पाने के लिए
एलएलएम चैटबॉट को शतरंज के खिलाड़ी में बदलने का एक उदाहरण है! चलिए, इसे लागू करते हैं!
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) दिए गए हैं. इसकी वजह यह है कि हमें शतरंज के बारे में सवाल हल करने के बजाय, सिर्फ़ एक ही फ़ैसला लेना है!
- इसके बाद, चैट में की गई बातचीत को सेव करने के लिए, चैट मेमोरी स्टोर बनाया जाता है.
- पिछले मूव को बनाए रखने के लिए, हम विंडो में चैट की एक असली मेमोरी बनाते हैं.
- चैट मेमोरी में, आप एक "सिस्टम" जोड़ते हैं मैसेज लिखें, जो चैट मॉडल को यह बताता हो कि उसे किसे चुनना चाहिए (यानी कि शतरंज का विशेषज्ञ खिलाड़ी). "सिस्टम" मैसेज से कुछ कॉन्टेक्स्ट जोड़ा जा सकता है, जबकि "उपयोगकर्ता" और "एआई" संदेश ही वास्तविक चर्चा हैं.
- बातचीत वाली एक चेन बनाई जाती है, जिसमें 'यादें' और चैट मॉडल को शामिल किया जाता है.
- इसके बाद, हमारे पास व्हाइट मूव की एक सूची है, जिसे आपको दोहराना है. चेन को हर बार अगली व्हाइट मूव के साथ चलाया जाता है और चैट मॉडल अगली सबसे अच्छी चाल के साथ जवाब देता है.
इस क्लास को इस मूव के साथ चलाने पर, आपको यह आउटपुट दिखेगा:
$ ./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 (पोर्टेबल गेम नोटेशन) फ़ाइलें भी देखी होंगी. हालांकि, ऐसा हो सकता है कि यह चैटबॉट AlphaZero से जीत न पाए (वह एआई जिसने बेहतरीन गो, शोगी, और शतरंज के खिलाड़ियों को हराया है). इसके बाद, हो सकता है कि यह बातचीत आगे भी पीछे जाएगी, क्योंकि मॉडल को गेम की असल स्थिति याद ही नहीं रहेगी.
चैट मॉडल बहुत कारगर होते हैं. ये उपयोगकर्ताओं के साथ बेहतर तरीके से बातचीत करने में मदद कर सकते हैं. साथ ही, ये अलग-अलग तरह के काम कर सकते हैं. अगले सेक्शन में, हम इससे जुड़े एक काम के बारे में जानेंगे: टेक्स्ट से स्ट्रक्चर्ड डेटा निकालना.
6. बिना स्ट्रक्चर वाले टेक्स्ट से जानकारी निकालना
पिछले सेक्शन में, आपने उपयोगकर्ता और चैट के भाषा मॉडल के बीच होने वाली बातचीत बनाई थी. हालांकि, LangChain4J की मदद से, बिना स्ट्रक्चर वाले टेक्स्ट से स्ट्रक्चर्ड जानकारी निकालने के लिए, चैट मॉडल का भी इस्तेमाल किया जा सकता है.
मान लें कि आपको किसी व्यक्ति की जीवनी या विवरण के आधार पर, उसका नाम और उम्र निकालना है. बड़ी भाषा वाले मॉडल को, बड़े तरीके से बदलाव किए गए प्रॉम्प्ट की मदद से, JSON डेटा स्ट्रक्चर जनरेट करने का निर्देश दिया जा सकता है. इसे आम तौर पर "प्रॉम्प्ट इंजीनियरिंग" कहा जाता है.
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() तरीके के कॉन्टेंट पर नज़र डालते हैं:
- चैट मॉडल इंस्टैंशिएट किया जाता है.
- LangChain4J की
AiServicesक्लास की मदद सेPersonExtractorऑब्जेक्ट बनाया गया. - इसके बाद, बिना स्ट्रक्चर वाले टेक्स्ट से व्यक्ति की जानकारी निकालने के लिए,
Person person = extractor.extractPerson(...)को कॉल करें. साथ ही, नाम और उम्र वालाPersonइंस्टेंस वापस पाएं.
अब, इस क्लास को नीचे दिए गए निर्देश के साथ चलाएं:
$ ./gradlew run -DjavaMainClass=palm.workshop.ChatPrompts > Task :app:run Anna 23
हां! ये ऐना हैं और उनकी उम्र 23 साल है!
इस AiServices तरीके में खास बात यह है कि आपको मज़बूत टाइप वाले ऑब्जेक्ट के साथ काम करना चाहिए. आपने चैट एलएलएम से सीधे तौर पर इंटरैक्ट नहीं किया है. इसके बजाय, एक्सट्रैक्ट की गई निजी जानकारी को दिखाने के लिए Person क्लास जैसी कंक्रीट क्लास के साथ काम किया जा रहा है और आपके पास extractPerson() तरीके वाली PersonExtractor क्लास है जो Person इंस्टेंस दिखाती है. एलएलएम का सिद्धांत हटा दिया गया है. Java डेवलपर के तौर पर, यह सिर्फ़ सामान्य क्लास और ऑब्जेक्ट में बदलाव कर रहा है.
7. रिकवर करने वाली ऑगमेंटेड जनरेशन: अपने दस्तावेज़ों से चैट करना
चलिए, बातचीत पर वापस चलते हैं. इस दौरान, आपके पास अपने दस्तावेज़ों के बारे में सवाल पूछने का विकल्प होगा. आपको एक ऐसा चैटबॉट बनाना होगा जो आपके दस्तावेज़ों के एक्सट्रैक्ट के डेटाबेस से काम की जानकारी हासिल कर सके. इस जानकारी का इस्तेमाल, मॉडल अपने जवाबों को "ग्राउंड" करने के लिए करेगा, न कि ट्रेनिंग से मिलने वाले जवाबों को जनरेट करने के लिए. इस पैटर्न को RAG या Retrieval ऑगमेंटेड जनरेशन कहा जाता है.
कम शब्दों में कहें, तो रिट्रीवल ऑगमेंटेड जनरेशन के दो चरण हैं:
- डेटा डालने का चरण — दस्तावेज़ लोड होते हैं और उन्हें छोटे-छोटे हिस्सों में बांट दिया जाता है. इसके बाद, उन्हें वेक्टर के ज़रिए दिखाने वाले तरीके ("वेक्टर एम्बेडिंग") को "वेक्टर डेटाबेस" में सेव कर दिया जाता है जिससे सिमैंटिक सर्च किया जा सकता है.
- क्वेरी फ़ेज़ — उपयोगकर्ता अब दस्तावेज़ के बारे में, आपके चैटबॉट से सवाल पूछ सकते हैं. सवाल को भी वेक्टर में बदल दिया जाएगा और उसकी तुलना डेटाबेस में मौजूद अन्य सभी वेक्टर से की जाएगी. सबसे मिलते-जुलते वेक्टर आम तौर पर शब्दों से जुड़े होते हैं और वेक्टर डेटाबेस के ज़रिए दिखाए जाते हैं. इसके बाद, एलएलएम को बातचीत का संदर्भ दिया जाता है. इसमें, डेटाबेस से मिले वेक्टर से जुड़े टेक्स्ट के स्निपेट दिए जाते हैं. इसके बाद, इन स्निपेट को देखकर एलएलएम को अपना जवाब देने के लिए कहा जाता है.
दस्तावेज़ तैयार करने का तरीका
इस नए डेमो के लिए, आपसे Google के शुरुआती दौर के "ट्रांसफ़ॉर्मर" न्यूरल नेटवर्क आर्किटेक्चर के बारे में सवाल पूछे जाएंगे. आज-कल सभी मॉडर्न लार्ज लैंग्वेज मॉडल इसी तरह से लागू किए जाते हैं.
इंटरनेट से PDF डाउनलोड करने के लिए, wget निर्देश का इस्तेमाल करके, इस आर्किटेक्चर ("सिर्फ़ ध्यान देने की ज़रूरत है") के बारे में जानकारी देने वाले रिसर्च पेपर को फिर से हासिल किया जा सकता है:
wget -O attention-is-all-you-need.pdf \
https://proceedings.neurips.cc/paper_files/paper/2017/file/3f5ee243547dee91fbd053c1c4a845aa-Paper.pdf
बातचीत वाली जानकारी वापस पाने की चेन को लागू करना
सबसे पहले दस्तावेज़ का डेटा डालने की सुविधा के बारे में बात करते हैं और फिर क्वेरी के समय की बात करते हैं. हम यह जानना चाहते हैं कि दो चरणों में पुष्टि कैसे की जाती है. इसके बाद, हम दस्तावेज़ के बारे में सवाल पूछते हैं.
दस्तावेज़ का डेटा डालना
दस्तावेज़ डालने के चरण का सबसे पहला चरण, डाउनलोड की गई 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 फ़ाइल के टेक्स्ट को 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();
आपको "रिट्रीवर" क्लास की भी ज़रूरत होगी, जो वेक्टर डेटाबेस (embeddingStore वैरिएबल में) और एम्बेडिंग मॉडल को लिंक करेगी. इसका काम, उपयोगकर्ता की क्वेरी के लिए वेक्टर एम्बेडिंग का हिसाब लगाकर वेक्टर डेटाबेस से क्वेरी करना है, ताकि डेटाबेस में मिलते-जुलते वेक्टर खोजा जा सके:
EmbeddingStoreRetriever retriever =
EmbeddingStoreRetriever.from(embeddingStore, embeddingModel);
इसके बाद, ConversationalRetrievalChain क्लास को इंस्टैंशिएट किया जा सकता है (यह 'वापस पाएं' ऑगमेंटेड जनरेशन पैटर्न का सिर्फ़ एक अलग नाम है):
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. बधाई हो
बधाई हो, आपने LangChain4J और PaLM API का इस्तेमाल करके, Java में अपना पहला जनरेटिव एआई चैट ऐप्लिकेशन बना लिया है! इस दौरान आपको पता चला कि लार्ज लैंग्वेज चैट मॉडल काफ़ी दमदार होते हैं. साथ ही, ये सवाल/जवाब जैसे कई टास्क पूरे करने में आपकी मदद करते हैं. यहां तक कि अपने दस्तावेज़ों और डेटा निकालने की प्रोसेस में भी यह काफ़ी हद तक शतरंज में बदल सकता है!
आगे क्या होगा?
Java में PaLM के साथ आगे बढ़ने के लिए, यहां दिए गए कोड लैब देखें:
आगे पढ़ें
- जनरेटिव एआई के इस्तेमाल के सामान्य उदाहरण
- जनरेटिव एआई पर ट्रेनिंग से जुड़े संसाधन
- जनरेटिव एआई Studio की मदद से, PaLM के साथ इंटरैक्ट करना
- ज़िम्मेदार एआई