Bugün, Code Llama modellerine Meta tarafından ince ayar yapma olanağını duyurmanın heyecanını yaşıyoruz. Amazon SageMaker Hızlı Başlangıç. Büyük dil modellerinden (LLM'ler) oluşan Code Llama ailesi, ölçeği 7 milyardan 70 milyar parametreye kadar değişen, önceden eğitilmiş ve ince ayarlı kod oluşturma modellerinin bir koleksiyonudur. İnce ayarlı Code Llama modelleri, temel Code Llama modellerine göre daha iyi doğruluk ve açıklanabilirlik sağlar, bu da testlerde açıkça görülmektedir. İnsanDeğerlendirmesi ve MBPP veri kümeleri. Code Llama modellerinde SageMaker JumpStart ile ince ayar yapabilir ve dağıtabilirsiniz. Amazon SageMaker Stüdyosu Birkaç tıklamayla veya SageMaker Python SDK'yı kullanarak kullanıcı arayüzü. Lama modellerinin ince ayarı, burada sağlanan komut dosyalarına dayanmaktadır. lama tarifleri GitHub deposu PyTorch FSDP, PEFT/LoRA ve Int8 niceleme tekniklerini kullanarak Meta'dan.

Bu yazıda, aşağıda sunulan tek tıklamalı kullanıcı arayüzü ve SDK deneyimi aracılığıyla SageMaker JumpStart aracılığıyla Code Llama'nın önceden eğitilmiş modellerine nasıl ince ayar yapılacağını açıklıyoruz. GitHub deposu.

SageMaker JumpStart nedir?

SageMaker JumpStart ile makine öğrenimi (ML) uygulayıcıları, halka açık geniş bir temel model yelpazesi arasından seçim yapabilir. ML uygulayıcıları temel modelleri özel olarak dağıtabilir Amazon Adaçayı Yapıcı izole edilmiş bir ağ ortamından bulut sunucuları oluşturun ve model eğitimi ve konuşlandırma için SageMaker'ı kullanarak modelleri özelleştirin.

Kod Lama Nedir?

Code Llama, Code Llama'nın koda özel bir versiyonudur. Llama 2 Bu, Llama 2'nin koda özgü veri kümeleri üzerinde daha fazla eğitilmesi ve aynı veri kümesinden daha uzun süre daha fazla veri örneklenmesiyle oluşturuldu. Code Llama, gelişmiş kodlama yeteneklerine sahiptir. Hem koddan hem de doğal dil istemlerinden kod ve kod hakkında doğal dil oluşturabilir (örneğin, "Bana Fibonacci dizisinin çıktısını veren bir fonksiyon yaz"). Bunu kod tamamlama ve hata ayıklama için de kullanabilirsiniz. Python, C++, Java, PHP, Typescript (JavaScript), C#, Bash ve daha fazlası dahil olmak üzere günümüzde kullanılan en popüler programlama dillerinin çoğunu destekler.

Code Llama modellerinde neden ince ayar yapılmalıdır?

Meta, Code Llama performans kıyaslamalarını yayınladı HumanEval ve MBPP Python, Java ve JavaScript gibi yaygın kodlama dilleri için. Code Llama Python modellerinin HumanEval üzerindeki performansı, farklı kodlama dilleri ve görevlerde 38B Python modelinde %7'den 57B Python modellerinde %70'ye kadar değişen performans sergiledi. Ek olarak, SQL programlama dilinde ince ayarlı Code Llama modelleri, SQL değerlendirme kıyaslamalarında açıkça görüldüğü gibi daha iyi sonuçlar vermiştir. Yayınlanan bu kıyaslamalar, Code Llama modellerinde ince ayar yapmanın potansiyel faydalarını vurgulayarak daha iyi performans, özelleştirme ve belirli kodlama alanlarına ve görevlerine uyum sağlamayı mümkün kılıyor.

SageMaker Studio Kullanıcı Arayüzü aracılığıyla kod gerektirmeden ince ayar yapma

SageMaker Studio'yu kullanarak Lama modellerinize ince ayar yapmaya başlamak için aşağıdaki adımları tamamlayın:

1. SageMaker Studio konsolunda seçin HızlıBaşlangıç Gezinti bölmesinde.

Açık kaynaklı ve tescilli modellerden 350'den fazla modelin listesini bulacaksınız.

2. Code Llama modellerini arayın.
   

Code Llama modellerini göremiyorsanız SageMaker Studio sürümünüzü kapatıp yeniden başlatarak güncelleyebilirsiniz. Sürüm güncellemeleri hakkında daha fazla bilgi için bkz. Studio Uygulamalarını Kapatın ve Güncelleyin. Diğer model çeşitlerini de tercih ederek bulabilirsiniz. Tüm Kod Oluşturma Modellerini keşfedin veya arama kutusunda Code Lama'yı arayın.

SageMaker JumpStart şu anda Code Llama modelleri için talimat ince ayarını desteklemektedir. Aşağıdaki ekran görüntüsü Code Llama 2 70B modelinin ince ayar sayfasını göstermektedir.

3. İçin Eğitim veri kümesi konumu, işaret edebilirsiniz Amazon Basit Depolama Hizmeti İnce ayar için eğitim ve doğrulama veri kümelerini içeren (Amazon S3) paketi.
4. İnce ayar için dağıtım yapılandırmanızı, hiper parametrelerinizi ve güvenlik ayarlarınızı belirleyin.
5. Klinik Tren SageMaker ML örneğinde ince ayar işini başlatmak için.
   

Bir sonraki bölümde talimat ince ayarı için hazırlamanız gereken veri kümesi formatını tartışacağız.

6. Modelde ince ayar yapıldıktan sonra SageMaker JumpStart'taki model sayfasını kullanarak dağıtabilirsiniz.

Aşağıdaki ekran görüntüsünde gösterildiği gibi, ince ayar tamamlandığında ince ayarlı modeli dağıtma seçeneği görünecektir.

SageMaker Python SDK aracılığıyla ince ayar yapın

Bu bölümde, talimat formatlı bir veri kümesinde SageMaker Python SDK'yı kullanarak Code LIama modellerine nasıl ince ayar yapılacağını gösteriyoruz. Spesifik olarak model, talimatlar kullanılarak açıklanan bir dizi doğal dil işleme (NLP) görevi için ince ayarlanmıştır. Bu, sıfır atışlı istemlerle görünmeyen görevler için modelin performansının geliştirilmesine yardımcı olur.

İnce ayar işinizi tamamlamak için aşağıdaki adımları tamamlayın. İnce ayar kodunun tamamını şuradan alabilirsiniz: GitHub deposu.

İlk olarak, talimat ince ayarı için gereken veri seti formatına bakalım. Eğitim verileri, her satırın bir veri örneğini temsil eden bir sözlük olduğu JSON satırları (.jsonl) biçiminde biçimlendirilmelidir. Tüm eğitim verileri tek bir klasörde olmalıdır. Ancak birden fazla .jsonl dosyasına kaydedilebilir. Aşağıda JSON satırları biçiminde bir örnek verilmiştir:

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

Eğitim klasörü şunları içerebilir: template.json Giriş ve çıkış formatlarını açıklayan dosya. Aşağıda örnek bir şablon verilmiştir:

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

Şablonla eşleşmesi için JSON satır dosyalarındaki her örnek şunları içermelidir: system_prompt, question, ve response alanlar. Bu gösteride, şunu kullanıyoruz: Dolphin Coder veri kümesi Hugging Face'den.

Veri kümesini hazırlayıp S3 klasörüne yükledikten sonra aşağıdaki kodu kullanarak ince ayar yapmaya başlayabilirsiniz:

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şağıdaki kodda gösterildiği gibi ince ayarlı modeli doğrudan tahminciden dağıtabilirsiniz. Ayrıntılar için, not defterine bakın. GitHub deposu.

finetuned_predictor = estimator.deploy()

İnce ayar teknikleri

Llama gibi dil modellerinin boyutu 10 GB'tan, hatta 100 GB'tan fazladır. Bu kadar büyük modellerde ince ayar yapmak, önemli ölçüde yüksek CUDA belleğine sahip örnekler gerektirir. Ayrıca bu modellerin eğitimi, modelin boyutundan dolayı çok yavaş olabilir. Bu nedenle verimli ince ayar için aşağıdaki optimizasyonları kullanıyoruz:

• Düşük Dereceli Uyarlama (LoRA) – Bu, büyük modellerin verimli ince ayarına yönelik bir tür parametre verimli ince ayardır (PEFT). Bu yöntemle tüm modeli dondurursunuz ve modele yalnızca küçük bir dizi ayarlanabilir parametre veya katman eklersiniz. Örneğin, Llama 7 2B için 7 milyar parametrenin tamamını eğitmek yerine parametrelerin %1'inden daha azına ince ayar yapabilirsiniz. Bu, bellek gereksiniminin önemli ölçüde azaltılmasına yardımcı olur çünkü parametrelerin yalnızca %1'i için degradeleri, optimize edici durumlarını ve eğitimle ilgili diğer bilgileri saklamanız gerekir. Ayrıca bu, eğitim süresinin ve maliyetin azaltılmasına yardımcı olur. Bu yöntemle ilgili daha fazla ayrıntı için bkz. LoRA: Büyük Dil Modellerinin Düşük Dereceli Uyarlaması.
• Int8 nicemleme – LoRA gibi optimizasyonlarla bile Llama 70B gibi modeller eğitilemeyecek kadar büyük. Eğitim sırasında bellek ayak izini azaltmak için eğitim sırasında Int8 nicelemesini kullanabilirsiniz. Niceleme genellikle kayan noktalı veri türlerinin kesinliğini azaltır. Bu, model ağırlıklarını depolamak için gereken belleği azaltsa da bilgi kaybı nedeniyle performansı düşürür. Int8 niceleme yalnızca çeyrek hassasiyet kullanır ancak bitleri düşürmediği için performansın düşmesine neden olmaz. Verileri bir türden diğerine yuvarlar. Int8 nicemleme hakkında bilgi edinmek için bkz. LLM.int8(): Uygun Ölçekte Transformatörler için 8-bit Matris Çarpımı.
• Tamamen Parçalanmış Veri Paralel (FSDP) – Bu, modelin parametrelerini veri paralel çalışanları arasında bölen ve isteğe bağlı olarak eğitim hesaplamasının bir kısmını CPU'lara aktarabilen bir tür veri paralel eğitim algoritmasıdır. Parametreler farklı GPU'lar arasında paylaştırılsa da, her bir mikro grubun hesaplanması GPU çalışanı için yereldir. Parametreleri daha düzgün bir şekilde parçalara ayırır ve eğitim sırasında iletişim ve hesaplamanın örtüşmesi yoluyla optimize edilmiş performansa ulaşır.

Aşağıdaki tablo, farklı ayarlara sahip her modelin ayrıntılarını özetlemektedir.

Lama modellerinin ince ayarı aşağıdakiler tarafından sağlanan komut dosyalarına dayanmaktadır: GitHub repo.

Eğitim için desteklenen hiperparametreler

Code Llama 2 ince ayarı, her biri ince ayarlı modelin bellek gereksinimini, eğitim hızını ve performansını etkileyebilen bir dizi hiper parametreyi destekler:

• çağ – İnce ayar algoritmasının eğitim veri kümesinde gerçekleştirdiği geçiş sayısı. 1'den büyük bir tam sayı olmalıdır. Varsayılan 5'tir.
• öğrenme oranı – Her eğitim örneği grubu üzerinde çalışıldıktan sonra model ağırlıklarının güncellenme hızı. 0'dan büyük bir pozitif kayan nokta olmalıdır. Varsayılan 1e-4'tür.
• talimat_tuned – Modeli eğitip eğitmeyeceği. Olmalıdır True or False. Varsayılan False.
• per_device_train_batch_size – Eğitim için GPU çekirdeği/CPU başına parti boyutu. Pozitif bir tam sayı olmalıdır. Varsayılan 4'tür.
• per_device_eval_batch_size – Değerlendirme için GPU çekirdeği/CPU başına parti boyutu. Pozitif bir tam sayı olmalıdır. Varsayılan 1'dir.
• max_train_samples – Hata ayıklama amacıyla veya daha hızlı eğitim için eğitim örneklerinin sayısını bu değere düşürün. Değer -1, tüm eğitim örneklerinin kullanılması anlamına gelir. Pozitif bir tam sayı veya -1 olmalıdır. Varsayılan -1'dir.
• max_val_samples – Hata ayıklama amacıyla veya daha hızlı eğitim için doğrulama örneklerinin sayısını bu değere düşürün. Değer -1, tüm doğrulama örneklerinin kullanılması anlamına gelir. Pozitif bir tam sayı veya -1 olmalıdır. Varsayılan -1'dir.
• max_input_length – Tokenizasyondan sonra maksimum toplam giriş dizisi uzunluğu. Bundan daha uzun diziler kesilecektir. -1 ise, max_input_length minimum 1024'e ve tokenizer tarafından tanımlanan maksimum model uzunluğuna ayarlanmıştır. Pozitif bir değere ayarlanırsa, max_input_length sağlanan değerin minimumuna ayarlanır ve model_max_length tokenizer tarafından tanımlanır. Pozitif bir tam sayı veya -1 olmalıdır. Varsayılan -1'dir.
• validation_split_ratio – Doğrulama kanalı ise none, tren verilerinden tren doğrulama bölünmesinin oranı 0-1 arasında olmalıdır. Varsayılan 0.2'dir.
• train_data_split_seed – Doğrulama verileri mevcut değilse, bu, giriş eğitim verilerinin algoritma tarafından kullanılan eğitim ve doğrulama verilerine rastgele bölünmesini düzeltir. Tam sayı olmak zorunda. Varsayılan 0'dır.
• preprocessing_num_workers – Ön işleme için kullanılacak işlemlerin sayısı. Eğer None, ana işlem ön işleme için kullanılır. Varsayılan: None.
• lora_r – Lora R. Pozitif bir tam sayı olmalıdır. Varsayılan 8'dir.
• lora_alpha - Lora Alfa. Pozitif bir tam sayı olmalıdır. Varsayılan 32'dir
• lora_dropout – Lora Bırakma. 0 ile 1 arasında pozitif bir kayan nokta olmalıdır. Varsayılan 0.05'tir.
• int8_kuantizasyon - Eğer Truemodel, eğitim için 8 bit hassasiyetle yüklenir. 7B ve 13B için varsayılan: False. 70B için varsayılan: True.
• etkinleştirme_fsdp – Doğruysa, eğitim FSDP'yi kullanır. 7B ve 13B için varsayılan Doğru'dur. 70B için varsayılan Yanlış'tır. Dikkat int8_quantization FSDP tarafından desteklenmez.

Hiperparametreleri seçerken aşağıdakileri göz önünde bulundurun:

• ayar int8_quantization=True Bellek gereksinimini azaltır ve daha hızlı eğitime yol açar.
• Azalan per_device_train_batch_size ve max_input_length bellek gereksinimini azaltır ve bu nedenle daha küçük örneklerde çalıştırılabilir. Ancak değerlerin çok düşük ayarlanması eğitim süresini artırabilir.
• Int8 nicelemesini kullanmıyorsanız (int8_quantization=False), FSDP'yi kullanın (enable_fsdp=True) daha hızlı ve verimli eğitim için.

Eğitim için desteklenen örnek türleri

Aşağıdaki tablo, farklı modellerin eğitimi için desteklenen bulut sunucusu türlerini özetlemektedir.

Bulut sunucusu tipini seçerken aşağıdakileri göz önünde bulundurun:

• G5 bulut sunucuları, desteklenen bulut sunucusu türleri arasında en verimli eğitimi sağlar. Bu nedenle G5 bulut sunucularınız varsa bunları kullanmalısınız.
• Eğitim süresi büyük ölçüde GPU sayısına ve mevcut CUDA belleğine bağlıdır. Bu nedenle, aynı sayıda GPU'ya (örneğin, ml.g5.2xlarge ve ml.g5.4xlarge) sahip bulut sunucuları üzerinde eğitim kabaca aynıdır. Bu nedenle eğitim için daha ucuz örneği kullanabilirsiniz (ml.g5.2xlarge).
• p3 örnekleri kullanıldığında bfloat32 bu örneklerde desteklenmediği için eğitim 16 bit hassasiyetle yapılacaktır. Bu nedenle eğitim işi, p3 bulut sunucuları üzerinde eğitim sırasında g5 bulut sunucularına kıyasla iki kat daha fazla CUDA belleği tüketecektir.

Örnek başına eğitim maliyeti hakkında bilgi edinmek için bkz. Amazon EC2 G5 Örnekleri.

Değerlendirme

Değerlendirme, ince ayarlı modellerin performansını değerlendirmek için önemli bir adımdır. İnce ayarlı modellerin ince ayarlı olmayan modellere göre gelişimini göstermek için hem niteliksel hem de niceliksel değerlendirmeler sunuyoruz. Niteliksel değerlendirmede, hem ince ayarlı hem de ince ayarlı olmayan modellerden örnek bir yanıt gösteriyoruz. Niceliksel değerlendirmede şunları kullanırız: İnsanDeğerlendirmesiDoğru ve doğru sonuçlar üretme yeteneklerini test etmek amacıyla Python kodu oluşturmak için OpenAI tarafından geliştirilen bir test paketi. HumanEval deposu MIT lisansı altındadır. Tüm Code LIama modellerinin Python varyantlarına farklı boyutlarda ince ayar yaptık (Code LIama Python 7B, 13B, 34B ve 70B Dolphin Coder veri kümesi) ve değerlendirme sonuçlarını aşağıdaki bölümlerde sunun.

Niteliksel değerlendirme

İnce ayarlı modeliniz dağıtıldığında, kod oluşturmak için uç noktayı kullanmaya başlayabilirsiniz. Aşağıdaki örnekte, bir test örneğinde hem temel hem de ince ayarlı Code LIama 34B Python varyantlarından yanıtlar sunuyoruz. Dolphin Coder veri kümesi:

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

İnce ayarlı Code Llama modeli, önceki sorgunun kodunu sağlamanın yanı sıra, yaklaşımın ayrıntılı bir açıklamasını ve bir sözde kod üretir.

Code Llama 34b Python İnce Ayarlı Olmayan Yanıt:

### 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 İnce Ayarlı Yanıt

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

Zemin gerçeği

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

İlginç bir şekilde, Code Llama 34B Python'un ince ayarlı sürümü, en uzun palindromik alt diziye dinamik programlama tabanlı bir çözüm sağlar; bu, seçilen test örneğindeki temel gerçeklikte sağlanan çözümden farklıdır. İnce ayarlı modelimiz, dinamik programlama tabanlı çözümü ayrıntılı olarak açıklıyor ve açıklıyor. Öte yandan, ince ayar yapılmamış model, potansiyel çıktıları, üretimden hemen sonra halüsinasyona uğratır. print deyimi (sol hücrede gösterilmektedir) çünkü çıktı axyzzyx verilen dizedeki en uzun palindrom değil. Zaman karmaşıklığı açısından dinamik programlama çözümü genellikle ilk yaklaşımdan daha iyidir. Dinamik programlama çözümünün zaman karmaşıklığı O(n^2)'dir; burada n, giriş dizesinin uzunluğudur. Bu, aynı zamanda O(n^2) ikinci dereceden zaman karmaşıklığına sahip olan ancak daha az optimize edilmiş bir yaklaşıma sahip olan, ince ayar yapılmamış modelin ilk çözümünden daha verimlidir.

Bu umut verici görünüyor! Unutmayın, Code LIama Python varyantında yalnızca %10 oranında ince ayar yaptık. Dolphin Coder veri kümesi. Keşfedilecek daha çok şey var!

Yanıttaki kapsamlı talimatlara rağmen yine de çözümde sağlanan Python kodunun doğruluğunu incelememiz gerekiyor. Daha sonra, adı verilen bir değerlendirme çerçevesi kullanırız. İnsan Değerlendirmesi Kalitesini sistematik olarak incelemek için Code LIama'dan oluşturulan yanıt üzerinde entegrasyon testleri yürütmek.

HumanEval ile niceliksel değerlendirme

HumanEval, makalede açıklandığı gibi, bir Yüksek Lisans'ın Python tabanlı kodlama problemlerinde problem çözme yeteneklerini değerlendirmek için kullanılan bir değerlendirme aracıdır. Kod Eğitimi Alan Büyük Dil Modellerinin Değerlendirilmesi. Spesifik olarak, bir dil modelinin işlev imzası, docstring, gövde ve birim testleri gibi sağlanan bilgilere dayalı olarak kod üretme yeteneğini değerlendiren 164 orijinal Python tabanlı programlama probleminden oluşur.

Her Python tabanlı programlama sorusunu k yanıt almak üzere SageMaker uç noktasında konuşlandırılan Code LIama modeline gönderiyoruz. Daha sonra, HumanEval deposundaki entegrasyon testlerinde k yanıtın her birini çalıştırıyoruz. K yanıtın herhangi bir yanıtı entegrasyon testlerini geçerse, o test senaryosunu başarılı sayarız; aksi takdirde başarısız oldu. Daha sonra başarılı vakaların oranını nihai değerlendirme puanı olarak hesaplamak için işlemi tekrarlıyoruz. pass@k. Standart uygulamayı takiben, soru başına yalnızca bir yanıt oluşturmak ve entegrasyon testini geçip geçmediğini test etmek için değerlendirmemizde k'yi 1 olarak belirledik.

Aşağıda HumanEval deposunu kullanmak için örnek bir kod bulunmaktadır. SageMaker uç noktasını kullanarak veri kümesine erişebilir ve tek bir yanıt oluşturabilirsiniz. Ayrıntılar için, not defterine bakın. GitHub deposu.

%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şağıdaki tablo, farklı model boyutlarında ince ayarlı Code LIama Python modellerinin ince ayarlı olmayan modellere göre iyileştirmelerini göstermektedir. Doğruluğu sağlamak için, ince ayar yapılmamış Code LIama modellerini de SageMaker uç noktalarına dağıtıyoruz ve İnsan Değerlendirmesi değerlendirmelerinden geçiyoruz. pas@1 sayılar (aşağıdaki tabloda ilk satır), raporda bildirilen sayılarla eşleşiyor Kod Lama araştırma makalesi. Çıkarım parametreleri tutarlı bir şekilde şu şekilde ayarlanır: "parameters": {"max_new_tokens": 384, "temperature": 0.2}.

Sonuçlardan da görebileceğimiz gibi, tüm ince ayarlı Code LIama Python varyantları, ince ayar yapılmamış modellere göre önemli bir gelişme göstermektedir. Özellikle Code LIama Python 70B, ince ayar yapılmayan modelden yaklaşık %12 oranında daha iyi performans göstermektedir.

Artık Code LIama modellerine kendi veri kümenizde ince ayar yapmayı deneyebilirsiniz.

Temizlemek

SageMaker uç noktasını artık çalışır durumda tutmak istemediğinize karar verirseniz, şunu kullanarak silebilirsiniz: Python için AWS SDK (Boto3), AWS Komut Satırı Arayüzü (AWS CLI) veya SageMaker konsolu. Daha fazla bilgi için bakınız Uç Noktaları ve Kaynakları Sil. Ayrıca şunları yapabilirsiniz: SageMaker Studio kaynaklarını kapatın artık gerekli değil.

Sonuç

Bu yazıda, SageMaker JumpStart'ı kullanarak Meta'nın Code Llama 2 modellerine ince ayar yapmayı tartıştık. Bu modellere ince ayar yapmak ve dağıtmak için SageMaker Studio'daki SageMaker JumpStart konsolunu veya SageMaker Python SDK'yı kullanabileceğinizi gösterdik. Ayrıca ince ayar tekniğini, örnek türlerini ve desteklenen hiperparametreleri de tartıştık. Ayrıca, yürüttüğümüz çeşitli testlere dayanarak optimize edilmiş eğitim önerilerinin ana hatlarını çizdik. İki veri kümesi üzerinde üç modele ince ayar yapılmasının bu sonuçlarından da görebileceğimiz gibi, ince ayar, ince ayar yapılmayan modellere kıyasla özetlemeyi geliştirir. Bir sonraki adım olarak, kullanım senaryolarınız için sonuçları test etmek ve kıyaslamak amacıyla GitHub deposunda sağlanan kodu kullanarak bu modellere kendi veri kümenizde ince ayar yapmayı deneyebilirsiniz.

Yazarlar Hakkında

Doktor Xin Huang Amazon SageMaker JumpStart ve Amazon SageMaker yerleşik algoritmaları için Kıdemli Uygulamalı Bilim İnsanıdır. Ölçeklenebilir makine öğrenimi algoritmaları geliştirmeye odaklanıyor. Araştırma ilgi alanları, doğal dil işleme, tablo verileri üzerinde açıklanabilir derin öğrenme ve parametrik olmayan uzay-zaman kümelemenin sağlam analizi alanındadır. ACL, ICDM, KDD konferanslarında ve Royal Statistical Society: Series A'da birçok makale yayınladı.

Vişaal Yalamanchali erken aşamadaki üretken yapay zeka, robot teknolojisi ve otonom araç şirketleriyle çalışan bir Startup Solutions Architect'tir. Vishaal, en son teknoloji makine öğrenimi çözümleri sunmak için müşterileriyle birlikte çalışıyor ve kişisel olarak takviyeli öğrenme, LLM değerlendirmesi ve kod oluşturmayla ilgileniyor. AWS'den önce Vishaal, UCI'da biyoinformatik ve akıllı sistemlere odaklanan bir lisans öğrencisiydi.

Meenakshisundaram Thandavarayan AWS'de AI/ML Uzmanı olarak çalışıyor. İnsan odaklı veri ve analitik deneyimlerini tasarlama, yaratma ve tanıtma tutkusuna sahiptir. Meena, AWS'nin stratejik müşterilerine ölçülebilir, rekabet avantajı sağlayan sürdürülebilir sistemler geliştirmeye odaklanıyor. Meena bir bağlayıcı ve tasarım düşünürüdür ve işletmeleri inovasyon, kuluçka ve demokratikleşme yoluyla yeni çalışma yöntemlerine yönlendirmeye çalışmaktadır.

Ashish Khetan Amazon SageMaker yerleşik algoritmalarına sahip Kıdemli Uygulamalı Bilim Adamıdır ve makine öğrenimi algoritmalarının geliştirilmesine yardımcı olur. Doktora derecesini University of Illinois Urbana-Champaign'den almıştır. Makine öğrenimi ve istatistiksel çıkarım alanlarında aktif bir araştırmacıdır ve NeurIPS, ICML, ICLR, JMLR, ACL ve EMNLP konferanslarında birçok makale yayınlamıştır.

• SEO Destekli İçerik ve Halkla İlişkiler Dağıtımı. Bugün Gücünüzü Artırın.
• PlatoData.Network Dikey Üretken Yapay Zeka. Kendine güç ver. Buradan Erişin.
• PlatoAiStream. Web3 Zekası. Bilgi Genişletildi. Buradan Erişin.
• PlatoESG. karbon, temiz teknoloji, Enerji, Çevre, Güneş, Atık Yönetimi. Buradan Erişin.
• PlatoSağlık. Biyoteknoloji ve Klinik Araştırmalar Zekası. Buradan Erişin.
• Kaynak: https://aws.amazon.com/blogs/machine-learning/fine-tune-code-llama-on-amazon-sagemaker-jumpstart/