1. Introduzione
Ultimo aggiornamento: 2024-04-08
Text Embedding
Il text embedding si riferisce al processo di trasformazione dei dati testuali in rappresentazioni numeriche. Queste rappresentazioni numeriche, spesso vettori, acquisiscono il significato semantico e le relazioni tra le parole di un testo. Immagina la situazione in questo modo:
I messaggi sono come un linguaggio complesso, pieno di sfumature e ambiguità.
L'incorporamento del testo traduce la lingua in un formato matematico più semplice che i computer possono comprendere e manipolare.
Vantaggi dell'incorporamento 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.
- Acquisizione del significato semantico: gli incorporamenti vanno oltre il significato letterale delle parole. Acquisiscono il contesto e le relazioni tra le parole, consentendo un'analisi più sfumata.
- Migliora le prestazioni del machine learning: gli incorporamenti di testo possono essere utilizzati come funzionalità nei modelli di machine learning, migliorando le prestazioni in attività come l'analisi del sentiment, la classificazione del testo e il modello degli argomenti.
Casi d'uso di Text Embedding
I text embedding, trasformando il testo in rappresentazioni numeriche, aprono le porte a una serie di applicazioni nell'elaborazione del linguaggio naturale (NLP). Ecco alcuni casi d'uso chiave:
1. Motori di ricerca e recupero delle informazioni:
Gli embedding di testo consentono ai motori di ricerca di comprendere il significato semantico delle query e di abbinarle a documenti pertinenti, anche se le parole chiave esatte non sono presenti.
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 raccomandazione:
I sistemi di raccomandazione utilizzano gli incorporamenti di testo per analizzare il comportamento e le preferenze degli utenti espresse tramite recensioni, valutazioni o cronologia di navigazione.
Il sistema può quindi consigliare articoli simili confrontando gli incorporamenti di prodotti, articoli o altri contenuti con cui l'utente ha interagito.
3. Rilevamento dei plagi:
Il confronto degli incorporamenti di due brani di testo può aiutare a identificare potenziali plagi rilevando somiglianze significative nella loro struttura semantica.
Questi sono solo alcuni esempi e le possibilità continuano a crescere man mano che le tecniche di text embedding si evolvono. Man mano che i computer acquisiscono una migliore comprensione del linguaggio attraverso gli incorporamenti, possiamo aspettarci applicazioni ancora più innovative in futuro.
textembedding-gecko@003
textembedding-gecko@003 è una versione specifica di un modello di incorporamento di testo preaddestrato offerto da Google Cloud tramite Vertex AI e la sua 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 text embedding (vettori).
- Crea un database simulato composto da testo e relativi vettori
- Esegui una query sul nostro database vettoriale simulato confrontando i vettori e ottieni la risposta più probabile.
Cosa imparerai a fare
- Come utilizzare l'incorporamento di testo in GCP
- Come chiamare textembedding-gecko@003
- Come eseguire questa operazione 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
Crea un'istanza di Vertex AI Workbench
- Nella console Google Cloud, nella pagina di selezione del progetto, seleziona o crea un progetto Google Cloud.
- Vai al selettore di 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. Per ulteriori informazioni sugli altri metodi, consulta questa pagina.
- Nella console Google Cloud, vai alla pagina Istanze, a cui puoi accedere nel menu Vertex AI, nella sezione Notebook, e fai clic su Workbench.
- Vai a Istanze.
- Fai clic su Crea nuovo.
- Nella finestra di dialogo Crea istanza, nella sezione Dettagli, 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 di 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 ne è configurata una. Se utilizzi un VPC condiviso nel progetto host, devi concedere anche il ruolo Utente di rete Compute (roles/compute.networkUser) all'agente di servizio Notebooks dal progetto di servizio.
Nel campo Rete, seleziona la rete che preferisci. Puoi selezionare una rete VPC, a condizione che la rete abbia l'accesso privato Google abilitato o possa accedere a internet.
Nel campo Subnet, seleziona la subnet che preferisci. 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. Cliccaci sopra.
Crea un notebook Python 3
- In JupyterLab, dalla sezione Avvio app, nella sezione Notebook, fai clic sull'icona con il logo Python che indica Python3.
- Viene creato un notebook Jupyter con il nome Untitled e l'estensione ipynb.
- Puoi rinominarlo utilizzando la sezione del browser di file a sinistra o lasciarlo così com'è.
Ora possiamo iniziare a inserire il codice nel notebook.
3. Importazione delle librerie richieste
Una volta creata l'istanza e aperto JupyterLab, dobbiamo installare tutte le librerie richieste per il nostro codelab.
Avremo bisogno di:
- 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. Crea un database vettoriale simulato
Per testare il nostro codice, creeremo un database composto da testo e dai rispettivi vettori tradotti utilizzando il modello di text embedding 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, ecco come lo creeremo:
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
Avrà questo aspetto:
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 da questi tre documenti (dizionari).
documents = [DOCUMENT1, DOCUMENT2, DOCUMENT3]
Infine, utilizzando pandas, creiamo un dataframe da questo elenco, che verrà chiamato 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 riportato di seguito 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
Avrà questo aspetto:
Analizziamo il codice
Abbiamo definito una funzione chiamata embed_fn che riceverà come input un dataframe Pandas contenente il testo su cui 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 scorrere ogni riga del DataFrame, ottenendo i valori dalla colonna Text (che contiene le informazioni manuali del nostro database simulato).
Per inviare 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, creiamo una nuova colonna nel dataframe chiamata Embedded text, 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 acquisisci il dataframe contenente i dati originali del database simulato più 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 vettoriale
Ora che il nostro database contiene testo e i relativi vettori, possiamo procedere a porre una domanda ed eseguire una query nel database per trovare una risposta.
Per farlo, copia e incolla il codice riportato di seguito 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
Analogamente alla 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 del modello 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 tra vettori
Ora abbiamo un elenco di vettori nel nostro database simulato e una domanda trasformata in un vettore. In questo modo, possiamo confrontare il vettore della domanda con tutti i vettori nel nostro database per scoprire quale è più vicino per rispondere alla nostra domanda in modo più accurato.
Per farlo, misureremo la distanza tra il vettore della domanda e ogni vettore del database. Esistono diverse tecniche per misurare le distanze tra i vettori. Per questo codelab specifico, utilizzeremo la distanza euclidea o la norma L2.
In Python, possiamo utilizzare la funzione numpy per farlo.
Copia e incolla il codice riportato di seguito 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 a questo:
Analizziamo il codice
Iniziamo convertendo in un elenco la colonna contenente l'embedding o i vettori del nostro database e memorizzandola in list_embedded_text_from_db.
Abbiamo anche inizializzato la variabile shortest_distance a 1 per continuare ad aggiornarla finché non troviamo la distanza più breve effettiva.
list_embedded_text_from_db = df_embedded_values_db['Embedded text']
shortest_distance=1
Quindi, utilizzando un ciclo for, eseguiamo l'iterazione e otteniamo la distanza tra il vettore della domanda e ciascun vettore del database.
Utilizzando la funzione numpy linalg.norm, calcoliamo la distanza.
Se la distanza calcolata è inferiore a quella nella variabile shortest_distance, la distanza calcolata verrà impostata su questa variabile
Quindi, acquisiamo 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
Conoscendo 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 riportato di seguito 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 l'esecuzione, otterrai un risultato simile a questo:
9. Complimenti
Congratulazioni, hai creato la tua prima applicazione utilizzando il modello textembedding-gecko@003 in un caso d'uso reale.
Hai appreso le nozioni di base sugli incorporamenti di testo e come utilizzare il modello gecko003 su Google Cloud Workbench.
Ora conosci i passaggi chiave necessari per continuare ad applicare le tue conoscenze ad altri casi d'uso.
Passaggi successivi
Dai un'occhiata ad alcuni di questi codelab...