1. Introduzione
Ultimo aggiornamento: 2024-04-08
Incorporamento del 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. Immaginate questa situazione:
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'incorporamento del 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 raccomandazione e traduzione automatica.
- Acquisisce il significato semantico: gli incorporamenti vanno oltre il solo significato letterale delle parole. Catturano il contesto e le relazioni tra le parole, consentendo un'analisi più articolata.
- Migliora le prestazioni del machine learning: gli incorporamenti di testo possono essere utilizzati come funzionalità nei modelli di machine learning, con conseguente miglioramento delle prestazioni in attività come l'analisi del sentiment, la classificazione del testo e la modellazione degli 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 incorporamenti di testo consentono ai motori di ricerca di comprendere il significato semantico delle query e di abbinarle ai documenti pertinenti, anche se non sono presenti parole chiave esatte.
Confrontando gli incorporamenti di una query di ricerca con gli incorporamenti di documenti, i motori di ricerca possono identificare documenti che trattano argomenti o concetti simili.
2. Sistema dei consigli:
I sistemi per suggerimenti 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 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 attraverso gli incorporamenti, 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 IA.
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 incorporamenti di testo (vettori).
- Crea un database simulato composto da testo e relativi vettori
- Esegui una query sul nostro database vettoriale simulato confrontando i vettori per ottenere la risposta più probabile.
Cosa imparerai a fare
- Come utilizzare l'incorporamento del 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
- Avere 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 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 a cui puoi accedere dal menu di Vertex AI, nella sezione Notebooks 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, specifica 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 anche concedere 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 ti interessa. Puoi selezionare una rete VPC, purché la rete abbia l'accesso privato Google abilitato o 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 sul pulsante.
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 in corso...
Dopo aver creato l'istanza e aperto JupyterLab, dobbiamo installare tutte le librerie richieste per il nostro codelab.
Ci serviranno:
- NumPy
- panda
- TextEmbeddingInput, TextEmbeddingModel di 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 fatto di testo e i rispettivi vettori tradotti utilizzando il modello di incorporamento di testo gecko@003.
L'obiettivo è cercare un testo, tradurlo in un vettore, cercarlo nel nostro database e restituire il risultato più approssimativo.
Il nostro database vettoriale conterrà tre 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
L'aspetto sarà simile al seguente:
Analizziamo il codice
Nelle variabili DOCUMENT1, DOCUMENT2 e DOCUMENT3 stiamo memorizzando un dizionario che emula documenti con i relativi titoli e contenuti. Questi "documenti" fanno riferimento a un manuale simulato di un'auto realizzata 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 otteniamo un incorporamento del testo utilizzando il modello gecko@003 per ogni record nel nostro database di documenti simulato.
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'URL avrà il seguente aspetto:
Analizziamo il codice
Abbiamo definito una funzione chiamataembed_fn che riceverà come input un dataframe pandas contenente il testo per eseguire l'incorporamento. 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, viene memorizzato e aggiunto 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 testo regolare e restituirne il vettore utilizzando il modello gecko@003, inizializza il modello di variabile che è il punto 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.
Al termine della funzione, creiamo una nuova colonna nel dataframe chiamata 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 database contiene testo e i relativi vettori, possiamo procedere con una domanda ed eseguire una query sul database per trovare una risposta.
Per farlo, 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 sarebbe simile a questo:
Analizziamo il codice
Analogamente alla funzione del passaggio precedente, inizializziamo innanzitutto la variabile della domanda con ciò che intendiamo porre al database.
question='How do you shift gears in the Google car?'
Quindi, 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 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.
A questo scopo, 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 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.
Inoltre, abbiamo inizializzato la variabile più breve_distance su 1 per continuare ad aggiornarla finché non troviamo la distanza minima 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 indicata nella variabile distanza_più breve, 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
Conoscendo la posizione nell'elenco del vettore che conserva 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 l'esecuzione, 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…