Perfeziona Code Llama su Amazon SageMaker JumpStart | Servizi Web di Amazon

Oggi siamo entusiasti di annunciare la possibilità di ottimizzare i modelli Code Llama utilizzando Meta JumpStart di Amazon SageMaker. La famiglia Code Llama di modelli linguistici di grandi dimensioni (LLM) è una raccolta di modelli di generazione di codice pre-addestrati e ottimizzati che vanno da 7 miliardi a 70 miliardi di parametri. I modelli Code Llama ottimizzati forniscono una migliore precisione e spiegabilità rispetto ai modelli Code Llama di base, come evidente nei test contro Valutazione umana e set di dati MBPP. Puoi ottimizzare e distribuire modelli Code Llama con SageMaker JumpStart utilizzando il file Amazon Sage Maker Studio Interfaccia utente con pochi clic o utilizzando SageMaker Python SDK. La messa a punto dei modelli Llama si basa sugli script forniti nel file Repository GitHub di ricette di lama da Meta utilizzando le tecniche di quantizzazione PyTorch FSDP, PEFT/LoRA e Int8.

In questo post, spiegheremo come ottimizzare i modelli pre-addestrati di Code Llama tramite SageMaker JumpStart attraverso un'interfaccia utente con un clic e un'esperienza SDK disponibile nei seguenti Repository GitHub.

Cos'è SageMaker JumpStart

Con SageMaker JumpStart, i professionisti del machine learning (ML) possono scegliere tra un'ampia selezione di modelli di base disponibili pubblicamente. I professionisti del machine learning possono distribuire modelli di base a progetti dedicati Amazon Sage Maker istanze da un ambiente isolato dalla rete e personalizza i modelli utilizzando SageMaker per l'addestramento e la distribuzione dei modelli.

Cos'è Code Llama

Code Llama è una versione specializzata in codice di lama 2 che è stato creato addestrando ulteriormente Llama 2 sui suoi set di dati specifici del codice e campionando più dati dallo stesso set di dati per un periodo più lungo. Code Llama offre funzionalità di codifica avanzate. Può generare codice e linguaggio naturale relativo al codice, sia da istruzioni di codice che di linguaggio naturale (ad esempio, "Scrivimi una funzione che restituisca la sequenza di Fibonacci"). Puoi anche usarlo per il completamento del codice e il debug. Supporta molti dei linguaggi di programmazione più popolari utilizzati oggi, tra cui Python, C++, Java, PHP, Typescript (JavaScript), C#, Bash e altri.

Perché ottimizzare i modelli Code Llama

Meta ha pubblicato i benchmark delle prestazioni di Code Llama su HumanEval e MBPP per linguaggi di codifica comuni come Python, Java e JavaScript. Le prestazioni dei modelli Code Llama Python su HumanEval hanno dimostrato prestazioni variabili tra diversi linguaggi di codifica e attività che vanno dal 38% sul modello Python 7B al 57% sui modelli Python 70B. Inoltre, i modelli Code Llama ottimizzati sul linguaggio di programmazione SQL hanno mostrato risultati migliori, come evidente nei benchmark di valutazione SQL. Questi benchmark pubblicati evidenziano i potenziali vantaggi della messa a punto dei modelli Code Llama, consentendo prestazioni, personalizzazione e adattamento migliori a domini e attività di codifica specifici.

Ottimizzazione senza codice tramite l'interfaccia utente di SageMaker Studio

Per iniziare a perfezionare i tuoi modelli Llama utilizzando SageMaker Studio, completa i seguenti passaggi:

1. Nella console di SageMaker Studio, scegli inizio di salto nel pannello di navigazione.

Troverai elenchi di oltre 350 modelli che vanno dai modelli open source e proprietari.

2. Cerca i modelli Code Llama.
   

Se non vedi i modelli Code Llama, puoi aggiornare la versione di SageMaker Studio spegnendo e riavviando. Per ulteriori informazioni sugli aggiornamenti della versione, fare riferimento a Chiudi e aggiorna le app di Studio. Puoi trovare anche altre varianti del modello scegliendo Esplora tutti i modelli di generazione del codice o cercando Code Llama nella casella di ricerca.

SageMaker JumpStart attualmente supporta la regolazione fine delle istruzioni per i modelli Code Llama. Lo screenshot seguente mostra la pagina di messa a punto per il modello Code Llama 2 70B.

3. Nel Posizione del set di dati di addestramento, puoi indicare il Servizio di archiviazione semplice Amazon (Amazon S3) bucket contenente i set di dati di training e convalida per la messa a punto.
4. Imposta la configurazione di distribuzione, gli iperparametri e le impostazioni di sicurezza per la messa a punto.
5. Scegli Treni per avviare il lavoro di ottimizzazione su un'istanza SageMaker ML.
   

Discuteremo il formato del set di dati necessario per preparare la messa a punto delle istruzioni nella sezione successiva.

6. Dopo aver ottimizzato il modello, puoi distribuirlo utilizzando la pagina del modello su SageMaker JumpStart.

L'opzione per distribuire il modello ottimizzato verrà visualizzata al termine dell'ottimizzazione, come mostrato nello screenshot seguente.

Ottimizza tramite SageMaker Python SDK

In questa sezione, dimostriamo come ottimizzare i modelli Code LIama utilizzando SageMaker Python SDK su un set di dati formattato con istruzioni. Nello specifico, il modello è ottimizzato per una serie di attività di elaborazione del linguaggio naturale (NLP) descritte utilizzando le istruzioni. Ciò aiuta a migliorare le prestazioni del modello per attività invisibili con istruzioni zero-shot.

Completa i seguenti passaggi per completare il lavoro di ottimizzazione. È possibile ottenere l'intero codice di regolazione fine dal file Repository GitHub.

Per prima cosa, diamo un'occhiata al formato del set di dati richiesto per la messa a punto dell'istruzione. I dati di training devono essere formattati in un formato di righe JSON (.jsonl), in cui ogni riga è un dizionario che rappresenta un campione di dati. Tutti i dati di allenamento devono trovarsi in un'unica cartella. Tuttavia, può essere salvato in più file .jsonl. Di seguito è riportato un esempio in formato righe 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'
}

La cartella di formazione può contenere a template.json file che descrive i formati di input e output. Di seguito è riportato un modello di esempio:

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

Per corrispondere al modello, ogni campione nei file delle righe JSON deve includere system_prompt, questione response campi. In questa dimostrazione utilizziamo il file Set di dati di Dolphin Coder da Il viso che abbraccia.

Dopo aver preparato il set di dati e averlo caricato nel bucket S3, puoi iniziare la messa a punto utilizzando il seguente codice:

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})

È possibile distribuire il modello ottimizzato direttamente dallo stimatore, come mostrato nel codice seguente. Per i dettagli consultare il quaderno in Repository GitHub.

finetuned_predictor = estimator.deploy()

Tecniche di messa a punto

I modelli linguistici come Llama hanno dimensioni superiori a 10 GB o addirittura 100 GB. La messa a punto di modelli così grandi richiede istanze con memoria CUDA significativamente elevata. Inoltre, l'addestramento di questi modelli può essere molto lento a causa delle dimensioni del modello. Pertanto, per una messa a punto efficiente, utilizziamo le seguenti ottimizzazioni:

• Adattamento di basso rango (LoRA) – Questo è un tipo di regolazione fine efficiente dei parametri (PEFT) per la regolazione fine efficiente di modelli di grandi dimensioni. Con questo metodo, si blocca l'intero modello e si aggiunge solo un piccolo set di parametri o livelli regolabili nel modello. Ad esempio, invece di allenare tutti i 7 miliardi di parametri per Llama 2 7B, puoi ottimizzare meno dell'1% dei parametri. Ciò aiuta a ridurre in modo significativo il fabbisogno di memoria poiché è necessario memorizzare gradienti, stati dell'ottimizzatore e altre informazioni relative all'allenamento solo per l'1% dei parametri. Inoltre, questo aiuta a ridurre i tempi di formazione e i costi. Per ulteriori dettagli su questo metodo, fare riferimento a LoRA: adattamento di basso rango di modelli linguistici di grandi dimensioni.
• Quantizzazione Int8 – Anche con ottimizzazioni come LoRA, modelli come Llama 70B sono ancora troppo grandi per essere addestrati. Per ridurre l'impronta di memoria durante l'addestramento, è possibile utilizzare la quantizzazione Int8 durante l'addestramento. La quantizzazione in genere riduce la precisione dei tipi di dati a virgola mobile. Sebbene ciò riduca la memoria richiesta per memorizzare i pesi del modello, riduce le prestazioni a causa della perdita di informazioni. La quantizzazione Int8 utilizza solo un quarto di precisione ma non comporta un degrado delle prestazioni perché non elimina semplicemente i bit. Arrotonda i dati da un tipo all'altro. Per ulteriori informazioni sulla quantizzazione Int8, fare riferimento a LLM.int8(): moltiplicazione di matrici a 8 bit per trasformatori su larga scala.
• Parallelo dati completamente condivisi (FSDP) – Si tratta di un tipo di algoritmo di addestramento parallelo ai dati che suddivide i parametri del modello tra i lavoratori paralleli dei dati e può facoltativamente scaricare parte del calcolo di addestramento sulle CPU. Sebbene i parametri siano suddivisi tra diverse GPU, il calcolo di ciascun microbatch è locale per il GPU Worker. Suddivide i parametri in modo più uniforme e raggiunge prestazioni ottimizzate tramite la sovrapposizione di comunicazione e calcolo durante l'addestramento.

La tabella seguente riassume i dettagli di ciascun modello con impostazioni diverse.

La messa a punto dei modelli Llama si basa sugli script forniti di seguito Repository GitHub.

Iperparametri supportati per l'addestramento

L'ottimizzazione di Code Llama 2 supporta una serie di iperparametri, ognuno dei quali può influire sui requisiti di memoria, sulla velocità di addestramento e sulle prestazioni del modello ottimizzato:

• epoca – Il numero di passaggi effettuati dall'algoritmo di fine tuning attraverso il set di dati di training. Deve essere un numero intero maggiore di 1. Il valore predefinito è 5.
• tasso_di_apprendimento – La velocità con cui i pesi del modello vengono aggiornati dopo aver elaborato ciascun batch di esempi di training. Deve essere un float positivo maggiore di 0. Il valore predefinito è 1e-4.
• istruzione_sintonizzata – Se addestrare il modello o meno. Deve essere True or False. L'impostazione predefinita è False.
• per_dispositivo_treno_dimensione_batch – La dimensione del batch per core GPU/CPU per l'addestramento. Deve essere un numero intero positivo. L'impostazione predefinita è 4.
• per_device_eval_batch_size – La dimensione del batch per core GPU/CPU per la valutazione. Deve essere un numero intero positivo. L'impostazione predefinita è 1.
• max_train_samples – Per scopi di debug o per una formazione più rapida, troncare il numero di esempi di formazione a questo valore. Il valore -1 indica l'utilizzo di tutti i campioni di training. Deve essere un numero intero positivo o -1. L'impostazione predefinita è -1.
• max_val_samples – Per scopi di debug o per una formazione più rapida, troncare il numero di esempi di convalida a questo valore. Il valore -1 indica l'utilizzo di tutti i campioni di convalida. Deve essere un numero intero positivo o -1. L'impostazione predefinita è -1.
• lunghezza_input_massima – Lunghezza massima totale della sequenza di input dopo la tokenizzazione. Le sequenze più lunghe verranno troncate. Se -1, max_input_length è impostato sul minimo di 1024 e sulla lunghezza massima del modello definita dal tokenizzatore. Se impostato su un valore positivo, max_input_length è impostato sul minimo del valore fornito e il model_max_length definito dal tokenizzatore. Deve essere un numero intero positivo o -1. L'impostazione predefinita è -1.
• validation_split_ratio – Se il canale di convalida è none, il rapporto tra la suddivisione della convalida del treno e i dati del treno deve essere compreso tra 0 e 1. L'impostazione predefinita è 0.2.
• train_data_split_seed – Se i dati di convalida non sono presenti, ciò fissa la suddivisione casuale dei dati di training di input nei dati di training e di convalida utilizzati dall'algoritmo. Deve essere un numero intero. L'impostazione predefinita è 0.
• preprocessing_num_workers – Il numero di processi da utilizzare per la preelaborazione. Se None, il processo principale viene utilizzato per la preelaborazione. L'impostazione predefinita è None.
• lora_r – Lora R. Deve essere un numero intero positivo. L'impostazione predefinita è 8.
• lora_alpha – Lora Alfa. Deve essere un numero intero positivo. L'impostazione predefinita è 32
• lora_dropout – Lora abbandona. deve essere un numero mobile positivo compreso tra 0 e 1. Il valore predefinito è 0.05.
• int8_quantizzazione - Se True, il modello viene caricato con precisione a 8 bit per l'addestramento. L'impostazione predefinita per 7B e 13B è False. L'impostazione predefinita per 70B è True.
• abilita_fsdp – Se Vero, la formazione utilizza FSDP. L'impostazione predefinita per 7B e 13B è Vero. L'impostazione predefinita per 70B è False. Notare che int8_quantization non è supportato con FSDP.

Quando si scelgono gli iperparametri, considerare quanto segue:

• Configurazione int8_quantization=True diminuisce il fabbisogno di memoria e porta ad un allenamento più veloce.
• Decrescente per_device_train_batch_size ed max_input_length riduce il requisito di memoria e quindi può essere eseguito su istanze più piccole. Tuttavia, l'impostazione di valori molto bassi potrebbe aumentare il tempo di allenamento.
• Se non stai utilizzando la quantizzazione Int8 (int8_quantization=False), utilizzare FSDP (enable_fsdp=True) per un allenamento più rapido ed efficiente.

Tipi di istanze supportate per l'addestramento

La tabella seguente riepiloga i tipi di istanza supportati per l'addestramento di modelli diversi.

Quando si sceglie il tipo di istanza, considerare quanto segue:

• Le istanze G5 forniscono la formazione più efficiente tra i tipi di istanza supportati. Pertanto, se disponi di istanze G5, dovresti utilizzarle.
• Il tempo di addestramento dipende in gran parte dalla quantità di GPU e memoria CUDA disponibili. Pertanto, l'addestramento su istanze con lo stesso numero di GPU (ad esempio, ml.g5.2xlarge e ml.g5.4xlarge) è più o meno lo stesso. Pertanto, puoi utilizzare l'istanza più economica per l'addestramento (ml.g5.2xlarge).
• Quando si utilizzano istanze p3, l'addestramento verrà eseguito con precisione a 32 bit perché bfloat16 non è supportato su queste istanze. Pertanto, il processo di training consumerà il doppio della quantità di memoria CUDA durante il training su istanze p3 rispetto alle istanze g5.

Per informazioni sul costo della formazione per istanza, fare riferimento a Istanze Amazon EC2 G5.

Valutazione

La valutazione è un passo importante per valutare le prestazioni dei modelli ottimizzati. Presentiamo valutazioni sia qualitative che quantitative per mostrare il miglioramento dei modelli ottimizzati rispetto a quelli non ottimizzati. Nella valutazione qualitativa, mostriamo una risposta di esempio da entrambi i modelli ottimizzati e non ottimizzati. Nella valutazione quantitativa, utilizziamo Valutazione umana, una suite di test sviluppata da OpenAI per generare codice Python per testare la capacità di produrre risultati corretti e accurati. Il repository HumanEval è sotto licenza MIT. Abbiamo perfezionato le varianti Python di tutti i modelli Code LIama su diverse dimensioni (Code LIama Python 7B, 13B, 34B e 70B sul Set di dati di Dolphin Coder) e presentare i risultati della valutazione nelle sezioni seguenti.

Valutazione qualitativa

Una volta distribuito il modello ottimizzato, puoi iniziare a utilizzare l'endpoint per generare codice. Nell'esempio seguente, presentiamo le risposte delle varianti Python di base e ottimizzate di Code LIama 34B su un campione di test in Set di dati di 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"]

Il modello Code Llama ottimizzato, oltre a fornire il codice per la query precedente, genera una spiegazione dettagliata dell'approccio e uno pseudo codice.

Codice Llama 34b Risposta Python non ottimizzata:

### 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/)

Codice Llama 34B Risposta ottimizzata 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]
```

Realtà di base

### 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]
```

È interessante notare che la nostra versione ottimizzata di Code Llama 34B Python fornisce una soluzione dinamica basata sulla programmazione per la sottostringa palindromica più lunga, che è diversa dalla soluzione fornita nella verità fondamentale dall'esempio di test selezionato. Il nostro modello ottimizzato motiva e spiega in dettaglio la soluzione basata sulla programmazione dinamica. D’altro canto, il modello non ottimizzato crea allucinazioni sui potenziali risultati subito dopo print istruzione (mostrata nella cella di sinistra) perché l'output axyzzyx non è il palindromo più lungo nella stringa data. In termini di complessità temporale, la soluzione di programmazione dinamica è generalmente migliore dell’approccio iniziale. La soluzione di programmazione dinamica ha una complessità temporale pari a O(n^2), dove n è la lunghezza della stringa di input. Ciò è più efficiente della soluzione iniziale del modello non ottimizzato, che aveva anch'esso una complessità temporale quadratica di O(n^2) ma con un approccio meno ottimizzato.

Sembra promettente! Ricorda, abbiamo perfezionato solo la variante Code LIama Python con il 10% del Set di dati di Dolphin Coder. C'è molto altro da esplorare!

Nonostante le istruzioni dettagliate nella risposta, dobbiamo ancora esaminare la correttezza del codice Python fornito nella soluzione. Successivamente, utilizziamo un quadro di valutazione chiamato Valutazione umana eseguire test di integrazione sulla risposta generata da Code LIama per esaminarne sistematicamente la qualità.

Valutazione quantitativa con HumanEval

HumanEval è un'attrezzatura di valutazione per valutare le capacità di risoluzione dei problemi di un LLM su problemi di codifica basati su Python, come descritto nel documento Valutazione di modelli linguistici di grandi dimensioni addestrati sul codice. Nello specifico, consiste in 164 problemi di programmazione originali basati su Python che valutano la capacità di un modello linguistico di generare codice in base alle informazioni fornite come firma della funzione, docstring, corpo e test unitari.

Per ogni domanda di programmazione basata su Python, la inviamo a un modello Code LIama distribuito su un endpoint SageMaker per ottenere k risposte. Successivamente, eseguiamo ciascuna delle risposte k sui test di integrazione nel repository HumanEval. Se una qualsiasi delle risposte k supera i test di integrazione, consideriamo positivo il caso di test; in caso contrario, fallito. Quindi ripetiamo il processo per calcolare il rapporto di casi di successo come punteggio di valutazione finale nominato pass@k. Seguendo la pratica standard, impostiamo k come 1 nella nostra valutazione, per generare solo una risposta per domanda e verificare se supera il test di integrazione.

Di seguito è riportato un codice di esempio per utilizzare il repository HumanEval. Puoi accedere al set di dati e generare una risposta singola utilizzando un endpoint SageMaker. Per i dettagli consultare il quaderno in Repository 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')

La tabella seguente mostra i miglioramenti dei modelli Code LIama Python ottimizzati rispetto ai modelli non ottimizzati in diverse dimensioni del modello. Per garantire la correttezza, distribuiamo anche i modelli Code LIama non ottimizzati negli endpoint SageMaker ed eseguiamo valutazioni di valutazione umana. IL passa@1 i numeri (la prima riga nella tabella seguente) corrispondono ai numeri riportati nel file Documento di ricerca su Code Llama. I parametri di inferenza sono costantemente impostati come "parameters": {"max_new_tokens": 384, "temperature": 0.2}.

Come possiamo vedere dai risultati, tutte le varianti Code LIama Python ottimizzate mostrano un miglioramento significativo rispetto ai modelli non ottimizzati. In particolare, Code LIama Python 70B supera il modello non ottimizzato di circa il 12%.

Ora puoi provare a ottimizzare i modelli Code LIama sul tuo set di dati.

ripulire

Se decidi di non voler più mantenere in esecuzione l'endpoint SageMaker, puoi eliminarlo utilizzando SDK AWS per Python (Boto3), Interfaccia della riga di comando di AWS (AWS CLI) o console SageMaker. Per ulteriori informazioni, vedere Elimina endpoint e risorse. Inoltre, puoi chiudere le risorse di SageMaker Studio che non sono più necessari.

Conclusione

In questo post, abbiamo discusso della messa a punto dei modelli Code Llama 2 di Meta utilizzando SageMaker JumpStart. Abbiamo dimostrato che è possibile utilizzare la console SageMaker JumpStart in SageMaker Studio o SageMaker Python SDK per ottimizzare e distribuire questi modelli. Abbiamo anche discusso la tecnica di perfezionamento, i tipi di istanza e gli iperparametri supportati. Inoltre, abbiamo delineato raccomandazioni per un allenamento ottimizzato sulla base di vari test che abbiamo effettuato. Come possiamo vedere da questi risultati dell'ottimizzazione di tre modelli su due set di dati, l'ottimizzazione migliora il riepilogo rispetto ai modelli non ottimizzati. Come passaggio successivo, puoi provare a mettere a punto questi modelli sul tuo set di dati utilizzando il codice fornito nel repository GitHub per testare e confrontare i risultati per i tuoi casi d'uso.

Informazioni sugli autori

Dott. Xin Huang è Senior Applied Scientist per gli algoritmi integrati di Amazon SageMaker JumpStart e Amazon SageMaker. Si concentra sullo sviluppo di algoritmi di apprendimento automatico scalabili. I suoi interessi di ricerca riguardano l'elaborazione del linguaggio naturale, il deep learning spiegabile su dati tabulari e l'analisi solida del clustering spazio-temporale non parametrico. Ha pubblicato molti articoli nelle conferenze ACL, ICDM, KDD e Royal Statistical Society: Series A.

Vishaal Yalamanchali è uno Startup Solutions Architect che lavora con aziende in fase iniziale di intelligenza artificiale generativa, robotica e veicoli autonomi. Vishaal collabora con i suoi clienti per fornire soluzioni ML all'avanguardia ed è personalmente interessato all'apprendimento per rinforzo, alla valutazione LLM e alla generazione di codice. Prima di AWS, Vishaal era uno studente universitario presso l'UCI, specializzato in bioinformatica e sistemi intelligenti.

Meenakshisundaram Tandavarayan lavora per AWS come specialista di IA/ML. Ha una passione per progettare, creare e promuovere esperienze di analisi e dati incentrati sull'uomo. Meena si concentra sullo sviluppo di sistemi sostenibili che offrano vantaggi competitivi e misurabili per i clienti strategici di AWS. Meena è una connettore e una pensatrice del design e si impegna a guidare le aziende verso nuovi modi di lavorare attraverso l'innovazione, l'incubazione e la democratizzazione.

Dottor Ashish Khetan è un Senior Applied Scientist con algoritmi integrati di Amazon SageMaker e aiuta a sviluppare algoritmi di machine learning. Ha conseguito il dottorato di ricerca presso l'Università dell'Illinois Urbana-Champaign. È un ricercatore attivo nell'apprendimento automatico e nell'inferenza statistica e ha pubblicato numerosi articoli nelle conferenze NeurIPS, ICML, ICLR, JMLR, ACL e EMNLP.

• Distribuzione di contenuti basati su SEO e PR. Ricevi amplificazione oggi.
• PlatoData.Network Generativo verticale Ai. Potenzia te stesso. Accedi qui.
• PlatoAiStream. Intelligenza Web3. Conoscenza amplificata. Accedi qui.
• PlatoneESG. Carbonio, Tecnologia pulita, Energia, Ambiente, Solare, Gestione dei rifiuti. Accedi qui.
• Platone Salute. Intelligence sulle biotecnologie e sulle sperimentazioni cliniche. Accedi qui.
• Fonte: https://aws.amazon.com/blogs/machine-learning/fine-tune-code-llama-on-amazon-sagemaker-jumpstart/