Funktionen zur Dokumentverarbeitung mit der Gemini API kennenlernen

Die Gemini API unterstützt die PDF-Eingabe, einschließlich langer Dokumente (bis zu 3.600 Seiten). Gemini-Modelle verarbeiten PDFs mit nativer Bilderkennung und können daher sowohl Text als auch Bildinhalte in Dokumenten verstehen. Dank der nativen Unterstützung für die PDF-Datenerkennung können Gemini-Modelle Folgendes tun:

  • Diagramme, Grafiken und Tabellen in Dokumenten analysieren
  • Informationen in strukturierte Ausgabeformate extrahieren.
  • Beantworten Sie Fragen zu visuellen und Textinhalten in Dokumenten.
  • Dokumente zusammenfassen
  • Dokumentinhalte (z. B. in HTML) mit Beibehaltung von Layout und Formatierung transkribieren, um sie in nachfolgenden Anwendungen (z. B. in RAG-Pipelines) zu verwenden.

In dieser Anleitung werden einige Möglichkeiten zur Verwendung der Gemini API mit PDF-Dokumenten veranschaulicht. Die gesamte Ausgabe besteht aus Text.

Bevor Sie beginnen: Projekt und API-Schlüssel einrichten

Bevor Sie die Gemini API aufrufen können, müssen Sie Ihr Projekt einrichten und Ihren API-Schlüssel konfigurieren.

Prompts mit PDFs

In diesem Leitfaden wird gezeigt, wie Sie PDFs mit der File API hochladen und verarbeiten oder sie als Inline-Daten einfügen.

Technische Details

Gemini 1.5 Pro und 1.5 Flash unterstützen maximal 3.600 Dokumentseiten. Dokumentseiten müssen einen der folgenden MIME-Typen für Textdaten haben:

  • PDF – application/pdf
  • JavaScript – application/x-javascript, text/javascript
  • Python – application/x-python, text/x-python
  • TXT – text/plain
  • HTML – text/html
  • Preisvergleichsportal – text/css
  • Markdown – text/md
  • CSV – text/csv
  • XML – text/xml
  • RTF – text/rtf

Jede Dokumentseite entspricht 258 Tokens.

Die Anzahl der Pixel in einem Dokument ist abgesehen vom Kontextfenster des Modells nicht begrenzt. Größere Seiten werden jedoch auf eine maximale Auflösung von 3.072 × 3.072 herunterskaliert, wobei ihr ursprüngliches Seitenverhältnis beibehalten wird. Kleinere Seiten werden auf 768 × 768 Pixel skaliert. Es gibt keine Kosteneinsparungen für Seiten mit niedrigerer Größe, abgesehen von der Bandbreite, und keine Leistungsverbesserung für Seiten mit höherer Auflösung.

Für optimale Ergebnisse:

  • Drehen Sie die Seiten vor dem Hochladen in die richtige Ausrichtung.
  • Vermeiden Sie unscharfe Seiten.
  • Wenn Sie eine einzelne Seite verwenden, platzieren Sie den Textprompt nach der Seite.

PDF-Eingabe

Bei PDF-Nutzlast unter 20 MB können Sie zwischen dem Hochladen von Base64-codierten Dokumenten oder dem direkten Hochladen lokal gespeicherter Dateien wählen.

Base64-codierte Dokumente

Sie können PDF-Dokumente direkt über URLs verarbeiten. Hier ist ein Code-Snippet, das zeigt, wie das geht:

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)

Lokal gespeicherte PDFs

Für lokal gespeicherte PDFs können Sie den folgenden Ansatz verwenden:

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)

Große PDFs

Mit der File API können Sie Dokumente beliebiger Größe hochladen. Verwenden Sie immer die File API, wenn die Gesamtgröße der Anfrage (einschließlich der Dateien, des Textprompts, der Systemanweisungen usw.) mehr als 20 MB beträgt.

Rufe media.upload auf, um eine Datei mit der File API hochzuladen. Im folgenden Code wird eine Dokumentdatei hochgeladen und dann in einem Aufruf von models.generateContent verwendet.

Große PDFs über URLs (:#large-pdfs-urls)

Verwenden Sie die File API für große PDF-Dateien, die über URLs verfügbar sind. So wird der Upload und die Verarbeitung dieser Dokumente direkt über ihre URLs vereinfacht:

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)

Lokal gespeicherte große PDFs (:#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

Sie können prüfen, ob die API die hochgeladene Datei erfolgreich gespeichert hat, und die zugehörigen Metadaten abrufen, indem Sie files.get aufrufen. Nur die name (und in gewissem Maße auch die uri) sind eindeutig.

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

Mehrere PDFs

Die Gemini API kann mehrere PDF-Dokumente in einer einzigen Anfrage verarbeiten, solange die Gesamtgröße der Dokumente und des Textprompts innerhalb des Kontextfensters des Modells liegt.

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)

Dateien auflisten

Mit files.list können Sie alle mit der File API hochgeladenen Dateien und ihre URIs auflisten.

import google.generativeai as genai

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

Dateien löschen

Dateien, die mit der File API hochgeladen wurden, werden nach zwei Tagen automatisch gelöscht. Sie können sie auch manuell mit files.delete löschen.

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

Kontext-Caching mit PDFs

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)

Caches auflisten

Es ist nicht möglich, im Cache gespeicherte Inhalte abzurufen oder anzusehen. Sie können jedoch Cache-Metadaten (name, model, display_name, usage_metadata, create_time, update_time und expire_time) abrufen.

Verwenden Sie CachedContent.list(), um Metadaten für alle hochgeladenen Caches aufzulisten:

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

Cache aktualisieren

Sie können für einen Cache einen neuen ttl oder expire_time festlegen. Andere Änderungen am Cache werden nicht unterstützt.

Das folgende Beispiel zeigt, wie die ttl eines Caches mit CachedContent.update() aktualisiert wird.

import datetime

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

Cache löschen

Der Caching-Dienst bietet einen Löschvorgang zum manuellen Entfernen von Inhalten aus dem Cache. Im folgenden Beispiel wird gezeigt, wie ein Cache mit CachedContent.delete() gelöscht wird.

cache.delete()

Nächste Schritte

In dieser Anleitung wird gezeigt, wie Sie generateContent verwenden und Textausgaben aus verarbeiteten Dokumenten generieren. Weitere Informationen finden Sie in den folgenden Ressourcen:

  • Strategien für Prompts aus Dateien: Die Gemini API unterstützt Prompts mit Text-, Bild-, Audio- und Videodaten, auch als multimodale Prompts bezeichnet.
  • Systemanweisungen: Mit Systemanweisungen können Sie das Verhalten des Modells entsprechend Ihren spezifischen Anforderungen und Anwendungsfällen steuern.
  • Sicherheitshinweise: Manchmal liefern generative KI-Modelle unerwartete Ausgaben, z. B. ungenaue, voreingenommene oder anstößige Ausgaben. Eine Nachbearbeitung und eine menschliche Bewertung sind unerlässlich, um das Risiko von Schäden durch solche Ausgaben zu begrenzen.