rozumienie dokumentów;

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 graficzną dokumentów. Dzięki natywnemu wsparciu dla widzenia maszynowego w PDF modele Gemini mogą:

  • analizować diagramy, wykresy i tabele w dokumentach;
  • Wyodrębnianie informacji w uporządkowanych formatach wyjściowych
  • odpowiadać na pytania dotyczące treści wizualnych i tekstowych w dokumentach;
  • streszczać dokumenty,
  • Transkrybowanie treści dokumentu (np. do formatu HTML) z zachowaniem układu i formatowania na potrzeby dalszego przetwarzania

W tym samouczku pokazujemy kilka sposobów korzystania z interfejsu Gemini API do przetwarzania dokumentów PDF.

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 przesłać pliki zapisane lokalnie.

Jako inline_data

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

DOC_URL="https://discovery.ucl.ac.uk/id/eprint/10089234/1/343019_3_art_0_py4t4l_convrt.pdf"
PROMPT="Summarize this document"
DISPLAY_NAME="base64_pdf"

# Download the PDF
wget -O "${DISPLAY_NAME}.pdf" "${DOC_URL}"

# Check for FreeBSD base64 and set flags accordingly
if [[ "$(base64 --version 2>&1)" = *"FreeBSD"* ]]; then
  B64FLAGS="--input"
else
  B64FLAGS="-w0"
fi

# Base64 encode the PDF
ENCODED_PDF=$(base64 $B64FLAGS "${DISPLAY_NAME}.pdf")

# Generate content using the base64 encoded PDF
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"inline_data": {"mime_type": "application/pdf", "data": "'"$ENCODED_PDF"'"}},
          {"text": "'$PROMPT'"}
        ]
      }]
    }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.json

# Clean up the downloaded PDF
rm "${DISPLAY_NAME}.pdf"

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.

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

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:

PDF_PATH="https://www.nasa.gov/wp-content/uploads/static/history/alsj/a17/A17_FlightPlan.pdf"
DISPLAY_NAME="A17_FlightPlan"
PROMPT="Summarize this document"

# Download the PDF from the provided URL
wget -O "${DISPLAY_NAME}.pdf" "${PDF_PATH}"

MIME_TYPE=$(file -b --mime-type "${DISPLAY_NAME}.pdf")
NUM_BYTES=$(wc -c < "${DISPLAY_NAME}.pdf")

echo "MIME_TYPE: ${MIME_TYPE}"
echo "NUM_BYTES: ${NUM_BYTES}"

tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GOOGLE_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${DISPLAY_NAME}.pdf" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo "file_uri: ${file_uri}"

# Now generate content using that file
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "'$PROMPT'"},
          {"file_data":{"mime_type": "application/pdf", "file_uri": '$file_uri'}}]
        }]
       }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.json

# Clean up the downloaded PDF
rm "${DISPLAY_NAME}.pdf"

duże pliki PDF przechowywane lokalnie;

NUM_BYTES=$(wc -c < "${PDF_PATH}")
DISPLAY_NAME=TEXT
tmp_header_file=upload-header.tmp

# Initial resumable request defining metadata.
# The upload url is in the response headers dump them to a file.
curl "${BASE_URL}/upload/v1beta/files?key=${GEMINI_API_KEY}" \
  -D upload-header.tmp \
  -H "X-Goog-Upload-Protocol: resumable" \
  -H "X-Goog-Upload-Command: start" \
  -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Header-Content-Type: application/pdf" \
  -H "Content-Type: application/json" \
  -d "{'file': {'display_name': '${DISPLAY_NAME}'}}" 2> /dev/null

upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
rm "${tmp_header_file}"

# Upload the actual bytes.
curl "${upload_url}" \
  -H "Content-Length: ${NUM_BYTES}" \
  -H "X-Goog-Upload-Offset: 0" \
  -H "X-Goog-Upload-Command: upload, finalize" \
  --data-binary "@${PDF_PATH}" 2> /dev/null > file_info.json

file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri

# Now generate content using that file
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-1.5-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"text": "Can you add a few more lines to this poem?"},
          {"file_data":{"mime_type": "application/pdf", "file_uri": '$file_uri'}}]
        }]
       }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.json
files.sh

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

name=$(jq ".file.name" file_info.json)
# Get the file of interest to check state
curl https://generativelanguage.googleapis.com/v1beta/files/$name > file_info.json
# Print some information about the file you got
name=$(jq ".file.name" file_info.json)
echo name=$name
file_uri=$(jq ".file.uri" file_info.json)
echo file_uri=$file_uri
files.sh

Wiele plików PDF

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

DOC_URL_1="https://arxiv.org/pdf/2312.11805"
DOC_URL_2="https://arxiv.org/pdf/2403.05530"
DISPLAY_NAME_1="Gemini_paper"
DISPLAY_NAME_2="Gemini_1.5_paper"
PROMPT="What is the difference between each of the main benchmarks between these two papers? Output these in a table."

# Function to download and upload a PDF
upload_pdf() {
  local doc_url="$1"
  local display_name="$2"

  # Download the PDF
  wget -O "${display_name}.pdf" "${doc_url}"

  local MIME_TYPE=$(file -b --mime-type "${display_name}.pdf")
  local NUM_BYTES=$(wc -c < "${display_name}.pdf")

  echo "MIME_TYPE: ${MIME_TYPE}"
  echo "NUM_BYTES: ${NUM_BYTES}"

  local tmp_header_file=upload-header.tmp

  # Initial resumable request
  curl "${BASE_URL}/upload/v1beta/files?key=${GOOGLE_API_KEY}" \
    -D "${tmp_header_file}" \
    -H "X-Goog-Upload-Protocol: resumable" \
    -H "X-Goog-Upload-Command: start" \
    -H "X-Goog-Upload-Header-Content-Length: ${NUM_BYTES}" \
    -H "X-Goog-Upload-Header-Content-Type: ${MIME_TYPE}" \
    -H "Content-Type: application/json" \
    -d "{'file': {'display_name': '${display_name}'}}" 2> /dev/null

  local upload_url=$(grep -i "x-goog-upload-url: " "${tmp_header_file}" | cut -d" " -f2 | tr -d "\r")
  rm "${tmp_header_file}"

  # Upload the PDF
  curl "${upload_url}" \
    -H "Content-Length: ${NUM_BYTES}" \
    -H "X-Goog-Upload-Offset: 0" \
    -H "X-Goog-Upload-Command: upload, finalize" \
    --data-binary "@${display_name}.pdf" 2> /dev/null > "file_info_${display_name}.json"

  local file_uri=$(jq ".file.uri" "file_info_${display_name}.json")
  echo "file_uri for ${display_name}: ${file_uri}"

  # Clean up the downloaded PDF
  rm "${display_name}.pdf"

  echo "${file_uri}"
}

# Upload the first PDF
file_uri_1=$(upload_pdf "${DOC_URL_1}" "${DISPLAY_NAME_1}")

# Upload the second PDF
file_uri_2=$(upload_pdf "${DOC_URL_2}" "${DISPLAY_NAME_2}")

# Now generate content using both files
curl "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GOOGLE_API_KEY" \
    -H 'Content-Type: application/json' \
    -X POST \
    -d '{
      "contents": [{
        "parts":[
          {"file_data": {"mime_type": "application/pdf", "file_uri": '$file_uri_1'}},
          {"file_data": {"mime_type": "application/pdf", "file_uri": '$file_uri_2'}},
          {"text": "'$PROMPT'"}
        ]
      }]
    }' 2> /dev/null > response.json

cat response.json
echo

jq ".candidates[].content.parts[].text" response.json

Co dalej?

Więcej informacji znajdziesz w tych materiałach: