PaLM और LangChain4J की मदद से, Java में दस्तावेज़ों और उपयोगकर्ताओं के साथ जनरेटिव एआई की मदद से चैट करें

1. परिचय

पिछले अपडेट की तारीख: 05-02-2024

जनरेटिव एआई क्या है

जनरेटिव एआई या जनरेटिव आर्टिफ़िशियल इंटेलिजेंस का मतलब है, एआई का इस्तेमाल करके नया कॉन्टेंट बनाना. जैसे, टेक्स्ट, इमेज, संगीत, ऑडियो, और वीडियो.

जनरेटिव एआई, फ़ाउंडेशन मॉडल (बड़े एआई मॉडल) की मदद से काम करता है. ये मॉडल एक साथ कई टास्क पूरे कर सकते हैं. साथ ही, ये अलग-अलग तरह के काम कर सकते हैं. जैसे- बड़े लेख की खास जानकारी लिखना, सवालों के जवाब देना, अलग-अलग कैटगरी बनाना वगैरह. इसके अलावा, फ़ाउंडेशन मॉडल को कम ट्रेनिंग की ज़रूरत होती है. इसलिए, इन्हें उदाहरण के तौर पर दिए गए बहुत कम डेटा के साथ, खास इस्तेमाल के मामलों के लिए अडैप्ट किया जा सकता है.

जनरेटिव एआई कैसे काम करता है?

जनरेटिव एआई, एमएल (मशीन लर्निंग) मॉडल का इस्तेमाल करके काम करता है. यह मॉडल, इंसानों के बनाए गए कॉन्टेंट के डेटासेट में मौजूद पैटर्न और संबंधों के बारे में जानकारी इकट्ठा करता है. इसके बाद, यह सीखे गए पैटर्न का इस्तेमाल करके नया कॉन्टेंट जनरेट करता है.

जनरेटिव एआई मॉडल को ट्रेन करने का सबसे सामान्य तरीका, सुपरवाइज़्ड लर्निंग का इस्तेमाल करना है. इसमें मॉडल को इंसानों के बनाए गए कॉन्टेंट का एक सेट और उससे जुड़े लेबल दिए जाते हैं. इसके बाद, यह लोगों के बनाए गए कॉन्टेंट के जैसा कॉन्टेंट जनरेट करना सीखता है. साथ ही, यह कॉन्टेंट को उसी तरह के लेबल से लेबल करता है.

जनरेटिव एआई के सामान्य इस्तेमाल क्या हैं?

जनरेटिव एआई, बहुत ज़्यादा कॉन्टेंट को प्रोसेस करता है. इसके बाद, टेक्स्ट, इमेज, और इस्तेमाल में आसान फ़ॉर्मैट में जवाब और अहम जानकारी देता है. जनरेटिव एआई का इस्तेमाल इन कामों के लिए किया जा सकता है:

  • बेहतर चैट और खोज के अनुभव के ज़रिए, ग्राहकों से बातचीत को बेहतर बनाना
  • बातचीत वाले इंटरफ़ेस और खास जानकारी की मदद से, स्ट्रक्चर नहीं किए गए डेटा के बड़े हिस्से को एक्सप्लोर करें
  • बार-बार किए जाने वाले कामों में मदद करना. जैसे, प्रस्ताव के अनुरोधों (आरएफ़पी) का जवाब देना, मार्केटिंग कॉन्टेंट को पांच भाषाओं में स्थानीय भाषा के हिसाब से तैयार करना, और ग्राहकों के कानूनी समझौतों की जांच करना, ताकि यह पता चल सके कि वे नियमों का पालन कर रहे हैं या नहीं. इसके अलावा, और भी कई काम

Google Cloud में जनरेटिव एआई की कौनसी सुविधाएं उपलब्ध हैं?

Vertex AI की मदद से, अपने ऐप्लिकेशन में फ़ाउंडेशन मॉडल को इंटरैक्ट किया जा सकता है, उन्हें पसंद के मुताबिक बनाया जा सकता है, और एम्बेड किया जा सकता है. इसके लिए, मशीन लर्निंग के बारे में ज़्यादा जानकारी होने की ज़रूरत नहीं होती. Model Garden पर फ़ाउंडेशन मॉडल ऐक्सेस करें, Generative AI Studio पर आसान यूज़र इंटरफ़ेस (यूआई) की मदद से मॉडल को ट्यून करें या डेटा साइंस नोटबुक में मॉडल का इस्तेमाल करें.

Vertex AI Search and Conversation की मदद से, डेवलपर जनरेटिव एआई की मदद से काम करने वाले सर्च इंजन और चैटबॉट तेज़ी से बना सकते हैं.

साथ ही, Duet AI, एआई की मदद से काम करने वाला आपका सहयोगी है. यह Google Cloud और IDE में उपलब्ध है, ताकि आप ज़्यादा काम तेज़ी से कर सकें.

यह कोडलैब किस चीज़ पर फ़ोकस कर रहा है?

यह कोडलैब, Google Cloud Vertex AI पर होस्ट किए गए PaLM 2 लार्ज लैंग्वेज मॉडल (एलएलएम) पर फ़ोकस करता है. इसमें मशीन लर्निंग के सभी प्रॉडक्ट और सेवाएं शामिल हैं.

PaLM API के साथ इंटरैक्ट करने के लिए, Java का इस्तेमाल किया जाएगा. साथ ही, LangChain4J LLM फ़्रेमवर्क ऑर्केस्ट्रेटर का इस्तेमाल किया जाएगा. आपको कई उदाहरणों के बारे में बताया जाएगा, ताकि सवालों के जवाब पाने, आइडिया जनरेट करने, इकाई और स्ट्रक्चर्ड कॉन्टेंट निकालने, और खास जानकारी पाने के लिए एलएलएम का फ़ायदा उठाया जा सके.

LangChain4J फ़्रेमवर्क के बारे में मुझे ज़्यादा जानकारी दो!

LangChain4J फ़्रेमवर्क, ओपन सोर्स लाइब्रेरी है. इसका इस्तेमाल, Java ऐप्लिकेशन में लार्ज लैंग्वेज मॉडल को इंटिग्रेट करने के लिए किया जाता है. इसके लिए, यह एलएलएम के साथ-साथ वेक्टर डेटाबेस (सिमेंटिक सर्च के लिए), दस्तावेज़ लोडर और स्प्लिटर (दस्तावेज़ों का विश्लेषण करने और उनसे सीखने के लिए), आउटपुट पार्सर जैसे कई कॉम्पोनेंट को व्यवस्थित करता है.

c6d7f7c3fd0d2951.png

आपको क्या सीखने को मिलेगा

  • PaLM और LangChain4J का इस्तेमाल करने के लिए, Java प्रोजेक्ट को कैसे सेट अप करें
  • अनस्ट्रक्चर्ड कॉन्टेंट से काम की जानकारी निकालने का तरीका (इकाई या कीवर्ड निकालना, JSON फ़ॉर्मैट में आउटपुट)
  • उपयोगकर्ताओं के साथ बातचीत कैसे शुरू करें
  • अपने दस्तावेज़ों के बारे में सवाल पूछने के लिए, चैट मॉडल का इस्तेमाल कैसे करें

आपको इन चीज़ों की ज़रूरत होगी

  • Java प्रोग्रामिंग लैंग्वेज की जानकारी
  • Google Cloud प्रोजेक्ट
  • Chrome या Firefox जैसे ब्राउज़र

2. सेटअप और ज़रूरी शर्तें

अपने हिसाब से एनवायरमेंट सेट अप करना

  1. Google Cloud Console में साइन इन करें और नया प्रोजेक्ट बनाएं या किसी मौजूदा प्रोजेक्ट का फिर से इस्तेमाल करें. अगर आपके पास पहले से कोई Gmail या Google Workspace खाता नहीं है, तो आपको एक खाता बनाना होगा.

295004821bab6a87.png

37d264871000675d.png

96d86d3d5655cdbe.png

  • प्रोजेक्ट का नाम, इस प्रोजेक्ट में हिस्सा लेने वाले लोगों के लिए डिसप्ले नेम होता है. यह एक वर्ण स्ट्रिंग है, जिसका इस्तेमाल Google API नहीं करते. इसे कभी भी अपडेट किया जा सकता है.
  • प्रोजेक्ट आईडी, सभी Google Cloud प्रोजेक्ट के लिए यूनीक होता है. साथ ही, इसे बदला नहीं जा सकता. Cloud Console, एक यूनीक स्ट्रिंग अपने-आप जनरेट करता है. आम तौर पर, आपको इससे कोई फ़र्क़ नहीं पड़ता कि यह क्या है. ज़्यादातर कोडलैब में, आपको अपने प्रोजेक्ट आईडी (आम तौर पर PROJECT_ID के तौर पर पहचाना जाता है) का रेफ़रंस देना होगा. अगर आपको जनरेट किया गया आईडी पसंद नहीं है, तो कोई दूसरा रैंडम आईडी जनरेट किया जा सकता है. इसके अलावा, आपके पास अपना नाम आज़माने का विकल्प भी है. इससे आपको पता चलेगा कि वह नाम उपलब्ध है या नहीं. इस चरण के बाद, इसे बदला नहीं जा सकता. यह प्रोजेक्ट की अवधि तक बना रहता है.
  • आपकी जानकारी के लिए बता दें कि एक तीसरी वैल्यू भी होती है, जिसे प्रोजेक्ट नंबर कहते हैं. इसका इस्तेमाल कुछ एपीआई करते हैं. इन तीनों वैल्यू के बारे में ज़्यादा जानने के लिए, दस्तावेज़ देखें.
  1. इसके बाद, आपको Cloud Console में बिलिंग चालू करनी होगी, ताकि Cloud संसाधनों/एपीआई का इस्तेमाल किया जा सके. इस कोडलैब को पूरा करने में ज़्यादा समय नहीं लगेगा. इस ट्यूटोरियल के बाद बिलिंग से बचने के लिए, संसाधनों को बंद किया जा सकता है. इसके लिए, बनाए गए संसाधनों को मिटाएं या प्रोजेक्ट को मिटाएं. Google Cloud के नए उपयोगकर्ताओं को, मुफ़्त में आज़माने के लिए 300 डॉलर का क्रेडिट मिलता है.

Cloud Shell शुरू करें

Google Cloud को अपने लैपटॉप से रिमोटली ऑपरेट किया जा सकता है. हालांकि, इस कोडलैब में Cloud Shell का इस्तेमाल किया जाएगा. यह क्लाउड में चलने वाला कमांड लाइन एनवायरमेंट है.

Cloud Shell चालू करें

  1. Cloud Console में, Cloud Shell चालू करें d1264ca30785e435.png पर क्लिक करें.

cb81e7c8e34bc8d.png

अगर आपने Cloud Shell को पहली बार शुरू किया है, तो आपको एक इंटरमीडिएट स्क्रीन दिखेगी. इसमें Cloud Shell के बारे में जानकारी दी गई होगी. अगर आपको इंटरमीडिएट स्क्रीन दिखती है, तो जारी रखें पर क्लिक करें.

d95252b003979716.png

Cloud Shell से कनेक्ट होने में कुछ ही सेकंड लगेंगे.

7833d5e1c5d18f54.png

इस वर्चुअल मशीन में, डेवलपमेंट के लिए ज़रूरी सभी टूल पहले से मौजूद हैं. यह 5 जीबी की होम डायरेक्ट्री उपलब्ध कराता है, जो हमेशा बनी रहती है. साथ ही, यह Google Cloud में काम करता है. इससे नेटवर्क की परफ़ॉर्मेंस और पुष्टि करने की प्रोसेस बेहतर होती है. इस कोडलैब में ज़्यादातर काम ब्राउज़र से किया जा सकता है.

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. यह पुष्टि करने के लिए कि gcloud कमांड को आपके प्रोजेक्ट के बारे में पता है, Cloud Shell में यह कमांड चलाएं:
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 चालू करना

  1. Google Cloud Console में, पक्का करें कि आपके प्रोजेक्ट का नाम, Google Cloud Console में सबसे ऊपर दिख रहा हो. अगर ऐसा नहीं है, तो प्रोजेक्ट चुनने वाला टूल खोलने के लिए, कोई प्रोजेक्ट चुनें पर क्लिक करें. इसके बाद, अपना पसंदीदा प्रोजेक्ट चुनें.
  2. अगर आप Google Cloud Console के Vertex AI सेक्शन में नहीं हैं, तो यह तरीका अपनाएं:
  3. Search में, Vertex AI डालें. इसके बाद, वापस जाएं
  4. खोज के नतीजों में, Vertex AI पर क्लिक करें. इसके बाद, Vertex AI डैशबोर्ड दिखेगा.
  5. Vertex AI डैशबोर्ड में, सुझाए गए सभी एपीआई चालू करें पर क्लिक करें.

इससे कई एपीआई चालू हो जाएंगे. हालांकि, कोडलैब के लिए सबसे ज़रूरी एपीआई 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 फ़ाइल को अपडेट करें. अगर 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 डायरेक्ट्री में ChatPrompts.java नाम की नई क्लास बनाएं. यह क्लास, डिफ़ॉल्ट 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 तैयार किया जा सकता है. यह 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 टोकन का अनुरोध किया गया था. तीन टोकन, करीब-करीब चार शब्दों के बराबर होते हैं. यह इस बात पर निर्भर करता है कि आपको जनरेट किया गया जवाब कितना लंबा चाहिए
  • .topK(20) — इसका इस्तेमाल, टेक्स्ट पूरा करने के लिए, संभावित शब्दों में से किसी एक शब्द को चुनने के लिए किया जाता है. इसकी वैल्यू 1 से 40 तक होती है
  • .topP(0.95) — उन संभावित शब्दों को चुनने के लिए जिनकी कुल संभावना, फ़्लोटिंग पॉइंट नंबर (0 से 1 के बीच) के बराबर होती है
  • .maxRetries(3) — अगर आपने तय समय में अनुरोधों की संख्या से ज़्यादा अनुरोध किए हैं, तो मॉडल को कॉल करने के लिए तीन बार फिर से कोशिश करने का निर्देश दिया जा सकता है.

5. एक मददगार चैटबॉट, जो आपकी पसंद के हिसाब से जवाब देता है!

पिछले सेक्शन में, आपने एलएलएम चैटबॉट से तुरंत सवाल पूछना शुरू कर दिया था. आपने उसे कोई कॉन्टेक्स्ट नहीं दिया था. हालांकि, इस तरह के चैटबॉट को किसी खास टास्क या विषय में विशेषज्ञ बनाया जा सकता है.

ऐसा कैसे किया जाता है? एलएलएम को टास्क के बारे में जानकारी देकर, कॉन्टेक्स्ट के बारे में बताकर, और शायद कुछ उदाहरण देकर कि उसे क्या करना है, उसे किस तरह का किरदार निभाना है, आपको किस फ़ॉर्मैट में जवाब चाहिए, और अगर आपको चैटबॉट से किसी खास तरीके से व्यवहार करवाना है, तो उसकी टोन के बारे में बताकर.

प्रॉम्प्ट बनाने से जुड़े इस लेख में, इस ग्राफ़िक के ज़रिए इस तरीके के बारे में अच्छी तरह से बताया गया है:

8a4c67679dcbd085.png

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 से नहीं जीत पाएगा. यह एक ऐसा एआई है जिसने Go, Shogi, और Chess के सबसे अच्छे खिलाड़ियों को हराया है. साथ ही, बातचीत आगे बढ़ने पर पटरी से उतर सकती है. ऐसा इसलिए, क्योंकि मॉडल को गेम की मौजूदा स्थिति के बारे में सही जानकारी नहीं होगी.

चैट मॉडल बहुत शक्तिशाली होते हैं. ये आपके उपयोगकर्ताओं के साथ बेहतर तरीके से इंटरैक्ट कर सकते हैं. साथ ही, कॉन्टेक्स्ट के हिसाब से अलग-अलग टास्क मैनेज कर सकते हैं. अगले सेक्शन में, हम एक ज़रूरी टास्क के बारे में जानेंगे: टेक्स्ट से स्ट्रक्चर्ड डेटा निकालना.

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 क्लास. साथ ही, आपके पास PersonExtractor क्लास होती है, जिसमें extractPerson() तरीका होता है. यह तरीका, Person इंस्टेंस दिखाता है. एलएलएम की अवधारणा को हटा दिया गया है. साथ ही, Java डेवलपर के तौर पर, आपको सिर्फ़ सामान्य क्लास और ऑब्जेक्ट में बदलाव करना होता है.

7. Retrieval Augmented Generation: अपने दस्तावेज़ों के साथ चैट करना

आइए, बातचीत पर वापस आते हैं. इस बार, आपको अपने दस्तावेज़ों के बारे में सवाल पूछने का विकल्प मिलेगा. आपको एक ऐसा चैटबॉट बनाना होगा जो आपके दस्तावेज़ों के एक्सट्रैक्ट के डेटाबेस से काम की जानकारी पा सके. इस जानकारी का इस्तेमाल मॉडल, अपने जवाबों को "ग्राउंड" करने के लिए करेगा. इसका मतलब है कि वह अपने जवाबों को ट्रेनिंग से जनरेट करने के बजाय, इस जानकारी के आधार पर जवाब देगा. इस पैटर्न को RAG या Retrieval Augmented Generation कहा जाता है.

रीट्रिवल ऑगमेंटेड जनरेशन में, मुख्य तौर पर दो चरण होते हैं:

  1. डेटा इकट्ठा करने का चरण — इस चरण में, दस्तावेज़ों को लोड किया जाता है और उन्हें छोटे-छोटे हिस्सों में बांटा जाता है. इसके बाद, उनका वेक्टर फ़ॉर्मैट ("वेक्टर एम्बेडिंग") "वेक्टर डेटाबेस" में सेव किया जाता है. यह डेटाबेस, सिमैंटिक सर्च करने में सक्षम होता है.

6c5bb5cb2e3b8088.png

  1. क्वेरी फ़ेज़ — अब लोग, आपके चैटबॉट से दस्तावेज़ के बारे में सवाल पूछ सकते हैं. सवाल को भी एक वेक्टर में बदल दिया जाएगा. इसके बाद, इसकी तुलना डेटाबेस में मौजूद अन्य सभी वेक्टर से की जाएगी. सबसे मिलते-जुलते वेक्टर, आम तौर पर सिमैंटिक तौर पर एक-दूसरे से जुड़े होते हैं. इन्हें वेक्टर डेटाबेस से वापस लाया जाता है. इसके बाद, एलएलएम को बातचीत का कॉन्टेक्स्ट दिया जाता है. साथ ही, डेटाबेस से मिले वेक्टर से जुड़े टेक्स्ट के स्निपेट दिए जाते हैं. एलएलएम को कहा जाता है कि वह इन स्निपेट को देखकर जवाब दे.

2c279c506d7606cd.png

अपने दस्तावेज़ तैयार करना

इस नए डेमो के लिए, आपको "ट्रांसफ़ॉर्मर" न्यूरल नेटवर्क आर्किटेक्चर के बारे में सवाल पूछने होंगे. इसे Google ने बनाया है. आजकल, सभी आधुनिक लार्ज लैंग्वेज मॉडल इसी आर्किटेक्चर पर काम करते हैं.

इस आर्किटेक्चर ("Attention is all you need") के बारे में बताने वाले रिसर्च पेपर को वापस पाया जा सकता है. इसके लिए, इंटरनेट से 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")));

चैट के लिए सामान्य भाषा मॉडल बनाने के बजाय, इससे पहले आपको "embedding" मॉडल का एक इंस्टेंस बनाना होगा. यह एक खास मॉडल और एंडपॉइंट है. इसका काम टेक्स्ट के हिस्सों (शब्दों, वाक्यों या पैराग्राफ़) के वेक्टर रिप्रेजेंटेशन बनाना है.

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();

आपको एक "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. बधाई हो

बधाई हो, आपने LangChain4J और PaLM API का इस्तेमाल करके, Java में अपना पहला जनरेटिव एआई चैट ऐप्लिकेशन बना लिया है! आपको यह पता चला कि लार्ज लैंग्वेज चैट मॉडल काफ़ी बेहतर होते हैं. साथ ही, ये कई तरह के टास्क कर सकते हैं. जैसे, सवाल/जवाब देना, आपके दस्तावेज़ों से डेटा निकालना. इसके अलावा, ये कुछ हद तक शतरंज भी खेल सकते हैं!

आगे क्या करना है?

Java में PaLM का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, यहां दिए गए कुछ कोडलैब देखें:

इस बारे में और पढ़ें

रेफ़रंस दस्तावेज़