Finjuster Code Llama på Amazon SageMaker JumpStart | Amazon Web Services

I dag er vi glade for at kunne annoncere muligheden for at finjustere Code Llama-modeller ved hjælp af Meta Amazon SageMaker JumpStart. Code Llama-familien af ​​store sprogmodeller (LLM'er) er en samling af fortrænede og finjusterede kodegenereringsmodeller i en skala fra 7 milliarder til 70 milliarder parametre. Finjusterede Code Llama-modeller giver bedre nøjagtighed og forklaring i forhold til de grundlæggende Code Llama-modeller, som det fremgår af deres test mod HumanEval og MBPP-datasæt. Du kan finjustere og implementere Code Llama-modeller med SageMaker JumpStart ved hjælp af Amazon SageMaker Studio UI med et par klik eller ved at bruge SageMaker Python SDK. Finjustering af Llama-modeller er baseret på de scripts, der findes i Lama-opskrifter GitHub repo fra Meta ved hjælp af PyTorch FSDP, PEFT/LoRA og Int8 kvantiseringsteknikker.

I dette indlæg gennemgår vi, hvordan man finjusterer Code Llama præ-trænede modeller via SageMaker JumpStart gennem en et-klik UI og SDK oplevelse tilgængelig i det følgende GitHub repository.

Hvad er SageMaker JumpStart

Med SageMaker JumpStart kan maskinlæringsudøvere (ML) vælge mellem et bredt udvalg af offentligt tilgængelige fundamentmodeller. ML praktikere kan implementere fundamentmodeller til dedikerede Amazon SageMaker forekomster fra et netværksisoleret miljø og tilpasse modeller ved hjælp af SageMaker til modeltræning og implementering.

Hvad er Code Llama

Code Llama er en kode-specialiseret version af Lama 2 der blev skabt ved at videreuddanne Llama 2 i dets kodespecifikke datasæt og prøveudtagning af flere data fra det samme datasæt i længere tid. Code Llama har forbedrede kodningsmuligheder. Det kan generere kode og naturligt sprog om kode fra både kode og naturlige sprogprompter (for eksempel "Skriv mig en funktion, der udsender Fibonacci-sekvensen"). Du kan også bruge det til kodefuldførelse og fejlfinding. Det understøtter mange af de mest populære programmeringssprog, der bruges i dag, inklusive Python, C++, Java, PHP, Typescript (JavaScript), C#, Bash og mere.

Hvorfor finjustere Code Llama-modeller

Meta publicerede Code Llama performance benchmarks på HumanEval og MBPP til almindelige kodningssprog som Python, Java og JavaScript. Ydeevnen af ​​Code Llama Python-modeller på HumanEval demonstrerede varierende ydeevne på tværs af forskellige kodningssprog og opgaver lige fra 38 % på 7B Python-modellen til 57 % på 70B Python-modeller. Derudover har finjusterede Code Llama-modeller på SQL-programmeringssprog vist bedre resultater, som det fremgår af SQL-evalueringsbenchmarks. Disse offentliggjorte benchmarks fremhæver de potentielle fordele ved at finjustere Code Llama-modeller, hvilket muliggør bedre ydeevne, tilpasning og tilpasning til specifikke kodningsdomæner og opgaver.

Kodefri finjustering via SageMaker Studio UI

For at begynde at finjustere dine Llama-modeller ved hjælp af SageMaker Studio, udfør følgende trin:

1. Vælg på SageMaker Studio-konsollen Forspring i navigationsruden.

Du vil finde lister over over 350 modeller lige fra open source og proprietære modeller.

2. Søg efter Code Llama-modeller.
   

Hvis du ikke kan se Code Llama-modeller, kan du opdatere din SageMaker Studio-version ved at lukke ned og genstarte. For mere information om versionsopdateringer, se Luk ned og opdater Studio-apps. Du kan også finde andre modelvarianter ved at vælge Udforsk alle kodegenereringsmodeller eller søger efter Code Llama i søgefeltet.

SageMaker JumpStart understøtter i øjeblikket finjustering af instruktion for Code Llama-modeller. Følgende skærmbillede viser finjusteringssiden for Code Llama 2 70B-modellen.

3. Til Placering af træningsdatasæt, kan du pege på Amazon Simple Storage Service (Amazon S3) spand, der indeholder trænings- og valideringsdatasæt til finjustering.
4. Indstil din implementeringskonfiguration, hyperparametre og sikkerhedsindstillinger til finjustering.
5. Vælg Tog for at starte finjusteringsjobbet på en SageMaker ML-instans.
   

Vi diskuterer det datasætformat, du skal forberede dig til finjustering af instruktion i næste afsnit.

6. Efter at modellen er finjusteret, kan du implementere den ved hjælp af modelsiden på SageMaker JumpStart.

Muligheden for at implementere den finjusterede model vises, når finjusteringen er færdig, som vist på det følgende skærmbillede.

Finjuster via SageMaker Python SDK

I dette afsnit demonstrerer vi, hvordan man finjusterer Code LIama-modeller ved hjælp af SageMaker Python SDK på et instruktionsformateret datasæt. Specifikt er modellen finjusteret til et sæt af NLP-opgaver (natural language processing) beskrevet ved hjælp af instruktioner. Dette hjælper med at forbedre modellens ydeevne til usete opgaver med nul-skud-prompter.

Udfør følgende trin for at fuldføre dit finjusteringsjob. Du kan få hele finjusteringskoden fra GitHub repository.

Lad os først se på det datasætformat, der kræves til finjustering af instruktionen. Træningsdataene skal formateres i et JSON-linjeformat (.jsonl), hvor hver linje er en ordbog, der repræsenterer et dataeksempel. Alle træningsdata skal være i en enkelt mappe. Det kan dog gemmes i flere .jsonl-filer. Følgende er et eksempel i JSON-linjeformat:

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

Træningsmappen kan indeholde en template.json fil, der beskriver input- og outputformaterne. Følgende er en eksempelskabelon:

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

For at matche skabelonen skal hver prøve i JSON-linjefilerne indeholde system_prompt, questionog response felter. I denne demonstration bruger vi Dolphin Coder datasæt fra Hugging Face.

Når du har forberedt datasættet og uploadet det til S3-bøtten, kan du begynde at finjustere ved hjælp af følgende kode:

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

Du kan implementere den finjusterede model direkte fra estimatoren, som vist i følgende kode. For detaljer, se notesbogen i GitHub repository.

finetuned_predictor = estimator.deploy()

Finjusteringsteknikker

Sprogmodeller som Llama er mere end 10 GB eller endda 100 GB i størrelse. Finjustering af så store modeller kræver instanser med betydelig høj CUDA-hukommelse. Desuden kan træningen af ​​disse modeller være meget langsom på grund af modellens størrelse. Derfor bruger vi følgende optimeringer til effektiv finjustering:

• Low-Rank Adaptation (LoRA) – Dette er en type parameter effektiv finjustering (PEFT) til effektiv finjustering af store modeller. Med denne metode fryser du hele modellen og tilføjer kun et lille sæt justerbare parametre eller lag i modellen. For eksempel, i stedet for at træne alle 7 milliarder parametre til Llama 2 7B, kan du finjustere mindre end 1 % af parametrene. Dette hjælper med en betydelig reduktion af hukommelseskravet, fordi du kun behøver at gemme gradienter, optimeringstilstande og anden træningsrelateret information for kun 1 % af parametrene. Desuden hjælper dette med at reducere træningstiden såvel som omkostningerne. For flere detaljer om denne metode, se LoRA: Low-Rank Adaptation of Large Language Models.
• Int8 kvantisering – Selv med optimeringer som LoRA er modeller som Llama 70B stadig for store til at træne. For at mindske hukommelsesfodaftrykket under træning, kan du bruge Int8 kvantisering under træning. Kvantisering reducerer typisk præcisionen af ​​datatyper med flydende komma. Selvom dette reducerer den nødvendige hukommelse til at lagre modelvægte, forringer det ydeevnen på grund af tab af information. Int8 kvantisering bruger kun en kvart præcision, men medfører ikke forringelse af ydeevnen, fordi den ikke bare taber bits. Det runder dataene fra den ene type til den anden. For at lære om Int8 kvantisering, se LLM.int8(): 8-bit matrix multiplikation for transformere i skala.
• Fuldt delte data parallelt (FSDP) – Dette er en type data-parallel træningsalgoritme, der sønderdeler modellens parametre på tværs af dataparallelle arbejdere og eventuelt kan overføre en del af træningsberegningen til CPU'erne. Selvom parametrene er fordelt på tværs af forskellige GPU'er, er beregningen af ​​hver mikrobatch lokal for GPU-arbejderen. Det skærer parametre mere ensartet og opnår optimeret ydeevne via kommunikation og beregningsoverlapning under træning.

Følgende tabel opsummerer detaljerne for hver model med forskellige indstillinger.

Finjustering af Llama-modeller er baseret på scripts leveret af følgende GitHub repo.

Understøttede hyperparametre til træning

Code Llama 2 finjustering understøtter en række hyperparametre, som hver især kan påvirke hukommelseskravet, træningshastigheden og ydeevnen af ​​den finjusterede model:

• epoke – Antallet af gennemløb, som finjusteringsalgoritmen tager gennem træningsdatasættet. Skal være et heltal større end 1. Standard er 5.
• learning_rate – Den hastighed, hvormed modelvægtene opdateres efter at have gennemgået hver gruppe træningseksempler. Skal være en positiv float større end 0. Standard er 1e-4.
• instruktion_tunet – Om man skal instruktionstræne modellen eller ej. Må være True or False. Standard er False.
• pr_device_train_batch_size – Batchstørrelsen pr. GPU-kerne/CPU til træning. Skal være et positivt heltal. Standard er 4.
• per_device_eval_batch_size – Batchstørrelsen pr. GPU-kerne/CPU til evaluering. Skal være et positivt heltal. Standard er 1.
• max_train_samples – Afkort antallet af træningseksempler til denne værdi til fejlfindingsformål eller hurtigere træning. Værdi -1 betyder at bruge alle træningseksemplerne. Skal være et positivt heltal eller -1. Standard er -1.
• max_val_samples – Afkort antallet af valideringseksempler til denne værdi til fejlfindingsformål eller hurtigere træning. Værdi -1 betyder at bruge alle valideringseksemplerne. Skal være et positivt heltal eller -1. Standard er -1.
• max_input_length – Maksimal samlet inputsekvenslængde efter tokenisering. Sekvenser længere end dette vil blive afkortet. Hvis -1, max_input_length er indstillet til minimum 1024 og den maksimale modellængde defineret af tokenizeren. Hvis indstillet til en positiv værdi, max_input_length er indstillet til minimum af den angivne værdi og model_max_length defineret af tokenizeren. Skal være et positivt heltal eller -1. Standard er -1.
• validation_split_ratio – Hvis valideringskanal er none, skal forholdet mellem togvalideringsopdelingen fra togdata være mellem 0–1. Standard er 0.2.
• train_data_split_seed – Hvis valideringsdata ikke er til stede, fikserer dette den tilfældige opdeling af inputtræningsdataene til trænings- og valideringsdata, der bruges af algoritmen. Skal være et heltal. Standard er 0.
• forbehandling_antal_arbejdere – Antallet af processer, der skal bruges til forbehandling. Hvis None, bruges hovedprocessen til forbehandling. Standard er None.
• lora_r – Lora R. Skal være et positivt heltal. Standard er 8.
• lora_alpha – Lora Alpha. Skal være et positivt heltal. Standard er 32
• lora_frafald – Lora Dropout. skal være en positiv float mellem 0 og 1. Standard er 0.05.
• int8_kvantisering - Hvis True, modellen er fyldt med 8-bit præcision til træning. Standard for 7B og 13B er False. Standard for 70B er True.
• enable_fsdp – Hvis det er sandt, bruger træning FSDP. Standard for 7B og 13B er True. Standard for 70B er falsk. Noter det int8_quantization er ikke understøttet med FSDP.

Når du vælger hyperparametrene, skal du overveje følgende:

• Lokal område int8_quantization=True mindsker hukommelsesbehovet og fører til hurtigere træning.
• Faldende per_device_train_batch_size , max_input_length reducerer hukommelseskravet og kan derfor køres på mindre instanser. Indstilling af meget lave værdier kan dog øge træningstiden.
• Hvis du ikke bruger Int8 kvantisering (int8_quantization=False), brug FSDP (enable_fsdp=True) for hurtigere og effektiv træning.

Understøttede instanstyper til træning

Følgende tabel opsummerer de understøttede instanstyper til træning af forskellige modeller.

Når du vælger instanstypen, skal du overveje følgende:

• G5-instanser giver den mest effektive træning blandt de understøttede instanstyper. Derfor, hvis du har G5-instanser til rådighed, bør du bruge dem.
• Træningstiden afhænger i høj grad af mængden af ​​antallet af GPU'er og den tilgængelige CUDA-hukommelse. Derfor er træning på instanser med det samme antal GPU'er (f.eks. ml.g5.2xlarge og ml.g5.4xlarge) nogenlunde det samme. Derfor kan du bruge den billigere instans til træning (ml.g5.2xlarge).
• Når du bruger p3-instanser, vil træningen blive udført med 32-bit præcision, fordi bfloat16 ikke understøttes på disse instanser. Derfor vil træningsjobbet forbruge den dobbelte mængde CUDA-hukommelse, når der trænes på p3-instanser sammenlignet med g5-instanser.

For at lære om omkostningerne ved uddannelse pr. instans, se Amazon EC2 G5-forekomster.

Evaluering

Evaluering er et vigtigt skridt til at vurdere ydeevnen af ​​finjusterede modeller. Vi præsenterer både kvalitative og kvantitative evalueringer for at vise forbedring af finjusterede modeller i forhold til ikke-finjusterede. I kvalitativ evaluering viser vi et eksempelsvar fra både finjusterede og ikke-finjusterede modeller. Ved kvantitativ evaluering bruger vi HumanEval, en testsuite udviklet af OpenAI til at generere Python-kode for at teste evnerne til at producere korrekte og nøjagtige resultater. HumanEval-depotet er under MIT-licens. Vi finjusterede Python-varianter af alle Code LIama-modeller over forskellige størrelser (Code LIama Python 7B, 13B, 34B og 70B på Dolphin Coder datasæt), og præsentere evalueringsresultaterne i de følgende afsnit.

Kvalitativ evaluering

Med din finjusterede model installeret, kan du begynde at bruge slutpunktet til at generere kode. I det følgende eksempel præsenterer vi svar fra både basis- og finjusterede Code LIama 34B Python-varianter på en testprøve i Dolphin Coder datasæt:

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

Den finjusterede Code Llama-model genererer, udover at levere koden til den foregående forespørgsel, en detaljeret forklaring af tilgangen og en pseudokode.

Kode Llama 34b Python ikke-finjusteret svar:

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

Kode Llama 34B Python finjusteret respons

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

Grund sandhed

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

Interessant nok giver vores finjusterede version af Code Llama 34B Python en dynamisk programmeringsbaseret løsning til den længste palindromiske understreng, som er forskellig fra den løsning, der leveres i grundsandheden fra det valgte testeksempel. Vores finjusterede model begrunder og forklarer den dynamiske programmeringsbaserede løsning i detaljer. På den anden side hallucinerer den ikke-finjusterede model potentielle output lige efter print sætning (vist i venstre celle), fordi outputtet axyzzyx er ikke det længste palindrom i den givne streng. Med hensyn til tidskompleksitet er den dynamiske programmeringsløsning generelt bedre end den oprindelige tilgang. Den dynamiske programmeringsløsning har en tidskompleksitet på O(n^2), hvor n er længden af ​​inputstrengen. Dette er mere effektivt end den oprindelige løsning fra den ikke-finjusterede model, som også havde en kvadratisk tidskompleksitet på O(n^2), men med en mindre optimeret tilgang.

Det her ser lovende ud! Husk, vi har kun finjusteret Code LIama Python-varianten med 10 % af Dolphin Coder datasæt. Der er meget mere at udforske!

På trods af grundige instruktioner i svaret skal vi stadig undersøge rigtigheden af ​​den Python-kode, der er leveret i løsningen. Dernæst bruger vi en evalueringsramme kaldet Menneskelig Eval at køre integrationstest på det genererede svar fra Code LIama for systematisk at undersøge dets kvalitet.

Kvantitativ evaluering med HumanEval

HumanEval er en evalueringssele til evaluering af en LLM's problemløsningsevner på Python-baserede kodningsproblemer, som beskrevet i papiret Evaluering af store sprogmodeller trænet i kode. Specifikt består den af ​​164 originale Python-baserede programmeringsproblemer, der vurderer en sprogmodels evne til at generere kode baseret på givet information som funktionssignatur, docstring, krop og enhedstest.

For hvert Python-baseret programmeringsspørgsmål sender vi det til en Code LIama-model installeret på et SageMaker-slutpunkt for at få k-svar. Dernæst kører vi hvert af de k-svar på integrationstestene i HumanEval-depotet. Hvis ethvert svar fra de k-svar består integrationstestene, tæller vi, at testtilfældet lykkes; ellers mislykkedes. Derefter gentager vi processen for at beregne forholdet mellem vellykkede sager som den endelige evalueringsscore pass@k. Efter standardpraksis sætter vi k som 1 i vores evaluering, til kun at generere ét svar pr. spørgsmål og teste, om det består integrationstesten.

Følgende er en eksempelkode til brug af HumanEval-depot. Du kan få adgang til datasættet og generere et enkelt svar ved hjælp af et SageMaker-slutpunkt. For detaljer, se notesbogen i GitHub repository.

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

Følgende tabel viser forbedringerne af de finjusterede Code LIama Python-modeller i forhold til de ikke-finjusterede modeller på tværs af forskellige modelstørrelser. For at sikre korrekthed implementerer vi også de ikke-finjusterede Code LIama-modeller i SageMaker-endepunkter og gennemgår Human Eval-evalueringer. Det bestå@1 tal (den første række i følgende tabel) matcher de rapporterede tal i Code Llama research paper. Inferensparametrene er konsekvent sat som "parameters": {"max_new_tokens": 384, "temperature": 0.2}.

Som vi kan se fra resultaterne, viser alle de finjusterede Code LIama Python-varianter betydelige forbedringer i forhold til de ikke-finjusterede modeller. Især Code LIama Python 70B overgår den ikke-finjusterede model med cirka 12%.

Nu kan du prøve at finjustere Code LIama-modeller på dit eget datasæt.

Ryd op

Hvis du beslutter, at du ikke længere ønsker at holde SageMaker-slutpunktet kørende, kan du slette det vha AWS SDK til Python (Boto3), AWS kommandolinjegrænseflade (AWS CLI) eller SageMaker-konsol. For mere information, se Slet slutpunkter og ressourcer. Derudover kan du lukke SageMaker Studio-ressourcerne som ikke længere er nødvendige.

Konklusion

I dette indlæg diskuterede vi finjustering af Metas Code Llama 2-modeller ved hjælp af SageMaker JumpStart. Vi viste, at du kan bruge SageMaker JumpStart-konsollen i SageMaker Studio eller SageMaker Python SDK til at finjustere og implementere disse modeller. Vi diskuterede også finjusteringsteknikken, instanstyper og understøttede hyperparametre. Derudover skitserede vi anbefalinger til optimeret træning baseret på forskellige tests, vi gennemførte. Som vi kan se fra disse resultater af finjustering af tre modeller over to datasæt, forbedrer finjustering sammenfatning sammenlignet med ikke-finjusterede modeller. Som et næste trin kan du prøve at finjustere disse modeller på dit eget datasæt ved at bruge koden i GitHub-lageret for at teste og benchmarke resultaterne for dine brugssager.

Om forfatterne

Dr. Xin Huang er en Senior Applied Scientist for Amazon SageMaker JumpStart og Amazon SageMaker indbyggede algoritmer. Han fokuserer på at udvikle skalerbare maskinlæringsalgoritmer. Hans forskningsinteresser er inden for området naturlig sprogbehandling, forklarlig dyb læring på tabeldata og robust analyse af ikke-parametrisk rum-tid-klynger. Han har udgivet mange artikler i ACL, ICDM, KDD-konferencer og Royal Statistical Society: Series A.

Vishaal Yalamanchali er en Startup Solutions Architect, der arbejder med generativ AI i tidlige stadier, robotteknologi og virksomheder med autonome køretøjer. Vishaal arbejder sammen med sine kunder om at levere banebrydende ML-løsninger og er personligt interesseret i forstærkningslæring, LLM-evaluering og kodegenerering. Før AWS var Vishaal bachelor ved UCI med fokus på bioinformatik og intelligente systemer.

Meenakshisundaram Thandavarayan arbejder for AWS som AI/ML Specialist. Han har en passion for at designe, skabe og fremme menneskecentrerede data- og analyseoplevelser. Meena fokuserer på at udvikle bæredygtige systemer, der leverer målbare, konkurrencemæssige fordele for strategiske kunder af AWS. Meena er en connector og designtænker og stræber efter at drive virksomheder til nye måder at arbejde på gennem innovation, inkubation og demokratisering.

Dr. Ashish Khetan er en Senior Applied Scientist med Amazon SageMaker indbyggede algoritmer og hjælper med at udvikle machine learning algoritmer. Han fik sin ph.d. fra University of Illinois Urbana-Champaign. Han er en aktiv forsker i maskinlæring og statistisk inferens og har publiceret mange artikler i NeurIPS, ICML, ICLR, JMLR, ACL og EMNLP konferencer.

• SEO Powered Content & PR Distribution. Bliv forstærket i dag.
• PlatoData.Network Vertical Generative Ai. Styrk dig selv. Adgang her.
• PlatoAiStream. Web3 intelligens. Viden forstærket. Adgang her.
• PlatoESG. Kulstof, CleanTech, Energi, Miljø, Solenergi, Affaldshåndtering. Adgang her.
• PlatoHealth. Bioteknologiske og kliniske forsøgs intelligens. Adgang her.
• Kilde: https://aws.amazon.com/blogs/machine-learning/fine-tune-code-llama-on-amazon-sagemaker-jumpstart/