A Code Llama finomhangolása az Amazon SageMaker JumpStart | Amazon webszolgáltatások

Ma örömmel jelentjük be, hogy a Meta segítségével finomhangolhatjuk a Code Llama modelleket Amazon SageMaker JumpStart. A Code Llama nagy nyelvi modellek (LLM) családja előre betanított és finomhangolt kódgenerálási modellek gyűjteménye, amelyek 7 milliárdtól 70 milliárd paraméterig terjednek. A finomhangolt Code Llama modellek jobb pontosságot és magyarázhatóságot biztosítanak az alap Code Llama modellekhez képest, amint az a tesztek során is nyilvánvaló. HumanEval és MBPP adatkészletek. A Code Llama modelleket a SageMaker JumpStart segítségével finomhangolhatja és üzembe helyezheti Amazon SageMaker Studio UI néhány kattintással vagy a SageMaker Python SDK használatával. A Llama modellek finomhangolása a következőben található szkripteken alapul láma-receptek GitHub repo a Metából PyTorch FSDP, PEFT/LoRA és Int8 kvantálási technikákkal.

Ebben a bejegyzésben azt mutatjuk be, hogyan lehet finomhangolni Code Llama előképzett modelleket a SageMaker JumpStart segítségével egy kattintással elérhető felhasználói felületen és SDK-n keresztül, amely a következőkben érhető el. GitHub tárház.

Mi az a SageMaker JumpStart

A SageMaker JumpStart segítségével a gépi tanulást (ML) gyakorló szakemberek nyilvánosan elérhető alapmodellek széles választékából választhatnak. Az ML gyakorlói alapmodelleket telepíthetnek dedikált Amazon SageMaker példányokat egy hálózattól elszigetelt környezetből, és testreszabhatja a modelleket a SageMaker segítségével a modell betanítására és telepítésére.

Mi az a Code Llama

A Code Llama a kódra specializálódott változata Láma 2 amelyet úgy hoztak létre, hogy a Llama 2-t továbbtanították a kódspecifikus adatkészleteire, és hosszabb ideig több adatot vettek minta ugyanabból az adatkészletből. A Code Llama továbbfejlesztett kódolási képességekkel rendelkezik. Képes kódot és természetes nyelvet generálni a kódról, mind a kódból, mind a természetes nyelvi promptokból (például: „Írjon nekem egy függvényt, amely a Fibonacci-szekvenciát adja ki”). Használhatja kódkiegészítésre és hibakeresésre is. Támogatja a ma használt legnépszerűbb programozási nyelvek közül sok, köztük a Python, C++, Java, PHP, Typescript (JavaScript), C#, Bash és még sok más.

Miért finomhangoljuk a Code Llama modelleket

A Meta közzétette a Code Llama teljesítményre vonatkozó referenciaértékeit HumanEval és MBPP olyan általános kódolási nyelvekhez, mint a Python, Java és JavaScript. A Code Llama Python modellek teljesítménye a HumanEval-on változó teljesítményt mutatott a különböző kódolási nyelveken és feladatokon, a 38B Python modell 7%-ától a 57B Python modellek 70%-áig terjedve. Ezenkívül az SQL programozási nyelven finomhangolt Code Llama modellek jobb eredményeket mutattak, amint az az SQL kiértékelési benchmarkokban is látható. Ezek a közzétett referenciaértékek rávilágítanak a Code Llama modellek finomhangolásának lehetséges előnyeire, amelyek lehetővé teszik a jobb teljesítményt, a testreszabást és az adott kódolási tartományokhoz és feladatokhoz való alkalmazkodást.

Kód nélküli finomhangolás a SageMaker Studio UI-n keresztül

A Llama modellek SageMaker Studio használatával történő finomhangolásához hajtsa végre a következő lépéseket:

1. A SageMaker Studio konzolon válassza a lehetőséget ugrás indítás a navigációs ablaktáblában.

Több mint 350 modell listája található, a nyílt forráskódú és a szabadalmaztatott modellektől kezdve.

2. Code Llama modellek keresése.
   

Ha nem látja a Code Llama modelleket, akkor a SageMaker Studio verziójának leállításával és újraindításával frissítheti. A verziófrissítésekkel kapcsolatos további információkért lásd: Állítsa le és frissítse a Studio alkalmazásokat. Választással más modellváltozatokat is találhat Fedezze fel az összes kódgenerációs modellt vagy a Code Llama kifejezésre keresve a keresőmezőben.

A SageMaker JumpStart jelenleg támogatja a Code Llama modellek utasításainak finomhangolását. A következő képernyőképen a Code Llama 2 70B modell finomhangolási oldala látható.

3. A Képzési adatkészlet helye, rámutathat a Amazon egyszerű tárolási szolgáltatás (Amazon S3) vödör, amely a képzési és érvényesítési adatkészleteket tartalmazza a finomhangoláshoz.
4. Állítsa be a központi telepítési konfigurációt, a hiperparamétereket és a biztonsági beállításokat a finomhangoláshoz.
5. A pop-art design, négy időzóna kijelzése egyszerre és méretének arányai azok az érvek, amelyek a NeXtime Time Zones-t kiváló választássá teszik. Válassza a Vonat a finomhangolási feladat elindításához egy SageMaker ML példányon.
   

A következő részben tárgyaljuk az adatkészlet-formátumot, amelyre szüksége van az utasítások finomhangolásához.

6. A modell finomhangolása után telepítheti a SageMaker JumpStart modelloldalán.

A finomhangolás befejeztével megjelenik a finomhangolt modell üzembe helyezésének lehetősége, amint az a következő képernyőképen látható.

Finomhangolás a SageMaker Python SDK segítségével

Ebben a részben bemutatjuk, hogyan lehet a Code LIama modelleket finomhangolni a SageMaker Python SDK használatával egy utasításformátumú adatkészleten. Pontosabban, a modell az utasítások segítségével leírt természetes nyelvi feldolgozási (NLP) feladatokhoz van finomhangolva. Ez segít a modell teljesítményének javításában a nem látott feladatoknál a nullapontos figyelmeztetésekkel.

A finomhangolási munka befejezéséhez hajtsa végre az alábbi lépéseket. A teljes finomhangoló kódot a GitHub tárház.

Először nézzük meg az utasítás finomhangolásához szükséges adatkészlet-formátumot. A betanítási adatokat JSON-sorok (.jsonl) formátumban kell formázni, ahol minden sor egy adatmintát képviselő szótár. Minden edzésadatnak egyetlen mappában kell lennie. Azonban több .jsonl fájlba is menthető. A következő példa JSON-sorok formátumban:

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

Az edzésmappa tartalmazhat a template.json a bemeneti és kimeneti formátumokat leíró fájl. A következő egy példa sablon:

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

A sablonhoz való illeszkedés érdekében a JSON-sorok fájljaiban minden mintának tartalmaznia kell system_prompt, questionés response mezőket. Ebben a bemutatóban a Dolphin Coder adatkészlet a Hugging Face-től.

Az adatkészlet előkészítése és az S3 tárolóba való feltöltése után megkezdheti a finomhangolást a következő kóddal:

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

A finomhangolt modellt közvetlenül a becslőből telepítheti, amint az a következő kódban látható. A részletekért lásd a jegyzetfüzetet a GitHub tárház.

finetuned_predictor = estimator.deploy()

Finomhangolási technikák

Az olyan nyelvi modellek, mint a Llama, több mint 10 GB vagy akár 100 GB méretűek. Az ilyen nagy modellek finomhangolásához lényegesen magas CUDA-memóriával rendelkező példányokra van szükség. Ezenkívül ezeknek a modelleknek a betanítása nagyon lassú lehet a modell mérete miatt. Ezért a hatékony finomhangolás érdekében a következő optimalizációkat használjuk:

• Alacsony szintű adaptáció (LoRA) – Ez a paraméterhatékony finomhangolás (PEFT) egy fajtája a nagy modellek hatékony finomhangolásához. Ezzel a módszerrel az egész modellt lefagyasztja, és csak egy kis állítható paraméter- vagy rétegkészletet ad hozzá a modellhez. Például ahelyett, hogy a Llama 7 2B mind a 7 milliárd paraméterét betanítaná, a paraméterek kevesebb mint 1%-át finomhangolhatja. Ez segít jelentősen csökkenteni a memóriaigényt, mivel csak a paraméterek 1%-ánál kell a gradienseket, az optimalizáló állapotokat és a képzéssel kapcsolatos egyéb információkat tárolni. Ezenkívül ez segít csökkenteni a képzési időt és a költségeket. A módszerrel kapcsolatos további részletekért lásd: LoRA: Nagy nyelvi modellek alacsony rangú adaptációja.
• Int8 kvantálás – Még az olyan optimalizálások mellett is, mint a LoRA, az olyan modellek, mint a Llama 70B, még mindig túl nagyok a betanításhoz. Az edzés közbeni memóriaterület csökkentése érdekében edzés közben használhatja az Int8 kvantálást. A kvantálás általában csökkenti a lebegőpontos adattípusok pontosságát. Ez ugyan csökkenti a modellsúlyok tárolásához szükséges memóriát, de rontja a teljesítményt az információvesztés miatt. Az Int8 kvantálás csak negyed pontosságot használ, de nem jár a teljesítmény romlásával, mert nem egyszerűen eldobja a biteket. Az adatokat egyik típusról a másikra kerekíti. Ha többet szeretne megtudni az Int8 kvantálásról, tekintse meg a LLM.int8(): 8 bites mátrixszorzás skálán transzformátorokhoz.
• Teljesen megosztott adatok párhuzamos (FSDP) – Ez az adatpárhuzamos betanítási algoritmus egyfajta típusa, amely a modell paramétereit az adatokkal párhuzamos dolgozók között szilánkokra bontja, és opcionálisan a betanítási számítások egy részét a CPU-kra terhelheti. Bár a paraméterek különböző GPU-k között vannak felosztva, minden egyes mikrobatch számítása helyileg a GPU-munkásra vonatkozik. Egyenletesebben bontja le a paramétereket, és optimalizált teljesítményt ér el az edzés közbeni kommunikáció és számítási átfedés révén.

Az alábbi táblázat összefoglalja az egyes modellek részleteit különböző beállításokkal.

A Llama modellek finomhangolása a következők által biztosított szkripteken alapul GitHub repo.

Támogatott hiperparaméterek az edzéshez

A Code Llama 2 finomhangolása számos hiperparamétert támogat, amelyek mindegyike befolyásolhatja a finomhangolt modell memóriaigényét, edzési sebességét és teljesítményét:

• korszak – A finomhangoló algoritmus által a betanítási adatkészleten keresztül végrehajtott lépések száma. 1-nél nagyobb egész számnak kell lennie. Az alapértelmezett érték 5.
• tanulási_ráta – Az a sebesség, amellyel a modellsúlyok frissítésre kerülnek az egyes képzési példák kötegeinek kidolgozása után. 0-nál nagyobb pozitív lebegésnek kell lennie. Az alapértelmezett érték 1e-4.
• utasítás_hangolt – Akár oktatni-tanítani a modellt, akár nem. Kell, hogy legyen True or False. Az alapértelmezett False.
• per_device_train_batch_size – A köteg mérete GPU magonként/CPU-nként a betanításhoz. Pozitív egész számnak kell lennie. Az alapértelmezett a 4.
• per_device_eval_batch_size – A köteg mérete GPU magonként/CPU-nként az értékeléshez. Pozitív egész számnak kell lennie. Az alapértelmezett az 1.
• max_train_samples – Hibakeresés vagy gyorsabb betanítás céljából csökkentse a betanítási példák számát erre az értékre. Az -1 érték az összes betanítási minta felhasználását jelenti. Pozitív egész számnak vagy -1-nek kell lennie. Az alapértelmezett érték -1.
• max_val_samples – Hibakeresés vagy gyorsabb betanítás érdekében csonkolja az érvényesítési példák számát erre az értékre. Az -1 érték az összes érvényesítési minta használatát jelenti. Pozitív egész számnak vagy -1-nek kell lennie. Az alapértelmezett érték -1.
• max_input_length – Maximális teljes bemeneti sorozathossz a tokenizálás után. Az ennél hosszabb sorozatok csonkolva lesznek. Ha -1, max_input_length a minimum 1024-re és a tokenizátor által meghatározott maximális modellhosszra van állítva. Ha pozitív értékre van állítva, max_input_length a megadott érték minimumára van állítva és a model_max_length a tokenizátor határozza meg. Pozitív egész számnak vagy -1-nek kell lennie. Az alapértelmezett érték -1.
• validation_split_ratio – Ha az érvényesítési csatorna none, a vonat-ellenőrzési felosztás arányának a vonatadatokból 0–1 között kell lennie. Az alapértelmezett 0.2.
• train_data_split_seed – Ha nincsenek érvényesítési adatok, ez rögzíti a bemeneti betanítási adatok véletlenszerű felosztását az algoritmus által használt betanítási és érvényesítési adatokra. Egész számnak kell lennie. Az alapértelmezett 0.
• preprocessing_num_workers – Az előfeldolgozáshoz használt folyamatok száma. Ha None, a fő eljárást előfeldolgozásra használják. Az alapértelmezett None.
• lora_r – Lora R. Pozitív egész számnak kell lennie. Az alapértelmezett a 8.
• lora_alpha – Alfa Lora. Pozitív egész számnak kell lennie. Az alapértelmezett a 32
• lora_dropout – Lora Dropout. pozitív lebegésnek kell lennie 0 és 1 között. Az alapértelmezett érték 0.05.
• int8_kvantálás - Ha True, a modell 8 bites pontossággal van betöltve az edzéshez. A 7B és 13B alapértelmezett értéke False. A 70B alapértelmezett értéke True.
• enable_fsdp – Ha igaz, a képzés FSDP-t használ. A 7B és 13B alapértelmezett értéke True. A 70B alapértelmezett értéke False. Vegye figyelembe, hogy int8_quantization az FSDP nem támogatja.

A hiperparaméterek kiválasztásakor vegye figyelembe a következőket:

• Beállítás int8_quantization=True csökkenti a memóriaigényt és gyorsabb edzéshez vezet.
• Csökkenő per_device_train_batch_size és a max_input_length csökkenti a memóriaigényt, ezért kisebb példányokon is futtatható. Nagyon alacsony értékek beállítása azonban megnövelheti az edzési időt.
• Ha nem használ Int8 kvantálást (int8_quantization=False), használja az FSDP-t (enable_fsdp=True) a gyorsabb és hatékonyabb edzés érdekében.

Támogatott példánytípusok képzéshez

Az alábbi táblázat összefoglalja a támogatott példánytípusokat a különböző modellek betanításához.

A példány típusának kiválasztásakor vegye figyelembe a következőket:

• A támogatott példánytípusok közül a G5-példányok biztosítják a leghatékonyabb képzést. Ezért, ha rendelkezésre állnak G5-példányok, használja azokat.
• A képzési idő nagyban függ a GPU-k számától és a rendelkezésre álló CUDA-memória mennyiségétől. Ezért az azonos számú GPU-val (például ml.g5.2xlarge és ml.g5.4xlarge) rendelkező példányokon végzett képzés nagyjából ugyanaz. Ezért az olcsóbb példányt használhatja edzésre (ml.g5.2xlarge).
• A p3 példányok használatakor a betanítás 32 bites pontossággal történik, mivel a bfloat16 nem támogatott ezeken a példányokon. Ezért a betanítási feladat kétszer annyi CUDA-memóriát fog igénybe venni, ha p3-példányokon oktat a g5-példányokhoz képest.

Ha többet szeretne megtudni a képzés példányonkénti költségeiről, tekintse meg a következőt: Amazon EC2 G5 példányok.

Értékelés

Az értékelés fontos lépés a finomhangolt modellek teljesítményének értékeléséhez. Minőségi és mennyiségi értékeléseket is bemutatunk, hogy bemutassuk a finomhangolt modellek javulását a nem finomhangolt modellekhez képest. A kvalitatív kiértékelés során példát mutatunk a finomhangolt és nem finomhangolt modellekből egyaránt. A mennyiségi értékelés során használjuk HumanEval, az OpenAI által kifejlesztett tesztcsomag, amely Python kódot állít elő a helyes és pontos eredmények előállításának képességének tesztelésére. A HumanEval adattár MIT licenc alatt áll. Finomhangoltuk az összes Code LIama modell Python változatát különböző méretekben (Code LIama Python 7B, 13B, 34B és 70B a Dolphin Coder adatkészlet), és mutassa be az értékelés eredményeit a következő szakaszokban.

Minőségi értékelés

A finomhangolt modell üzembe helyezésével megkezdheti a végpont használatát a kód létrehozásához. A következő példában a Code LIama 34B Python alap és finomhangolt változataiból származó válaszokat mutatjuk be egy tesztmintán a Dolphin Coder adatkészlet:

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

A finomhangolt Code Llama modell amellett, hogy megadja az előző lekérdezés kódját, részletes magyarázatot ad a megközelítésről és egy pszeudo kódot.

Code Llama 34b Python nem finomhangolt válasz:

### 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 Python finomhangolt válasz

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

Alapvető igazság

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

Érdekes módon a Code Llama 34B Python finomhangolt verziója dinamikus programozáson alapuló megoldást nyújt a leghosszabb palindrom részstringre, amely eltér a kiválasztott tesztpéldában szereplő alapigazságban megadott megoldástól. Finomhangolt modellünk részletesen megindokolja és elmagyarázza a dinamikus programozás alapú megoldást. Másrészt a nem finomhangolt modell közvetlenül azután hallucinálja a potenciális kimeneteket print utasítás (a bal oldali cellában látható), mert a kimenet axyzzyx nem a leghosszabb palindrom az adott karakterláncban. Az idő bonyolultságát tekintve a dinamikus programozási megoldás általában jobb, mint a kezdeti megközelítés. A dinamikus programozási megoldás időbonyolultsága O(n^2), ahol n a bemeneti karakterlánc hossza. Ez hatékonyabb, mint a nem finomhangolt modell kezdeti megoldása, amelynek négyzetes időbonyolultsága is O(n^2), de kevésbé optimalizált megközelítéssel.

Ez ígéretesnek tűnik! Ne feledje, hogy a Code LIama Python változatot csak a 10%-ával finomítottuk Dolphin Coder adatkészlet. Van még sok felfedeznivaló!

A válaszban található alapos utasítások ellenére még mindig meg kell vizsgálnunk a megoldásban szereplő Python kód helyességét. Ezt követően egy értékelési keretrendszert használunk, az úgynevezett Human Eval integrációs tesztek futtatása a Code LIama által generált válaszon annak minőségének szisztematikus vizsgálata érdekében.

Mennyiségi értékelés a HumanEval segítségével

A HumanEval egy kiértékelő eszköz az LLM-ek Python-alapú kódolási problémákra vonatkozó problémamegoldó képességeinek értékelésére, amint azt a dokumentumban leírtuk. A kódon betanított nagy nyelvi modellek értékelése. Konkrétan 164 eredeti Python-alapú programozási problémából áll, amelyek felmérik a nyelvi modell azon képességét, hogy kódot generáljon a megadott információk, például a függvényaláírás, docstring, törzs- és egységtesztek alapján.

Minden Python-alapú programozási kérdést elküldünk egy Code LIama modellnek, amely egy SageMaker végponton van telepítve, hogy k választ kapjunk. Ezután lefuttatjuk mind a k választ az integrációs teszteken a HumanEval adattárban. Ha a k válasz bármelyik válasza átmegy az integrációs teszteken, akkor azt a tesztesetet sikeresnek számítjuk; egyébként nem sikerült. Ezután megismételjük a folyamatot, hogy kiszámítsuk a sikeres esetek arányát a végső értékelési pontszámként pass@k. Az általános gyakorlatot követve a k értéket 1-ként állítjuk be az értékelésünkben, hogy kérdésenként csak egy választ generáljunk, és teszteljük, hogy megfelel-e az integrációs teszten.

A következő egy mintakód a HumanEval adattár használatához. Hozzáférhet az adatkészlethez, és egyetlen választ generálhat egy SageMaker-végpont használatával. A részletekért lásd a jegyzetfüzetet a GitHub tárház.

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

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

evaluate_functional_correctness('./samples.jsonl')

A következő táblázat a finomhangolt Code LIama Python modellek fejlesztéseit mutatja a nem finomhangolt modellekhez képest különböző modellméretekben. A helyesség biztosítása érdekében a nem finomhangolt Code LIama modelleket is telepítjük a SageMaker végpontjaiban, és végigfutjuk a Human Eval kiértékeléseken. A pass@1 számok (a következő táblázat első sora) egyeznek a jelentésben szereplő számokkal Code Llama kutatási cikk. A következtetési paraméterek következetesen úgy vannak beállítva "parameters": {"max_new_tokens": 384, "temperature": 0.2}.

Amint az eredményekből látható, az összes finomhangolt Code LIama Python változat jelentős javulást mutat a nem finomhangolt modellekhez képest. A Code LIama Python 70B körülbelül 12%-kal felülmúlja a nem finomhangolt modellt.

Most kipróbálhatja a Code LIama modellek finomhangolását saját adatkészletén.

Tisztítsuk meg

Ha úgy dönt, hogy nem szeretné tovább futni a SageMaker végpontot, törölheti a használatával AWS SDK Pythonhoz (Boto3), AWS parancssori interfész (AWS CLI), vagy a SageMaker konzolon. További információkért lásd Törölje a végpontokat és az erőforrásokat. Ezenkívül megteheti állítsa le a SageMaker Studio erőforrásait amelyekre már nincs szükség.

Következtetés

Ebben a bejegyzésben a Meta Code Llama 2 modelljeinek finomhangolását tárgyaltuk a SageMaker JumpStart segítségével. Megmutattuk, hogy a SageMaker Studio SageMaker JumpStart konzolját vagy a SageMaker Python SDK-t használhatja a modellek finomhangolására és üzembe helyezésére. Megbeszéltük a finomhangolási technikát, a példánytípusokat és a támogatott hiperparamétereket is. Ezen kívül ajánlásokat fogalmaztunk meg az optimalizált képzésre az általunk végzett különféle tesztek alapján. Amint azt a három modell két adathalmazon keresztüli finomhangolásának eredményeiből láthatjuk, a finomhangolás javítja az összegzést a nem finomhangolt modellekhez képest. Következő lépésként megpróbálhatja finomhangolni ezeket a modelleket a saját adatkészletén a GitHub-tárhelyben található kód segítségével, hogy tesztelje és összehasonlítsa az eredményeket az Ön használati eseteihez.

A szerzőkről

Dr. Xin Huang az Amazon SageMaker JumpStart és az Amazon SageMaker beépített algoritmusainak vezető alkalmazott tudósa. A skálázható gépi tanulási algoritmusok fejlesztésére összpontosít. Kutatási területe a természetes nyelvi feldolgozás, a táblázatos adatok magyarázható mély tanulása és a nem-paraméteres tér-idő klaszterezés robusztus elemzése. Számos közleményt publikált az ACL-ben, az ICDM-ben, a KDD konferenciákon és a Royal Statistical Society: A sorozatban.

Vishaal Yalamanchali egy Startup Solutions Architect, aki korai szakaszban generatív AI-val, robotikával és autonóm járművekkel foglalkozó cégekkel dolgozik. Vishaal ügyfeleivel dolgozik azon, hogy élvonalbeli ML-megoldásokat szállítson, és személyesen érdeklődik a megerősítő tanulás, az LLM-értékelés és a kódgenerálás iránt. Az AWS előtt Vishaal az UCI egyetemi hallgatója volt, a bioinformatikára és az intelligens rendszerekre összpontosítva.

Meenakshisundaram Thandavarayan az AWS-nél dolgozik AI/ML specialistaként. Szenvedélye az emberközpontú adat- és elemzési tapasztalatok tervezése, létrehozása és népszerűsítése. A Meena a fenntartható rendszerek fejlesztésére összpontosít, amelyek mérhető, versenyelőnyöket biztosítanak az AWS stratégiai ügyfelei számára. Meena egy összekötő és tervező, és arra törekszik, hogy az innováció, az inkubáció és a demokratizálódás révén új munkamódszerek felé terelje a vállalkozásokat.

Dr. Ashish Khetan vezető alkalmazott tudós az Amazon SageMaker beépített algoritmusaival, és segít gépi tanulási algoritmusok fejlesztésében. PhD fokozatát az Illinois Urbana-Champaign Egyetemen szerezte. A gépi tanulás és a statisztikai következtetések aktív kutatója, és számos közleményt publikált NeurIPS, ICML, ICLR, JMLR, ACL és EMNLP konferenciákon.

• SEO által támogatott tartalom és PR terjesztés. Erősödjön még ma.
• PlatoData.Network Vertical Generative Ai. Erősítse meg magát. Hozzáférés itt.
• PlatoAiStream. Web3 Intelligence. Felerősített tudás. Hozzáférés itt.
• PlatoESG. Carbon, CleanTech, Energia, Környezet, Nap, Hulladékgazdálkodás. Hozzáférés itt.
• PlatoHealth. Biotechnológiai és klinikai vizsgálatok intelligencia. Hozzáférés itt.
• Forrás: https://aws.amazon.com/blogs/machine-learning/fine-tune-code-llama-on-amazon-sagemaker-jumpstart/