SigLIP2

SigLIP2 è un modello a due torri che confronta un'immagine con dei prompt testuali usando un sigmoid indipendente per classe, invece di un softmax condiviso su un insieme fisso di etichette. LibreYOLO lo supporta per la classificazione zero-shot e per l'embedding di immagini e testo, senza nessun passaggio di addestramento.

Task
classify, embed
Dimensioni
Installa
pip install libreyolo
Livello di supporto
Livello parallelo, dalla v. Un'interfaccia di prodotto separata, con una propria factory e un proprio contratto.
Origine
SigLIP 2 di Google DeepMind, Apache-2.0. Articolo, sorgente
Licenze
Codice MIT, pesi Apache-2.0. Uso commerciale

Installazione

SigLIP2 richiede un extra dedicato, che installa il pacchetto SentencePiece usato dal suo tokenizer multilingue.

bash
pip install "libreyolo[siglip2]"

Predizione

I pesi vengono scaricati da Hugging Face al primo utilizzo e restano nella cache locale.

Python
from libreyolo import LibreYOLO, SAMPLE_IMAGE model = LibreYOLO("LibreSigLIP2b16-cls.pt")model.set_classes(["a forklift", "an empty aisle", "a spill"])result = model(SAMPLE_IMAGE, save=True) print(model.names[result.probs.top1], float(result.probs.top1conf))
CLI
# Senza una chiamata a set_classes(), predict da CLI usa i 1.000 nomi# di classe ImageNet con cui il modello viene caricato di default.libreyolo predict model=LibreSigLIP2b16-cls.pt source=https://raw.githubusercontent.com/LibreYOLO/libreyolo/release/libreyolo/assets/parkour.jpg save=True
Punteggi sigmoid multi-etichetta
from libreyolo import LibreYOLO, SAMPLE_IMAGE model = LibreYOLO("LibreSigLIP2b16-cls.pt")model.set_classes(["a dog", "a cat", "outdoors"], multi_label=True)r = model(SAMPLE_IMAGE) # Probabilità indipendenti per classe: più di una, o nessuna, possono# avere un punteggio alto insieme. Il softmax (predefinito) invece le# normalizza in una distribuzione a etichetta singola, come fa LibreCLIP.for i, name in model.names.items():    print(name, float(r.probs.data[i]))
Embedding di immagini e testo
from libreyolo import LibreYOLO, SAMPLE_IMAGE model = LibreYOLO("LibreSigLIP2b16-cls.pt", task="embed")image_embed = model(SAMPLE_IMAGE).embeddings.datatext_embed = model.embed_text("a photo of a forklift") # Entrambi sono normalizzati L2, quindi un semplice prodotto scalare è la similarità coseno.similarity = (image_embed @ text_embed.T).item()

set_classes() è l'unica primitiva che rende questo modello un classificatore a vocabolario aperto: inserisce ogni etichetta in ciascun template di prompt, codifica e media i risultati e memorizza nella cache la matrice [K, D] risultante come testa del classificatore, così non viene ricalcolata per ogni immagine. Chiamala di nuovo per cambiare classi in qualsiasi momento. Senza nessuna chiamata, LibreSigLIP2 viene caricato con i 1.000 nomi di classe di ImageNet-1k già impostati.

SigLIP assegna un punteggio a ogni classe in modo indipendente: logit = scale * (image . text) + bias. Di default quell'insieme di logit passa comunque per un softmax, che dà una distribuzione a etichetta singola equivalente al comportamento di top1/top5 di LibreCLIP. Passando multi_label=True a set_classes() (o alla costruzione del modello) si passa invece a probabilità sigmoid indipendenti, così più di una classe, o nessuna, può avere un punteggio alto sulla stessa immagine. Il tokenizer è un modello SentencePiece multilingue (vocabolario Gemma), quindi i nomi di classe in lingue diverse dall'inglese funzionano allo stesso modo.

Con task="embed", la predizione restituisce un vettore immagine normalizzato L2 per ogni input invece delle probabilità di classe, e embed_text() restituisce righe di testo normalizzate nello stesso spazio vettoriale, quindi un semplice prodotto scalare tra i due è la similarità coseno. iou non ha effetto su nessuno dei due task; non c'è nessun passaggio di NMS. Vedi predizione per sorgenti, streaming e gestione dei risultati.

Validazione

val() legge i nomi delle cartelle di classe sotto lo split train/ di un ImageFolder, li passa a set_classes() e poi misura l'accuratezza zero-shot top-1 e top-5 con punteggio softmax. L'accuratezza dipende da come i nomi delle classi funzionano come prompt, non da un aggiornamento dei pesi, dato che non c'è niente da addestrare. La validazione copre solo task="classify"; task="embed" non ha un validatore su dataset.

Python
from libreyolo import LibreYOLO model = LibreYOLO("LibreSigLIP2b16-cls.pt") # data è una directory radice ImageFolder con uno split train/; i nomi# delle cartelle diventano i prompt di classe zero-shot per questa esecuzione.metrics = model.val(data="imagenette160") print(metrics["metrics/accuracy_top1"])print(metrics["metrics/accuracy_top5"])
CLI
libreyolo val model=LibreSigLIP2b16-cls.pt data=imagenette160

Esportazione

TaskONNXTorchScriptExecuTorchTensorRTOpenVINOPaddleMNNRKNNncnnTFLiteCoreMLCore AI
classifyclassify to ONNX: supportatoclassify to TorchScript: supportatoclassify to ExecuTorch: supportatoclassify to TensorRT: supportatoclassify to OpenVINO: supportatoclassify to Paddle: non supportatoclassify to MNN: non supportatoclassify to RKNN: non supportatoclassify to ncnn: non supportatoclassify to TFLite: supportatoclassify to CoreML: non supportatoclassify to Core AI: supportato
embedembed to ONNX: supportatoembed to TorchScript: supportatoembed to ExecuTorch: supportatoembed to TensorRT: supportatoembed to OpenVINO: supportatoembed to Paddle: non supportatoembed to MNN: non supportatoembed to RKNN: non supportatoembed to ncnn: non supportatoembed to TFLite: supportatoembed to CoreML: non supportatoembed to Core AI: non supportato

L'esportazione fissa lo stato corrente del modello in un grafo statico. Per task="classify", le ultime etichette impostate da set_classes() e la risoluzione al momento dell'esportazione vengono fissate in un layer lineare finale con lo scale e il bias appresi, quindi il grafo esportato è un normale classificatore di immagini [B, K] senza torre testuale e senza tokenizer; riesporta dopo aver cambiato le classi o la dimensione. L'esportazione in modalità multi_label=True non è implementata; riportalo prima a False. L'esportazione con task="embed" traccia solo la torre delle immagini. Entrambe richiedono l'opset ONNX 14 o superiore, che l'esportatore imposta di default.

Python
from libreyolo import LibreYOLO model = LibreYOLO("LibreSigLIP2b16-cls.pt")model.set_classes(["a forklift", "an empty aisle", "a spill"])model.export(format="onnx") # Le etichette correnti di set_classes() e la risoluzione di input# vengono fissate nel grafo. Riesporta dopo aver cambiato una delle due.# multi_label deve essere False (il valore predefinito) al momento# dell'esportazione.
CLI
# Qui non c'è nessuna chiamata a set_classes(), quindi vengono fissate# le 1.000 classi ImageNet predefinite con cui il modello viene caricato.libreyolo export model=LibreSigLIP2b16-cls.pt format=onnx
Esportazione degli embedding
from libreyolo import LibreYOLO # task="embed" traccia solo la torre delle immagini; non servono classi.model = LibreYOLO("LibreSigLIP2b16-cls.pt", task="embed")model.export(format="onnx")

Checkpoint

Tutti i file di pesi pubblicati per questa famiglia. Entrambi sono convertiti dai checkpoint Apache-2.0 di Google siglip2-base-patch16-256 e siglip2-so400m-patch14-384, non da un addestramento su COCO.

FileIngresso (px)Licenza dei pesi
classify
LibreSigLIP2b16-cls.ptapache-2.0
LibreSigLIP2so400m-cls.ptapache-2.0

Oggi tutti i file elencati sopra sono presenti nell<link>organizzazione LibreYOLO</link> e vengono scaricati al primo utilizzo.

Licenze

Controlla la licenza nel repository Hugging Face degli specifici pesi che scarichi. Ogni checkpoint nell<link>organizzazione LibreYOLO</link> ne include una e non è sempre la stessa per tutta la famiglia. Quel repository è la fonte autorevole; il riepilogo seguente descrive le condizioni applicabili al momento dellultima verifica di questa pagina.

Questa è una descrizione delle licenze coinvolte, non una consulenza legale. Se la risposta è importante a fini commerciali, leggi personalmente le licenze e chiedi una consulenza indipendente.

Lavoro originale
SigLIP 2, Google DeepMind
Licenza upstream
Apache-2.0
Codice LibreYOLO
MIT
Pesi
Apache-2.0, ripubblicati su huggingface.co/LibreYOLO
Interpretazione
Apache-2.0 is a permissive license, so these weights can be used in commercial and closed-source products. It asks you to keep its license text and attribution notices with any copy of the weights you redistribute, and it grants a patent license. It places no obligation on your own application code. LibreSigLIP2's image and text towers are a clean-room re-implementation structured to match Hugging Face Transformers' SigLIP reference implementation, built without transformers as a runtime dependency; the multilingual SentencePiece tokenizer (Gemma vocabulary) is shipped verbatim from the Apache-2.0 google/siglip2-* release. The shipped checkpoints (b16, so400m) are converted from Google's Apache-2.0 siglip2-base-patch16-256 and siglip2-so400m-patch14-384 weights, a metadata wrap with the learned parameters unchanged. Training is not offered for this family: LibreSigLIP2 is zero-shot, and set_classes() replaces the fine-tuning step a trained classifier would otherwise need.

Citazione

@misc{tschannen2025siglip2multilingualvisionlanguage,
      title={SigLIP 2: Multilingual Vision-Language Encoders with Improved Semantic Understanding, Localization, and Dense Features}, 
      author={Michael Tschannen and Alexey Gritsenko and Xiao Wang and Muhammad Ferjad Naeem and Ibrahim Alabdulmohsin and Nikhil Parthasarathy and Talfan Evans and Lucas Beyer and Ye Xia and Basil Mustafa and Olivier Hénaff and Jeremiah Harmsen and Andreas Steiner and Xiaohua Zhai},
      year={2025},
      eprint={2502.14786},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2502.14786}, 
}

Copiato dal blocco di citazione degli autori disponibile su huggingface.co/google/siglip2-base-patch16-256#bibtex-entry-and-citation-info.

Verificato con LibreYOLO v1.5.0. Le tabelle di supporto, i checkpoint e i dati dei benchmark in questa pagina vengono generati dalla libreria rilasciata e dai pesi pubblicati, non scritti a mano.