OpenAI o1: O que os desenvolvedores precisam saber
Em setembro de 2024, a OpenAI apresentou a série mais recente de seus Modelos de Linguagem de Grande Escala (LLMs) proprietários, chamada série o1. O principal recurso que diferencia a série o1 do modelo anterior mais poderoso da OpenAI, o GPT-4o, é sua capacidade de refletir sobre problemas antes de gerar uma resposta final para o usuário. Isso significa que os modelos o1 são treinados para decompor problemas em componentes menores e resolvê-los de maneira passo a passo, um processo comumente chamado de raciocínio em cadeia de pensamento.
Neste artigo, falaremos sobre a série o1 a partir da perspectiva de um desenvolvedor, explorando como esses modelos podem ser implementados para casos de uso sofisticados. Antes disso, vamos examinar brevemente o que são os modelos o1, como eles se comparam ao GPT-4o em termos de desempenho e os novos recursos que a OpenAI introduziu com esta série.
Breve introdução aos modelos o1
A OpenAI introduziu três variantes na série o1: o1-preview, o1 e o1-mini, sendo o o1-preview o primeiro a ser lançado. Todas as três variantes compartilham um recurso único em comparação com outros modelos da OpenAI, como o GPT-4: capacidades avançadas de raciocínio.
Os modelos o1 são projetados para passar mais tempo analisando um problema antes de gerar uma resposta. Essa abordagem imita a forma como os humanos dissecam e resolvem questões complexas. Para qualquer problema dado, esses modelos tentam decompor a pergunta, articular seu processo de pensamento passo a passo e explorar soluções alternativas se seu raciocínio inicial for inadequado.
Como esses modelos são totalmente de código fechado, detalhes explícitos sobre seu processo de treinamento permanecem indisponíveis. No entanto, há duas abordagens prováveis usadas durante o treinamento dos modelos o1: prompting de cadeia de pensamento (CoT) e aprendizado por reforço (RL).
O conceito por trás do prompting CoT é simples. Em vez de dar ao modelo as respostas diretas para problemas dados, os prompts CoT incluem etapas contextuais detalhadas para resolver os problemas, como você pode ver abaixo:
Comparação entre prompt normal e prompt CoT.
Ao combinar uma enorme quantidade de dados de prompting CoT com RL durante o ajuste fino, o modelo refina iterativamente seu processo de raciocínio. Ele aprende a identificar falhas em sua lógica e a adotar abordagens mais sensatas para a resolução de problemas. O modelo é então recompensado por gerar etapas de raciocínio precisas e respostas corretas. Como resultado, os modelos da série o1 conseguem pensar criticamente e raciocinar de forma eficaz antes de fornecer respostas.
Para implementar essa capacidade de raciocínio, a OpenAI introduziu tokens adicionais chamados "tokens de raciocínio" nos modelos o1. Diferentemente de outros LLMs que usam apenas tokens de entrada e saída, os modelos o1 utilizam tokens de raciocínio para facilitar seu processo de pensamento.
Esses tokens de raciocínio permitem que o modelo analise prompts e considere múltiplas abordagens antes de gerar tokens de saída. Uma vez que uma resposta é finalizada, os tokens de raciocínio são descartados do contexto. Abaixo está uma visualização da dinâmica dos tokens de entrada, saída e raciocínio durante várias rodadas de interações usuário-modelo:
A dinâmica dos tokens de entrada, saída e raciocínio durante várias rodadas de interação usuário-modelo. Fonte.
O que torna o o1 único (e por que isso importa para os desenvolvedores)
Em essência, os modelos o1 se baseiam em tudo o que torna o GPT-4o excelente, mas ampliam ainda mais os limites ao combinar abordagens de cadeia de pensamento (CoT) e aprendizado por reforço (RL). Como resultado, os modelos o1 superam o GPT-4o em vários domínios que exigem raciocínio complexo, como programação, matemática e ciências gerais.
Conforme ilustrado na visualização abaixo, tanto o modelo o1-preview quanto o o1 superam o GPT-4o em benchmarks que exigem raciocínio avançado. Especificamente, eles apresentam desempenho significativamente melhor em três benchmarks principais de raciocínio científico: AIME 2024, Codeforces e GPQA Diamond.
AIME 2024: Um benchmark baseado em exames de matemática projetados para testar os estudantes de ensino médio mais brilhantes em matemática nos EUA.
GPQA Diamond: Mede a expertise em disciplinas científicas como química, biologia e física.
Codeforces: Inclui desafios de competições de programação competitiva.
Comparação entre GPT-4o, o1-preview e o modelo o1 em vários benchmarks de raciocínio. Fonte.
Embora o modelo o1-preview demonstre desempenho superior em tarefas de raciocínio complexo em comparação com o GPT-4o, ele tem desvantagens notáveis:
Alto Uso de Tokens de Raciocínio: O o1-preview gera um grande número de tokens de raciocínio, que consomem uma porção significativa da janela de contexto de 128.000 tokens do modelo. Para tarefas que exigem tokens extensos de entrada e saída, as respostas podem ser truncadas. Isso também aumenta os custos de uso em comparação com o GPT-4o.
Problemas de Latência: O alto número de tokens contribui para tempos de resposta mais lentos. Em média, a latência do o1-preview é aproximadamente 10 vezes mais lenta que a do GPT-4o, tornando-o menos ideal para uso em produção.
Para lidar com essas limitações, a OpenAI introduziu dois modelos adicionais na série o1: o1-mini e o modelo o1 mais recente.
O o1-mini é um modelo menor em comparação com o o1-preview e é especificamente otimizado para dados relacionados a STEM. Essa otimização permite que ele supere o o1-preview em benchmarks científicos como AIME 2024 (alcançando 70% de precisão em comparação com os 44,6% do o1-preview) e Codeforces.
Comparação entre GPT-4o, o1-preview e o modelo o1-mini em benchmarks do Codeforces. Fonte.
Além disso, por ser menor que o o1-preview, o o1-mini apresenta latência mais rápida. O tempo de inferência para esse modelo é aproximadamente 3–5 vezes mais rápido que o do o1-preview. No entanto, é importante observar que o desempenho do o1-mini ainda é pior que o do o1-preview em benchmarks não relacionados a STEM.
Para aprimorar ainda mais o desempenho e as capacidades, a OpenAI introduziu a versão mais recente do modelo o1. Como mostrado na visualização acima, esse modelo supera o o1-preview em todos os benchmarks científicos.
Além de um desempenho mais forte em tarefas de raciocínio complexo, o modelo o1 mais recente também oferece várias melhorias importantes:
Janela de Contexto Maior: Suporta até 200.000 tokens para entrada e um máximo de 100.000 tokens de saída.
Uso Eficiente de Tokens de Raciocínio: Usa, em média, cerca de 60% menos tokens de raciocínio que o o1-preview para qualquer solicitação. Isso torna a latência dos modelos o1 mais recentes melhor que a do o1 preview.
Capacidades de Visão: Aceita imagens como entradas, permitindo raciocínio sobre dados visuais. Observe que esse recurso não está disponível nos modelos o1-preview nem o1-mini.
Integração Aprimorada com Ferramentas da OpenAI: Inclui funcionalidade para saídas estruturadas, chamada de funções e estilos ou tons definidos pelo desenvolvedor. Além disso, os usuários podem ajustar o esforço de raciocínio (baixo, médio ou alto) usando o parâmetro
reasoning_effortpara equilibrar velocidade, custo e qualidade.
Casos de Uso Reais dos Modelos o1
Há muitos casos de uso reais que podemos resolver usando a série o1. Nesta seção, apresentaremos vários exemplos, como raciocínio de problemas complexos, extração de informações e dedução a partir de textos, Geração Aumentada por Recuperação (RAG), compreensão de imagens e chamada de funções.
No entanto, no momento em que este artigo foi escrito, a disponibilidade do modelo o1 mais recente ainda é limitada, pois ele está disponível apenas para determinados níveis de usuários. Portanto, demonstraremos os trechos de código para os casos de uso usando o modelo o1-mini sempre que possível, já que esse modelo é acessível à maioria dos níveis de usuários (Tier 1 a 5).
Antes de prosseguirmos para os exemplos, precisamos definir nossa chave da API da OpenAI primeiro. Você pode saber mais sobre como configurar sua própria chave da API aqui. Em seguida, coloque a chave da API como parte do ambiente da seguinte forma:
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 agora estamos prontos para usar os modelos da OpenAI.
Raciocínio de Problemas Complexos
A aplicação mais direta do modelo o1 é resolver problemas complexos de matemática e programação que exigem reflexão aprofundada antes de chegarmos a uma resposta. Digamos que queremos que ele nos ensine como resolver um problema de matemática; podemos fazer isso chamando a API da OpenAI da seguinte forma:
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.
"""
Como você pode ver, em vez de apenas fornecer a resposta final, o modelo gera seu processo de pensamento passo a passo, o que aprimora nossa compreensão de como abordar problemas semelhantes no futuro.
Automações Criativas
Assim como outros LLMs da OpenAI, o modelo o1 pode ser usado para automação criativa, como resumir o conteúdo de um PDF, gerar um roteiro para YouTube a partir de um artigo e extrair e deduzir informações específicas de documentos.
No exemplo a seguir, usaremos o modelo o1-mini para extrair informações específicas de um texto com um esquema de saída específico. Não apenas extrairemos informações contidas no texto, mas também pediremos ao modelo que deduza informações realizando operações matemáticas simples.
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}.
- Retorne o resultado em ordem do maior para o menor e mostre-me os 5 principais. Retorne apenas como um JSON com o seguinte formato: {json_format}"
"""
}
]
)
print(o1_response.choices[0].message.content)
"""
Saída:
```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"
}
]
}
"""
Como você pode ver, o modelo o1 não apenas extrai as informações de acordo com o esquema de saída que definimos, mas também é capaz de realizar operações matemáticas e incluir o resultado apropriado no esquema de saída junto com outras informações extraídas.
Mecanismos de busca com tecnologia de IA
Também podemos usar o modelo o1 em um cenário de Retrieval Augmented Generation (RAG), no qual o usamos para gerar uma resposta a uma consulta com base no contexto fornecido obtido por meio de busca por similaridade.
O fluxo de trabalho usual de uma aplicação RAG é o seguinte: dada uma consulta do usuário, a consulta é transformada em um embedding usando um modelo de embedding de nossa escolha, como text-embedding-3-large da OpenAI. Em seguida, o embedding da consulta é comparado com uma coleção de embeddings de contexto armazenados dentro de um banco de dados vetorial por meio de busca por similaridade. Os top-k contextos mais relevantes são então recuperados e adicionados ao prompt, fornecendo ao nosso LLM um contexto útil para responder à consulta.
Fluxo de trabalho RAG.
Como você pode ver, para usar o modelo o1 em um caso de uso RAG, normalmente o combinamos com bancos de dados vetoriais, como Milvus, para armazenar grandes quantidades de contexto e realizar buscas por similaridade eficientes e rápidas.
No exemplo abaixo, criaremos uma aplicação RAG simples usando a combinação do modelo o1-mini e Milvus.
Primeiro, carregamos a fonte de texto a partir de HTML, que usaremos como possíveis contextos em nossa aplicação RAG. Em seguida, dividimos o texto original em chunks, cada um consistindo em aproximadamente 2000 caracteres. Após o processo de chunking, podemos armazenar todos os chunks dentro do banco de dados vetorial Milvus. Definiremos o tipo de indexação como "FLAT", pois queremos conduzir uma busca exaustiva para encontrar os melhores contextos possíveis para qualquer consulta dada.
!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
)
Agora podemos definir o modelo e o prompt, que contém instruções como "Use the provided context to answer the query," bem como a própria consulta. Buscaremos o top-1 contexto mais relevante como resultado.
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)
Por fim, podemos orquestrar facilmente o fluxo de trabalho de RAG com LangChain e então obter a resposta do nosso modelo o1-mini para qualquer consulta dada usando o contexto mais relevante recuperado do nosso banco de dados Milvus.
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.
"""
Compreensão de Imagens
Uma das principais vantagens do modelo o1 mais recente em comparação com o o1-preview e o o1-mini é sua capacidade multimodal — ele aceita não apenas texto como entrada, mas também imagens. Isso torna o modelo o1 ideal para casos de uso de raciocínio com imagens, como descrever o conteúdo de uma imagem, resumir texto em uma imagem e extrair informações estruturadas de uma imagem.
Há duas maneiras de fornecer ao modelo uma entrada de imagem: passando o link para a imagem ou passando a imagem codificada em Base64. Abaixo está o código de exemplo para fazer isso:
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])
Chamada de Função
Outro caso de uso empolgante que podemos explorar com o modelo o1 é a chamada de função. Em essência, a chamada de função permite que o LLM interaja com nosso código ou com serviços externos, como um mecanismo de busca ou uma API. Com sua capacidade de refletir sobre um problema, ele consegue usar com precisão os serviços externos apropriados para ajudá-lo a resolver a tarefa em questão.
Como exemplo, digamos que queremos saber o clima atual em Los Angeles. Sem serviços externos, seria impossível para o LLM nos dar a resposta correta, e é provável que ele comece a alucinar. Se tivermos acesso à API de clima, podemos usar esta "ferramenta" como um recurso adicional para ajudar nosso modelo o1 a responder à nossa consulta.
Você pode aprender mais sobre a implementação em código da chamada de função para criar um modelo agêntico nas documentações fornecidas pela OpenAI ou pela LangChain.
Comparação Entre o Modelo o1 e suas Alternativas
Nesta seção, compararemos os prós e contras do modelo o1 com suas alternativas, como GPT 4o, o3-mini, Claude 3.5 Sonnet e DeepSeek R1.
Comparação com GPT 4o
Embora o desempenho do modelo o1 seja muito superior ao do modelo GPT-4o em benchmarks de raciocínio complexo, isso não significa que devemos sempre escolher o modelo o1 em vez do GPT-4o.
No geral, o modelo o1 se destaca em tarefas que exigem processos de pensamento complexos e detalhados, como tarefas de ideação. Por exemplo, podemos usar o modelo o1 como parceiro para nos ajudar a planejar estratégias e delinear os melhores e piores cenários para um negócio que estamos prestes a iniciar. No campo educacional, podemos usar o modelo o1 para gerar explicações detalhadas para cada componente de um curso científico que estamos desenvolvendo. Também podemos utilizar o modelo o1 como nosso parceiro durante revisões de código ou para otimização de código.
No entanto, quando queremos implantar um assistente de IA em produção, o GPT-4o atualmente ainda é preferido em relação ao modelo o1. Isso ocorre porque o GPT-4o é muito mais maduro em termos de implementação da API da OpenAI em comparação com o modelo o1. Por exemplo, embora tanto o GPT-4o quanto o modelo o1 aceitem imagens como entradas, o modelo o1 não tem acesso a várias ferramentas e recursos, como instruções personalizadas, uploads de arquivos (exceto imagens), recursos de voz e navegação na web. Portanto, se nosso caso de uso exigir esses recursos, precisamos usar o GPT-4o.
Além disso, a disponibilidade do modelo o1 é limitada no momento. Apenas determinados usuários têm acesso ao modelo, pois devemos ser pelo menos um usuário Tier 3 ou assinar o plano ChatGPT Plus ou Pro para conseguir acessar este modelo. Além disso, se a latência de inferência for muito crítica em nosso caso de uso, o GPT-4o ainda oferece uma alternativa melhor do que o modelo o1.
Comparação com o3-mini
O modelo o3-mini é o modelo mais recente entre os LLMs de raciocínio da OpenAI. Assim como o o1-mini, o o3-mini foi altamente otimizado nos domínios STEM, mas com desempenho superior ao o1-mini e comparável ao modelo o1, como você pode ver no gráfico de desempenho em diferentes benchmarks STEM mostrado abaixo:
Comparação de desempenho entre o3-mini e o modelo o1 em diferentes benchmarks STEM. Fonte.
O o3-mini mantém tudo o que torna o o1-mini excelente (baixo custo e latência) e ainda o aprimora. Portanto, se seu caso de uso estiver dentro do domínio STEM e a latência ou o custo forem críticos, então o modelo o3 seria mais preferível do que o modelo o1. No entanto, o modelo o1 ainda oferece conhecimento mais amplo do que o o3-mini, o que o torna mais adequado para uso se seu caso de uso for mais geral e não estiver no domínio STEM.
Tanto o o3-mini quanto o modelo o1 oferecem suporte a recursos avançados de API, como chamada de funções, saída estruturada, mensagens de desenvolvedor, bem como esforço de raciocínio ajustável. No entanto, o o3-mini atualmente oferece suporte apenas a entrada de texto, o que significa que, se a entrada do nosso caso de uso for uma imagem, então precisamos usar o modelo o1.
Quanto à disponibilidade por meio da API, no momento, tanto os modelos o3-mini quanto o1 estão disponíveis apenas para usuários nos Tiers 3-5. Você pode usar ambos os modelos se estiver inscrito no ChatGPT Plus, Pro e Team.
Comparação com DeepSeek R1 e Claude 3.5 Sonnet
Outras alternativas ao modelo o1 incluem Claude 3.5 Sonnet e DeepSeek R1. Desses dois, o DeepSeek R1 é um concorrente mais próximo do o1 devido à sua otimização de raciocínio durante o treinamento, enquanto o Claude 3.5 Sonnet não foi realmente otimizado para raciocínio. Como você pode ver em vários benchmarks de raciocínio abaixo, tanto o o1 quanto o R1 superam o 3.5 Sonnet por uma margem considerável. Enquanto isso, o desempenho do o1 e do R1 é comparável entre si.
Comparação entre o modelo o1 e outros modelos representativos. Fonte.
Portanto, recomenda-se usar o o1 ou o R1 quando seu caso de uso precisar de capacidade de raciocínio do LLM. Caso contrário, o Claude 3.5 Sonnet seria preferível, pois resultaria em custo mais baixo e melhor latência do que o modelo o1.
Agora, digamos que nosso caso de uso exija a capacidade de raciocínio dos nossos LLMs, o que significa que podemos usar os modelos o1 ou R1. A principal vantagem do modelo R1 é sua natureza open-source, o que significa que podemos hospedá-lo em nossa própria infraestrutura. Isso é muito benéfico se a privacidade dos dados for uma preocupação em nosso caso de uso.
Em termos de latência, o R1 pode ser melhor do que o o1 devido à sua arquitetura Mixture-of-Expert (MoE). Graças ao MoE, apenas uma pequena fração dos parâmetros do R1 será ativada em qualquer solicitação, o que acelera o processo de inferência. Além disso, o R1 adota uma abordagem de previsão de múltiplos tokens durante o treinamento, que pode ser reaproveitada para decodificação especulativa durante a inferência. Isso acelera ainda mais o processo de inferência.
No entanto, é importante observar que o DeepSeek R1 contém, no total, 671B parâmetros, o que significa que você precisa de aproximadamente 1,5 TB de memória de GPU (por exemplo, NVIDIA A100 80GB x16) para hospedá-lo. Portanto, é muito caro hospedar o modelo por conta própria, e usar o modelo o1 seria mais preferível para nos poupar das etapas complicadas de hospedar o R1.Com o o1, só precisamos pagar quando fazemos a solicitação à API. Isso acaba sendo mais barato na maioria dos casos em comparação com o custo por hora de GPU que precisamos pagar ao hospedar o modelo R1 em provedores de nuvem populares como AWS ou GCP.
Conclusão
O modelo o1 representa um avanço nas capacidades de raciocínio de IA, pois melhora o GPT-4o ao integrar prompting de cadeia de pensamento e aprendizado por reforço. Com sua capacidade de decompor problemas complexos e explorar soluções alternativas, o modelo o1 se destaca em tarefas que exigem pensamento analítico profundo, como tarefas relacionadas a STEM ou programação. Além disso, o modelo o1 mais recente aumenta a eficiência com uma janela de contexto maior, recursos multimodais e uso otimizado de tokens de raciocínio.
No entanto, apesar de seus pontos fortes, adotar o modelo o1 em vez de suas alternativas ainda depende totalmente dos requisitos específicos do caso de uso. O modelo o1 supera o GPT-4o em tarefas complexas de raciocínio, mas, em termos de custo, latência e maturidade da API, o GPT-4o é mais preferível. Comparado ao o3-mini, o o1 oferece conhecimento geral mais amplo, enquanto o o3-mini é mais eficiente para aplicações STEM com menor custo e latência. Contra DeepSeek R1 e Claude 3.5 Sonnet, o o1 e o R1 se destacam em raciocínio, mas a natureza open-source do R1 e a arquitetura Mixture-of-Expert melhoram a latência, embora exija infraestrutura cara.
Tutoriais usando OpenAI GPT-o1
Chatbot RAG com LangChain, Milvus, OpenAI GPT-o1 e OpenAI text-embedding-3-small
Chatbot RAG com LangChain, Milvus, OpenAI GPT-o1 e NVIDIA embed-qa-4
Chatbot RAG com LangChain, Milvus, OpenAI GPT-o1 e Cohere embed-multilingual-v3.0
Chatbot RAG com LangChain, Milvus, OpenAI GPT-o1 e Ollama mxbai-embed-large
Chatbot RAG com LangChain, Milvus, OpenAI GPT-o1 e HuggingFace all-MiniLM-L12-v1
Continue lendo
Notion's Vector Search Is Excellent. Their Next Problem Is Harder.
Notion solved vector search scaling in two years. The next bottleneck — offline context engineering, unified data, and the real-time/offline gap — is harder.
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.
Vector Databases vs. Object-Relational Databases
Use a vector database for AI-powered similarity search; use an object-relational database for complex data modeling with both relational integrity and object-oriented features.