Fine-Tuning Llama 3 dan Penggunaannya Secara Lokal: Panduan Langkah demi Langkah

Memahami Llama 3

Meta telah merilis seri model bahasa besar (LLM) baru bernama Llama 3, kumpulan model text-to-text yang telah dipra-latih dan diinstruksi-tuning.

Llama 3 adalah model bahasa autoregresif yang menggunakan arsitektur transformer yang dioptimalkan. Baik model pra-latih maupun instruksi-tuning hadir dengan 8B dan 70B parameter dengan panjang konteks 8K token.

Llama 3 8B adalah LLM yang paling disukai di Hugging Face. Versi instruksi-tuning-nya lebih baik daripada Gemma 7B-It milik Google dan Mistral 7B Instruct pada berbagai metrik kinerja. Versi 70B yang diinstruksi-tuning telah melampaui Gemini Pro 1.5 dan Claude Sonnet pada sebagian besar metrik kinerja:

Sumber: Meta Llama 3

Meta melatih Llama 3 pada campuran baru data online yang tersedia untuk umum, dengan jumlah token lebih dari 15 triliun token. Model 8B memiliki batas pengetahuan Maret 2023, sementara model 70B memiliki batas Desember 2023. Model-model ini menggunakan Grouped-Query Attention (GQA), yang mengurangi bandwidth memori dan meningkatkan efisiensi.

Model Llama 3 dirilis di bawah lisensi komersial kustom. Untuk mengakses model, Anda perlu mengisi formulir dengan nama, afiliasi, dan email Anda serta menyetujui syarat dan ketentuan. Jika Anda menggunakan alamat email berbeda untuk platform yang berbeda seperti Kaggle dan Hugging Face, Anda mungkin perlu mengisi formulir beberapa kali.

Anda dapat mempelajari lebih lanjut tentang Llama 3 dari artikel ini: Apa itu Llama 3?.

1. Fine-Tuning Llama 3

Untuk tutorial ini, kita akan melakukan fine-tuning model Llama 3 8B-Chat menggunakan dataset ruslanmv/ai-medical-chatbot. Dataset ini berisi 250 ribu dialog antara pasien dan dokter. Kita akan menggunakan Kaggle Notebook untuk mengakses model ini dan GPU gratis.

Menyiapkan

Sebelum meluncurkan Kaggle Notebook, isi formulir unduhan Meta dengan alamat email Kaggle Anda, lalu buka halaman model Llama 3 di Kaggle dan setujui perjanjian. Proses persetujuan dapat memakan waktu satu hingga dua hari.

Sekarang mari lakukan langkah-langkah berikut:

1. Luncurkan Notebook baru di Kaggle, dan tambahkan model Llama 3 dengan mengeklik tombol + Add Input, memilih opsi Models, dan mengeklik tombol plus + di samping model Llama 3. Setelah itu, pilih framework, variasi, dan versi yang tepat, lalu tambahkan model.

2. Buka Session options dan pilih GPU P100 sebagai akselerator.

3. Hasilkan token Hugging Face dan Weights & Biases, lalu buat Kaggle Secrets. Anda dapat membuat dan mengaktifkan Kaggle Secrets dengan pergi ke Add-ons > Secrets > Add rahasia baru.

4. Inisialisasi sesi Kaggle dengan memasang semua paket Python yang diperlukan.

%%capture
%pip install -U transformers 
%pip install -U datasets 
%pip install -U accelerate 
%pip install -U peft 
%pip install -U trl 
%pip install -U bitsandbytes 
%pip install -U wandb

5. Impor pustaka Python yang diperlukan untuk memuat dataset, model, dan tokenizer serta melakukan fine-tuning.

from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    HfArgumentParser,
    TrainingArguments,
    pipeline,
    logging,
)
from peft import (
    LoraConfig,
    PeftModel,
    prepare_model_for_kbit_training,
    get_peft_model,
)
import os, torch, wandb
from datasets import load_dataset
from trl import SFTTrainer, setup_chat_format

6. Kita akan melacak proses pelatihan menggunakan Weights & Biases dan kemudian menyimpan model hasil fine-tuning di Hugging Face, sehingga kita harus masuk ke Hugging Face Hub dan Weights & Biases menggunakan kunci API.

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")

login(token = hf_token)

wb_token = user_secrets.get_secret("wandb")

wandb.login(key=wb_token)
run = wandb.init(
    project='Fine-tune Llama 3 8B on Medical Dataset', 
    job_type="training", 
    anonymous="allow"
)

7. Atur variabel model dasar, dataset, dan model baru. Kita akan memuat model dasar dari Kaggle dan dataset dari HugginFace Hub lalu menyimpan model baru.

base_model = "/kaggle/input/llama-3/transformers/8b-chat-hf/1"
dataset_name = "ruslanmv/ai-medical-chatbot"
new_model = "llama-3-8b-chat-doctor"

8. Atur tipe data dan implementasi attention.

torch_dtype = torch.float16
attn_implementation = "eager"

Memuat model dan tokenizer

Pada bagian ini, kita akan memuat model dari Kaggle. Namun, karena keterbatasan memori, kita tidak dapat memuat model penuh. Oleh karena itu, kita memuat model menggunakan presisi 4-bit.

Tujuan kita dalam proyek ini adalah mengurangi penggunaan memori dan mempercepat proses fine-tuning.

# QLoRA config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch_dtype,
    bnb_4bit_use_double_quant=True,
)

# Load model
model = AutoModelForCausalLM.from_pretrained(
    base_model,
    quantization_config=bnb_config,
    device_map="auto",
    attn_implementation=attn_implementation
)

Muat tokenizer lalu siapkan model dan tokenizer untuk tugas AI percakapan. Secara bawaan, ini menggunakan templat chatml dari OpenAI, yang akan mengonversi teks masukan menjadi format mirip obrolan.

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model)
model, tokenizer = setup_chat_format(model, tokenizer)

Menambahkan adapter ke layer

Melakukan fine-tuning pada seluruh model akan memakan banyak waktu, jadi untuk meningkatkan waktu pelatihan, kita akan menambahkan layer adapter dengan beberapa parameter, sehingga seluruh proses menjadi lebih cepat dan lebih hemat memori.

# LoRA config
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=['up_proj', 'down_proj', 'gate_proj', 'k_proj', 'q_proj', 'v_proj', 'o_proj']
)
model = get_peft_model(model, peft_config)

Memuat dataset

Untuk memuat dan memproses awal dataset kita, kita:

1. Memuat dataset ruslanmv/ai-medical-chatbot, mengacaknya, dan memilih hanya 1000 baris teratas. Ini akan secara signifikan mengurangi waktu pelatihan.

2. Memformat templat chat agar bersifat percakapan. Gabungkan pertanyaan pasien dan respons dokter ke dalam kolom "text".

3. Menampilkan sampel dari kolom teks (kolom “text” memiliki format mirip obrolan dengan token khusus).

#Importing the dataset
dataset = load_dataset(dataset_name, split="all")
dataset = dataset.shuffle(seed=65).select(range(1000)) # Only use 1000 samples for quick demo

def format_chat_template(row):
    row_json = [{"role": "user", "content": row["Patient"]},
               {"role": "assistant", "content": row["Doctor"]}]
    row["text"] = tokenizer.apply_chat_template(row_json, tokenize=False)
    return row

dataset = dataset.map(
    format_chat_template,
    num_proc=4,
)

dataset['text'][3]

4. Membagi dataset menjadi set pelatihan dan validasi.

dataset = dataset.train_test_split(test_size=0.1)

Menyusun dan melatih model

Kita menetapkan hiperparameter model agar dapat dijalankan di Kaggle. Anda dapat mempelajari setiap hiperparameter dengan membaca tutorial Fine-Tuning Llama 2.

Kita melakukan fine-tuning model selama satu epoch dan mencatat metrik menggunakan Weights and Biases.

training_arguments = TrainingArguments(
    output_dir=new_model,
    per_device_train_batch_size=1,
    per_device_eval_batch_size=1,
    gradient_accumulation_steps=2,
    optim="paged_adamw_32bit",
    num_train_epochs=1,
    evaluation_strategy="steps",
    eval_steps=0.2,
    logging_steps=1,
    warmup_steps=10,
    logging_strategy="steps",
    learning_rate=2e-4,
    fp16=False,
    bf16=False,
    group_by_length=True,
    report_to="wandb"
)

Sekarang kita akan menyiapkan pelatih supervised fine-tuning (SFT) dan memberikan dataset pelatihan dan evaluasi, konfigurasi LoRA, argumen pelatihan, tokenizer, dan model. Kita menetapkan max_seq_length ke 512 untuk menghindari melebihi memori GPU selama pelatihan.

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    peft_config=peft_config,
    max_seq_length=512,
    dataset_text_field="text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)

Kita akan memulai proses fine-tuning dengan menjalankan kode berikut.

trainer.train()

Baik loss pelatihan maupun validasi telah menurun. Pertimbangkan untuk melatih model selama tiga epoch pada dataset penuh untuk hasil yang lebih baik.

Evaluasi model

Saat Anda menyelesaikan sesi Weights & Biases, sesi tersebut akan menghasilkan riwayat dan ringkasan run.

wandb.finish()
model.config.use_cache = True

Metrik kinerja model juga disimpan di bawah nama proyek tertentu pada akun Weights & Biases Anda.

Mari evaluasi model pada contoh pertanyaan pasien untuk memeriksa apakah model telah di-fine-tune dengan baik.

Untuk menghasilkan respons, kita perlu mengonversi pesan ke format chat, melewatkannya melalui tokenizer, memasukkan hasilnya ke model, lalu mendekode token yang dihasilkan untuk menampilkan teks.

messages = [
    {
        "role": "user",
        "content": "Hello doctor, I have bad acne. How do I get rid of it?"
    }
]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, 
                                       add_generation_prompt=True)

inputs = tokenizer(prompt, return_tensors='pt', padding=True, 
                   truncation=True).to("cuda")

outputs = model.generate(**inputs, max_length=150, 
                         num_return_sequences=1)

text = tokenizer.decode(outputs[0], skip_special_tokens=True)

print(text.split("assistant")[1])

Ternyata kita bisa mendapatkan hasil rata-rata bahkan dengan satu epoch.

Menyimpan berkas model

Sekarang kita akan menyimpan adapter hasil fine-tuning dan mendorongnya ke Hugging Face Hub. API Hub akan otomatis membuat repositori dan menyimpan berkas adapter.

trainer.model.save_pretrained(new_model)
trainer.model.push_to_hub(new_model, use_temp_dir=False)

Seperti yang terlihat, berkas adapter yang kita simpan jauh lebih kecil daripada model dasar.

Pada akhirnya, kita akan menyimpan notebook dengan berkas adapter untuk digabungkan dengan model dasar di notebook baru.

Untuk menyimpan Kaggle Notebook, klik tombol Save Version di kanan atas, pilih tipe versi Quick Save, buka pengaturan lanjutan, pilih Always save output when creating a Quick Save, lalu tekan tombol Save.

Jika Anda mengalami masalah saat menjalankan kode, lihat Kaggle Notebook ini: Fine-tune Llama 3 8B on Medical Dataset.

Kita telah melakukan fine-tuning model menggunakan GPU. Anda juga dapat mempelajari fine-tuning LLM menggunakan TPU dengan mengikuti tutorial Fine-Tune dan Jalankan Inferensi pada Model Gemma Google Menggunakan TPU.

Jika Anda ingin mempelajari cara melakukan fine-tuning model lain, lihat Tutorial Mistral 7B: Panduan Langkah demi Langkah untuk Menggunakan dan Melakukan Fine-Tuning Mistral 7B.

2. Menggabungkan Llama 3

Untuk menggunakan model hasil fine-tuning secara lokal, kita harus terlebih dahulu menggabungkan adapter dengan model dasar dan kemudian menyimpan model penuh.

Menyiapkan

Mari lakukan langkah-langkah berikut:

1. Buat Kaggle Notebook baru dan pasang semua paket Python yang diperlukan. Pastikan Anda menggunakan GPU sebagai akselerator.

%%capture
%pip install -U bitsandbytes
%pip install -U transformers
%pip install -U accelerate
%pip install -U peft
%pip install -U trl

2. Masuk ke Hugging Face Hub menggunakan Kaggle Secrets. Ini akan membantu kita mengunggah model hasil fine-tuning secara penuh dengan mudah.

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()

hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

3. Tambahkan model Llama 3 8B Chat dan Kaggle Notebook hasil fine-tuning yang baru saja kita simpan. Kita dapat menambahkan Notebook di sesi saat ini seperti Anda menambahkan dataset dan model.

Menambahkan Notebook ke sesi Kaggle akan memungkinkan kita mengakses berkas output. Dalam kasus kita, ini adalah berkas adapter model.

4. Menetapkan variabel lokasi model dasar dan adapter.

base_model = "/kaggle/input/llama-3/transformers/8b-chat-hf/1"
new_model = "/kaggle/input/fine-tune-llama-3-8b-on-medical-dataset/llama-3-8b-chat-doctor/"

Menggabungkan model dasar dengan adapter

Pertama kita akan memuat tokenizer dan model dasar menggunakan pustaka transformers. Lalu, kita akan menyiapkan format chat menggunakan pustaka trl. Terakhir, kita akan memuat dan menggabungkan adapter ke model dasar menggunakan pustaka PEFT.

Fungsi merge_and_unload() akan membantu kita menggabungkan bobot adapter dengan model dasar dan menggunakannya sebagai model mandiri.

from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
from peft import PeftModel
import torch
from trl import setup_chat_format
# Reload tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(base_model)

base_model_reload = AutoModelForCausalLM.from_pretrained(
        base_model,
        return_dict=True,
        low_cpu_mem_usage=True,
        torch_dtype=torch.float16,
        device_map="auto",
        trust_remote_code=True,
)

base_model_reload, tokenizer = setup_chat_format(base_model_reload, tokenizer)

# Merge adapter with base model
model = PeftModel.from_pretrained(base_model_reload, new_model)

model = model.merge_and_unload()

Inferensi Model

Untuk memverifikasi apakah model kita telah digabungkan dengan benar, kita akan melakukan inferensi sederhana menggunakan pipeline dari pustaka transformers. Kita akan mengonversi pesan menggunakan templat chat lalu memberikan prompt ke pipeline. Pipeline diinisialisasi menggunakan model, tokenizer, dan jenis tugas.

Sebagai catatan, Anda dapat mengatur device_map ke "auto" jika ingin menggunakan beberapa GPU.

messages = [{"role": "user", "content": "Hello doctor, I have bad acne. How do I get rid of it?"}]

prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.float16,
    device_map="auto",
)

outputs = pipe(prompt, max_new_tokens=120, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)
print(outputs[0]["generated_text"])

Model hasil fine-tuning kita bekerja sebagaimana mestinya setelah digabungkan.

Menyimpan dan mendorong model yang telah digabungkan

Sekarang kita akan menyimpan tokenizer dan model menggunakan fungsi save_pretrained().

model.save_pretrained("llama-3-8b-chat-doctor")
tokenizer.save_pretrained("llama-3-8b-chat-doctor")

Berkas model disimpan dalam format safetensors, dan total ukuran model sekitar 16 GB.

Kita dapat mendorong semua berkas ke Hugging Face Hub menggunakan fungsi push_to_hub().

model.push_to_hub("llama-3-8b-chat-doctor", use_temp_dir=False)
tokenizer.push_to_hub("llama-3-8b-chat-doctor", use_temp_dir=False)

Pada akhirnya, kita dapat menyimpan Kaggle Notebook seperti sebelumnya.

Menggunakan Kaggle Notebook Fine Tuned Adapter to fully model akan membantu Anda menyelesaikan masalah apa pun terkait menjalankan kode sendiri.

3. Mengonversi Model ke Llama.cpp GGUF

Kita tidak dapat menggunakan berkas safetensors secara lokal karena sebagian besar chatbot AI lokal tidak mendukungnya. Sebagai gantinya, kita akan mengonversinya ke format berkas GGUF llama.cpp.

Menyiapkan

Mulai sesi Kaggle Notebook baru dan tambahkan Notebook Fine Tuned Adapter to the full model.

Klon repositori llama.cpp dan pasang kerangka kerja llama.cpp menggunakan perintah make seperti di bawah ini.

Sebagai catatan, perintah di bawah hanya berfungsi untuk Kaggle Notebook. Anda mungkin harus mengubah beberapa hal untuk menjalankannya di platform lain atau secara lokal.

%cd /kaggle/working
!git clone --depth=1 https://github.com/ggerganov/llama.cpp.git
%cd /kaggle/working/llama.cpp
!sed -i 's|MK_LDFLAGS   += -lcuda|MK_LDFLAGS   += -L/usr/local/nvidia/lib64 -lcuda|' Makefile
!LLAMA_CUDA=1 conda run -n base make -j > /dev/null

Mengonversi Safetensors ke format model GGUF

Jalankan perintah berikut di sel Kaggle Notebook untuk mengonversi model ke format GGUF.

File convert-hf-to-gguf.py memerlukan direktori model masukan, direktori berkas keluaran, dan tipe keluaran.

!python convert-hf-to-gguf.py /kaggle/input/fine-tuned-adapter-to-full-model/llama-3-8b-chat-doctor/ \
    --outfile /kaggle/working/llama-3-8b-chat-doctor.gguf \
    --outtype f16

Dalam beberapa menit, model dikonversi dan disimpan secara lokal. Kita kemudian dapat menyimpan notebook untuk menyimpan berkas.

Jika Anda mengalami masalah saat menjalankan kode di atas, lihat Kaggle Notebook HF LLM to GGUF .

4. Mengkuantisasi model GGUF

Laptop biasa tidak memiliki cukup RAM dan memori GPU untuk memuat seluruh model, jadi kita harus mengkuantisasi model GGUF, mengurangi model 16 GB menjadi sekitar 4–5 GB.

Menyiapkan

Mulai sesi Kaggle Notebook baru dan tambahkan Notebook HF LLM to GGUF.

Lalu, pasang llama.cpp dengan menjalankan perintah berikut di sel Kaggle Notebook.

%cd /kaggle/working
!git clone --depth=1 https://github.com/ggerganov/llama.cpp.git
%cd /kaggle/working/llama.cpp
!sed -i 's|MK_LDFLAGS   += -lcuda|MK_LDFLAGS   += -L/usr/local/nvidia/lib64 -lcuda|' Makefile
!LLAMA_CUDA=1 conda run -n base make -j > /dev/null

Kuantisasi

Skrip quantize memerlukan direktori model GGUF, direktori berkas keluaran, dan metode kuantisasi. Kita mengonversi model menggunakan metode Q4_K_M.

%cd /kaggle/working/

!./llama.cpp/llama-quantize /kaggle/input/hf-llm-to-gguf/llama-3-8b-chat-doctor.gguf llama-3-8b-chat-doctor-Q4_K_M.gguf Q4_K_M

Ukuran model kita berkurang signifikan dari 15317,05 MB menjadi 4685,32 MB.

Mendorong berkas model ke Hugging Face

Untuk mendorong satu berkas ke Hugging Face Hub, kita akan:

1. Masuk ke Hugging Face Hub menggunakan kunci API.
2. Membuat objek API.
3. Mengunggah berkas dengan memberikan path lokal, path repo, ID repo, dan tipe repo.

from huggingface_hub import login
from kaggle_secrets import UserSecretsClient
from huggingface_hub import HfApi
user_secrets = UserSecretsClient()
hf_token = user_secrets.get_secret("HUGGINGFACE_TOKEN")
login(token = hf_token)

api = HfApi()
api.upload_file(
    path_or_fileobj="/kaggle/working/llama-3-8b-chat-doctor-Q4_K_M.gguf",
    path_in_repo="llama-3-8b-chat-doctor-Q4_K_M.gguf",
    repo_id="kingabzpro/llama-3-8b-chat-doctor",
    repo_type="model",
)

Model kita berhasil didorong ke server jarak jauh, seperti terlihat di bawah ini.

Jika Anda masih mengalami masalah, silakan lihat Kaggle Notebook GGUF to Quantize, yang berisi semua kode dan keluarannya.

Jika Anda mencari cara yang lebih sederhana untuk mengonversi dan mengkuantisasi model Anda, kunjungi Hugging Face Space ini dan berikan Hub Model Id.

5. Menggunakan Model Hasil Fine-Tuning Secara Lokal

Untuk menggunakan model GGUF secara lokal, Anda harus mengunduhnya dan mengimpornya ke aplikasi Jan.

Mengunduh model dari Hugging Face

Untuk mengunduh model, kita perlu:

1. Buka repositori kita di Hugging Face.

2. Klik tab Files.

3. Klik berkas model yang telah dikuantisasi dengan ekstensi GGUF.

4. Klik tombol download.

Mengunduh berkas secara lokal akan memakan waktu beberapa menit.

Memasang aplikasi Jan

Unduh dan pasang aplikasi Jan dari Jan AI.

Beginilah tampilannya saat Anda meluncurkan aplikasi jendela Jan:

Memuat model hasil fine-tuning di Jan

Untuk menambahkan model ke aplikasi Jan, kita harus mengimpor berkas GGUF yang telah dikuantisasi.

Kita perlu masuk ke menu Hub dan klik Import Model, seperti ditunjukkan di bawah. Berikan lokasi berkas yang baru saja diunduh, dan selesai.

Kita masuk ke menu Thread dan memilih model hasil fine-tuning.

Menggunakan model hasil fine-tuning di Jan

Sebelum menggunakan model, kita perlu menyesuaikannya agar respons ditampilkan dengan benar. Pertama, kita memodifikasi templat Prompt di bagian Model Parameters.

<|im_start|>system
{system_message}<|im_end|>
<|im_start|>user
{prompt}<|im_end|>
<|im_start|>assistant

Kita menambahkan token Stop dan mengubah jumlah token maksimum menjadi 512 pada parameter inferensi.

<endofstring>, Best, Regards, Thanks,-->

Kita mulai menulis kueri, dan dokter akan merespons sesuai.

Model hasil fine-tuning kita bekerja dengan sangat baik secara lokal.

Model ini berfungsi dengan GPT4ALL, Llama.cpp, Ollama, dan banyak aplikasi AI lokal lainnya. Untuk mempelajari cara menggunakan masing-masing, lihat tutorial tentang cara menjalankan LLM secara lokal.

Kesimpulan

Melakukan fine-tuning model Llama 3 pada dataset kustom dan menggunakannya secara lokal telah membuka banyak kemungkinan untuk membangun aplikasi inovatif. Potensi kasus penggunaannya berkisar dari solusi AI percakapan privat dan kustom hingga chatbot spesifik domain, klasifikasi teks, penerjemahan bahasa, sistem tanya jawab, rekomendasi yang dipersonalisasi, bahkan aplikasi otomasi kesehatan dan pemasaran.

Dengan kerangka kerja Ollama dan Langchain, membangun aplikasi AI Anda sendiri kini lebih mudah dari sebelumnya, hanya memerlukan beberapa baris kode. Untuk melakukannya, ikuti tutorial LlamaIndex: Kerangka Data untuk Aplikasi berbasis Large Language Models (LLMs).

Dalam tutorial ini, kita mempelajari cara melakukan fine-tuning Llama 3 8B Chat pada dataset medis. Kita melalui proses menggabungkan adapter dengan model dasar, mengonversinya ke format GGUF, dan mengkuantisasinya untuk penggunaan lokal pada aplikasi chatbot Jan.

Jika Anda ingin belajar lebih jauh, lihat jalur keterampilan empat kursus tentang Developing Large Language Models.