OpenAI o1 : ce que les développeurs doivent savoir
En septembre 2024, OpenAI a présenté la dernière série de ses grands modèles de langage (LLM) propriétaires, appelée la série o1. La principale caractéristique qui différencie la série o1 du modèle le plus puissant précédent d’OpenAI, GPT-4o, est leur capacité à réfléchir aux problèmes avant de générer une réponse finale pour l’utilisateur. Cela signifie que les modèles o1 sont entraînés à décomposer les problèmes en composants plus petits et à les résoudre étape par étape, un processus communément appelé raisonnement par chaîne de pensée.
Dans cet article, nous parlerons de la série o1 du point de vue d’un développeur, en explorant comment ces modèles peuvent être implémentés pour des cas d’utilisation sophistiqués. Avant cela, examinons brièvement ce que sont les modèles o1, comment ils se comportent par rapport à GPT-4o, et les nouvelles fonctionnalités qu’OpenAI a introduites avec cette série.
Brève introduction aux modèles o1
OpenAI a introduit trois variantes dans la série o1 : o1-preview, o1 et o1-mini, o1-preview ayant été la première à être lancée. Les trois variantes partagent une fonctionnalité unique par rapport à d’autres modèles OpenAI comme GPT-4 : des capacités de raisonnement avancées.
Les modèles o1 sont conçus pour passer plus de temps à analyser un problème avant de générer une réponse. Cette approche imite la façon dont les humains dissèquent et résolvent des problèmes complexes. Pour tout problème donné, ces modèles tentent de décomposer la question, d’articuler leur processus de réflexion étape par étape et d’explorer des solutions alternatives si leur raisonnement initial est inadéquat.
Comme ces modèles sont entièrement closed-source, les détails explicites concernant leur processus d’entraînement restent indisponibles. Cependant, il existe deux approches probablement utilisées lors de l’entraînement des modèles o1 : le prompting par chaîne de pensée (CoT) et l’apprentissage par renforcement (RL).
Le concept derrière le prompting CoT est simple. Au lieu de donner au modèle les réponses directes aux problèmes donnés, les prompts CoT incluent des étapes contextuelles détaillées pour résoudre les problèmes, comme vous pouvez le voir ci-dessous :
Comparaison entre un prompt normal et un prompt CoT.
En combinant une quantité massive de données de prompting CoT avec le RL lors du fine-tuning, le modèle affine itérativement son processus de raisonnement. Il apprend à identifier les failles dans sa logique et à adopter des approches plus sensées pour la résolution de problèmes. Le modèle est ensuite récompensé pour la génération d’étapes de raisonnement précises et de réponses correctes. Ainsi, les modèles de la série o1 peuvent penser de manière critique et raisonner efficacement avant de fournir des réponses.
Pour implémenter cette capacité de raisonnement, OpenAI a introduit des tokens supplémentaires appelés "reasoning tokens" dans les modèles o1. Contrairement aux autres LLM qui n’utilisent que des tokens d’entrée et de sortie, les modèles o1 utilisent des reasoning tokens pour faciliter leur processus de réflexion.
Ces reasoning tokens permettent au modèle d’analyser les prompts et d’envisager plusieurs approches avant de générer des tokens de sortie. Une fois qu’une réponse est finalisée, les reasoning tokens sont supprimés du contexte. Ci-dessous se trouve une visualisation de la dynamique des tokens d’entrée, de sortie et de raisonnement au cours de plusieurs tours d’interactions utilisateur-modèle :
La dynamique des tokens d’entrée, de sortie et de raisonnement au cours de plusieurs tours d’interactions utilisateur-modèle. Source.
Ce qui rend o1 unique (et pourquoi c’est important pour les développeurs)
En substance, les modèles o1 s’appuient sur tout ce qui rend GPT-4o excellent, mais repoussent encore les limites en combinant les approches de chaîne de pensée (CoT) et d’apprentissage par renforcement (RL). Ainsi, les modèles o1 surpassent GPT-4o dans divers domaines nécessitant un raisonnement complexe, tels que le codage, les mathématiques et les sciences générales.
Comme illustré dans la visualisation ci-dessous, les modèles o1-preview et o1 surpassent tous deux GPT-4o sur des benchmarks qui exigent un raisonnement avancé. Plus précisément, ils obtiennent de bien meilleurs résultats sur trois benchmarks clés de raisonnement scientifique : AIME 2024, Codeforces et GPQA Diamond.
AIME 2024 : Un benchmark basé sur des examens de mathématiques conçus pour tester les meilleurs lycéens en mathématiques aux États-Unis.
GPQA Diamond : Mesure l’expertise dans des matières scientifiques comme la chimie, la biologie et la physique.
Codeforces : Inclut des défis issus de concours de programmation compétitive.
Comparaison entre GPT-4o, o1-preview et le modèle o1 sur plusieurs benchmarks de raisonnement. Source.
Bien que le modèle o1-preview démontre des performances supérieures dans les tâches de raisonnement complexes par rapport à GPT-4o, il présente des inconvénients notables :
Utilisation élevée de tokens de raisonnement : o1-preview génère un grand nombre de tokens de raisonnement, qui consomment une part importante de la fenêtre de contexte de 128 000 tokens du modèle. Pour les tâches nécessitant de nombreux tokens d’entrée-sortie, les réponses peuvent être tronquées. Cela augmente également les coûts d’utilisation par rapport à GPT-4o.
Problèmes de latence : Le nombre élevé de tokens contribue à des temps de réponse plus lents. En moyenne, la latence d’o1-preview est environ 10 fois plus lente que celle de GPT-4o, ce qui le rend moins idéal pour une utilisation en production.
Pour remédier à ces limites, OpenAI a introduit deux modèles supplémentaires dans la série o1 : o1-mini et le dernier modèle o1.
o1-mini est un modèle plus petit que o1-preview et est spécifiquement optimisé pour les données liées aux STEM. Cette optimisation lui permet de surpasser o1-preview sur des benchmarks scientifiques tels qu’AIME 2024 (atteignant 70 % de précision contre 44,6 % pour o1-preview) et Codeforces.
Comparaison entre GPT-4o, o1-preview et le modèle o1-mini sur les benchmarks Codeforces. Source.
De plus, le fait d’être plus petit qu’o1-preview se traduit par une latence plus rapide pour o1-mini. Le temps d’inférence de ce modèle est environ 3 à 5 fois plus rapide que celui d’o1-preview. Cependant, il est important de noter que les performances d’o1-mini restent inférieures à celles d’o1-preview sur les benchmarks non-STEM.
Pour améliorer encore les performances et les capacités, OpenAI a introduit la dernière version du modèle o1. Comme le montre la visualisation ci-dessus, ce modèle dépasse o1-preview sur tous les benchmarks scientifiques.
Au-delà de performances plus solides sur les tâches de raisonnement complexes, le dernier modèle o1 offre également plusieurs améliorations clés :
Fenêtre de contexte plus large : Prend en charge jusqu’à 200 000 tokens en entrée et un maximum de 100 000 tokens en sortie.
Utilisation efficace des tokens de raisonnement : Utilise en moyenne environ 60 % de tokens de raisonnement en moins qu’o1-preview pour toute requête donnée. Cela rend la latence des derniers modèles o1 meilleure que celle d’o1-preview.
Capacités de vision : Accepte les images comme entrées, permettant le raisonnement sur des données visuelles. Notez que cette fonctionnalité n’est disponible ni dans les modèles o1-preview ni dans o1-mini.
Intégration améliorée avec les outils OpenAI : Inclut des fonctionnalités pour les sorties structurées, l’appel de fonctions et les styles ou tons définis par les développeurs. De plus, les utilisateurs peuvent ajuster l’effort de raisonnement (faible, moyen ou élevé) à l’aide du paramètre
reasoning_effortafin d’équilibrer vitesse, coût et qualité.
Cas d’utilisation réels des modèles o1
Il existe de nombreux cas d’utilisation réels que nous pouvons résoudre en utilisant la série o1. Dans cette section, nous vous présenterons plusieurs exemples, tels que le raisonnement sur des problèmes complexes, l’extraction d’informations et la déduction à partir de textes, la génération augmentée par récupération (RAG), la compréhension d’images et l’appel de fonctions.
Cependant, au moment de la rédaction de cet article, la disponibilité du dernier modèle o1 est encore limitée, car il n’est disponible que pour certains niveaux d’utilisateurs. Par conséquent, nous présenterons les extraits de code pour les cas d’utilisation en utilisant le modèle o1-mini chaque fois que possible, puisque ce modèle est accessible à la plupart des niveaux d’utilisateurs (du niveau 1 au niveau 5).
Avant de passer aux exemples, nous devons d’abord définir notre clé API OpenAI. Vous pouvez en savoir plus sur la configuration de votre propre clé API ici. Ensuite, ajoutez la clé API à l’environnement comme suit :
import getpass
import os
if not os.environ.get("OPENAI_API_KEY"):
os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter API key for OpenAI: ")
Et maintenant, nous sommes prêts à utiliser les modèles d’OpenAI.
Raisonnement pour problèmes complexes
L’application la plus directe du modèle o1 consiste à résoudre des problèmes complexes en mathématiques et en programmation qui nécessitent une réflexion approfondie avant de parvenir à une réponse. Supposons que nous voulions qu’il nous apprenne à résoudre un problème de mathématiques ; nous pouvons le faire en appelant l’API OpenAI comme suit :
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.
"""
Comme vous pouvez le constater, au lieu de fournir uniquement la réponse finale, le modèle génère son processus de réflexion étape par étape, ce qui améliore notre compréhension de la manière d’aborder des problèmes similaires à l’avenir.
Automatisations créatives
Comme avec les autres LLM d’OpenAI, le modèle o1 peut être utilisé pour l’automatisation créative, comme résumer le contenu d’un PDF, générer un script YouTube à partir d’un article, et extraire et déduire des informations particulières à partir de documents.
Dans l’exemple suivant, nous utiliserons le modèle o1-mini pour extraire des informations particulières d’un texte avec un schéma de sortie spécifique. Non seulement nous extrairons les informations contenues dans le texte, mais nous demanderons également au modèle de déduire des informations en effectuant de simples opérations mathématiques.
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}.
- Renvoyez le résultat dans l’ordre du plus élevé au plus bas, et montrez-moi le top 5. Renvoyez uniquement sous forme de JSON avec le format suivant : {json_format}"
"""
}
]
)
print(o1_response.choices[0].message.content)
"""
Sortie :
```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"
}
]
}
"""
Comme vous pouvez le voir, le modèle o1 n’extrait pas seulement les informations selon le schéma de sortie que nous avons défini, mais il est également capable d’effectuer des opérations mathématiques et d’inclure le résultat approprié dans le schéma de sortie avec les autres informations extraites.
Moteurs de recherche alimentés par l’IA
Nous pouvons également utiliser le modèle o1 dans un contexte de Retrieval Augmented Generation (RAG), où nous l’utilisons pour générer une réponse à une requête sur la base du contexte fourni obtenu via une recherche par similarité.
Le flux de travail habituel d’une application RAG est le suivant : étant donné une requête utilisateur, la requête est transformée en embedding à l’aide d’un modèle d’embedding de notre choix, comme text-embedding-3-large d’OpenAI. Ensuite, l’embedding de la requête est comparé à une collection d’embeddings de contexte stockés dans une base de données vectorielle via une recherche par similarité. Les top-k contextes les plus pertinents sont ensuite récupérés et ajoutés au prompt, fournissant à notre LLM un contexte utile pour répondre à la requête.
Flux de travail RAG.
Comme vous pouvez le voir, pour utiliser le modèle o1 dans un cas d’utilisation RAG, nous le combinons généralement avec des bases de données vectorielles, telles que Milvus, afin de stocker d’énormes quantités de contexte et d’effectuer des recherches par similarité efficaces et rapides.
Dans l’exemple ci-dessous, nous allons créer une application RAG simple en utilisant la combinaison du modèle o1-mini et de Milvus.
Tout d’abord, nous chargeons la source de texte depuis HTML, que nous utiliserons comme contextes possibles dans notre application RAG. Ensuite, nous découpons le texte original en morceaux, chacun composé d’environ 2000 caractères. Après le processus de découpage, nous pouvons stocker tous les morceaux dans la base de données vectorielle Milvus. Nous définirons le type d’indexation sur "FLAT" puisque nous voulons effectuer une recherche exhaustive afin de trouver les meilleurs contextes possibles pour toute requête donnée.
!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)
# Diviser les documents en fragments à l’aide de text_splitter
docs = text_splitter.split_documents(documents)
# Définir le modèle d’embedding par défaut d’OpenAI
embeddings = OpenAIEmbeddings()
# Stocker les données fragmentées dans 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, # Supprimer l’ancienne collection Milvus si elle existe
)
Nous pouvons maintenant définir le modèle et le prompt, qui contient des instructions comme « Utilisez le contexte fourni pour répondre à la requête », ainsi que la requête elle-même. Nous récupérerons le contexte le plus pertinent, en top-1, comme résultat.
from langchain_openai import ChatOpenAI
from langchain import hub
# Initialiser le modèle de langage OpenAI pour la génération de réponses
llm = ChatOpenAI(model_name="o1-mini", temperature=1)
# Définir le modèle de prompt pour générer des réponses d’IA
prompt = hub.pull("rlm/rag-prompt")
# Convertir le magasin de vecteurs en récupérateur
retriever = vectorstore.as_retriever()
query = "Qu’est-ce que l’auto-réflexion d’un agent IA ?"
vectorstore.similarity_search(query, k=1)
Enfin, nous pouvons facilement orchestrer le workflow RAG avec LangChain, puis obtenir la réponse de notre modèle o1-mini à n’importe quelle requête donnée en utilisant le contexte le plus pertinent récupéré depuis notre base de données Milvus.
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
# Définir une fonction pour formater les documents récupérés
def format_docs(docs):
return "nn".join(doc.page_content for doc in docs)
# Définir la chaîne RAG (Retrieval-Augmented Generation) pour la génération de réponses d’IA
rag_chain = (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
# rag_chain.get_graph().print_ascii()
# Invoquer la chaîne RAG avec une question spécifique et récupérer la réponse
res = rag_chain.invoke(query)
print(res)
"""
Sortie :
L’auto-réflexion chez un agent IA désigne sa capacité à évaluer et affiner ses propres actions et décisions sur la base d’expériences passées. Ce processus permet à l’agent d’identifier et de corriger ses erreurs, améliorant ainsi ses performances au fil du temps. Elle est essentielle pour gérer des tâches complexes du monde réel, où l’amélioration itérative par essais et erreurs est nécessaire.
"""
Compréhension d’images
L’un des principaux avantages du dernier modèle o1 par rapport à o1-preview et o1-mini est sa capacité multimodale : il accepte non seulement du texte en entrée, mais aussi des images. Cela rend le modèle o1 idéal pour les cas d’usage de raisonnement sur image, comme décrire le contenu d’une image, résumer le texte présent dans une image et extraire des informations structurées d’une image.
Il existe deux façons de fournir une image en entrée au modèle : en transmettant le lien vers l’image ou en transmettant l’image encodée en Base64. Voici ci-dessous un exemple de code pour le faire :
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
model="o1",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "Qu’y a-t-il dans cette 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])
Appel de fonctions
Un autre cas d’utilisation passionnant que nous pouvons explorer avec le modèle o1 est l’appel de fonctions. En substance, l’appel de fonctions permet au LLM d’interagir avec notre code ou des services externes, tels qu’un moteur de recherche ou une API. Grâce à sa capacité à réfléchir à un problème, il peut utiliser avec précision les services externes appropriés pour l’aider à résoudre la tâche à accomplir.
À titre d’exemple, disons que nous voulons connaître la météo actuelle à Los Angeles. Sans services externes, il serait impossible pour le LLM de nous donner la bonne réponse, et il est probable qu’il commence à halluciner. Si nous avons accès à l’API météo, nous pouvons utiliser cet « outil » comme ressource supplémentaire pour aider notre modèle o1 à répondre à notre requête.
Vous pouvez en apprendre davantage sur l’implémentation en code de l’appel de fonctions pour créer un modèle agentique dans les documentations fournies par OpenAI ou LangChain.
Comparaison entre le modèle o1 et ses alternatives
Dans cette section, nous comparerons les avantages et les inconvénients du modèle o1 avec ses alternatives, telles que GPT 4o, o3-mini, Claude 3.5 Sonnet et DeepSeek R1.
Comparaison avec GPT 4o
Bien que les performances du modèle o1 soient largement supérieures à celles du modèle GPT-4o sur les benchmarks de raisonnement complexe, cela ne signifie pas que nous devrions toujours choisir le modèle o1 plutôt que GPT-4o.
Dans l’ensemble, le modèle o1 excelle dans les tâches qui nécessitent des processus de réflexion complexes et détaillés, comme les tâches d’idéation. Par exemple, nous pouvons utiliser le modèle o1 comme partenaire pour nous aider à planifier des stratégies et à définir les meilleurs et les pires scénarios pour une entreprise que nous sommes sur le point de lancer. Dans le domaine de l’éducation, nous pouvons utiliser le modèle o1 pour générer des explications détaillées pour chaque composant d’un cours scientifique que nous développons. Nous pouvons également utiliser le modèle o1 comme partenaire lors des revues de code ou pour l’optimisation du code.
Cependant, lorsque nous voulons déployer un assistant IA en production, GPT-4o est actuellement toujours préféré au modèle o1. Cela s’explique par le fait que GPT-4o est beaucoup plus mature en termes d’implémentation de l’API d’OpenAI par rapport au modèle o1. Par exemple, bien que GPT-4o et le modèle o1 acceptent tous deux les images en entrée, le modèle o1 n’a pas accès à plusieurs outils et fonctionnalités, tels que les instructions personnalisées, les téléversements de fichiers (à l’exception des images), les capacités vocales et la navigation web. Par conséquent, si notre cas d’utilisation nécessite ces fonctionnalités, nous devons utiliser GPT-4o.
De plus, la disponibilité du modèle o1 est limitée pour le moment. Seuls certains utilisateurs ont accès au modèle, car nous devons au moins être un utilisateur de Tier 3 ou souscrire à un forfait ChatGPT Plus ou Pro pour pouvoir accéder à ce modèle. En outre, si la latence d’inférence est très critique dans notre cas d’utilisation, GPT-4o offre encore une meilleure alternative que le modèle o1.
Comparaison avec o3-mini
Le modèle o3-mini est le dernier modèle parmi les LLM de raisonnement d’OpenAI. Tout comme o1-mini, o3-mini a été fortement optimisé dans les domaines STEM, mais avec des performances supérieures à celles d’o1-mini et comparables à celles du modèle o1, comme vous pouvez le voir dans le graphique de performance sur différents benchmarks STEM présenté ci-dessous :
Comparaison des performances entre o3-mini et le modèle o1 sur différents benchmarks STEM. Source.
o3-mini conserve tout ce qui fait la force d’o1-mini (faible coût et faible latence) et l’améliore encore. Par conséquent, si votre cas d’utilisation se situe dans le domaine STEM et que la latence ou le coût est critique, alors le modèle o3 serait préférable au modèle o1. Cependant, le modèle o1 offre toujours des connaissances plus larges qu’o3-mini, ce qui le rend plus adapté si votre cas d’utilisation est plus général et ne relève pas du domaine STEM.
Les modèles o3-mini et o1 prennent tous deux en charge des fonctionnalités d’API avancées comme l’appel de fonctions, la sortie structurée, les messages développeur, ainsi qu’un effort de raisonnement ajustable. Cependant, o3-mini prend actuellement en charge uniquement les entrées textuelles, ce qui signifie que si l’entrée de notre cas d’utilisation est une image, nous devons alors utiliser le modèle o1.
Concernant la disponibilité via l’API, à l’heure actuelle, les modèles o3-mini et o1 ne sont disponibles que pour les utilisateurs des niveaux Tier 3-5. Vous pouvez utiliser les deux modèles si vous êtes abonné à ChatGPT Plus, Pro et Team.
Comparaison avec DeepSeek R1 et Claude 3.5 Sonnet
D’autres alternatives au modèle o1 incluent Claude 3.5 Sonnet et DeepSeek R1. Parmi ces deux modèles, DeepSeek R1 est un concurrent plus proche de o1 en raison de son optimisation du raisonnement pendant l’entraînement, tandis que Claude 3.5 Sonnet n’a pas vraiment été optimisé pour le raisonnement. Comme vous pouvez le voir sur plusieurs benchmarks de raisonnement ci-dessous, o1 et R1 surpassent tous deux 3.5 Sonnet avec une marge considérable. Pendant ce temps, les performances de o1 et R1 sont comparables l’une à l’autre.
Comparaison entre le modèle o1 et d’autres modèles représentatifs. Source.
Par conséquent, il est recommandé d’utiliser soit o1, soit R1 lorsque votre cas d’utilisation nécessite une capacité de raisonnement de la part du LLM. Sinon, Claude 3.5 Sonnet serait préférable, car il offrirait à la fois un coût plus faible et une meilleure latence que le modèle o1.
Supposons maintenant que notre cas d’utilisation nécessite une capacité de raisonnement de la part de nos LLMs, ce qui signifie que nous pouvons utiliser soit les modèles o1, soit R1. Le principal avantage du modèle R1 est sa nature open source, ce qui signifie que nous pouvons l’héberger dans notre propre infrastructure. C’est très avantageux si la confidentialité des données est une préoccupation dans notre cas d’utilisation.
En termes de latence, R1 pourrait être meilleur que o1 grâce à son architecture Mixture-of-Expert (MoE). Grâce au MoE, seule une petite fraction des paramètres de R1 sera activée pour une requête donnée, ce qui accélère le processus d’inférence. De plus, R1 adopte une approche de prédiction multi-token pendant l’entraînement, qui peut être réutilisée pour le décodage spéculatif pendant l’inférence. Cela accélère encore davantage le processus d’inférence.
Cependant, il est important de noter que DeepSeek R1 contient au total 671B de paramètres, ce qui signifie que vous avez besoin d’environ 1,5 To de mémoire GPU (par exemple, NVIDIA A100 80GB x16) pour l’héberger. Par conséquent, il est très coûteux d’héberger le modèle nous-mêmes, et l’utilisation du modèle o1 serait préférable pour nous éviter les étapes compliquées de l’hébergement de R1.Avec o1, nous ne payons que lorsque nous effectuons la requête API. Cela finit par être moins cher dans la plupart des cas par rapport au coût GPU horaire que nous devons payer lorsque nous hébergeons le modèle R1 chez des fournisseurs cloud populaires comme AWS ou GCP.
Conclusion
Le modèle o1 représente une avancée dans les capacités de raisonnement de l’IA, car il améliore GPT-4o en intégrant le prompting par chaîne de pensée et l’apprentissage par renforcement. Grâce à sa capacité à décomposer des problèmes complexes et à explorer des solutions alternatives, le modèle o1 excelle dans les tâches nécessitant une réflexion analytique approfondie, comme les tâches liées aux STEM ou au codage. De plus, le dernier modèle o1 améliore l’efficacité avec une fenêtre de contexte plus large, des capacités multimodales et une utilisation optimisée des tokens de raisonnement.
Cependant, malgré ses points forts, l’adoption du modèle o1 plutôt que de ses alternatives dépend encore totalement des exigences spécifiques du cas d’utilisation. Le modèle o1 surpasse GPT-4o dans les tâches de raisonnement complexes, mais en termes de coût, de latence et de maturité de l’API, GPT-4o est préférable. Comparé à o3-mini, o1 offre des connaissances générales plus étendues, tandis que o3-mini est plus efficace pour les applications STEM avec un coût et une latence plus faibles. Face à DeepSeek R1 et Claude 3.5 Sonnet, o1 et R1 excellent en raisonnement, mais la nature open source de R1 et son architecture Mixture-of-Expert améliorent la latence, bien qu’il nécessite une infrastructure coûteuse.
Tutoriels utilisant OpenAI GPT-o1
Chatbot RAG avec LangChain, Milvus, OpenAI GPT-o1 et OpenAI text-embedding-3-small
Chatbot RAG avec LangChain, Milvus, OpenAI GPT-o1 et NVIDIA embed-qa-4
Chatbot RAG avec LangChain, Milvus, OpenAI GPT-o1 et Cohere embed-multilingual-v3.0
Chatbot RAG avec LangChain, Milvus, OpenAI GPT-o1 et Ollama mxbai-embed-large
Chatbot RAG avec LangChain, Milvus, OpenAI GPT-o1 et HuggingFace all-MiniLM-L12-v1
Continuer à lire
Data Deduplication at Trillion Scale: How to Solve the Biggest Bottleneck of LLM Training
Explore how MinHash LSH and Milvus handle data deduplication at the trillion-scale level, solving key bottlenecks in LLM training for improved AI model performance.
Zilliz Cloud Enterprise Vector Search Powers High-Performance AI on AWS
Zilliz Cloud on AWS powers secure, scalable, ultra-fast vector search for enterprise AI apps, with BYOC, sub-10ms latency, and zero-DevOps simplicity.
Vector Databases vs. Time Series Databases
Use a vector database for similarity search and semantic relationships; use a time series database for tracking value changes over time.