Gemini API की मदद से, दस्तावेज़ को प्रोसेस करने से जुड़ी सुविधाओं के बारे में जानें

Gemini API, PDF इनपुट के साथ काम करता है. इसमें लंबे दस्तावेज़ (ज़्यादा से ज़्यादा 3,600 पेज) भी शामिल हैं. Gemini मॉडल, नेटिव विज़न की मदद से PDF को प्रोसेस करते हैं. इसलिए, ये दस्तावेज़ों में मौजूद टेक्स्ट और इमेज, दोनों कॉन्टेंट को समझ सकते हैं. PDF व्यू की नेटिव सुविधा की मदद से, Gemini मॉडल ये काम कर सकते हैं:

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

इस ट्यूटोरियल में, PDF दस्तावेज़ों के साथ Gemini API का इस्तेमाल करने के कुछ संभावित तरीके दिखाए गए हैं. पूरा आउटपुट सिर्फ़ टेक्स्ट में होता है.

शुरू करने से पहले: अपना प्रोजेक्ट और एपीआई पासकोड सेट अप करना

Gemini API को कॉल करने से पहले, आपको अपना प्रोजेक्ट सेट अप करना होगा और अपनी एपीआई पासकोड को कॉन्फ़िगर करना होगा.

PDF फ़ाइलों के साथ प्रॉम्प्ट करना

इस गाइड में, File API का इस्तेमाल करके या उन्हें इनलाइन डेटा के तौर पर शामिल करके, PDF अपलोड करने और प्रोसेस करने का तरीका बताया गया है.

तकनीकी ब्यौरे

Gemini 1.5 Pro और 1.5 Flash, ज़्यादा से ज़्यादा 3,600 पेजों वाले दस्तावेज़ के साथ काम करते हैं. दस्तावेज़ के पेज, टेक्स्ट डेटा के इनमें से किसी एक MIME टाइप में होने चाहिए:

  • PDF - application/pdf
  • JavaScript - application/x-javascript, text/javascript
  • Python - application/x-python, text/x-python
  • TXT - text/plain
  • एचटीएमएल - text/html
  • सीएसएस - text/css
  • मार्कडाउन - text/md
  • CSV - text/csv
  • एक्सएमएल - text/xml
  • RTF - text/rtf

दस्तावेज़ का हर पेज 258 टोकन के बराबर होता है.

मॉडल की कॉन्टेक्स्ट विंडो के अलावा, किसी दस्तावेज़ में पिक्सल की संख्या की कोई खास सीमा नहीं होती. हालांकि, बड़े पेजों को 3072x3072 पिक्सल के ज़्यादा से ज़्यादा रिज़ॉल्यूशन पर स्केल किया जाता है. साथ ही, उनके ओरिजनल आसपेक्ट रेशियो को बनाए रखा जाता है. वहीं, छोटे पेजों को 768x768 पिक्सल तक स्केल किया जाता है. कम साइज़ वाले पेजों के लिए, बैंडविड्थ के अलावा कोई और शुल्क नहीं लिया जाता. इसके अलावा, ज़्यादा रिज़ॉल्यूशन वाले पेजों की परफ़ॉर्मेंस भी बेहतर नहीं होती.

सर्वोत्तम परिणामों के लिएः

  • अपलोड करने से पहले, पेजों को सही ओरिएंटेशन में घुमाएं.
  • धुंधले पेजों का इस्तेमाल न करें.
  • अगर एक पेज का इस्तेमाल किया जा रहा है, तो टेक्स्ट प्रॉम्प्ट को पेज के बाद रखें.

PDF इनपुट

20 एमबी से कम साइज़ के PDF पेलोड के लिए, आपके पास base64 में कोड किए गए दस्तावेज़ अपलोड करने या सीधे तौर पर लोकल स्टोरेज में मौजूद फ़ाइलें अपलोड करने का विकल्प होता है.

Base64 में एन्कोड किए गए दस्तावेज़

PDF दस्तावेज़ों को सीधे यूआरएल से प्रोसेस किया जा सकता है. ऐसा करने का तरीका बताने वाला कोड स्निपेट यहां दिया गया है:

import httpx
import base64

model = genai.GenerativeModel("gemini-1.5-flash")
doc_url = "https://discovery.ucl.ac.uk/id/eprint/10089234/1/343019_3_art_0_py4t4l_convrt.pdf"  # Replace with the actual URL of your PDF

# Retrieve and encode the PDF
doc_data = base64.standard_b64encode(httpx.get(doc_url).content).decode("utf-8")

prompt = "Summarize this document"

response = model.generate_content([{'mime_type':'application/pdf', 'data': doc_data}, prompt])
print(response.text)

डिवाइस पर सेव की गई PDF फ़ाइलें

डिवाइस में सेव किए गए PDF फ़ाइलों के लिए, यह तरीका अपनाएं:

import base64

model = genai.GenerativeModel("gemini-1.5-flash")
doc_path = "/path/to/file.pdf" # Replace with the actual path to your local PDF

# Read and encode the local file
with open(doc_path, "rb") as doc_file:
    doc_data = base64.standard_b64encode(doc_file.read()).decode("utf-8")

prompt = "Summarize this document"

response = model.generate_content([{'mime_type': 'application/pdf', 'data': doc_data}, prompt])

print(response.text)

बड़े साइज़ के PDF

किसी भी साइज़ का दस्तावेज़ अपलोड करने के लिए, File API का इस्तेमाल किया जा सकता है. जब अनुरोध का कुल साइज़ (इसमें फ़ाइलें, टेक्स्ट प्रॉम्प्ट, सिस्टम के निर्देश वगैरह शामिल हैं) 20 एमबी से ज़्यादा हो, तो हमेशा File API का इस्तेमाल करें.

File API का इस्तेमाल करके फ़ाइल अपलोड करने के लिए, media.upload को कॉल करें. नीचे दिया गया कोड, दस्तावेज़ फ़ाइल को अपलोड करता है. इसके बाद, models.generateContent को कॉल करने के लिए फ़ाइल का इस्तेमाल करता है.

यूआरएल से बड़े पीडीएफ़ (:#large-pdfs-urls)

यूआरएल से उपलब्ध बड़ी PDF फ़ाइलों के लिए, File API का इस्तेमाल करें. इससे, इन दस्तावेज़ों को सीधे उनके यूआरएल से अपलोड करने और प्रोसेस करने की प्रोसेस को आसान बनाया जा सकता है:

import io
import httpx

model = genai.GenerativeModel("gemini-1.5-flash")
long_context_pdf_path = "https://www.nasa.gov/wp-content/uploads/static/history/alsj/a17/A17_FlightPlan.pdf" # Replace with the actual URL of your large PDF

# Retrieve and upload the PDF using the File API
doc_data = io.BytesIO(httpx.get(long_context_pdf_path).content)
sample_doc = genai.upload_file(data=doc_data, mime_type='application/pdf')

prompt = "Summarize this document"

response = model.generate_content([sample_doc, prompt])
print(response.text)

डिवाइस में सेव की गई बड़ी PDF फ़ाइलें (:#large-pdfs-local)

import google.generativeai as genai

model = genai.GenerativeModel("gemini-1.5-flash")
sample_pdf = genai.upload_file(media / "test.pdf")
response = model.generate_content(["Give me a summary of this pdf file.", sample_pdf])
print(response.text)
files.py

files.get को कॉल करके, यह पुष्टि की जा सकती है कि अपलोड की गई फ़ाइल को एपीआई ने सही से सेव किया है या नहीं. साथ ही, इसका मेटाडेटा भी पाया जा सकता है. सिर्फ़ name (और एक्सटेंशन के तौर पर, uri) यूनीक है.

import google.generativeai as genai

myfile = genai.upload_file(media / "poem.txt")
file_name = myfile.name
print(file_name)  # "files/*"

myfile = genai.get_file(file_name)
print(myfile)
files.py

एक से ज़्यादा PDF

Gemini API, एक ही अनुरोध में कई PDF दस्तावेज़ों को प्रोसेस कर सकता है. हालांकि, ऐसा तब ही होगा, जब दस्तावेज़ों और टेक्स्ट प्रॉम्प्ट का कुल साइज़, मॉडल की कॉन्टेक्स्ट विंडो में रहे.

import io
import httpx

model = genai.GenerativeModel("gemini-1.5-flash")

doc_url_1 = "https://arxiv.org/pdf/2312.11805" # Replace with the URL to your first PDF
doc_url_2 = "https://arxiv.org/pdf/2403.05530" # Replace with the URL to your second PDF

# Retrieve and upload both PDFs using the File API
doc_data_1 = io.BytesIO(httpx.get(doc_url_1).content)
doc_data_2 = io.BytesIO(httpx.get(doc_url_2).content)

sample_pdf_1 = genai.upload_file(data=doc_data_1, mime_type='application/pdf')
sample_pdf_2 = genai.upload_file(data=doc_data_2, mime_type='application/pdf')

prompt = "What is the difference between each of the main benchmarks between these two papers? Output these in a table."

response = model.generate_content([sample_pdf_1, sample_pdf_2, prompt])
print(response.text)

फ़ाइलों की सूची

files.list का इस्तेमाल करके, File API और उनके यूआरआई का इस्तेमाल करके अपलोड की गई सभी फ़ाइलों की सूची बनाई जा सकती है.

import google.generativeai as genai

print("My files:")
for f in genai.list_files():
    print("  ", f.name)
files.py

फ़ाइलें मिटाना

File API का इस्तेमाल करके अपलोड की गई फ़ाइलें, दो दिन बाद अपने-आप मिट जाती हैं. files.delete का इस्तेमाल करके, उन्हें मैन्युअल तरीके से भी मिटाया जा सकता है.

import google.generativeai as genai

myfile = genai.upload_file(media / "poem.txt")

myfile.delete()

try:
    # Error.
    model = genai.GenerativeModel("gemini-1.5-flash")
    result = model.generate_content([myfile, "Describe this file."])
except google.api_core.exceptions.PermissionDenied:
    pass
files.py

PDF फ़ाइलों के साथ कॉन्टेक्स्ट कैश मेमोरी का इस्तेमाल करना

import os
from google.generativeai import caching
import io
import httpx

# Define the path to the PDF document (or use a URL)
long_context_pdf_path = "https://www.nasa.gov/wp-content/uploads/static/history/alsj/a17/A17_FlightPlan.pdf" # Replace with the URL of your large PDF
doc_data = io.BytesIO(httpx.get(long_context_pdf_path).content)

# Upload the PDF document using the File API
document = genai.upload_file(data=doc_data, mime_type='application/pdf')

# Specify the model name and system instruction for caching
model_name = "gemini-1.5-flash-002" # Ensure this matches the model you intend to use
system_instruction = "You are an expert analyzing transcripts."

# Create a cached content object
cache = caching.CachedContent.create(
    model=model_name,
    system_instruction=system_instruction,
    contents=[document], # The document(s) and other content you wish to cache
)

# Display the cache details
print(cache)

# Initialize a generative model from the cached content
model = genai.GenerativeModel.from_cached_content(cache)

# Generate content using the cached prompt and document
response = model.generate_content("Please summarize this transcript")

# (Optional) Print usage metadata for insights into the API call
print(response.usage_metadata)

# Print the generated text
print(response.text)

कैश मेमोरी की सूची बनाना

कैश मेमोरी में सेव किए गए कॉन्टेंट को वापस पाना या देखना मुमकिन नहीं है. हालांकि, कैश मेमोरी में सेव किए गए मेटाडेटा (name, model, display_name, usage_metadata, create_time, update_time, और expire_time) को वापस पाया जा सकता है.

अपलोड किए गए सभी कैश मेमोरी के मेटाडेटा की सूची देखने के लिए, CachedContent.list() का इस्तेमाल करें:

for c in caching.CachedContent.list():
  print(c)

कैश मेमोरी अपडेट करना

कैश मेमोरी के लिए, नया ttl या expire_time सेट किया जा सकता है. कैश मेमोरी के बारे में कुछ और बदलाव नहीं किया जा सकता.

यहां दिए गए उदाहरण में, CachedContent.update() का इस्तेमाल करके कैश मेमोरी के ttl को अपडेट करने का तरीका बताया गया है.

import datetime

cache.update(ttl=datetime.timedelta(hours=2))

कैश मेमोरी मिटाना

कैश मेमोरी सेवा, कैश मेमोरी से कॉन्टेंट को मैन्युअल तरीके से हटाने के लिए, मिटाने की सुविधा देती है. यहां दिए गए उदाहरण में, CachedContent.delete() का इस्तेमाल करके कैश मेमोरी मिटाने का तरीका बताया गया है.

cache.delete()

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

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

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