SentenceTransformers: un framework Python per embeddings di frasi, testi e immagini

I modelli di Processing del Linguaggio Naturale (NLP) hanno subito notevoli progressi negli ultimi anni, soprattutto grazie all’introduzione di reti neurali e architetture come BERT, RoBERTa e XLM-RoBERTa. 

Queste reti hanno portato a importanti miglioramenti nella traduzione automatica, nella risposta a domande e nella ricerca semantica. 

Tra le soluzioni emergenti che sfruttano queste architetture, Sentence-Transformers è un’opzione eccellente per calcolare embeddings di frasi, testi e immagini in Python.

Cos’è Sentence-Transformers?

SentenceTransformers è un framework Python basato su PyTorch e Transformers che permette di calcolare embeddings densi per frasi, paragrafi e immagini utilizzando reti neurali come BERT, RoBERTa e XLM-RoBERTa. 

Descritto nel paper Sentence-BERT, offre modelli pre-addestrati allo stato dell’arte per più di 100 lingue, ottimizzati per diverse applicazioni. 

Il framework consente inoltre di affinare facilmente modelli di embedding personalizzati per specifici compiti. È adatto per Python 3.6 o versioni successive, PyTorch 1.6.0 e transformers v4.6.0, e può essere installato tramite pip, conda o dal codice sorgente.

Leggi anche: Azure OpenAI: una soluzione cloud per potenziare le applicazioni con intelligenza artificiale

Modelli pre-addestrati e fine-tuning

SentenceTransformers offre una vasta gamma di modelli pre-addestrati per diverse lingue e casi d’uso. Alcuni di questi modelli includono:

• BERT Base: un modello generico basato sull’architettura BERT con 110 milioni di parametri.
• DistilBERT: una versione semplificata di BERT che conserva la maggior parte delle prestazioni del modello originale, ma con solo il 40% dei parametri.
• RoBERTa: una variante di BERT ottimizzata per una maggiore accuratezza e velocità di addestramento.
• XLM-RoBERTa: un’evoluzione di RoBERTa progettata per supportare più di 100 lingue.

Il framework supporta anche il fine-tuning per embeddings specifici di determinati compiti. Ciò significa che è possibile addestrare un modello preesistente su un nuovo dataset per ottenere prestazioni migliori in specifici scenari.

Installazione e utilizzo di SentenceTransformers

Per iniziare a utilizzare SentenceTransformers, è necessario installare il package tramite pip, conda o dal codice sorgente.

Installazione tramite pip

Per installare SentenceTransformers con pip, eseguire il seguente comando:

pip install sentence-transformers

Installazione tramite conda

Per installare SentenceTransformers con conda, eseguire il seguente comando:

conda install -c conda-forge sentence-transformers

Installazione dal codice sorgente

Per installare SentenceTransformers dal codice sorgente, eseguire i seguenti comandi:

git clone https://github.com/UKPLab/sentence-transformers.git
cd sentence-transformers
python setup.py install

Calcolare embeddings per frasi e testi

Una volta installato SentenceTransformers, è possibile iniziare a calcolare embeddings per frasi e testi. Di seguito è riportato un esempio di codice che dimostra come utilizzare il framework per calcolare gli embeddings per una lista di frasi:

from sentence_transformers import SentenceTransformer
 
# Load a pre-trained model
model = SentenceTransformer('bert-base-nli-mean-tokens')
 
# Define the list of sentences
sentences = [
    "Il cane corre nel parco.",
    "Una volta era una giovane ragazza.",
    "L'uomo suona il piano."
]
 
# Compute the embeddings
embeddings = model.encode(sentences)
 
# Print the embeddings
for sentence, embedding in zip(sentences, embeddings):
    print(f"Sentence: {sentence}")
    print(f"Embedding: {embedding}")

Confrontare embeddings tramite similarità coseno

Una delle principali applicazioni di SentenceTransformers è trovare frasi dal significato simile. Per fare ciò, è possibile confrontare gli embeddings calcolati utilizzando la similarità del coseno. Di seguito è riportato un esempio di codice che mostra come confrontare gli embeddings delle frasi per trovare la frase più simile a una frase target:

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
 
# Define the target sentence
target_sentence = "Il gatto corre nel parco."
 
# Compute the embedding for the target sentence
target_embedding = model.encode([target_sentence])[0]
 
# Compute the cosine similarity between embeddings
similarities = cosine_similarity([target_embedding], embeddings)[0]
 
# Find the index of the most similar sentence
most_similar_index = np.argmax(similarities)
 
# Print the most similar sentence
print(f"Most similar sentence: {sentences[most_similar_index]}")

Addestrare un modello personalizzato

SentenceTransformers consente di addestrare modelli personalizzati su nuovi dataset per specifici compiti. Di seguito è riportato un esempio di codice che mostra come addestrare un modello su un dataset di esempio:

from sentence_transformers import SentenceTransformer, InputExample, losses
from torch.utils.data import DataLoader
 
# Define training examples (pairs of sentences with a similarity score)
train_examples = [
    InputExample(texts=["Il cane corre nel parco.", "Il gatto gioca con la palla."], label=0.5),
    InputExample(texts=["Una volta era una giovane ragazza.", "La vecchia signora camminava al parco."], label=0.7),
    # ... more examples ...
]
 
# Create a DataLoader for the training examples
train_dataloader = DataLoader(train_examples, shuffle=True, batch_size=16)
 
# Define the loss function
train_loss = losses.CosineSimilarityLoss(model)
 
# Train the model
model.fit(train_objectives=[(train_dataloader, train_loss)], epochs=1, warmup_steps=100)

In questo esempio, il modello viene addestrato utilizzando esempi di input composti da coppie di frasi e un punteggio di similarità. Il modello apprende a generare embeddings che riflettono questi punteggi di similarità.

Integrazione con Hugging Face e Weaviate

SentenceTransformers può essere integrato con altre soluzioni NLP come Hugging Face e Weaviate. Ad esempio, Weaviate ha introdotto un nuovo modulo che consente agli utenti di integrare modelli Hugging Face per vettorizzare dati e query.

Con oltre 700 modelli disponibili, l’attenzione si è spostata dalle differenze architettoniche ai dati su cui sono stati addestrati e ad altri fattori sottili. Le reti neurali variano per dominio, dataset, lingua e altri dettagli. Per selezionare il modello giusto per la ricerca semantica, gli utenti dovrebbero considerare queste dimensioni e fare riferimento alle descrizioni dei modelli colorate di Hugging Face.

Conclusioni

SentenceTransformers è un framework Python flessibile e potente che rende facile calcolare embeddings densi per frasi, testi e immagini utilizzando reti neurali allo stato dell’arte. Grazie alla sua ampia gamma di modelli pre-addestrati, al supporto per il fine-tuning e alle sue integrazioni con altre soluzioni NLP, SentenceTransformers è una soluzione ideale per lo sviluppo di applicazioni di comprensione del linguaggio naturale e ricerca semantica.