Destilação do modelo OpenAI: Um guia com exemplos

Eu tentei o OpenAIa nova ferramenta de ferramenta de destilação de modelos da OpenAI-ela requer um mínimo de codificação e nos permite gerenciar todo o processo de destilação em uma única plataforma, desde a geração de conjuntos de dados até o modelos de ajuste fino e avaliação de seu desempenho.

Neste tutorial, ajudarei você a começar a usar a ferramenta de destilação de modelos da OpenAI. Primeiro, abordaremos os conceitos básicos da destilação de modelos e, em seguida, faremos um projeto de destilação de demonstração usando a a API da OpenAI.

O que é destilação de modelos?

Imagine um professor habilidoso e com boa formação ensinando seu processo de raciocínio e conhecimento a um aluno. Esses são os princípios básicos de como funciona a destilação de modelos.

Nessa técnica, o professor é um modelo grande pré-treinado, e o aluno é um modelo menor que aprende a replicar o resultado do professor. Isso permite que o aluno realize tarefas específicas em um nível comparável ao do professor, mas com menos recursos necessários.

A destilação de modelos pode ser feita de várias formas, cada uma com seus próprios métodos e objetivos. Em um caso, precisamos que o aluno apenas imite os resultados de um modelo maior. Em outro caso, queremos incutir a abordagem de solução de problemas do professor no modelo menor. Em última análise, o objetivo é se beneficiar dos recursos de um modelo grande, usando um modelo eficiente.

Destilação de conhecimento

Um método comum de transferência de conhecimento de um modelo de "professor" para um modelo de "aluno" é o ajuste fino do aluno em um conjunto de dados que consiste em entradas e suas saídas correspondentes geradas pelo professor.

Durante essa aprendizado supervisionado Durante esse processo de aprendizado supervisionado, o modelo do aluno aprende a replicar as respostas do professor quando recebe entradas semelhantes.

Benefícios da destilação de modelos

O processo de destilação tem muitas vantagens:

• Custo reduzido: Os modelos menores são mais baratos de usar.
• Resposta mais rápida: A experiência do usuário é aprimorada pelos resultados mais rápidos gerados pelos modelos pequenos.
• Acessibilidade: O modelo pode ser usado em ambientes com recursos computacionais limitados, como plataformas de borda ou dispositivos móveis.

Para saber mais sobre destilação, você pode ler este artigo: Explicação sobre a destilação do LLM.

Como implementar a destilação de modelos com a API OpenAI

Nesta seção, exploraremos um exemplo de destilação de modelos utilizando a plataforma OpenAI. Nosso foco principal será a geração de comandos Git para uma solicitação do usuário.

Primeiro, criaremos um conjunto de dados do pequeno GPT-4o mini (estudante) da OpenAI e avaliaremos os resultados.

Em seguida, usamos o GPT-4o (professor) para traduzir as mesmas frases e ajustar o modelo do aluno no conjunto de dados produzido pelo professor.

Por fim, precisamos avaliar o modelo do aluno e avaliar o aprimoramento.

Em resumo, aqui estão as etapas que vamos seguir:

1. Selecione os modelos de professor e aluno
2. Prepare seu conjunto de dados
3. Gerar pares de entrada/saída para o aluno
4. Avaliar o desempenho do aluno
5. Gerar pares de entrada/saída para o professor
6. Faça o ajuste fino do aluno no conjunto de dados do professor
7. Avalie o modelo de ajuste fino

Etapa 1: Selecione os modelos de professor e aluno

A primeira etapa da destilação de modelos é selecionar o professor e o aluno, o que é determinado pela tarefa pretendida e pelo seu orçamento computacional.

Ao trabalhar com modelos de código aberto, há uma variedade de LLMs com diferentes recursos e tamanhos. Com a plataforma da OpenAI, as opções são limitadas.

Para o propósito de nosso exemplo, selecionaremos GPT-4o mini como o modelo de aluno menor e o GPT-4o como o modelo do professor.

O GPT-4o-mini é um modelo relativamente pequeno e um bom candidato para a função de estudante. O GPT-4o é relativamente maior, mas muito mais capaz e pode funcionar como um professor eficiente para o aluno.

Existem outras opções, e a alteração dos modelos exigiria um esforço mínimo em nosso projeto de destilação de modelos.

Etapa 2: Prepare seu conjunto de dados

Seu conjunto de dados para essa tarefa deve ser desafiador o suficiente para o modelo do aluno, mas não tão desafiador para o professor. As qualidades de um bom conjunto de dados, como diversidade, representatividade ou precisão, ainda são relevantes na destilação de modelos.

É muito importante ter um conjunto de dados grande o suficiente para afetar o modelo do aluno. Não há uma resposta direta para "Qual deve ser o tamanho do conjunto de dados de destilação?", pois isso depende da complexidade da sua tarefa-alvo e dos modelos que você selecionou como professor e aluno.

De acordo com a documentação da documentação da OpenAIembora algumas centenas de amostras possam ser suficientes, um grupo mais diversificado de milhares de amostras pode, às vezes, levar a melhores resultados.

Nosso conjunto de dados neste artigo é composto de 386 solicitações de usuários armazenadas em um arquivo JSON (você poderia armazená-las na forma de uma lista Python da mesma forma).

{    
    "requests": [
      "Initialize a new Git repository in the current directory.",
      "Clone the repository from GitHub to my local machine.",
      "Create a new branch called 'feature-login'.",
			...
      "Show the differences between the working directory and the staging area.",
      "Stage all modified and deleted files for commit.",
      ]
}

Etapa 3: Gerar pares de entrada/saída para o aluno (opcional)

Atualmente, nosso conjunto de dados consiste apenas em entradas, e devemos gerar saídas também. Os resultados do aluno não são necessários para a destilação, mas precisamos deles para obter uma linha de base para a precisão do modelo do aluno (etapa 4).

Usamos o código abaixo para iterar sobre o conjunto de dados de entrada e gerar uma saída para cada um deles:

def generate_responses():
    with open(JSON_PATH, 'r') as file:
        user_messages = json.load(file)
    
    for sentence in user_messages['requests']:
        # Call the OpenAI model gpt-4o-mini and store the response
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[
                {"role": "system", "content": system_prompt},
                {
                    "role": "user",
                    "content": sentence
                },
            ],
            store=True,
            metadata={
                "task": "git"
            }
        )

generate_responses()

Observe que usamos store=True ao chamar o modelo da OpenAI. Esse argumento salvará os pares de entrada/saída em nosso painel do OpenAI, de modo que não precisaremos armazenar as saídas usando código.

Para identificar e filtrar posteriormente essas conclusões de bate-papo, não se esqueça de incluir metadados ao chamar a função client.chat.completions.create. Os argumentos para esses metadados são arbitrários.

Os resultados gerados podem ser encontrados na página Conclusões de bate-papo do nosso painel do OpenAI.

Etapa 4: Avaliar o desempenho do aluno (opcional)

Outra ferramenta da OpenAI que é útil para a destilação de modelos é a Avaliações da OpenAI. Usamos essa ferramenta para avaliar o desempenho do modelo do aluno antes do treinamento como uma métrica de linha de base. Também o usaremos mais tarde quando avaliarmos o modelo de aluno ajustado.

Depois de filtrar as conclusões do bate-papo da etapa anterior, c lique no botãoEvaluate (Avaliar ). Agora precisamos adicionar critérios de teste.

Há uma variedade de métodos para avaliar os pares de entrada/saída. Observe que nosso conjunto de dados atual é gerado automaticamente pelas conclusões de bate-papo da OpenAI e contém apenas as entradas e saídas. No entanto, alguns desses critérios também exigem umareferência para comparação.

Essa referência poderia ser os resultados gerados por um modelo mais sofisticado, como o GPT-4o ou o o1-preview. Como o armazenamento automático dos bate-papos na OpenAI não nos permite fornecer essa referência, estamos limitados a usar os métodos Criteria match ou Custom prompt, que precisam apenas de uma entrada e uma saída.

Se precisar usar outros métodos, você não poderá usar as conclusões de bate-papo da OpenAI e deverá criar seu arquivoJSON com código. Isso não é complicado, mas não entraremos em detalhes neste artigo.

Depois de executar as avaliações, você receberá os resultados em breve.

Etapa 5: Gerar pares de entrada/saída para o professor

Para fazer o ajuste fino do modelo do aluno, precisamos de um conjunto de dados de alta qualidade gerado pelo professor. Esta etapa é quase igual à etapa 3 - você só precisa alterar o argumento model de gpt-4o-mini para gpt-4o.

Etapa 6: Ajuste fino do aluno

Novamente, nas Conclusões de bate-papo, filtre pelo modelo do professor e pelos metadados. Em seguida, selecione o botão Distill. O distill da OpenAI é essencialmente a ferramenta de ajuste fino.

Para o modelo básico, selecionamos o aluno. Os hiperparâmetros precisam ser experimentados e testados para que você obtenha os melhores resultados - definidos como automáticos. Por fim, selecione Create e aguarde até que o ajuste fino seja concluído.

Etapa 7: Avalie o modelo de ajuste fino

Quando terminar, usaremos o código da etapa 3 novamente, desta vez usando o modelo ajustado como o argumento model. O nome do modelo ajustado é exibido como o "Modelo de saída" na página de ajuste fino.

def generate_responses():
    with open(JSON_PATH, 'r') as file:
        user_messages = json.load(file)

    for sentence in user_messages['requests']:
        # Call the OpenAI model gpt-4o-mini and store the response
        response = client.chat.completions.create(
            model="ft:gpt-4o-mini-2024-07-18:personal:git:AF7QSF0m",
            messages=[
                {"role": "system", "content": system_prompt},
                {
                    "role": "user",
                    "content": sentence
                },
            ],
            store=True,
            metadata={
                "task": "git"
            }
        )

generate_responses()

Depois de terminar de gerar os resultados, use as avaliações para avaliar a capacidade de seu novo modelo nos inputs.

Conclusão

A receita de destilação da OpenAI é simples, mas direta. É especialmente útil porque você não precisará se preocupar com o ajuste fino dos modelos ou com o uso de código para avaliar os resultados.

Os modelos da OpenAI, mesmo os menores, já são bastante sofisticados. Certifique-se de experimentar os hiperparâmetros antes de fazer o ajuste fino do modelo, preparar prompts adequados e desafiadores para o professor e o aluno e comparar a avaliação ajustada com a avaliação de linha de base.

Antes de colocar a mão na massa com sua própria destilação de modelos, aconselho você a ler estes dois recursos da OpenAI: Destilação de modelos da OpenAI na API e Documento de destilação de modelos.