As 6 Melhores Ferramentas de Fine Tuning Para Treinamento de Modelos em 2026

Introdução

Ajuste fino é uma técnica utilizada em aprendizado de máquina, especialmente em aprendizado profundo, onde um modelo pré-treinado é treinado ou "ajustado" adicionalmente em um conjunto de dados menor e específico, adaptado a uma tarefa particular. 

Suponha que você esteja desenvolvendo um modelo que gera manuais técnicos para eletrônicos usando GPT-3 (um modelo de linguagem grande com 175 bilhões de parâmetros), mas a saída genérica do GPT-3 não está atendendo à precisão técnica e ao tom exigidos.

Neste caso, você pode pensar em retreinar o modelo para o seu caso de uso específico, mas treinar diretamente um modelo como o GPT-3 do zero para abordar esta tarefa de nicho é impraticável devido à exigência de recursos computacionais e dados especializados. 

É aqui que o ajuste fino entra em jogo.

O ajuste fino é como ensinar um truque novo ao GPT-3. Ele já sabe muito sobre linguagens graças ao seu treinamento em inúmeros textos, de livros a websites. Seu trabalho é treiná-lo adicionalmente em um conjunto de dados direcionado — neste caso, um corpus de manuais técnicos e documentação existentes específicos para eletrônicos.

Alguns métodos básicos de ajuste fino:

1. Congelamento de Camadas: Congelar seletivamente os pesos de certas camadas, permitindo que outras se atualizem durante o processo de ajuste fino.
2. Ajuste da Taxa de Aprendizagem: Ajustar a taxa na qual o modelo aprende durante o processo de ajuste fino, tipicamente para evitar a sobrescrita de conhecimento pré-aprendido valioso.
3. Adição de Camadas Específicas para a Tarefa: Isso envolve estender a arquitetura do modelo com novas camadas que são diretamente treinadas para a tarefa.

‍

Ajuste Fino Eficiente em Parâmetros

Ajuste Fino Eficiente em Parâmetros (PEFT) é uma técnica que visa minimizar o número de parâmetros adicionais necessários durante o ajuste fino de modelos de redes neurais pré-treinados,

Isso ajuda a reduzir os custos computacionais e o uso de memória, enquanto ainda mantém ou até melhora o desempenho. O PEFT consegue isso adicionando embeddings de prompt como parâmetros extras do modelo e ajustando apenas um pequeno número de parâmetros extras. 

O PEFT também requer um conjunto de dados muito menor em comparação com o ajuste fino tradicional.

‍

Etapas para realizar o PEFT

1. Carregando o modelo escolhido

Carregue o modelo escolhido usando um framework de aprendizado de máquina como TensorFlow, PyTorch ou a biblioteca Transformers da Hugging Face. Esses frameworks fornecem APIs para baixar e carregar modelos pré-treinados facilmente.

Aqui está um exemplo de código:

from transformers import GPT2Model, GPT2Tokenizer
model_name = 'gpt2-medium'  # Choose the model variant
tokenizer = GPT2Tokenizer.from_pretrained(model_name)
model = GPT2Model.from_pretrained(model_name)

2. Engenharia de Prompts

Antes do ajuste fino, você deve experimentar diferentes prompts para guiar as respostas do modelo. Teste vários prompts com o modelo pré-treinado para ver como eles afetam a saída e escolha o mais apropriado. Você também pode alterar diferentes parâmetros como max_length, temperature, etc.

É como descobrir a melhor forma de fazer sua pergunta para que o modelo entenda o que você quer.

from transformers import pipeline

generator = pipeline('text-generation', model='gpt2')

prompt = """"""

# Generate responses
responses = generator(prompt, max_length=200, num_return_sequences=3)

for i, response in enumerate(responses):
    print(f"Response {i+1}: {response['generated_text']}")

3. Conjunto de Dados

Em um conjunto de dados para ajuste fino, existem tipicamente duas partes: Prompt (Entrada) e Resposta (Saída). O Prompt é como uma pergunta ou um ponto de partida, e a Resposta é o que você deseja que o modelo gere em resposta a essa pergunta. Pode ser na forma de colunas ou uma sequência de entradas de texto (mais comum).

O melhor prompt identificado na etapa anterior será usado aqui e a Resposta será exatamente o que queremos que o modelo produza quando receber esse Prompt. 

4. Ajuste Fino do Modelo

É aqui que você ensina o modelo a melhorar em sua tarefa. Você usará o conjunto de dados para ajustar ligeiramente o “conhecimento” do modelo. 

Aqui está uma visão geral simplificada de como configurar e executar o processo de ajuste fino com PyTorch:

• Configuração para Treinamento:

from transformers import AdamW

optimizer = AdamW(model.parameters(), lr=5e-5) # lr é a taxa de aprendizado

• Loop de Treinamento:

for epoch in range(total_epochs):
    for batch in data_loader:
        inputs, labels = batch
        outputs = model(**inputs)
        loss = outputs.loss
        loss.backward()
        optimizer.step()
        optimizer.zero_grad() 

Ferramentas para Ajuste Fino

Ao explorar ferramentas para engenharia de prompts, é útil categorizá-las em dois domínios principais: Plataformas de Código e Plataformas No-Code. Essa distinção simplifica o processo de seleção
Plataformas de Código referem-se a plataformas que fornecem máquinas virtuais que podem ser usadas para executar seu script Python personalizado para ajuste fino, como o mencionado anteriormente. Enquanto isso, Plataformas No-Code referem-se a ferramentas que exigem um script Python simples ou nenhum script para funcionar. Elas possuem uma interface de usuário dedicada onde você pode iniciar o treinamento com apenas alguns cliques.

Plataformas No-Code:

Plataformas no-code, por outro lado, são projetadas para simplicidade e facilidade de uso. Elas eliminam a necessidade de escrever scripts Python, oferecendo uma interface de usuário intuitiva onde o treinamento pode ser iniciado com apenas alguns cliques. Este domínio é adequado para usuários sem conhecimento de programação ou para aqueles que preferem uma abordagem direta à engenharia de prompts.

1. TrueFoundry

TrueFoundry é uma ferramenta que ajuda as equipes de ML a colocar seus modelos em funcionamento sem problemas. É construída sobre Kubernetes, o que significa que pode ser executada em diferentes nuvens ou até mesmo em seus próprios servidores. Isso é importante para empresas preocupadas em manter seus dados seguros e controlar custos

Para o ajuste fino (fine-tuning), é uma das melhores ferramentas disponíveis, atendendo tanto a iniciantes quanto a especialistas. Aqui você tem duas opções: implantar um notebook de ajuste fino para experimentação ou iniciar um trabalho de ajuste fino dedicado.

1. Notebooks: Campo de Experimentação

Notebooks oferecem uma configuração ideal para ajuste fino exploratório e iterativo. Você pode experimentar em um pequeno subconjunto de dados, testando diferentes hiperparâmetros para descobrir a configuração ideal para o melhor desempenho.

2. Trabalhos: Confiáveis e Escaláveis

Depois de identificar os hiperparâmetros e a configuração ideais por meio da experimentação, a transição para um trabalho de implantação ajuda a realizar o ajuste fino em todo o conjunto de dados e facilita um treinamento rápido e confiável.

Portanto, notebooks são fortemente recomendados para exploração inicial e ajuste de hiperparâmetros, e os trabalhos de implantação são a escolha preferida para o ajuste fino de LLMs em larga escala, especialmente quando a configuração ideal foi estabelecida por meio de experimentação prévia.

Aqui está um guia passo a passo para realizar o ajuste fino usando Notebook e Trabalhos:

1. Configurando os Dados de Treinamento

Truefoundry suporta dois formatos de dados diferentes:

1. Chat: Os dados precisam estar no formato JSONL, com cada linha contendo uma conversa completa no formato OpenAI Chat.

Cada linha contém uma chave chamada messages. Cada chave de mensagem contém uma lista de mensagens, onde cada mensagem é um dicionário com as chaves role e content. A chave role pode ser user, assistant ou system, e a chave content contém o conteúdo da mensagem.

2. Conclusão: Os dados precisam estar no formato JSONL, com cada linha contendo uma string codificada em JSON que contém duas chaves: prompt e completion.

{"prompt": "What is 2 + 2?", "completion": "The answer to 2 + 2 is 4"}
{"prompt": "Flip a coin", "completion": "I flipped a coin and the result is heads!"}
{"prompt": "", "completion": ""}

2. Ajuste Fino

Você pode iniciar o ajuste fino com apenas três cliques:

1. Selecione o espaço de trabalho onde você deseja trabalhar
2. Escolha o modelo:

Você pode escolher um modelo da lista abrangente disponível ou simplesmente colar o URL do Hugging Face para iniciar o ajuste fino.

3. Clique em Próximo

Agora, após selecionar a GPU desejada, você tem duas opções: Executar como notebook ou como Job.

3. Ajuste Fino usando um Notebook

Após escolher ‘Launch as Notebook’ e selecionar os valores padrão para os hiperparâmetros, você pode ver seu notebook:

4. Ajuste Fino como Job:

Antes de começar, você precisará primeiro criar um ML Repo (este será usado para armazenar suas métricas de treinamento e artefatos, como seus checkpoints e modelos) e conceder acesso ao seu workspace ao ML Repo. Você pode ler mais sobre Repositórios ML na documentação da Truefoundry.

Agora você deve escolher ‘Launch as Job’ e selecionar os valores padrão dos hiperparâmetros para iniciar o ajuste fino.

Dentro dos deployments você pode ver o job listado e clicar em 'run job'.

Principais Recursos:

• Suporte para LLMs Populares: Permite o ajuste fino de LLMs de código aberto amplamente utilizados, como Llama 2, Mistral, Zephyr e Mixtral.
• Flexibilidade na Abordagem de Ajuste Fino: Oferece a opção de ajustar LLMs usando Jobs para escalabilidade e confiabilidade ou Notebooks para experimentação e ajuste iterativo.
• Técnica QLoRA: Emprega a técnica de ajuste fino QLoRA, que equilibra eficiência com desempenho, permitindo o ajuste fino em hardware menos potente sem comprometer a qualidade.
• Suporte a Formato de Dados: Suporta dados no formato jsonl, atendendo a conjuntos de dados do tipo chat e completion, facilitando uma variedade de aplicações de LLM.
• Fácil Integração de Dados: Oferece opções para carregar dados de treinamento como um artefato TrueFoundry, para serviços de armazenamento em nuvem, ou localmente, proporcionando flexibilidade no gerenciamento de dados.
• Suporte a Implantação: Após o ajuste fino, guias sobre a implantação do modelo ajustado para aplicação prática estão disponíveis, aumentando a utilidade do modelo.
• Integração com Repositório ML: Permite o acompanhamento do progresso do ajuste fino e o gerenciamento de métricas/artefatos de treinamento através de Repositórios ML, garantindo um desenvolvimento de modelo organizado e acessível.

2. API da OpenAI

A API da OpenAI fornece acesso a modelos avançados de inteligência artificial desenvolvidos pela OpenAI, incluindo as versões mais recentes do GPT (Generative Pre-trained Transformer). Uma das características marcantes da API da OpenAI é sua capacidade de ajustar modelos em conjuntos de dados personalizados.

Assim, você pode adaptar o comportamento de modelos como o GPT-3 ou versões mais recentes para aplicações específicas ou para aderir a estilos e preferências de conteúdo particulares.

Como estou me referindo à API, não é exatamente "No-Code", mas ainda assim é fácil configurá-la para treinamento em comparação com outras ferramentas da seção anterior.

Exemplo de Código para Fine-Tuning:

‍

1. Preparando Seu Conjunto de Dados

Para fazer o fine-tuning de um modelo, você primeiro precisa preparar seu conjunto de dados em um formato que a API da OpenAI possa entender. Tipicamente, você teria que criar um arquivo JSON que se parece com isto:

{"prompt": "The capital of France is", "completion": " Paris"}
{"prompt": "The largest planet in the solar system is", "completion": " Jupiter"}

2. Carregando Seu Conjunto de Dados para a OpenAI

Você pode facilmente carregar o conjunto de dados usando a CLI (Interface de Linha de Comando) da OpenAI. 

openai tools fine_tunes.prepare_data -f your_dataset.jsonl

3. Fine-Tuning do Modelo

Uma vez que seu conjunto de dados esteja preparado e carregado, você pode iniciar um processo de fine-tuning. O seguinte é um exemplo usando a biblioteca Python da OpenAI:

import openai

openai.api_key = "your-api-key"

response = openai.FineTune.create(
  training_file="file-YourFileIDHere",
  model="gpt-3.5-turbo",
  n_epochs=4,
  learning_rate_multiplier=0.1,
  batch_size=4
)

4. Usando Seu Modelo com Fine-Tuning

Após a conclusão do processo de fine-tuning, você pode usar seu modelo com fine-tuning para gerar texto ou outras tarefas, especificando o ID do modelo com fine-tuning:

response = openai.Completion.create(
  model="YOUR_FINE_TUNED_MODEL_ID",
  prompt="The capital of Italy is",
  max_tokens=50
)
print(response.choices[0].text.strip())

Você também pode implantar seu modelo com fine-tuning.

Principais Recursos:

• Facilidade de Uso: A API simplifica as interações com modelos de IA poderosos, eliminando as complexidades de gerenciar ou treinar diretamente grandes redes neurais.
• Escalabilidade: A OpenAI gerencia a infraestrutura e o dimensionamento, proporcionando desempenho consistente independentemente da carga de trabalho.
• Atualizações Contínuas: A OpenAI atualiza frequentemente sua API e modelos, dando aos usuários acesso aos mais recentes avanços na pesquisa de IA.

3. Microsoft Azure

Microsoft Azure é uma plataforma de computação em nuvem que oferece uma ampla gama de serviços, incluindo computação, armazenamento, análise e muito mais. Ela fornece aos usuários as ferramentas para construir, implantar e gerenciar aplicativos de forma eficiente. 

Uma característica notável é sua interface intuitiva, facilitando a navegação para iniciantes sem a necessidade de conhecimento aprofundado em codificação. Com simples cliques, em vez de codificação complexa, os usuários podem ajustar suas aplicações, tornando o Azure uma ferramenta acessível para um desenvolvimento sem estresse.

Aqui está um guia simples sobre como configurar uma tarefa de ajuste fino no Azure:

1. Preparando seus dados:

Obviamente, este é o requisito básico para todas as ferramentas. Os dados de treinamento podem estar no formato JSON Lines (JSONL), CSV ou TSV. Os requisitos dos seus dados variam com base na tarefa específica para a qual você pretende ajustar seu modelo.

Para classificação de texto:
Duas colunas: Frase (string) e Rótulo (inteiro/string)

2. Escolha um modelo base

3. Configure uma tarefa de ajuste fino: 

Após enviar a tarefa de ajuste fino, um trabalho de pipeline será criado para treinar seu modelo. Você pode revisar todas as entradas e coletar o modelo a partir das saídas do trabalho.

4. Avalie seu modelo ajustado

Para decidir se o seu modelo ajustado tem o desempenho esperado, você pode revisar as métricas de treinamento e avaliação.

Principais Recursos:

• Interface Amigável: A interface fácil de usar do Azure simplifica a navegação para iniciantes.
• Opções Sem Código: O ajuste fino não exige codificação extensa; os usuários podem realizar tarefas com simples cliques.
• Escalabilidade: As aplicações podem ser facilmente escaladas para cima ou para baixo para atender às demandas em constante mudança.
• Serviços Abrangentes: O Azure oferece uma variedade de ferramentas para ajuste fino, incluindo recursos de análise e monitoramento.
• Integração: Integra-se perfeitamente com ferramentas da Microsoft e de terceiros para flexibilidade nos fluxos de trabalho.

4. Replicate

Replicate é uma ferramenta versátil projetada para o ajuste fino de vários aspectos de aplicações de software. As aplicações do Replicate como ferramenta de ajuste fino incluem otimização de desempenho, ajuste de configurações e aprimoramento de funcionalidades com esforço mínimo. Ele simplifica o processo ao lidar com a configuração da GPU. Semelhante à API da OpenAI, não é exatamente "Sem Código" como outras ferramentas da lista, mas ainda assim é fácil configurá-lo para treinamento em comparação com outras ferramentas da seção anterior.

Passos para o Ajuste Fino do llama-2b:

1. Prepare os Seus Dados de Treino

Os seus dados de treino precisam estar no formato JSONL. Abaixo, encontra-se um exemplo de como poderá estruturar este ficheiro:

{"prompt": "What's the weather like?", "completion": "The weather is sunny."}
{"prompt": "Tell me a joke.", "completion": "Why don't scientists trust atoms? Because they make up everything!"}

2. Autenticar com o Replicate

Precisa de definir o seu token de API do Replicate como uma variável de ambiente no seu terminal:

export REPLICATE_API_TOKEN=<your-token-here>

3. Carregue os Seus Dados de Treino

Pode carregar os seus dados para um bucket s3 ou diretamente no Replicate usando comandos curl:

4. Criar um Modelo no Replicate

Precisa de criar um modelo vazio no Replicate para o seu modelo treinado. Quando o seu treino terminar, este será enviado como uma nova versão para este modelo.

5. Criar um Trabalho de Treino

Precisa de criar um Trabalho de treino na sua IDE, como mostrado abaixo:

import replicate

training = replicate.trainings.create(
  version="meta/llama-2-7b:version-id", # Replace "version-id" with the actual version ID of the model you chose
  input={
    "train_data": "https://yourdata.com/data.jsonl", # Use your actual data URL here
    "num_train_epochs": 3
  },
  destination="your-username/your-model-name" # Use your actual username and model name here
)

print(training)

6. Monitorizar o Progresso do Treino

Para monitorizar o progresso programaticamente, pode usar:

training.reload()
print(training.status)

7. Executar o Seu Modelo Ajustado

Após a conclusão do treino, pode executar o seu modelo com a API:

output = replicate.predictions.create(
  version=training.output["version"], # Use the version output from your training
  input={"prompt": "Your prompt here"}
)

print(output)

Principais Funcionalidades:

• Facilidade de Uso: Simplifica o processo de ajuste fino com uma interface amigável e uma API direta, tornando-o acessível tanto para iniciantes quanto para profissionais experientes.
• Treino Baseado na Nuvem: Elimina a necessidade de recursos de GPU locais ao oferecer treino baseado na nuvem, permitindo que os utilizadores treinem modelos independentemente do seu hardware.
• Entrada de Dados Flexível: Suporta o formato JSONL para dados de treino, permitindo uma entrada flexível e estruturada para uma variedade de tarefas.
• Alojamento de Modelos: Alojamento automático de modelos ajustados, permitindo fácil integração e implementação de modelos de IA em aplicações.
• Controle de Versão: Acompanha diferentes versões de treinamento, facilitando o gerenciamento, comparação e reversão para versões anteriores de um modelo.

‍

5. Google Gen AI Studio

No Gen AI Studio, você tem ambas as opções para configurar trabalhos de ajuste fino, via API ou pelo site; aqui, falarei apenas sobre o método da API. Ele possui o processo mais simplificado em comparação com as ferramentas discutidas anteriormente.

Aqui está um guia passo a passo:

1. Prepare Seu Conjunto de Dados

Seu conjunto de dados deve estar no formato JSONL, com cada linha sendo um objeto JSON com as chaves "input_text" e "output_text". Ele pode começar o treinamento com apenas 10 exemplos, mas pelo menos 100 exemplos são recomendados.

2. Faça o Upload do Seu Conjunto de Dados

Você deve fazer o upload do seu conjunto de dados para um bucket do Google Cloud Storage (GCS); se não tiver um, pode criar um no Google Drive.

3. Autenticação e Inicialização

Agora você precisa fornecer suas credenciais para estabelecer a conexão:

from google.auth import default
from google.cloud import aiplatform
from vertexai import init

credentials, _ = default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
project_id = "your-project-id"
location = "your-project-location" # e.g., "us-central1"
init(project=project_id, location=location, credentials=credentials)

4. Prepare a Função de Ajuste

Você precisa definir uma função para o ajuste com os parâmetros necessários.

from vertexai.language_models import TextGenerationModel
from vertexai.preview.language_models import TuningEvaluationSpec

def tuning(project_id, location, model_display_name, training_data, train_steps=10, evaluation_dataset=None, tensorboard_instance_name=None):
    eval_spec = TuningEvaluationSpec(evaluation_data=evaluation_dataset)
    if tensorboard_instance_name:
        eval_spec.tensorboard = aiplatform.Tensorboard(tensorboard_name=tensorboard_instance_name)
    model = TextGenerationModel.from_pretrained("text-bison@002")

    model.tune_model(
        training_data=training_data,
        model_display_name=model_display_name,
        train_steps=train_steps,
        tuning_job_location="europe-west4",
        tuned_model_location=location,
        tuning_evaluation_spec=eval_spec,
    )
    print(model._job.status)
    return model

5. Execute o Ajuste do Modelo

Chame a função de ajuste especificada anteriormente, com seus parâmetros específicos. O parâmetro training_data pode ser um URI do GCS ou um pandas DataFrame.

Principais Recursos:

1. Disponibilidade de Acesso via API e Interface de Usuário: Para aqueles que preferem uma abordagem gráfica, o Gen AI Studio oferece uma interface de usuário intuitiva.
2. Infraestrutura Escalável: Aproveite a infraestrutura escalável do Google Cloud para lidar com grandes conjuntos de dados e trabalhos de ajuste computacionalmente intensivos de forma eficiente.
3. Integração com Serviços Google Cloud: Integração perfeita com outros serviços Google Cloud, como Cloud Storage para gerenciamento de conjuntos de dados e Vertex AI para implantação de modelos.
4. Ampla Gama de Modelos Pré-Treinados: Acesse uma variedade de modelos pré-treinados adequados para diferentes tarefas e idiomas, oferecendo um sólido ponto de partida para o ajuste fino.
5. Colaboração e Controle de Versão: Recursos para colaborar com membros da equipe, compartilhar projetos de ajuste fino e manter o controle de versão sobre modelos ajustados.

6. Predibase

Predibase é uma plataforma especializada projetada para facilitar o ajuste fino de grandes modelos de linguagem (LLMs), como o GPT-4, para tarefas ou aplicações específicas. Ela oferece acesso às capacidades avançadas dos LLMs, fornecendo um ambiente simplificado e fácil de usar para personalizar esses modelos de acordo com as necessidades individuais.

O Predibase oferece a opção de usar tanto o SDK Python quanto a interface de usuário (UI) para realizar trabalhos de ajuste fino.

Aqui está um guia passo a passo para ajustar o mistral-7b-instruct:

1. Configuração Básica

Primeiro, crie uma conta no Predibase e faça um depósito para adicionar créditos. Em seguida, gere sua Chave de API.

2. Criando Repositório de Modelos

Vá para Modelos e clique em “Novo Repositório de Modelos”, conforme mostrado abaixo:

Agora, nomeie seu repositório e adicione uma descrição.

3. Iniciar Ajuste Fino:

Preencha as áreas destacadas e depois clique em treinar. Isso colocará sua solicitação na fila até que haja um recurso de computação disponível.

Plataformas de Código:

As Plataformas de Código são projetadas para usuários com uma sólida formação em programação. Essas plataformas fornecem máquinas virtuais que permitem a execução de scripts Python personalizados para tarefas como ajuste fino. Essas plataformas são perfeitas para projetos que exigem alta personalização e controle intrincado sobre as fases de treinamento e implantação.

1. Amazon Sagemaker:

Amazon SageMaker é um serviço totalmente gerenciado que oferece a desenvolvedores e cientistas de dados a capacidade de construir, treinar e implantar modelos de aprendizado de máquina rapidamente.

O Amazon SageMaker não possui um recurso de "ajuste fino" dedicado e integrado, especificamente rotulado como tal para grandes modelos de linguagem. Em vez disso, ele oferece uma plataforma poderosa e flexível que permite executar scripts Python personalizados para realizar tarefas de ajuste fino.

Aqui está um exemplo simples de como você pode iniciar um trabalho de ajuste fino para um modelo de linguagem com Hugging Face no SageMaker. Isso pressupõe que você já configurou uma conta AWS e o AWS CLI. (você pode usar TensorFlow ou PyTorch diretamente no Amazon SageMaker para tarefas de ajuste fino)

1. Configurar e Inicializar Sessão do SageMaker:

import sagemaker
from sagemaker.huggingface import HuggingFace

# Initialize a sagemaker session
sagemaker_session = sagemaker.Session()

# Set up the role for SageMaker
role = sagemaker.get_execution_role()

2. Prepare o Script de Ajuste Fino:

Normalmente, você escreveria um script de ajuste fino (train.py) que você passa para o estimador. Este script deve incluir sua lógica de carregamento, ajuste fino e salvamento do modelo.

# Define hyperparameters (if any), model name, and fine-tuning script
hyperparameters = {'epochs': 3, 'train_batch_size': 16, 'model_name': 'distilbert-base-uncased'}

huggingface_estimator = HuggingFace(
    entry_point='train.py',          # Your script name
    instance_type='ml.p3.2xlarge',   # Training instance type
    instance_count=1,                # Number of instances
    role=role,                       # IAM role with permissions
    transformers_version='4.6.1',    # Transformers library version
    pytorch_version='1.7.1',         # PyTorch library version
    py_version='py36',               # Python version
    hyperparameters=hyperparameters)

3. Crie um Estimador Hugging Face:

# Define hyperparameters (if any), model name, and fine-tuning script
hyperparameters = {'epochs': 3, 'train_batch_size': 16, 'model_name': 'distilbert-base-uncased'}

huggingface_estimator = HuggingFace(
    entry_point='train.py',          # Your script name
    instance_type='ml.p3.2xlarge',   # Training instance type
    instance_count=1,                # Number of instances
    role=role,                       # IAM role with permissions
    transformers_version='4.6.1',    # Transformers library version
    pytorch_version='1.7.1',         # PyTorch library version
    py_version='py36',               # Python version
    hyperparameters=hyperparameters
)

4. Inicie o Trabalho de Treinamento:

# Assuming you have your training data in an S3 bucket
data = {'train': 's3://your-bucket/train-dataset/', 'test': 's3://your-bucket/test-dataset/'}

# Fit the model
huggingface_estimator.fit(data)

Principais Recursos:

1. Algoritmos pré-construídos e suporte para frameworks populares: O SageMaker suporta TensorFlow, PyTorch, Hugging Face e outros, facilitando o ajuste fino de LLMs em conjuntos de dados personalizados.
2. Treinamento Spot Gerenciado: Ele reduz o custo de treinamento de modelos usando instâncias spot do Amazon EC2.
3. Treinamento Distribuído: O SageMaker simplifica o treinamento de modelos de forma mais rápida e econômica, distribuindo o trabalho de treinamento por várias GPUs ou instâncias.

2. Google Colab:

O Google Colab é um serviço popular de notebook Jupyter baseado em nuvem que oferece acesso gratuito a recursos de computação, incluindo GPUs e TPUs, tornando-o uma excelente plataforma para o ajuste fino de grandes modelos de linguagem (LLMs)

É particularmente amigável para iniciantes. Os notebooks do Colab são executados na nuvem, diretamente do seu navegador, sem exigir nenhuma configuração local.

Aqui está o trecho de código simples para ajustar um Modelo Transformer com Hugging Face Transformers e PyTorch no Google Colab

1. Configurando o Ambiente:

!pip install torch torchvision transformers

2. Carregando um Modelo Pré-treinado e um Tokenizador:

from transformers import BertTokenizer, BertForSequenceClassification
from transformers import AdamW

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')

# Prepare the model for training
model.train()

3. Ajustando o Modelo:  (assumindo que você tenha um conjunto de dados carregado nas variáveis input_ids, attention_masks e labels)

from torch.utils.data import DataLoader, RandomSampler, TensorDataset

# Create a data loader
dataset = TensorDataset(input_ids, attention_masks, labels)
dataloader = DataLoader(dataset, sampler=RandomSampler(dataset), batch_size=32)

optimizer = AdamW(model.parameters(), lr=2e-5)

# Example training loop
for epoch in range(4):  # loop over the dataset multiple times
    for step, batch in enumerate(dataloader):
        batch = [r.to('cuda') for r in batch]  # Move batch to GPU
        b_input_ids, b_input_mask, b_labels = batch

        # Forward + backward + optimize
        outputs = model(b_input_ids, token_type_ids=None, attention_mask=b_input_mask, labels=b_labels)
        loss = outputs[0]
        loss.backward()
        optimizer.step()
        optimizer.zero_grad()

4. Salvando o Modelo:

model.save_pretrained("/content/drive/My Drive/Colab Models/my_finetuned_model")

Principais Recursos:

1. Acesso Gratuito a GPUs/TPUs: O Colab oferece acesso gratuito a GPUs NVIDIA e TPUs do Google, o que pode acelerar significativamente o treinamento e o ajuste fino de modelos de aprendizado de máquina.
2. Integração com o Google Drive: Armazene e acesse facilmente seus conjuntos de dados e modelos diretamente do Google Drive, facilitando o manuseio de dados e o salvamento de modelos.
3. Bibliotecas Pré-instaladas: O Colab vem com a maioria das bibliotecas de ciência de dados e aprendizado de máquina pré-instaladas, incluindo TensorFlow, PyTorch, Hugging Face Transformers e muitas outras, facilitando o início imediato do ajuste fino de modelos.
4. Ambiente Interativo: A interface do notebook permite o desenvolvimento e a documentação interativos, combinando código ao vivo, visualizações e anotações de texto.

3. Paperspace Gradient

Paperspace Gradient é um conjunto de ferramentas projetado para simplificar o processo de desenvolvimento, treinamento e implantação de modelos de aprendizado de máquina na nuvem.

O Gradient é particularmente eficaz para tarefas como o ajuste fino de grandes modelos de linguagem (LLMs) devido à sua infraestrutura escalável e suporte a contêineres, tornando-o uma excelente escolha para cientistas de dados e profissionais de ML.

Aqui está um exemplo de ajuste fino de um Modelo Transformer com PyTorch no Paperspace Gradient.

1. Carregando um Modelo Pré-treinado e Tokenizador:

from transformers import BertTokenizer, BertForSequenceClassification
import torch

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')

2. Preparando o Conjunto de Dados:

from transformers import TextDatasetForNextSentencePrediction

dataset = TextDatasetForNextSentencePrediction(
    tokenizer=tokenizer,
    file_path="./my_dataset.txt",
    block_size=128
)

3. Ajustando o Modelo:

from torch.utils.data import DataLoader
from transformers import AdamW

dataloader = DataLoader(dataset, shuffle=True, batch_size=8)
optimizer = AdamW(model.parameters(), lr=1e-5)

model.train()
for epoch in range(3):  # Loop over the dataset multiple times
    for batch in dataloader:
        optimizer.zero_grad()
        inputs, labels = batch['input_ids'], batch['labels']
        outputs = model(inputs, labels=labels)
        loss = outputs.loss
        loss.backward()
        optimizer.step()

4. Salvando o Modelo:

model.save_pretrained("./my_finetuned_model")

Principais Recursos:

1. Ambientes Pré-configurados: O Gradient oferece ambientes pré-configurados para TensorFlow, PyTorch, Hugging Face e outros frameworks de aprendizado de máquina, permitindo uma configuração rápida para tarefas de ajuste fino.
2. GPUs Poderosas: O acesso a uma ampla gama de opções de GPU garante que você possa escalar seu poder de computação de acordo com as necessidades do seu projeto, desde opções mais econômicas para experimentos iniciais até GPUs de ponta para sessões de treinamento intensivas.
3. Gradient Notebooks: Um ambiente de codificação interativo semelhante aos Jupyter Notebooks, mas com o benefício adicional de rodar na infraestrutura de nuvem da Paperspace. Isso é ideal para desenvolver, ajustar e experimentar diretamente na nuvem.
4. Tarefas e Fluxos de Trabalho: Automatize seus pipelines de aprendizado de máquina executando tarefas em sequência ou em paralelo, permitindo o treinamento e a implantação eficientes de modelos.

4. Run.ai

Run.AI é uma plataforma projetada para otimizar os recursos de GPU para cargas de trabalho de aprendizado de máquina, facilitando para cientistas de dados e pesquisadores de IA executar e gerenciar modelos de IA complexos, incluindo o ajuste fino de grandes modelos de linguagem (LLMs). 

É baseado em Kubernetes, uma ferramenta que organiza os recursos computacionais de forma eficiente. Assim, facilita a execução de projetos complexos de IA e permite que as equipes desenvolvam seus projetos sem problemas.

Você pode consultar a documentação do Run.AI para obter informações detalhadas, aqui está um exemplo simplificado baseado no fluxo de trabalho geral para o ajuste fino de um modelo como o LLaMA-2 na plataforma Run.AI.

1.  Preparando Seu Ambiente

2. Configurando Seu Projeto e Solicitações de GPU

runai submit my-fine-tuning-job -p my-project --gpu 2 --image my-llama2-fine-tuning-image train.py

3. Escrevendo o Script de Ajuste Fino

Seu script train.py deve incluir a lógica para carregar o LLaMA-2 (ou o modelo escolhido), seu conjunto de dados e executar o processo de ajuste fino. Isso pode envolver o uso de bibliotecas como Hugging Face Transformers para carregamento de modelos e TensorFlow ou PyTorch para o loop de treinamento.

from transformers import LlamaForConditionalGeneration, LlamaTokenizer

# Load model and tokenizer
model = LlamaForConditionalGeneration.from_pretrained('Llama-2-model-name')
tokenizer = LlamaTokenizer.from_pretrained('Llama-2-tokenizer-name')

# Load your dataset, prepare data loaders, define your training loop here #
model.train()


for epoch in range(num_epochs):
    for batch in dataloader:
        # Training loop logic
        pass

# Save your fine-tuned model
model.save_pretrained('./fine-tuned-model')

4. Monitorando e Gerenciando o Trabalho de Treinamento

O Run.AI oferece ferramentas para monitorar o uso da GPU, o progresso dos seus trabalhos de treinamento e gerenciar os recursos computacionais de forma eficaz. Use o painel ou a CLI do Run.AI para acompanhar o status e o desempenho do seu trabalho.

runai list jobs

Este comando lista todos os trabalhos atuais, permitindo que você monitore o progresso e o uso de recursos da sua tarefa de ajuste fino.

Principais Recursos:

1. Otimização de GPU e Alocação Elástica de GPU: Otimiza automaticamente o uso da GPU, melhora a eficiência e aloca dinamicamente os recursos da GPU com base nas demandas da carga de trabalho, reduzindo significativamente os custos.
2. Gerenciamento Simplificado de Recursos: Oferece um painel intuitivo e CLI para gerenciar cargas de trabalho de IA, facilitando o monitoramento e o ajuste do uso de recursos em tempo real.
3. Integração com Frameworks Populares: Suporta frameworks populares de aprendizado de máquina, como TensorFlow, PyTorch e Hugging Face Transformers, facilitando a integração perfeita em fluxos de trabalho existentes.

Escolhendo a Ferramenta Certa para Você:

Facilidade de Uso: Escolha ferramentas que sejam diretas, especialmente se você não é muito fã de codificação. Algumas ferramentas nem sequer exigem que você escreva código!

Escalabilidade: Garantir que a ferramenta possa crescer com o seu projeto, lidando com conjuntos de dados maiores e modelos mais complexos de forma fluida.

Suporte a Modelos e Conjuntos de Dados: Escolha ferramentas que funcionem bem com os tipos específicos de dados e modelos que você está usando.

Recursos Computacionais: Procure acesso a GPUs ou TPUs se o seu projeto precisar de grande poder computacional.

Custo: Considere quanto você está disposto a gastar. Algumas ferramentas são gratuitas; outras cobram com base nos recursos que você utiliza.

Personalização e Controle: Se você domina a programação, pode preferir ferramentas que permitem ajustar tudo.

Integração: É mais fácil se a ferramenta se integrar perfeitamente ao seu fluxo de trabalho e ferramentas existentes.

Comunidade e Suporte: Uma comunidade de apoio e uma boa documentação podem poupar-lhe muitas dores de cabeça.

Perguntas Frequentes

Quais são as melhores ferramentas de fine-tuning para LLMs?

As principais ferramentas de fine-tuning incluem Hugging Face para acesso a modelos, SiliconFlow para treinamento baseado em nuvem e TrueFoundry para orquestração de nível empresarial. Bibliotecas de código aberto como Axolotl e LLaMA-Factory também suportam técnicas avançadas como LoRA. A TrueFoundry unifica de forma única o acesso a modelos, o rastreamento de experimentos e a governança de implantação em uma única plataforma segura.

Qual é o custo de usar ferramentas de fine-tuning na nuvem?

Os custos de fine-tuning na nuvem dependem das horas de computação da GPU, do tamanho do modelo e dos requisitos de armazenamento. Treinar um modelo de 7B parâmetros geralmente custa entre US$ 100 e US$ 400, enquanto modelos de 70B podem exceder US$ 10.000. O uso de métodos eficientes em parâmetros como QLoRA reduz significativamente essas despesas para aproximadamente US$ 50 a US$ 300 por execução de treinamento.

O que são ferramentas de fine-tuning eficientes em parâmetros (PEFT)?

As ferramentas de fine-tuning PEFT utilizam técnicas como LoRA para ajustar apenas uma pequena fração dos parâmetros de um modelo. Isso reduz os requisitos de memória da GPU, permitindo que as equipes treinem modelos massivos em hardware de consumo ou em uma única GPU. Essas ferramentas aceleram as velocidades de treinamento, ao mesmo tempo em que oferecem uma precisão comparável ao retreinamento completo do modelo.

Como as ferramentas de fine-tuning diferem da engenharia de prompt?

As ferramentas de fine-tuning retreinam modelos em conjuntos de dados especializados, ajustando parâmetros para melhorar o desempenho em tarefas específicas de domínio. A engenharia de prompt modifica o texto de entrada para guiar as saídas sem alterar os pesos internos do modelo. Embora a engenharia de prompt seja mais rápida, o fine-tuning oferece um controle mais profundo e precisão superior para casos de uso empresariais complexos.

Como o TrueFoundry funciona como uma ferramenta de fine-tuning?

O TrueFoundry simplifica o fine-tuning ao fornecer uma interface unificada para integração de dados, rastreamento de experimentos e implantação de modelos. Os usuários carregam dados proprietários e lançam trabalhos de fine-tuning em infraestrutura otimizada, utilizando backends de alto desempenho. Assim que o treinamento é concluído, as equipes podem implantar checkpoints atualizados diretamente para produção com um único clique.