Ajustați Code Llama pe Amazon SageMaker JumpStart | Amazon Web Services

Astăzi, suntem încântați să anunțăm capacitatea de a ajusta modelele Code Llama folosind Meta Amazon SageMaker JumpStart. Familia Code Llama de modele de limbaj mari (LLM) este o colecție de modele de generare de cod pre-antrenate și ajustate, cu o scară cuprinsă între 7 miliarde și 70 de miliarde de parametri. Modelele Code Llama ajustate oferă o mai bună acuratețe și explicabilitate față de modelele de bază Code Llama, așa cum este evident în testarea acestuia împotriva HumanEval și seturi de date MBPP. Puteți ajusta și implementa modele Code Llama cu SageMaker JumpStart folosind Amazon SageMaker Studio Interfața de utilizare cu câteva clicuri sau folosind SDK-ul SageMaker Python. Reglarea fină a modelelor Llama se bazează pe scripturile furnizate în rețete-lama GitHub repo de la Meta folosind tehnici de cuantizare PyTorch FSDP, PEFT/LoRA și Int8.

În această postare, vom expune cum să reglam modelele pre-antrenate Code Llama prin SageMaker JumpStart printr-o interfață de utilizare cu un singur clic și experiență SDK disponibile în următoarele GitHub depozit.

Ce este SageMaker JumpStart

Cu SageMaker JumpStart, practicienii de învățare automată (ML) pot alege dintr-o selecție largă de modele de fundație disponibile public. Practicienii ML pot implementa modele de fundație pentru dedicate Amazon SageMaker instanțe dintr-un mediu izolat în rețea și personalizați modelele folosind SageMaker pentru instruirea și implementarea modelelor.

Ce este Code Llama

Code Llama este o versiune specializată în cod Lama 2 care a fost creat prin instruirea suplimentară a Llama 2 pe seturile de date specifice codului și prin prelevarea mai multor date din același set de date pentru mai mult timp. Code Llama are capabilități de codare îmbunătățite. Poate genera cod și limbaj natural despre cod, atât din solicitările codului, cât și din limbajul natural (de exemplu, „Scrie-mi o funcție care scoate secvența Fibonacci”). De asemenea, îl puteți folosi pentru completarea codului și depanare. Acceptă multe dintre cele mai populare limbaje de programare folosite astăzi, inclusiv Python, C++, Java, PHP, Typescript (JavaScript), C#, Bash și multe altele.

De ce să reglați fin modelele Code Llama

Meta a publicat benchmark-uri de performanță Code Llama pe HumanEval și MBPP pentru limbaje de codare comune, cum ar fi Python, Java și JavaScript. Performanța modelelor Code Llama Python pe HumanEval a demonstrat performanțe diferite în diferite limbaje de codare și sarcini, variind de la 38% pe modelul 7B Python la 57% pe modelele 70B Python. În plus, modelele Code Llama ajustate pe limbajul de programare SQL au arătat rezultate mai bune, așa cum se vede în benchmark-urile de evaluare SQL. Aceste repere publicate evidențiază beneficiile potențiale ale reglarii fine a modelelor Code Llama, permițând performanțe, personalizare și adaptare mai bune la domenii și sarcini specifice de codare.

Reglare fină fără cod prin interfața de utilizare SageMaker Studio

Pentru a începe reglarea fină a modelelor Llama folosind SageMaker Studio, parcurgeți următorii pași:

1. Pe consola SageMaker Studio, alegeți pornire în panoul de navigare.

Veți găsi liste cu peste 350 de modele, de la modele open source și proprietare.

2. Căutați modele Code Llama.
   

Dacă nu vedeți modele Code Llama, vă puteți actualiza versiunea SageMaker Studio prin închiderea și repornirea. Pentru mai multe informații despre actualizările versiunii, consultați Închideți și actualizați aplicațiile Studio. Poti gasi si alte variante de model alegand Explorați toate modelele de generare de cod sau căutând Code Llama în caseta de căutare.

SageMaker JumpStart acceptă în prezent reglarea fină a instrucțiunilor pentru modelele Code Llama. Următoarea captură de ecran arată pagina de reglare fină pentru modelul Code Llama 2 70B.

3. Pentru Locația setului de date de antrenament, puteți indica Serviciul Amazon de stocare simplă Bucket (Amazon S3) care conține seturile de date de instruire și validare pentru reglare fină.
4. Setați configurația de implementare, hiperparametrii și setările de securitate pentru reglare fină.
5. Alege Tren pentru a începe lucrarea de reglare fină pe o instanță SageMaker ML.
   

Discutăm formatul setului de date de care aveți nevoie să vă pregătiți pentru reglarea fină a instrucțiunilor în secțiunea următoare.

6. După ce modelul este reglat fin, îl puteți implementa folosind pagina de model din SageMaker JumpStart.

Opțiunea de a implementa modelul reglat fin va apărea când reglarea fină este terminată, așa cum se arată în următoarea captură de ecran.

Reglați fin prin intermediul SDK-ului SageMaker Python

În această secțiune, demonstrăm cum să reglați fin modelele Code LIama utilizând SDK-ul SageMaker Python pe un set de date formatat cu instrucțiuni. În mod specific, modelul este reglat fin pentru un set de sarcini de procesare a limbajului natural (NLP) descrise folosind instrucțiuni. Acest lucru ajută la îmbunătățirea performanței modelului pentru sarcini nevăzute cu solicitări zero-shot.

Parcurgeți următorii pași pentru a finaliza lucrarea de reglare fină. Puteți obține întregul cod de reglare fină de la GitHub depozit.

Mai întâi, să ne uităm la formatul setului de date necesar pentru reglarea fină a instrucțiunilor. Datele de antrenament ar trebui să fie formatate într-un format de linii JSON (.jsonl), unde fiecare linie este un dicționar care reprezintă un eșantion de date. Toate datele de antrenament trebuie să fie într-un singur folder. Cu toate acestea, poate fi salvat în mai multe fișiere .jsonl. Următorul este un exemplu în format de linii 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'
}

Dosarul de antrenament poate conține a template.json fișier care descrie formatele de intrare și de ieșire. Următorul este un exemplu de șablon:

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

Pentru a se potrivi cu șablonul, fiecare eșantion din fișierele de linii JSON trebuie să includă system_prompt, question, și response câmpuri. În această demonstrație, folosim Setul de date Dolphin Coder din Hugging Face.

După ce pregătiți setul de date și îl încărcați în compartimentul S3, puteți începe reglarea fină folosind următorul cod:

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

Puteți implementa modelul ajustat direct din estimator, așa cum se arată în codul următor. Pentru detalii, consultați caietul din GitHub depozit.

finetuned_predictor = estimator.deploy()

Tehnici de reglare fină

Modelele de limbaj precum Llama au o dimensiune mai mare de 10 GB sau chiar 100 GB. Reglarea fină a modelelor atât de mari necesită instanțe cu memorie CUDA semnificativ mare. Mai mult, antrenarea acestor modele poate fi foarte lent din cauza dimensiunii modelului. Prin urmare, pentru o reglare fină eficientă, folosim următoarele optimizări:

• Adaptare de rang scăzut (LoRA) – Acesta este un tip de reglare fină eficientă a parametrilor (PEFT) pentru reglarea fină eficientă a modelelor mari. Cu această metodă, înghețați întregul model și adăugați doar un set mic de parametri sau straturi reglabile în model. De exemplu, în loc să antrenați toate cele 7 miliarde de parametri pentru Llama 2 7B, puteți regla mai puțin de 1% dintre parametri. Acest lucru ajută la reducerea semnificativă a necesarului de memorie, deoarece trebuie să stocați doar gradienți, stări de optimizare și alte informații legate de antrenament pentru doar 1% din parametri. În plus, acest lucru ajută la reducerea timpului de antrenament, precum și a costurilor. Pentru mai multe detalii despre această metodă, consultați LoRA: Low-Rank Adaptation of Large Language Models.
• Cuantizarea Int8 – Chiar și cu optimizări precum LoRA, modelele precum Llama 70B sunt încă prea mari pentru a fi antrenate. Pentru a reduce amprenta memoriei în timpul antrenamentului, puteți utiliza cuantizarea Int8 în timpul antrenamentului. Cuantificarea reduce de obicei precizia tipurilor de date în virgulă mobilă. Deși acest lucru scade memoria necesară pentru stocarea greutăților modelului, degradează performanța din cauza pierderii de informații. Cuantizarea Int8 folosește doar un sfert de precizie, dar nu implică o degradare a performanței, deoarece nu reduce pur și simplu biții. Rotunjește datele de la un tip la altul. Pentru a afla despre cuantizarea Int8, consultați LLM.int8(): Înmulțirea matricei pe 8 biți pentru transformatoare la scară.
• Paralel de date complet fragmentate (FSDP) – Acesta este un tip de algoritm de antrenament în paralel cu date care împarte parametrii modelului între lucrătorii paraleli de date și poate, opțional, să descarce o parte din calculul antrenamentului către procesoare. Deși parametrii sunt împărțiți în diferite GPU-uri, calculul fiecărui microbatch este local pentru lucrătorul GPU. Se fragmentează parametrii în mod mai uniform și obține performanțe optimizate prin suprapunere de comunicare și calcul în timpul antrenamentului.

Următorul tabel rezumă detaliile fiecărui model cu setări diferite.

Reglarea fină a modelelor Llama se bazează pe scripturile furnizate de următoarele GitHub repo.

Hiperparametri acceptați pentru antrenament

Reglajul fin Code Llama 2 acceptă o serie de hiperparametri, fiecare dintre acestea putând avea un impact asupra cerințelor de memorie, a vitezei de antrenament și a performanței modelului reglat fin:

• epocă – Numărul de treceri efectuate de algoritmul de reglare fină prin setul de date de antrenament. Trebuie să fie un număr întreg mai mare decât 1. Implicit este 5.
• rata_de_învățare – Rata cu care greutățile modelului sunt actualizate după ce se lucrează la fiecare lot de exemple de antrenament. Trebuie să fie un float pozitiv mai mare decât 0. Implicit este 1e-4.
• instruction_tuned – Dacă trebuie să instruiți sau nu modelul. Trebuie să fie True or False. Implicit este False.
• per_device_train_batch_size – Dimensiunea lotului per nucleu GPU/CPU pentru antrenament. Trebuie să fie un număr întreg pozitiv. Implicit este 4.
• per_device_eval_batch_size – Dimensiunea lotului per nucleu GPU/CPU pentru evaluare. Trebuie să fie un număr întreg pozitiv. Implicit este 1.
• max_train_samples – În scopuri de depanare sau de instruire mai rapidă, trunchiați numărul de exemple de antrenament la această valoare. Valoarea -1 înseamnă utilizarea tuturor mostrelor de antrenament. Trebuie să fie un număr întreg pozitiv sau -1. Implicit este -1.
• max_val_samples – În scopuri de depanare sau de instruire mai rapidă, trunchiați numărul de exemple de validare la această valoare. Valoarea -1 înseamnă utilizarea tuturor probelor de validare. Trebuie să fie un număr întreg pozitiv sau -1. Implicit este -1.
• lungime_intrare_max – Lungimea totală maximă a secvenței de intrare după tokenizare. Secvențele mai lungi decât aceasta vor fi trunchiate. Dacă -1, max_input_length este setată la minimul de 1024 și lungimea maximă a modelului definită de tokenizer. Dacă este setată la o valoare pozitivă, max_input_length este setat la minimul valorii furnizate și model_max_length definit de tokenizer. Trebuie să fie un număr întreg pozitiv sau -1. Implicit este -1.
• raportul_diviziunii_validării – Dacă canalul de validare este none, raportul diviziunii de validare a trenului din datele trenului trebuie să fie între 0–1. Implicit este 0.2.
• semințe_divizate_date_trenului – Dacă datele de validare nu sunt prezente, acest lucru fixează împărțirea aleatorie a datelor de antrenament de intrare în datele de antrenament și validare utilizate de algoritm. Trebuie să fie un număr întreg. Implicit este 0.
• preprocessing_num_workers – Numărul de procese de utilizat pentru preprocesare. Dacă None, procesul principal este utilizat pentru preprocesare. Implicit este None.
• lora_r – Lora R. Trebuie să fie un număr întreg pozitiv. Implicit este 8.
• lora_alpha – Lora Alpha. Trebuie să fie un număr întreg pozitiv. Implicit este 32
• lora_dropout – Lora Dropout. trebuie să fie un float pozitiv între 0 și 1. Implicit este 0.05.
• int8_quantization - În cazul în care True, modelul este încărcat cu precizie de 8 biți pentru antrenament. Implicit pentru 7B și 13B este False. Implicit pentru 70B este True.
• enable_fsdp – Dacă este adevărat, antrenamentul folosește FSDP. Implicit pentru 7B și 13B este True. Implicit pentru 70B este False. Rețineți că int8_quantization nu este acceptat cu FSDP.

Atunci când alegeți hiperparametrii, luați în considerare următoarele:

• reglaj int8_quantization=True scade necesarul de memorie si duce la un antrenament mai rapid.
• In scadere per_device_train_batch_size și max_input_length reduce necesarul de memorie și, prin urmare, poate fi rulat pe instanțe mai mici. Totuși, setarea unor valori foarte scăzute poate crește timpul de antrenament.
• Dacă nu utilizați cuantizarea Int8 (int8_quantization=False), utilizați FSDP (enable_fsdp=True) pentru un antrenament mai rapid și eficient.

Tipuri de instanțe acceptate pentru instruire

Următorul tabel rezumă tipurile de instanțe acceptate pentru antrenarea diferitelor modele.

Atunci când alegeți tipul de instanță, luați în considerare următoarele:

• Instanțele G5 oferă cea mai eficientă instruire dintre tipurile de instanțe acceptate. Prin urmare, dacă aveți instanțe G5 disponibile, ar trebui să le utilizați.
• Timpul de antrenament depinde în mare măsură de numărul de GPU-uri și de memoria CUDA disponibilă. Prin urmare, antrenamentul pe instanțe cu același număr de GPU (de exemplu, ml.g5.2xlarge și ml.g5.4xlarge) este aproximativ același. Prin urmare, puteți folosi instanța mai ieftină pentru antrenament (ml.g5.2xlarge).
• Când utilizați instanțe p3, antrenamentul se va face cu o precizie de 32 de biți, deoarece bfloat16 nu este acceptat în aceste instanțe. Prin urmare, munca de antrenament va consuma dublul cantității de memorie CUDA atunci când se antrenează pe instanțe p3, comparativ cu instanțele g5.

Pentru a afla despre costul instruirii pe instanță, consultați Instanțe Amazon EC2 G5.

Evaluare

Evaluarea este un pas important pentru a evalua performanța modelelor reglate fin. Prezentăm evaluări atât calitative, cât și cantitative pentru a arăta îmbunătățirea modelelor reglate fin față de cele neajustate. În evaluarea calitativă, arătăm un exemplu de răspuns din ambele modele ajustate și neajustate. În evaluarea cantitativă, folosim HumanEval, o suită de teste dezvoltată de OpenAI pentru a genera cod Python pentru a testa abilitățile de a produce rezultate corecte și precise. Depozitul HumanEval este sub licență MIT. Am ajustat variantele Python ale tuturor modelelor Code LIama pe diferite dimensiuni (Code LIama Python 7B, 13B, 34B și 70B pe Setul de date Dolphin Coder), și prezentați rezultatele evaluării în secțiunile următoare.

Evaluare calitativă

Cu modelul reglat fin implementat, puteți începe să utilizați punctul final pentru a genera cod. În exemplul următor, prezentăm răspunsuri din variantele de bază și ajustate ale Codului LIama 34B Python pe un eșantion de testare în Setul de date 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"]

Modelul Code Llama ajustat, pe lângă faptul că oferă codul pentru interogarea precedentă, generează o explicație detaliată a abordării și un pseudocod.

Cod Llama 34b Python Răspuns neajustat:

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

Cod Llama 34B Python Răspuns reglat fin

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

Adevărul la sol

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

Interesant este că versiunea noastră reglată fin de Code Llama 34B Python oferă o soluție dinamică bazată pe programare pentru cel mai lung subșir palindromic, care este diferită de soluția furnizată în adevărul de bază din exemplul de test selectat. Modelul nostru ajustat motivează și explică în detaliu soluția bazată pe programare dinamică. Pe de altă parte, modelul neajustat halucinează potențiale rezultate imediat după print instrucțiune (afișată în celula din stânga) deoarece rezultatul axyzzyx nu este cel mai lung palindrom din șirul dat. În ceea ce privește complexitatea timpului, soluția de programare dinamică este în general mai bună decât abordarea inițială. Soluția de programare dinamică are o complexitate de timp de O(n^2), unde n este lungimea șirului de intrare. Aceasta este mai eficientă decât soluția inițială din modelul neajustat, care avea și o complexitate de timp pătratică de O(n^2), dar cu o abordare mai puțin optimizată.

Asta pare promitator! Amintiți-vă, am ajustat doar varianta Code LIama Python cu 10% din Setul de date Dolphin Coder. Mai sunt multe de explorat!

În ciuda instrucțiunilor detaliate din răspuns, trebuie totuși să examinăm corectitudinea codului Python furnizat în soluție. În continuare, folosim un cadru de evaluare numit Evaluare umană pentru a rula teste de integrare pe răspunsul generat de Code LIama pentru a examina sistematic calitatea acestuia.

Evaluare cantitativă cu HumanEval

HumanEval este un ham de evaluare pentru evaluarea capabilităților de rezolvare a problemelor unui LLM cu privire la problemele de codare bazate pe Python, așa cum este descris în lucrare Evaluarea modelelor lingvistice mari instruite pe cod. Mai exact, constă din 164 de probleme originale de programare bazate pe Python care evaluează capacitatea unui model de limbaj de a genera cod pe baza informațiilor furnizate, cum ar fi semnătura funcției, docstring, corpul și testele unitare.

Pentru fiecare întrebare de programare bazată pe Python, o trimitem la un model Code LIama implementat pe un punct final SageMaker pentru a obține k răspunsuri. Apoi, rulăm fiecare dintre cele k răspunsuri la testele de integrare din depozitul HumanEval. Dacă orice răspuns al celor k răspunsuri trece testele de integrare, numărăm acel caz de testare reușit; altfel, a esuat. Apoi repetăm ​​procesul pentru a calcula raportul cazurilor de succes ca punctajul final al evaluării numit pass@k. Urmând practica standard, am stabilit k ca 1 în evaluarea noastră, pentru a genera un singur răspuns per întrebare și a testa dacă trece testul de integrare.

Următorul este un exemplu de cod pentru a utiliza depozitul HumanEval. Puteți accesa setul de date și puteți genera un singur răspuns folosind un punct final SageMaker. Pentru detalii, consultați caietul din GitHub depozit.

%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')

Următorul tabel arată îmbunătățirile modelelor Code LIama Python ajustate față de modelele neajustate pe diferite dimensiuni de model. Pentru a asigura corectitudinea, implementăm și modelele Code LIama neajustate în punctele finale SageMaker și rulăm prin evaluări Human Eval. The trece@1 numerele (primul rând din tabelul următor) se potrivesc cu numerele raportate în Lucrare de cercetare Code Llama. Parametrii de inferență sunt stabiliți în mod constant ca "parameters": {"max_new_tokens": 384, "temperature": 0.2}.

După cum putem vedea din rezultate, toate variantele Code LIama Python ajustate arată o îmbunătățire semnificativă față de modelele neajustate. În special, Code LIama Python 70B depășește cu aproximativ 12% modelul neajustat.

Acum puteți încerca să reglați fin modelele Code LIama pe propriul set de date.

A curăța

Dacă decideți că nu mai doriți să păstrați punctul final SageMaker în funcțiune, îl puteți șterge folosind SDK AWS pentru Python (Boto3), Interfața liniei de comandă AWS (AWS CLI) sau consola SageMaker. Pentru mai multe informații, consultați Ștergeți punctele finale și resursele. În plus, poți închideți resursele SageMaker Studio care nu mai sunt necesare.

Concluzie

În această postare, am discutat despre reglarea fină a modelelor Meta's Code Llama 2 folosind SageMaker JumpStart. Am arătat că puteți utiliza consola SageMaker JumpStart în SageMaker Studio sau SDK-ul SageMaker Python pentru a regla și implementa aceste modele. Am discutat, de asemenea, despre tehnica de reglare fină, tipurile de instanțe și hiperparametrii acceptați. În plus, am subliniat recomandări pentru o pregătire optimizată pe baza diferitelor teste pe care le-am efectuat. După cum putem vedea din aceste rezultate ale reglajului fin a trei modele pe două seturi de date, reglarea fină îmbunătățește rezumarea în comparație cu modelele neajustate. Ca pas următor, puteți încerca să reglați aceste modele pe propriul set de date folosind codul furnizat în depozitul GitHub pentru a testa și compara rezultatele pentru cazurile dvs. de utilizare.

Despre Autori

Dr. Xin Huang este cercetător aplicat senior pentru algoritmii încorporați Amazon SageMaker JumpStart și Amazon SageMaker. El se concentrează pe dezvoltarea de algoritmi scalabili de învățare automată. Interesele sale de cercetare sunt în domeniul prelucrării limbajului natural, al învățării profunde explicabile pe date tabulare și al analizei robuste a grupării non-parametrice spațiu-timp. A publicat multe lucrări în ACL, ICDM, conferințe KDD și Royal Statistical Society: Series A.

Vishaal Yalamanchali este un arhitect de soluții de pornire care lucrează cu companii de IA generativă, robotică și vehicule autonome în stadiu incipient. Vishaal lucrează cu clienții săi pentru a oferi soluții de ML de ultimă oră și este personal interesat de învățare prin consolidare, evaluare LLM și generare de cod. Înainte de AWS, Vishaal a fost student la UCI, concentrat pe bioinformatică și sisteme inteligente.

Meenakshisundaram Thandavarayan lucrează pentru AWS ca specialist AI/ML. Are o pasiune de a proiecta, crea și promova experiențe de analiză și date centrate pe om. Meena se concentrează pe dezvoltarea de sisteme sustenabile care oferă avantaje măsurabile și competitive pentru clienții strategici ai AWS. Meena este un conector și gânditor de design și se străduiește să conducă afacerile către noi moduri de lucru prin inovare, incubare și democratizare.

Dr. Ashish Khetan este un om de știință senior aplicat cu algoritmi încorporați Amazon SageMaker și ajută la dezvoltarea algoritmilor de învățare automată. Și-a luat doctoratul la Universitatea din Illinois Urbana-Champaign. Este un cercetător activ în învățarea automată și inferența statistică și a publicat multe lucrări în conferințele NeurIPS, ICML, ICLR, JMLR, ACL și EMNLP.

• Distribuție de conținut bazat pe SEO și PR. Amplifică-te astăzi.
• PlatoData.Network Vertical Generative Ai. Împuterniciți-vă. Accesați Aici.
• PlatoAiStream. Web3 Intelligence. Cunoștințe amplificate. Accesați Aici.
• PlatoESG. carbon, CleanTech, Energie, Mediu inconjurator, Solar, Managementul deșeurilor. Accesați Aici.
• PlatoHealth. Biotehnologie și Inteligență pentru studii clinice. Accesați Aici.
• Sursa: https://aws.amazon.com/blogs/machine-learning/fine-tune-code-llama-on-amazon-sagemaker-jumpstart/