Koda och skicka bilder i Base64
På denna sida
Varför använda Base64?
I föregående lektion lärde du dig hur man skickar bilder via en URL. De flesta bilder som bearbetas i affärssammanhang har dock ingen URL: en faktura som nyss kommit via e-post, en skärmdump genererad av ett automatiserat test eller ett foto taget av en operatör i en produktionslinje. Att publicera dessa filer på en internetåtkomlig server bara för att analysera dem vore absurt, och ofta förbjudet.
Här kommer kodning med Base64 in i bilden. Det omvandlar bildens binära data till en textsträng som du inkluderar direkt i din API-förfrågan, utan behov av en extern URL eller mellanliggande lagring.
När ska du använda URL kontra Base64?
| Kriterium | URL | Base64 |
|---|---|---|
| Bilder som redan är hostade | Idealt | Onödigt |
| Lokala bilder | Olämpligt | Idealt |
| Dynamiskt genererade bilder | Olämpligt | Idealt |
| Nätverkslatens | Beror på servern | Ingen (inbäddad) |
| Förfrågningsstorlek | Lättviktig | Tyngre (~33 %) |
| Säkerhet/integritet | Offentlig URL | Data inuti förfrågan |
Regeln är enkel: om bilden är tillgänglig via en stabil URL, använd URL:n. Använd annars Base64.
Koda en bild till Base64
Inga beroenden krävs; Python tillhandahåller modulen base64 i sitt standardbibliotek:
import base64
def encode_image(file_path):
"""Encode an image file to a Base64 string."""
with open(file_path, "rb") as f:
return base64.standard_b64encode(f.read()).decode("utf-8")
# Encode a local image
image_b64 = encode_image("captures/screenshot.png")
print(f"Base64 string length: {len(image_b64)} characters")
Läget "rb" när du öppnar filen är inte valfritt: att läsa en bild i textläge kommer att utlösa ett avkodningsfel. Räkna med långa strängar – kodningen ökar storleken med cirka 33 % jämfört med originalfilen, så en bild på 1 MB ger ungefär 1,33 MB text.
Format för Data URI
Den råa strängen räcker inte: API:t behöver veta bildformatet. Du måste därför presentera den som en data URI, vilket prefixar datan med dess MIME-typ:
data:image/{format};base64,{base64_data}
De fyra användbara prefixen motsvarar de format som stöds:
data:image/jpeg;base64,...data:image/png;base64,...data:image/gif;base64,...data:image/webp;base64,...
Att ange en PNG som image/jpeg orsakar ett bearbetningsfel; därav detekteringsfunktionen i exemplet nedan.
Komplett exempel
Här är hela kedjan, från att läsa den lokala filen till modellens svar:
import base64
import os
from mistralai.client import Mistral
def encode_image(chemin):
"""Encode a local image to Base64."""
with open(chemin, "rb") as f:
return base64.standard_b64encode(f.read()).decode("utf-8")
# Determine MIME type
def obtenir_mime(chemin):
"""Return MIME type based on extension."""
extensions = {
".jpg": "image/jpeg",
".jpeg": "image/jpeg",
".png": "image/png",
".gif": "image/gif",
".webp": "image/webp"
}
ext = os.path.splitext(chemin)[1].lower()
return extensions.get(ext, "image/jpeg")
# Prepare the image
chemin_image = "documents/facture-2024.png"
image_b64 = encode_image(chemin_image)
mime_type = obtenir_mime(chemin_image)
data_uri = f"data:{mime_type};base64,{image_b64}"
# Call the API
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
response = client.chat.complete(
model="mistral-small-latest",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "Extract all information from this invoice."},
{"type": "image_url", "image_url": data_uri}
]
}
]
)
print(response.choices[0].message.content)
Viktig poäng: fältet heter alltid image_url, även när det innehåller en data URI. Meddelandestrukturen ändras inte ett dugg jämfört med lektion 4; endast värdet skiljer sig.
Koda bilder från andra källor
En fil på disken är bara ett fall i mängden. Om din bild redan finns i minnet, som ett Pillow-objekt från en fångst eller ett bearbetningssteg, vore det en onödig omväg att skriva den till disk bara för att läsa tillbaka den direkt – en minnesbuffert fungerar utmärkt:
import base64
from io import BytesIO
from PIL import Image
def pil_to_base64(pil_image):
"""Convert a Pillow image to a Base64 data URI."""
buffer = BytesIO()
pil_image.save(buffer, format="PNG")
b64 = base64.standard_b64encode(buffer.getvalue()).decode("utf-8")
return f"data:image/png;base64,{b64}"
# Example with a Pillow image
img = Image.open("capture.png")
data_uri = pil_to_base64(img)
Samma logik gäller för en bild som hämtas via HTTP som du inte vill lagra, till exempel för att den kommer från en länk med kort livslängd:
import base64
import requests
def url_to_base64(url):
"""Download an image and convert it to a data URI."""
response = requests.get(url, timeout=10)
response.raise_for_status()
content_type = response.headers.get("Content-Type", "image/jpeg")
b64 = base64.standard_b64encode(response.content).decode("utf-8")
return f"data:{content_type};base64,{b64}"
data_uri = url_to_base64("https://example.com/photo.jpg")
Optimera storleken innan kodning
Ett smartfonfoto väger idag mellan 4 och 8 MB, vilket blir nästan 10 MB när det är kodat. API:t kommer ändå att ändra storlek på det, som du såg i lektion 2: du skulle betala för överföringen i onödan. Ändra därför alltid storlek innan kodning.
from PIL import Image
from io import BytesIO
import base64
def preparer_et_encoder(chemin, taille_max=1024, qualite=85):
"""Resize, compress, and encode an image."""
img = Image.open(chemin)
# Resize if necessary
if max(img.size) > taille_max:
img.thumbnail((taille_max, taille_max))
# Convert to JPEG to reduce size
buffer = BytesIO()
img.convert("RGB").save(buffer, format="JPEG", quality=qualite)
b64 = base64.standard_b64encode(buffer.getvalue()).decode("utf-8")
taille_ko = len(buffer.getvalue()) / 1024
print(f"Encoded image: {taille_ko:.0f} KB")
return f"data:image/jpeg;base64,{b64}"
data_uri = preparer_et_encoder("photo_haute_resolution.png")
Att visa den slutliga storleken är inte bara dekorativt: behåll detta under dina tester, eftersom det omedelbart berättar för dig om din pipeline skickar 80 KB eller 8 MB vid varje anrop.
Begränsningar att känna till
Tre begränsningar följer med Base64. Den kodade bilden läggs till i HTTP-förfrågningskroppen, så bortom 10 MB riskerar du timeout. Kodning laddar också hela bilden i minnet: för batchbearbetning, hantera bilder en i taget snarare än att bygga en lista med tusen kodade strängar. Slutligen, till skillnad från URL:er, sänds Base64-bilder vidare i sin helhet vid varje förfrågan – att analysera samma faktura två gånger innebär att skicka den två gånger.
Viktiga punkter
- Base64 är idealiskt för lokala eller dynamiskt genererade bilder
- Data URI-formatet kombinerar MIME-typ och data:
data:image/png;base64,... - Ändra storlek och komprimera dina bilder innan kodning för att optimera latens
- Base64 ökar storleken med cirka 33 % – håll dina bilder under 10 MB
- Använd URL när bilden redan är hostad, Base64 i alla andra fall