सिमैंटिक कॉन्टेंट वापस पाने की शुरुआत करना

ai.google.dev पर देखें Colab notebook को आज़माएं GitHub पर notebook देखें

खास जानकारी

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

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

यह notebook, बाहरी टेक्स्ट कॉर्पोरा की मदद से एलएलएम के जवाब को बेहतर बनाने के वर्कफ़्लो के बारे में जानकारी देता है. साथ ही, सिमैंटिक रिट्रीवर और एट्रिब्यूट किए गए सवाल और Generative Language API के एपीआई का जवाब देना (AQA) एपीआई.

सेटअप

Generative Language API इंपोर्ट करना

# Install the Client library (Semantic Retriever is only supported for versions >0.4.0)
pip install -U google.ai.generativelanguage

प्रमाणीकृत करें

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

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

सेवा खातों का इस्तेमाल करके, OAuth सेटअप करना

सेवा खातों का इस्तेमाल करके, OAuth सेट अप करने के लिए यह तरीका अपनाएं:

  1. Generative Language API चालू करना.

  1. दस्तावेज़ों में दिए गए निर्देशों का पालन करके, सेवा खाता बनाएं.

    • सेवा खाता बनाने के बाद, सेवा खाते की कुंजी जनरेट करें.

  1. सेवा खाते की फ़ाइल अपलोड करने के लिए, बाईं ओर साइडबार में फ़ाइल आइकॉन का इस्तेमाल करें. इसके बाद, नीचे दिए गए स्क्रीनशॉट में बताए गए तरीके से 'अपलोड करें' आइकॉन का इस्तेमाल करें.

    • अपलोड की गई फ़ाइल का नाम बदलकर service_account_key.json करें या नीचे दिए गए कोड में वैरिएबल service_account_file_name को बदलें.

pip install -U google-auth-oauthlib

service_account_file_name = 'service_account_key.json'

from google.oauth2 import service_account

credentials = service_account.Credentials.from_service_account_file(service_account_file_name)

scoped_credentials = credentials.with_scopes(
    ['https://www.googleapis.com/auth/cloud-platform', 'https://www.googleapis.com/auth/generative-language.retriever'])

सेवा खाते के क्रेडेंशियल का इस्तेमाल करके, क्लाइंट लाइब्रेरी को शुरू करें.

import google.ai.generativelanguage as glm
generative_service_client = glm.GenerativeServiceClient(credentials=scoped_credentials)
retriever_service_client = glm.RetrieverServiceClient(credentials=scoped_credentials)
permission_service_client = glm.PermissionServiceClient(credentials=scoped_credentials)

कॉर्पस (संग्रह) बनाएं

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

  • name: Corpus संसाधन का नाम (आईडी). ज़्यादा से ज़्यादा 40 अक्षर और अंक ही होने चाहिए. अगर name बनाते समय कोई वैल्यू नहीं दी जाती, तो ज़्यादा से ज़्यादा 40 वर्णों वाला यूनीक नाम जनरेट किया जाएगा. इसमें प्रीफ़िक्स display_name और 12 वर्णों का कोई सफ़िक्स शामिल किया जाएगा.
  • display_name: Corpus का डिसप्ले नेम, जिसे कोई भी व्यक्ति आसानी से पढ़ सकता है. इसमें ज़्यादा से ज़्यादा 512 वर्ण होने चाहिए. इनमें अक्षर और अंक, स्पेस, और डैश शामिल हैं.
example_corpus = glm.Corpus(display_name="Google for Developers Blog")
create_corpus_request = glm.CreateCorpusRequest(corpus=example_corpus)

# Make the request
create_corpus_response = retriever_service_client.create_corpus(create_corpus_request)

# Set the `corpus_resource_name` for subsequent sections.
corpus_resource_name = create_corpus_response.name
print(create_corpus_response)

name: "corpora/google-for-developers-blog-dqrtz8rs0jg"
display_name: "Google for Developers Blog"
create_time {
  seconds: 1713497533
  nanos: 587977000
}
update_time {
  seconds: 1713497533
  nanos: 587977000
}

बनाया गया संग्रह पाएं

आपने ऊपर जो Corpus बनाया है उसे प्रोग्राम के हिसाब से ऐक्सेस करने के लिए, GetCorpusRequest तरीके का इस्तेमाल करें. name पैरामीटर की वैल्यू, Corpus के पूरे संसाधन नाम के बारे में बताती है. साथ ही, यह वैल्यू ऊपर दी गई सेल में corpus_resource_name के तौर पर सेट है. सही फ़ॉर्मैट corpora/corpus-123 है.

get_corpus_request = glm.GetCorpusRequest(name=corpus_resource_name)

# Make the request
get_corpus_response = retriever_service_client.get_corpus(get_corpus_request)

# Print the response
print(get_corpus_response)

दस्तावेज़ बनाएँ

Corpus में, ज़्यादा से ज़्यादा 10,000 Document हो सकते हैं. अपने दस्तावेज़ों को परिभाषित करते समय आप इनमें से किसी एक फ़ील्ड को चुन सकते हैं:

  • name: Document संसाधन का नाम (आईडी). ज़्यादा से ज़्यादा 40 वर्ण (सिर्फ़ अक्षर और अंक या डैश) होने चाहिए. आईडी, किसी यूआरएल से शुरू या खत्म नहीं हो सकता डैश. अगर नाम बनाए जाने पर खाली है, तो उससे यूनीक नाम लिया जाएगा display_name और 12 वर्णों का कोई भी सफ़िक्स.
  • display_name: ऐप्लिकेशन का डिसप्ले नेम, जिसे कोई भी व्यक्ति आसानी से पढ़ सकता है. इसमें ज़्यादा से ज़्यादा 512 वर्ण होने चाहिए. इनमें अक्षर और अंक, स्पेस, और डैश शामिल हैं.

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

# Create a document with a custom display name.
example_document = glm.Document(display_name="Introducing Project IDX, An Experiment to Improve Full-stack, Multiplatform App Development")

# Add metadata.
# Metadata also supports numeric values not specified here
document_metadata = [
    glm.CustomMetadata(key="url", string_value="https://developers.googleblog.com/2023/08/introducing-project-idx-experiment-to-improve-full-stack-multiplatform-app-development.html")]
example_document.custom_metadata.extend(document_metadata)

# Make the request
# corpus_resource_name is a variable set in the "Create a corpus" section.
create_document_request = glm.CreateDocumentRequest(parent=corpus_resource_name, document=example_document)
create_document_response = retriever_service_client.create_document(create_document_request)

# Set the `document_resource_name` for subsequent sections.
document_resource_name = create_document_response.name
print(create_document_response)

बनाया गया दस्तावेज़ पाएं

आपने ऊपर जो दस्तावेज़ बनाया है उसे प्रोग्राम के हिसाब से ऐक्सेस करने के लिए, GetDocumentRequest तरीके का इस्तेमाल करें. name पैरामीटर की वैल्यू, दस्तावेज़ के पूरे संसाधन के नाम के बारे में बताती है. साथ ही, इसे ऊपर मौजूद सेल में document_resource_name के तौर पर सेट किया गया है. सही फ़ॉर्मैट corpora/corpus-123/documents/document-123 है.

get_document_request = glm.GetDocumentRequest(name=document_resource_name)

# Make the request
# document_resource_name is a variable set in the "Create a document" section.
get_document_response = retriever_service_client.get_document(get_document_request)

# Print the response
print(get_document_response)

डेटा डालें और दस्तावेज़ को कई हिस्सों में बांटना

सिमैंटिक डेटा का इस्तेमाल करते समय वेक्टर डेटाबेस से लौटाए गए कॉन्टेंट को ज़्यादा काम का बनाने के लिए, दस्तावेज़ का डेटा लेते समय, बड़े दस्तावेज़ों को छोटे-छोटे हिस्सों में या छोटे-छोटे हिस्सों में बांट लें.

Chunk, Document का एक सब-पार्ट है, जिसे वेक्टर दिखाने और स्टोरेज के लिए इंडिपेंडेंट यूनिट माना जाता है. Chunk में ज़्यादा से ज़्यादा 2043 टोकन हो सकते हैं. Corpus में ज़्यादा से ज़्यादा 10 लाख Chunk हो सकते हैं.

Document की तरह ही, Chunks में भी उपयोगकर्ताओं के हिसाब से बताए गए ज़्यादा से ज़्यादा 20 custom_metadata फ़ील्ड काम करते हैं. इन फ़ील्ड को की-वैल्यू पेयर के तौर पर बताया जाता है. कस्टम मेटाडेटा, स्ट्रिंग, स्ट्रिंग की सूची या अंकों वाला हो सकता है. ध्यान दें कि स्ट्रिंग की सूचियों में ज़्यादा से ज़्यादा 10 वैल्यू इस्तेमाल की जा सकती हैं. साथ ही, एपीआई में न्यूमेरिक वैल्यू को फ़्लोटिंग-पॉइंट नंबरों के तौर पर दिखाया जाता है.

यह गाइड Google के ओपन सोर्स htmlChunker का इस्तेमाल करती है.

इसके अलावा, LangChain या LlamaIndex को इस्तेमाल करने वाले कई हिस्से इस्तेमाल किए जा सकते हैं.

htmlChunker के ज़रिए एचटीएमएल और डेटा को अलग-अलग सेगमेंट में डालें

!pip install google-labs-html-chunker

from google_labs_html_chunker.html_chunker import HtmlChunker

from urllib.request import urlopen

किसी वेबसाइट के लिए एचटीएमएल डीओएम पाएं. यहां एचटीएमएल को सीधे पढ़ा जाता है, लेकिन JavaScript-इंजेक्टेड एचटीएमएल को शामिल करने के लिए, एचटीएमएल पोस्ट-रेंडरिंग का बेहतर तरीके से इस्तेमाल करें जैसे कि document.documentElement.innerHTML.

with(urlopen("https://developers.googleblog.com/2023/08/introducing-project-idx-experiment-to-improve-full-stack-multiplatform-app-development.html")) as f:
  html = f.read().decode("utf-8")

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

# Chunk the file using HtmlChunker
chunker = HtmlChunker(
    max_words_per_aggregate_passage=200,
    greedily_aggregate_sibling_nodes=True,
    html_tags_to_exclude={"noscript", "script", "style"},
)
passages = chunker.chunk(html)
print(passages)


# Create `Chunk` entities.
chunks = []
for passage in passages:
    chunk = glm.Chunk(data={'string_value': passage})
    # Optionally, you can add metadata to a chunk
    chunk.custom_metadata.append(glm.CustomMetadata(key="tags",
                                                    string_list_value=glm.StringList(
                                                        values=["Google For Developers", "Project IDX", "Blog", "Announcement"])))
    chunk.custom_metadata.append(glm.CustomMetadata(key="chunking_strategy",
                                                    string_value="greedily_aggregate_sibling_nodes"))
    chunk.custom_metadata.append(glm.CustomMetadata(key = "publish_date",
                                                    numeric_value = 20230808))
    chunks.append(chunk)
print(chunks)

बैच बनाएं

टुकड़ों को बैच में बनाएं. हर एक बैच के लिए अनुरोध के ज़्यादा से ज़्यादा 100 हिस्से तय किए जा सकते हैं.

डेटा का एक ग्रुप बनाने के लिए, CreateChunk() का इस्तेमाल करें.

# Option 1: Use HtmlChunker in the section above.
# `chunks` is the variable set from the section above.
create_chunk_requests = []
for chunk in chunks:
  create_chunk_requests.append(glm.CreateChunkRequest(parent=document_resource_name, chunk=chunk))

# Make the request
request = glm.BatchCreateChunksRequest(parent=document_resource_name, requests=create_chunk_requests)
response = retriever_service_client.batch_create_chunks(request)
print(response)

इसके अलावा, htmlChunker का इस्तेमाल किए बिना भी हिस्से बनाए जा सकते हैं.

# Add up to 100 CreateChunk requests per batch request.
# document_resource_name is a variable set in the "Create a document" section.
chunks = []
chunk_1 = glm.Chunk(data={'string_value': "Chunks support user specified metadata."})
chunk_1.custom_metadata.append(glm.CustomMetadata(key="section",
                                                  string_value="Custom metadata filters"))
chunk_2 = glm.Chunk(data={'string_value': "The maximum number of metadata supported is 20"})
chunk_2.custom_metadata.append(glm.CustomMetadata(key = "num_keys",
                                                  numeric_value = 20))
chunks = [chunk_1, chunk_2]
create_chunk_requests = []
for chunk in chunks:
  create_chunk_requests.append(glm.CreateChunkRequest(parent=document_resource_name, chunk=chunk))

# Make the request
request = glm.BatchCreateChunksRequest(parent=document_resource_name, requests=create_chunk_requests)
response = retriever_service_client.batch_create_chunks(request)
print(response)

Chunk की सूची बनाएं और राज्य का नाम पाएं

सभी उपलब्ध Chunk को, पेजों वाली सूची के तौर पर पाने के लिए, ListChunksRequest तरीके का इस्तेमाल करें. हर पेज के लिए, साइज़ की सीमा 100 Chunk से ज़्यादा नहीं होनी चाहिए. इसे Chunk.create_time के बढ़ते क्रम में लगाया जाता है. अगर सीमा की जानकारी नहीं दी जाती है, तो ज़्यादा से ज़्यादा 10 Chunk लौटाए जाते हैं.

अगला पेज वापस पाने के लिए, अगले अनुरोध के लिए तर्क के तौर पर, ListChunksRequest के जवाब में दिए गए next_page_token को उपलब्ध कराएं. ध्यान दें कि पेजों पर नंबर डालते समय, ListChunks को दिए गए अन्य सभी पैरामीटर, पेज टोकन देने वाले कॉल से मैच होने चाहिए.

सभी Chunk, state दिखाते हैं. Corpus की क्वेरी करने से पहले, Chunks की स्थिति की जांच करने के लिए इसका इस्तेमाल करें. Chunk राज्यों में शामिल हैं - UNSPECIFIED, PENDING_PROCESSING, ACTIVE, और FAILED. सिर्फ़ ACTIVE Chunk के लिए क्वेरी की जा सकती है.

# Make the request
request = glm.ListChunksRequest(parent=document_resource_name)
list_chunks_response = retriever_service_client.list_chunks(request)
for index, chunks in enumerate(list_chunks_response.chunks):
  print(f'\nChunk # {index + 1}')
  print(f'Resource Name: {chunks.name}')
  # Only ACTIVE chunks can be queried.
  print(f'State: {glm.Chunk.State(chunks.state).name}')

कोई दूसरा दस्तावेज़ डालें

htmlChunker के ज़रिए एक और Document जोड़ें और फ़िल्टर जोड़ें.

# Create a document with a custom display name.
example_document = glm.Document(display_name="How it’s Made: Interacting with Gemini through multimodal prompting")

# Add document metadata.
# Metadata also supports numeric values not specified here
document_metadata = [
    glm.CustomMetadata(key="url", string_value="https://developers.googleblog.com/2023/12/how-its-made-gemini-multimodal-prompting.html")]
example_document.custom_metadata.extend(document_metadata)

# Make the CreateDocument request
# corpus_resource_name is a variable set in the "Create a corpus" section.
create_document_request = glm.CreateDocumentRequest(parent=corpus_resource_name, document=example_document)
create_document_response = retriever_service_client.create_document(create_document_request)

# Set the `document_resource_name` for subsequent sections.
document_resource_name = create_document_response.name
print(create_document_response)

# Chunks - add another webpage from Google for Developers
with(urlopen("https://developers.googleblog.com/2023/12/how-its-made-gemini-multimodal-prompting.html")) as f:
  html = f.read().decode("utf-8")

# Chunk the file using HtmlChunker
chunker = HtmlChunker(
    max_words_per_aggregate_passage=100,
    greedily_aggregate_sibling_nodes=False,
)
passages = chunker.chunk(html)

# Create `Chunk` entities.
chunks = []
for passage in passages:
    chunk = glm.Chunk(data={'string_value': passage})
    chunk.custom_metadata.append(glm.CustomMetadata(key="tags",
                                                    string_list_value=glm.StringList(
                                                        values=["Google For Developers", "Gemini API", "Blog", "Announcement"])))
    chunk.custom_metadata.append(glm.CustomMetadata(key="chunking_strategy",
                                                    string_value="no_aggregate_sibling_nodes"))
    chunk.custom_metadata.append(glm.CustomMetadata(key = "publish_date",
                                                    numeric_value = 20231206))
    chunks.append(chunk)

# Make the request
create_chunk_requests = []
for chunk in chunks:
  create_chunk_requests.append(glm.CreateChunkRequest(parent=document_resource_name, chunk=chunk))
request = glm.BatchCreateChunksRequest(parent=document_resource_name, requests=create_chunk_requests)
response = retriever_service_client.batch_create_chunks(request)
print(response)

कॉर्पस (संग्रह) के बारे में क्वेरी करें

काम के पैसेज पाने के लिए सिमैंटिक खोज करने के लिए, QueryCorpusRequest तरीके का इस्तेमाल करें.

  • results_count: दिए जाने वाले पैसेज की संख्या बताएं. यह संख्या ज़्यादा से ज़्यादा 100 तक हो सकती है. अगर जानकारी नहीं दी गई है, तो एपीआई ज़्यादा से ज़्यादा 10 Chunks का अनुरोध करता है.
  • metadata_filters: chunk_metadata या document_metadata के हिसाब से फ़िल्टर करें. हर MetadataFilter, एक खास कुंजी से जुड़ा होना चाहिए. एक से ज़्यादा MetadataFilter ऑब्जेक्ट को लॉजिकल AND से जोड़ा जाता है. मिलती-जुलती मेटाडेटा फ़िल्टर की शर्तें, लॉजिकल OR से जोड़ी जाती हैं. कुछ उदाहरण:
(year >= 2020 OR year < 2010) AND (genre = drama OR genre = action)

metadata_filter = [
  {
    key = "document.custom_metadata.year"
    conditions = [
      {int_value = 2020, operation = GREATER_EQUAL},
      {int_value = 2010, operation = LESS}]
  },
  {
    key = "document.custom_metadata.genre"
    conditions = [
      {string_value = "drama", operation = EQUAL},
      {string_value = "action", operation = EQUAL} }]
  }]

ध्यान दें कि सिर्फ़ अंकों वाली वैल्यू, एक कुंजी के लिए "AND" का इस्तेमाल करती हैं. स्ट्रिंग मान एक ही कुंजी के लिए सिर्फ़ "OR" का समर्थन करते हैं.

("Google for Developers" in tags) and (20230314 > publish_date)

metadata_filter = [
 {
    key = "chunk.custom_metadata.tags"
    conditions = [
    {string_value = 'Google for Developers', operation = INCLUDES},
  },
  {
    key = "chunk.custom_metadata.publish_date"
    conditions = [
    {numeric_value = 20230314, operation = GREATER_EQUAL}]
  }]

user_query = "What is the purpose of Project IDX?"
results_count = 5

# Add metadata filters for both chunk and document.
chunk_metadata_filter = glm.MetadataFilter(key='chunk.custom_metadata.tags',
                                           conditions=[glm.Condition(
                                              string_value='Google For Developers',
                                              operation=glm.Condition.Operator.INCLUDES)])

# Make the request
# corpus_resource_name is a variable set in the "Create a corpus" section.
request = glm.QueryCorpusRequest(name=corpus_resource_name,
                                 query=user_query,
                                 results_count=results_count,
                                 metadata_filters=[chunk_metadata_filter])
query_corpus_response = retriever_service_client.query_corpus(request)
print(query_corpus_response)

एट्रिब्यूट किए गए सवालों के जवाब

अपने दस्तावेज़, कॉर्पस या पैसेज के किसी सेट पर एट्रिब्यूट किए गए सवालों के जवाब देने के लिए, GenerateAnswer तरीके का इस्तेमाल करें.

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

जिन मामलों में AQA चाहिए होता है, उनमें अलग-अलग एलएलएम इस्तेमाल करने के बजाय, GenerateAnswer के कई फ़ायदे होते हैं:

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

answerable_probability और “मुझे नहीं पता” समस्या

कुछ मामलों में, सवाल का सबसे सही जवाब यह होगा कि “मुझे नहीं पता”. उदाहरण के लिए, अगर दिए गए संदर्भ में सवाल का जवाब शामिल नहीं है, तो उस सवाल को “जवाब नहीं दिया जा सकता” माना जाएगा.

एक्यूए मॉडल ऐसे मामलों की पहचान करने में काफ़ी माहिर है. यह कई स्तर पर जवाब देने की क्षमता और जवाब न देने की क्षमता के बीच का अंतर भी बता सकता है.

हालांकि, आखिरी फ़ैसला लेने के लिए आपको GenerateAnswer API का इस्तेमाल करना पड़ता है. इसके लिए:

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

कम answerable_probability को इनमें से एक या उससे ज़्यादा वजहों से समझाया जा सकता है:

  • मॉडल को इस बात पर भरोसा नहीं है कि इसका जवाब सही है.
  • मॉडल को भरोसा नहीं है कि इसका जवाब, बताए गए पैसेज पर आधारित है; ऐसा हो सकता है कि इस सवाल का जवाब, दुनिया के बारे में दी गई जानकारी से लिया जाए. उदाहरण के लिए: question="1+1=?", passages=["2+2=4”] → answer=2, answerable_probability=0.02
  • मॉडल ने काम की जानकारी दी, जिससे सवाल का पूरा जवाब नहीं मिला. उदाहरण: question="Is it available in my size?, passages=["Available in sizes 5-11"] → answer="Yes it is available in sizes 5-11", answerable_probability=0.03"
  • जनरेट किए जाने के जवाब का अनुरोध करते समय, सही फ़ॉर्मैट में कोई सवाल नहीं पूछा गया.

answerable_probability का मान कम होने का मतलब है कि generateAnswerResponse.answer गलत या तथ्यों पर आधारित नहीं है. इसलिए, हमारा सुझाव है कि answerable_probability की जांच करके, जवाब को आगे प्रोसेस करें.

answerable_probability के कम होने पर, कुछ क्लाइंट ये काम कर सकते हैं:

  • "इस सवाल का जवाब नहीं दिया जा सका" मैसेज दिखाएं असली उपयोगकर्ता को दिखता है.
  • अलग-अलग कामों के लिए बनाए जाने वाले एलएलएम का इस्तेमाल शुरू करें. यहां आपको दुनिया के बारे में अपने सवालों के जवाब मिलेंगे. ऐसे फ़ॉलबैक का थ्रेशोल्ड और किस तरह का है, यह हर मामले में अलग-अलग इस्तेमाल के उदाहरणों पर निर्भर करेगा. वैल्यू के तौर पर answerable_probability <= 0.5, एक अच्छी शुरुआती थ्रेशोल्ड है.

AQA से जुड़ी काम की सलाह

एपीआई की पूरी जानकारी के लिए, GenerateAnswerRequest एपीआई का रेफ़रंस देखें.

  • पैसेज की अवधि: हर पैसेज के लिए 300 टोकन तक रखने का सुझाव दिया जाता है.
  • पैसेज को क्रम में लगाना:
    • अगर आपने GenerateAnswerRequest.inline_passages दिया है, तो पैसेज को क्वेरी के हिसाब से घटते क्रम में लगाया जाना चाहिए. अगर मॉडल में कॉन्टेक्स्ट के लिए वर्ण सीमा पार हो जाती है, तो आखिरी (सबसे कम काम के) पैसेज हटा दिए जाएंगे.
    • GenerateAnswerRequest.semantic_retriever उपलब्ध कराने पर, ज़रूरत के हिसाब से क्रम में लगाने की प्रक्रिया अपने-आप पूरी हो जाएगी.
  • सीमाएं: AQA मॉडल को सवालों के जवाब देने के लिए खास तौर पर बनाया गया है. क्रिएटिव तरीके से लिखने, खास जानकारी देने वगैरह जैसे अन्य मामलों के लिए, कृपया generateContent की मदद से सामान्य मकसद वाले मॉडल को कॉल करें.
    • चैट: अगर उपयोगकर्ता का इनपुट कोई ऐसा सवाल है जिसका जवाब किसी खास संदर्भ में दिया जा सकता है, तो AQA चैट क्वेरी का जवाब दे सकता है. हालांकि, अगर उपयोगकर्ता का इनपुट किसी भी तरह का हो सकता है, तो अलग-अलग कामों के लिए इस्तेमाल किया जाने वाला मॉडल बेहतर विकल्प हो सकता है.
  • तापमान:
    • आम तौर पर, सटीक एक्यूआई के लिए, सामान्य से कम (~0.2) तापमान का सुझाव दिया जाता है.
    • अगर आपके इस्तेमाल का उदाहरण डिटरमिनिस्टिक आउटपुट पर निर्भर करता है, तो तापमान=0 सेट करें.
user_query = "What is the purpose of Project IDX?"
answer_style = "ABSTRACTIVE" # Or VERBOSE, EXTRACTIVE
MODEL_NAME = "models/aqa"

# Make the request
# corpus_resource_name is a variable set in the "Create a corpus" section.
content = glm.Content(parts=[glm.Part(text=user_query)])
retriever_config = glm.SemanticRetrieverConfig(source=corpus_resource_name, query=content)
req = glm.GenerateAnswerRequest(model=MODEL_NAME,
                                contents=[content],
                                semantic_retriever=retriever_config,
                                answer_style=answer_style)
aqa_response = generative_service_client.generate_answer(req)
print(aqa_response)

# Get the metadata from the first attributed passages for the source
chunk_resource_name = aqa_response.answer.grounding_attributions[0].source_id.semantic_retriever_chunk.chunk
get_chunk_response = retriever_service_client.get_chunk(name=chunk_resource_name)
print(get_chunk_response)

ज़्यादा विकल्प: इनलाइन पैसेज का इस्तेमाल करके AQA को इस्तेमाल करना

इसके अलावा, inline_passages पास करके, सिमैंटिक रिट्रीवर एपीआई का इस्तेमाल किए बिना, एक्यूआई एंडपॉइंट का सीधे तौर पर इस्तेमाल किया जा सकता है.

user_query = "What is AQA from Google?"
user_query_content = glm.Content(parts=[glm.Part(text=user_query)])
answer_style = "VERBOSE" # or ABSTRACTIVE, EXTRACTIVE
MODEL_NAME = "models/aqa"

# Create the grounding inline passages
grounding_passages = glm.GroundingPassages()
passage_a = glm.Content(parts=[glm.Part(text="Attributed Question and Answering (AQA) refers to answering questions grounded to a given corpus and providing citation")])
grounding_passages.passages.append(glm.GroundingPassage(content=passage_a, id="001"))
passage_b = glm.Content(parts=[glm.Part(text="An LLM is not designed to generate content grounded in a set of passages. Although instructing an LLM to answer questions only based on a set of passages reduces hallucination, hallucination still often occurs when LLMs generate responses unsupported by facts provided by passages")])
grounding_passages.passages.append(glm.GroundingPassage(content=passage_b, id="002"))
passage_c = glm.Content(parts=[glm.Part(text="Hallucination is one of the biggest problems in Large Language Models (LLM) development. Large Language Models (LLMs) could produce responses that are fictitious and incorrect, which significantly impacts the usefulness and trustworthiness of applications built with language models.")])
grounding_passages.passages.append(glm.GroundingPassage(content=passage_c, id="003"))

# Create the request
req = glm.GenerateAnswerRequest(model=MODEL_NAME,
                                contents=[user_query_content],
                                inline_passages=grounding_passages,
                                answer_style=answer_style)
aqa_response = generative_service_client.generate_answer(req)
print(aqa_response)

कॉर्पस (संग्रह) शेयर करें

CreatePermissionRequest एपीआई का इस्तेमाल करके, इस संग्रह को अन्य लोगों के साथ शेयर किया जा सकता है.

पाबंदियां:

  • शेयर करने के लिए दो भूमिकाएं हैं: READER और EDITOR.
    • READER, कॉर्पस (संग्रह) पर क्वेरी कर सकता है.
    • WRITER के पास लोगों की अनुमतियां होती हैं. साथ ही, वह संग्रह में बदलाव कर सकता है और उसे शेयर भी कर सकता है.
  • EVERYONE को user_type पढ़ने का ऐक्सेस देकर, कॉर्पस को सार्वजनिक किया जा सकता है.
# Replace your-email@gmail.com with the email added as a test user in the OAuth Quickstart
shared_user_email = "TODO-your-email@gmail.com" #  @param {type:"string"}
user_type = "USER"
role = "READER"

# Make the request
# corpus_resource_name is a variable set in the "Create a corpus" section.
request = glm.CreatePermissionRequest(
    parent=corpus_resource_name,
    permission=glm.Permission(grantee_type=user_type,
                              email_address=shared_user_email,
                              role=role))
create_permission_response = permission_service_client.create_permission(request)
print(create_permission_response)

कॉर्पस (संग्रह) मिटाएं

उपयोगकर्ताओं के संग्रह और उससे जुड़े सभी Document औरDeleteCorpusRequest Chunks.

ध्यान दें कि जो कॉर्पोरा खाली नहीं है, उससे force=True फ़्लैग तय किए बिना गड़बड़ी मिलेगी. अगर force=True को सेट किया जाता है, तो इस Document से जुड़े सभी Chunk और ऑब्जेक्ट भी मिटा दिए जाएंगे.

अगर force=False (डिफ़ॉल्ट) और Document में कोई Chunk हो, तो FAILED_PRECONDITION गड़बड़ी मिलेगी.

# Set force to False if you don't want to delete non-empty corpora.
req = glm.DeleteCorpusRequest(name=corpus_resource_name, force=True)
delete_corpus_response = retriever_service_client.delete_corpus(req)
print("Successfully deleted corpus: " + corpus_resource_name)

खास जानकारी और आगे का लेख

इस गाइड में सिमैंटिक रिट्रीवर और एट्रिब्यूट किए गए सवाल और इनके बारे में जानकारी दी गई है Generative Language API के एपीआई का जवाब देना और दिखाया गया था कि कस्टम टेक्स्ट डेटा से सिमैंटिक जानकारी पाने के लिए, इसका इस्तेमाल कैसे किया जा सकता है. ध्यान दें कि यह एपीआई LlamaIndex डेटा फ़्रेमवर्क के साथ भी काम करता है. ज़्यादा जानने के लिए ट्यूटोरियल देखें.

साथ ही, अन्य उपलब्ध फ़ंक्शन के बारे में ज़्यादा जानने के लिए, एपीआई के दस्तावेज़ देखें.

अपेंडिक्स: उपयोगकर्ता के क्रेडेंशियल की मदद से OAuth सेटअप करना

OAuth से पुष्टि करने की सुविधा सेट अप करने के लिए, OAuth क्विकस्टार्ट से नीचे दिया गया तरीका अपनाएं.

  1. उस स्क्रीन को कॉन्फ़िगर करें जहां OAuth के लिए सहमति दी जाती है.

  2. डेस्कटॉप ऐप्लिकेशन के लिए क्रेडेंशियल को अनुमति दें. इस notebook को Colab में चलाने के लिए, पहले अपनी क्रेडेंशियल फ़ाइल (आम तौर पर client_secret_*.json) का नाम बदलकर सिर्फ़ client_secret.json करें. इसके बाद, बाईं ओर साइडबार पर फ़ाइल आइकॉन का इस्तेमाल करके, फिर अपलोड आइकॉन का इस्तेमाल करके फ़ाइल अपलोड करें, जैसा कि नीचे स्क्रीनशॉट में दिखाया गया है.

# Replace TODO-your-project-name with the project used in the OAuth Quickstart
project_name = "TODO-your-project-name" #  @param {type:"string"}
# Replace TODO-your-email@gmail.com with the email added as a test user in the OAuth Quickstart
email = "TODO-your-email@gmail.com" #  @param {type:"string"}
# Rename the uploaded file to `client_secret.json` OR
# Change the variable `client_file_name` in the code below.
client_file_name = "client_secret.json"

# IMPORTANT: Follow the instructions from the output - you must copy the command
# to your terminal and copy the output after authentication back here.
!gcloud config set project $project_name
!gcloud config set account $email

# NOTE: The simplified project setup in this tutorial triggers a "Google hasn't verified this app." dialog.
# This is normal, click "Advanced" -> "Go to [app name] (unsafe)"
!gcloud auth application-default login --no-browser --client-id-file=$client_file_name --scopes="https://www.googleapis.com/auth/generative-language.retriever,https://www.googleapis.com/auth/cloud-platform"

क्लाइंट लाइब्रेरी शुरू करें और कॉर्पस बनाएं से शुरू करते हुए, notebook को फिर से चलाएं.

import google.ai.generativelanguage as glm

generative_service_client = glm.GenerativeServiceClient()
retriever_service_client = glm.RetrieverServiceClient()
permission_service_client = glm.PermissionServiceClient()