Ajuste o Code Llama no Amazon SageMaker JumpStart | Amazon Web Services

Hoje, temos o prazer de anunciar a capacidade de ajustar os modelos Code Llama do Meta usando JumpStart do Amazon SageMaker. A família Code Llama de grandes modelos de linguagem (LLMs) é uma coleção de modelos de geração de código pré-treinados e ajustados que variam em escala de 7 bilhões a 70 bilhões de parâmetros. Modelos Code Llama ajustados fornecem melhor precisão e explicabilidade em relação aos modelos básicos do Code Llama, como fica evidente em seus testes em relação a Avaliação Humana e conjuntos de dados MBPP. Você pode ajustar e implantar modelos Code Llama com SageMaker JumpStart usando o Estúdio Amazon SageMaker UI com apenas alguns cliques ou usando o SageMaker Python SDK. O ajuste fino dos modelos Llama é baseado nos scripts fornecidos no repositório GitHub de receitas de lhama do Meta usando técnicas de quantização PyTorch FSDP, PEFT/LoRA e Int8.

Nesta postagem, explicamos como ajustar modelos pré-treinados do Code Llama por meio do SageMaker JumpStart por meio de uma interface de usuário de um clique e experiência de SDK disponível a seguir Repositório GitHub.

O que é o SageMaker JumpStart

Com o SageMaker JumpStart, os profissionais de aprendizado de máquina (ML) podem escolher entre uma ampla seleção de modelos básicos disponíveis publicamente. Os profissionais de ML podem implantar modelos básicos para dedicados Amazon Sage Maker instâncias de um ambiente isolado de rede e personalize modelos usando o SageMaker para treinamento e implantação de modelo.

O que é Código Llama

Code Llama é uma versão especializada em código do lhama 2 que foi criado treinando ainda mais o Llama 2 em seus conjuntos de dados específicos de código e amostrando mais dados desse mesmo conjunto de dados por mais tempo. Code Llama apresenta recursos de codificação aprimorados. Ele pode gerar código e linguagem natural sobre o código, tanto a partir de prompts de código quanto de linguagem natural (por exemplo, “Escreva-me uma função que produza a sequência de Fibonacci”). Você também pode usá-lo para conclusão e depuração de código. Ele suporta muitas das linguagens de programação mais populares usadas atualmente, incluindo Python, C++, Java, PHP, Typescript (JavaScript), C#, Bash e muito mais.

Por que ajustar os modelos do Code Llama

Meta publicou benchmarks de desempenho do Code Llama em HumanEval e MBPP para linguagens de codificação comuns, como Python, Java e JavaScript. O desempenho dos modelos Code Llama Python no HumanEval demonstrou desempenho variável em diferentes linguagens de codificação e tarefas, variando de 38% no modelo 7B Python a 57% nos modelos 70B Python. Além disso, modelos Code Llama ajustados na linguagem de programação SQL mostraram melhores resultados, como fica evidente nos benchmarks de avaliação SQL. Esses benchmarks publicados destacam os benefícios potenciais do ajuste fino dos modelos Code Llama, permitindo melhor desempenho, personalização e adaptação a domínios e tarefas de codificação específicos.

Ajuste fino sem código por meio da IU do SageMaker Studio

Para começar a ajustar seus modelos Llama usando o SageMaker Studio, conclua as seguintes etapas:

1. No console do SageMaker Studio, escolha Acelerador no painel de navegação.

Você encontrará listagens de mais de 350 modelos, desde modelos de código aberto até modelos proprietários.

2. Pesquise modelos Code Llama.
   

Se você não vir os modelos Code Llama, poderá atualizar sua versão do SageMaker Studio desligando e reiniciando. Para obter mais informações sobre atualizações de versão, consulte Desligue e atualize os aplicativos do Studio. Você também pode encontrar outras variantes de modelo escolhendo Explore todos os modelos de geração de código ou pesquisando Code Llama na caixa de pesquisa.

O SageMaker JumpStart atualmente oferece suporte ao ajuste fino de instruções para modelos Code Llama. A captura de tela a seguir mostra a página de ajuste fino do modelo Code Llama 2 70B.

3. Escolha Localização do conjunto de dados de treinamento, você pode apontar para o Serviço de armazenamento simples da Amazon (Amazon S3) que contém os conjuntos de dados de treinamento e validação para ajuste fino.
4. Defina sua configuração de implantação, hiperparâmetros e configurações de segurança para ajuste fino.
5. Escolha Trem para iniciar o trabalho de ajuste fino em uma instância do SageMaker ML.
   

Discutiremos o formato do conjunto de dados que você precisa preparar para o ajuste fino das instruções na próxima seção.

6. Depois que o modelo for ajustado, você poderá implantá-lo usando a página do modelo no SageMaker JumpStart.

A opção de implantar o modelo ajustado aparecerá quando o ajuste fino for concluído, conforme mostrado na captura de tela a seguir.

Ajuste por meio do SageMaker Python SDK

Nesta seção, demonstramos como ajustar modelos Code LIama usando o SageMaker Python SDK em um conjunto de dados formatado por instruções. Especificamente, o modelo é ajustado para um conjunto de tarefas de processamento de linguagem natural (PNL) descritas por meio de instruções. Isso ajuda a melhorar o desempenho do modelo para tarefas invisíveis com avisos de disparo zero.

Conclua as etapas a seguir para concluir seu trabalho de ajuste fino. Você pode obter todo o código de ajuste fino no Repositório GitHub.

Primeiro, vejamos o formato do conjunto de dados necessário para o ajuste fino da instrução. Os dados de treinamento devem ser formatados em formato de linhas JSON (.jsonl), onde cada linha é um dicionário que representa uma amostra de dados. Todos os dados de treinamento devem estar em uma única pasta. No entanto, ele pode ser salvo em vários arquivos .jsonl. A seguir está um exemplo no formato de linhas JSON:

{
	'system_prompt': 'a chat',
	'question': 'Please focus on the efficiency of this problem and provide code in python:nYou are given two strings `s` and `t` consisting of only lowercase English letters.nnReturn _the minimum number of characters that need to be appended to the end of_ `s` _so that_ `t` _becomes a **subsequence** of_ `s`.nnA **subsequence** is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.nn**Example 1:**nn**Input:** s = "coaching ", t = "coding "n**Output:** 4n**Explanation:** Append the characters "ding " to the end of s so that s = "coachingding ".nNow, t is a subsequence of s ( "**co**aching**ding** ").nIt can be shown that appending any 3 characters to the end of s will never make t a subsequence.nn**Example 2:**nn**Input:** s = "abcde ", t = "a "n**Output:** 0n**Explanation:** t is already a subsequence of s ( "**a**bcde ").nn**Example 3:**nn**Input:** s = "z ", t = "abcde "n**Output:** 5n**Explanation:** Append the characters "abcde " to the end of s so that s = "zabcde ".nNow, t is a subsequence of s ( "z**abcde** ").nIt can be shown that appending any 4 characters to the end of s will never make t a subsequence.nn**Constraints:**nn* `1 <= s.length, t.length <= 105`n* `s` and `t` consist only of lowercase English letters.',
	'response': '### Explanationn The algorithm maintains two pointers, `i` and `j`, to iterate through the given strings `s` and `t`. The pointer `i` iterates through the string `s` and the pointer `j` iterates through the string `t`. While iterating through `s`, if we find a character that matches the current character in `t`, we increment the `j` pointer. This is because the matched character can be a part of the subsequence we are looking for. The iteration stops when either `i` reaches the end of `s` or `j` reaches the end of `t`.nnAt the end, we subtract the index `j` from the length of `t`. This gives us the minimum number of characters that need to be appended to the end of `s` so that `t` becomes a subsequence of `s`.nn### Pseudocode:n```nMIN-ADDITION(s, t)n s_len = LENGTH(s)n t_len = LENGTH(t)n i = 1n j = 1n WHILE i <= s_len AND j <= t_lenn IF s[i] == t[j]n j = j + 1n ENDIFn i = i + 1n ENDWHILEn RETURN t_len - j + 1nENDMIN-ADDITIONn```nn### Coden```pythonndef min_addition(s: str, t: str) -> int:n s_len = len(s)n t_len = len(t)n i, j = 0, 0n while i < s_len and j < t_len:n if s[i] == t[j]:n j += 1n i += 1n return t_len - jn```n'
}

A pasta de treinamento pode conter um template.json arquivo que descreve os formatos de entrada e saída. A seguir está um modelo de exemplo:

{
    "prompt": "{system_prompt} ### Input: {question}",
    "completion": "{response}"
}

Para corresponder ao modelo, cada amostra nos arquivos de linhas JSON deve incluir system_prompt, question e response Campos. Nesta demonstração, usamos o Conjunto de dados do Dolphin Coder de Abraçando o Rosto.

Depois de preparar o conjunto de dados e carregá-lo no bucket S3, você pode iniciar o ajuste fino usando o seguinte código:

from sagemaker.jumpstart.estimator import JumpStartEstimator

model_id = "meta-textgeneration-llama-codellama-7b" 
model_version = "*"
train_data_location = f"s3://{your_own_bucket_hosting_training_data}/" # training data in s3 bucket

estimator = JumpStartEstimator(
    model_id=model_id,
    model_version=model_version,
    hyperparameters= hyperparameters,
    environment={
        "accept_eula": "false"
    },  # please change `accept_eula` to be `true` to accept EULA.
)

estimator.fit({"training": train_data_location})

Você pode implantar o modelo ajustado diretamente do estimador, conforme mostrado no código a seguir. Para obter detalhes, consulte o caderno no Repositório GitHub.

finetuned_predictor = estimator.deploy()

Técnicas de ajuste fino

Modelos de linguagem como o Llama têm mais de 10 GB ou até 100 GB de tamanho. O ajuste fino de modelos tão grandes requer instâncias com memória CUDA significativamente alta. Além disso, o treinamento desses modelos pode ser muito lento devido ao tamanho do modelo. Portanto, para um ajuste fino eficiente, usamos as seguintes otimizações:

• Adaptação de baixo escalão (LoRA) – Este é um tipo de ajuste fino eficiente de parâmetros (PEFT) para ajuste fino eficiente de modelos grandes. Com esse método, você congela todo o modelo e adiciona apenas um pequeno conjunto de parâmetros ou camadas ajustáveis ​​ao modelo. Por exemplo, em vez de treinar todos os 7 bilhões de parâmetros do Llama 2 7B, você pode ajustar menos de 1% dos parâmetros. Isso ajuda na redução significativa do requisito de memória porque você só precisa armazenar gradientes, estados do otimizador e outras informações relacionadas ao treinamento para apenas 1% dos parâmetros. Além disso, isso auxilia na redução do tempo de treinamento e também dos custos. Para obter mais detalhes sobre este método, consulte LoRA: Adaptação de Baixo Nível de Grandes Modelos de Linguagem.
• Quantização Int8 – Mesmo com otimizações como LoRA, modelos como o Llama 70B ainda são grandes demais para serem treinados. Para diminuir o consumo de memória durante o treinamento, você pode usar a quantização Int8 durante o treinamento. A quantização normalmente reduz a precisão dos tipos de dados de ponto flutuante. Embora isso diminua a memória necessária para armazenar os pesos do modelo, degrada o desempenho devido à perda de informações. A quantização Int8 usa apenas um quarto de precisão, mas não incorre em degradação de desempenho porque não simplesmente elimina os bits. Ele arredonda os dados de um tipo para outro. Para aprender sobre a quantização Int8, consulte LLM.int8(): Multiplicação de matrizes de 8 bits para transformadores em escala.
• Dados totalmente fragmentados paralelos (FSDP) – Este é um tipo de algoritmo de treinamento paralelo de dados que fragmenta os parâmetros do modelo entre trabalhadores paralelos de dados e pode, opcionalmente, descarregar parte da computação de treinamento para as CPUs. Embora os parâmetros sejam fragmentados em diferentes GPUs, o cálculo de cada microlote é local para o trabalhador da GPU. Ele fragmenta os parâmetros de maneira mais uniforme e alcança desempenho otimizado por meio da sobreposição de comunicação e computação durante o treinamento.

A tabela a seguir resume os detalhes de cada modelo com configurações diferentes.

O ajuste fino dos modelos Llama é baseado em scripts fornecidos pelos seguintes GitHub repo.

Hiperparâmetros compatíveis para treinamento

O ajuste fino do Code Llama 2 oferece suporte a vários hiperparâmetros, cada um dos quais pode impactar o requisito de memória, a velocidade de treinamento e o desempenho do modelo ajustado:

• época – O número de passagens que o algoritmo de ajuste fino realiza no conjunto de dados de treinamento. Deve ser um número inteiro maior que 1. O padrão é 5.
• taxa de Aprendizagem – A taxa na qual os pesos do modelo são atualizados após trabalhar em cada lote de exemplos de treinamento. Deve ser um valor flutuante positivo maior que 0. O padrão é 1e-4.
• instrução_tuned – Se deve treinar o modelo por instrução ou não. Devemos ser True or False. O padrão é False.
• per_device_train_batch_size – O tamanho do lote por núcleo GPU/CPU para treinamento. Deve ser um número inteiro positivo. O padrão é 4.
• per_device_eval_batch_size – O tamanho do lote por núcleo GPU/CPU para avaliação. Deve ser um número inteiro positivo. O padrão é 1.
• max_train_samples – Para fins de depuração ou treinamento mais rápido, trunque o número de exemplos de treinamento para esse valor. O valor -1 significa usar todas as amostras de treinamento. Deve ser um número inteiro positivo ou -1. O padrão é -1.
• max_val_samples – Para fins de depuração ou treinamento mais rápido, trunque o número de exemplos de validação para esse valor. O valor -1 significa usar todas as amostras de validação. Deve ser um número inteiro positivo ou -1. O padrão é -1.
• max_input_length – Comprimento total máximo da sequência de entrada após tokenização. Sequências maiores que isso serão truncadas. Se -1, max_input_length é definido como o mínimo de 1024 e o comprimento máximo do modelo definido pelo tokenizer. Se definido com um valor positivo, max_input_length é definido para o mínimo do valor fornecido e o model_max_length definido pelo tokenizador. Deve ser um número inteiro positivo ou -1. O padrão é -1.
• validação_split_ratio – Se o canal de validação for none, a proporção entre a divisão da validação do trem e os dados do trem deve estar entre 0–1. O padrão é 0.2.
• train_data_split_seed – Se os dados de validação não estiverem presentes, isso corrige a divisão aleatória dos dados de treinamento de entrada em dados de treinamento e validação usados ​​pelo algoritmo. Deve ser um número inteiro. O padrão é 0.
• pré-processamento_num_workers – O número de processos a serem usados ​​para pré-processamento. Se None, o processo principal é usado para pré-processamento. O padrão é None.
• lora_r – Lora R. Deve ser um número inteiro positivo. O padrão é 8.
• lora_alpha – Lora Alfa. Deve ser um número inteiro positivo. O padrão é 32
• lora_dropout – Lora Desistente. deve ser um valor flutuante positivo entre 0 e 1. O padrão é 0.05.
• int8_quantização - Se True, o modelo é carregado com precisão de 8 bits para treinamento. O padrão para 7B e 13B é False. O padrão para 70B é True.
• habilitar_fsdp – Se True, o treinamento usa FSDP. O padrão para 7B e 13B é True. O padrão para 70B é Falso. Observe que int8_quantization não é compatível com FSDP.

Ao escolher os hiperparâmetros, considere o seguinte:

• Configuração int8_quantization=True diminui a necessidade de memória e leva a um treinamento mais rápido.
• Decrescente per_device_train_batch_size e max_input_length reduz o requisito de memória e, portanto, pode ser executado em instâncias menores. Contudo, definir valores muito baixos pode aumentar o tempo de treino.
• Se você não estiver usando a quantização Int8 (int8_quantization=False), use FSDP (enable_fsdp=True) para um treinamento mais rápido e eficiente.

Tipos de instância compatíveis para treinamento

A tabela a seguir resume os tipos de instância compatíveis para treinar diferentes modelos.

Ao escolher o tipo de instância, considere o seguinte:

• As instâncias G5 fornecem o treinamento mais eficiente entre os tipos de instância suportados. Portanto, se você tiver instâncias G5 disponíveis, deverá usá-las.
• O tempo de treinamento depende muito da quantidade de GPUs e da memória CUDA disponível. Portanto, o treinamento em instâncias com o mesmo número de GPUs (por exemplo, ml.g5.2xlarge e ml.g5.4xlarge) é praticamente o mesmo. Portanto, você pode usar a instância mais barata para treinamento (ml.g5.2xlarge).
• Ao usar instâncias p3, o treinamento será feito com precisão de 32 bits porque bfloat16 não é compatível com essas instâncias. Portanto, o trabalho de treinamento consumirá o dobro da quantidade de memória CUDA ao treinar em instâncias p3 em comparação com instâncias g5.

Para saber mais sobre o custo do treinamento por instância, consulte Instâncias G2 do Amazon EC5.

Avaliação

A avaliação é uma etapa importante para avaliar o desempenho de modelos ajustados. Apresentamos avaliações qualitativas e quantitativas para mostrar a melhoria dos modelos ajustados em relação aos não ajustados. Na avaliação qualitativa, mostramos um exemplo de resposta de modelos ajustados e não ajustados. Na avaliação quantitativa, usamos Avaliação Humana, um conjunto de testes desenvolvido pela OpenAI para gerar código Python para testar a capacidade de produzir resultados corretos e precisos. O repositório HumanEval está sob licença do MIT. Ajustamos variantes Python de todos os modelos do Code LIama em diferentes tamanhos (Code LIama Python 7B, 13B, 34B e 70B no Conjunto de dados do Dolphin Coder) e apresentar os resultados da avaliação nas seções seguintes.

Avaliação qualitativa

Com seu modelo ajustado implantado, você pode começar a usar o endpoint para gerar código. No exemplo a seguir, apresentamos respostas de variantes básicas e ajustadas do Code LIama 34B Python em uma amostra de teste no Conjunto de dados do Dolphin Coder:

alpaca_format = """{system_prompt}

### Input:
{question}

### Response:n"""

system="You are a coding AI"
prompt = """Please explain the reasoning behind the following solution and 
provide code in python: Given a string `s`, return the longest palindromic 
substring in `s`. **Example 1:** **Input:** s = "babad " **Output:** "bab " 
**Explanation:** "aba " is also a valid answer. **Example 2:** 
**Input:** s = "cbbd " **Output:** "bb " 
**Constraints:** * `1 <= s.length <= 1000` * `s` consist of only digits 
and English letters."""

payload = json.dumps({
    "inputText": alpaca_format.format(system_prompt=system, question=prompt),
    "textGenerationConfig": {
    "maxTokenCount": 2048,
    "temperature":0.2
}})

finetuned_response = finetuned_predictor.predict(payload)
finetuned_response["generated_text"]

O modelo Code Llama ajustado, além de fornecer o código para a consulta anterior, gera uma explicação detalhada da abordagem e um pseudocódigo.

Resposta não ajustada do Code Llama 34b Python:

### Code
def longestPalindrome(s):
    # Fill this in.
    longest = ""
    for i in range(len(s)):
        for j in range(len(s), i, -1):
            if len(longest) >= j-i:
                break
            elif s[i:j] == s[i:j][::-1]:
                longest = s[i:j]
                break
    return longest

print(longestPalindrome("abaxyzzyxf"))
# axyzzyx
###Reference:
- [https://www.geeksforgeeks.org/longest-palindrome-substring-set-1/]
(https://www.geeksforgeeks.org/longest-palindrome-substring-set-1/)

Resposta ajustada do Code Llama 34B Python

### Explanation
The algorithm uses dynamic programming to find the longest palindromic substring. 
It initializes a 2D boolean table `dp` with the same dimensions as the input string `s`. 
The `dp[i][j]` value is set to `true` if the substring from index `i` to index `j` is a palindrome.

The algorithm then iterates through the string in a nested loop, starting from the first character to the last. 
It checks if the substring from index `i` to index `j` is a palindrome. 
If it is, it sets the `dp[i][j]` value to `true`. 
If the substring is of length 2 or 3, it sets the `dp[i][j]` value to `true` as well.

After the nested loop, the algorithm iterates through the `dp` table to find the longest palindromic substring. 
It keeps track of the maximum length and the starting and ending indices of the substring.

Finally, the algorithm returns the substring from the starting index to the ending index.

### Code
```python
def longestPalindrome(s: str) -> str:
    n = len(s)
    dp = [[False] * n for _ in range(n)]

    for i in range(n):
        dp[i][i] = True
        if i + 1 < n:
            dp[i][i + 1] = s[i] == s[i + 1]

    max_len = 1
    start = 0
    end = 0

    for i in range(n - 1):
        for j in range(i + 1, n):
            if j - i == 1 or dp[i + 1][j - 1]:
                dp[i][j] = s[i] == s[j]
                if j - i + 1 > max_len:
                    max_len = j - i + 1
                    start = i
                    end = j

    return s[start:end + 1]
```

Verdade do solo

### Explanation 
1. Initialize `start` and `maxLength` for result substring. 
2. Iterate through the given string `s` using the index `i`. 
3. For each index `i`, create two pointers `l` and `r` starting at `i`. 
4. Check if there's a consecutive sequence of identical characters, increment the right pointer `r` until the end of the sequence is reached. 
5. Update the index `i` to the current value of `r`. 
6. Expand the pointers `l` and `r` outwards to find the longest palindromic substring, checking that characters on both sides are equal. 
7. If the current length of the substring is greater than `maxLength`, update `start` and `maxLength`. 
8. Return the longest palindromic substring using the `start` and `maxLength`. 

### Code 
```python 
def longest_palindromic_substring(s: str) → str:
    n = len(s)
    if n == 0:
        return ""
    
    start, max_length = 0, 1
    for i in range(n):
        l, r = i, i
        while r < n - 1 and s[r] == s[r + 1]:
            r += 1
            i = r
        while l > 0 and r < n - 1 and s[l - 1] == s[r + 1]:
            l -= 1
            r += 1
        length = r - l + 1
        if length > max_length:
            start, max_length = l, length
    return s[start:start + max_length]
```

Curiosamente, nossa versão ajustada do Code Llama 34B Python fornece uma solução dinâmica baseada em programação para a substring palindrômica mais longa, que é diferente da solução fornecida na verdade do exemplo de teste selecionado. Nosso modelo ajustado raciocina e explica detalhadamente a solução baseada em programação dinâmica. Por outro lado, o modelo não ajustado alucina resultados potenciais logo após o print instrução (mostrada na célula esquerda) porque a saída axyzzyx não é o palíndromo mais longo na string fornecida. Em termos de complexidade de tempo, a solução de programação dinâmica é geralmente melhor que a abordagem inicial. A solução de programação dinâmica tem uma complexidade de tempo de O(n^2), onde n é o comprimento da string de entrada. Isso é mais eficiente do que a solução inicial do modelo não ajustado, que também tinha uma complexidade de tempo quadrática de O(n^2), mas com uma abordagem menos otimizada.

Isso parece promissor! Lembre-se, nós apenas ajustamos a variante Code LIama Python com 10% do Conjunto de dados do Dolphin Coder. Há muito mais para explorar!

Apesar das instruções completas na resposta, ainda precisamos examinar a exatidão do código Python fornecido na solução. A seguir, usamos uma estrutura de avaliação chamada Avaliação Humana executar testes de integração na resposta gerada pelo Code LIama para examinar sistematicamente sua qualidade.

Avaliação quantitativa com HumanEval

HumanEval é um equipamento de avaliação para avaliar as capacidades de resolução de problemas de um LLM em problemas de codificação baseados em Python, conforme descrito no artigo Avaliando grandes modelos de linguagem treinados em código. Especificamente, consiste em 164 problemas originais de programação baseados em Python que avaliam a capacidade de um modelo de linguagem de gerar código com base nas informações fornecidas, como assinatura de função, docstring, corpo e testes de unidade.

Para cada questão de programação baseada em Python, nós a enviamos para um modelo Code LIama implantado em um endpoint SageMaker para obter k respostas. A seguir, executamos cada uma das k respostas nos testes de integração no repositório HumanEval. Se alguma resposta das k respostas passar nos testes de integração, consideramos que o caso de teste foi bem-sucedido; caso contrário, falhou. Em seguida, repetimos o processo para calcular a proporção de casos de sucesso conforme a pontuação final da avaliação denominada pass@k. Seguindo a prática padrão, definimos k como 1 em nossa avaliação, para gerar apenas uma resposta por pergunta e testar se ela passa no teste de integração.

A seguir está um exemplo de código para usar o repositório HumanEval. Você pode acessar o conjunto de dados e gerar uma única resposta usando um endpoint SageMaker. Para obter detalhes, consulte o caderno no Repositório GitHub.

%pip3 install human_eval
import json
from human_eval.evaluation import evaluate_functional_correctness
from human_eval.data import write_jsonl, read_problems
from tqdm import tqdm
problems = read_problems()

num_samples_per_task = 1 # value k: number of responses for each question
samples = [
    dict(task_id=task_id, completion=generate_one_completion(problems[task_id]["prompt"]))
    for task_id in tqdm(problems)
    for _ in range(num_samples_per_task)
]
write_jsonl("samples.jsonl", samples)

evaluate_functional_correctness('./samples.jsonl')

A tabela a seguir mostra as melhorias dos modelos Code LIama Python ajustados em relação aos modelos não ajustados em diferentes tamanhos de modelo. Para garantir a correção, também implantamos os modelos Code LIama não ajustados em endpoints SageMaker e executamos avaliações Human Eval. O passe@1 números (a primeira linha da tabela a seguir) correspondem aos números relatados no Artigo de pesquisa do Code Llama. Os parâmetros de inferência são consistentemente definidos como "parameters": {"max_new_tokens": 384, "temperature": 0.2}.

Como podemos ver nos resultados, todas as variantes do Code LIama Python ajustadas mostram melhorias significativas em relação aos modelos não ajustados. Em particular, o Code LIama Python 70B supera o modelo não ajustado em aproximadamente 12%.

Agora você pode tentar ajustar os modelos do Code LIama em seu próprio conjunto de dados.

limpar

Se você decidir que não deseja mais manter o endpoint SageMaker em execução, poderá excluí-lo usando SDK da AWS para Python (Boto3), Interface de linha de comando da AWS (AWS CLI) ou console do SageMaker. Para mais informações, veja Excluir endpoints e recursos. Além disso, você pode desligue os recursos do SageMaker Studio que não são mais necessários.

Conclusão

Nesta postagem, discutimos o ajuste fino dos modelos Code Llama 2 do Meta usando SageMaker JumpStart. Mostramos que você pode usar o console SageMaker JumpStart no SageMaker Studio ou o SageMaker Python SDK para ajustar e implantar esses modelos. Também discutimos a técnica de ajuste fino, tipos de instância e hiperparâmetros suportados. Além disso, traçamos recomendações para um treinamento otimizado com base em diversos testes que realizamos. Como podemos ver a partir desses resultados do ajuste fino de três modelos em dois conjuntos de dados, o ajuste fino melhora o resumo em comparação com modelos não ajustados. Na próxima etapa, você pode tentar ajustar esses modelos em seu próprio conjunto de dados usando o código fornecido no repositório GitHub para testar e comparar os resultados para seus casos de uso.

Sobre os autores

Dr.Xin Huang é um cientista aplicado sênior para Amazon SageMaker JumpStart e algoritmos integrados do Amazon SageMaker. Ele se concentra no desenvolvimento de algoritmos de aprendizado de máquina escalonáveis. Seus interesses de pesquisa estão na área de processamento de linguagem natural, aprendizado profundo explicável em dados tabulares e análise robusta de agrupamento de espaço-tempo não paramétrico. Ele publicou muitos artigos nas conferências ACL, ICDM, KDD e Royal Statistical Society: Series A.

Vishaal Yalamanchali é um arquiteto de soluções para startups que trabalha com empresas de IA generativa, robótica e veículos autônomos em estágio inicial. Vishaal trabalha com seus clientes para fornecer soluções de ML de ponta e está pessoalmente interessado em aprendizado por reforço, avaliação LLM e geração de código. Antes da AWS, Vishaal era estudante de graduação na UCI, com foco em bioinformática e sistemas inteligentes.

Meenakshisundaram Thandavarayan trabalha para a AWS como especialista em IA/ML. Ele tem paixão por projetar, criar e promover experiências de análise e dados centradas no ser humano. Meena se concentra no desenvolvimento de sistemas sustentáveis ​​que oferecem vantagens competitivas mensuráveis ​​para clientes estratégicos da AWS. Meena é uma conectora e pensadora de design e se esforça para levar as empresas a novas formas de trabalhar por meio da inovação, incubação e democratização.

Dr. é um cientista aplicado sênior com algoritmos integrados do Amazon SageMaker e ajuda a desenvolver algoritmos de aprendizado de máquina. Ele obteve seu PhD pela University of Illinois Urbana-Champaign. Ele é um pesquisador ativo em aprendizado de máquina e inferência estatística e publicou muitos artigos em conferências NeurIPS, ICML, ICLR, JMLR, ACL e EMNLP.

• Conteúdo com tecnologia de SEO e distribuição de relações públicas. Seja amplificado hoje.
• PlatoData.Network Gerativa Vertical Ai. Capacite-se. Acesse aqui.
• PlatoAiStream. Inteligência Web3. Conhecimento Amplificado. Acesse aqui.
• PlatãoESG. Carbono Tecnologia Limpa, Energia, Ambiente, Solar, Gestão de resíduos. Acesse aqui.
• PlatoHealth. Inteligência em Biotecnologia e Ensaios Clínicos. Acesse aqui.
• Fonte: https://aws.amazon.com/blogs/machine-learning/fine-tune-code-llama-on-amazon-sagemaker-jumpstart/