Poznaj możliwości przetwarzania dokumentów dzięki interfejsowi Gemini API

Interfejs Gemini API obsługuje dane wejściowe w formacie PDF, w tym długie dokumenty (do 3600 stron). Modele Gemini przetwarzają pliki PDF z wykorzystaniem natywnej funkcji widzenia, dzięki czemu są w stanie zrozumieć zarówno zawartość tekstową, jak i obrazową dokumentów. Dzięki natywnemu obsłudze widzenia maszynowego w PDF modele Gemini są w stanie:

  • analizować diagramy, wykresy i tabele w dokumentach;
  • wyodrębniać informacje w uporządkowanych formatach wyjściowych;
  • odpowiadać na pytania dotyczące treści wizualnych i tekstowych w dokumentach.
  • streszczać dokumenty,
  • Transkrypcja treści dokumentu (np.do formatu HTML) z zachowaniem układu i formatowania na potrzeby dalszego przetwarzania (np. w ramach procesów RAG).

W tym samouczku pokazujemy kilka sposobów korzystania z interfejsu Gemini API w przypadku dokumentów PDF. Wszystkie dane wyjściowe są w postaci tekstu.

Zanim zaczniesz: skonfiguruj projekt i klucz interfejsu API

Zanim wywołasz interfejs Gemini API, musisz skonfigurować projekt i klucz interfejsu API.

Prośby o opinię w plikach PDF

Ten przewodnik pokazuje, jak przesyłać i przetwarzać pliki PDF za pomocą interfejsu File API lub dołączać je jako dane wbudowane.

Szczegóły techniczne

Gemini 1.5 Pro i 1.5 Flash obsługują maksymalnie 3600 stron dokumentu. Strony dokumentu muszą mieć jeden z tych typów MIME danych tekstowych:

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

Każda strona dokumentu odpowiada 258 znacnikom.

Chociaż nie ma żadnych konkretnych ograniczeń liczby pikseli w dokumencie poza oknem kontekstowym modelu, większe strony są zmniejszane do maksymalnej rozdzielczości 3072 x 3072 przy zachowaniu oryginalnego współczynnika proporcji, a mniejsze strony są powiększane do 768 x 768 pikseli. Nie ma obniżenia kosztów w przypadku stron o mniejszych rozmiarach (poza przepustowością) ani poprawy wydajności w przypadku stron o wyższej rozdzielczości.

Aby uzyskać najlepsze wyniki:

  • Przed przesłaniem obróć strony w odpowiednią orientację.
  • Unikaj stron z rozmazanymi obrazami.
  • Jeśli używasz pojedynczej strony, umieść prompt tekstowy po tej stronie.

Dane wejściowe w formacie PDF

W przypadku plików PDF o wielkości poniżej 20 MB możesz przesłać dokumenty zakodowane w formacie base64 lub bezpośrednio zapisane lokalnie pliki.

Dokumenty zakodowane w Base64

Dokumenty PDF możesz przetwarzać bezpośrednio z adresów URL. Oto fragment kodu pokazujący, jak to zrobić:

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)

Pliki PDF zapisane lokalnie

W przypadku plików PDF zapisanych lokalnie możesz użyć tej metody:

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)

Duże pliki PDF

Za pomocą interfejsu File API możesz przesyłać dokumenty o dowolnym rozmiarze. Zawsze używaj interfejsu File API, gdy łączny rozmiar żądania (w tym pliki, prompt tekstowy, instrukcje systemu itp.) przekracza 20 MB.

Aby przesłać plik za pomocą interfejsu File API, wywołaj funkcję media.upload. Poniższy kod przesyła plik dokumentu, a potem używa go w wywołaniu funkcji models.generateContent.

Duże pliki PDF z adresów URL (:#large-pdfs-urls)

Użyj interfejsu File API w przypadku dużych plików PDF dostępnych pod adresami URL, aby uprościć proces przesyłania i przetwarzania tych dokumentów bezpośrednio za pomocą ich adresów URL:

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)

Duże pliki PDF przechowywane lokalnie (:#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

Aby sprawdzić, czy interfejs API poprawnie zapisał przesłany plik, i pobrać jego metadane, wywołaj funkcję files.get. Tylko name (a w rozszerzeniu uri) są niepowtarzalne.

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

Wiele plików PDF

Interfejs Gemini API może przetwarzać wiele dokumentów PDF w jednym żądaniu, o ile łączny rozmiar dokumentów i promptu tekstowego mieści się w oknie kontekstu modelu.

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)

Wyświetlanie listy plików

Wszystkie pliki przesłane za pomocą interfejsu File API oraz ich identyfikatory URI możesz wyświetlić za pomocą interfejsu files.list.

import google.generativeai as genai

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

Usuwanie plików

Pliki przesłane za pomocą interfejsu File API są automatycznie usuwane po 2 dniach. Możesz je też usunąć ręcznie, korzystając z funkcji 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

Buforowanie kontekstu w plikach 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)

Wyświetlanie pamięci podręcznej

Nie można pobierać ani wyświetlać treści z pamięci podręcznej, ale można pobrać metadane z pamięci podręcznej (name, model, display_name, usage_metadata, create_time, update_time i expire_time).

Aby wyświetlić metadane wszystkich przesłanych pamięci podręcznych, użyj CachedContent.list():

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

Aktualizowanie pamięci podręcznej

Możesz ustawić nową wartość ttl lub expire_time dla pamięci podręcznej. Zmiana innych ustawień pamięci podręcznej nie jest obsługiwana.

Ten przykład pokazuje, jak za pomocą funkcji CachedContent.update() zaktualizować ttl pamięci podręcznej.

import datetime

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

Usuwanie pamięci podręcznej

Usługa buforowania udostępnia operację usuwania, która umożliwia ręczne usuwanie treści z pamięci podręcznej. Ten przykład pokazuje, jak usunąć pamięć podręczną za pomocą funkcji CachedContent.delete().

cache.delete()

Co dalej?

Ten przewodnik pokazuje, jak korzystać z generateContent i generować dane wyjściowe w postaci tekstu z przetworzonych dokumentów. Więcej informacji znajdziesz w tych materiałach:

  • Strategie wyświetlania promptów dotyczących plików: interfejs Gemini API obsługuje prompty z tekstem, obrazem, dźwiękiem i danymi wideo, które są też nazywane promptami multimodalnymi.
  • Instrukcje systemowe: instrukcje systemowe pozwalają kierować działaniem modelu na podstawie konkretnych potrzeb i przypadków użycia.
  • Wskazówki dotyczące bezpieczeństwa: modele generatywnej AI czasami generują nieoczekiwane wyniki, np. niedokładne, stronnicze lub obraźliwe. Przetwarzanie końcowe i sprawdzanie przez weryfikatorów są niezbędne do ograniczenia ryzyka szkód wynikających z takich danych wyjściowych.