1. Introduzione
Ultimo aggiornamento: 08/04/2024
Embedding di testo
L'embedding del testo si riferisce al processo di trasformazione dei dati di testo in rappresentazioni numeriche. Queste rappresentazioni numeriche, spesso vettori, acquisiscono il significato semantico e le relazioni tra le parole in un testo. Immagina:
Il testo è come un linguaggio complesso, pieno di sfumature e ambiguità.
L'embedding del testo traduce questo linguaggio in un formato matematico più semplice che i computer possono comprendere e manipolare.
Vantaggi dell'embedding di testo
- Consente un'elaborazione efficiente: le rappresentazioni numeriche sono molto più veloci da elaborare per i computer rispetto al testo non elaborato. Questo è fondamentale per attività come motori di ricerca, sistemi di suggerimenti e traduzione automatica.
- Cattura il significato semantico: le rappresentazioni distribuite vanno oltre il significato letterale delle parole. Catturano il contesto e le relazioni tra le parole, consentendo un'analisi più sfumata.
- Migliora il rendimento del machine learning: gli embedding di testo possono essere utilizzati come funzionalità nei modelli di machine learning, con un conseguente miglioramento del rendimento in attività come l'analisi del sentiment, la classificazione del testo e la creazione di modelli di argomenti.
Casi d'uso dell'embedding di testo
Gli embedding di testo, trasformando il testo in rappresentazioni numeriche, sbloccano una serie di applicazioni nell'elaborazione del linguaggio naturale (NLP). Ecco alcuni casi d'uso principali:
1. Motori di ricerca e recupero di informazioni:
Gli embedding di testo consentono ai motori di ricerca di comprendere il significato semantico delle query e di associarle a documenti pertinenti, anche se non sono presenti le parole chiave esatte.
Confrontando gli embedding di una query di ricerca con gli embedding dei documenti, i motori di ricerca possono identificare i documenti che trattano argomenti o concetti simili.
2. Sistemi di consigli:
I sistemi di raccomandazione utilizzano gli embedding di testo per analizzare il comportamento e le preferenze degli utenti espressi tramite recensioni, valutazioni o cronologia di navigazione.
Il sistema può quindi consigliare articoli simili confrontando gli embedding di prodotti, articoli o altri contenuti con cui l'utente ha interagito.
3. Rilevamento dei plagi:
Il confronto degli embedding di due testi può aiutare a identificare potenziali casi di plagio trovando somiglianze significative nella loro struttura semantica.
Questi sono solo alcuni esempi e le possibilità continuano a crescere con l'evoluzione delle tecniche di embedding del testo. Man mano che i computer acquisiscono una migliore comprensione del linguaggio tramite gli embedding, possiamo aspettarci applicazioni ancora più innovative in futuro.
textembedding-gecko@003
Textembedding-gecko@003 è una versione specifica di un modello di embedding di testo preaddestrato offerto dalla piattaforma Google Cloud (GCP) tramite Vertex AI e la relativa suite di strumenti e servizi di AI.
Cosa creerai
In questo codelab, creerai uno script Python. Questo script:
- Utilizza l'API Vertex per chiamare textembedding-gecko@003 e trasformare il testo in embedding di testo (vettori).
- Crea un database simulato composto da testo e relativi vettori
- Esegui una query sul nostro database di vettori simulati confrontando i vettori e ottieni la risposta più probabile.
Cosa imparerai a fare
- Come utilizzare l'inserimento di testo in Google Cloud
- Come chiamare textembedding-gecko@003
- Come eseguire questo comando in Workbench
- Come utilizzare Vertex AI - Workbench per eseguire script
Che cosa ti serve
- Una versione recente di Chrome
- Conoscenza di Python
- Un progetto Google Cloud
- Accesso a Vertex AI - Workbench
2. Preparazione
Creare un'istanza di Vertex AI Workbench
- Nella console Google Cloud, nella pagina del selettore di progetti, seleziona o crea un progetto Google Cloud.
- Vai al selettore dei progetti
- Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud.
- Abilita l'API Notebooks.
Puoi creare un'istanza di Vertex AI Workbench utilizzando la console Google Cloud, gcloud CLI o Terraform. Ai fini di questo tutorial, lo creeremo utilizzando la console Google Cloud. Ulteriori informazioni sugli altri metodi sono disponibili qui.
- Nella console Google Cloud, vai alla pagina Istanze, accessibile nel menu Vertex AI, nella sezione Notebook e fai clic su Workbench.
- Vai a Istanze.
- Fai clic su Crea nuovo.
- Nella sezione Dettagli della finestra di dialogo Crea istanza, fornisci le seguenti informazioni per la nuova istanza:
Nome: fornisci un nome per la nuova istanza. Il nome deve iniziare con una lettera seguita da un massimo di 62 lettere minuscole, numeri o trattini (-) e non può terminare con un trattino.
Regione e zona: seleziona una regione e una zona per la nuova istanza. Per ottenere le migliori prestazioni della rete, seleziona la regione geograficamente più vicina a te.
Non è necessario installare la GPU
Nella sezione Networking, fornisci quanto segue:
Networking: modifica le opzioni di rete per utilizzare una rete nel progetto corrente o una rete VPC condivisa da un progetto host, se configurata. Se utilizzi un VPC condiviso nel progetto host, devi concedere il ruolo Utente di rete Compute (roles/compute.networkUser) anche all'agente di servizio Notebooks dal progetto di servizio.
Nel campo Rete: seleziona la rete che ti interessa. Puoi selezionare una rete VPC, a condizione che sia attivato l'accesso privato Google o che la rete possa accedere a internet
Nel campo Subnet:seleziona la subnet che ti interessa. Puoi scegliere quello predefinito.
Nelle proprietà dell'istanza puoi lasciare quella predefinita, ovvero e2-standard-4.
- Fai clic su Crea.
Vertex AI Workbench crea un'istanza e la avvia automaticamente. Quando l'istanza è pronta per l'uso, Vertex AI Workbench attiva un link Apri JupyterLab. Fai clic.
Creare un notebook Python 3
- In JupyterLab, fai clic sull'icona con il logo di Python che indica Python3 nella sezione Blocco note dell'Avvio app.
- Viene creato un blocco note Jupyter con il nome Senza titolo e l'estensione ipynb.
- Puoi rinominarlo utilizzando la sezione del browser di file a sinistra o lasciarlo invariato.
Ora possiamo iniziare a inserire il codice nel notebook.
3. Importazione delle librerie richieste
Dopo aver creato l'istanza e aperto JupyterLab, dobbiamo installare tutte le librerie richieste per il nostro codelab.
Ci serviranno:
- NumPy
- panda
- TextEmbeddingInput, TextEmbeddingModel da vertexai.language_models
Copia e incolla il codice riportato di seguito in una cella:
from vertexai.language_models import TextEmbeddingInput, TextEmbeddingModel
import numpy as np
import pandas as pd
L'URL avrà il seguente aspetto:
4. Creare un database di vettori simulati
Per testare il nostro codice, creeremo un database composto da testo e dai relativi vettori tradotti utilizzando il modello di embedding del testo gecko@003.
L'obiettivo è che gli utenti cerchino un testo, lo traducano in un vettore, lo cerchino nel nostro database e restituiscano il risultato più approssimativo.
Il nostro database vettoriale conterrà 3 record, che creeremo nel seguente modo:
Copia e incolla il codice riportato di seguito in una nuova cella.
DOCUMENT1 = {
"title": "Operating the Climate Control System",
"content": "Your Googlecar has a climate control system that allows you to adjust the temperature and airflow in the car. To operate the climate control system, use the buttons and knobs located on the center console. Temperature: The temperature knob controls the temperature inside the car. Turn the knob clockwise to increase the temperature or counterclockwise to decrease the temperature. Airflow: The airflow knob controls the amount of airflow inside the car. Turn the knob clockwise to increase the airflow or counterclockwise to decrease the airflow. Fan speed: The fan speed knob controls the speed of the fan. Turn the knob clockwise to increase the fan speed or counterclockwise to decrease the fan speed. Mode: The mode button allows you to select the desired mode. The available modes are: Auto: The car will automatically adjust the temperature and airflow to maintain a comfortable level. Cool: The car will blow cool air into the car. Heat: The car will blow warm air into the car. Defrost: The car will blow warm air onto the windshield to defrost it."}
DOCUMENT2 = {
"title": "Touchscreen",
"content": "Your Googlecar has a large touchscreen display that provides access to a variety of features, including navigation, entertainment, and climate control. To use the touchscreen display, simply touch the desired icon. For example, you can touch the \"Navigation\" icon to get directions to your destination or touch the \"Music\" icon to play your favorite songs."}
DOCUMENT3 = {
"title": "Shifting Gears",
"content": "Your Googlecar has an automatic transmission. To shift gears, simply move the shift lever to the desired position. Park: This position is used when you are parked. The wheels are locked and the car cannot move. Reverse: This position is used to back up. Neutral: This position is used when you are stopped at a light or in traffic. The car is not in gear and will not move unless you press the gas pedal. Drive: This position is used to drive forward. Low: This position is used for driving in snow or other slippery conditions."}
documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]
df_initial_db = pd.DataFrame(documents)
df_initial_db.columns = ['Title', 'Text']
df_initial_db
L'aspetto sarà simile al seguente:
Analizziamo il codice
Nelle variabili DOCUMENT1, DOCUMENT2 e DOCUMENT3 memorizziamo un dizionario che emulerà i documenti con i relativi titoli e contenuti. Questi "documenti" fanno riferimento a un manuale simulato di un'auto prodotta da Google.
Nella riga successiva, creiamo un elenco di questi tre documenti (dizionari).
documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]
Infine, sfruttando Pandas, creiamo un dataframe da quell'elenco che chiameremo df_initial_db.
df_initial_db = pd.DataFrame(documents)
df_initial_db.columns = ['Title', 'Text']
df_initial_db
5. Creare incorporamenti di testo
Ora otterremo un embedding di testo utilizzando il modello gecko@003 per ogni record nel nostro database simulato di documenti.
Copia e incolla il codice seguente in una nuova cella:
def embed_fn(df_input):
list_embedded_values = []
for index, row in df_input.iterrows():
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
list_embedded_values.append(embeddings[0].values)
df_input['Embedded text'] = list_embedded_values
return df_input
df_embedded_values_db = embed_fn(df_initial_db)
df_embedded_values_db
L'aspetto sarà simile al seguente:
Analizziamo il codice
Abbiamo definito una funzione chiamata embed_fn che riceverà come input un dataframe Pandas contenente il testo per eseguire l'embedding. La funzione restituisce quindi il testo codificato come vettore.
def embed_fn(df_input):
list_embedded_values = []
for index, row in df_input.iterrows():
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
list_embedded_values.append(embeddings[0].values)
df_input['Embedded text'] = list_embedded_values
return df_input
Nell'elenco denominato list_embedded_values memorizzeremo e accoderemo il testo codificato di ogni riga.
Utilizzando il metodo iterrows di pandas, possiamo eseguire l'iterazione di ogni riga del dataframe, ottenendo i valori dalla colonna Testo (che contiene le informazioni manuali del nostro database simulato).
Per inviare un testo normale e restituirne il vettore utilizzando il modello gecko@003, inizializziamo la variabile model, in cui impostiamo il modello da utilizzare, chiamando la funzione TextEmbeddingModel.from_pretrained.
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(row['Text'])])
Poi, negli incorporamenti delle variabili, acquisiamo il vettore del testo che inviamo tramite la funzione model.get_embeddings.
Alla fine della funzione, viene creata una nuova colonna nel dataframe denominata Testo incorporato, che conterrà l'elenco dei vettori creati in base al modello gecko@003.
df_input['Embedded text'] = list_embedded_values
return df_input
Infine, nella variabile df_embedded_values_db acquisiamo il dataframe contenente i dati originali del database simulato, oltre a una nuova colonna contenente l'elenco dei vettori per ogni riga.
df_embedded_values_db = embed_fn(df_initial_db)
df_embedded_values_db
6. Fare una domanda al database di vettori
Ora che il nostro database contiene il testo e i relativi vettori, possiamo procedere a porre una domanda ed eseguire una query sul database per trovare una risposta.
A questo scopo, copia e incolla il codice seguente in una nuova cella:
question='How do you shift gears in the Google car?'
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
embeddings = model.get_embeddings([(question)])
text_to_search=embeddings[0].values
len(text_to_search)
Il risultato sarà simile a questo:
Analizziamo il codice
Come per la funzione del passaggio precedente, inizializziamo prima la variabile della domanda con ciò che intendiamo chiedere al nostro database.
question='How do you shift gears in the Google car?'
Poi, nella variabile model impostiamo il modello che vogliamo utilizzare tramite la funzione TextEmbeddingModel.from_pretrained, che in questo caso è il modello gecko@003.
model = TextEmbeddingModel.from_pretrained("textembedding-gecko@003")
Nella variabile embeddings, chiamiamo la funzione model.get_embeddings e passiamo il testo da convertire in vettore, in questo caso, passiamo la domanda da porre.
embeddings = model.get_embeddings([(question)])
Infine, la variabile text_to_search contiene l'elenco dei vettori tradotti dalla domanda.
Stampiamo la lunghezza del vettore solo come riferimento.
text_to_search=embeddings[0].values
len(text_to_search)
7. Confronto di vettori
Ora abbiamo un elenco di vettori nel nostro database simulato e una domanda trasformata in un vettore. In altre parole, ora possiamo confrontare il vettore della domanda con tutti i vettori del nostro database per scoprire quale è più vicino a rispondere alla nostra domanda in modo più accurato.
Per farlo, misureremo la distanza tra il vettore della domanda e ciascun vettore del database. Esistono diverse tecniche per misurare le distanze tra i vettori. Per questo specifico codelab, utilizzeremo la distanza euclidea o la norma L2.
In Python, possiamo utilizzare la funzione numpy per farlo.
Copia e incolla il codice seguente in una nuova cella:
list_embedded_text_from_db = df_embedded_values_db['Embedded text']
shortest_distance=1
for position, embedded_value in enumerate(list_embedded_text_from_db):
distance=np.linalg.norm((np.array(embedded_value) - np.array(text_to_search)), ord = 2)
print(distance)
if distance<shortest_distance:
shortest_distance=distance
shortest_position=position
print(f'The shortest distance is {shortest_distance} and the position of that value is {shortest_position}')
Il risultato dovrebbe essere simile al seguente:
Analizziamo il codice
Iniziamo convertendo la colonna contenente il testo incorporato o i vettori del nostro database in un elenco e archiviandola in list_embedded_text_from_db.
Abbiamo anche inizializzato la variabile shortest_distance a 1 per continuare ad aggiornarla fino a trovare la distanza più breve effettiva.
list_embedded_text_from_db = df_embedded_values_db['Embedded text']
shortest_distance=1
Poi, utilizzando un ciclo for, eseguiamo l'iterazione e otteniamo la distanza tra il vettore della domanda e ogni vettore del database.
Utilizziamo la funzione linalg.norm di NumPy per calcolare la distanza.
Se la distanza calcolata è inferiore a quella nella variabile shortest_distance, la distanza calcolata verrà impostata su questa variabile
Acquisiamo quindi la distanza più breve e la posizione nell'elenco in cui è stata trovata. Nelle variabili shortest_distance e shortest_position.
for position, embedded_value in enumerate(list_embedded_text_from_db):
distance=np.linalg.norm((np.array(embedded_value) - np.array(text_to_search)), ord = 2)
print(distance)
if distance<shortest_distance:
shortest_distance=distance
shortest_position=position
8. Risultati
Sapendo la posizione nell'elenco del vettore che contiene la distanza più breve tra la domanda e il database, possiamo stampare i risultati.
Copia e incolla il codice seguente in una nuova cella:
print("Your question was:\n "+question+ " \nAnd our answer is:\n "+
df_embedded_values_db.at[shortest_position, 'Title']+": "+
df_embedded_values_db.at[shortest_position, 'Text'])
Dopo averlo eseguito, vedrai qualcosa di simile a questo:
9. Complimenti
Congratulazioni, hai creato correttamente la tua prima applicazione utilizzando il modello textembedding-gecko@003 in un caso d'uso reale.
Hai appreso le nozioni di base sugli embedding di testo e su come utilizzare il modello gecko003 su GCP Workbench.
Ora conosci i passaggi chiave necessari per continuare ad applicare le tue conoscenze a più casi d'uso.
Passaggi successivi
Dai un'occhiata ad alcuni di questi codelab…