La API de Gemini admite la entrada de PDF, incluidos los documentos largos (hasta 3,600 páginas). Los modelos de Gemini procesan archivos PDF con visión nativa y, por lo tanto, pueden interpretar el contenido de texto y de imagen dentro de los documentos. Con la compatibilidad nativa con la visión de PDF, los modelos de Gemini pueden hacer lo siguiente:
- Analiza diagramas, gráficos y tablas dentro de los documentos.
- Extrae información en formatos de salida estructurados.
- Responde preguntas sobre el contenido visual y de texto de los documentos.
- Resumir documentos
- Transcribe el contenido de los documentos (p.ej., a HTML) preservando los diseños y el formato para usarlos en aplicaciones descendentes (como en las canalizaciones de RAG).
En este instructivo, se muestran algunas formas posibles de usar la API de Gemini con documentos PDF. Todo el resultado es solo texto.
Antes de comenzar: Configura tu proyecto y clave de API
Antes de llamar a la API de Gemini, debes configurar tu proyecto y tu clave de API.
Instrucciones con archivos PDF
En esta guía, se muestra cómo subir y procesar archivos PDF con la API de File o incluirlos como datos intercalados.
Detalles técnicos
Gemini 1.5 Pro y 1.5 Flash admiten un máximo de 3,600 páginas de documentos. Las páginas del documento deben estar en uno de los siguientes tipos MIME de datos de texto:
- 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
Cada página del documento equivale a 258 tokens.
Si bien no hay límites específicos para la cantidad de píxeles en un documento además de la ventana de contexto del modelo, las páginas más grandes se reducen a una resolución máxima de 3,072 x 3,072, a la vez que conservan su relación de aspecto original, mientras que las páginas más pequeñas se aumentan a 768 x 768 píxeles. No hay reducción de costos para las páginas de tamaños más pequeños, aparte del ancho de banda, ni mejora del rendimiento para las páginas de resolución más alta.
Para lograr resultados óptimos, haz lo siguiente:
- Rota las páginas a la orientación correcta antes de subirlas.
- Evita las páginas borrosas.
- Si usas una sola página, coloca la instrucción de texto después de ella.
Entrada de PDF
En el caso de las cargas útiles de PDF de menos de 20 MB, puedes elegir entre subir documentos codificados en base64 o subir directamente archivos almacenados de forma local.
Documentos codificados en base64
Puedes procesar documentos PDF directamente desde URLs. Este es un fragmento de código que muestra cómo hacerlo:
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)
PDFs almacenados de forma local
Para los archivos PDF almacenados de forma local, puedes usar el siguiente enfoque:
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)
Archivos PDF grandes
Puedes usar la API de File para subir un documento de cualquier tamaño. Usa siempre la API de File cuando el tamaño total de la solicitud (incluidos los archivos, el mensaje de texto, las instrucciones del sistema, etcétera) sea superior a 20 MB.
Llama a media.upload para subir un archivo con la API de archivos. El siguiente código sube un archivo de documento y, luego, lo usa en una
llamada a
models.generateContent.
Archivos PDF grandes de URLs (:#large-pdfs-urls)
Usa la API de File para archivos PDF grandes disponibles desde URLs, lo que simplifica el proceso de carga y procesamiento de estos documentos directamente a través de sus URLs:
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)
PDFs grandes almacenados de forma local (:#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)
Para verificar que la API almacenó correctamente el archivo subido y obtener sus metadatos, llama a files.get. Solo name (y, por extensión, uri) son únicos.
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)
Varios archivos PDF
La API de Gemini puede procesar varios documentos PDF en una sola solicitud, siempre que el tamaño combinado de los documentos y la instrucción de texto permanezca dentro de la ventana de contexto del modelo.
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)
Enumerar archivos
Puedes enumerar todos los archivos subidos con la API de archivos y sus URIs con files.list.
import google.generativeai as genai
print("My files:")
for f in genai.list_files():
print(" ", f.name)
Borrar archivos
Los archivos subidos con la API de Files se borran automáticamente después de 2 días. También puedes borrarlos de forma manual con 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
Almacenamiento en caché de contexto con archivos 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)
Enumera las cachés
No es posible recuperar ni ver el contenido almacenado en caché, pero puedes recuperar los metadatos de la caché (name, model, display_name, usage_metadata, create_time, update_time y expire_time).
Para enumerar los metadatos de todas las cachés subidas, usa CachedContent.list():
for c in caching.CachedContent.list():
print(c)
Actualiza una caché
Puedes establecer un ttl o expire_time nuevo para una caché. No se admite cambiar ningún otro elemento de la caché.
En el siguiente ejemplo, se muestra cómo actualizar el ttl de una caché con CachedContent.update().
import datetime
cache.update(ttl=datetime.timedelta(hours=2))
Borra una memoria caché
El servicio de almacenamiento en caché proporciona una operación de eliminación para quitar contenido de la caché de forma manual. En el siguiente ejemplo, se muestra cómo borrar una caché con CachedContent.delete().
cache.delete()
¿Qué sigue?
En esta guía, se muestra cómo usar generateContent y generar resultados de texto a partir de documentos procesados. Para obtener más información, consulta los siguientes recursos:
- Estrategias de indicaciones de archivos: La API de Gemini admite indicaciones con datos de texto, imagen, audio y video, también conocidos como indicaciones multimodales.
- Instrucciones del sistema: Las instrucciones del sistema te permiten dirigir el comportamiento del modelo según tus necesidades y casos de uso específicos.
- Orientación de seguridad: A veces, los modelos de IA generativa producen resultados inesperados, como resultados imprecisos, sesgados o ofensivos. El procesamiento posterior y la evaluación humana son esenciales para limitar el riesgo de daños que pueden causar estos resultados.