OpenAI o1: Cosa devono sapere gli sviluppatori
Nel settembre 2024, OpenAI ha introdotto l’ultima serie dei suoi Large Language Models (LLM) proprietari, chiamata serie o1. La caratteristica principale che differenzia la serie o1 dal precedente modello più potente di OpenAI, GPT-4o, è la loro capacità di ragionare sui problemi prima di generare una risposta finale per l’utente. Questo significa che i modelli o1 sono addestrati a scomporre i problemi in componenti più piccoli e a risolverli in modo graduale, un processo comunemente definito ragionamento chain-of-thought.
In questo articolo, parleremo della serie o1 dalla prospettiva di uno sviluppatore, esplorando come questi modelli possano essere implementati per casi d’uso sofisticati. Prima, esaminiamo brevemente cosa sono i modelli o1, come si comportano rispetto a GPT-4o e le nuove funzionalità introdotte da OpenAI con questa serie.
Breve introduzione ai modelli o1
OpenAI ha introdotto tre varianti nella serie o1: o1-preview, o1 e o1-mini, con o1-preview come prima variante lanciata. Tutte e tre le varianti condividono una caratteristica unica rispetto ad altri modelli OpenAI come GPT-4: capacità di ragionamento avanzate.
I modelli o1 sono progettati per dedicare più tempo all’analisi di un problema prima di generare una risposta. Questo approccio imita il modo in cui gli esseri umani scompongono e risolvono questioni complesse. Per qualsiasi problema dato, questi modelli tentano di scomporre la domanda, articolare il loro processo di pensiero passo dopo passo ed esplorare soluzioni alternative se il loro ragionamento iniziale è inadeguato.
Poiché questi modelli sono interamente closed-source, i dettagli espliciti sul loro processo di addestramento rimangono non disponibili. Tuttavia, ci sono due approcci probabilmente utilizzati durante l’addestramento dei modelli o1: prompting chain-of-thought (CoT) e reinforcement learning (RL).
Il concetto alla base del prompting CoT è semplice. Invece di fornire al modello le risposte dirette per determinati problemi, i prompt CoT includono passaggi contestuali dettagliati per risolvere i problemi, come puoi vedere di seguito:
Confronto tra prompt normale e prompt CoT.
Combinando un’enorme quantità di dati di prompting CoT con RL durante il fine-tuning, il modello affina iterativamente il suo processo di ragionamento. Impara a identificare le falle nella propria logica e ad adottare approcci più sensati alla risoluzione dei problemi. Il modello viene quindi ricompensato per la generazione di passaggi di ragionamento accurati e risposte corrette. Di conseguenza, i modelli della serie o1 possono pensare in modo critico e ragionare efficacemente prima di fornire risposte.
Per implementare questa capacità di ragionamento, OpenAI ha introdotto nei modelli o1 token aggiuntivi chiamati "reasoning tokens". A differenza di altri LLM che usano solo token di input e output, i modelli o1 utilizzano reasoning tokens per facilitare il loro processo di pensiero.
Questi reasoning tokens permettono al modello di analizzare i prompt e considerare più approcci prima di generare token di output. Una volta finalizzata una risposta, i reasoning tokens vengono scartati dal contesto. Di seguito è riportata una visualizzazione delle dinamiche dei token di input, output e reasoning durante più cicli di interazione utente-modello:
Le dinamiche dei token di input, output e reasoning durante più cicli di interazione utente-modello. Fonte.
Cosa rende o1 unico (e perché è importante per gli sviluppatori)
In sostanza, i modelli o1 si basano su tutto ciò che rende GPT-4o eccellente, ma spingono oltre i confini combinando approcci chain-of-thought (CoT) e reinforcement learning (RL). Di conseguenza, i modelli o1 superano GPT-4o in vari ambiti che richiedono ragionamento complesso, come programmazione, matematica e scienze generali.
Come illustrato nella visualizzazione qui sotto, sia il modello o1-preview sia il modello o1 superano GPT-4o nei benchmark che richiedono ragionamento avanzato. In particolare, ottengono risultati significativamente migliori in tre benchmark chiave di ragionamento scientifico: AIME 2024, Codeforces e GPQA Diamond.
AIME 2024: Un benchmark basato su esami di matematica progettati per mettere alla prova gli studenti di matematica delle scuole superiori più brillanti negli Stati Uniti.
GPQA Diamond: Misura la competenza in materie scientifiche come chimica, biologia e fisica.
Codeforces: Include sfide tratte da competizioni di programmazione competitiva.
Confronto tra GPT-4o, o1-preview e il modello o1 su diversi benchmark di ragionamento. Fonte.
Sebbene il modello o1-preview dimostri prestazioni superiori nei compiti di ragionamento complesso rispetto a GPT-4o, presenta notevoli svantaggi:
Elevato utilizzo di token di ragionamento: o1-preview genera un gran numero di token di ragionamento, che consumano una parte significativa della finestra di contesto da 128.000 token del modello. Per attività che richiedono estesi token di input-output, le risposte potrebbero essere troncate. Questo aumenta anche i costi di utilizzo rispetto a GPT-4o.
Problemi di latenza: L’elevato numero di token contribuisce a tempi di risposta più lenti. In media, la latenza di o1-preview è circa 10 volte più lenta di GPT-4o, rendendolo meno ideale per l’uso in produzione.
Per affrontare queste limitazioni, OpenAI ha introdotto due modelli aggiuntivi nella serie o1: o1-mini e il più recente modello o1.
o1-mini è un modello più piccolo rispetto a o1-preview ed è specificamente ottimizzato per dati relativi a STEM. Questa ottimizzazione gli consente di superare o1-preview nei benchmark scientifici come AIME 2024 (raggiungendo il 70% di accuratezza rispetto al 44,6% di o1-preview) e Codeforces.
Confronto tra GPT-4o, o1-preview e il modello o1-mini sui benchmark Codeforces. Fonte.
Inoltre, essendo più piccolo di o1-preview, o1-mini ha una latenza più rapida. Il tempo di inferenza per questo modello è circa 3–5 volte più veloce rispetto a quello di o1-preview. Tuttavia, è importante notare che le prestazioni di o1-mini sono ancora inferiori a quelle di o1-preview nei benchmark non-STEM.
Per migliorare ulteriormente prestazioni e capacità, OpenAI ha introdotto la versione più recente del modello o1. Come mostrato nella visualizzazione sopra, questo modello supera o1-preview in tutti i benchmark scientifici.
Oltre a prestazioni più solide nei compiti di ragionamento complesso, il modello o1 più recente offre anche diversi miglioramenti chiave:
Finestra di contesto più ampia: Supporta fino a 200.000 token per l’input e un massimo di 100.000 token di output.
Utilizzo efficiente dei token di ragionamento: Utilizza in media circa il 60% in meno di token di ragionamento rispetto a o1-preview per qualsiasi richiesta. Questo rende la latenza dei modelli o1 più recenti migliore di quella di o1 preview.
Capacità di visione: Accetta immagini come input, consentendo il ragionamento su dati visivi. Nota che questa funzionalità non è disponibile né nei modelli o1-preview né in o1-mini.
Integrazione migliorata con gli strumenti OpenAI: Include funzionalità per output strutturati, chiamata di funzioni e stili o toni definiti dallo sviluppatore. Inoltre, gli utenti possono regolare lo sforzo di ragionamento (basso, medio o alto) utilizzando il parametro
reasoning_effortper bilanciare velocità, costo e qualità.
Casi d’uso reali dei modelli o1
Ci sono molti casi d’uso reali che possiamo risolvere utilizzando la serie o1. In questa sezione, ti guideremo attraverso diversi esempi, come il ragionamento su problemi complessi, l’estrazione di informazioni e la deduzione dai testi, Retrieval Augmented Generation (RAG), la comprensione delle immagini e la chiamata di funzioni.
Tuttavia, al momento della stesura di questo articolo, la disponibilità del modello o1 più recente è ancora limitata, poiché è disponibile solo per determinati livelli di utenti. Pertanto, dimostreremo gli snippet di codice per i casi d’uso utilizzando il modello o1-mini ogni volta che sarà possibile, poiché questo modello è accessibile alla maggior parte dei livelli di utenti (dal Tier 1 al 5).
Prima di procedere con gli esempi, dobbiamo innanzitutto impostare la nostra chiave API di OpenAI. Puoi scoprire di più su come configurare la tua chiave API qui. Successivamente, inserisci la chiave API come parte dell’ambiente come segue:
import getpass
import os
if not os.environ.get("OPENAI_API_KEY"):
os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter API key for OpenAI: ")
E ora siamo pronti a usare i modelli di OpenAI.
Ragionamento su problemi complessi
L’applicazione più immediata del modello o1 è risolvere problemi complessi di matematica e programmazione che richiedono un ragionamento approfondito prima di poter arrivare a una risposta. Supponiamo di volerci far insegnare come risolvere un problema di matematica; possiamo farlo chiamando l’API di OpenAI come segue:
from openai import OpenAI
client = OpenAI()
prompt = """
Julie is reading a 120-page book. Yesterday, she was able to read 12 pages and
today, she read twice as many pages as yesterday. If she wants to read half of the
remaining pages tomorrow, how many pages should she read?
"""
response = client.chat.completions.create(
model="o1-mini",
messages=[
{
"role": "user",
"content": prompt
}
]
)
print(response.choices[0].message.content)
"""
Output:
To determine how many pages Julie should read tomorrow, let's break down the problem step by step:
1. **Total Pages in the Book:**
The book has **120 pages**.
2. **Pages Read Yesterday:**
Julie read **12 pages** yesterday.
3. **Pages Read Today:**
Today, she read **twice** as many pages as yesterday.
( 2 times 12 = 24 ) pages.
4. **Total Pages Read in Two Days:**
( 12 text{ (yesterday)} + 24 text{ (today)} = 36 ) pages.
5. **Remaining Pages:**
( 120 text{ (total)} - 36 text{ (read)} = 84 ) pages left.
6. **Pages to Read Tomorrow:**
She wants to read **half** of the remaining pages:
( frac{84}{2} = 42 ) pages.
**Answer:**
Julie should read **42 pages** tomorrow.
"""
Come puoi vedere, invece di fornire soltanto la risposta finale, il modello genera il suo processo di pensiero passo dopo passo, il che migliora la nostra comprensione di come affrontare problemi simili in futuro.
Automazioni creative
Come con altri LLM di OpenAI, il modello o1 può essere usato per l’automazione creativa, come riassumere il contenuto di un PDF, generare uno script YouTube da un articolo ed estrarre e dedurre informazioni particolari dai documenti.
Nell’esempio seguente, useremo il modello o1-mini per estrarre informazioni specifiche da un testo con uno schema di output specifico. Non solo estrarremo informazioni contenute nel testo, ma chiederemo anche al modello di dedurre informazioni eseguendo semplici operazioni matematiche.
import requests
def fetch_html(url):
response = requests.get(url)
if response.status_code == 200:
return response.text
else:
return None
url = "<https://en.wikipedia.org/wiki/List_of_NBA_career_scoring_leaders>"
html_content = fetch_html(url)
json_format = """
{
companies: [
{
"player_name": "Tim Duncan",,
"total_points": "1750",
"total_points_without_free_throw": "1050",
}
]
}
"""
o1_response = client.chat.completions.create(
model="o1-mini",
messages=[
{
"role": "user",
"content": f"""
Extract information from the text.
- Read the following html and return players with the most points without free throw in the NBA's history: {html_content}.
- Restituisci il risultato in ordine dal più alto al più basso e mostrami i primi 5. Restituisci solo come JSON con il seguente formato: {json_format}"
"""
}
]
)
print(o1_response.choices[0].message.content)
"""
Output:
```json
{
"players": [
{
"player_name": "LeBron James",
"total_points": "41599",
"total_points_without_free_throw": "33048"
},
{
"player_name": "Kareem Abdul-Jabbar",
"total_points": "38387",
"total_points_without_free_throw": "31675"
},
{
"player_name": "Karl Malone",
"total_points": "36928",
"total_points_without_free_throw": "27141"
},
{
"player_name": "Wilt Chamberlain",
"total_points": "31419",
"total_points_without_free_throw": "25362"
},
{
"player_name": "Kobe Bryant",
"total_points": "33643",
"total_points_without_free_throw": "25265"
}
]
}
"""
Come puoi vedere, il modello o1 non solo estrae le informazioni secondo lo schema di output che abbiamo definito, ma è anche in grado di eseguire operazioni matematiche e includere il risultato appropriato nello schema di output insieme alle altre informazioni estratte.
Motori di ricerca basati sull’IA
Possiamo anche usare il modello o1 in un contesto di Retrieval Augmented Generation (RAG), in cui lo utilizziamo per generare una risposta a una query basata sul contesto fornito ottenuto tramite ricerca per similarità.
Il flusso di lavoro abituale di un’applicazione RAG è il seguente: data una query dell’utente, la query viene trasformata in un embedding utilizzando un modello di embedding a nostra scelta, come text-embedding-3-large di OpenAI. Successivamente, l’embedding della query viene confrontato con una raccolta di embedding di contesto memorizzati all’interno di un database vettoriale tramite ricerca per similarità. I top-k contesti più rilevanti vengono quindi recuperati e aggiunti al prompt, fornendo al nostro LLM un contesto utile per rispondere alla query.
Flusso di lavoro RAG.
Come puoi vedere, per usare il modello o1 in un caso d’uso RAG, di solito lo combiniamo con database vettoriali, come Milvus, per archiviare enormi quantità di contesto ed eseguire ricerche per similarità efficienti e veloci.
Nell’esempio seguente, creeremo una semplice applicazione RAG utilizzando la combinazione del modello o1-mini e Milvus.
Per prima cosa, carichiamo la sorgente di testo da HTML, che useremo come possibili contesti nella nostra applicazione RAG. Successivamente, dividiamo il testo originale in chunk, ciascuno composto da circa 2000 caratteri. Dopo il processo di chunking, possiamo memorizzare tutti i chunk all’interno del database vettoriale Milvus. Imposteremo il tipo di indicizzazione su "FLAT" poiché vogliamo condurre una ricerca esaustiva per trovare i migliori contesti possibili per qualsiasi query data.
!pip install --upgrade --quiet langchain langchain-core langchain-community langchain-text-splitters langchain-milvus langchain-openai bs4
import bs4
from langchain_community.document_loaders import WebBaseLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_milvus import Milvus
from langchain_openai import OpenAIEmbeddings
# Create a WebBaseLoader instance to load documents from web sources
loader = WebBaseLoader(
web_paths=(
"<https://lilianweng.github.io/posts/2023-06-23-agent/>",
"<https://lilianweng.github.io/posts/2023-03-15-prompt-engineering/>",
),
bs_kwargs=dict(
parse_only=bs4.SoupStrainer(
class_=("post-content", "post-title", "post-header")
)
),
)
# Load documents from web sources using the loader
documents = loader.load()
# Initialize a RecursiveCharacterTextSplitter for splitting text into chunks
text_splitter = RecursiveCharacterTextSplitter(chunk_size=2000, chunk_overlap=200)
# Dividi i documenti in blocchi usando il text_splitter
docs = text_splitter.split_documents(documents)
# Definisci il modello di embedding predefinito di OpenAI
embeddings = OpenAIEmbeddings()
# Memorizza i dati suddivisi in blocchi in Milvus
vectorstore = Milvus.from_documents(
documents=docs,
embedding=embeddings,
connection_args={
"uri": "./milvus_demo.db",
},
index_params={"index_type": "FLAT", "metric_type": "L2"},
drop_old=True, # Elimina la vecchia collection Milvus se esiste
)
Ora possiamo definire il modello e il prompt, che contiene istruzioni come "Usa il contesto fornito per rispondere alla query", oltre alla query stessa. Recupereremo il top-1 dei contesti più rilevanti come risultato.
from langchain_openai import ChatOpenAI
from langchain import hub
# Inizializza il modello linguistico OpenAI per la generazione delle risposte
llm = ChatOpenAI(model_name="o1-mini", temperature=1)
# Definisci il template del prompt per generare risposte AI
prompt = hub.pull("rlm/rag-prompt")
# Converti il vector store in un retriever
retriever = vectorstore.as_retriever()
query = "What is self-reflection of an AI Agent?"
vectorstore.similarity_search(query, k=1)
Infine, possiamo orchestrare facilmente il flusso di lavoro RAG con LangChain e poi ottenere la risposta dal nostro modello o1-mini a qualsiasi query fornita, usando il contesto più rilevante recuperato dal nostro database Milvus.
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
# Definisci una funzione per formattare i documenti recuperati
def format_docs(docs):
return "nn".join(doc.page_content for doc in docs)
# Definisci la catena RAG (Retrieval-Augmented Generation) per la generazione di risposte AI
rag_chain = (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
# rag_chain.get_graph().print_ascii()
# Invoca la catena RAG con una domanda specifica e recupera la risposta
res = rag_chain.invoke(query)
print(res)
"""
Output:
L’autoriflessione in un agente AI si riferisce alla sua capacità di valutare e perfezionare le proprie azioni e decisioni sulla base delle esperienze passate. Questo processo consente all’agente di identificare e correggere gli errori, migliorando così le sue prestazioni nel tempo. È essenziale per gestire attività complesse del mondo reale, dove è necessario un miglioramento iterativo attraverso tentativi ed errori.
"""
Comprensione delle immagini
Uno dei principali vantaggi dell’ultimo modello o1 rispetto a o1-preview e o1-mini è la sua capacità multimodale: accetta come input non solo testo, ma anche immagini. Questo rende il modello o1 ideale per casi d’uso di ragionamento sulle immagini, come descrivere il contenuto di un’immagine, riassumere il testo in un’immagine ed estrarre informazioni strutturate da un’immagine.
Ci sono due modi in cui possiamo fornire al modello un input immagine: passando il link all’immagine oppure passando l’immagine codificata in Base64. Di seguito è riportato il codice di esempio per farlo:
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
model="o1",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "What's in this image?"},
{
"type": "image_url",
"image_url": {
"url": "<https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg>",
},
},
],
}
],
max_tokens=300,
)
print(response.choices[0])
Function Calling
Un altro entusiasmante caso d'uso che possiamo esplorare con il modello o1 è la function calling. In sostanza, la function calling consente all'LLM di interagire con il nostro codice o con servizi esterni, come un motore di ricerca o un'API. Grazie alla sua capacità di ragionare su un problema, può utilizzare accuratamente i servizi esterni appropriati per aiutarlo a risolvere il compito in questione.
Ad esempio, supponiamo di voler conoscere il meteo attuale a Los Angeles. Senza servizi esterni, sarebbe impossibile per l'LLM darci la risposta corretta, ed è probabile che inizi ad avere allucinazioni. Se abbiamo accesso all'API meteo, possiamo usare questo "tool" come risorsa aggiuntiva per aiutare il nostro modello o1 a rispondere alla nostra query.
Puoi saperne di più sull'implementazione del codice della function calling per creare un modello agentico nelle documentazioni fornite da OpenAI o LangChain.
Confronto tra il modello o1 e le sue alternative
In questa sezione, confronteremo i pro e i contro del modello o1 con le sue alternative, come GPT 4o, o3-mini, Claude 3.5 Sonnet e DeepSeek R1.
Confronto con GPT 4o
Sebbene le prestazioni del modello o1 siano di gran lunga superiori a quelle del modello GPT-4o nei benchmark di ragionamento complesso, ciò non significa che dovremmo sempre scegliere il modello o1 rispetto a GPT-4o.
Nel complesso, il modello o1 eccelle nei compiti che richiedono processi di pensiero complessi e dettagliati, come i compiti di ideazione. Ad esempio, possiamo usare il modello o1 come partner per aiutarci a pianificare strategie e delineare gli scenari migliori e peggiori per un'azienda che stiamo per avviare. In ambito educativo, possiamo usare il modello o1 per generare spiegazioni dettagliate per ogni componente di un corso scientifico che stiamo sviluppando. Possiamo anche utilizzare il modello o1 come nostro partner durante le revisioni del codice o per l'ottimizzazione del codice.
Tuttavia, quando vogliamo distribuire un assistente AI in produzione, GPT-4o è attualmente ancora preferito al modello o1. Questo perché GPT-4o è molto più maturo in termini di implementazione dell'API di OpenAI rispetto al modello o1. Ad esempio, mentre sia GPT-4o sia il modello o1 accettano immagini come input, il modello o1 non ha accesso a diversi strumenti e funzionalità, come istruzioni personalizzate, caricamenti di file (eccetto le immagini), funzionalità vocali e navigazione web. Pertanto, se il nostro caso d'uso richiede queste funzionalità, dobbiamo usare GPT-4o.
Inoltre, la disponibilità del modello o1 è al momento limitata. Solo alcuni utenti hanno accesso al modello, poiché dovremmo essere almeno utenti di Tier 3 o sottoscrivere un piano ChatGPT Plus o Pro per poter accedere a questo modello. Inoltre, se la latenza di inferenza è molto critica nel nostro caso d'uso, GPT-4o offre ancora un'alternativa migliore rispetto al modello o1.
Confronto con o3-mini
Il modello o3-mini è il modello più recente tra gli LLM di ragionamento di OpenAI. Come o1-mini, o3-mini è stato altamente ottimizzato nei domini STEM, ma con prestazioni superiori a o1-mini e comparabili al modello o1, come puoi vedere nel grafico delle prestazioni sui diversi benchmark STEM mostrato di seguito:
Confronto delle prestazioni tra o3-mini e il modello o1 su diversi benchmark STEM. Fonte.
o3-mini mantiene tutto ciò che rende o1-mini eccellente (basso costo e bassa latenza) e lo migliora ulteriormente. Pertanto, se il tuo caso d'uso rientra nel dominio STEM e la latenza o il costo sono critici, allora il modello o3 sarebbe preferibile al modello o1. Tuttavia, il modello o1 offre comunque una conoscenza più ampia rispetto a o3-mini, il che lo rende più adatto da usare se il tuo caso d'uso è più generale e non rientra nel dominio STEM.
Sia il modello o3-mini sia il modello o1 supportano funzionalità API avanzate come la chiamata di funzioni, l’output strutturato, i messaggi per sviluppatori, nonché lo sforzo di ragionamento regolabile. Tuttavia, o3-mini attualmente supporta solo input testuali, il che significa che se l’input del nostro caso d’uso è un’immagine, allora dobbiamo usare il modello o1.
Per quanto riguarda la disponibilità tramite API, al momento, sia i modelli o3-mini sia i modelli o1 sono disponibili solo per gli utenti nei Tier 3-5. Puoi usare entrambi i modelli se sei abbonato a ChatGPT Plus, Pro e Team.
Confronto con DeepSeek R1 e Claude 3.5 Sonnet
Altre alternative al modello o1 includono Claude 3.5 Sonnet e DeepSeek R1. Tra questi due, DeepSeek R1 è un concorrente più vicino a o1 grazie alla sua ottimizzazione del ragionamento durante l’addestramento, mentre Claude 3.5 Sonnet non è stato realmente ottimizzato per il ragionamento. Come puoi vedere in diversi benchmark di ragionamento qui sotto, sia o1 sia R1 superano 3.5 Sonnet con un margine considerevole. Nel frattempo, le prestazioni di o1 e R1 sono paragonabili tra loro.
Confronto tra il modello o1 e altri modelli rappresentativi. Fonte.
Pertanto, si consiglia di usare o1 o R1 quando il tuo caso d’uso richiede capacità di ragionamento dall’LLM. In caso contrario, Claude 3.5 Sonnet sarebbe preferibile poiché offrirebbe sia un costo inferiore sia una latenza migliore rispetto al modello o1.
Ora supponiamo che il nostro caso d’uso richieda la capacità di ragionamento dai nostri LLM, il che significa che possiamo usare i modelli o1 o R1. Il principale vantaggio del modello R1 è la sua natura open-source, il che significa che possiamo ospitarlo nella nostra infrastruttura. Questo è molto vantaggioso se la privacy dei dati è una preoccupazione nel nostro caso d’uso.
In termini di latenza, R1 potrebbe essere migliore di o1 grazie alla sua architettura Mixture-of-Expert (MoE). Grazie a MoE, solo una piccola frazione dei parametri di R1 sarà attivata in qualsiasi richiesta, il che accelera il processo di inferenza. Inoltre, R1 adotta un approccio di previsione multi-token durante l’addestramento, che può essere riutilizzato per il decoding speculativo durante l’inferenza. Questo accelera ulteriormente il processo di inferenza.
Tuttavia, è importante notare che DeepSeek R1 contiene in totale 671B parametri, il che significa che sono necessari circa 1,5 TB di memoria GPU (ad es., NVIDIA A100 80GB x16) per ospitarlo. Pertanto, è molto costoso ospitare il modello autonomamente, e usare il modello o1 sarebbe preferibile per evitarci i passaggi complicati dell’hosting di R1.Con o1, dobbiamo pagare solo quando effettuiamo la richiesta API. Questo finisce per essere più economico nella maggior parte dei casi rispetto al costo orario della GPU che dobbiamo pagare quando ospitiamo il modello R1 su provider cloud popolari come AWS o GCP.
Conclusione
Il modello o1 rappresenta un progresso nelle capacità di ragionamento dell’IA, poiché migliora GPT-4o integrando il prompting chain-of-thought e il reinforcement learning. Grazie alla sua capacità di scomporre problemi complessi ed esplorare soluzioni alternative, il modello o1 eccelle in attività che richiedono un pensiero analitico profondo, come attività legate alle STEM o alla programmazione. Inoltre, l’ultimo modello o1 migliora l’efficienza con una finestra di contesto più ampia, capacità multimodali e un uso ottimizzato dei token di ragionamento.
Tuttavia, nonostante i suoi punti di forza, adottare il modello o1 rispetto alle sue alternative dipende ancora totalmente dai requisiti specifici del caso d’uso. Il modello o1 supera GPT-4o nelle attività di ragionamento complesso ma, in termini di costo, latenza e maturità dell’API, GPT-4o è più preferibile. Rispetto a o3-mini, o1 offre una conoscenza generale più ampia, mentre o3-mini è più efficiente per applicazioni STEM con costo e latenza inferiori. Rispetto a DeepSeek R1 e Claude 3.5 Sonnet, o1 e R1 eccellono nel ragionamento, ma la natura open-source di R1 e l’architettura Mixture-of-Expert migliorano la latenza, sebbene richieda un’infrastruttura costosa.
Tutorial che usano OpenAI GPT-o1
Chatbot RAG con LangChain, Milvus, OpenAI GPT-o1 e OpenAI text-embedding-3-small
Chatbot RAG con LangChain, Milvus, OpenAI GPT-o1 e NVIDIA embed-qa-4
Chatbot RAG con LangChain, Milvus, OpenAI GPT-o1 e Cohere embed-multilingual-v3.0
Chatbot RAG con LangChain, Milvus, OpenAI GPT-o1 e Ollama mxbai-embed-large
Chatbot RAG con LangChain, Milvus, OpenAI GPT-o1 e HuggingFace all-MiniLM-L12-v1
Continua a leggere
Zilliz Cloud Update: Tiered Storage, Business Critical Plan, Cross-Region Backup, and Pricing Changes
This release offers a rebuilt tiered storage with lower costs, a new Business Critical plan for enhanced security, and pricing updates, among other features.
Announcing the General Availability of Zilliz Cloud BYOC on Google Cloud Platform
Zilliz Cloud BYOC on GCP offers enterprise vector search with full data sovereignty and seamless integration.
DeepSeek Always Busy? Deploy It Locally with Milvus in Just 10 Minutes—No More Waiting!
Learn how to set up DeepSeek-R1 on your local machine using Ollama, AnythingLLM, and Milvus in just 10 minutes. Bypass busy servers and enhance AI responses with custom data.