Kod og send billeder i Base64
På denne side
Hvorfor bruge Base64?
I den forrige lektion lærte du at sende billeder via en URL. De fleste billeder, der behandles i en forretningsmæssig kontekst, har dog ikke en URL: en faktura, der netop er modtaget pr. e-mail, et skærmbillede genereret af en automatiseret test, eller et foto taget af en operatør på en produktionslinje. Det ville være absurd og ofte forbudt at offentliggøre disse filer på en internettilgængelig server blot for at analysere dem.
Her kommer Base64-kodning ind i billedet. Den transformerer et billedes binære data til en tekststreng, som du kan inkludere direkte i din API-anmodning uden behov for en ekstern URL eller mellemliggende hosting.
Hvornår skal du bruge URL kontra Base64?
| Kriterium | URL | Base64 |
|---|---|---|
| Allerede hostede billeder | Ideelt | Unødvendigt |
| Lokale billeder | Ikke egnet | Ideelt |
| Dynamisk genererede billeder | Ikke egnet | Ideelt |
| Netværkslatens | Afhænger af serveren | Ingen (indlejret) |
| Anmodningsstørrelse | Letvægts | Tungere (~33 %) |
| Sikkerhed/privatliv | Offentlig URL | Data inde i anmodningen |
Reglen er enkel: Hvis billedet er tilgængeligt via en stabil URL, så brug URL’en. Ellers skal du bruge Base64.
Kodning af et billede til Base64
Der kræves ingen eksterne afhængigheder; Python leverer modulet base64 i sit 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")
Tilstanden "rb" ved åbning af filen er ikke valgfri: Læsning af et billede i teksttilstand vil udløse en dekodningsfejl. Forvent lange strenge – kodning øger størrelsen med ca. 33 % sammenlignet med den oprindelige fil, så et billede på 1 MB producerer cirka 1,33 MB tekst.
Data URI-format
Den rå streng er ikke nok: API’et skal kende billedformatet. Du skal derfor præsentere det som en data URI, hvilket sætter et præfiks foran dataene med deres MIME-type:
data:image/{format};base64,{base64_data}
De fire brugbare præfikser svarer til de understøttede formater:
data:image/jpeg;base64,...data:image/png;base64,...data:image/gif;base64,...data:image/webp;base64,...
Hvis du annoncerer et PNG som image/jpeg, opstår der en behandlingsfejl; heraf kommer detektionsfunktionen i eksemplet nedenfor.
Komplet eksempel
Her er hele kæden, fra læsning af den lokale fil til 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)
Vigtig pointe: Feltet hedder altid image_url, selv når det indeholder en data URI. Meddelelsesstrukturen ændrer sig ikke en smule i forhold til lektion 4; kun værdien er anderledes.
Kodning af billeder fra andre kilder
En fil på disken er blot ét tilfælde blandt mange. Hvis dit billede allerede eksisterer i hukommelsen, som et Pillow-objekt fra en optagelse eller et behandlingstrin, ville det være en unødvendig omvej at skrive det til disken blot for at læse det tilbage med det samme – en hukommelsesbuffer fungerer fint:
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)
Samme logik gælder for et billede hentet via HTTP, som du ikke ønsker at gemme, f.eks. fordi det stammer fra et kortlivet link:
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")
Optimer størrelsen før kodning
Et smartphone-foto vejer i dag 4 til 8 MB, hvilket bliver til næsten 10 MB, når det er kodet. API’et vil alligevel ændre størrelsen på det, som du så i lektion 2: du ville betale for overførslen for ingenting. Så ændr altid størrelsen før 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")
At vise den endelige størrelse er ikke blot dekorativt: Behold det under dine tests, da det straks vil fortælle dig, om din pipeline sender 80 KB eller 8 MB ved hvert opkald.
Grænser du skal kende
Der følger tre begrænsninger med Base64. Det kodede billede lægges til HTTP-anmodningens body, så ud over 10 MB risikerer du timeouts. Kodning loader også hele billedet ind i hukommelsen: Ved batch-behandling skal du håndtere billeder ét ad gangen i stedet for at bygge en liste over tusind kodede strenge. Endelig bliver Base64-billeder, i modsætning til URL’er, videresendt i fuld længde ved hver anmodning – at analysere den samme faktura to gange betyder at sende den to gange.
Vigtige pointer
- Base64 er ideelt til lokale eller dynamisk genererede billeder
- Data URI-formatet kombinerer MIME-type og data:
data:image/png;base64,... - Ændr størrelse og komprimer dine billeder før kodning for at optimere latensen
- Base64 øger størrelsen med ca. 33 % – hold dine billeder under 10 MB
- Brug URL, når billedet allerede er hostet, og Base64 i alle andre tilfælde