Por que ninguém resolveu o aprendizado contínuo

Ver no idioma original →

Autoria: LangChain · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Why Nobody Has Solved Continual Learning · Canal: LangChain · 19:09 · Assistir no YouTube

Tópicos: Agentes de IA, Modelos de IA

Resumo

O vídeo explica por que não existe uma solução simples para atualizar continuamente os pesos de um modelo a partir dos dados gerados em produção. SFT pode ensinar informações e trajetórias novas, mas pode falhar quando o modelo comete erros diferentes dos dados de treino; RL preserva melhor o comportamento existente, mas depende do que o modelo já consegue amostrar. Em ciclos repetidos, SFT pode causar esquecimento catastrófico e degradar capacidades gerais, enquanto RL tem dificuldade para incorporar conhecimento específico. A estratégia adequada depende da tarefa e do equilíbrio entre SFT, destilação e RL.

Pontos-chave

• SFT aprende a partir de trajetórias de referência, mas, por ser off-policy, pode não ensinar o modelo a se recuperar de erros próprios.
• RL é on-policy e pode reforçar comportamentos que o modelo já consegue produzir, mas não consegue facilmente ensinar trajetórias fora da distribuição atual.
• A destilação pode dar ao modelo um ponto de partida para RL, embora modelos treinados com RL possam alcançar um desempenho final mais alto em certas tarefas.
• SFT repetido em tarefas amplas e não estacionárias pode causar esquecimento catastrófico, perda de informações recentes e degradação de capacidades gerais.
• RL tende a interferir menos nas capacidades gerais, mas é difícil usá-lo para incorporar fatos específicos que o modelo não tem probabilidade de amostrar.
• Abordagens que combinam RL e aut destilação on-policy tentam unir os pontos fortes dos métodos, mas podem introduzir viés.
• Tarefas estreitas e estáveis podem se beneficiar de grandes conjuntos de trajetórias de referência e SFT repetido.
• Para tarefas gerais com ferramentas, construir um ciclo de aprendizado contínuo pode exigir capacidades semelhantes às de um laboratório de fronteira.
• Equipes devem escolher a proporção de SFT ou destilação e RL de acordo com o quão estreita e estável é a tarefa.

Capítulos

Início	Capítulo	Resumo
00:03	O ciclo de feedback e os limites do treinamento	O apresentador descreve o ciclo de coleta e avaliação de trajetórias e explica por que o treinamento contínuo ainda não está resolvido.
06:18	Quando combinar destilação e RL	A destilação pode preparar um modelo para RL, mas, em alguns experimentos, modelos treinados diretamente com RL alcançam um teto mais alto.
10:07	Falhas do aprendizado contínuo	O vídeo compara os efeitos de repetir SFT e RL, destacando o esquecimento e a dificuldade de incorporar conhecimentos específicos.
15:26	Escolher a estratégia conforme a tarefa	Tarefas estreitas e estáveis podem favorecer SFT, enquanto tarefas gerais com ferramentas exigem abordagens mais abrangentes.
18:04	O ciclo dos laboratórios de fronteira	Laboratórios de fronteira já executam ciclos de aprendizado mais lentos que combinam dados, mid-training e RL.

Citações

A caixa de treinamento não está resolvida de forma alguma. — 01:04

Assim que comete um erro, o modelo não tem dados de treinamento que mostrem como voltar ao caminho correto de raciocínio. — 04:12

SFT com aut estudo não é uma solução mágica para o aprendizado contínuo. — 12:16

Você precisa pensar com cuidado na proporção de SFT ou destilação em relação a RL. — 19:09

Conceitos e entidades

• Continual learning (conceito): Processo de atualizar repetidamente um modelo com novos dados e experiências, buscando melhorar seu desempenho ao longo do tempo.
• SFT (conceito): Treinamento supervisionado que ajusta o modelo com exemplos ou trajetórias de referência.
• RL (conceito): Aprendizado por reforço que atualiza o modelo com base nas recompensas de trajetórias que ele próprio amostra.
• distillation (conceito): Transferência de comportamentos ou trajetórias de um modelo para outro, frequentemente usada para preparar o modelo para RL.
• catastrophic forgetting (conceito): Perda de conhecimentos ou capacidades previamente adquiridos durante novas etapas de treinamento.
• DAgger (repo): Trabalho citado como referência para entender problemas de aprendizado com dados off-policy.
• Qwen 4B (modelo): Modelo usado como exemplo para comparar SFT e RL com trajetórias de referência.
• Fable 5.1 (modelo): Modelo citado como fonte de trajetórias de referência para treinar outro modelo.
• ECHO (conceito): Abordagem mencionada que combina elementos de aprendizado por reforço e aut destilação on-policy.
• Cursor (empresa): Empresa citada como exemplo de organização que busca adaptar seus modelos e sistemas às próprias tarefas.
• Composer (modelo): Nome associado no vídeo à abordagem recente da Cursor com aut destilação on-policy.
• Anthropic (empresa): Laboratório de fronteira citado como concorrente contra o qual empresas buscam construir uma vantagem própria.
• OpenAI (empresa): Laboratório de fronteira citado como referência para empresas que desejam desenvolver seus próprios ciclos de aprendizado.

Tradução completa (pt-BR)

00:03 Estou muito animado para passar por algumas das coisas em que estamos pensando, especialmente do lado da pesquisa. Mas, em termos de como atualizamos os pesos do modelo, de assumir o controle da sua inteligência, essa é uma das grandes coisas que você pode fazer. Então, parece que há muita coisa acontecendo, e vou tentar dar um panorama geral de pelo menos o que estamos pensando e do que acreditamos que até mesmo os laboratórios de ponta estejam pensando quando se trata de pós-treinamento e até mesmo dos estágios iniciais do treinamento dos seus modelos. Então, esse é mais ou menos o ciclo a que todo mundo se refere.

00:33 Esse é o ciclo que você vê em todos aqueles slides sobre assumir o controle da própria inteligência. É basicamente assim: temos um agent realizando algum tipo de tarefa. Conseguimos extrair trajetórias dessa tarefa. Depois, podemos analisá-las e ver o que o modelo está fazendo certo e o que está fazendo errado. E vamos transformar isso em algum tipo de eval. Isso pode ser um ambiente com uma função de recompensa, como vemos em RL. Pode ser um eval que se transforma em uma trajetória de referência perfeita, na qual podemos então fazer SFT, ou fine-tune supervisionado. Seja qual for a forma, há algum jeito de

01:04 distinguir o bom do ruim nas trajetórias que estamos gerando. E então, há essa caixa, que é esse processo de treinamento muito nebuloso. Depois de treinar, esperamos que o modelo melhore e fazemos o deploy dele. Acho que o que quero enfatizar hoje é que, não importa o que digam, o processo de treinamento não está nem perto de ser resolvido. É muito, muito difícil, e tudo o que você faz tem problemas e trade-offs. Então, para contextualizar, estou falando do regime de aprendizado contínuo. Se você vai assumir o controle da sua inteligência, não quer fazer apenas

01:36 uma única rodada de SFT ou uma única rodada de RL. Você quer que seu modelo continue melhorando com base nas trajetórias que está coletando. Esse é o objetivo de ter esse ciclo de feedback: é um ciclo que você executa continuamente. Não é algo que se faz uma única vez. Então, hoje vou falar sobre por que você não pode simplesmente continuar fazendo SFT. Também não pode simplesmente continuar fazendo RL. Não existe uma solução perfeita. Vou tentar esboçar os trade-offs e dar uma visão geral de todos os diferentes métodos que podemos usar. Então, talvez um bom ponto de partida seja tentar resumir a literatura

02:10 sobre RL, SFT, destilação etc. Provavelmente todo mundo tem uma ideia vaga de que SFT permite instalar novas informações em um modelo. Por exemplo, posso pegar uma trajetória de referência do Fable 5.1, fornecê-la ao Qwen 4B e fazer SFT com ela; assim, o Qwen vai adquirir novas informações e, acho, trajetórias ou caminhos de raciocínio que nunca teria amostrado por conta própria. Essa é uma grande vantagem do SFT. O RL não consegue fazer isso muito bem.

02:41 O RL se limita ao que chamamos de suporte do modelo. Se um modelo consegue amostrar uma determinada sequência de ações, uma trajetória de raciocínio, seja como você quiser chamá-la, podemos aumentar a probabilidade dessa trajetória se ela for boa. Então, o RL só pode usar coisas que estão no suporte do modelo. O SFT pode, de certa forma, fazer o modelo se comportar como quiser. Há muita coisa a destrinchar aqui porque, com base nessa descrição tão breve, parece que SFT é exatamente o que você gostaria de fazer. Posso fazer meu Qwen3 4B se comportar como o Fable 5.1.

03:11 Basta ter trajetórias de SFT suficientes. O problema é que o SFT é um processo muito off-policy. Os dados com que estou aprendendo, sim, fornecem um sinal muito denso. A cada token, recebo uma nova recompensa sobre qual é o próximo token correto, segundo o Fable 5.1, mas o processo é muito, muito off-policy. Então, faço fine-tuning do meu Qwen3 4B com esses dados e depois o coloco em produção. Aí, encontro um caso extremo em produção que nem sequer está fora da distribuição. Simplesmente não está na distribuição de treinamento. Por exemplo,

03:41 nunca vi esse exemplo exato antes. E essa característica off-policy significa que o Qwen3 4B é ordens de grandeza menor que o Fable 5.1. Então, digamos que ele cometa um erro, um passo em falso. Vamos supor que esteja resolvendo um problema de matemática. O problema de ser off-policy é que o Qwen3 4B nunca foi treinado com os próprios erros do Qwen3 4B. Ele só foi treinado com as trajetórias geradas pelo Fable 5.1. Isso significa que, assim que comete um erro, não há nada nos dados de treinamento que mostre como voltar ao caminho correto de raciocínio.

04:12 E esse é um grande modo de falha do SFT. Isso foi apontado inicialmente na literatura tradicional de RL. Há um artigo chamado DAgger que recomendo muito que as pessoas leiam. Ele dá muitas intuições sobre isso, mas esse é um dos motivos pelos quais não podemos simplesmente aumentar muito o SFT, a menos que possamos literalmente fazer SFT com tudo, o que é mais ou menos a ideia do pré-treinamento. O RL, no extremo oposto, é extremamente on-policy. Então, só usamos amostras do modelo — o Qwen3 4B — que pretendemos usar em produção. Vamos supor, de novo, que estamos nesse ambiente de matemática.

04:46 Vamos aumentar a probabilidade de o Qwen3 4B produzir boas trajetórias quando receber uma recompensa positiva e diminuir a probabilidade de suas trajetórias negativas. Mas há um limite, certo? Digamos que estamos tentando resolver um problema da IOI de 2026. É muito improvável que o Qwen3 4B consiga amostrar uma solução. Provavelmente não devia dizer isso agora, porque até mesmo os modelos 4B são capazes disso. É possível que eles resolvam problemas da IOI, o que é meio louco. Mas, se for um problema de matemática muito difícil, será muito improvável

05:18 que esse modelo pequeno consiga amostrar uma resposta correta. E, se nunca conseguirmos amostrar uma resposta correta, nunca poderemos atualizá-lo. Então existe esse trade-off: o processo é incrivelmente on-policy e não estamos prejudicando o modelo dessa maneira. Em qualquer momento, o modelo vai saber exatamente como se recuperar, porque tudo sempre vem do próprio modelo. Mas temos esse limite: só podemos aumentar a probabilidade de coisas que já fazem parte da distribuição do modelo. Isso é muita informação, mas espero que agora eu esteja começando a mostrar que há muitos trade-offs.

05:48 Posso usar RL para melhorar meu modelo, mas isso depende muito do ponto de partida do modelo. Com SFT, não é bem assim. Posso pegar dados de referência muito bons e, independentemente de onde meu modelo esteja, treiná-lo com esses dados deve melhorá-lo de acordo com os dados usados no treinamento. Mas o RL não funciona assim. Claro que o SFT tem os problemas que acabei de mencionar. Esse é o ponto de partida. Agora quero falar um pouco sobre algumas das maneiras como temos

06:18 pensado em quando fazer SFT ou destilação e quando fazer RL. Acho que essa é uma pergunta muito interessante em geral, porque permite prever o que os laboratórios chineses de open source deveriam estar fazendo: quanta destilação um laboratório de open source deveria fazer em comparação com RL? Este foi um resultado realmente interessante que replicamos de algumas maneiras diferentes. Como acabei de explicar, não dá para usar RL se não houver nenhuma probabilidade de amostrar uma boa trajetória logo de início. Então, muita gente faz o seguinte, e acreditamos que os laboratórios de open source também fazem:

06:51 é que eles pegam um modelo depois do pré-treinamento que provavelmente tem uma probabilidade muito baixa de amostrar algo útil em qualquer um dos ambientes de RL que nos interessam. Então, a destilação é usada como uma forma de dar a esse modelo um ponto de partida. Pegamos alguns rastros de raciocínio e algumas trajetórias de um modelo de ponta de código fechado e os colocamos no fim do pré-treinamento, ou numa espécie de treinamento intermediário ou pré-treinamento contínuo. Assim, o modelo vê alguns exemplos de como executar essa tarefa corretamente. E isso é exatamente igual a SFT. Quer dizer, isso é literalmente só SFT. Estamos apenas fazendo previsão do próximo token com esses rastros.

07:24 É para isso que acreditamos que a destilação é usada nos laboratórios de open source. É uma forma de conseguir uma taxa de aprovação diferente de zero em, sabe, k para o seu ambiente de RL específico; depois, você faz RL a partir daí e observa o modelo subir. E esse costuma ser o processo usado; vemos muitas empresas passando por ele. Elas têm vários ambientes de RL muito complexos. Querem que o modelo fique melhor neles, mas o modelo começa com um pass@k muito, muito baixo. O pass@256 pode ser muito, muito baixo, e elas simplesmente não têm capacidade computacional para executar um grupo desse tamanho por tanto tempo a fim de observar o modelo subir. Então fazem um pouco de destilação com alguns rastros de código fechado e depois fazem RL.

07:58 Para chegar ao ponto, acho que o que este gráfico mostra — e, de novo, reproduzimos isso de muitas maneiras — é que, curiosamente, se você faz uma quantidade significativa de destilação para dar ao modelo um ponto de partida e depois faz RL corretamente até ele realmente atingir um platô, você começa de um ponto muito mais alto depois da destilação. Obviamente, esse é todo o objetivo de fazer isso.

08:29 Mas fazer RL em um modelo que não foi destilado acaba levando a resultados muito melhores. Então você tem esse tipo de curva em que a curva da destilação começa mais alta, mas atinge um platô muito mais baixo do que a do modelo treinado com RL. Isso foi um pouco surpreendente, e achamos que era uma peculiaridade da configuração inicial que tínhamos feito, mas descobrimos que esse resultado se mantém em muitas situações. E isso também depende muito do tipo de tarefa que você está aprendendo. Parece que os modelos de RL atingem um patamar muito mais alto em tarefas de cálculo ou matemática, basicamente porque acho que a destilação está restringindo a entropia do modelo.

09:04 Então tentamos aplicar isso. Treinamos muitos modelos para clientes. Agora estamos pensando com muito cuidado se devemos fazer alguma destilação no início. Hoje estamos muito mais convencidos de que, se tivermos capacidade computacional, vamos fazer RL até o fim. Isso significa que você precisa se preocupar com outras coisas; por exemplo, com o currículo da sua tarefa de RL. Se você tem uma tarefa em que o pass@k é bom e outra em que a taxa de aprovação é basicamente zero, precisa organizar esse currículo. É mais uma coisa com que você precisa se preocupar.

09:35 Mas, se no fim você chega a um patamar mais alto, provavelmente vale a pena se preocupar com isso. Outra coisa sobre a qual quero falar, em termos dos resultados que vimos recentemente, é essa ideia de, acho que sim, aprendizado contínuo. No início, mencionei que, basicamente, se você está fazendo uma grande rodada de treinamento pontual, esses problemas estão meio que resolvidos. Você pode usar SFT, e seu modelo vai melhorar. Sim, haverá coisas fora da distribuição em que ele não vai se sair bem, mas você tem um grande exemplo de tarefas ou rollouts do Fable 5.1, e seu modelo Qwen vai melhorar.

10:07 O mesmo vale para RL. Você reúne vários ambientes, faz RL, o modelo sobe gradualmente e obtém um modelo melhor. O que acho realmente interessante é o regime de aprendizado contínuo, em que você faz esse processo não uma vez, nem dez vezes, mas provavelmente centenas, se não dezenas de milhares de vezes. A atualização dos pesos de fato acontece várias vezes por semana, no mínimo.

10:38 Acho que esse é o mundo mais interessante para se estar, e acho que é para esse mundo que muitas empresas vão ter que mirar, porque precisam de algum tipo de vantagem competitiva contra Anthropic ou OpenAI. E o que começa a dar errado aqui são algumas coisas. A primeira é: se eu continuar fazendo SFT, digamos que eu tenha esse LLM que é um associado jurídico e esteja tentando treiná-lo com todas as informações novas que encontra. Então, ele aprendeu coisas novas sobre esse caso, aprendeu que essa pessoa entrou como paralegal e aprendeu que essa informação está armazenada aqui nesta firma, e assim por diante.

11:10 Então, de novo, posso fazer um grande fine-tune com SFT. Usamos algo chamado estudo autodirigido se quisermos aprender conhecimento. Fazer um grande fine-tune uma vez não tem problema. Se eu repetir esse processo sem parar, várias coisas acontecem. A primeira é que esqueço coisas da minha distribuição-base que são úteis para a tarefa que estou realizando. Isso se chama esquecimento catastrófico. A maioria das pessoas já ouviu falar disso. Vou esquecer não só a literatura inglesa do século XVII, mas também vou começar a esquecer conhecimentos jurídicos em algum momento, embora esses conhecimentos supostamente sejam úteis para mim e para meu agent associado jurídico.

11:42 A segunda coisa é que vou esquecer o que aprendi depois do pré-treinamento. Digamos que, no primeiro dia, eu tenha feito fine-tune com esse caso específico e, 100 atualizações depois, faça fine-tune com um caso completamente diferente. O que constatamos é que o modelo esquece os casos anteriores, e a uma taxa muito mais rápida do que ocorre o esquecimento catastrófico no modelo em geral. Isso é realmente interessante. A terceira coisa muito ruim é que as capacidades gerais do modelo se degradam. Se você começar a testá-lo em tarefas gerais, como seguir instruções, matemática e raciocínio,

12:16 vemos que isso realmente falha no regime iterativo. Portanto, está claro que estudo autodirigido mais SFT não é uma solução mágica para o aprendizado contínuo e não funciona quando a tarefa é muito, muito ampla. Faço a ressalva de que isso funciona quando temos uma tarefa muito restrita, com uma distribuição estacionária que não muda. Posso continuar fazendo fine-tune nela. Posso continuar gerando rastros de referência nela, e meu modelo continuará melhorando. Mas, para tarefas muito gerais e não estacionárias,

12:49 nas quais chegam tanto informações novas quanto capacidades novas, SFT com o material de estudo autodirigido não parece funcionar muito bem. Então você pode perguntar: e quanto a RL? Eu diria que RL não altera o modelo da mesma forma que SFT. Não vemos tanto esquecimento catastrófico com RL. Não vemos degradação das capacidades gerais. E vemos pouca interferência entre as tarefas em que estamos fazendo RL. Basicamente, a razão disso — você pode ler toda a literatura sobre o assunto — se resume ao fato de que o modelo tem, independentemente do método de RL usado,

13:21 basicamente, essa penalidade KL implícita. Ela o mantém muito próximo do modelo-base original. Então, quando fazemos RL, damos apenas ajustes muito, muito pequenos ao modelo. Mas o problema com RL é que é muito difícil, primeiro, incorporar conhecimento. Como eu disse, só podemos mudar o comportamento de um modelo com RL se for provável que ele amostre alguma coisa. É muito improvável que um modelo amostre algo como: “Jenny entrou para a equipe XYZ como paralegal”. É muito difícil incorporar um conhecimento muito específico assim.

13:52 projetar ambientes de RL para incorporar conhecimento e, em segundo lugar, é muito difícil induzir isso de alguma forma por meio de qualquer tipo de penalidade de eficiência. Então, você poderia imaginar que, se tivesse a melhor penalidade de eficiência do mundo, conseguiria incentivar o modelo a aprender algum comportamento em vez de ter que procurá-lo todas as vezes. Mas nunca vimos isso acontecer com RL. O modelo vai melhorar na busca, vai melhorar em usar grep e em todo o resto, mas nunca será incentivado o suficiente, nem mesmo com as maiores penalidades de eficiência, para dizer: “Certo, vou me lembrar desta informação para a próxima vez”, simplesmente por causa do mecanismo de funcionamento do RL.

14:23 Então, acho que essa é a principal coisa que vocês devem tirar daqui. Basicamente, no regime iterativo, muitas dessas coisas deixam de funcionar, e RL não é uma solução geral suficiente para incorporar nosso aprendiz contínuo. Houve muitas abordagens, como ECHO e, mais recentemente, o Composer, da Cursor. Eles tentaram algo em que adaptaram a destilação própria on-policy para, essencialmente, fornecer dicas — dicas densas — ao modelo durante o RL, mais ou menos na etapa de rollout.

14:54 Então, estão tentando combinar o melhor dos dois mundos aqui: ter uma recompensa de RL e uma recompensa de destilação própria, em que tentamos, de fato, fornecer novas informações ao modelo. Acho que a conclusão geral sobre a destilação própria é que é muito, muito difícil fazê-la funcionar, porque ela introduz naturalmente viés no algoritmo de RL, e os LLMs, quando chegam à etapa de RL, são muito, muito resistentes a viés. Qualquer tipo de viés vai atrapalhar, mas fico feliz em conversar sobre isso com as pessoas depois. É. Então, para resumir… quanto tempo ainda tenho?

15:26 Certo, temos mais um tempinho. Então, para resumir, acabei despejando um monte de coisas para todo mundo. O que isso realmente significa quando você tem uma tarefa específica que está realizando com algum tipo de LLM ou agent e quer controlar esse ciclo de aprendizado contínuo? Acho que todo mundo sabe que, se você tem uma tarefa única e extremamente restrita, está com tudo a seu favor. Está feliz. Está muito satisfeito. Por exemplo, se você está escrevendo notas clínicas, então insere uma transcrição e espera receber notas clínicas com uma estrutura específica de

15:58 prompt; ou, sabe, se está fazendo extração de voz, então tem uma configuração de conversão de fala em texto, LLM e conversão de texto em fala. Tenho esses agents de atendimento ao cliente por telefone. Esse é outro exemplo de uma tarefa realmente restrita em que, teoricamente, minhas regras e a distribuição, de modo geral, são muito estáveis. Então, provavelmente, o melhor a fazer aqui — e não me citem — é pegar o melhor modelo que você conseguir encontrar, ignorar os termos de serviço e gerar

16:28 centenas de milhares, ou até milhões, de traces, e fazer SFT com eles. De novo, não me citem. Isso não é aconselhamento jurídico nem nada do tipo, mas a ideia é que você pode simplesmente pegar esses traces de SFT de referência e fazer SFT com eles; assim, vai convergir para essa distribuição de referência e, no regime de dados infinitos, vai chegar lá. Isso é ótimo. Aí, sabe, o mundo ficou mais orientado a agents. Alguém decidiu dar ferramentas aos LLMs. Começamos a deixá-los circular um pouco mais livremente, até que, basicamente,

17:00 todo harness de LLM virou uma espécie de máquina universal de Turing com LLM, que permitia aos modelos fazer o que quisessem em qualquer sandbox que quisessem. Então, nesse caso, as coisas são bem mais difíceis. Por exemplo, entre as empresas que tentaram controlar a própria inteligência nessa camada estão Cursor, Notion, Harvey, Lovable e várias outras, que estão percebendo que, quando sua tarefa é genérica o suficiente, basicamente você precisa se transformar em um laboratório de fronteira para controlar a própria inteligência. Isso significa fazer pós-treinamento em vários ambientes que vocês mesmos

17:33 criam, como já conversamos, mas também fazer as etapas anteriores, o mid-training, que, mais uma vez, se parece com SFT. Então, desse ponto de vista, sim, é possível, mas é muito, muito difícil. Acho que a última coisa que quero transmitir é que esse ciclo de aprendizado contínuo já foi resolvido. Parece que eu disse que não o resolvemos. Quer dizer, não o resolvemos em um nível realmente granular, quando você está operando ou atualizando seu modelo várias vezes por dia.

18:04 Acho que, se você observar o que os laboratórios de fronteira estão fazendo, eles estão executando um ciclo de aprendizado contínuo, só que em um ritmo muito lento. Eles treinam um modelo e o lançam para o mundo. Alguns analisam os dados exatos dos usuários; outros pedem feedback aos usuários. Reúnem tudo isso e analisam todas as coisas que o modelo não consegue fazer. Ótimo, vamos transformar isso em ambientes de RL. Sabe, se tivermos resultados zero nesses ambientes de RL, vamos usar informações privilegiadas ou algum outro método para construir essas ótimas trajetórias. Vamos fazer mid-training com elas e, depois, fazer RL a partir daí e aquecer o modelo a partir daí. Então, acho que, se você observar esse ciclo, ele já está em funcionamento e envolve tanto SFT quanto

18:38 RL. Só que, nessa escala, não precisamos nos preocupar com esquecimento catastrófico, com a degradação das capacidades gerais e com todas as outras coisas que mencionei antes, os problemas que aparecem. É, acho que essa era a última coisa que eu queria transmitir. Mas a maioria das pessoas nesta sala vai atuar em algum ponto intermediário. Você tem uma tarefa que não é exatamente restrita, mas também não é bem como a da Cursor. E vai conseguir encontrar alguma forma de incorporar ao modelo tanto o conhecimento quanto as capacidades que você quer que melhorem continuamente.

19:09 Você só precisa pensar com muito cuidado na proporção entre SFT/destilação e RL que vai usar. E acho que esse é o ponto mais importante para começar a pensar nesse ciclo. Então, equipes técnicas, equipes de pós-treinamento etc.: é por aí que vocês devem começar a analisar e pensar em que ponto desse espectro estão. Beleza. Obrigado, pessoal.

Transcrição original

[00:03] Very excited to go through some of the things we’re thinking about from particularly the research side. But in terms of how we update the model weights for a model, like, in terms of owning your intelligence, that’s one of the big things you can do. So it feels like there’s a lot going on, and I’m going to try and, like, give a big context dump of at least, like, what we’re thinking about, what we believe even the frontier labs are thinking about when it comes to, like, post-training and even earlier stages of training with your models. So this is kind of like the loop that, you know, everyone refers to.

[00:33] This is the loop you see in all the, you know, own your own intelligence slides. It’s essentially like, okay, we have an agent doing some sort of task. We are able to extract traces for that task. We are able to then look through them and see what the model is doing right and what it’s doing wrong. And we’re going to turn that into some form of an eval. Now, this might look like an environment with a reward function, as we see in RL. It might look like an eval that turns into, you know, a perfect gold trace that we can then SFT on, supervised fine-tune on. Whatever it looks like, there is some way to

[01:04] determine good from bad in the traces that we’re generating. And then, you know, there’s this box, which is like this very nebulous, like, train. Once we’ve trained, we’re hoping the model gets better and we deploy it. I think the thing I want to like hammer home today is that no matter what anyone tells you, like, the train box is like not solved at all. It’s really, really, really hard, and everything that you do has problems and trade-offs. And so I guess for everyone’s context, I’m talking about the continual learning regime. So if you’re going to own your intelligence, like, you don’t want to just do

[01:36] a one-off SFT run or a one-off RL run. You want your model to continue to get better from these traces that you’re collecting. Like, that’s the whole point of having this feedback loop, is that it is a loop that you’re consistently running. It’s not a one-off thing. So I guess today, like, I’m going to talk to you about why you can’t just continually SFT. You can’t also just continually RL. Like, there is no perfect solution. I’m going to try and, like, sketch the trade-offs and the, like, give you an outline of all the different methods that we can use. So yeah, maybe, like, a place to start here is, like, trying to summarize the literature

[02:10] around RL, SFT, distillation, etc. So everyone probably has this vague idea of SFT as being able to install new information in a model. So I can take a gold trace from, you know, Fable 5.1 and give it to Qwen 4B and SFT on that, and, like, Qwen is going to get new information and it’s going to get, like, I guess, reasoning traces or paths that it never would have sampled by itself. That’s a great thing about SFT. RL can’t really do that.

[02:41] RL is limited to what we say the support is of the model. So if a model can sample a particular rollout, a reasoning trace, however you want to call it, we can upweight the likelihood of that reasoning trace if it’s good. So RL can only take things which are in the support of the model. SFT can kind of make the model do whatever it wants. Now, there’s a lot to break down here because, like, from that, like, very brief description, it seems like SFT is, like, exactly the thing that you’d want to do. Like, I can get my Qwen3 4B to act like Fable 5.1.

[03:11] I just get enough SFT traces. The problem comes here because SFT is a very off-policy process. So the data that I am learning from, yes, it’s got a very dense signal. Like, every token, I’m getting a new reward about what the correct next token is, according to Fable 5.1, but it’s very, very off-policy. And so I fine-tune my Qwen3 4B on this and then I go deploy it in production, and, you know, I hit this production edge case which isn’t even out of distribution. It’s just not in the training distribution. Like,

[03:41] I haven’t seen this exact example before. And this off-policyness means Qwen3 4B is orders of magnitude smaller than Fable 5.1. So let’s just say it makes, like, one mistake, like one misstep. We say it’s solving a math problem. The problem with off-policyness is that Qwen3 4B has never been trained on Qwen3 4B’s mistakes. Like, it’s only been trained on Fable 5.1’s rollouts. And so that means that as soon as it makes a mistake, it’s got nothing in its training data which shows how to get back onto the correct reasoning path.

[04:12] And this is a big failure mode of SFT. This was first kind of pointed out in the old traditional RL literature. There’s a paper called DAgger that I highly recommend people read. Gives a lot of intuitions about this, but it’s a reason why we can’t just, like, kind of jack up SFT unless we can literally SFT on everything, which is kind of the idea of pre-training. RL, in, like, kind of the opposite end of the spectrum, is extremely on policy. So, we’re only ever taking samples from the model, Qwen3 4B, that we intend on using in production. And so let’s say, again, we’re in this, like, kind of maths

[04:46] environment. Like, we are going to upweight Qwen3 4B’s probability of doing good rollouts, so when it gets a positive reward, and then we’re going to downweight its negative rollouts. But there is a limit here, right? Like, let’s say that we’re trying to solve, you know, an IOI problem from 2026. Like, it’s very unlikely that Qwen3 4B is going to sample. I probably shouldn’t say that now ’cause like even the 4B models are, like, possible. It’s possible for them to do IOI problems, which is kind of crazy. But, like, you know, if it’s a very hard math problem, it’s going to be very unlikely

[05:18] for that small model to be able to sample a correct answer. And if we can never sample a correct answer, we’re never going to be able to update it. So there is this trade-off, like it’s incredibly on-policy and like, you know, we’re not damaging the model in this way. The model is going to know exactly how to recover from wherever, at any point in time, because it’s always coming from the model. But, you know, we have this ceiling of, like, we can only upweight things which are already in the distribution of the model. And so that’s a lot of information, but hopefully, like, now I’m starting to instill into you, like, okay, there’s a lot of these trade-offs.

[05:48] I can use RL to improve my model, but that is very, very dependent on where my model starts from. SFT is not really like that. I can take some really good gold data, and no matter where my model is sitting, like, training the model on that gold data should improve according to the data that I’m training on. But RL’s not like that. But of course, SFT has, like, the problems that I just talked about. So this is, like, the starting point. I want to talk now a little bit about, like, some of the ways that we’ve been

[06:18] thinking about, like, when to do SFT/distillation and when to do RL. And I think this is, like, a very interesting question in general because you know it allows you to predict what, you know, the Chinese open source lab should be doing, like how much distillation should an open source lab be doing versus RL? And this was one really interesting result which we replicated in a few different ways. So as I just told you, you can’t use RL if it doesn’t, if you don’t have any probability of sampling a good rollout in the first place. So what a lot of people do and what we believe, you know, the open source labs to do,

[06:51] is they will take a model after pre-training that’s probably got a very low likelihood of sampling anything useful on any of the RL environments that we care about. So distillation is then used as a way to warm start this model. So we’ll take some reasoning traces and some trajectories from, you know, a frontier closed source model, and we’ll throw those in at the end of pre-training or in kind of like mid-training or continued pre-training. So the model sees some examples of how to do this task correctly. And this looks exactly like SFT. Like, this is literally just SFT. We’re just doing next-token prediction on these traces.

[07:24] That’s what we believe distillation is used for at the open source labs. It’s a way to get a nonzero pass at, you know, k for your particular RL environment, and then you do your RL from there and you watch your model climb. And this is typically like the process that’s used, and you know, like we see many companies going through this process. So they’ll have, you know, they have, like, a bunch of very complex RL environments. They want their model to get better at them, but the model’s starting off at a really, really low pass@k. Like, pass@256 might be, like, really, really low, and they just don’t have the compute to be able to run, like, that

[07:58] big of a group size for that long to watch the model climb. So they’ll do a bit of distillation on, you know, some closed source traces and then do the RL after that. To get to the point, I think what this graph is showing, and again, like, we’ve replicated this in many ways, is that, really interestingly, if you do, like, any meaningful amount of distillation in order to get your warm starting, and then you do RL properly and you do it until, like, you’ve really, really plateaued, basically you start off much higher after you’ve done distillation. Obviously, that’s the whole

[08:29] point of doing it. But RLing on a model that hasn’t been distilled at all ends up getting much better. So you have this kind of, like, curve where the distillation curve starts higher but it plateaus much lower than the model that’s been RL’d. And this was a little bit surprising, and we thought this was a quirk of the initial setup that we’ve done, but this turned out to hold across a lot of things. And it’s very dependent on the type of task that you’re learning as well. So it seems like the RL models, like, reach a much higher ceiling in, like, calculation or math-based tasks, purely because like I think basically distillation is constraining the like entropy,

[09:04] you can think of, of the model. So we’ve kind of, like, tried to apply this in, like, you know, we train a lot of models for customers. Now we’re actually really thinking about carefully about whether we do any distillation at all to start off with. Like, now we’re much more pilled on, like, if we have the compute, we’re going to RL, like, all the way. It means you have to care about different things, like, for instance, you have to care about the curriculum of your RL task. Like, if you’ve got some task that, you know, you have a good pass@k, and some task where pass is, like basically zero, you kind of have to order this curriculum. It’s another thing you

[09:35] have to care about. But, like, you know, if you get to a higher point at the end of the day, then it probably is worth caring about it. Another thing that, like, I kind of want to talk about in terms of, like, results that we’ve seen recently is this idea of, like, I guess, yeah, continual learning. So right at the start I mentioned that basically if you’re doing a one-off like, you know, big training run, these things are kind of solved. Like, you can use SFT, your model is going to get better. Like, yes, there’ll be things outside the distribution

[10:07] that it won’t go well on, but like, you know, you’ve got a big example of, like, Fable 5.1 tasks or rollouts, like, your Qwen model is going to get better. Same with RL. Like, you collect a bunch of environments, you do the RL, the model hill climbs, like, you got a better model. I think what’s really interesting to me is, like, the continual learning regime, where you’re doing this process, like, not once and not, like, 10 times, but probably, like, hundreds if not tens of thousands of times. Like, your actual, like, weight update is happening, you know, at least multiple times a week.

[10:38] I think, like, this is the most interesting world to live in, and I think it’s the world that, like, a lot of companies are going to have to shoot towards because, you know, they need some sort of moat against Anthropic or OpenAI. And the thing that breaks down here is, well, it’s a few things. So the first thing is like, if I keep SFTing on, let’s say I have this, like, you know LLM that’s a legal associate, and I’m trying to train this legal associate on all the new information it’s seeing. So, you know, it’s learned new things about this case, and it’s learned that this person has joined as a paralegal, and it’s learned that this information is stored

[11:10] here in this firm, and so on. So again, like, I can kind of, like, you know, do a big fine-tune with SFT. So we use something called self-study if we want to learn, like, knowledge. Do a big fine-tune once, that’s fine. If I repeat that process over and over and over again, I find that multiple things happen. The first thing is I forget things in my base distribution which are useful to the task that I’m currently doing. So this is called catastrophic forgetting. Most people have heard about this. I will forget not only, like, you know, English literature from the 17th century, but I will actually start forgetting law stuff as well at some point, even though

[11:42] that law stuff is supposedly helpful to me and my legal associate agent. The second thing is I will forget stuff that I’ve learned after pre-training. Like, you know, let’s say the first day I’ve fine-tuned on, you know, this particular case, and then, you know, 100 updates later, I fine-tune on a completely different case. What we find is that the model will forget the earlier cases, and at a much faster rate than catastrophic forgetting happens in the model in general. That’s really interesting. The third really bad thing is that the model’s general capabilities will degrade. So if you start testing it on, you know, instruction following, maths, reasoning,

[12:16] all these kind of, like, general tasks, we see that this really fails in the iterative regime. So it’s clear that, like, you know, self-study plus SFT is not this like silver bullet to continual learning, and, like, it doesn’t work when you have this very, very broad task. I will caveat this with saying that this does work when we have, you know, a very constrained task with a stationary distribution that’s not changing. Like, I can keep fine-tuning on that. I can keep generating gold traces on that, and my model will keep getting better. Like, but for very, very general tasks that are non-stationary,

[12:49] like new information is coming in as well as new capabilities, SFT on the self-study stuff doesn’t really seem to work. So you might say, okay, what about RL? RL, I will say, doesn’t mess with the model in the same way that SFT does. So, you know, we don’t see that much catastrophic forgetting with RL. We don’t see, you know, degradation of general abilities. And we see little interference between tasks that we’re kind of RLing on. Basically, the reason for this, like, you can read all the literature about it, boils down to the fact that the model has, no matter what RL kind of method you use,

[13:21] basically this implicit KL penalty. It’s like tying it very closely to the original base model. So when we RL, we just, like, make very, very small nudges to the model. But the problem with RL is, like, it’s very hard to, one, bake in knowledge. So again, as I said, we can only change the behavior of a model in RL if the model is likely to sample something. A model is very unlikely to sample something like, you know, Jenny has joined as a paralegal in team XYZ. Like, some very, very specific knowledge is very hard to, like,

[13:52] engineer RL environments to bake in knowledge, and secondly it’s very hard to like induce that in any way through any sort of efficiency penalty. So you might imagine if you had the world’s best efficiency penalty, you could incentivize the model to, like, learn some behavior instead of having to search for it each time, but we’ve never seen this happen with RL. Like, the model will get better at searching and it’ll get better at grepping and everything, but it will never be incentivized enough, even with the highest efficiency penalties, to say, okay, I’m going to remember this information for next time, simply because of the mechanism of how RL works.

[14:23] So I think, like, that’s the main thing that you should take away from this. Basically, in the iterative regime, a lot of these things break down, and RL is not enough of a general solution to bake in our, like, continual learner. There’s been, like, a lot of approaches, like ECHO and, like, you know, even Cursor recently with Composer. They tried this thing where they adapted on-policy self- distillation to, like, essentially provide hints, like dense-level hints, to the model in doing RL at kind of, like, rollout time.

[14:54] So they’re trying to combine the best of both worlds here, essentially, where they go, okay, we’re going to have an RL reward, we’re going to have a self-distillation reward where we’re actually trying to provide new information to the model. I think the general take with, like, self-distillation even is very, very hard to get to work because it naturally introduces bias into your RL algorithm, and LLMs, by the time you get to RL, are very, very, like, anti-bias. Any sort of bias will mess with them, but I’m happy to talk to people about that later. Yeah. So, to kind of take away… how much time I got?

[15:26] Okay, we got a little bit of time. So, to take away, like, I’ve kind of dumped a bunch of stuff on everyone. What does this really mean when you have this particular task that you’re doing with some form of LLM or agent, and you want to, like, own this continual learning loop? So, I think everyone’s kind of aware that if you have one task and it’s extremely narrow, then you’re kind of, like, sailing. You’re cheering. You’re really happy, like if it’s, you know, writing clinical notes so I’m dumping in a transcript and expecting some clinical notes with a particular

[15:58] prompt structure out, or you know, I’m doing, you know, voice extraction, so I’ve got like you know speech-to-text, LLM, text-to-speech kind of setup. I’ve got these like phone calling customer service agents. That’s another example of a task that is like really narrow and theoretically my rules and distribution in general is very stationary. So I can, you know, the best thing to do probably here and like don’t quote me on this, is, like, take the best model you can find, ignore the terms of service, and generate

[16:28] like hundreds of thousands, if not millions, of traces and SFT on that. Like, again, don’t quote me on that. That wasn’t legal advice or anything, but the idea there is that you can just take these gold SFT traces and SFT on them, and you’re going to asymptote towards that gold distribution, and in the infinite data regime, you’re going to get there. That’s great. Then, you know, the world got more agentic. Someone decided to give LLMs tools. We started to, like, let them roam free a little bit more until like basically, like,

[17:00] every LLM harness was this like kind of universal Turing LLM machine that allowed them to do whatever they want on whatever sandbox they wanted. And so, in this case, like, things are a lot harder. As an example, people that have tried to own their own intelligence at this layer have been, you know, Cursor, Notion, Harvey, Lovable, like, a bunch of these companies that are realizing that when your task is general enough, you basically have to turn into a frontier lab in order to own your intelligence. So this means, you know, post-training on a bunch of environments that you yourself

[17:33] create, as, like, we’ve talked about before, but also, like, doing the earlier stages as well, the mid-training, which again looks like SFT. So from that perspective, like, yes, it’s doable, but it’s very, very hard. I think the last thing I want to, like, convey is this continual learning loop, like, we’ve already solved. Like, it kind of sounds like I’ve said that this is, we haven’t solved it. I mean, we haven’t solved it at a really granular level when you’re operating or you’re updating your model, like, you know, multiple times a day.

[18:04] I think if you look at what the frontier labs are doing, like, they are running a continual learning loop, just on a very slow cadence. So, you know, they train a model, release it to the world. Like, some will look at the exact user data, some will ask for user feedback. They aggregate all this and look at all the things the model can’t do. Great, we’ll turn that into RL environments. You know, if we get zero on those RL environments, we’re going to, like, use privileged information or some way to construct these great trajectories. We’re going to mid-train on them, and then we’re going to do RL from there and warm up from there. So I think if you look at this loop, it’s already running and it involves both SFT and

[18:38] RL. It’s just, at that scale, we don’t have to worry about catastrophic forgetting, like general capability degradation, all the things that I mentioned earlier, the breakdown. Yeah, I think that’s the last thing I wanted to convey. But yeah, most of the people in this room will live kind of in the middle. Like, you have a task that is, like, not quite narrow, but also not quite Cursor. And you will be able to come up with some way to bake both the knowledge and the capabilities that you want to, like, continually get better at into that model.

[19:09] You just need to be very smart about, like, the ratio of SFT/distillation to RL that you do. And I think that’s the most important place to start thinking about this loop. And so technical teams, post-training teams, etc. Like, that’s the place to start looking and thinking about, like, where on that spectrum you sit. Cool. Thanks, guys.