Negli anni la mia knowledge base tech personale si è riempita di screenshot: dashboard Grafana di esperimenti, terminal con output di comandi che voglio ricordare, snippet di interfacce di tool che ho provato, diagrammi presi al volo durante una call. Quando li riprendo in mano mesi dopo, riconoscere a colpo d’occhio cosa contiene ciascuno di trecento screenshot è impossibile, e cercarli per nome file non aiuta perché il nome è quasi sempre Screenshot_2026-04-12_at_15-32-08.png. Da qualche settimana mi sto appoggiando a Florence-2 base, il modello vision-language compatto di Microsoft, per fare un primo giro di caption automatici da rifinire poi a mano e usare come metadato di ricerca.
Il modello pesa intorno ai 270 MB, gira su CPU senza farsi notare e produce caption brevi in inglese che mi servono come bozza. La traduzione in italiano me la faccio dopo nello stesso script, ma è un dettaglio successivo.
Setup con Transformers e Florence-2
Florence-2 si carica con la libreria transformers di Hugging Face, e l’API è quella standard AutoModelForCausalLM + AutoProcessor con trust_remote_code=True (perché il modello porta con sé del codice di pre-processing custom).
sudo apt install -y python3-venv
python3 -m venv ~/.venvs/florence
source ~/.venvs/florence/bin/activate
pip install --upgrade pip
pip install transformers torch pillow einops timm
Lo script che uso lavora su una cartella di immagini e per ognuna chiede a Florence-2 una caption nel formato
from pathlib import Path
from PIL import Image
import torch
from transformers import AutoModelForCausalLM, AutoProcessor
MODEL_ID = "microsoft/Florence-2-base"
processor = AutoProcessor.from_pretrained(MODEL_ID, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
MODEL_ID,
trust_remote_code=True,
torch_dtype=torch.float32,
)
model.eval()
def caption(image_path: Path, task: str = "<MORE_DETAILED_CAPTION>") -> str:
image = Image.open(image_path).convert("RGB")
inputs = processor(text=task, images=image, return_tensors="pt")
with torch.no_grad():
out = model.generate(
input_ids=inputs["input_ids"],
pixel_values=inputs["pixel_values"],
max_new_tokens=256,
num_beams=3,
do_sample=False,
)
text = processor.batch_decode(out, skip_special_tokens=False)[0]
parsed = processor.post_process_generation(
text, task=task, image_size=(image.width, image.height)
)
return parsed[task]
screenshots = Path.home() / "Screenshots"
for img in sorted(screenshots.glob("*.png")):
print(f"{img.name}: {caption(img)}")
Il primo run scarica i pesi del modello in ~/.cache/huggingface/hub/models--microsoft--Florence-2-base/, sono circa 270 MB. Da lì in poi il modello viene caricato dalla cache e parte in pochi secondi.
Per gli screenshot lavoro in batch: il loop attraversa la cartella, scrive le caption in un file JSON di indice, e quando voglio cercare uno screenshot di una dashboard specifica leggo il JSON con jq o lo passo allo script di ricerca semantica che ho già montato sopra MiniLM.
Un esempio reale
Ho passato un pomeriggio a riorganizzare la cartella ~/Screenshots/ che si era riempita di circa 480 immagini accumulate negli ultimi sei mesi. Tra dashboard Grafana di test di carico, terminal con output di kubectl describe pod, configurazioni Caddy aperte nell’editor, qualche grafico Prometheus, qualche pagina di documentazione di tool open source che avevo voluto archiviare. Per ricostruirne il senso dovevo aprirle una per una.
Ho lanciato lo script Florence-2 su tutte e quattrocentottanta, lasciato il portatile in idle con il modello che girava su CPU a 8 thread. Ci ha messo circa due ore e mezza. Il risultato: ogni immagine aveva accanto una stringa tipo “a screenshot of a terminal with kubectl output showing several pods in pending state”, oppure “a Grafana dashboard with multiple time series panels displaying CPU and memory metrics over the last 24 hours”. Da lì ho buttato il JSON nello script di ricerca semantica con MiniLM, e in trenta secondi avevo un indice navigabile: query “grafana dashboard cpu” mi tirava fuori i sette screenshot rilevanti, query “kubectl pod pending” altri quattro. Non perfetto, ma utilissimo, e soprattutto fatto in modo automatico su un materiale che altrimenti avrei abbandonato a sé stesso.
Cosa fa bene
Descrizione di scene comuni: dashboard, terminal, pagine web, codice in un editor, diagrammi semplici. Riconosce bene la tipologia di interfaccia (terminal, browser, dashboard di monitoring, editor) e i pattern visivi forti (un grafico a barre, un grafico time series, una tabella). Sui colori e sulle disposizioni spaziali (“in alto a sinistra”, “tre colonne”) tiene bene.
Cosa fa meno bene
Non legge il testo dentro le immagini in modo affidabile: per OCR vero serve altro (Tesseract o Florence-2 nel task OCR specifico, che è un’altra modalità). Su screenshot molto densi di informazione produce caption generiche tipo “a screenshot of a complex dashboard with multiple panels”, che non aiutano a distinguere fra trenta dashboard simili. Sui contenuti molto specifici di settore (un grafico di latenza percentile P99 vs P95) la descrizione è troppo generica per essere utile da sola.
Privacy – vantaggio del modello locale
Gli screenshot tech che ho da catalogare sono pieni di dettagli che non posso permettermi di caricare su servizi terzi: hostname interni di clienti, IP di sistemi di produzione, output di comandi che mostrano configurazioni sensibili, snippet di documentazione interna. Florence-2 in locale processa tutto sull’host: il modello vede le immagini, sputa la caption, nulla esce dalla macchina. Su API di vision remote ogni immagine andrebbe uploadata e processata sui server del provider, con tutte le policy di retention del caso; qui questo problema non si pone.
I pesi del modello stanno in ~/.cache/huggingface/hub/models--microsoft--Florence-2-base/ e si liberano con rm -rf. Niente telemetria, niente chiamate di rete dopo il download iniziale. Confronto con servizi cloud: l’API di Vision di Google, Azure Computer Vision, Amazon Rekognition richiedono tutte upload e hanno policy di retention specifiche; qui niente upload, niente policy esterna.
Licenza: Florence-2 è rilasciato sotto MIT da Microsoft. La libreria transformers è Apache 2.0 (Hugging Face). Stack interamente permissivo, integrabile in tooling interno senza vincoli copyleft.
In pratica
Per la mia knowledge base tech personale Florence-2 base è diventato il primo passaggio di triage: appena una cartella di screenshot supera le cento immagini, lancio lo script di caption e poi indicizzo con MiniLM. Il risultato non è una catalogazione perfetta, ma è un livello di metadato di ricerca che prima semplicemente non esisteva. Per la documentazione visiva di tool e dashboard che voglio ricordare di aver visto, mi è cambiato il modo di tenere ordinato l’archivio.
Immagine generata con ComfyUI Mac M1 / RealVisXL V5 Lightning.