Sempurnakan Kode Llama di Amazon SageMaker JumpStart | Layanan Web Amazon

Hari ini, kami sangat gembira mengumumkan kemampuan untuk menyempurnakan model Code Llama dengan menggunakan Meta Mulai Lompatan Amazon SageMaker. Keluarga model bahasa besar (LLM) Code Llama adalah kumpulan model pembuatan kode yang telah dilatih dan disempurnakan dengan skala mulai dari 7 miliar hingga 70 miliar parameter. Model Code Llama yang disempurnakan memberikan akurasi dan penjelasan yang lebih baik dibandingkan model Code Llama dasar, sebagaimana terbukti dalam pengujiannya terhadap Evaluasi Manusia dan kumpulan data MBPP. Anda dapat menyempurnakan dan menerapkan model Code Llama dengan SageMaker JumpStart menggunakan Studio Amazon SageMaker UI dengan beberapa klik atau menggunakan SageMaker Python SDK. Penyempurnaan model Llama didasarkan pada skrip yang disediakan di repo GitHub resep llama dari Meta menggunakan teknik kuantisasi PyTorch FSDP, PEFT/LoRA, dan Int8.

Dalam postingan ini, kita akan mempelajari cara menyempurnakan model terlatih Code Llama melalui SageMaker JumpStart melalui pengalaman UI dan SDK sekali klik yang tersedia berikut ini Repositori GitHub.

Apa itu SageMaker JumpStart

Dengan SageMaker JumpStart, praktisi pembelajaran mesin (ML) dapat memilih dari beragam pilihan model dasar yang tersedia untuk umum. Praktisi ML dapat menerapkan model dasar ke model khusus Amazon SageMaker instans dari lingkungan yang terisolasi jaringan dan sesuaikan model menggunakan SageMaker untuk pelatihan dan penerapan model.

Apa itu Kode Llama

Code Llama adalah versi khusus kode Lama 2 yang dibuat dengan melatih lebih lanjut Llama 2 pada kumpulan data khusus kode dan mengambil sampel lebih banyak data dari kumpulan data yang sama dalam jangka waktu yang lebih lama. Code Llama menampilkan kemampuan pengkodean yang ditingkatkan. Ini dapat menghasilkan kode dan bahasa alami tentang kode, baik dari kode maupun perintah bahasa alami (misalnya, “Tuliskan saya fungsi yang menghasilkan deret Fibonacci”). Anda juga dapat menggunakannya untuk penyelesaian kode dan debugging. Ini mendukung banyak bahasa pemrograman paling populer yang digunakan saat ini, termasuk Python, C++, Java, PHP, TypeScript (JavaScript), C#, Bash, dan banyak lagi.

Mengapa menyempurnakan model Code Llama

Meta menerbitkan tolok ukur kinerja Code Llama pada HumanEval dan MBPP untuk bahasa pengkodean umum seperti Python, Java, dan JavaScript. Performa model Code Llama Python di HumanEval menunjukkan performa yang bervariasi di berbagai bahasa pengkodean dan tugas mulai dari 38% pada model Python 7B hingga 57% pada model Python 70B. Selain itu, model Code Llama yang disempurnakan pada bahasa pemrograman SQL telah menunjukkan hasil yang lebih baik, sebagaimana terlihat dalam tolok ukur evaluasi SQL. Tolok ukur yang dipublikasikan ini menyoroti manfaat potensial dari penyempurnaan model Code Llama, memungkinkan kinerja, penyesuaian, dan adaptasi yang lebih baik terhadap domain dan tugas pengkodean tertentu.

Penyempurnaan tanpa kode melalui UI SageMaker Studio

Untuk mulai menyempurnakan model Llama Anda menggunakan SageMaker Studio, selesaikan langkah-langkah berikut:

1. Di konsol SageMaker Studio, pilih Tingkatkan di panel navigasi.

Anda akan menemukan daftar lebih dari 350 model mulai dari model open source dan proprietary.

2. Cari model Kode Llama.
   

Jika Anda tidak melihat model Code Llama, Anda dapat memperbarui versi SageMaker Studio dengan mematikan dan memulai ulang. Untuk informasi lebih lanjut tentang pembaruan versi, lihat Matikan dan Perbarui Aplikasi Studio. Anda juga dapat menemukan varian model lainnya dengan memilih Jelajahi semua Model Pembuatan Kode atau mencari Kode Llama di kotak pencarian.

SageMaker JumpStart saat ini mendukung penyempurnaan instruksi untuk model Code Llama. Tangkapan layar berikut menunjukkan halaman penyesuaian untuk model Code Llama 2 70B.

3. Untuk Lokasi set data pelatihan, Anda dapat menunjuk ke Layanan Penyimpanan Sederhana Amazon (Amazon S3) yang berisi kumpulan data pelatihan dan validasi untuk penyesuaian.
4. Tetapkan konfigurasi penerapan, hyperparameter, dan pengaturan keamanan Anda untuk penyesuaian.
5. Pilih Pelatihan VE untuk memulai pekerjaan penyesuaian pada instans SageMaker ML.
   

Kami membahas format kumpulan data yang perlu Anda persiapkan untuk penyesuaian instruksi di bagian berikutnya.

6. Setelah model disetel dengan baik, Anda dapat menerapkannya menggunakan halaman model di SageMaker JumpStart.

Opsi untuk menyebarkan model yang telah disempurnakan akan muncul setelah penyesuaian selesai, seperti yang ditunjukkan pada gambar layar berikut.

Sempurnakan melalui SageMaker Python SDK

Di bagian ini, kami mendemonstrasikan cara menyempurnakan model Code LIama menggunakan SageMaker Python SDK pada kumpulan data berformat instruksi. Secara khusus, model ini disesuaikan untuk serangkaian tugas pemrosesan bahasa alami (NLP) yang dijelaskan menggunakan instruksi. Hal ini membantu meningkatkan performa model untuk tugas yang tidak terlihat dengan perintah zero-shot.

Selesaikan langkah-langkah berikut untuk menyelesaikan pekerjaan penyesuaian Anda. Anda bisa mendapatkan seluruh kode penyesuaian dari Repositori GitHub.

Pertama, mari kita lihat format kumpulan data yang diperlukan untuk penyesuaian instruksi. Data pelatihan harus diformat dalam format baris JSON (.jsonl), dengan setiap baris merupakan kamus yang mewakili sampel data. Semua data pelatihan harus berada dalam satu folder. Namun, itu dapat disimpan dalam beberapa file .jsonl. Berikut ini contoh format baris JSON:

{
	'system_prompt': 'a chat',
	'question': 'Please focus on the efficiency of this problem and provide code in python:nYou are given two strings `s` and `t` consisting of only lowercase English letters.nnReturn _the minimum number of characters that need to be appended to the end of_ `s` _so that_ `t` _becomes a **subsequence** of_ `s`.nnA **subsequence** is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.nn**Example 1:**nn**Input:** s = "coaching ", t = "coding "n**Output:** 4n**Explanation:** Append the characters "ding " to the end of s so that s = "coachingding ".nNow, t is a subsequence of s ( "**co**aching**ding** ").nIt can be shown that appending any 3 characters to the end of s will never make t a subsequence.nn**Example 2:**nn**Input:** s = "abcde ", t = "a "n**Output:** 0n**Explanation:** t is already a subsequence of s ( "**a**bcde ").nn**Example 3:**nn**Input:** s = "z ", t = "abcde "n**Output:** 5n**Explanation:** Append the characters "abcde " to the end of s so that s = "zabcde ".nNow, t is a subsequence of s ( "z**abcde** ").nIt can be shown that appending any 4 characters to the end of s will never make t a subsequence.nn**Constraints:**nn* `1 <= s.length, t.length <= 105`n* `s` and `t` consist only of lowercase English letters.',
	'response': '### Explanationn The algorithm maintains two pointers, `i` and `j`, to iterate through the given strings `s` and `t`. The pointer `i` iterates through the string `s` and the pointer `j` iterates through the string `t`. While iterating through `s`, if we find a character that matches the current character in `t`, we increment the `j` pointer. This is because the matched character can be a part of the subsequence we are looking for. The iteration stops when either `i` reaches the end of `s` or `j` reaches the end of `t`.nnAt the end, we subtract the index `j` from the length of `t`. This gives us the minimum number of characters that need to be appended to the end of `s` so that `t` becomes a subsequence of `s`.nn### Pseudocode:n```nMIN-ADDITION(s, t)n s_len = LENGTH(s)n t_len = LENGTH(t)n i = 1n j = 1n WHILE i <= s_len AND j <= t_lenn IF s[i] == t[j]n j = j + 1n ENDIFn i = i + 1n ENDWHILEn RETURN t_len - j + 1nENDMIN-ADDITIONn```nn### Coden```pythonndef min_addition(s: str, t: str) -> int:n s_len = len(s)n t_len = len(t)n i, j = 0, 0n while i < s_len and j < t_len:n if s[i] == t[j]:n j += 1n i += 1n return t_len - jn```n'
}

Folder pelatihan dapat berisi a template.json file yang menjelaskan format input dan output. Berikut contoh templatnya:

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

Untuk mencocokkan templat, setiap sampel dalam file baris JSON harus disertakan system_prompt, question, dan response bidang. Dalam demonstrasi ini, kami menggunakan Kumpulan data Dolphin Coder dari Memeluk Wajah.

Setelah Anda menyiapkan himpunan data dan mengunggahnya ke bucket S3, Anda dapat mulai melakukan penyesuaian menggunakan kode berikut:

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

Anda dapat menerapkan model yang telah disempurnakan langsung dari estimator, seperti yang ditunjukkan dalam kode berikut. Untuk lebih jelasnya lihat buku catatan di Repositori GitHub.

finetuned_predictor = estimator.deploy()

Teknik penyempurnaan

Model bahasa seperti Llama berukuran lebih dari 10 GB atau bahkan 100 GB. Menyempurnakan model besar seperti itu memerlukan instans dengan memori CUDA yang sangat tinggi. Selain itu, pelatihan model ini bisa sangat lambat karena ukuran modelnya. Oleh karena itu, untuk penyesuaian yang efisien, kami menggunakan pengoptimalan berikut:

• Adaptasi Tingkat Rendah (LoRA) – Ini adalah jenis penyempurnaan efisien parameter (PEFT) untuk penyempurnaan efisien pada model besar. Dengan metode ini, Anda membekukan keseluruhan model dan hanya menambahkan sekumpulan kecil parameter atau lapisan yang dapat disesuaikan ke dalam model. Misalnya, daripada melatih seluruh 7 miliar parameter untuk Llama 2 7B, Anda dapat menyempurnakan kurang dari 1% parameter. Hal ini membantu mengurangi kebutuhan memori secara signifikan karena Anda hanya perlu menyimpan gradien, status pengoptimal, dan informasi terkait pelatihan lainnya hanya untuk 1% parameter. Selain itu, ini membantu mengurangi waktu pelatihan serta biaya. Untuk rincian lebih lanjut tentang metode ini, lihat LoRA: Adaptasi Peringkat Rendah dari Model Bahasa Besar.
• kuantisasi Int8 – Bahkan dengan optimasi seperti LoRA, model seperti Llama 70B masih terlalu besar untuk dilatih. Untuk mengurangi jejak memori selama pelatihan, Anda dapat menggunakan kuantisasi Int8 selama pelatihan. Kuantisasi biasanya mengurangi ketepatan tipe data floating point. Meskipun hal ini mengurangi memori yang diperlukan untuk menyimpan bobot model, hal ini menurunkan kinerja karena hilangnya informasi. Kuantisasi Int8 hanya menggunakan presisi seperempat tetapi tidak menyebabkan penurunan kinerja karena tidak menghilangkan sedikit pun. Ini membulatkan data dari satu tipe ke tipe lainnya. Untuk mempelajari tentang kuantisasi Int8, lihat LLM.int8(): Perkalian Matriks 8-bit untuk Transformer dalam Skala Besar.
• Paralel Data Terpecah Sepenuhnya (FSDP) – Ini adalah jenis algoritme pelatihan paralel data yang membagi parameter model ke seluruh pekerja paralel data dan secara opsional dapat memindahkan sebagian komputasi pelatihan ke CPU. Meskipun parameternya dibagi ke beberapa GPU yang berbeda, komputasi setiap microbatch bersifat lokal bagi pekerja GPU. Ini memecah parameter secara lebih seragam dan mencapai performa optimal melalui komunikasi dan komputasi yang tumpang tindih selama pelatihan.

Tabel berikut merangkum detail masing-masing model dengan pengaturan berbeda.

Penyempurnaan model Llama didasarkan pada skrip yang disediakan berikut ini GitHub repo.

Hyperparameter yang didukung untuk pelatihan

Penyempurnaan kode Llama 2 mendukung sejumlah hyperparameter, yang masing-masing dapat memengaruhi kebutuhan memori, kecepatan pelatihan, dan performa model yang disempurnakan:

• masa – Jumlah lintasan yang dilakukan algoritme penyesuaian melalui kumpulan data pelatihan. Harus berupa bilangan bulat yang lebih besar dari 1. Standarnya adalah 5.
• tingkat_belajar – Kecepatan pembaruan bobot model setelah mengerjakan setiap batch contoh pelatihan. Harus berupa float positif yang lebih besar dari 0. Defaultnya adalah 1e-4.
• instruksi_disetel – Apakah akan melatih model secara instruksi atau tidak. Harus True or False. Default-nya adalah False.
• per_device_train_batch_size – Ukuran batch per inti GPU/CPU untuk pelatihan. Harus berupa bilangan bulat positif. Standarnya adalah 4.
• per_device_eval_batch_size – Ukuran batch per inti GPU/CPU untuk evaluasi. Harus berupa bilangan bulat positif. Standarnya adalah 1.
• max_train_samples – Untuk tujuan debugging atau pelatihan yang lebih cepat, potong jumlah contoh pelatihan ke nilai ini. Nilai -1 berarti menggunakan semua sampel pelatihan. Harus berupa bilangan bulat positif atau -1. Standarnya adalah -1.
• max_val_samples – Untuk tujuan debugging atau pelatihan yang lebih cepat, potong jumlah contoh validasi ke nilai ini. Nilai -1 berarti menggunakan seluruh sampel validasi. Harus berupa bilangan bulat positif atau -1. Standarnya adalah -1.
• max_input_length – Total panjang urutan input maksimum setelah tokenisasi. Urutan yang lebih panjang dari ini akan terpotong. Jika -1, max_input_length diatur ke minimum 1024 dan panjang model maksimum yang ditentukan oleh tokenizer. Jika disetel ke nilai positif, max_input_length diatur ke nilai minimum yang diberikan dan model_max_length ditentukan oleh tokenizer. Harus berupa bilangan bulat positif atau -1. Standarnya adalah -1.
• validasi_split_ratio – Jika saluran validasi adalah none, rasio pemisahan validasi kereta dari data kereta harus antara 0–1. Standarnya adalah 0.2.
• train_data_split_seed – Jika data validasi tidak ada, tindakan ini akan memperbaiki pemisahan acak data pelatihan masukan menjadi data pelatihan dan validasi yang digunakan oleh algoritme. Harus bilangan bulat. Standarnya adalah 0.
• preprocessing_num_workers – Jumlah proses yang digunakan untuk prapemrosesan. Jika None, proses utama digunakan untuk preprocessing. Standarnya adalah None.
• lora_r – Lora R. Harus bilangan bulat positif. Standarnya adalah 8.
• lora_alpha – Lora Alfa. Harus berupa bilangan bulat positif. Standarnya adalah 32
• lora_putus sekolah – Lora Putus Sekolah. harus berupa float positif antara 0 dan 1. Standarnya adalah 0.05.
• int8_quantisasi - Jika True, model dimuat dengan presisi 8-bit untuk pelatihan. Default untuk 7B dan 13B adalah False. Default untuk 70B adalah True.
• aktifkan_fsdp – Jika Benar, pelatihan menggunakan FSDP. Default untuk 7B dan 13B adalah Benar. Default untuk 70B adalah False. Perhatikan itu int8_quantization tidak didukung dengan FSDP.

Saat memilih hyperparameter, pertimbangkan hal berikut:

• Pengaturan int8_quantization=True mengurangi kebutuhan memori dan menghasilkan pelatihan yang lebih cepat.
• Penurunan per_device_train_batch_size dan max_input_length mengurangi kebutuhan memori dan oleh karena itu dapat dijalankan pada instance yang lebih kecil. Namun, menetapkan nilai yang sangat rendah dapat menambah waktu pelatihan.
• Jika Anda tidak menggunakan kuantisasi Int8 (int8_quantization=False), gunakan FSDP (enable_fsdp=True) untuk pelatihan yang lebih cepat dan efisien.

Jenis instans yang didukung untuk pelatihan

Tabel berikut merangkum jenis instans yang didukung untuk melatih berbagai model.

Saat memilih jenis instans, pertimbangkan hal berikut:

• Instans G5 memberikan pelatihan paling efisien di antara jenis instans yang didukung. Oleh karena itu, jika Anda memiliki instans G5, Anda harus menggunakannya.
• Waktu pelatihan sangat bergantung pada jumlah GPU dan memori CUDA yang tersedia. Oleh karena itu, pelatihan pada instans dengan jumlah GPU yang sama (misalnya, ml.g5.2xlarge dan ml.g5.4xlarge) kurang lebih sama. Oleh karena itu, Anda dapat menggunakan instance yang lebih murah untuk pelatihan (ml.g5.2xlarge).
• Saat menggunakan instans p3, pelatihan akan dilakukan dengan presisi 32-bit karena bfloat16 tidak didukung pada instans ini. Oleh karena itu, tugas pelatihan akan mengonsumsi dua kali lipat jumlah memori CUDA saat pelatihan pada instans p3 dibandingkan dengan instans g5.

Untuk mempelajari tentang biaya pelatihan per instans, lihat Contoh Amazon EC2 G5.

Evaluasi

Evaluasi adalah langkah penting untuk menilai kinerja model yang telah disesuaikan. Kami menyajikan evaluasi kualitatif dan kuantitatif untuk menunjukkan peningkatan model yang telah disesuaikan dibandingkan model yang tidak telah disesuaikan. Dalam evaluasi kualitatif, kami menunjukkan contoh tanggapan dari model yang telah disesuaikan dan yang belum disesuaikan. Dalam evaluasi kuantitatif, kami menggunakan Evaluasi Manusia, rangkaian pengujian yang dikembangkan oleh OpenAI untuk menghasilkan kode Python guna menguji kemampuan dalam menghasilkan hasil yang benar dan akurat. Repositori HumanEval berada di bawah lisensi MIT. Kami menyempurnakan varian Python dari semua model Kode LIama dengan ukuran berbeda (Kode LIama Python 7B, 13B, 34B, dan 70B di Kumpulan data Dolphin Coder), dan sajikan hasil evaluasi pada bagian berikut.

Evaluasi secara kualitatif

Dengan penerapan model yang telah disesuaikan, Anda dapat mulai menggunakan titik akhir untuk menghasilkan kode. Dalam contoh berikut, kami menyajikan respons dari varian Python Code LIama 34B dasar dan yang telah disempurnakan pada sampel pengujian di Kumpulan data Dolphin Coder:

alpaca_format = """{system_prompt}

### Input:
{question}

### Response:n"""

system="You are a coding AI"
prompt = """Please explain the reasoning behind the following solution and 
provide code in python: Given a string `s`, return the longest palindromic 
substring in `s`. **Example 1:** **Input:** s = "babad " **Output:** "bab " 
**Explanation:** "aba " is also a valid answer. **Example 2:** 
**Input:** s = "cbbd " **Output:** "bb " 
**Constraints:** * `1 <= s.length <= 1000` * `s` consist of only digits 
and English letters."""

payload = json.dumps({
    "inputText": alpaca_format.format(system_prompt=system, question=prompt),
    "textGenerationConfig": {
    "maxTokenCount": 2048,
    "temperature":0.2
}})

finetuned_response = finetuned_predictor.predict(payload)
finetuned_response["generated_text"]

Model Code Llama yang disempurnakan, selain menyediakan kode untuk kueri sebelumnya, menghasilkan penjelasan mendetail tentang pendekatan dan kode semu.

Kode Llama 34b Respons Python yang Tidak Diselesaikan:

### 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 Respons Python yang Disempurnakan

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

Kebenaran dasar

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

Menariknya, versi Code Llama 34B Python kami yang telah disempurnakan memberikan solusi berbasis pemrograman dinamis untuk substring palindromik terpanjang, yang berbeda dari solusi yang diberikan dalam kebenaran dasar dari contoh pengujian yang dipilih. Model kami yang telah disempurnakan menjelaskan dan menjelaskan solusi berbasis pemrograman dinamis secara mendetail. Di sisi lain, model yang tidak disesuaikan akan berhalusinasi tentang keluaran potensial tepat setelahnya print pernyataan (ditampilkan di sel kiri) karena output axyzzyx bukan palindrom terpanjang dalam string tertentu. Dalam hal kompleksitas waktu, solusi pemrograman dinamis umumnya lebih baik daripada pendekatan awal. Solusi pemrograman dinamis memiliki kompleksitas waktu O(n^2), di mana n adalah panjang string masukan. Hal ini lebih efisien dibandingkan solusi awal dari model yang tidak disempurnakan, yang juga memiliki kompleksitas waktu kuadrat O(n^2) namun dengan pendekatan yang kurang optimal.

Ini terlihat menjanjikan! Ingat, kami hanya menyempurnakan varian Code LIama Python dengan 10% dari varian tersebut Kumpulan data Dolphin Coder. Masih banyak lagi yang bisa dijelajahi!

Meskipun ada instruksi menyeluruh dalam responsnya, kami masih perlu memeriksa kebenaran kode Python yang disediakan dalam solusi. Selanjutnya, kita menggunakan kerangka evaluasi yang disebut Evaluasi Manusia untuk menjalankan pengujian integrasi pada respons yang dihasilkan dari Kode LIama untuk memeriksa kualitasnya secara sistematis.

Evaluasi kuantitatif dengan HumanEval

HumanEval adalah alat evaluasi untuk mengevaluasi kemampuan pemecahan masalah LLM pada masalah pengkodean berbasis Python, seperti yang dijelaskan dalam makalah Mengevaluasi Model Bahasa Besar yang Dilatih tentang Kode. Secara khusus, ini terdiri dari 164 masalah pemrograman asli berbasis Python yang menilai kemampuan model bahasa untuk menghasilkan kode berdasarkan informasi yang diberikan seperti tanda tangan fungsi, docstring, body, dan pengujian unit.

Untuk setiap pertanyaan pemrograman berbasis Python, kami mengirimkannya ke model Code LIama yang diterapkan pada titik akhir SageMaker untuk mendapatkan k respons. Selanjutnya, kami menjalankan setiap respons k pada pengujian integrasi di repositori HumanEval. Jika ada respons dari k respons yang lolos uji integrasi, kami menghitung kasus uji tersebut berhasil; jika tidak, gagal. Kemudian kami ulangi proses untuk menghitung rasio kasus yang berhasil sebagai nama skor evaluasi akhir pass@k. Mengikuti praktik standar, kami menetapkan k sebagai 1 dalam evaluasi kami, untuk hanya menghasilkan satu respons per pertanyaan dan menguji apakah respons tersebut lolos uji integrasi.

Berikut ini adalah contoh kode untuk menggunakan repositori HumanEval. Anda dapat mengakses himpunan data dan menghasilkan respons tunggal menggunakan titik akhir SageMaker. Untuk lebih jelasnya lihat buku catatan di Repositori GitHub.

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

Tabel berikut menunjukkan peningkatan model Code LIama Python yang telah disempurnakan dibandingkan model yang tidak disempurnakan pada berbagai ukuran model. Untuk memastikan kebenarannya, kami juga menerapkan model Code LIama yang tidak disempurnakan di titik akhir SageMaker dan menjalankannya melalui evaluasi Human Eval. Itu lulus@1 nomor (baris pertama pada tabel berikut) cocok dengan nomor yang dilaporkan di Makalah penelitian Kode Llama. Parameter inferensi secara konsisten ditetapkan sebagai "parameters": {"max_new_tokens": 384, "temperature": 0.2}.

Seperti yang dapat kita lihat dari hasilnya, semua varian Code LIama Python yang telah disempurnakan menunjukkan peningkatan yang signifikan dibandingkan model yang tidak disempurnakan. Secara khusus, Code LIama Python 70B mengungguli model yang tidak disempurnakan sekitar 12%.

Sekarang Anda dapat mencoba menyempurnakan model Code LIama pada kumpulan data Anda sendiri.

Membersihkan

Jika Anda memutuskan tidak ingin lagi menjalankan titik akhir SageMaker, Anda dapat menghapusnya menggunakan AWS SDK untuk Python (Boto3), Antarmuka Baris Perintah AWS (AWS CLI), atau konsol SageMaker. Untuk informasi lebih lanjut, lihat Hapus Titik Akhir dan Sumber Daya. Selain itu, Anda bisa matikan sumber daya SageMaker Studio yang tidak diperlukan lagi.

Kesimpulan

Dalam postingan ini, kita membahas menyempurnakan model Code Llama 2 Meta menggunakan SageMaker JumpStart. Kami menunjukkan bahwa Anda dapat menggunakan konsol SageMaker JumpStart di SageMaker Studio atau SageMaker Python SDK untuk menyempurnakan dan menerapkan model ini. Kami juga membahas teknik penyesuaian, jenis instans, dan hyperparameter yang didukung. Selain itu, kami menguraikan rekomendasi untuk pelatihan yang dioptimalkan berdasarkan berbagai tes yang kami lakukan. Seperti yang dapat kita lihat dari hasil penyesuaian tiga model pada dua kumpulan data, penyesuaian meningkatkan peringkasan dibandingkan dengan model yang tidak disempurnakan. Sebagai langkah selanjutnya, Anda dapat mencoba menyempurnakan model ini pada kumpulan data Anda sendiri menggunakan kode yang disediakan di repositori GitHub untuk menguji dan membuat tolok ukur hasil untuk kasus penggunaan Anda.

Tentang Penulis

Dr Xin Huang adalah Ilmuwan Terapan Senior untuk Amazon SageMaker JumpStart dan algoritme bawaan Amazon SageMaker. Dia berfokus pada pengembangan algoritme pembelajaran mesin yang dapat diskalakan. Minat penelitiannya adalah di bidang pemrosesan bahasa alami, pembelajaran mendalam yang dapat dijelaskan pada data tabular, dan analisis kuat pengelompokan ruang-waktu non-parametrik. Dia telah menerbitkan banyak makalah di konferensi ACL, ICDM, KDD, dan Royal Statistical Society: Series A.

Vishaal Yalamanchali adalah Arsitek Solusi Startup yang bekerja dengan perusahaan AI generatif, robotika, dan kendaraan otonom tahap awal. Vishaal bekerja dengan pelanggannya untuk memberikan solusi ML mutakhir dan secara pribadi tertarik pada pembelajaran penguatan, evaluasi LLM, dan pembuatan kode. Sebelum bekerja di AWS, Vishaal adalah seorang sarjana di UCI, dengan fokus pada bioinformatika dan sistem cerdas.

Meenakshisundaram Thandavarayan bekerja untuk AWS sebagai Spesialis AI/ML. Dia memiliki hasrat untuk merancang, membuat, dan mempromosikan pengalaman data dan analitik yang berpusat pada manusia. Meena berfokus pada pengembangan sistem berkelanjutan yang memberikan keunggulan kompetitif dan terukur bagi pelanggan strategis AWS. Meena adalah seorang penghubung dan pemikir desain, dan berupaya mendorong bisnis ke cara kerja baru melalui inovasi, inkubasi, dan demokratisasi.

Dr Ashish Khetan adalah Ilmuwan Terapan Senior dengan algoritme bawaan Amazon SageMaker dan membantu mengembangkan algoritme pembelajaran mesin. Ia mendapatkan gelar PhD dari University of Illinois Urbana-Champaign. Dia adalah peneliti aktif dalam pembelajaran mesin dan inferensi statistik, dan telah menerbitkan banyak makalah di konferensi NeurIPS, ICML, ICLR, JMLR, ACL, dan EMNLP.

• Konten Bertenaga SEO & Distribusi PR. Dapatkan Amplifikasi Hari Ini.
• PlatoData.Jaringan Vertikal Generatif Ai. Berdayakan Diri Anda. Akses Di Sini.
• PlatoAiStream. Intelijen Web3. Pengetahuan Diperkuat. Akses Di Sini.
• PlatoESG. Karbon, teknologi bersih, energi, Lingkungan Hidup, Tenaga surya, Penanganan limbah. Akses Di Sini.
• PlatoHealth. Kecerdasan Uji Coba Biotek dan Klinis. Akses Di Sini.
• Sumber: https://aws.amazon.com/blogs/machine-learning/fine-tune-code-llama-on-amazon-sagemaker-jumpstart/