एआई मॉडल की मदद से कॉन्टेंट जनरेट करना

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

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

इसके अलावा, एलएलएम की मदद से, टेक्स्ट जनरेट करने के अलावा और भी काम किए जा सकते हैं:

• कंप्यूटर प्रोग्राम लिखना
• किसी बड़े टास्क को पूरा करने के लिए, सबटास्क बनाना
• व्यवस्थित नहीं किए गए डेटा को व्यवस्थित करना
• टेक्स्ट के कॉर्पस से जानकारी का डेटा समझना और निकालना
• गतिविधि की टेक्स्ट जानकारी के आधार पर, ऑटोमेट की गई गतिविधियों को फ़ॉलो करना और उन्हें पूरा करना

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

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

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

शुरू करने से पहले

अगर आपको इस पेज पर दिए गए कोड के उदाहरण चलाने हैं, तो पहले शुरू करने से जुड़ी गाइड में दिया गया तरीका अपनाएं. सभी उदाहरणों में यह माना गया है कि आपने अपने प्रोजेक्ट में, डिपेंडेंसी के तौर पर Genkit पहले ही इंस्टॉल कर लिया है.

Genkit के साथ काम करने वाले मॉडल

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

Genkit टीम, Vertex AI, Google जनरेटिव एआई, और Ollama के उपलब्ध कराए गए मॉडल के साथ काम करने के लिए प्लग इन मैनेज करती है:

• Google Cloud Vertex AI प्लग इन की मदद से, एलएलएम की Gemini फ़ैमिली
• Google के एआई प्लगिन की मदद से, एलएलएम की Gemini फ़ैमिली
• Google Cloud Vertex AI की मदद से, इमेज जनरेट करने वाले Imagen2 और Imagen3 मॉडल
• Google Cloud Vertex AI के मॉडल गार्डन की मदद से, Anthropic की एलएलएम की Claude 3 फ़ैमिली
• Ollama प्लग इन की मदद से, Gemma 2, Llama 3, और कई अन्य ओपन मॉडल (आपको Ollama सर्वर को खुद होस्ट करना होगा)

इसके अलावा, कम्यूनिटी के साथ काम करने वाले कई प्लग इन भी हैं, जो इन मॉडल के लिए इंटरफ़ेस उपलब्ध कराते हैं:

• Anthropic प्लगिन की मदद से, एलएलएम के Claude 3 फ़ैमिली
• OpenAI प्लग इन की मदद से, एलएलएम की GPT फ़ैमिली
• Azure OpenAI प्लग इन की मदद से, एलएलएम की GPT फ़ैमिली
• Cohere प्लग इन की मदद से, एलएलएम की R फ़ैमिली को कमांड देना
• Mistral प्लग इन की मदद से, एलएलएम की Mistral फ़ैमिली
• Groq प्लग इन की मदद से, Groq पर होस्ट किए गए Gemma 2, Llama 3, और कई अन्य ओपन मॉडल

npmjs.org पर, genkit-model से टैग किए गए पैकेज खोजकर, ज़्यादा जानकारी पाई जा सकती है.

मॉडल प्लग इन लोड और कॉन्फ़िगर करना

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

generate() तरीका

Genkit में, generate() तरीका वह मुख्य इंटरफ़ेस है जिसकी मदद से जनरेटिव एआई मॉडल के साथ इंटरैक्ट किया जाता है.

सबसे आसान generate() कॉल में, आपको जिस मॉडल का इस्तेमाल करना है और टेक्स्ट के लिए प्रॉम्प्ट की जानकारी दी जाती है:

import { gemini15Flash, googleAI } from '@genkit-ai/googleai';
import { genkit } from 'genkit';

const ai = genkit({
  plugins: [googleAI()],
  model: gemini15Flash,
});

(async () => {
  const { text } = await ai.generate(
    'Invent a menu item for a pirate themed restaurant.'
  );
  console.log(text);
})();

इस छोटे उदाहरण को चलाने पर, यह डीबग करने से जुड़ी कुछ जानकारी प्रिंट करेगा. इसके बाद, generate() कॉल का आउटपुट दिखेगा. आम तौर पर, यह Markdown टेक्स्ट होता है, जैसा कि इस उदाहरण में दिखाया गया है:

## The Blackheart's Bounty

**A hearty stew of slow-cooked beef, spiced with rum and molasses, served in a
hollowed-out cannonball with a side of crusty bread and a dollop of tangy
pineapple salsa.**

**Description:** This dish is a tribute to the hearty meals enjoyed by pirates
on the high seas. The beef is tender and flavorful, infused with the warm spices
of rum and molasses. The pineapple salsa adds a touch of sweetness and acidity,
balancing the richness of the stew. The cannonball serving vessel adds a fun and
thematic touch, making this dish a perfect choice for any pirate-themed
adventure.

स्क्रिप्ट को फिर से चलाएं और आपको एक अलग आउटपुट मिलेगा.

ऊपर दिए गए कोड सैंपल में, जनरेट करने का अनुरोध डिफ़ॉल्ट मॉडल पर भेजा गया है. इस मॉडल को Genkit इंस्टेंस को कॉन्फ़िगर करते समय तय किया जाता है.

किसी एक generate() कॉल के लिए भी मॉडल तय किया जा सकता है:

const { text } = await ai.generate({
  model: gemini15Pro,
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

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

const { text } = await ai.generate({
  model: 'googleai/gemini-1.5-pro-latest',
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

मॉडल स्ट्रिंग आइडेंटिफ़ायर providerid/modelid जैसा दिखता है. इसमें, प्रोवाइडर आईडी (इस मामले में, googleai) प्लग इन की पहचान करता है और मॉडल आईडी, प्लग इन के हिसाब से किसी मॉडल के खास वर्शन के लिए स्ट्रिंग आइडेंटिफ़ायर होता है.

Ollama प्लग इन जैसे कुछ मॉडल प्लग इन, संभावित रूप से दर्जनों अलग-अलग मॉडल का ऐक्सेस देते हैं. इसलिए, वे अलग-अलग मॉडल के रेफ़रंस एक्सपोर्ट नहीं करते. ऐसे मामलों में, generate() को सिर्फ़ स्ट्रिंग आइडेंटिफ़ायर का इस्तेमाल करके मॉडल के बारे में बताया जा सकता है.

इन उदाहरणों से एक अहम बात भी पता चलती है: जनरेटिव एआई मॉडल कॉल करने के लिए generate() का इस्तेमाल करने पर, जिस मॉडल का इस्तेमाल करना है उसे बदलने के लिए, मॉडल पैरामीटर में कोई दूसरी वैल्यू पास करना ज़रूरी है. नेटिव मॉडल एसडीके के बजाय generate() का इस्तेमाल करने पर, आपको अपने ऐप्लिकेशन में कई अलग-अलग मॉडल का इस्तेमाल करने और आने वाले समय में मॉडल बदलने की सुविधा मिलती है.

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

सिस्टम से मिलने वाले निर्देश

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

अगर इस्तेमाल किया जा रहा मॉडल, सिस्टम प्रॉम्प्ट के साथ काम करता है, तो system पैरामीटर के साथ एक प्रॉम्प्ट दिया जा सकता है:

const { text } = await ai.generate({
  system: 'You are a food industry marketing consultant.',
  prompt: 'Invent a menu item for a pirate themed restaurant.',
});

मॉडल के पैरामीटर

generate() फ़ंक्शन में एक config पैरामीटर होता है. इसकी मदद से, वैकल्पिक सेटिंग तय की जा सकती हैं. इनसे यह कंट्रोल होता है कि मॉडल, कॉन्टेंट कैसे जनरेट करता है:

const { text } = await ai.generate({
  prompt: 'Invent a menu item for a pirate themed restaurant.',
  config: {
    maxOutputTokens: 400,
    stopSequences: ['<end>', '<fin>'],
    temperature: 1.2,
    topP: 0.4,
    topK: 50,
  },
});

कौनसे पैरामीटर काम करते हैं, यह मॉडल और मॉडल एपीआई पर निर्भर करता है. हालांकि, पिछले उदाहरण में दिए गए पैरामीटर, ज़्यादातर मॉडल में एक जैसे होते हैं. इन पैरामीटर के बारे में यहां बताया गया है:

आउटपुट की लंबाई को कंट्रोल करने वाले पैरामीटर

maxOutputTokens

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

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

जैसा कि पहले बताया गया है, हो सकता है कि कुछ टोकन, वर्ण क्रम में मैप न हों. इसका एक उदाहरण यह है कि अक्सर एक टोकन होता है जो क्रम के आखिर में दिखता है: जब कोई एलएलएम यह टोकन जनरेट करता है, तो वह ज़्यादा जनरेट करना बंद कर देता है. इसलिए, यह मुमकिन है और अक्सर ऐसा होता है कि एलएलएम, ज़्यादा से ज़्यादा टोकन के मुकाबले कम टोकन जनरेट करता है, क्योंकि उसने "स्टॉप" टोकन जनरेट किया है.

stopSequences

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

ध्यान दें कि आपने वर्ण क्रम तय किए हैं, न कि टोकन. ज़्यादातर मामलों में, आपको एक कैरेक्टर सीक्वेंस तय करना होगा, जिसे मॉडल का टोकेनेटर एक टोकन पर मैप करता है.

"क्रिएटिविटी" को कंट्रोल करने वाले पैरामीटर

तापमान, top-p, और top-k पैरामीटर, यह कंट्रोल करते हैं कि आपको मॉडल कितना "क्रिएटिव" चाहिए. यहां इन पैरामीटर के बारे में कम शब्दों में बताया गया है कि इनका क्या मतलब है. हालांकि, सबसे अहम बात यह है कि इन पैरामीटर का इस्तेमाल, एलएलएम के आउटपुट के कैरेक्टर में बदलाव करने के लिए किया जाता है. इनके लिए सबसे सही वैल्यू, आपके लक्ष्यों और प्राथमिकताओं पर निर्भर करती हैं. साथ ही, ये वैल्यू सिर्फ़ प्रयोग करके ही मिल सकती हैं.

तापमान

एलएलएम, टोकन का अनुमान लगाने वाली मशीनें हैं. टोकन के किसी दिए गए क्रम (जैसे, प्रॉम्प्ट) के लिए, एलएलएम अपनी शब्दावली में मौजूद हर टोकन के लिए यह अनुमान लगाता है कि टोकन, क्रम में अगला होने की कितनी संभावना है. तापमान, स्केलिंग फ़ैक्टर होता है. इन अनुमानों को 0 से 1 के बीच की संभावना के लिए सामान्य बनाने से पहले, इनमें तापमान का इस्तेमाल किया जाता है.

कम तापमान की वैल्यू—0.0 से 1.0 के बीच—टोकन के बीच संभावनाओं में अंतर को बढ़ाती हैं. इस वजह से, मॉडल के लिए ऐसा टोकन जनरेट करने की संभावना और भी कम हो जाती है जिसका पहले ही आकलन किया जा चुका है कि वह जनरेट नहीं होगा. इसे अक्सर कम क्रिएटिव आउटपुट माना जाता है. तकनीकी तौर पर, 0.0 एक मान्य वैल्यू नहीं है. हालांकि, कई मॉडल इसे इस तरह से इस्तेमाल करते हैं कि मॉडल को तय तरीके से काम करना चाहिए और सिर्फ़ सबसे संभावित टोकन को ध्यान में रखना चाहिए.

1.0 से ज़्यादा की टेंपरेचर वैल्यू, टोकन के बीच संभावनाओं में अंतर को कम कर देती हैं. इस वजह से, मॉडल ऐसे टोकन जनरेट कर सकता है जिनके बारे में पहले यह अनुमान लगाया गया था कि वे जनरेट नहीं होंगे. इसे अक्सर ज़्यादा क्रिएटिव आउटपुट माना जाता है. कुछ मॉडल एपीआई, ज़्यादा से ज़्यादा तापमान की सीमा तय करते हैं. आम तौर पर, यह सीमा 2.0 होती है.

topP

Top-p, 0.0 से 1.0 के बीच की वैल्यू होती है. यह उन संभावित टोक़न की संख्या को कंट्रोल करती है जिन्हें मॉडल को इस्तेमाल करना है. इसके लिए, टोक़न की कुल संभावना तय की जाती है. उदाहरण के लिए, 1.0 की वैल्यू का मतलब है कि हर संभावित टोक़न को ध्यान में रखें. हालांकि, हर टोक़न की संभावना को भी ध्यान में रखें. 0.4 की वैल्यू का मतलब है कि सिर्फ़ उन सबसे संभावित टोकन को शामिल करना जिनकी संभावनाएं 0.4 तक जोड़ती हैं. साथ ही, बाकी टोकन को शामिल नहीं करना.

topK

Top-k एक पूर्णांक वैल्यू है. यह उन संभावित टोकन की संख्या को भी कंट्रोल करती है जिन्हें आपको मॉडल में शामिल करना है. हालांकि, इस बार टोकन की ज़्यादा से ज़्यादा संख्या को साफ़ तौर पर बताकर ऐसा किया जाता है. वैल्यू 1 तय करने का मतलब है कि मॉडल का व्यवहार तय होना चाहिए.

मॉडल पैरामीटर के साथ एक्सपेरिमेंट करना

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

स्ट्रक्चर्ड आउटपुट

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

Genkit में, generate() को कॉल करते समय स्कीमा तय करके, मॉडल से स्ट्रक्चर्ड आउटपुट का अनुरोध किया जा सकता है:

import { z } from 'genkit'; // Import Zod, which is re-exported by Genkit.

const MenuItemSchema = z.object({
  name: z.string(),
  description: z.string(),
  calories: z.number(),
  allergens: z.array(z.string()),
});

const { output } = await ai.generate({
  prompt: 'Invent a menu item for a pirate themed restaurant.',
  output: { schema: MenuItemSchema },
});

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

generate() में कोई स्कीमा तय करने पर, Genkit कई काम करता है:

• प्रॉम्प्ट में, पसंदीदा आउटपुट फ़ॉर्मैट के बारे में ज़्यादा दिशा-निर्देश जोड़ता है. इससे मॉडल को यह बताने का साइड इफ़ेक्ट भी होता है कि आपको किस तरह का कॉन्टेंट जनरेट करना है. उदाहरण के लिए, सिर्फ़ मेन्यू आइटम का सुझाव देना ही नहीं, बल्कि उसका ब्यौरा, एलर्जी वाले आइटम की सूची वगैरह जनरेट करना.
• मॉडल के आउटपुट को JavaScript ऑब्जेक्ट में पार्स करता है.
• यह पुष्टि करता है कि आउटपुट, स्कीमा के मुताबिक है या नहीं.

जनरेट किए गए कॉल से स्ट्रक्चर्ड आउटपुट पाने के लिए, रिस्पॉन्स ऑब्जेक्ट की output प्रॉपर्टी का इस्तेमाल करें:

if (output) {
  const { name, description, calories, allergens } = output;
}

गड़बड़ियों को मैनेज करना

पिछले उदाहरण में ध्यान दें कि output प्रॉपर्टी null हो सकती है. ऐसा तब हो सकता है, जब मॉडल स्कीमा के मुताबिक आउटपुट जनरेट न कर पाए. ऐसी गड़बड़ियों को ठीक करने का सबसे सही तरीका, आपके इस्तेमाल के उदाहरण पर निर्भर करेगा. हालांकि, यहां कुछ सामान्य सुझाव दिए गए हैं:

• कोई दूसरा मॉडल आज़माएं. स्ट्रक्चर्ड आउटपुट पाने के लिए, मॉडल को JSON में आउटपुट जनरेट करने की सुविधा होनी चाहिए. Gemini और Claude जैसे सबसे बेहतर एलएलएम, ऐसा करने के लिए काफ़ी बेहतर हैं. हालांकि, हो सकता है कि छोटे मॉडल, जैसे कि Ollama के साथ इस्तेमाल किए जाने वाले कुछ स्थानीय मॉडल, भरोसेमंद स्ट्रक्चर्ड आउटपुट जनरेट न कर पाएं. ऐसा तब तक होगा, जब तक उन्हें ऐसा करने के लिए खास तौर पर ट्रेन नहीं किया जाता.

• Zod की ज़बरदस्ती करने की सुविधाओं का इस्तेमाल करें: अपने स्कीमा में यह बताया जा सकता है कि Zod को, स्कीमा में बताए गए टाइप में, गलत टाइप को ज़बरदस्ती बदलने की कोशिश करनी चाहिए. अगर आपके स्कीमा में स्ट्रिंग के अलावा प्राइमटिव टाइप शामिल हैं, तो Zod के ज़रिए ज़बरदस्ती वैल्यू डालने की सुविधा का इस्तेमाल करके, generate() गड़बड़ियों की संख्या कम की जा सकती है. MenuItemSchema के इस वर्शन में, टाइप कोर्सर का इस्तेमाल करके उन स्थितियों को अपने-आप ठीक किया जाता है जहां मॉडल, कैलोरी की जानकारी को संख्या के बजाय स्ट्रिंग के तौर पर जनरेट करता है:

  const MenuItemSchema = z.object({
    name: z.string(),
    description: z.string(),
    calories: z.coerce.number(),
    allergens: z.array(z.string()),
  });
  

• generate() कॉल को फिर से आज़माएं. अगर आपने जो मॉडल चुना है वह कभी-कभी ही ज़रूरी शर्तें पूरी करने वाला आउटपुट जनरेट नहीं कर पाता है, तो इस गड़बड़ी को नेटवर्क से जुड़ी गड़बड़ी की तरह ही माना जा सकता है. साथ ही, किसी तरह की इंक्रीमेंटल बैक-ऑफ़ रणनीति का इस्तेमाल करके, अनुरोध को फिर से आज़माएं.

स्ट्रीमिंग

ज़्यादा टेक्स्ट जनरेट करते समय, आउटपुट को जनरेट होते ही दिखाकर, अपने उपयोगकर्ताओं के अनुभव को बेहतर बनाया जा सकता है. इसके लिए, आउटपुट को स्ट्रीम करें. स्ट्रीमिंग की सुविधा का उदाहरण, एलएलएम वाले ज़्यादातर चैट ऐप्लिकेशन में देखा जा सकता है: उपयोगकर्ता अपने मैसेज के जवाब को मॉडल के जनरेट होने के दौरान पढ़ सकते हैं. इससे, ऐप्लिकेशन के जवाब देने की क्षमता बेहतर होती है और उपयोगकर्ता को यह एहसास होता है कि वह किसी स्मार्ट चैट बॉट से बात कर रहा है.

Genkit में, generateStream() तरीके का इस्तेमाल करके आउटपुट स्ट्रीम किया जा सकता है. इसका सिंटैक्स, generate() तरीके से मिलता-जुलता है:

const { response, stream } = await ai.generateStream(
  'Suggest a complete menu for a pirate themed restaurant.'
);

रिस्पॉन्स ऑब्जेक्ट में stream प्रॉपर्टी होती है. इसका इस्तेमाल, अनुरोध के जनरेट होने के बाद, स्ट्रीमिंग आउटपुट पर बार-बार जाने के लिए किया जा सकता है:

for await (const chunk of stream) {
  console.log(chunk.text);
}

स्ट्रीमिंग के लिए अनुरोध करने पर भी, आपको अनुरोध का पूरा आउटपुट मिल सकता है, जैसे कि स्ट्रीमिंग के लिए अनुरोध न करने पर मिलता है:

const completeText = (await response).text;

स्ट्रीमिंग, स्ट्रक्चर्ड आउटपुट के साथ भी काम करती है:

const MenuSchema = z.object({
  starters: z.array(MenuItemSchema),
  mains: z.array(MenuItemSchema),
  desserts: z.array(MenuItemSchema),
});

const { response, stream } = await ai.generateStream({
  prompt: 'Suggest a complete menu for a pirate themed restaurant.',
  output: { schema: MenuSchema },
});

for await (const chunk of stream) {
  // `output` is an object representing the entire output so far.
  console.log(chunk.output);
}

// Get the completed output.
const { output } = await response;

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

उदाहरण के लिए, पिछले उदाहरण के पहले पांच आउटपुट ऐसे दिख सकते हैं:

null

{ starters: [ {} ] }

{
  starters: [ { name: "Captain's Treasure Chest", description: 'A' } ]
}

{
  starters: [
    {
      name: "Captain's Treasure Chest",
      description: 'A mix of spiced nuts, olives, and marinated cheese served in a treasure chest.',
      calories: 350
    }
  ]
}

{
  starters: [
    {
      name: "Captain's Treasure Chest",
      description: 'A mix of spiced nuts, olives, and marinated cheese served in a treasure chest.',
      calories: 350,
      allergens: [Array]
    },
    { name: 'Shipwreck Salad', description: 'Fresh' }
  ]
}

मल्टीमोडल इनपुट

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

मीडिया इनपुट स्वीकार करने की सुविधा और इस्तेमाल किए जा सकने वाले मीडिया टाइप, पूरी तरह से मॉडल और उसके एपीआई पर निर्भर करते हैं. उदाहरण के लिए, Gemini 1.5 के मॉडल, प्रॉम्प्ट के तौर पर इमेज, वीडियो, और ऑडियो स्वीकार कर सकते हैं.

अगर आपको किसी ऐसे मॉडल के लिए मीडिया प्रॉम्प्ट देना है जिसमें यह सुविधा काम करती है, तो generate को सिर्फ़ टेक्स्ट प्रॉम्प्ट देने के बजाय, मीडिया और टेक्स्ट, दोनों से जुड़ा कलेक्शन दें:

const { text } = await ai.generate([
  { media: { url: 'https://example.com/photo.jpg' } },
  { text: 'Compose a poem about this image.' },
]);

ऊपर दिए गए उदाहरण में, आपने सार्वजनिक तौर पर ऐक्सेस किए जा सकने वाले एचटीटीपीएस यूआरएल का इस्तेमाल करके, इमेज की जानकारी दी है. मीडिया डेटा को डेटा यूआरएल के तौर पर कोड करके, उसे सीधे तौर पर भी पास किया जा सकता है. उदाहरण के लिए:

import { readFile } from 'node:fs/promises';

const b64Data = await readFile('photo.jpg', { encoding: 'base64url' });
const dataUrl = `data:image/jpeg;base64,${b64Data}`;

const { text } = await ai.generate([
  { media: { url: dataUrl } },
  { text: 'Compose a poem about this image.' },
]);

मीडिया इनपुट की सुविधा वाले सभी मॉडल, डेटा यूआरएल और एचटीटीपीएस यूआरएल, दोनों के साथ काम करते हैं. कुछ मॉडल प्लग इन, अन्य मीडिया सोर्स के साथ काम करने की सुविधा जोड़ते हैं. उदाहरण के लिए, Vertex AI प्लग इन की मदद से, Cloud Storage (gs://) के यूआरएल भी इस्तेमाल किए जा सकते हैं.

मीडिया जनरेट करना

अब तक, इस पेज पर दिए गए ज़्यादातर उदाहरणों में, एलएलएम का इस्तेमाल करके टेक्स्ट जनरेट करने के बारे में बताया गया है. हालांकि, Genkit का इस्तेमाल इमेज जनरेशन मॉडल के साथ भी किया जा सकता है. इमेज जनरेट करने वाले मॉडल के साथ generate() का इस्तेमाल करना, एलएलएम का इस्तेमाल करने जैसा है. उदाहरण के लिए, Vertex AI की मदद से Imagen2 मॉडल का इस्तेमाल करके इमेज जनरेट करने के लिए:

1. Genkit, जनरेट किए गए मीडिया के लिए स्टैंडर्ड आउटपुट फ़ॉर्मैट के तौर पर data: यूआरएल का इस्तेमाल करता है. यह एक स्टैंडर्ड फ़ॉर्मैट है. इसे मैनेज करने के लिए, कई लाइब्रेरी उपलब्ध हैं. इस उदाहरण में, jsdom से data-urls पैकेज का इस्तेमाल किया गया है:

   npm i --save data-urls
   npm i --save-dev @types/data-urls

2. इमेज जनरेट करने और उसे फ़ाइल में सेव करने के लिए, generate() को कॉल करें. साथ ही, इमेज जनरेट करने के मॉडल और आउटपुट फ़ॉर्मैट के मीडिया टाइप की जानकारी दें:

   import { imagen3Fast, vertexAI } from '@genkit-ai/vertexai';
   import parseDataURL from 'data-urls';
   import { genkit } from 'genkit';
   
   import { writeFile } from 'node:fs/promises';
   
   const ai = genkit({
     plugins: [vertexAI({ location: 'us-central1' })],
   });
   
   (async () => {
     const { media } = await ai.generate({
       model: imagen3Fast,
       prompt: 'photo of a meal fit for a pirate',
       output: { format: 'media' },
     });
   
     if (media === null) throw new Error('No media generated.');
   
     const data = parseDataURL(media.url);
     if (data === null) throw new Error('Invalid "data:" URL.');
   
     await writeFile(`output.${data.mimeType.subtype}`, data.body);
   })();
   

अगले चरण

Genkit के बारे में ज़्यादा जानें

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

LLM के बेहतर इस्तेमाल के बारे में जानकारी

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

मॉडल के आउटपुट की जांच करना

सॉफ़्टवेयर इंजीनियर के तौर पर, आपको ऐसे सिस्टम के बारे में पता होता है जहां एक ही इनपुट से हमेशा एक ही आउटपुट मिलता है. हालांकि, एआई मॉडल के काम करने का तरीका, संभावनाओं पर आधारित होता है. इसलिए, इनपुट, मॉडल के ट्रेनिंग डेटा, और तापमान जैसे पैरामीटर की वजह से, एआई मॉडल के नतीजे अलग-अलग हो सकते हैं.

Genkit के एवैल्यूएटर, अलग-अलग रणनीतियों का इस्तेमाल करके, आपके एलएलएम के जवाबों की क्वालिटी का आकलन करने के लिए, व्यवस्थित तरीके से काम करते हैं. ज़्यादा जानकारी के लिए, मूल्यांकन पेज पर जाएं.