Avaliação de desempenho de modelos destilados DeepSeek-R1 em GPQA usando Ollama e avaliações simples da OpenAI

A versão mais recente do modelo DeepSeek-R1 teve grande repercussão na comunidade global de IA. Ela alcançou avanços comparáveis ​​aos modelos de inferência da Meta e da OpenAI, e o fez em muito menos tempo e a um custo muito menor.

Mas, além das manchetes e do exagero online, como podemos avaliar as capacidades de inferência de um modelo usando critérios reconhecidos? Esta é uma questão importante para especialistas em IA.

A interface de usuário do Deepseek facilita a exploração de suas funcionalidades, mas o uso programático proporciona insights mais profundos e integração perfeita em aplicações do mundo real. Compreender como esses modelos são executados localmente também oferece maior controle e acesso offline.

Neste artigo, exploraremos como usar o Ollama e o simple-evals da OpenAI para avaliar as capacidades de raciocínio de modelos destilados do DeepSeek-R1 com base no popular benchmark GPQA-Diamond . Este benchmark é uma das ferramentas mais importantes para avaliar modelos de IA na área de raciocínio lógico.

Segue o link para o repositório do GitHub que acompanha este artigo.

(1) Quais são os modelos de raciocínio?

Modelos de inferência, como DeepSeek-R1 e modelos de série o da OpenAI (por exemplo, o1, o3), são modelos de linguagem grande (LLMs) treinados usando aprendizado de reforço para realizar inferência. Esses modelos são ferramentas avançadas no campo da inteligência artificial, representando o auge da evolução na capacidade das máquinas de pensar logicamente e resolver problemas complexos.

A heurística é caracterizada pelo pensamento profundo antes de responder, produzindo uma longa série de pensamentos internos antes de responder. Ele se destaca na resolução de problemas complexos, programação, raciocínio científico e planejamento de várias etapas de fluxos de trabalho de agentes. Esses recursos os tornam indispensáveis ​​em áreas como desenvolvimento avançado de software, pesquisa científica e automação de processos complexos.

(2) O que é o modelo DeepSeek-R1?

DeepSeek-R1 é um modelo de linguagem de grande porte (LLM, na sigla em inglês) de código aberto e de última geração, projetado especificamente para inferência avançada . Foi apresentado em janeiro de 2025 no artigo de pesquisa " DeepSeek-R1: Estimulando a Capacidade de Inferência em Modelos de Linguagem de Grande Porte via Aprendizado por Reforço " . DeepSeek-R1 é considerado um modelo pioneiro no campo da inteligência artificial.

Este modelo é baseado em uma arquitetura de modelo de grande linguagem (LLM) com 671 bilhões de parâmetros e foi treinado usando aprendizado por reforço extensivo (RL) com base no seguinte caminho:

• Dois estágios de aumento visam descobrir padrões de raciocínio aprimorados e alinhá-los às preferências humanas.
• Dois estágios de ajuste fino supervisionado servem como semente para as capacidades de inferência e não inferência do modelo.

Para ilustrar, o DeepSeek treinou dois modelos:

• O primeiro modelo, DeepSeek-R1-Zero, é um modelo de inferência treinado usando aprendizagem por reforço e gera dados para treinar o segundo modelo, DeepSeek-R1.
• Ele consegue isso produzindo rastros de inferência, dos quais apenas saídas de alta qualidade são retidas com base em seus resultados finais.
• Isso significa que, diferentemente da maioria dos modelos, os exemplos de aprendizado por reforço (RL) neste pipeline de treinamento não são selecionados por humanos, mas são gerados pelo próprio modelo.

O resultado é que o modelo alcançou desempenho semelhante a modelos líderes, como o modelo o1 da OpenAI, em tarefas como matemática, programação e raciocínio complexo.

(3) Compreendendo o processo de destilação e os modelos destilados do DeepSeek-R1

Além do modelo completo, eles também disponibilizaram o código-fonte de seis modelos menores e mais densos (também chamados de DeepSeek-R1) em diferentes tamanhos (1.5B, 7B, 8B, 14B, 32B, 70B), derivados do DeepSeek-R1 com base em Qwen ou Llama.

A destilação é uma técnica na qual um modelo menor ("o aluno") é treinado para replicar o desempenho de um modelo maior e mais robusto que foi previamente treinado ("o professor").

Neste caso, o professor é o modelo 1B DeepSeek-R671, e os alunos são os seis modelos destilados usando este modelo base de código aberto:

• Qwen2.5 — Matemática-1.5B
• Qwen2.5 — Matemática-7B
• Qwen2.5 — 14B
• Qwen2.5 — 32B
• Lhama-3.1 — 8B
• Lhama-3.3 — 70B-Instruir

O DeepSeek-R1 foi usado como modelo professor para gerar 800,000 amostras de treinamento, uma mistura de amostras de inferência e não inferência, para destilação por meio de ajuste fino supervisionado dos modelos base (1.5B, 7B, 8B, 14B, 32B e 70B).

Então, por que destilamos em primeiro lugar?

O objetivo é transferir os recursos de inferência de modelos maiores, como o DeepSeek-R1 671B, para modelos menores e mais eficientes. Isso permite que modelos menores lidem com tarefas de inferência complexas, sendo mais rápidos e eficientes em termos de recursos.

Além disso, o DeepSeek-R1 tem um número enorme de parâmetros (671 bilhões), o que dificulta sua execução na maioria dos dispositivos de consumo.

Mesmo o mais potente MacBook Pro, com memória unificada máxima de 128 GB, não é suficiente para rodar um modelo com parâmetros de 671 bilhões.

Dessa forma, modelos destilados abrem a possibilidade de implantação em dispositivos com recursos computacionais limitados.

A Unsloth alcançou um feito notável ao quantizar o modelo original DeepSeek-R1, com 671 bilhões de parâmetros, para apenas 131 GB – uma redução significativa de 80% no tamanho. No entanto, a necessidade de 131 GB de VRAM continua sendo um grande obstáculo, especialmente para desenvolvedores que trabalham com hardware de recursos limitados. Essa conquista representa um passo significativo para tornar grandes modelos de IA acessíveis a uma gama mais ampla de usuários.

(4) Seleção do modelo destilado ideal

Com seis tamanhos diferentes de modelos destilados para escolher, determinar o modelo certo depende em grande parte da capacidade do seu equipamento local.

Para aqueles com GPUs ou CPUs de alto desempenho que precisam de desempenho máximo, os modelos maiores DeepSeek-R1 (32B e superiores) são ideais – até mesmo a versão quântica 671B é viável.

No entanto, se os recursos forem limitados ou você preferir tempos de construção mais rápidos (como eu), variantes destiladas menores, como 8B ou 14B, são uma opção melhor. Isso equilibra o desempenho e os requisitos de recursos.

Para este projeto, utilizarei o DeepSeek-R1 Qwen-14B , que é compatível com as limitações de hardware que encontrei. Este modelo (14B) representa um excelente equilíbrio entre precisão e velocidade, tornando-o perfeitamente adequado ao meu ambiente de desenvolvimento.

(5) Critérios para avaliar a capacidade de inferência de grandes modelos de linguagem

Os Modelos de Linguagem de Grande Porte (LLMs, na sigla em inglês) são normalmente avaliados usando benchmarks padronizados que determinam seu nível de desempenho em diversas tarefas, incluindo compreensão de linguagem, geração de código, seguimento de instruções e resposta a perguntas. Exemplos comuns incluem métricas como MMLU , HumanEval e MGSM . Esses benchmarks são fundamentais para avaliar as capacidades dos LLMs.

Para medir a capacidade de raciocínio de um grande modelo de linguagem, precisamos de parâmetros mais desafiadores que se concentrem bastante no raciocínio e vão além de tarefas superficiais. Aqui estão alguns exemplos comuns que se concentram na avaliação de habilidades avançadas de raciocínio:

(i) Exame AIME 2024: Matemática Competitiva

• Preparar Exame Americano de Matemática por Convite (AIME) 2024 Um benchmark robusto para avaliar as capacidades de grandes modelos de linguagem (LLMs) no raciocínio matemático.
• Este exame representa um desafio significativo em matemática competitiva, pois apresenta problemas complexos e de várias etapas. O exame testa a capacidade de grandes modelos de linguagem de entender questões complexas, aplicar raciocínio avançado e realizar manipulações simbólicas precisas. O AIME é uma medida importante para avaliar habilidades complexas de resolução de problemas matemáticos.

(ii) Codeforces – Código da Concorrência

• Levante-se Padrão Codeforces Avaliar a capacidade de inferência de um grande modelo de linguagem (LLM) usando problemas de programação competitiva do mundo real da Codeforces, uma plataforma conhecida por desafios algorítmicos. Codeforces é o padrão ouro para avaliar as capacidades dos modelos de IA para resolver problemas complexos.
• Esses problemas testam a capacidade de um grande modelo de linguagem (LLM) de entender instruções complexas, executar raciocínio lógico e matemático, planejar soluções de várias etapas e gerar código correto e eficiente. Esses problemas exigem uma compreensão profunda de algoritmos e estruturas de dados, bem como a capacidade de traduzir o problema em código executável.

(iii) GPQA Diamond – questões científicas de nível de doutorado

• GPQA-Diamond é um subconjunto selecionado de As perguntas mais difíceis Do padrão GPQA (Perguntas e Respostas de Física de Pós-Graduação) O mais amplo e projetado especificamente para ampliar os limites da capacidade dos modelos de LLM de inferir em tópicos avançados de nível de doutorado. Este padrão representa um verdadeiro desafio à capacidade da IA ​​de entender e inferir conceitos científicos complexos.
• Enquanto o GPQA inclui um conjunto de questões de pós-graduação conceituais e baseadas em cálculos, o GPQA-Diamond isola apenas as questões mais desafiadoras e aquelas que exigem raciocínio intensivo.
• Este critério é considerado “resistente ao Google”, o que significa que é difícil de responder mesmo com acesso irrestrito à web. Isso o torna uma ferramenta valiosa para avaliar a capacidade de grandes modelos de linguagem raciocinarem de forma independente.
• Aqui está um exemplo de uma questão GPQA-Diamond:

### GPQA Diamond - Pergunta de exemplo (Biologia Molecular) Uma célula eucariótica desenvolveu um mecanismo para transformar blocos de construção macromoleculares em energia. O processo ocorre nas mitocôndrias, que são fábricas de energia celular. Na série de reações redox, a energia dos alimentos é armazenada entre os grupos fosfato e usada como moeda celular universal. As moléculas carregadas de energia são transportadas para fora da mitocôndria para atuar em todos os processos celulares. Você descobriu um novo medicamento antidiabetes e quer investigar se ele tem efeito nas mitocôndrias. Você montou uma série de experimentos com sua linhagem celular HEK293. Qual dos experimentos listados abaixo não ajudará você a descobrir o papel mitocondrial do seu medicamento: (A) Extração de mitocôndrias por centrifugação diferencial seguida pelo kit de ensaio colorimétrico de captação de glicose (B) Citometria de fluxo após marcação com 2.5 µM de iodeto de 5,5',6,6'-tetracloro-1,1',3,3'-tetraetilbenzimidazolilcarbocianina (C) Transformação de células com luciferase recombinante e leitura no luminômetro após adição de 5 µM de luciferina ao sobrenadante (D) Microscopia de fluorescência confocal após coloração das células com Mito-RTP

Neste projeto, utilizamos o GPQA-Diamond como critério de inferência , visto que a OpenAI e a DeepSeek o utilizaram para avaliar seus modelos de inferência. A escolha do GPQA-Diamond como critério de avaliação demonstra sua complexidade e importância no campo do desenvolvimento de inteligência artificial.

(6) Ferramentas utilizadas

Neste projeto, utilizamos principalmente o Ollama e o simple-evals da OpenAI. O Ollama é uma plataforma poderosa para executar grandes modelos de linguagem localmente, enquanto o simple-evals fornece uma estrutura para avaliar o desempenho desses modelos.

(i) Ollama

Ollama é uma ferramenta de código aberto que simplifica a execução de Modelos de Linguagem de Grande Porte (LLMs) em nosso computador ou em um servidor local. Ollama é uma plataforma ideal para executar modelos de IA localmente.

Ele atua como um gerenciador e tempo de execução, lidando com tarefas como downloads e configuração do ambiente. Isso permite que os usuários interajam com esses modelos sem a necessidade de uma conexão constante com a internet ou de depender de serviços em nuvem. Gerenciar modelos de linguagem grandes (LLMs) locais é um recurso essencial do Olama.

Ele suporta muitos modelos de linguagem de código aberto, incluindo DeepSeek-R1, e é compatível com várias plataformas: macOS, Windows e Linux. Além disso, ele oferece configuração simples, com o mínimo de complicações e uso eficiente de recursos. O Ollama permite que você aproveite o poder da inteligência artificial diretamente no seu dispositivo.

ImportanteCertifique-se de que sua máquina local tenha: Acessibilidade da GPU Para Ollama, isso acelera significativamente o desempenho e torna o benchmarking subsequente mais eficiente em comparação à CPU. Execute o comando nvidia-smi No terminal para verificar se a GPU foi detectada. Este procedimento garante que as capacidades do dispositivo sejam maximizadas para executar modelos com alta eficiência.

(ii) Biblioteca OpenAI simple-evals para avaliação de modelos de linguagem

Simple-Evals é uma biblioteca leve projetada para avaliar modelos de linguagem usando uma metodologia zero-shot com instruções baseadas na cadeia de raciocínio. Ela incorpora critérios de avaliação populares como MMLU, MATH, GPQA, MGSM e HumanEval, e visa simular casos de uso do mundo real para avaliar o desempenho de modelos de IA em tarefas complexas de raciocínio.

Alguns de vocês podem estar familiarizados com a biblioteca de avaliação mais popular e abrangente da OpenAI, chamada Evals , que é diferente da simple-evals.

Na verdade, a página README do simple-evals indica especificamente que ele não se destina a substituir a biblioteca Evals.

Então, por que usamos simple-evals?

A resposta simples é que o simple-evals vem com scripts de avaliação integrados para os critérios de inferência que estamos visando (como o GPQA), algo que a biblioteca Evals não possui.

Além disso, não encontrei outras ferramentas ou plataformas, além do simple-evals, que ofereçam uma maneira direta e nativa em Python de executar muitos benchmarks importantes, como o GPQA, especialmente ao trabalhar com o Ollama.

(7) Resultados da avaliação

Como parte da avaliação, selecionei aleatoriamente 20 questões do conjunto GPQA-Diamond de 198 questões para a versão resumida do exame 14B . O tempo total foi de 216 minutos, ou aproximadamente 11 minutos por questão.

O resultado foi um tanto decepcionante, atingindo apenas 10% , o que é significativamente inferior ao resultado relatado de 73.3% para o modelo DeepSeek-R1 de tamanho 671B.

O principal problema que notei foi que, durante o raciocínio interno intensivo, o modelo frequentemente falhava em produzir qualquer resposta (por exemplo, retornando tokens de raciocínio como linhas de saída finais) ou fornecia uma resposta que não correspondia ao formato de múltipla escolha esperado (por exemplo, Resposta: A).

Como mostrado acima, muitas das saídas acabaram como: None Porque a lógica regex em simple-evals não conseguiu detectar o padrão de resposta esperado na resposta LLM.

Embora fosse interessante observar a lógica de raciocínio semelhante à humana , eu previa um desempenho melhor em termos de precisão nas respostas às perguntas.

Também vi usuários on-line mencionando que mesmo o modelo maior 32B não funciona tão bem quanto o o1. Isso levantou dúvidas sobre a utilidade dos modelos de inferência destilados, especialmente quando eles têm dificuldade em fornecer respostas corretas, apesar de gerarem longas inferências.

No entanto, o GPQA-Diamond é um benchmark muito exigente, então esses modelos ainda podem ser úteis para tarefas de inferência mais simples. Seus menores requisitos computacionais também o tornam mais fácil.

Além disso, a equipe do DeepSeek recomendou executar vários testes e calcular a média dos resultados como parte do processo de benchmarking — algo que negligenciei devido a restrições de tempo.

(8) Guia detalhado passo a passo

Até aqui, abordamos os conceitos básicos e as principais conclusões.

Se você estiver pronto para uma experiência técnica prática, esta seção fornece uma visão aprofundada dos mecanismos internos e da implementação passo a passo. Este guia técnico prático fornecerá uma compreensão abrangente de como o sistema funciona.

Para visualizar (ou clonar) o repositório GitHub correspondente, consulte o seguinte. Os requisitos de configuração do ambiente virtual podem ser encontrados aqui.

(i) Configuração inicial – Ollama

Começamos baixando o Ollama. Visita
Página de download do Ollama, escolha seu sistema operacional e siga as instruções de instalação correspondentes.

Após a conclusão da instalação, inicie o Ollama clicando duas vezes no aplicativo Ollama (para Windows e macOS) ou executando o comando ollama serve No terminal.

(ii) Configuração inicial – OpenAI simple-evals

A configuração simple-evals é relativamente única.

Embora simple-evals se apresente como uma biblioteca, A ausência de arquivos __init__.py No repositório significa que ele não está estruturado como um pacote Python adequado., levando a erros de importação após clonar o repositório localmente. Isso significa que não é um pacote Python padrão no sentido comumente usado em engenharia de software.

Como também não é publicado no PyPI e não possui arquivos de empacotamento padrão como setup.py أو pyproject.tomlNão pode ser instalado via pip. Isso torna o processo um pouco desafiador para novos desenvolvedores.

Felizmente, podemos usar submódulos Git como uma alternativa direta. Esses submódulos permitem incorporar um repositório Git dentro de outro, facilitando o gerenciamento de dependências.

“`html

Um submódulo Git nos permite incluir o conteúdo de outro repositório Git em nosso projeto. Ele extrai arquivos de um repositório externo (como simple-evals), mas mantém seu histórico separado.

Você pode escolher um dos dois métodos (A ou B) para extrair o conteúdo de simple-evals:

(a) Se você clonar meu repositório de projeto

Meu repositório de projeto já inclui simple-evals Como um submódulo, você pode simplesmente executar:

git submodule update --init --recursive

(b) Se você estiver adicionando-o a um projeto recém-criado.
Para adicionar manualmente simple-evals como um submódulo, execute isto:

git submodule add https://github.com/openai/simple-evals.git simple_evals

Nota: que simple_evals No final (com sublinhado) é muito importante. Ele especifica o nome da pasta, usando um hífen (ou seja, simples-evals) podem levar a problemas de importação mais tarde.

Etapa final (para ambos os métodos)

Depois de puxar o conteúdo do repositório, você deve criar um arquivo. __init__.py Vazio na pasta simple_evals O recém-criado pode ser importado como uma unidade. Você pode criá-lo manualmente ou usar o seguinte comando:

touch simple_evals/__init__.py

(iii) Extraindo o modelo DeepSeek-R1 via Ollama

O próximo passo é baixar o modelo destilado localmente de sua escolha (por exemplo, 14B) usando este comando:

Uma lista dos modelos DeepSeek-R1 disponíveis no Ollama pode ser encontrada aqui . Para um desempenho ideal, recomenda-se usar a versão mais recente do modelo.

ollama pull deepseek-r1:14b

(Quarto) Especifique as configurações

Definimos os parâmetros no arquivo YAML de configurações, conforme mostrado abaixo:

# config/config.yaml MODEL_NAME: "deepseek-r1:14b" # Nome do modelo (corresponde à lista de modelos Ollama) MODEL_TEMPERATURE: 0.6 # Definido entre 0.5 e 0.7 para DeepSeek-R1 EVAL_BENCHMARK: "gpqa" GPQA_VARIANT: "diamond" EVAL_N_EXAMPLES: 20

A temperatura do modelo foi definida para 0.6 (em comparação com o valor padrão típico de 0). Isso segue as recomendações de uso do DeepSeek, que sugerem uma faixa de temperatura de 0.5 a 0.7 (0.6 é o recomendado) para evitar repetições infinitas ou resultados inconsistentes. Essa configuração é essencial para melhorar a qualidade da saída e garantir a consistência.

Não perca a oportunidade de analisar as recomendações de uso exclusivas e interessantes do DeepSeek-R1 – especialmente no que diz respeito aos benchmarks – para garantir o desempenho ideal ao usar os modelos DeepSeek-R1.

EVAL_N_EXAMPLES Este é o parâmetro usado para definir o número de perguntas do conjunto completo de 198 perguntas usadas na avaliação. Este parâmetro é necessário para ajustar o processo de avaliação de acordo com os recursos disponíveis e os objetivos específicos do teste.

(v) Configurando o código do Sampler

Para oferecer suporte a modelos de linguagem baseados em Ollama dentro da estrutura simple-evals, criamos uma classe wrapper personalizada chamada OllamaSampler E guarde isso dentro utils/samplers/ollama_sampler.py. O amostrador é um componente essencial para testar e avaliar o desempenho de modelos de linguagem.

# utils/samplers/ollama_sampler.py importar ollama classe OllamaSampler: def __init__(self, model_name=None, temperature=0): self.model_name = model_name self.temperature = temperature def __call__(self, prompt_messages): prompt_text = prompt_messages[-1]["content"] resposta = ollama.chat( modelo=self.model_name, mensagens=[{"role": "user", "content": prompt_text}], opções={"temperature": self.temperature} ) conteúdo_da_resposta = resposta["mensagem"]["content"] retornar conteúdo_da_resposta def _pack_message(self, conteúdo, função): retornar {"função": função, "conteúdo": conteúdo}

Nesse contexto, um sampler é uma classe Python que gera saídas de um modelo de linguagem com base em um estímulo específico. Essa ferramenta é crucial para garantir que o modelo gere respostas diversas e representativas.

Como os amostradores em simple-evals cobrem apenas provedores como OpenAI e Claude, precisamos de uma classe de amostrador que forneça uma interface compatível com Ollama. Isso garante uma integração perfeita com a estrutura de avaliação.

Levante-se OllamaSampler Extrai um prompt de pergunta do GPQA, envia-o ao formulário em uma temperatura especificada e retorna uma resposta em texto simples. A temperatura é um parâmetro importante que controla a aleatoriedade da saída.

Método incluído _pack_message Para garantir que o formato de saída corresponda ao que os scripts de avaliação em simple-evals esperam. Isso garante consistência e facilidade de análise.

6. Crie um roteiro de avaliação

O código a seguir demonstra como configurar a implementação de avaliação em um arquivo. main.py, incluindo o uso da categoria GPQAEval Da biblioteca simple-evals para executar testes de benchmark GPQA.

Função run_eval() É uma ferramenta de avaliação de tempo de execução configurável que testa grandes modelos de linguagem (LLMs) por meio do Ollama em relação a padrões como o GPQA. Esta função é necessária para avaliar com precisão o desempenho dos modelos.

# main.py def run_eval(): start_time = time.time() # Carregar arquivo de configuração config = load_config("config/config.yaml") # Inicializar o amostrador Ollama (wrapper em torno do bate-papo Ollama) ollama_sampler = OllamaSampler(model_name=config["MODEL_NAME"], temperature=config["MODEL_TEMPERATURE"] ) # Selecionar classe de avaliação a ser usada com base em EVAL_BENCHMARK eval_benchmark = config["EVAL_BENCHMARK"] # GPQA print(f">>> Executando {eval_benchmark} avaliação") if eval_benchmark == "gpqa": eval_class = GPQAEval eval_kwargs = { "n_repeats": config["EVAL_N_REPEATS"], # Padrão 1 "num_examples": config["EVAL_N_EXAMPLES"], # Definir como 20 "variant": config["GPQA_VARIANT"], # Subconjunto GPQA-Diamond } else: raise ValueError( f"Unknown EVAL_BENCHMARK '{eval_benchmark}'." ) # Instanciar e executar a avaliação apropriada evaluator = eval_class(**eval_kwargs) results = evaluator(ollama_sampler) # Executar avaliação com sampler end_time = time.time() elapsed_seconds = end_time - start_time minutes, seconds = divmod(elapsed_seconds, 60) # Calcular o tempo total gasto # O resultado retornado é um EvalResult que inclui uma lista de SingleEvalResult e métricas agregadas print(">>>> Métricas de Avaliação Geral:", results.metrics) print(">>>> Pontuação:", results.score) print(f">>>> Tempo Total de Execução: {int(minutos)} min {segundos:.2f} seg") if __name__ == "__main__": # Executar avaliação GPQA run_eval()

A função carrega as configurações do arquivo de configuração, configura a classe de avaliação apropriada de simple-evals e executa o modelo por meio de um processo de avaliação uniforme. Ele é salvo em um arquivo. main.py, que pode ser executado usando o comando python main.py. Isso garante um processo de avaliação consistente e repetível.

Seguindo os passos acima, configuramos e executamos com sucesso o benchmark GPQA-Diamond no modelo destilado DeepSeek-R1. Esse processo fornece insights valiosos sobre os recursos do modelo.

O resultado final

Neste artigo, analisamos como podemos combinar ferramentas como Ollama e simple-evals da OpenAI para explorar e avaliar os modelos refinados do DeepSeek-R1, com foco na avaliação do desempenho de grandes modelos de linguagem.

Os modelos destilados podem ainda não igualar o modelo original de 671 bilhões de parâmetros em critérios de inferência exigentes como o GPQA-Diamond. No entanto, eles demonstram como a destilação pode expandir o acesso às capacidades de inferência dos Grandes Modelos de Linguagem (LLMs). Melhorar o acesso aos LLMs é um objetivo fundamental nesta área.

Apesar dos resultados inferiores em tarefas complexas de nível de doutorado, essas variantes menores podem permanecer viáveis ​​em cenários menos exigentes, abrindo caminho para uma implementação local eficiente em uma gama mais ampla de dispositivos. Isso contribui para a implementação local eficiente de grandes modelos de linguagem.