OpenAI o1: Was Entwickler wissen müssen
Im September 2024 stellte OpenAI die neueste Reihe ihrer proprietären Large Language Models (LLMs) vor, die o1-Serie genannt wird. Das Hauptmerkmal, das die o1-Serie von OpenAIs zuvor leistungsstärkstem Modell, GPT-4o, unterscheidet, ist ihre Fähigkeit, Probleme zu durchdenken, bevor sie eine endgültige Antwort für den Benutzer generiert. Das bedeutet, dass die o1-Modelle darauf trainiert sind, Probleme in kleinere Komponenten zu zerlegen und sie Schritt für Schritt zu lösen, ein Prozess, der allgemein als Chain-of-Thought-Reasoning bezeichnet wird.
In diesem Artikel werden wir aus der Perspektive eines Entwicklers über die o1-Serie sprechen und untersuchen, wie diese Modelle für anspruchsvolle Anwendungsfälle implementiert werden können. Zuvor wollen wir kurz betrachten, was die o1-Modelle sind, wie sie im Vergleich zu GPT-4o abschneiden und welche neuen Funktionen OpenAI mit dieser Serie eingeführt hat.
Kurze Einführung in o1-Modelle
OpenAI hat drei Varianten in der o1-Serie eingeführt: o1-preview, o1 und o1-mini, wobei o1-preview als erste gestartet wurde. Alle drei Varianten teilen im Vergleich zu anderen OpenAI-Modellen wie GPT-4 ein einzigartiges Merkmal: fortgeschrittene Reasoning-Fähigkeiten.
Die o1-Modelle sind darauf ausgelegt, mehr Zeit mit der Analyse eines Problems zu verbringen, bevor sie eine Antwort generieren. Dieser Ansatz imitiert, wie Menschen komplexe Probleme zerlegen und lösen. Bei jedem gegebenen Problem versuchen diese Modelle, die Frage aufzuschlüsseln, ihren Denkprozess Schritt für Schritt zu artikulieren und alternative Lösungen zu erkunden, falls ihre anfängliche Argumentation unzureichend ist.
Da diese Modelle vollständig Closed-Source sind, sind ausdrückliche Details über ihren Trainingsprozess nicht verfügbar. Es gibt jedoch zwei wahrscheinliche Ansätze, die während des Trainings von o1-Modellen verwendet wurden: Chain-of-Thought (CoT) Prompting und Reinforcement Learning (RL).
Das Konzept hinter CoT Prompting ist unkompliziert. Anstatt dem Modell die direkten Antworten für gegebene Probleme zu geben, enthalten CoT Prompts detaillierte kontextbezogene Schritte zur Lösung der Probleme, wie Sie unten sehen können:
Vergleich zwischen normalem Prompt und CoT Prompt.
Durch die Kombination einer riesigen Menge an CoT-Prompting-Daten mit RL während des Fine-Tunings verfeinert das Modell seinen Reasoning-Prozess iterativ. Es lernt, Fehler in seiner Logik zu erkennen und sinnvollere Ansätze zur Problemlösung zu übernehmen. Das Modell wird dann dafür belohnt, genaue Reasoning-Schritte und korrekte Antworten zu generieren. Infolgedessen können die Modelle der o1-Serie kritisch denken und effektiv schlussfolgern, bevor sie Antworten liefern.
Um diese Reasoning-Fähigkeit zu implementieren, führte OpenAI zusätzliche Tokens namens "reasoning tokens" in den o1-Modellen ein. Im Gegensatz zu anderen LLMs, die nur Eingabe- und Ausgabe-Tokens verwenden, nutzen o1-Modelle Reasoning-Tokens, um ihren Denkprozess zu unterstützen.
Diese Reasoning-Tokens ermöglichen es dem Modell, Prompts zu analysieren und mehrere Ansätze zu berücksichtigen, bevor es Ausgabe-Tokens generiert. Sobald eine Antwort finalisiert ist, werden die Reasoning-Tokens aus dem Kontext verworfen. Unten sehen Sie eine Visualisierung der Dynamik von Eingabe-, Ausgabe- und Reasoning-Tokens während mehrerer Runden von Benutzer-Modell-Interaktionen:
Die Dynamik von Eingabe-, Ausgabe- und Reasoning-Tokens während mehrerer Runden der Benutzer-Modell-Interaktion. Quelle.
Was o1 einzigartig macht (und warum es für Entwickler wichtig ist)
Im Wesentlichen bauen die o1-Modelle auf allem auf, was GPT-4o großartig macht, verschieben die Grenzen jedoch weiter, indem sie Chain-of-Thought (CoT)- und Reinforcement-Learning (RL)-Ansätze kombinieren. Infolgedessen übertreffen die o1-Modelle GPT-4o in verschiedenen Bereichen, die komplexes Reasoning erfordern, wie Programmierung, Mathematik und allgemeine Wissenschaft.
Wie in der Visualisierung unten dargestellt, übertreffen sowohl das o1-preview- als auch das o1-Modell GPT-4o in Benchmarks, die fortgeschrittenes Schlussfolgern erfordern. Konkret schneiden sie bei drei wichtigen Benchmarks für wissenschaftliches Schlussfolgern deutlich besser ab: AIME 2024, Codeforces und GPQA Diamond.
AIME 2024: Ein Benchmark, der auf Mathematikprüfungen basiert, die darauf ausgelegt sind, die begabtesten Highschool-Schüler in Mathematik in den USA zu testen.
GPQA Diamond: Misst Fachwissen in naturwissenschaftlichen Fächern wie Chemie, Biologie und Physik.
Codeforces: Umfasst Aufgaben aus Wettbewerben im kompetitiven Programmieren.
Vergleich zwischen GPT-4o, o1-preview und dem o1-Modell bei mehreren Reasoning-Benchmarks. Quelle.
Während das o1-preview-Modell bei komplexen Reasoning-Aufgaben im Vergleich zu GPT-4o eine überlegene Leistung zeigt, hat es bemerkenswerte Nachteile:
Hohe Nutzung von Reasoning-Tokens: o1-preview erzeugt eine große Anzahl von Reasoning-Tokens, die einen erheblichen Teil des 128.000-Token-Kontextfensters des Modells verbrauchen. Bei Aufgaben, die umfangreiche Input-Output-Tokens erfordern, können Antworten abgeschnitten werden. Dies erhöht außerdem die Nutzungskosten im Vergleich zu GPT-4o.
Latenzprobleme: Die hohe Anzahl an Tokens trägt zu langsameren Antwortzeiten bei. Im Durchschnitt ist die Latenz von o1-preview etwa 10-mal langsamer als GPT-4o, wodurch es weniger ideal für den Produktionseinsatz ist.
Um diese Einschränkungen zu adressieren, führte OpenAI zwei weitere Modelle in der o1-Serie ein: o1-mini und das neueste o1-Modell.
o1-mini ist im Vergleich zu o1-preview ein kleineres Modell und speziell für STEM-bezogene Daten optimiert. Diese Optimierung ermöglicht es ihm, o1-preview bei wissenschaftlichen Benchmarks wie AIME 2024 (mit einer Genauigkeit von 70 % im Vergleich zu 44,6 % bei o1-preview) und Codeforces zu übertreffen.
Vergleich zwischen GPT-4o, o1-preview und dem o1-mini-Modell bei Codeforces-Benchmarks. Quelle.
Zusätzlich führt die geringere Größe im Vergleich zu o1-preview bei o1-mini zu schnellerer Latenz. Die Inferenzzeit für dieses Modell ist ungefähr 3–5-mal schneller als die von o1-preview. Es ist jedoch wichtig zu beachten, dass die Leistung von o1-mini bei Nicht-STEM-Benchmarks weiterhin schlechter ist als die von o1-preview.
Um Leistung und Fähigkeiten weiter zu verbessern, führte OpenAI die neueste Version des o1-Modells ein. Wie in der obigen Visualisierung gezeigt, übertrifft dieses Modell o1-preview in allen wissenschaftlichen Benchmarks.
Neben einer stärkeren Leistung bei komplexen Reasoning-Aufgaben bietet das neueste o1-Modell auch mehrere wichtige Verbesserungen:
Größeres Kontextfenster: Unterstützt bis zu 200.000 Tokens für die Eingabe und maximal 100.000 Output-Tokens.
Effiziente Nutzung von Reasoning-Tokens: Verwendet im Durchschnitt etwa 60 % weniger Reasoning-Tokens als o1-preview für eine beliebige Anfrage. Dadurch ist die Latenz der neuesten o1-Modelle besser als bei o1-preview.
Vision-Fähigkeiten: Akzeptiert Bilder als Eingaben und ermöglicht Schlussfolgerungen über visuelle Daten. Beachten Sie, dass diese Funktion weder in o1-preview- noch in o1-mini-Modellen verfügbar ist.
Erweiterte Integration mit OpenAI-Tools: Umfasst Funktionalität für strukturierte Ausgaben, Function Calling und von Entwicklern definierte Stile oder Tonalitäten. Zusätzlich können Nutzer den Reasoning-Aufwand (niedrig, mittel oder hoch) mithilfe des Parameters
reasoning_effortanpassen, um Geschwindigkeit, Kosten und Qualität auszubalancieren.
Praxisnahe Anwendungsfälle von o1-Modellen
Es gibt viele praxisnahe Anwendungsfälle, die wir mithilfe der o1-Serie lösen können. In diesem Abschnitt führen wir Sie durch mehrere Beispiele, etwa komplexes Problem-Reasoning, Informationsextraktion und Ableitung aus Texten, Retrieval Augmented Generation (RAG), Bildverständnis und Function Calling.
Zum Zeitpunkt der Erstellung dieses Artikels ist die Verfügbarkeit des neuesten o1-Modells jedoch noch eingeschränkt, da es nur für bestimmte Nutzerstufen verfügbar ist. Daher demonstrieren wir die Code-Snippets für die Anwendungsfälle, wann immer möglich, mit dem o1-mini-Modell, da dieses Modell für die meisten Nutzerstufen zugänglich ist (Tier 1 bis 5).
Bevor wir mit den Beispielen fortfahren, müssen wir zuerst unseren OpenAI-API-Schlüssel festlegen. Mehr darüber, wie du deinen eigenen API-Schlüssel einrichtest, erfährst du hier. Anschließend fügst du den API-Schlüssel wie folgt als Teil der Umgebung ein:
import getpass
import os
if not os.environ.get("OPENAI_API_KEY"):
os.environ["OPENAI_API_KEY"] = getpass.getpass("Enter API key for OpenAI: ")
Und nun sind wir bereit, die Modelle von OpenAI zu verwenden.
Komplexes Problemlösen
Die naheliegendste Anwendung des o1-Modells besteht darin, komplexe Probleme in Mathematik und Programmierung zu lösen, die gründliches Nachdenken erfordern, bevor wir zu einer Antwort gelangen können. Nehmen wir an, wir möchten, dass es uns beibringt, wie man eine mathematische Aufgabe löst; das können wir tun, indem wir die OpenAI-API wie folgt aufrufen:
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.
"""
Wie du sehen kannst, liefert das Modell nicht nur die endgültige Antwort, sondern generiert seinen schrittweisen Denkprozess, was unser Verständnis dafür verbessert, wie wir ähnliche Probleme in Zukunft angehen können.
Kreative Automatisierungen
Wie andere LLMs von OpenAI kann das o1-Modell für kreative Automatisierung verwendet werden, z. B. zum Zusammenfassen des Inhalts einer PDF-Datei, zum Generieren eines YouTube-Skripts aus einem Artikel sowie zum Extrahieren und Ableiten bestimmter Informationen aus Dokumenten.
Im folgenden Beispiel verwenden wir das o1-mini-Modell, um bestimmte Informationen aus einem Text mit einem spezifischen Ausgabeschema zu extrahieren. Wir werden nicht nur Informationen extrahieren, die im Text enthalten sind, sondern das Modell auch bitten, Informationen durch einfache mathematische Operationen abzuleiten.
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}.
- Gib das Ergebnis in absteigender Reihenfolge vom höchsten zum niedrigsten zurück und zeige mir die Top 5. Gib es nur als JSON im folgenden Format zurück: {json_format}"
"""
}
]
)
print(o1_response.choices[0].message.content)
"""
Ausgabe:
```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"
}
]
}
"""
Wie du sehen kannst, extrahiert das o1-Modell nicht nur die Informationen gemäß dem von uns definierten Ausgabeschema, sondern ist auch in der Lage, mathematische Operationen durchzuführen und das entsprechende Ergebnis zusammen mit anderen extrahierten Informationen in das Ausgabeschema aufzunehmen.
KI-gestützte Suchmaschinen
Wir können das o1-Modell auch in einem Retrieval Augmented Generation-Setting (RAG) verwenden, in dem wir es nutzen, um eine Antwort auf eine Anfrage basierend auf bereitgestelltem Kontext zu generieren, der über Ähnlichkeitssuche erhalten wurde.
Der übliche Workflow einer RAG-Anwendung ist wie folgt: Ausgehend von einer Nutzeranfrage wird die Anfrage mithilfe eines Embedding-Modells unserer Wahl, wie z. B. text-embedding-3-large von OpenAI, in ein Embedding umgewandelt. Anschließend wird das Anfrage-Embedding per Ähnlichkeitssuche mit einer Sammlung von Kontext-Embeddings verglichen, die in einer Vektordatenbank gespeichert sind. Die top-k relevantesten Kontexte werden dann abgerufen und dem Prompt hinzugefügt, wodurch unser LLM hilfreichen Kontext erhält, um die Anfrage zu beantworten.
RAG-Workflow.
Wie du sehen kannst, kombinieren wir das o1-Modell für einen RAG-Anwendungsfall typischerweise mit Vektordatenbanken wie Milvus, um riesige Mengen an Kontext zu speichern und effiziente sowie schnelle Ähnlichkeitssuchen durchzuführen.
Im folgenden Beispiel erstellen wir eine einfache RAG-Anwendung mit der Kombination aus dem o1-mini-Modell und Milvus.
Zuerst laden wir die Textquelle aus HTML, die wir als mögliche Kontexte in unserer RAG-Anwendung verwenden werden. Anschließend teilen wir den ursprünglichen Text in Chunks auf, die jeweils aus etwa 2000 Zeichen bestehen. Nach dem Chunking-Prozess können wir alle Chunks in der Milvus-Vektordatenbank speichern. Wir setzen den Indextyp auf "FLAT", da wir eine exhaustive Suche durchführen möchten, um die bestmöglichen Kontexte für jede gegebene Anfrage zu finden.
!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)
# Split the documents into chunks using the text_splitter
docs = text_splitter.split_documents(documents)
# Define the default embedding model from OpenAI
embeddings = OpenAIEmbeddings()
# Store the chunked data into 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, # Drop the old Milvus collection if it exists
)
Jetzt können wir das Modell und den Prompt definieren, der Anweisungen wie „Use the provided context to answer the query“ sowie die Abfrage selbst enthält. Als Ergebnis rufen wir den Top-1-relevantesten Kontext ab.
from langchain_openai import ChatOpenAI
from langchain import hub
# Initialize the OpenAI language model for response generation
llm = ChatOpenAI(model_name="o1-mini", temperature=1)
# Define the prompt template for generating AI responses
prompt = hub.pull("rlm/rag-prompt")
# Convert the vector store to a retriever
retriever = vectorstore.as_retriever()
query = "What is self-reflection of an AI Agent?"
vectorstore.similarity_search(query, k=1)
Schließlich können wir den RAG-Workflow einfach mit LangChain orchestrieren und dann mithilfe des relevantesten Kontexts, der aus unserer Milvus-Datenbank abgerufen wurde, die Antwort von unserem o1-mini-Modell auf eine beliebige Anfrage erhalten.
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
# Define a function to format the retrieved documents
def format_docs(docs):
return "nn".join(doc.page_content for doc in docs)
# Define the RAG (Retrieval-Augmented Generation) chain for AI response generation
rag_chain = (
{"context": retriever | format_docs, "question": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
# rag_chain.get_graph().print_ascii()
# Invoke the RAG chain with a specific question and retrieve the response
res = rag_chain.invoke(query)
print(res)
"""
Output:
Self-reflection in an AI agent refers to its ability to evaluate and refine its own actions and decisions based on past experiences. This process allows the agent to identify and correct mistakes, thereby improving its performance over time. It is essential for handling complex, real-world tasks where iterative improvement through trial and error is necessary.
"""
Bildverständnis
Einer der Hauptvorteile des neuesten o1-Modells im Vergleich zu o1-preview und o1-mini ist seine multimodale Fähigkeit – es akzeptiert nicht nur Text als Eingabe, sondern auch Bilder. Dadurch ist das o1-Modell ideal für Anwendungsfälle des Bild-Reasonings, wie das Beschreiben des Inhalts eines Bildes, das Zusammenfassen von Text in einem Bild und das Extrahieren strukturierter Informationen aus einem Bild.
Es gibt zwei Möglichkeiten, dem Modell ein Bild als Eingabe bereitzustellen: durch Übergabe des Links zum Bild oder durch Übergabe des Base64-codierten Bildes. Unten befindet sich der Beispielcode dafür:
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])
Funktionsaufruf
Ein weiterer spannender Anwendungsfall, den wir mit dem o1-Modell erkunden können, ist Function Calling. Im Wesentlichen ermöglicht Function Calling dem LLM, mit unserem Code oder externen Diensten zu interagieren, beispielsweise mit einer Suchmaschine oder einer API. Mit seiner Fähigkeit, ein Problem gedanklich zu durchdringen, kann es die passenden externen Dienste präzise nutzen, um die vorliegende Aufgabe zu lösen.
Nehmen wir als Beispiel an, wir möchten das aktuelle Wetter in Los Angeles wissen. Ohne externe Dienste wäre es für das LLM unmöglich, uns die richtige Antwort zu geben, und es würde wahrscheinlich anfangen zu halluzinieren. Wenn wir Zugriff auf die Wetter-API haben, können wir dieses "Tool" als zusätzliche Ressource verwenden, um unserem o1-Modell dabei zu helfen, unsere Anfrage zu beantworten.
Mehr über die Code-Implementierung von Function Calling zur Erstellung eines agentischen Modells erfahren Sie in den Dokumentationen von OpenAI oder LangChain.
Vergleich zwischen dem o1-Modell und seinen Alternativen
In diesem Abschnitt vergleichen wir die Vor- und Nachteile des o1-Modells mit seinen Alternativen, wie GPT 4o, o3-mini, Claude 3.5 Sonnet und DeepSeek R1.
Vergleich mit GPT 4o
Obwohl die Leistung des o1-Modells bei Benchmarks für komplexes Reasoning der des GPT-4o-Modells weit überlegen ist, bedeutet das nicht, dass wir immer das o1-Modell gegenüber GPT-4o wählen sollten.
Insgesamt eignet sich das o1-Modell besonders für Aufgaben, die komplexe und detaillierte Denkprozesse erfordern, wie etwa Ideationsaufgaben. Zum Beispiel können wir das o1-Modell als Partner nutzen, um Strategien zu planen und Best- und Worst-Case-Szenarien für ein Unternehmen zu skizzieren, das wir gründen möchten. Im Bildungsbereich können wir das o1-Modell verwenden, um detaillierte Erklärungen für jede Komponente eines wissenschaftlichen Kurses zu erstellen, den wir entwickeln. Wir können das o1-Modell auch als Partner bei Code-Reviews oder zur Code-Optimierung einsetzen.
Wenn wir jedoch einen KI-Assistenten in der Produktion bereitstellen möchten, wird GPT-4o derzeit immer noch gegenüber dem o1-Modell bevorzugt. Das liegt daran, dass GPT-4o im Vergleich zum o1-Modell in Bezug auf die API-Implementierung von OpenAI deutlich ausgereifter ist. Während beispielsweise sowohl GPT-4o als auch das o1-Modell Bilder als Eingaben akzeptieren, hat das o1-Modell keinen Zugriff auf mehrere Tools und Funktionen, wie etwa benutzerdefinierte Anweisungen, Datei-Uploads (außer Bilder), Sprachfunktionen und Web-Browsing. Wenn unser Anwendungsfall diese Funktionen erfordert, müssen wir daher GPT-4o verwenden.
Darüber hinaus ist die Verfügbarkeit des o1-Modells derzeit begrenzt. Nur bestimmte Nutzer haben Zugriff auf das Modell, da wir mindestens Tier-3-Nutzer sein oder den ChatGPT Plus- oder Pro-Plan abonnieren müssen, um auf dieses Modell zugreifen zu können. Wenn außerdem die Inferenzlatenz in unserem Anwendungsfall sehr kritisch ist, bietet GPT-4o weiterhin eine bessere Alternative als das o1-Modell.
Vergleich mit o3-mini
Das o3-mini-Modell ist das neueste Modell unter OpenAIs Reasoning-LLMs. Genau wie o1-mini wurde o3-mini in den MINT-Bereichen stark optimiert, jedoch mit einer Leistung, die der von o1-mini überlegen und mit dem o1-Modell vergleichbar ist, wie Sie im unten gezeigten Leistungsdiagramm über verschiedene MINT-Benchmarks hinweg sehen können:
Leistungsvergleich zwischen o3-mini und dem o1-Modell über verschiedene MINT-Benchmarks hinweg. Quelle.
o3-mini behält alles bei, was o1-mini großartig macht (niedrige Kosten und geringe Latenz), und verbessert es weiter. Wenn Ihr Anwendungsfall also im MINT-Bereich liegt und Latenz oder Kosten entscheidend sind, dann wäre das o3-Modell dem o1-Modell vorzuziehen. Allerdings bietet das o1-Modell weiterhin breiteres Wissen als o3-mini, wodurch es besser geeignet ist, wenn Ihr Anwendungsfall allgemeiner ist und nicht im MINT-Bereich liegt.
Sowohl das o3-mini- als auch das o1-Modell unterstützen fortgeschrittene API-Funktionen wie Function Calling, strukturierte Ausgabe, Developer Messages sowie einstellbaren Reasoning-Aufwand. Allerdings unterstützt o3-mini derzeit nur Texteingaben, was bedeutet, dass wir das o1-Modell verwenden müssen, wenn die Eingabe unseres Anwendungsfalls ein Bild ist.
Was die Verfügbarkeit über die API betrifft, sind derzeit sowohl o3-mini- als auch o1-Modelle nur für Nutzer in Tier 3-5 verfügbar. Sie können beide Modelle verwenden, wenn Sie ChatGPT Plus, Pro und Team abonniert haben.
Vergleich mit DeepSeek R1 und Claude 3.5 Sonnet
Weitere Alternativen zum o1-Modell sind Claude 3.5 Sonnet und DeepSeek R1. Von diesen beiden ist DeepSeek R1 aufgrund seiner Reasoning-Optimierung während des Trainings ein näherer Konkurrent zu o1, während Claude 3.5 Sonnet nicht wirklich für Reasoning optimiert wurde. Wie Sie unten an mehreren Reasoning-Benchmarks sehen können, übertreffen sowohl o1 als auch R1 3.5 Sonnet mit deutlichem Abstand. Gleichzeitig ist die Leistung von o1 und R1 miteinander vergleichbar.
Vergleich zwischen dem o1-Modell und anderen repräsentativen Modellen. Quelle.
Daher wird empfohlen, entweder o1 oder R1 zu verwenden, wenn Ihr Anwendungsfall Reasoning-Fähigkeiten vom LLM erfordert. Falls nicht, wäre Claude 3.5 Sonnet vorzuziehen, da es im Vergleich zum o1-Modell sowohl geringere Kosten als auch eine bessere Latenz bieten würde.
Nehmen wir nun an, dass unser Anwendungsfall Reasoning-Fähigkeiten von unseren LLMs erfordert, was bedeutet, dass wir entweder o1- oder R1-Modelle verwenden können. Der Hauptvorteil des R1-Modells ist seine Open-Source-Natur, was bedeutet, dass wir es in unserer eigenen Infrastruktur hosten können. Das ist sehr vorteilhaft, wenn Datenschutz in unserem Anwendungsfall ein Anliegen ist.
In Bezug auf die Latenz könnte R1 aufgrund seiner Mixture-of-Expert-(MoE)-Architektur besser sein als o1. Dank MoE wird bei jeder Anfrage nur ein kleiner Teil der Parameter von R1 aktiviert, was den Inferenzprozess beschleunigt. Außerdem verwendet R1 während des Trainings einen Multi-Token-Prediction-Ansatz, der während der Inferenz für Speculative Decoding wiederverwendet werden kann. Dies beschleunigt den Inferenzprozess zusätzlich.
Es ist jedoch wichtig zu beachten, dass DeepSeek R1 insgesamt 671B Parameter enthält, was bedeutet, dass Sie ungefähr 1,5 TB GPU-Speicher (z. B. NVIDIA A100 80GB x16) benötigen, um es zu hosten. Daher ist es sehr teuer, das Modell selbst zu hosten, und die Verwendung des o1-Modells wäre vorzuziehen, um uns die komplizierten Schritte des Hostings von R1 zu ersparen.Mit o1 müssen wir nur bezahlen, wenn wir die API-Anfrage stellen. Das ist in den meisten Fällen günstiger im Vergleich zu den stündlichen GPU-Kosten, die wir zahlen müssen, wenn wir das R1-Modell bei beliebten Cloud-Anbietern wie AWS oder GCP hosten.
Fazit
Das o1-Modell stellt einen Fortschritt bei den Reasoning-Fähigkeiten von KI dar, da es GPT-4o durch die Integration von Chain-of-Thought-Prompting und Reinforcement Learning verbessert. Mit seiner Fähigkeit, komplexe Probleme aufzuschlüsseln und alternative Lösungen zu erkunden, ist das o1-Modell hervorragend für Aufgaben geeignet, die tiefgehendes analytisches Denken erfordern, wie etwa STEM-bezogene oder Coding-Aufgaben. Außerdem verbessert das neueste o1-Modell die Effizienz durch ein größeres Kontextfenster, multimodale Fähigkeiten und optimierte Nutzung von Reasoning-Tokens.
Trotz seiner Stärken hängt die Einführung des o1-Modells gegenüber seinen Alternativen jedoch weiterhin vollständig von den spezifischen Anforderungen des Anwendungsfalls ab. Das o1-Modell übertrifft GPT-4o bei komplexen Reasoning-Aufgaben, aber in Bezug auf Kosten, Latenz und API-Reife ist GPT-4o vorzuziehen. Im Vergleich zu o3-mini bietet o1 ein breiteres Allgemeinwissen, während o3-mini für STEM-Anwendungen bei geringeren Kosten und niedrigerer Latenz effizienter ist. Gegenüber DeepSeek R1 und Claude 3.5 Sonnet zeichnen sich o1 und R1 im Reasoning aus, aber R1s Open-Source-Natur und Mixture-of-Expert-Architektur verbessern die Latenz, obwohl es kostspielige Infrastruktur erfordert.
Tutorials mit OpenAI GPT-o1
RAG-Chatbot mit LangChain, Milvus, OpenAI GPT-o1 und OpenAI text-embedding-3-small
RAG-Chatbot mit LangChain, Milvus, OpenAI GPT-o1 und NVIDIA embed-qa-4
RAG-Chatbot mit LangChain, Milvus, OpenAI GPT-o1 und Cohere embed-multilingual-v3.0
RAG-Chatbot mit LangChain, Milvus, OpenAI GPT-o1 und Ollama mxbai-embed-large
RAG-Chatbot mit LangChain, Milvus, OpenAI GPT-o1 und HuggingFace all-MiniLM-L12-v1
Weiterlesen
Zilliz Cloud Just Landed in Claude Code
The Zilliz Cloud Plugin brings the full power of Zilliz Cloud directly into your Claude Code terminal as natural-language conversations.
How to Improve Retrieval Quality for Japanese Text with Sudachi, Milvus/Zilliz, and AWS Bedrock
Learn how Sudachi normalization and Milvus/Zilliz hybrid search improve Japanese RAG accuracy with BM25 + vector fusion, AWS Bedrock embeddings, and practical code examples.
How Zilliz Saw the Future of Vector Databases—and Built for Production
An inside look at how Zilliz built vector databases for real-world use, focusing on scalability, stability, and running them reliably at scale.