Täpsustage Code Llama rakenduses Amazon SageMaker JumpStart | Amazoni veebiteenused

Täna on meil hea meel teatada, et Meta abil on võimalik Code Llama mudeleid peenhäälestada Amazon SageMaker JumpStart. Code Llama suurte keelemudelite (LLM) perekond on eelkoolitatud ja peenhäälestatud koodi genereerimise mudelite kogum, mille skaala ulatub 7 miljardist 70 miljardi parameetrini. Peenhäälestatud Code Llama mudelid pakuvad paremat täpsust ja seletatavust võrreldes Code Llama põhimudelitega, nagu ilmneb selle testimisel. HumanEval ja MBPP andmekogumid. Code Llama mudeleid saate SageMaker JumpStarti abil peenhäälestada ja juurutada Amazon SageMaker Studio Kasutajaliides mõne klõpsuga või SageMaker Python SDK abil. Llama mudelite peenhäälestus põhineb dokumendis esitatud skriptidel laama-retseptid GitHubi repo Metast, kasutades PyTorch FSDP, PEFT/LoRA ja Int8 kvantimistehnikaid.

Selles postituses käsitleme Code Llama eelkoolitatud mudelite viimistlemist SageMaker JumpStarti kaudu ühe klõpsuga kasutajaliidese ja SDK kogemuse kaudu, mis on saadaval järgmistes kohtades. GitHubi hoidla.

Mis on SageMaker JumpStart

SageMaker JumpStarti abil saavad masinõppe (ML) praktikud valida laia valiku avalikult saadaolevate alusmudelite hulgast. ML-praktikud saavad sihtotstarbeliselt kasutusele võtta sihtasutuse mudelid Amazon SageMaker eksemplare võrgust eraldatud keskkonnast ja kohandage mudeleid SageMakeri abil mudeli koolituseks ja juurutamiseks.

Mis on Code Lama

Code Llama on koodile spetsialiseerunud versioon Laama 2 mis loodi Llama 2 koodispetsiifiliste andmekogumite edasiõppimisel ja samast andmekogumist pikema aja jooksul rohkemate andmete valimisega. Code Llamal on täiustatud kodeerimisvõimalused. See võib genereerida koodi ja loomuliku keele koodi kohta nii koodi kui ka loomuliku keele viipadest (näiteks "Kirjutage mulle funktsioon, mis väljastab Fibonacci jada"). Saate seda kasutada ka koodi lõpetamiseks ja silumiseks. See toetab paljusid tänapäeval kasutatavaid populaarsemaid programmeerimiskeeli, sealhulgas Python, C++, Java, PHP, Typescript (JavaScript), C#, Bash ja palju muud.

Miks Code Llama mudeleid peenhäälestada

Meta avaldas Code Llama jõudlusnäitajad HumanEval ja MBPP levinud kodeerimiskeelte jaoks, nagu Python, Java ja JavaScript. Code Llama Pythoni mudelite jõudlus HumanEvalis näitas erinevat jõudlust erinevates kodeerimiskeeltes ja -ülesannetes vahemikus 38% Pythoni 7B mudelil kuni 57% 70B Pythoni mudelitel. Lisaks on SQL-i programmeerimiskeele peenhäälestatud Code Llama mudelid näidanud paremaid tulemusi, nagu ilmneb SQL-i hindamise võrdlusalustest. Need avaldatud võrdlusnäitajad toovad esile Code Llama mudelite peenhäälestuse võimalikud eelised, mis võimaldavad paremat jõudlust, kohandamist ja kohandamist konkreetsete kodeerimisvaldkondade ja ülesannetega.

Koodivaba peenhäälestus SageMaker Studio kasutajaliidese kaudu

Llama mudelite peenhäälestamise alustamiseks SageMaker Studio abil toimige järgmiselt.

1. Valige SageMaker Studio konsoolil KiirStart navigeerimispaanil.

Leiate enam kui 350 mudeli loendid, alates avatud lähtekoodiga mudelitest kuni patenteeritud mudeliteni.

2. Otsi Code Llama mudeleid.
   

Kui te Code Llama mudeleid ei näe, saate oma SageMaker Studio versiooni värskendada, sulgedes ja taaskäivitades. Versioonivärskenduste kohta lisateabe saamiseks vaadake Lülitage Studio rakendused välja ja värskendage neid. Valides leiate ka teisi mudelivariante Tutvuge kõigi koodi genereerimise mudelitega või otsides otsingukastist Code Lama.

SageMaker JumpStart toetab praegu Code Llama mudelite juhiste peenhäälestamist. Järgmine ekraanipilt näitab Code Llama 2 70B mudeli peenhäälestuslehte.

3. eest Koolituse andmestiku asukoht, võite osutada Amazoni lihtne salvestusteenus (Amazon S3) kopp, mis sisaldab peenhäälestamiseks mõeldud koolitus- ja valideerimisandmekogumeid.
4. Määrake peenhäälestamiseks juurutamise konfiguratsioon, hüperparameetrid ja turbesätted.
5. Vali Rong et alustada SageMaker ML eksemplari peenhäälestustööd.
   

Järgmises jaotises käsitleme andmekogumi vormingut, mida vajate juhiste peenhäälestamiseks.

6. Pärast mudeli peenhäälestamist saate selle juurutada, kasutades SageMakeri JumpStarti mudelilehte.

Peenhäälestatud mudeli juurutamise valik kuvatakse, kui peenhäälestus on lõppenud, nagu on näidatud järgmisel ekraanipildil.

Täpsustage SageMaker Python SDK kaudu

Selles jaotises näitame, kuidas viimistleda Code LIama mudeleid, kasutades SageMaker Python SDK-d käsuvormingus andmestikul. Täpsemalt, mudel on peenhäälestatud loomuliku keele töötlemise (NLP) ülesannete komplekti jaoks, mida kirjeldatakse juhiste abil. See aitab nullkaadri viipade abil parandada mudeli jõudlust nähtamatute ülesannete puhul.

Täppishäälestustöö lõpuleviimiseks täitke järgmised sammud. Kogu peenhäälestuskoodi saate aadressilt GitHubi hoidla.

Kõigepealt vaatame käsu peenhäälestamiseks vajalikku andmestiku vormingut. Treeningandmed tuleks vormindada JSON-ridade (.jsonl) vormingusse, kus iga rida on andmenäidist esindav sõnastik. Kõik treeninguandmed peavad olema ühes kaustas. Selle saab aga salvestada mitmesse jsonl-faili. Järgmine on JSON-ridade vormingu näidis:

{
	'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'
}

Koolitusmapp võib sisaldada a template.json fail, mis kirjeldab sisend- ja väljundvorminguid. Järgmine on näidismall:

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

Malliga sobitamiseks peab iga JSON-ridade faili näidis sisaldama system_prompt, questionja response väljad. Selles esitluses kasutame Dolphin Coderi andmestik alates Hugging Face.

Pärast andmestiku ettevalmistamist ja selle S3 ämbrisse laadimist saate alustada peenhäälestamist järgmise koodi abil.

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

Täppishäälestatud mudeli saate juurutada otse hindajast, nagu on näidatud järgmises koodis. Üksikasjalikumat teavet leiate sülearvutist GitHubi hoidla.

finetuned_predictor = estimator.deploy()

Peenhäälestustehnikad

Keelemudelid, nagu Llama, on suuremad kui 10 GB või isegi 100 GB. Selliste suurte mudelite peenhäälestamiseks on vaja märkimisväärselt suure CUDA-mäluga eksemplare. Lisaks võib nende mudelite treenimine mudeli suuruse tõttu olla väga aeglane. Seetõttu kasutame tõhusaks peenhäälestamiseks järgmisi optimeerimisi:

• Madala asetusega kohandamine (LoRA) – See on teatud tüüpi parameetrite tõhus peenhäälestus (PEFT) suurte mudelite tõhusaks peenhäälestamiseks. Selle meetodi abil külmutate kogu mudeli ja lisate mudelisse vaid väikese komplekti reguleeritavaid parameetreid või kihte. Näiteks selle asemel, et treenida kõiki 7 miljardit parameetrit Llama 2 7B jaoks, saate peenhäälestada vähem kui 1% parameetritest. See aitab oluliselt vähendada mäluvajadust, kuna peate salvestama ainult 1% parameetrite gradiente, optimeerija olekuid ja muud treeninguga seotud teavet. Lisaks aitab see vähendada koolituse aega ja kulusid. Selle meetodi kohta lisateabe saamiseks vaadake LoRA: suurte keelemudelite madalatasemeline kohandamine.
• Int8 kvantimine – Isegi selliste optimeeringutega nagu LoRA on mudelid nagu Llama 70B ikka veel treenimiseks liiga suured. Treeningu ajal mälujalajälje vähendamiseks saate treeningu ajal kasutada Int8 kvantiseerimist. Kvantimine vähendab tavaliselt ujukoma andmetüüpide täpsust. Kuigi see vähendab mudeli kaalude salvestamiseks vajalikku mälu, halvendab see teabe kadumise tõttu jõudlust. Int8 kvantimine kasutab ainult veerandi täpsust, kuid ei põhjusta jõudluse halvenemist, kuna see ei kaota lihtsalt bitte. See ümardab andmed ühelt tüübilt teisele. Int8 kvantimise kohta lisateabe saamiseks vaadake LLM.int8(): 8-bitine maatrikskorrutis mastaabis transformerite jaoks.
• Täielikult jagatud andmete paralleelne (FSDP) – See on teatud tüüpi andmeparalleelne treeningalgoritm, mis killustab mudeli parameetrid andmetega paralleelsete töötajate vahel ja võib valikuliselt osa treeninguarvutustest protsessoritele maha laadida. Kuigi parameetrid on jagatud erinevate GPU-de vahel, on iga mikropartii arvutamine GPU töötaja jaoks kohalik. See killustab parameetreid ühtlasemalt ja saavutab optimeeritud jõudluse suhtluse ja arvutuste kattumise kaudu treeningu ajal.

Järgmine tabel võtab kokku iga mudeli üksikasjad erinevate seadistustega.

Llama mudelite peenhäälestus põhineb alljärgnevatel skriptidel GitHub repo.

Toetatud hüperparameetrid treenimiseks

Code Llama 2 peenhäälestus toetab mitmeid hüperparameetreid, millest igaüks võib mõjutada peenhäälestatud mudeli mälunõuet, treeningkiirust ja jõudlust:

• epohh – Läbimiste arv, mille peenhäälestusalgoritm läbib treeningu andmestiku. Peab olema täisarv, mis on suurem kui 1. Vaikimisi on 5.
• õppimise_määr – Mudeli kaalude värskendamise kiirus pärast iga treeningnäidete partii läbitöötamist. Peab olema positiivne ujuk, mis on suurem kui 0. Vaikimisi on 1e-4.
• instruction_tuned – Kas modelli juhendada-koolitada või mitte. Peab olema True or False. Vaikimisi on False.
• per_device_train_batch_size – Partii suurus GPU tuuma/protsessori kohta koolituse jaoks. Peab olema positiivne täisarv. Vaikimisi on 4.
• per_device_eval_batch_size – Hindamiseks mõeldud partii suurus GPU tuuma/protsessori kohta. Peab olema positiivne täisarv. Vaikimisi on 1.
• max_train_samples – Silumiseks või kiiremaks treenimiseks kärpige treeningnäidete arv selle väärtuseni. Väärtus -1 tähendab kõigi treeningnäidiste kasutamist. Peab olema positiivne täisarv või -1. Vaikimisi on -1.
• max_val_samples – Silumiseks või kiiremaks väljaõppeks kärpige valideerimisnäidete arv selle väärtuseni. Väärtus -1 tähendab kõigi valideerimisnäidiste kasutamist. Peab olema positiivne täisarv või -1. Vaikimisi on -1.
• max_sisendi_pikkus – Sisendjada maksimaalne kogupikkus pärast märgistamist. Sellest pikemad jadad kärbitakse. Kui -1, max_input_length on seatud minimaalseks 1024 ja maksimaalseks mudeli pikkuseks, mille määrab tokenisaator. Kui see on seatud positiivsele väärtusele, max_input_length on seatud antud väärtuse miinimumile ja model_max_length määratletud tokenisaatori poolt. Peab olema positiivne täisarv või -1. Vaikimisi on -1.
• validation_split_ratio – Kui valideerimiskanal on none, peab rongi andmetest eraldatud rongi valideerimise suhe olema vahemikus 0–1. Vaikimisi on 0.2.
• train_data_split_seed – Kui valideerimisandmed puuduvad, fikseerib see sisendtreeningu andmete juhusliku jagamise algoritmi kasutatavateks treening- ja valideerimisandmeteks. Peab olema täisarv. Vaikimisi on 0.
• eeltöötlus_töötajate_arv – eeltöötluseks kasutatavate protsesside arv. Kui None, põhiprotsessi kasutatakse eeltöötluseks. Vaikimisi on None.
• lora_r – Lora R. Peab olema positiivne täisarv. Vaikimisi on 8.
• lora_alpha - Lora Alfa. Peab olema positiivne täisarv. Vaikimisi on 32
• lora_dropout – Lora Dropout. peab olema positiivne ujuk vahemikus 0 kuni 1. Vaikimisi on 0.05.
• int8_kvantimine - Kui True, mudel on treenimiseks laaditud 8-bitise täpsusega. Vaikimisi 7B ja 13B jaoks on False. Vaikimisi on 70B True.
• enable_fsdp – Kui see on tõsi, kasutab koolitus FSDP-d. 7B ja 13B vaikeväärtus on Tõene. 70B vaikeväärtus on False. Pange tähele, et int8_quantization FSDP ei toeta.

Hüperparameetrite valimisel võtke arvesse järgmist:

• Kehtestamine int8_quantization=True vähendab mäluvajadust ja viib kiirema treeninguni.
• Vähenemine per_device_train_batch_size ja max_input_length vähendab mälunõuet ja seetõttu saab seda kasutada väiksematel eksemplaridel. Väga madalate väärtuste seadmine võib aga treeninguaega pikendada.
• Kui te ei kasuta Int8 kvantiseerimist (int8_quantization=False), kasutage FSDP-d (enable_fsdp=True) kiiremaks ja tõhusamaks treenimiseks.

Koolituse toetatud eksemplaritüübid

Järgmine tabel võtab kokku erinevate mudelite koolitamiseks toetatud eksemplaritüübid.

Eksemplari tüübi valimisel võtke arvesse järgmist.

• G5 eksemplarid pakuvad toetatud eksemplaritüüpide seas kõige tõhusamat koolitust. Seega, kui teil on saadaval G5 eksemplare, peaksite neid kasutama.
• Treeningu aeg sõltub suuresti GPU-de arvust ja saadaolevast CUDA mälust. Seetõttu on sama arvu GPU-dega eksemplaride (nt ml.g5.2xlarge ja ml.g5.4xlarge) koolitus ligikaudu sama. Seetõttu saate treenimiseks kasutada odavamat eksemplari (ml.g5.2xlarge).
• P3 eksemplaride kasutamisel toimub koolitus 32-bitise täpsusega, kuna bfloat16 nendel juhtudel ei toetata. Seetõttu kulutab treeningtöö p3 eksemplaridel treenides võrreldes g5 eksemplaridega kaks korda rohkem CUDA mälu.

Koolituse maksumuse kohta eksemplari kohta lisateabe saamiseks vaadake Amazon EC2 G5 eksemplarid.

Hindamine

Hindamine on oluline samm peenhäälestatud mudelite toimivuse hindamisel. Esitame nii kvalitatiivseid kui ka kvantitatiivseid hinnanguid, et näidata peenhäälestatud mudelite paranemist võrreldes mitte-peenhäälestatud mudelitega. Kvalitatiivses hindamises näitame nii peenhäälestatud kui ka peenhäälestamata mudelite vastust. Kvantitatiivsel hindamisel kasutame HumanEval, OpenAI välja töötatud testikomplekt Pythoni koodi genereerimiseks, et testida õigete ja täpsete tulemuste andmise võimet. HumanEvali hoidla on MIT-i litsentsi all. Täpsustasime kõigi Code LIama mudelite Pythoni variante eri suurustes (kood LIama Python 7B, 13B, 34B ja 70B seadmel Dolphin Coderi andmestik) ja esitage hindamistulemused järgmistes osades.

Kvalitatiivne hindamine

Kui teie peenhäälestatud mudel on juurutatud, saate hakata koodi genereerimiseks kasutama lõpp-punkti. Järgmises näites esitame vastused nii põhi- kui ka peenhäälestatud Code LIama 34B Pythoni variantidest testnäidises Dolphin Coderi andmestik:

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"]

Täppishäälestatud Code Llama mudel genereerib lisaks eelneva päringu koodi andmisele lähenemise üksikasjaliku selgituse ja pseudokoodi.

Code Llama 34b Pythoni peenhäälestuseta vastus:

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

Code Llama 34B Pythoni peenhäälestatud vastus

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

Põhjendatud tõde

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

Huvitaval kombel pakub meie Code Llama 34B Pythoni peenhäälestatud versioon dünaamilise programmeerimisel põhinevat lahendust pikima palindroomse alamstringi jaoks, mis erineb valitud testnäite põhitões pakutavast lahendusest. Meie peenhäälestatud mudel põhjendab ja selgitab üksikasjalikult dünaamilist programmeerimispõhist lahendust. Teisest küljest hallutsineerib peenhäälestuseta mudel potentsiaalseid väljundeid kohe pärast print avaldus (näidatud vasakpoolses lahtris), kuna väljund axyzzyx ei ole antud stringi pikim palindroom. Ajalise keerukuse poolest on dünaamiline programmeerimislahendus üldiselt parem kui esialgne lähenemine. Dünaamilise programmeerimislahenduse ajaline keerukus on O(n^2), kus n on sisendstringi pikkus. See on tõhusam kui peenhäälestuseta mudeli esialgne lahendus, millel oli ka ruutajaline keerukus O (n ^ 2), kuid vähem optimeeritud lähenemisviisiga.

See tundub paljulubav! Pidage meeles, et koodi LIama Pythoni varianti peenhäälestasime ainult 10% -ga Dolphin Coderi andmestik. Uurida on veel palju!

Vaatamata põhjalikele juhistele vastuses, peame siiski uurima lahenduses esitatud Pythoni koodi õigsust. Järgmisena kasutame hindamisraamistikku nimega Inimene Eval käivitada Code LIama loodud vastuse integratsioonitestid, et süstemaatiliselt kontrollida selle kvaliteeti.

Kvantitatiivne hindamine HumanEvaliga

HumanEval on hindamisriist LLM-i probleemide lahendamise võimete hindamiseks Pythoni-põhiste kodeerimisprobleemide puhul, nagu on kirjeldatud artiklis Koodi järgi koolitatud suurte keelemudelite hindamine. Täpsemalt koosneb see 164 algsest Pythoni-põhisest programmeerimisprobleemist, mis hindavad keelemudeli võimet genereerida koodi esitatud teabe, näiteks funktsiooni allkirja, dokumendistringi, keha- ja ühikutestide põhjal.

Iga Pythoni-põhise programmeerimisküsimuse jaoks saadame selle Code LIama mudelile, mis on juurutatud SageMakeri lõpp-punktis, et saada k vastust. Järgmisena käivitame HumanEvali hoidlas integratsioonitestides kõik k vastusest. Kui mõni vastus k vastusest läbib integratsioonitestid, loeme, et testjuhtum õnnestus; muidu ebaõnnestus. Seejärel kordame protsessi, et arvutada edukate juhtumite suhe lõpliku hindamisskoorina pass@k. Tavapraktikat järgides määrasime oma hindamisel k väärtuseks 1, et genereerida ainult üks vastus küsimuse kohta ja testida, kas see läbib integratsioonitesti.

Järgmine on HumanEvali hoidla kasutamise näidiskood. Saate juurdepääsu andmestikule ja luua ühe vastuse, kasutades SageMakeri lõpp-punkti. Üksikasjalikumat teavet leiate sülearvutist GitHubi hoidla.

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

Järgmises tabelis on näidatud peenhäälestatud Code LIama Pythoni mudelite täiustused võrreldes peenhäälestamata mudelitega erinevates mudelisuurustes. Korrektsuse tagamiseks juurutame SageMakeri lõpp-punktides ka viimistlemata Code LIama mudelid ja läbime Human Evali hinnangud. The pass@1 numbrid (järgmise tabeli esimene rida) vastavad esitatud numbritele Code Lama uurimistöö. Järeldusparameetrid on järjepidevalt seatud kui "parameters": {"max_new_tokens": 384, "temperature": 0.2}.

Nagu tulemustest näeme, näitavad kõik peenhäälestatud Code LIama Pythoni variandid märkimisväärselt paranemist võrreldes peenhäälestamata mudelitega. Eelkõige ületab Code LIama Python 70B peenhäälestamata mudelit ligikaudu 12%.

Nüüd saate proovida Code LIama mudeleid oma andmekogumis peenhäälestada.

Koristage

Kui otsustate, et te ei soovi enam SageMakeri lõpp-punkti töös hoida, saate selle kustutada AWS SDK Pythoni jaoks (Boto3), AWS-i käsurea liides (AWS CLI) või SageMakeri konsool. Lisateabe saamiseks vt Kustutage lõpp-punktid ja ressursid. Lisaks saate sulgege SageMaker Studio ressursid mida enam ei nõuta.

Järeldus

Selles postituses arutasime Meta Code Llama 2 mudelite peenhäälestamist, kasutades SageMaker JumpStart. Näitasime, et saate nende mudelite viimistlemiseks ja juurutamiseks kasutada SageMakeri JumpStart-konsooli SageMaker Studios või SageMaker Python SDK-d. Arutasime ka peenhäälestustehnikat, eksemplaritüüpe ja toetatud hüperparameetreid. Lisaks andsime välja soovitused optimeeritud koolituseks, mis põhinevad erinevatel meie poolt läbi viidud testidel. Nagu näeme nendest kolme mudeli kahe andmekogumi peenhäälestuse tulemustest, parandab peenhäälestus kokkuvõtet võrreldes peenhäälestamata mudelitega. Järgmise sammuna võite proovida neid mudeleid oma andmekogus peenhäälestada, kasutades GitHubi hoidlas oleva koodi, et testida ja võrrelda tulemusi oma kasutusjuhtumite jaoks.

Autoritest

Dr Xin Huang on Amazon SageMaker JumpStart ja Amazon SageMaker sisseehitatud algoritmide vanemrakendusteadlane. Ta keskendub skaleeritavate masinõppe algoritmide arendamisele. Tema uurimishuvid on seotud loomuliku keele töötlemise, tabeliandmete seletatava süvaõppe ja mitteparameetrilise aegruumi klastrite tugeva analüüsiga. Ta on avaldanud palju artikleid ACL-is, ICDM-is, KDD konverentsidel ja Kuninglikus Statistikaühingus: A-seeria.

Vishaal Yalamanchali on Startup Solutions Architect, kes töötab varajases staadiumis generatiivse AI, robootika ja autonoomsete sõidukite ettevõtetega. Vishaal töötab koos oma klientidega tipptasemel ML-lahenduste pakkumisel ning on isiklikult huvitatud arendusõppest, LLM-i hindamisest ja koodide genereerimisest. Enne AWS-i oli Vishaal UCI bakalaureuseõppes, keskendudes bioinformaatikale ja intelligentsetele süsteemidele.

Meenakshisundaram Thandavarayan töötab AWS-is AI/ML spetsialistina. Tal on kirg kujundada, luua ja edendada inimkeskseid andme- ja analüüsikogemusi. Meena keskendub jätkusuutlike süsteemide arendamisele, mis pakuvad AWS-i strateegilistele klientidele mõõdetavaid konkurentsieeliseid. Meena on ühendaja ja disainimõtleja ning püüab innovatsiooni, inkubatsiooni ja demokratiseerimise kaudu juhtida ettevõtteid uutele tööviisidele.

Dr Ashish Khetan on vanemrakendusteadlane, kellel on Amazon SageMaker sisseehitatud algoritmid ja aitab välja töötada masinõppe algoritme. Ta sai doktorikraadi Illinoisi Urbana-Champaigni ülikoolist. Ta on aktiivne masinõppe ja statistiliste järelduste uurija ning avaldanud palju artikleid NeurIPS, ICML, ICLR, JMLR, ACL ja EMNLP konverentsidel.

• SEO-põhise sisu ja PR-levi. Võimenduge juba täna.
• PlatoData.Network Vertikaalne generatiivne Ai. Jõustage ennast. Juurdepääs siia.
• PlatoAiStream. Web3 luure. Täiustatud teadmised. Juurdepääs siia.
• PlatoESG. Süsinik, CleanTech, Energia, Keskkond päikeseenergia, Jäätmekäitluse. Juurdepääs siia.
• PlatoTervis. Biotehnoloogia ja kliiniliste uuringute luureandmed. Juurdepääs siia.
• Allikas: https://aws.amazon.com/blogs/machine-learning/fine-tune-code-llama-on-amazon-sagemaker-jumpstart/