Esplorare Text-Embedding-3-Large: una guida completa ai nuovi Embeddings di OpenAI

Il panorama del machine learning e dell’elaborazione del linguaggio naturale (NLP) è in continua evoluzione, con OpenAI che guida costantemente la strada verso l’innovazione.

L’introduzione dei modelli text-embedding-3-large e text-embedding-3-small segna una nuova era nel settore, destinata a cambiare il modo in cui sviluppatori e professionisti dell’AI affrontano l’analisi del testo e i compiti di embedding.

Nel complesso mondo dell’intelligenza artificiale, gli embedding sono fondamentali per trasformare il linguaggio umano, intrinsecamente complesso, in qualcosa che le macchine possano comprendere ed elaborare. Questo nuovo modello di OpenAI rappresenta un passo avanti significativo per sviluppatori e aspiranti data practitioner.

Questo articolo ha l’obiettivo di spiegare i modelli text-embedding-3-large e text-embedding-3-small, offrendo approfondimenti sulle loro funzioni principali, sulle varie applicazioni e su come utilizzarli in modo efficace.

Esplorando le basi dei text embeddings e mettendo in evidenza le nuove funzionalità e gli usi pratici del modello, l’articolo intende fornire ai lettori le informazioni necessarie per impiegare questo strumento avanzato nei propri progetti.

Inoltre, tratterà le nozioni di base per iniziare a usare il modello, condividerà suggerimenti per migliorare i compiti di embedding e discuterà l’ampio impatto di questo progresso tecnologico sul campo dell’NLP.

Capire i text embeddings

Prima di entrare nello specifico del nuovo modello, è utile una breve panoramica sui text embeddings per una migliore comprensione.

I text embeddings sono rappresentazioni numeriche del testo che catturano la semantica, ovvero il significato, di parole, frasi o interi documenti. Sono alla base di molti task NLP, come l’analisi del sentiment, la classificazione del testo e altro ancora.

La nostra Introduzione ai Text Embeddings con la OpenAI API fornisce una guida completa all’uso della OpenAI API per creare text embeddings. Scopri le loro applicazioni nella classificazione del testo, nel recupero di informazioni e nel rilevamento della similarità semantica.

Di seguito un’illustrazione che utilizza un modello di embedding:

• I documenti da rappresentare sono a sinistra
• Il modello di embedding al centro, e
• Gli embedding corrispondenti di ciascun documento sono a destra

Illustrazione dei text embeddings

Per chi è alle prime armi con questo concetto, consigliamo il nostro corso Introduction to Embeddings with the OpenAI API. Spiega come sfruttare gli embeddings di OpenAI tramite la OpenAI API per creare embedding a partire da dati testuali e iniziare a sviluppare applicazioni reali.

I nuovi Embeddings di OpenAI in breve

Annunciati il 25 gennaio 2024, questi modelli sono gli embedding più recenti e potenti, progettati per rappresentare il testo in uno spazio ad alta dimensionalità, facilitandone una comprensione più accurata.

Il modello text-embedding-3-small è ottimizzato per latenza e archiviazione. D’altra parte, text-embedding-3-large è una buona opzione per una precisione maggiore, e possiamo anche sfruttare il nuovo parametro delle dimensions per mantenere l’embedding a 1536 invece della dimensione nativa di 3072 senza impattare le prestazioni complessive.

Analisi di benchmarking

Prima del rilascio, il modello text-embedding-ada-2 era in cima alla classifica dei precedenti modelli di embedding di OpenAI; la tabella seguente offre una panoramica rapida del benchmarking tra questi tre modelli.

Dai valori forniti, osserviamo un miglioramento delle prestazioni da ada v2 (text-embedding-ada-002) a text-embedding-3-large sia sui benchmark MIRACL che MTEB. Ciò suggerisce che text-embedding-3-large, avendo un numero maggiore di dimensioni (3072), offra una qualità di embedding migliore rispetto agli altri due, il che si traduce direttamente in punteggi di benchmark più alti.


L’aumento delle dimensioni da text-embedding-ada-002 e text-embedding-3-small (entrambi 1536) a text-embedding-3-large (3072) indica un modello più complesso, in grado di catturare un set più ricco di caratteristiche nei suoi embedding. Tuttavia, ciò comporta anche un costo più alto per 1.000 token elaborati, evidenziando un compromesso tra prestazioni e costo.


A seconda dei requisiti specifici di un task (ad esempio la necessità di capacità multilingue, la complessità del testo da incorporare o vincoli di budget), si potrebbe scegliere un modello diverso.

Per compiti che richiedono embedding di alta qualità su più lingue e task, text-embedding-3-large potrebbe essere preferibile nonostante il costo maggiore. Al contrario, per applicazioni con budget più limitati o in cui la precisione estrema non è critica, text-embedding-ada-002 o text-embedding-3-small possono essere opzioni più adatte.


Applicazioni di Text-Embedding-3-Large

Le tecnologie di embedding sono state estremamente utili per molte applicazioni moderne di elaborazione e comprensione del linguaggio naturale. La scelta tra modelli più potenti come text-embedding-3-large e opzioni più economiche come text-embedding-3-small può influenzare le prestazioni e l’efficienza dei costi delle applicazioni NLP.

Di seguito tre illustrazioni di casi d’uso per entrambi i modelli, che ne dimostrano la versatilità e l’impatto in scenari reali.

Applicazioni di text-embedding-3-large

Applicazioni di text-embedding-3-large (immagini generate con GPT-4)

Automazione dell’assistenza clienti multilingue

Grazie alle prestazioni superiori nella comprensione e nell’elaborazione di 18 lingue diverse, text-embedding-3-large può alimentare chatbot di assistenza clienti e sistemi di risposta automatica per aziende globali, garantendo un supporto accurato e contestualizzato in contesti linguistici eterogenei.

Motori di ricerca semantici avanzati

Sfruttando embedding ad alta dimensionalità, text-embedding-3-large può migliorare gli algoritmi dei motori di ricerca, consentendo di comprendere meglio le sfumature delle query e recuperare risultati più pertinenti e contestualmente coerenti, soprattutto in ambiti specialistici come il legale o la ricerca medica.

Sistemi di raccomandazione cross-lingua

Per piattaforme che ospitano un’ampia gamma di contenuti multilingue, come servizi di streaming o aggregatori di notizie, text-embedding-3-large può analizzare preferenze degli utenti e contenuti in più lingue, raccomandando contenuti altamente pertinenti indipendentemente dalle barriere linguistiche.

Applicazioni di text-embedding-3-small

Applicazioni di text-embedding-3-small (Immagine generata con GPT-4)

Analisi del sentiment conveniente

Per startup e aziende di medie dimensioni che desiderano capire il sentiment dei clienti attraverso il monitoraggio dei social media o l’analisi dei feedback, text-embedding-3-small offre una soluzione economica ma efficace per valutare l’opinione pubblica e la soddisfazione dei clienti.

Categorizzazione dei contenuti scalabile

Piattaforme di contenuti con grandi volumi di dati, come blog o siti di e-commerce, possono utilizzare text-embedding-3-small per categorizzare automaticamente contenuti o prodotti. La sua efficienza e il costo inferiore lo rendono ideale per gestire dataset vasti senza compromettere l’accuratezza.

Strumenti di apprendimento delle lingue efficienti

App educative che richiedono soluzioni scalabili ed economiche per fornire esercizi di apprendimento linguistico, come l’abbinamento di parole ai significati o il controllo grammaticale, possono trarre vantaggio da text-embedding-3-small. Il suo equilibrio tra prestazioni e convenienza supporta lo sviluppo di contenuti didattici interattivi focalizzati sulla lingua.

Queste applicazioni mostrano come text-embedding-3-large e text-embedding-3-small possano essere impiegati in modo ottimale in vari settori, allineando i loro punti di forza alle esigenze specifiche di ciascuna applicazione per migliorare prestazioni, esperienza utente ed efficienza dei costi.

Guida passo passo all’uso dei nuovi Embeddings di OpenAI

Ora abbiamo tutti gli strumenti necessari per procedere all’implementazione di text-embedding-3-large, text-embedding-3-small e ada-v2 in uno scenario di similarità tra documenti.

Tutto il codice in questo tutorial è disponibile in un DataLab workbook. Crea una copia di questo workbook per eseguire il codice senza dover installare nulla sul tuo computer.

Informazioni sui dati

• Si tratta del dataset CORD-19, una risorsa con oltre 59.000 articoli accademici, inclusi più di 48.000 con testo completo, su COVID-19, SARS-CoV-2 e coronavirus correlati.
• Questi dati sono stati resi liberamente disponibili dalla Casa Bianca e da una coalizione di importanti gruppi di ricerca per aiutare la comunità scientifica globale a generare insight a supporto della lotta contro questa malattia infettiva.
• È scaricabile da questa pagina su Kaggle.
• Ulteriori dettagli sul dataset sono disponibili in questa pagina.

Prima di procedere oltre, è importante installare e importare le seguenti librerie per la riuscita del progetto.

Usando l’istruzione %%bash, possiamo installare più librerie senza usare il punto esclamativo (!).

%%bash
pip -q install tiktoken
pip -q install openaiOfferto da

Ora possiamo importare le librerie come segue:

import os
import tiktoken
import numpy as np
import pandas as pd
from openai import OpenAI
from sklearn.metrics.pairwise import cosine_similarityOfferto da

Vediamo il ruolo di ciascuna libreria:

• os: Fornisce un modo per usare funzionalità dipendenti dal sistema operativo, come leggere o scrivere nel filesystem.
• tiktoken: Gestisce task di tokenizzazione specifici per l’elaborazione di documenti scientifici.
• numpy (np): Aggiunge supporto per array e matrici di grandi dimensioni e multidimensionali, insieme a una vasta collezione di funzioni matematiche di alto livello per operare su questi array, fondamentale per il calcolo scientifico.
• pandas (pd): Offre strutture dati e operazioni per manipolare tabelle numeriche e serie temporali, essenziali per gestire dataset scientifici.
• openai.OpenAI: Funziona da interfaccia alla OpenAI API, consentendo l’interazione con modelli di machine learning per compiti come la generazione di embedding di testi scientifici.
• sklearn.metrics.pairwise.cosine_similarity: Calcola la similarità coseno tra vettori, utile nell’analisi di similarità tra documenti scientifici.

Esplorazione dei dati

Il dataframe originale è superiore a 1 GB e, per semplicità, viene caricato solo un campione di 1000 osservazioni casuali.

scientific_docs = pd.read_parquet("./data/cord19_df_sample.parquet")Offerto da

Usando la funzione .head(), possiamo vedere le prime 2 righe dei dati; il risultato è mostrato nell’animazione qui sotto.

scientific_docs.head(2)Offerto da

Prime due righe dei dati

Il body, il titolo e l’abstract di un documento scientifico possono essere sufficienti a rappresentarlo. Questi tre attributi vengono concatenati per ottenere una singola rappresentazione testuale per ciascun documento.

Prima, vediamo la percentuale di valori mancanti in ciascuna di queste tre colonne:

percent_missing = scientific_docs.isnull().sum() * 100 / len(scientific_docs)
percent_missingOfferto da

Percentuale di dati mancanti nelle colonne target

Dall’immagine sopra, osserviamo che titolo e abstract hanno valori mancanti, rispettivamente 10,5% e 12,4%. È quindi importante riempire questi valori mancanti con stringhe vuote prima della concatenazione per evitare perdita di informazioni.

Il processo complessivo di riempimento dei valori mancanti e concatenazione delle colonne è implementato con la seguente funzione.

def concatenate_columns_with_null_handling(df, body_text_column,
                                       	abstract_column,
                                       	title_column,
                                       	new_col_name):
    
	df[new_col_name] = df[body_text_column].fillna('') + df[abstract_column].fillna('') + df[title_column].fillna('')
    
	return dfOfferto da

Dopo aver eseguito la funzione di concatenazione sui dati originali e aver controllato le prime 3 righe, possiamo notare che la concatenazione è riuscita.

new_scientific_docs = concatenate_columns_with_null_handling(scientific_docs,
                                                         	"body_text",
                                                         	"abstract",
                                                         	"title",
                                                         	"concatenated_text")Offerto da

new_scientific_docs.head(3)Offerto da

La nuova colonna aggiunta è concatenated_text.

Prime 3 righe con la nuova colonna

Il passo successivo è applicare gli embedding sulla nuova colonna utilizzando i diversi modelli di embedding menzionati in questo articolo. Ma prima vediamo la distribuzione della lunghezza dei token.

L’obiettivo di questa analisi è verificare il limite massimo di token del modello rispetto al numero effettivo di token presenti in un dato documento.

Prima, però, dobbiamo contare il numero totale di token in ciascun documento, operazione eseguita tramite la funzione di supporto num_tokens_from_text e l’encoder cl100k_base.

def num_tokens_from_text(text: str, encoding_name="cl100k_base"):
    	"""
    	Returns the number of tokens in a text string.
    	"""
    	encoding = tiktoken.get_encoding(encoding_name)
    	num_tokens = len(encoding.encode(text))
    	return num_tokensOfferto da

Prima di applicare la funzione all’intero dataset, vediamo come funziona con il seguente testo: This article is about new OpenAI Embeddings.

text = "This article is about new OpenAI Embeddings"
num_tokens = num_tokens_from_text(text)
print(f"Number of tokens: {num_tokens}")Offerto da

Dopo aver eseguito con successo il codice sopra, vediamo che il testo ha 10 token.

Numero di token nel testo

Con questa conferma, possiamo applicare la funzione all’intero testo nel dataframe usando l’espressione lambda come segue:

new_scientific_docs['num_tokens'] = new_scientific_docs["concatenated_text"].apply(lambda x: num_tokens_from_text(x))Offerto da

Possiamo contare il numero totale di documenti con più di 8191 token filtrando in base al numero di token e verificando quali superano il limite effettivo di 8191.

smaller_tokens_docs = new_scientific_docs[new_scientific_docs['num_tokens'] <= 8191]
len(smaller_tokens_docs)Offerto da

⇒ Output: 764

Ciò significa che 764 documenti su 1000 soddisfano il requisito del limite massimo di token, e per semplicità useremo questi documenti.

Tecniche avanzate possono essere applicate per elaborare il restante set di documenti che hanno più di 8191 token.

Una di queste tecniche consiste nel calcolare la media di tutti gli embedding di un singolo documento. Un’altra tecnica prevede di prendere i primi 8191 token del documento. Questo approccio non è efficiente perché può portare a perdita di informazioni.

Assicuriamoci di reimpostare l’indice del dataframe in modo che parta da zero.

smaller_tokens_docs_reset = smaller_tokens_docs.reset_index(drop=True)Offerto da

Eseguire gli embeddings

Sono soddisfatti tutti i requisiti per ottenere la rappresentazione tramite embedding di tutti i documenti, e questo viene fatto per ciascun modello di embedding.

Il primo passo è acquisire le credenziali OpenAI e configurare il client come segue:

os.environ["OPENAI_API_KEY"] = "YOUR KEY"
client = OpenAI()Offerto da

Quindi, la seguente funzione di supporto aiuta a generare l’embedding fornendo il modello di embedding e il testo da incorporare.

def get_embedding(text_to_embbed, model_ID):
    
	text = text_to_embbed.replace("\n", " ")
	return client.embeddings.create(input = [text_to_embbed],
                                	model=model_ID).data[0].embeddingOfferto da

Ora viene creato un nuovo dataframe con tre colonne aggiuntive corrispondenti all’embedding di ciascuno dei tre modelli:

• text-embedding-3-small
• text-embedding-3-large
• text-embedding-ada-002

smaller_tokens_docs_reset['text-embedding-3-small'] = smaller_tokens_docs_reset["concatenated_text"].apply(lambda x: get_embedding(x, "text-embedding-3-small"))

smaller_tokens_docs_reset['text-embedding-3-large'] = smaller_tokens_docs_reset["concatenated_text"].apply(lambda x: get_embedding(x, "text-embedding-3-large"))

smaller_tokens_docs_reset['text-embedding-ada-002'] = smaller_tokens_docs_reset["concatenated_text"].apply(lambda x: get_embedding(x, "text-embedding-ada-002"))Offerto da

Dopo aver eseguito con successo il codice sopra, possiamo vedere che le colonne di embedding pertinenti sono state aggiunte.

smaller_tokens_docs_reset.head(1)Offerto da

Nuovo dataframe con le colonne di embedding pertinenti

Ricerca di similarità

Questa sezione utilizza la tecnica della similarità coseno su ciascuno degli approcci di embedding sopra per trovare i 3 documenti più simili a un documento specifico.

La seguente funzione di supporto accetta quattro parametri principali:

• Il dataframe corrente
• L’indice del testo per cui vogliamo trovare i documenti più simili
• Lo specifico embedding da utilizzare
• Il numero di documenti più simili desiderati, 3 per impostazione predefinita.

def find_top_N_similar_documents(df, chosen_index,
                             	embedding_column_name,
                             	top_N=3):
    
	chosen_document_embedding = np.array(df.iloc[chosen_index][embedding_column_name]).reshape(1, -1)
	embedding_matrix = np.vstack(df[embedding_column_name])
	similarity_scores = cosine_similarity(chosen_document_embedding, embedding_matrix)[0]
    
	df_temp = df.copy()
	df_temp['similarity_to_chosen'] = similarity_scores
	similar_documents = df_temp.drop(index=chosen_index).sort_values(by='similarity_to_chosen', ascending=False)
	top_N_similar = similar_documents.head(top_N)
    
	return top_N_similar[[concatenated_text, 'similarity_to_chosen']]Offerto da

Nella sezione seguente, troviamo i documenti più simili al primo documento (index=0)

Ecco come appare il primo documento:

chosen_index = 0

first_document_data = smaller_tokens_docs_reset.iloc[0]["concatenated_text"]
print(first_document_data)Offerto da

Contenuto del primo documento (versione concatenata)

La funzione di ricerca della similarità può essere eseguita come segue:

top_3_similar_3_small = find_top_N_similar_documents(smaller_tokens_docs_reset,
                                                 	chosen_index,
                                                 	"text-embedding-3-small")

top_3_similar_3_large= find_top_N_similar_documents(smaller_tokens_docs_reset,
                                                 	chosen_index,
                                                 	"text-embedding-3-large")

top_3_similar_ada_002 = find_top_N_similar_documents(smaller_tokens_docs_reset,
                                                 	chosen_index,
                                                 	"text-embedding-ada-002")Offerto da

Dopo aver elaborato i compiti di similarità, il risultato può essere visualizzato come segue:

print("Top 3 Similar Documents with :")
print("--> text-embedding-3-small")
print(top_3_similar_3_small)
print("\n")

print("--> text-embedding-3-large")
print(top_3_similar_3_large)
print("\n")

print("--> text-embedding-ada-002")
print(top_3_similar_ada_002)
print("\n")Offerto da

Top 3 documenti più simili usando ciascun modello di embedding

Osservazioni sul risultato

Il modello "text-embedding-3-small" mostra punteggi di similarità moderati, intorno a 0,54, mentre "text-embedding-3-large" presenta punteggi leggermente più alti, indicando una migliore capacità di catturare la similarità.

Il modello "text-embedding-ada-002" mostra punteggi di similarità significativamente più alti, con il punteggio massimo vicino a 0,85, suggerendo una fortissima similarità con il documento scelto.

Tuttavia, il Documento 372 è un risultato comune in cima alla lista per tutti i modelli, a indicare una rilevanza costante rispetto alla query. Le differenze nei punteggi tra i modelli evidenziano l’impatto della scelta del modello di embedding sui risultati di similarità.

Conclusione

In conclusione, i nuovi modelli text-embedding-3-large e text-embedding-3-small di OpenAI rappresentano un salto significativo nel campo dell’elaborazione del linguaggio naturale, offrendo rappresentazioni del testo più sfumate e ad alta dimensionalità.

Come mostrato nell’articolo, la scelta tra questi modelli può influire in modo sostanziale sull’esito di vari task NLP, come la similarità tra documenti, l’analisi del sentiment e i sistemi di supporto multilingue. Sebbene text-embedding-3-large offra una precisione superiore grazie al numero maggiore di dimensioni, text-embedding-3-small offre un equilibrio tra efficienza e prestazioni per applicazioni sensibili ai costi.

L’analisi di benchmarking ha rivelato che text-embedding-3-large supera i suoi predecessori, fissando un nuovo standard nel settore. Le applicazioni reali di questi modelli sono vaste, dal potenziamento dell’assistenza clienti all’alimentazione di motori di ricerca sofisticati e sistemi di raccomandazione dei contenuti.

Seguendo la guida dettagliata fornita, i professionisti del settore sono in grado di prendere decisioni informate su quale modello usare in base alla complessità del task, ai vincoli di budget e alla necessità di capacità multilingue.

In definitiva, la scelta del modello dovrebbe allinearsi alle esigenze specifiche del progetto, sfruttando i punti di forza di text-embedding-3-large per i compiti che richiedono alta fedeltà e di text-embedding-3-small per scopi più generali. L’avvento di questi modelli sottolinea l’impegno di OpenAI nel far progredire la tecnologia AI e la continua evoluzione degli strumenti di machine learning.

Dove andare da qui?

Il nostro articolo, The OpenAI API in Python, è una cheat sheet che ti aiuta a imparare le basi per sfruttare una delle API di AI più potenti, la OpenAI API.

La nostra sessione di code along Fine-tuning GPT3.5 with OpenAI API fornisce le guide per utilizzare OpenAI API e Python per iniziare a fare fine-tuning di GPT3.5, aiutandoti a capire quando il fine-tuning dei large language model può essere utile, come usare gli strumenti di fine-tuning nella OpenAI API e, infine, a comprendere il workflow del fine-tuning.