Kod LLM’leri ile Kod Tamamlama
Kod amaçları için ön eğitilmiş büyük dil modellerini kod tamamlama amacıyla eğitmeye dair bulduğum kaynakları derledim.
Kod Tamamlama / Kod Otomatik Tamamlama Nedir?
Kod tamamlama, aynı zamanda otomatik tamamlama olarak da bilinir, birçok entegre geliştirme ortamı (IDE) ve metin editörü tarafından sunulan bir özelliktir. Bu, yazılım dilinin sözdizimi ve anlambilgisi hakkında kapsamlı bir anlayışa dayanarak, yazarken kod parçacıkları öneren ve tamamlayan bir programlama aracıdır. Kod tamamlama tarafından sunulan öneriler bağlamsal olarak alakalıdır, yani daha önce yazdığınız kod ve projenizin mevcut bağlamına dayanır. Bu özellik, zaman kazandırabilir, hataları azaltabilir ve genel kodlama verimliliğinizi artırabilir. [1]
Kod Tamamlamanın Gerçek Değeri
Ancak kod tamamlama, size sadece birkaç tuş vuruşundan tasarruf ettirmekten daha fazlasını yapar. Ayrıca, bir programlama dilinin söz dizimi ve incelikleri arasında size rehberlik ederek anında bir referans ve kılavuz görevi görür. Bu özellik, özellikle yeni bir dil öğrendiğinizde veya büyük ve karmaşık bir kod tabanıyla çalıştığınızda faydalı olabilir. Size doğru söz dizimini göstererek ve uygun kod öğelerini önererek, kod tamamlama öğrenme eğrinizi önemli ölçüde hızlandırabilir ve kodlama doğruluğunuzu iyileştirebilir. [1]
Kod Tamamlamanın Dezavantajları
LLM’ler kodlama görevleri için inanılmaz derecede yararlı olsa da, aynı zamanda yeni riskler de getirirler. LLM’ler yeterince yüksek kalitede olmayan, güvenlik açıkları içeren veya kuruluşun veya belirli projenin gereksinimlerini karşılamayan kod üretebilir. Ayrıca oldukça pahalıdırlar ve model boyutuna bağlı olarak oldukça akıllı ve yavaş olabilirler. Ayrıca ‘halüsinasyonlara’ eğilimlidirler, yani geçerli görünen ancak hatalar veya yanlışlıklar içeren kod üretebilirler. Bu, kalite veya güvenlik kusurlarını belirleyebilen ve düzeltebilen bilgili geliştiriciler tarafından LLM tabanlı kod tamamlamalarının çıktısını dikkatlice incelemeyi önemli hale getirir. [1]
Kod Tamamlama Modellerinin İnce Ayarı
Yeni teknolojileri öğretmek için kendi özel reponuzu ince ayarlamanız veya bir modelin yeteneklerini geliştirmeniz gerekir. İnce ayarlama eskiden veri, zaman ve hesaplama maliyeti açısından çok pahalıydı. LoRa ve QloRa gibi yeni tekniklerle çok daha hızlılar. [2]
LoRA Nedir?
Bir modelin tüm ağırlıklarını ince ayarlamak yani full finetuning gerekli değildir. Parametre Verimli İnce Ayar (PEFT) yöntemleri bulunmaktadır, her zaman kullandığımız yönteme LoRA denir [https://arxiv.org/abs/2106.09685]. Avantajları: Daha hızlı eğitim, eğitmek için çok daha az bellek gereklidir, orijinal modelin hızını korunur ve çıkarım sırasında LoRA’ları çok hızlı bir şekilde değiştirmek mümkündür. [2]
Bir modelin tüm ağırlıklarını çözmeye kıyasla, ‘LoRA’ aynı zamanda ‘felaket derece unutma’ (catastrophic forgetting) yani, yeni bir şey öğrenirken daha önce öğrenilen becerilerin unutulması olgusuna daha az eğilimlidir. Bunun nedenini LoRA’nın matematiğinden anlamak kolaydır: LoRA, ağırlıklara küçük bir ekleme yapar ve bu eklemeyi daha da küçülterek temel modelin orijinal ağırlıklarına ve becerilerine geri dönmek mümkündür. Bu nedenle LoRA eğitimi sırasında hiçbir şey kaybolmaz: Süreç sadece yeni bilgiyi (daha yüksek LoRA ağırlıkları) ve temel modelin yeteneklerini korumayı (daha düşük LoRA ağırlıkları) dengelemelidir. [2]
3 milyar parametreli bir model için, iyi bir donanım hızlandırmasıyla (hardware acceleration) çalıştırılması mümkün olan en büyük LoRA, 150 milyon parametrelidir. Bu oldukça fazladır; birkaç yıl önce 150 milyon parametreli modeller oldukça popülerdi! Ancak pratikte, müşterilerimizden gelen geri bildirimler de dahil olmak üzere, bir LoRA’nın ne kadar bilgi tutabileceği konusunda hâlâ sınırlamalar görüyoruz. [2]
İşte, muhtemelen işe yarayacak bir ince ayar ile işe yaramayacak bir ince ayar arasındaki farkı anlamanıza yardımcı olabilecek bazı örnekler: [2]
- C++ dilinde 6 bin dosya => iyi çalışır, tipik bir kullanım durumu.
- C dilinde 60 bin dosya => çok iyi değil, gözle görülür iyileşme az.
- Python dilinde 600 dosya => çok iyi çalışır.
- Python dilinde 600 dosya + Rust dilinde 100 dosya => iyi çalışır.
- Python dilinde 600 dosya + Rust dilinde 100 dosya + C++ dilinde 500 dosya => hâlâ çalışır, ancak zaman zaman işlev isimlerini hatırlamakta zorlanmaya başlar.
Bu deneyimden, LoRA’nın tek bir dil veya konu üzerinde yoğunlaşmayı sevdiği görülmektedir. Farklı dillerde yazılmış birden fazla ilgisiz yazılım projesini beslemek muhtemelen kötü bir fikirdir. [2]
Bu teknolojiler oldukça yenidir ve bu nedenle tek bir çözüm yoktur; değerlerle deneme yapmanız gerekir. Ve hatta bundan önce, genellikle her model için bir ince ayar betiğine ihtiyacınız olur çünkü hepsi birbirinden farklıdır. Bu teknolojiler yeni olduğundan, eğitim için kullandığınız kütüphanelerde genellikle sürüm sorunlarıyla başa çıkmanız gerekir. Eğer bir yapay zeka uzmanı değilseniz ve sadece en uygun maliyetli çözümü bulmak istiyorsanız, neredeyse tüm modelleri destekleyen bir tam yığın ince ayar çerçevesi olan Llama-Factory’yi kullanabilirsiniz: [https://github.com/hiyouga/LLaMA-Factory]
Kod Tamamlama için LLM’i İnce Ayarlama
Diğer meraklılar için, işte kod tamamlama amacıyla kodlarınızı kullanarak LLM’inizi ince ayar yapmanıza yardımcı olacak bir script:
Vaka çalışmamızda, eğitim verisi olarak GitHub’daki Hugging Face’in en popüler on halka açık reposunu seçtik. Görseller, ses dosyaları ve slaytlar gibi kod dışı öğeleri filtreleyerek yalnızca Jupyter defterlerindeki kod segmentlerini tuttuk. Bu özenle oluşturulmuş veri kümesi, repo kimlikleri, dosya yolları ve kod içeriklerini içermektedir ve Hugging Face Hub’da smangrul/hf-stack-v1 adresinden erişilebilir: [https://huggingface.co/datasets/smangrul/hf-stack-v1]. [3]
GitHub’ı kazıma (web scraping) işlemi burada açıklanmıştır: [https://huggingface.co/blog/personal-copilot]
İnce ayar çalışmalarımızı, bigcode/starcoder2–3b [https://huggingface.co/bigcode/starcoder2-3b] modeli etrafında odaklayacağız. Bu model, 3 milyar parametreye sahiptir ve The Stack v2 veri kümesinden, isteğe bağlı olarak çıkarılan veriler hariç, 17 programlama dilinde eğitilmiştir. Grup Sorgu Dikkati (Grouped Query Attention) yöntemini kullanır ve 16.384 token’lık geniş bir bağlam penceresine ek olarak, 4.096 token’lık bir kaydırma penceresi (sliding window) ile dikkat mekanizmasını destekler. Model, 3 trilyondan fazla token üzerinde Fill-in-the-Middle (Ortayı Doldurma) eğitim hedefiyle geliştirilmiştir. Bu modele erişim kısıtlıdır, bu nedenle Hugging Face sayfasını ziyaret ederek ve hesabınıza giriş yaparak izin aldığınızdan emin olun. [3]
Bölüm 1: Veri Hazırlama
from huggingface_hub import notebook_login
notebook_login()
!pip install -q git+https://github.com/huggingface/transformers.git
!pip install -q datasets peft bitsandbytes flash-attn fire gradio
MODEL="bigcode/starcoder2-3b" # Hugging Face Hub'da model kontrol noktası
DATASET="smangrul/hf-stack-v1" # Hugging Face Hub'daki veri kümesi
DATA_COLUMN="content" # Kod içeriğini içeren sütun adı
SEQ_LENGTH=2048 # Sequence length
# Training arguments
MAX_STEPS=2000 # max_steps
BATCH_SIZE=8 # batch_size
GR_ACC_STEPS=1 # gradient_accumulation_steps
LR=5e-4 # learning_rate
LR_SCHEDULER_TYPE="cosine" # lr_scheduler_type
WEIGHT_DECAY=0.01 # weight_decay
NUM_WARMUP_STEPS=30 # num_warmup_steps
EVAL_FREQ=100 # eval_freq
SAVE_FREQ=100 # save_freq
LOG_FREQ=25 # log_freq
OUTPUT_DIR="peft-starcoder2-3b-lora-a100" # output_dir
BF16=True # bf16
FP16=False # no_fp16
# FIM trasformations arguments
FIM_RATE=0.5 # fim_rate
FIM_SPM_RATE=0.5 # fim_spm_rate
# LORA
LORA_R=8 # lora_r
LORA_ALPHA=32 # lora_alpha
LORA_DROPOUT=0.0 # lora_dropout
LORA_TARGET_MODULES="c_proj,c_attn,q_attn,c_fc,c_proj" # lora_target_modules
# bitsandbytes config
USE_NESTED_QUANT=True # use_nested_quant
BNB_4BIT_COMPUTE_DTYPE="bfloat16" # bnb_4bit_compute_dtype
SEED=315
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
Trainer,
TrainingArguments,
logging,
set_seed,
BitsAndBytesConfig,
)
set_seed(SEED)
# PREPARE DATA
"""
Veri kümesinin oldukça büyük olması muhtemeldir, streamig modunu etkinleştirdiğinizden emin olun.
Streaming (akış), tüm veri kümesini bir kerede indirmek yerine, veri kümesi üzerinde yineleme yaparken verileri kademeli olarak yüklememize olanak tanır.
İlk 4000 örneği doğrulama kümesi olarak ayıracağız ve diğer her şey eğitim verisi olacak.
"""
from datasets import load_dataset
import torch
from tqdm import tqdm
dataset = load_dataset(
DATASET,
data_dir="data",
split="train",
streaming=True,
)
valid_data = dataset.take(4000)
train_data = dataset.skip(4000)
train_data = train_data.shuffle(buffer_size=5000, seed=SEED)
"""
Bu adımda, veri kümesi hala keyfi uzunlukta kod içeren ham veriler içeriyor.
Eğitim için sabit uzunlukta girdilere ihtiyacımız var.
Bir metin dosyası akışından sabit uzunlukta belirteç parçaları döndürecek bir Yinelebilir veri kümesi oluşturalım.
Öncelikle, veri kümesindeki token başına ortalama karakter sayısını tahmin edelim; bu, daha sonra metin tamponundaki token sayısını tahmin etmemize yardımcı olacaktır.
Varsayılan olarak, veri kümesinden yalnızca 400 örnek (nb_examples) alacağız.
Tüm veri kümesinin yalnızca bir alt kümesini kullanmak, genel karakter-token oranının makul bir tahminini sağlarken hesaplama maliyetini azaltacaktır.
"""
tokenizer = AutoTokenizer.from_pretrained(MODEL, trust_remote_code=True)
def chars_token_ratio(dataset, tokenizer, data_column, nb_examples=400):
"""
Veri kümesindeki token başına ortalama karakter sayısını tahmin edin.
"""
total_characters, total_tokens = 0, 0
for _, example in tqdm(zip(range(nb_examples), iter(dataset)), total=nb_examples):
total_characters += len(example[data_column])
total_tokens += len(tokenizer(example[data_column]).tokens())
return total_characters / total_tokens
chars_per_token = chars_token_ratio(train_data, tokenizer, DATA_COLUMN)
print(f"The character to token ratio of the dataset is: {chars_per_token:.2f}")
"""
Karakter-token oranı, metin tokenizasyonunun kalitesinin bir göstergesi olarak da kullanılabilir.
Örneğin, 1.0'lık bir karakter-token oranı, her karakterin bir token ile temsil edildiği anlamına gelir ki bu da çok anlamlı değildir.
Bu, zayıf tokenizasyona işaret eder.
Standart İngilizce metinde, bir token tipik olarak yaklaşık dört karaktere eşdeğerdir, yani karakter-token oranı yaklaşık 4.0'dır.
Kod veri kümesinde daha düşük bir oran bekleyebiliriz, ancak genel olarak konuşursak, 2.0 ile 3.5 arasındaki bir sayı yeterince iyi kabul edilebilir.
"""
Bölüm 2: İnce Ayarlama (Finetuning)
Veriler hazır olduğuna göre, modeli yükleme zamanı! Modelin nicemlenmiş (quantized) versiyonunu yükleyeceğiz. Bu, bellekte daha az yer kullanmamızı sağlayacak çünkü nicemleme veriyi daha az bit ile temsil eder. Modeli nicemlemek için bitsandbytes kütüphanesini kullanacağız, çünkü transformers ile iyi bir entegrasyona sahiptir. Tek yapmamız gereken bir bitsandbytes konfigürasyonu tanımlamak ve modeli yüklerken bunu kullanmak.
4 bit kuantizasyonun farklı varyantları vardır, ancak genellikle daha iyi performans için NF4 kuantizasyonunu kullanmanızı öneririz (bnb_4bit_quant_type=”nf4"). bnb_4bit_use_double_quant seçeneği, her bir parametre başına 0.4 bit daha tasarruf etmek için ilk nicemlemeden sonra ikinci bir nicemleme ekler. Nicemleme hakkında daha fazla bilgi edinmek için şu blog yazısına göz atabilirsiniz: “Making LLMs even more accessible with bitsandbytes, 4-bit quantization and QLoRA”: [https://huggingface.co/blog/4bit-transformers-bitsandbytes]
Bir kez tanımlandıktan sonra, konfigürasyonu from_pretrained metoduna geçirerek nicemlenmiş model versiyonunu yükleyebilirsiniz. Nicemlenmiş model hazır olduğunda, bir LoRA yapılandırması oluşturabiliriz. LoRA, eğitilebilir parametre sayısını önemli ölçüde azaltarak ince ayar yapmayı daha verimli hale getirir. LoRA tekniğini kullanarak bir modeli eğitmek için temel modeli bir PeftModel olarak sarmalamamız gerekir. Bu, bir LoraConfig ile LoRA yapılandırması tanımlamayı ve orijinal modeli get_peft_model() ile bu yapılandırmayı kullanarak sarmayı içerir. LoRA ve parametreleri hakkında daha fazla bilgi edinmek için PEFT dokümantasyonuna bakabilirsiniz: [https://huggingface.co/docs/peft/conceptual_guides/lora].
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from peft.tuners.lora import LoraLayer
load_in_8bit = False
# 4-bit quantization
compute_dtype = getattr(torch, BNB_4BIT_COMPUTE_DTYPE)
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=compute_dtype,
bnb_4bit_use_double_quant=USE_NESTED_QUANT,
)
device_map = {"": 0}
model = AutoModelForCausalLM.from_pretrained(
MODEL,
load_in_8bit=load_in_8bit,
quantization_config=bnb_config,
device_map=device_map,
use_cache=False, # Gradyan checkpoint kullanacağız
trust_remote_code=True,
attn_implementation="flash_attention_2",
)
# Eğitim için niceliksel bir model kullanırken, eğitim için niceliksel modeli ön işleme tabi tutmak amacıyla prepare_model_for_kbit_training() fonksiyonunu çağırmanız gerekir.
model = prepare_model_for_kbit_training(model)
# Lora'yı kurun
peft_config = LoraConfig(
lora_alpha=LORA_ALPHA,
lora_dropout=LORA_DROPOUT,
r=LORA_R,
bias="none",
task_type="CAUSAL_LM",
target_modules=LORA_TARGET_MODULES.split(","),
)
model = get_peft_model(model, peft_config)
model.print_trainable_parameters()
# trainable params: 7,372,800 || all params: 3,037,744,128 || trainable%: 0.24270641928140696Gördüğünüz gibi, LoRA tekniğini uygulayarak artık parametrelerin %1'inden daha azını eğitmemiz gerekecek. [3]
Bölüm 3: Model Eğitimi
Artık verileri hazırladığımıza ve modeli optimize ettiğimize göre, eğitimi başlatmak için her şeyi bir araya getirmeye hazırız. Bir Trainer örneği oluşturmak için eğitim yapılandırmasını tanımlamanız gerekir. En önemlisi, eğitimi yapılandırmak için tüm öznitelikleri içeren bir sınıf olan TrainingArguments’tır. [3]
train_data.start_iteration = 0
training_args = TrainingArguments(
output_dir=f"jdeklerk10/{OUTPUT_DIR}",
dataloader_drop_last=True,
evaluation_strategy="steps",
save_strategy="steps",
max_steps=MAX_STEPS,
eval_steps=EVAL_FREQ,
save_steps=SAVE_FREQ,
logging_steps=LOG_FREQ,
per_device_train_batch_size=BATCH_SIZE,
per_device_eval_batch_size=BATCH_SIZE,
learning_rate=LR,
lr_scheduler_type=LR_SCHEDULER_TYPE,
warmup_steps=NUM_WARMUP_STEPS,
gradient_accumulation_steps=GR_ACC_STEPS,
gradient_checkpointing=True,
fp16=FP16,
bf16=BF16,
weight_decay=WEIGHT_DECAY,
push_to_hub=True,
include_tokens_per_second=True,
use_reentrant=True
)
trainer = Trainer(
model=model, args=training_args, train_dataset=train_dataset, eval_dataset=eval_dataset
)
print("Training...")
trainer.train()
# İnce ayarlı modeli ekibinizle paylaşmak üzere Hub reponuza gönderin.
from google.colab import runtime
runtime.unassign()
trainer.push_to_hub()
Bölüm 4: Çıkarım
Model Hub’a yüklendikten sonra, çıkarım için kullanabiliriz. Bunu yapmak için önce orijinal temel modeli ve onun belirteçleyicisini başlatırız. Sonra, ince ayarlı ağırlıkları temel modelle birleştirmemiz gerekir. [3]
from peft import PeftModel
import torch
# önce orijinal modeli yükleyin
tokenizer = AutoTokenizer.from_pretrained(MODEL, trust_remote_code=True)
base_model = AutoModelForCausalLM.from_pretrained(
MODEL,
quantization_config=None,
device_map=None,
trust_remote_code=True,
torch_dtype=torch.bfloat16,
).cuda()
# ince ayarlı ağırlıkları temel modelle birleştirin
peft_model_id = f"jdeklerk10/{OUTPUT_DIR}"
model = PeftModel.from_pretrained(base_model, peft_model_id)
model.merge_and_unload()
def get_code_completion(prefix, suffix):
text = prompt = f"""{prefix}{suffix}"""
model.eval()
outputs = model.generate(
input_ids=tokenizer(text, return_tensors="pt").input_ids.cuda(),
max_new_tokens=128,
temperature=0.2,
top_k=50,
top_p=0.95,
do_sample=True,
repetition_penalty=1.0,
)
return tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]
prefix = """from peft import LoraConfig, TaskType, get_peft_model
from transformers import AutoModelForCausalLM
peft_config = LoraConfig(
"""
suffix =""""""
print(get_code_completion(prefix, suffix))
"""
from peft import LoraConfig, TaskType, get_peft_model
from transformers import AutoModelForCausalLM
peft_config = LoraConfig(
r=1024,
hidden_size=512,
cross_attention_dim=512,
layers_per_block=2,
num_attention_heads=4,
num_hidden_layers=5,
norm_num_groups=32,
norm_type="layer_norm",
scale_attn_bias=True,
scale_embedding=True,
upcast_attention=True,
)
model = AutoModelForCausalLM.from_pretrained("hf-internal-testing/tiny-stable-diffusion-
"""
prefix = """from peft import LoraConfig, TaskType, get_peft_model
from transformers import AutoModelForCausalLM
peft_config = LoraConfig(
"""
suffix =""""""
print(get_code_completion(prefix, suffix))
"""
from peft import LoraConfig, TaskType, get_peft_model
from transformers import AutoModelForCausalLM
peft_config = LoraConfig(
model_name_or_path="facebook/wav2vec2-base-960h",
num_labels=1,
num_features=1,
num_hidden_layers=1,
num_attention_heads=1,
num_hidden_layers_per_attention_head=1,
num_attention_heads_per_hidden_layer=1,
hidden_size=1024,
hidden_dropout_prob=0.1,
hidden_act="gelu",
hidden_act_dropout_prob=0.1,
hidden
"""Peki ya Tam İnce Ayar ve Diğer Yaklaşımlar?
Diğer ince ayar tekniklerini karşılaştıralım. Llama gibi dil modelleri 10 GB’tan veya hatta 100 GB’tan daha büyüktür. Bu kadar büyük modellerin ince ayarını yapmak, önemli ölçüde yüksek CUDA belleğine sahip örnekler gerektirir. Ayrıca, bu modellerin eğitimi, modelin boyutu nedeniyle çok yavaş olabilir. Bu nedenle, verimli ince ayar için aşağıdaki optimizasyonları kullanırız [4]:
Düşük Dereceli Adaptasyon (LoRA: Low Rank Adaptation)
Bu, büyük modellerin verimli ince ayarı için kullanılan bir tür parametre-verimli ince ayar (PEFT) yöntemidir. Bu yöntemle, tüm modeli dondurur ve yalnızca modele küçük bir ayarlanabilir parametre veya katman grubu eklenir. Örneğin, Llama 3 8B modelinin 8 milyar parametresinin tamamını eğitmek yerine, parametrelerin %1’inden daha azını ince ayarlayabilirsiniz. Bu yöntem, yalnızca %1’lik bir parametre seti için gradyanlar, optimize edici durumları ve diğer eğitimle ilgili bilgileri saklamanız gerektiğinden bellek gereksinimlerini önemli ölçüde azaltır. Ayrıca, eğitim süresini ve maliyetini de düşürür. Bu yöntemle ilgili daha fazla bilgi için şu makaleye göz atabilirsiniz: LoRA: Büyük Dil Modellerinin Düşük Dereceli Adaptasyonu: [https://arxiv.org/pdf/2106.09685.pdf]
Int8 Nicemleme
LoRA gibi optimizasyonlara rağmen, Llama 70B gibi modeller hala eğitmek için çok büyüktür. Eğitim sırasında bellek kullanımını azaltmak için, Int8 nicemlemeyi kullanabilirsiniz. Nicemleme, genellikle float veri tiplerinin hassasiyetini azaltır. Bu, model ağırlıklarını saklamak için gereken belleği azaltırken bilgi kaybı nedeniyle performansta düşüşe neden olabilir. Ancak Int8 nicemleme, yalnızca dörtte bir hassasiyet kullanır ve bitleri rastgele bırakmak yerine bir türden diğerine yuvarlama yaptığı için performans düşüşüne yol açmaz. Int8 nicemlemeyle ilgili daha fazla bilgi için şu makaleye bakabilirsiniz: LLM.int8(): Büyük Ölçekli Dönüştürücüler için 8-bit Matris Çarpımı: [https://arxiv.org/abs/2208.07339].
Tam Parçalanmış Veri Paralel (FSDP)
Bu, modelin parametrelerini veri paralel çalışanlar arasında parçalayan ve isteğe bağlı olarak eğitimin bir kısmını CPU’lara aktaran bir veri paralel eğitim algoritmasıdır. Parametreler farklı GPU’lara dağıtılmış olsa da, her mikro işlem kümesinin hesaplaması yerel GPU çalışanında gerçekleşir. FSDP, parametreleri daha eşit şekilde böler ve eğitim sırasında iletişim ve hesaplama çakışmasını optimize ederek performansı artırır.
Bu Bölümde Ele Alınan Modeller
Aşağıdaki modellerin ince ayarı nasıl yapılır gösterilecektir:
- bigcode/starcoder (15.5B parametre)
- bigcode/starcoderbase-1b (1B parametre)
- Deci/DeciCoder-1b (1B parametre)
Bütün deneylerde tek bir A100 40GB Colab Notebook kullanılarak 🤗 PEFT (Parametre Verimli İnce Ayar) yöntemi uygulanacaktır. Ayrıca, 🤗 Accelerate’in FSDP entegrasyonu kullanılarak bigcode/starcoder (15.5B parametre) modelinin 8 A100 80GB GPU ile tamamen ince ayarlanması gösterilecektir. Eğitim hedefi olarak, bir eğitim dizisinin parçalarının sona taşındığı ve sıralamanın otomatik olarak tahmin edildiği FIM (Ortayı Doldur) [https://arxiv.org/abs/2207.14255] yöntemi kullanılacaktır.
Neden PEFT?
Tam ince ayar maliyetlidir. Bunu perspektife oturtmak için birkaç sayı:
Tam ince ayar için minimum GPU belleği gereksinimleri:
- Ağırlık: 2 bayt (Karışık Hassasiyet eğitimi)
- Ağırlık gradyanı: 2 bayt
- Adam optimize edicisi için durum: 4 bayt (FP32 ağırlık) + 8 bayt (birinci ve ikinci moment tahminleri)
- Parametre başına maliyet: 16 bayt
- 15.5B model -> 248GB GPU belleği (ara aktivasyonları dahil etmeden) -> minimum 4X A100 80GB GPU gereklidir.
Donanım gereksinimleri bu kadar büyük olduğu için, QLoRA yöntemini kullanacağız [https://arxiv.org/abs/2305.14314].
QLoRA ile StarCoder için minimum GPU bellek gereksinimleri:
- Eğitilebilir parametreler: 110,428,160
- Tüm parametreler: 15,627,884,544
- Eğitilebilir yüzdesi: %0.71
- Temel model ağırlığı: 0.5 bayt * 15.51B dondurulmuş parametre = 7.755 GB
- Adaptör ağırlığı: 2 bayt * 0.11B eğitilebilir parametre = 0.22GB
- Ağırlık gradyanı: 2 bayt * 0.11B eğitilebilir parametre = 0.12GB
- Adam optimize edicisi: 4 bayt * 0.11B eğitilebilir parametre * 3 = 1.32GB
- Toplam: 9.51 GB ~10GB -> 1 A100 40GB GPU gerekli.
Ayrıca, uzun dizilim uzunlukları (2048) ve 4 partilik mini partiler nedeniyle daha yüksek bellek gereksinimleri oluşmaktadır. A100 GPU’lar, Flash Attention 2 ile daha iyi uyumluluk sunar.
QLoRA, Flash Attention V2 ve gradyan kontrol noktaları kullanıldığında:
- Tek bir A100 40GB GPU üzerindeki toplam bellek: 26 GB (4 partilik mini parti boyutu).
- FSDP ve Flash Attention V2 ile tam ince ayar: GPU başına bellek kullanımı 70 GB ile 77.6 GB arasında (mini parti boyutu: 1).
GPU bellek gereksinimlerini hesaplamak için şu kaynak kullanılabilir: https://huggingface.co/spaces/hf-accelerate/model-memory-usage.
Tam İnce Ayar
8 A100 80GB GPU kullanarak PyTorch Fully Sharded Data Parallel (FSDP) tekniğiyle bigcode/starcoder (15B parametre) modelinin tam ince ayarını nasıl yapacağımıza bakacağız. FSDP hakkında daha fazla bilgi için, Fine-tuning Llama 2 70B using PyTorch FSDP [https://huggingface.co/blog/ram-efficient-pytorch-fsdp] ve Accelerate Large Model Training using PyTorch Fully Sharded Data Parallel [https://huggingface.co/blog/pytorch-fsdp] makalelerine başvurabilirsiniz.[4]
Kaynaklar
- Kod Deposu: [https://github.com/pacman100/DHS-LLM-Workshop/tree/main/personal_copilot/training]. Transformers kütüphanesine yeni eklenen Flash Attention V2 desteğini kullanmaktadır.
- FSDP Yapılandırması: fsdp_config.yaml [https://github.com/pacman100/DHS-LLM-Workshop/blob/main/personal_copilot/training/configs/fsdp_config.yaml]
- Model: bigcode/starcoder
- Veri Seti: smangrul/hf-stack-v1
- İnce Ayarlı Model: smangrul/peft-lora-starcoder15B-v2-personal-copilot-A100–40GB-colab
Eğitim başlatma komutu run_fsdp.sh dosyasında verilmiştir [https://github.com/pacman100/DHS-LLM-Workshop/blob/main/personal_copilot/training/run_fsdp.sh].[4]
accelerate launch --config_file "configs/fsdp_config.yaml" train.py \
--model_path "bigcode/starcoder" \
--dataset_name "smangrul/hf-stack-v1" \
--subset "data" \
--data_column "content" \
--split "train" \
--seq_length 2048 \
--max_steps 2000 \
--batch_size 1 \
--gradient_accumulation_steps 2 \
--learning_rate 5e-5 \
--lr_scheduler_type "cosine" \
--weight_decay 0.01 \
--num_warmup_steps 30 \
--eval_freq 100 \
--save_freq 500 \
--log_freq 25 \
--num_workers 4 \
--bf16 \
--no_fp16 \
--output_dir "starcoder-personal-copilot-A100-40GB-colab" \
--fim_rate 0.5 \
--fim_spm_rate 0.5 \
--use_flash_attnToplam eğitim süresi 9 saatti. Lambdalabs’a dayalı olarak 8x A100 80GB GPU için saatlik 12,00$ maliyeti alındığında, toplam maliyet 108$ olurdu.[4]
PEFT
Tek bir A100 40GB GPU üzerinde 🤗 PEFT kullanarak bigcode/starcoder (15 milyar parametre) modelini ince ayarlamak için QLoRA’nın nasıl kullanılacağını ele alacağız. QLoRA ve PEFT yöntemleri hakkında daha fazla bilgi için lütfen şu kaynaklara bakın: Making LLMs even more accessible with bitsandbytes, 4-bit quantization and QLoRA ve 🤗 PEFT: Parameter-Efficient Fine-Tuning of Billion-Scale Models on Low-Resource Hardware.
Kaynaklar
- Kod tabanı: [https://github.com/pacman100/DHS-LLM-Workshop/tree/main/personal_copilot/training]. Transformers’ta yakın zamanda eklenen Flash Attention V2 desteğini kullanmaktadır.[4]
- Colab not defteri: Link. A100 GPU’yu Yüksek RAM ayarıyla seçtiğinizden emin olun.
- Model: bigcode/starcoder
- Veri seti: smangrul/hf-stack-v1
- QLoRA ile İnce Ayarlanmış Model: smangrul/peft-lora-starcoder15B-v2-personal-copilot-A100–40GB-colab
Eğitimi başlatmak için gerekli komut run_peft.sh dosyasında verilmiştir. Toplam eğitim süresi 12,5 saattir. Lambdalabs fiyatlandırmasına göre saatlik maliyet $1.10 olarak alınırsa, toplam maliyet $13.75 olacaktır. Bu oldukça iyi 🚀! Maliyet açısından bakıldığında, tam ince ayara göre 7.8 kat daha düşük maliyetlidir.[4]
QLoRA modelimizin felaket unutmaya yol açmamasını sağlamak için, üzerinde Python Human Eval’ı çalıştırıyoruz. Aşağıda elde ettiğimiz sonuçlar yer almaktadır. Pass@1, problem başına yalnızca tek bir oluşturulmuş kod adayı dikkate alınarak tamamlanmaların geçiş oranını ölçer. humaneval-python’daki performansın temel bigcode/starcoder (15B parametre) ve ince ayarlı PEFT modeli smangrul/peft-lora-starcoder15B-v2-personal-copilot-A100–40GB-colab arasında karşılaştırılabilir olduğunu gözlemleyebiliriz.[4]
Şimdi bazı nitel örneklere bakalım. Manuel analizimizde, QLoRA’nın hafif bir aşırı uyuma yol açtığını fark ettik ve bu nedenle PEFT’in add_weighted_adapter yardımcı programı aracılığıyla ağırlığı 0,8 olan yeni ağırlıklı adaptör oluşturarak bunu azalttık. Modelin görevinin <FILL_ME> yer tutucusu ile belirtilen kısmı doldurmak olduğu 2 kod doldurma örneğine bakacağız. GitHub Copilot’tan, QLoRA ince ayarlı modelden ve tam ince ayarlı modelden doldurma tamamlamalarını ele alacağız.[4]
Yukarıdaki örnekte, GitHub Copilot’tan gelen tamamlama doğru çizgidedir ancak çok yardımcı olmaz. Öte yandan, QLoRA ve tam ince ayarlı modellerden gelen tamamlamalar, tüm fonksiyon çağrısını gerekli parametrelerle doğru şekilde doldurmaktadır. Ancak, sonrasında çok daha fazla gürültü de eklemektedirler. Bu, tamamlamaları kapanış parantezlerine veya yeni satırlara sınırlamak için bir son işlem adımıyla kontrol edilebilir. Hem QLoRA hem de tam ince ayarlı modellerin benzer kalitede sonuçlar ürettiğini unutmayın.[4]
Yukarıdaki ikinci örnekte, GitHub Copilot herhangi bir tamamlama vermedi. Bunun nedeni 🤗 PEFT’in yeni bir kütüphane olması ve henüz Copilot’un eğitim verilerinin bir parçası olmaması olabilir; bu da tam olarak ele almaya çalıştığımız sorun türüdür. Öte yandan, QLoRA ve tam ince ayarlı modellerden gelen tamamlamalar, tüm fonksiyon çağrısını gerekli parametrelerle doğru şekilde dolduruyor. Tekrar belirtmek gerekirse, hem QLoRA hem de tam ince ayarlı modeller benzer kalitede nesiller veriyor. Tam ince ayarlı model ve peft modeli için çeşitli örnekler içeren Çıkarım Kodu sırasıyla Full_Finetuned_StarCoder_Inference.ipynb ve PEFT_StarCoder_Inference.ipynb adreslerinde mevcuttur. 🤗 llm-vscode VS Code Uzantısı’nı kullanarak ve modeli 🤗 Inference EndPoints aracılığıyla barındırarak VS Code’da özel bir kod tamamlama LLM’sini kolayca yapılandırabilirsiniz. Aşağıda gerekli adımları inceleyeceğiz. Bir uç noktanın dağıtımı hakkında daha fazla ayrıntıyı çıkarım uç noktaları belgelerinde öğrenebilirsiniz.[4]
Kendi Kod Sohbet Asistanınızı İnce Ayarlama
Şimdiye kadar eğittiğimiz modeller, kod tamamlama görevleri için kişisel yardımcı pilot olarak özel olarak eğitildi. Konuşmalar yürütmek veya soru cevaplamak için eğitilmediler. Octocoder ve StarChat bu tür modellerin harika örnekleridir. Bu bölüm, bunun nasıl başarılacağını kısaca açıklamaktadır.[4]
Kaynaklar
- Kod tabanı: link. Transformers’da yakın zamanda eklenen Flash Attention V2 desteğini kullanır.
- Colab notebook: link. Yüksek RAM ayarına sahip bir A100 GPU seçtiğinizden emin olun.
- Model: bigcode/stacoderplus
- Veri kümesi: smangrul/code-chat-assistant-v1. Hazır eğitilebilir bir formatta uygun biçimlendirmeyle LIMA+GUANACO karışımı.
- Eğitilmiş Model: smangrul/peft-lora-starcoderplus-chat-asst-A100–40GB-colab
LoRA’ların Dansı (Dance of LoRAs)
Kendi Dreambooth modellerinizi yapmak için Stable Diffusion modelleri ve LoRA’larla uğraştıysanız, farklı ağırlıklara sahip farklı LoRA’ları, eğitildiği modelden farklı bir temel modele sahip bir LoRA modeli kullanarak birleştirme kavramlarına aşina olabilirsiniz. Metin/kod alanında, bu keşfedilmemiş bir alan olmaya devam ediyor. Bu konuda deneyler yürütüyoruz ve çok ümit verici bulgular gözlemledik. [4]
Karıştır ve Eşleştir LoRA’lar (Mix-and-Match LoRAs)
PEFT şu anda LoRA modellerini birleştirmenin 3 yolunu destekliyor: doğrusal, svd ve cat. Daha fazla ayrıntı için:
[https://github.com/pacman100/DHS-LLM-Workshop/blob/main/personal_copilot/inference/Dance_of_LoRAs.ipynb] not defterimiz tüm çıkarım kodunu ve starcodeplus yerine starcoder’ın üzerine sohbet asistanını yükleme gibi çeşitli LoRA yükleme kombinasyonlarını içeriyor; bu, ince ayar yaptığımız temel modeldir.[4]
Burada, 2 veri dağıtımında (ilk 10 genel hf kod tabanı ve genel kod tabanı) 2 yeteneği (sohbet/QA ve kod tamamlama) ele alacağız. Bu bize bazı nitel değerlendirme analizleri yapacağımız 4 eksen verir. Bağdaştırıcıları devre dışı bırakırsak, temel model (starcoder) yalnızca kod tamamlama için tasarlandığından ve sohbet/soru cevaplama için uygun olmadığından, görevin her iki veri kümesi için de başarısız olduğunu gözlemleriz. Yardımcı pilot bağdaştırıcısını etkinleştirmek, devre dışı bırakılan duruma benzer şekilde çalışır çünkü bu LoRA da kod tamamlama için özel olarak ince ayarlanmıştır.[4]
Karşılaştırma
Aşağıdaki grafik, QLoRA ile tam ince ayar için değerlendirme kaybını, eğitim kaybını ve öğrenme oranı planlayıcısını göstermektedir. Tam ince ayarın QLoRA ile karşılaştırıldığında biraz daha düşük kayba yol açtığını ve biraz daha hızlı yakınsadığını gözlemliyoruz. PEFT ince ayarı için öğrenme oranı, tam ince ayardan 10 kat daha fazladır. [4]
Kod LLM’lerin Değerlendirilmeleri
İnce ayar kalitesini kontrol etmek için her zaman birkaç yanıtı inceleyebilir ve değerlendirebilirsiniz, ancak süreci otomatikleştirip daha ayrıntılı bir şekilde değerlendirmeye karar verirseniz bilmeniz gereken bazı şeyler vardır.[4]
Değerlendirme, ince ayar yapılmış modellerin performansını değerlendirmek için önemli bir adımdır. İnce ayar yapılmış modellerin, ince ayar yapılmamış modellere göre gösterdiği gelişimi ortaya koymak için hem niteliksel hem de niceliksel değerlendirmeler sunuyoruz. Niteliksel değerlendirmede, ince ayar yapılmış ve yapılmamış modellerden alınan bir örnek yanıtı gösteriyoruz. Niceliksel değerlendirmede ise, OpenAI tarafından geliştirilen ve Python kodu üretme yeteneklerini doğru ve kesin sonuçlar üretebilme açısından test eden bir test paketi olan HumanEval’i kullanıyoruz [https://huggingface.co/datasets/openai/openai_humaneval]. HumanEval deposu MIT lisansı altındadır. Dolphin Coder veri kümesinde farklı boyutlardaki tüm Code Llama modellerinin Python varyantlarını (Code Llama Python 7B, 13B, 34B ve 70B) ince ayara tabi tuttuk ve değerlendirme sonuçlarını aşağıdaki bölümlerde sunuyoruz.[4]
HumanEval, bir büyük dil modelinin (LLM) Python tabanlı kodlama problemlerinde problem çözme yeteneklerini değerlendirmek için bir değerlendirme altyapısıdır. Bu, Kod Üzerine Eğitilmiş Büyük Dil Modellerinin Değerlendirilmesi başlıklı makalede açıklanmıştır [https://arxiv.org/abs/2107.03374]. Özellikle, bir dil modelinin işlev imzası, açıklama (docstring), gövde ve birim testleri gibi sağlanan bilgilere dayalı olarak kod oluşturma yeteneğini değerlendiren 164 özgün Python tabanlı programlama problemini içerir.[4]
Her Python tabanlı programlama sorusu için, soruyu bir SageMaker uç noktasında dağıtılmış bir Code Llama modeline gönderiyor ve k adet yanıt alıyoruz. Daha sonra, alınan her k yanıtını HumanEval deposundaki entegrasyon testlerinde çalıştırıyoruz. Eğer k yanıtından herhangi biri entegrasyon testlerinden geçerse, o test vakasını başarılı; aksi takdirde başarısız sayıyoruz. Ardından, başarılı vakaların oranını hesaplayarak, nihai değerlendirme skoru olan pass@k’yi belirliyoruz. Standart uygulamaya uygun olarak, değerlendirmemizde k’yi 1 olarak belirliyoruz, yani her soru için yalnızca bir yanıt oluşturuyor ve bunun entegrasyon testinden geçip geçmediğini test ediyoruz.[4]
Aşağıda HumanEval deposunu kullanmak için örnek bir kod verilmiştir [4]:
%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')Ayrıntılar için GitHub deposundaki not defterine bakın: [https://github.com/aws/amazon-sagemaker-examples/blob/main/introduction_to_amazon_algorithms/jumpstart-foundation-models/code-llama-fine-tuning-evaluate-human-eval.ipynb]
BigCodeBench
HumanEval, kod üretim görevlerinde büyük dil modellerini (LLM’ler) değerlendirmek için bir referans kriteridir, çünkü küçük çaplı işlev düzeyindeki kod parçalarının değerlendirilmesini kolaylaştırır. Ancak, HumanEval’in LLM’lerin programlama yeteneklerini değerlendirmedeki etkinliği konusunda artan endişeler bulunmaktadır ve temel endişe, HumanEval’deki görevlerin çok basit olması ve gerçek dünya programlama görevlerini temsil etmeyebileceğidir. HumanEval’deki algoritma odaklı görevlere kıyasla, gerçek dünya yazılım geliştirme genellikle çeşitli kütüphaneleri ve işlev çağrılarını içerir. Ayrıca, HumanEval’deki LLM’lerin performansı, kontaminasyon ve aşırı öğrenme sorunlarına bağlıdır ([https://arxiv.org/abs/2403.07974]), bu da LLM’lerin genelleme yeteneklerini değerlendirmek için daha az güvenilir hale getirir. [6]
Bu sorunları ele almak için bazı girişimler olsa da, bunlar ya alan özelinde, deterministik ya da ajan merkezlidir (üzgünüz DS-1000 [https://github.com/HKUNLP/DS-1000], ODEX [https://github.com/zorazrw/odex] ve SWE-bench [https://github.com/princeton-nlp/SWE-bench]). Topluluğun, LLM’lerin programlama yeteneklerini geniş bir şekilde değerlendirebilecek, kullanımı kolay bir kriterden hala yoksun olduğunu düşünüyoruz ve işte bu noktaya odaklandık. [6]
BigCodeBench’in duyurusunu yapmaktan heyecan duyuyoruz; bu araç, LLM’leri kontaminasyonsuz olarak pratik ve zorlu programlama görevlerini çözme yetenekleri üzerinde değerlendirir. Özellikle, BigCodeBench, LLM’leri 139 kütüphaneden gelen birden fazla işlev çağrısını araç olarak kullanarak talimatları takip etmeye zorlayan 1.140 işlev düzeyindeki görev içermektedir. LLM’leri titizlikle değerlendirmek için, her bir programlama görevi, ortalama %99 dal kapsamına sahip 5,6 test vakasını kapsamaktadır. [6]
BigCodeBench, her görev için net işlevsellik açıklamaları, giriş/çıkış biçimleri, hata işleme ve doğrulanmış etkileşimli örnekler dahil olmak üzere karmaşık, kullanıcı odaklı talimatlar sunar. Yetenekli LLM’lerin görevleri kullanıcının bakış açısından açık uçlu bir şekilde anlamaları ve çözmeleri gerektiğine inanarak adım adım görev talimatlarından kaçınırız. Test vakalarını kullanarak belirli özellikleri doğrularız.[6]
# We elaborate the above task with some test cases:
# Requirements SetUp
import unittest
from unittest.mock import patch
import http.client
import ssl
import socket
# Start the test
class TestCases(unittest.TestCase):
# Mock the successful connection and assess the response content
@patch('http.client.HTTPSConnection')
def test_response_content(self, mock_conn):
""" Test the content of the response. """
mock_conn.return_value.getresponse.return_value.read.return_value = b'Expected Content'
result = task_func('www.example.com', 443, '/content/path')
self.assertEqual(result, 'Expected Content')
# Mock the failed connection and assess the error handling
@patch('socket.create_connection')
@patch('http.client.HTTPSConnection')
def test_ssl_handshake_error_handling(self, mock_conn, mock_socket):
""" Test handling of SSL handshake errors. """
mock_socket.side_effect = ssl.SSLError('SSL handshake failed')
with self.assertRaises(ssl.SSLError):
task_func('badssl.com', 443, '/test/path')
# More test cases...BigCodeBench’teki görevler, popüler kütüphanelerden çeşitli işlev çağrılarını kullanır. LLM’lerin kullanabileceği işlev çağrılarını kısıtlamıyoruz, uygun işlevleri seçmelerini ve görevleri çözmek için bunları esnek bir şekilde birleştirmelerini bekliyoruz. Test durumları, çalışma zamanı sırasında beklenen program davranışlarını incelemek için test koşumları olarak tasarlanmıştır.[6]
LLM performansını değerlendirmek için, düzenlenmiş test durumları aracılığıyla ilk oluşturulan kod parçacığıyla doğru şekilde çözülen görevlerin yüzdesini ölçerek açgözlü kod çözme ile Pass@1 kullanıyoruz. Bu yaklaşım, HumanEval ve MBPP [https://github.com/google-research/google-research/tree/master/mbpp] gibi ölçütlerle uyumludur. LLM’lerin uzun kod istemlerini atlama eğilimini, kalibre edilmiş Pass@1 olarak adlandırılan Pass@1 değerlendirmesi sırasında eksik kurulumlar (örneğin, içe aktarma ifadeleri, genel sabitler) ekleyerek ele alıyoruz.[6]
Uygulama karmaşıklığını ve araç kullanım çeşitliliğini daha iyi anlamak için BigCodeBench’teki görevleri APPS, DS-1000, ODEX, APIBench, MBPP, NumpyEval, PandasEval, HumanEval ve TorchDataEval [https://github.com/microsoft/PyCodeGPT/tree/main/apicoder/private-eval] dahil olmak üzere temsili kıyaslamalardakilerle karşılaştırıyoruz. BigCodeBench’in kapsamlı işlevleri uygulamak için daha karmaşık muhakeme ve problem çözme becerileri gerektirdiğini görüyoruz.[6]
Görev figüründe gösterildiği gibi, ana hedef senaryo, LLM’lerin doküman dizisindeki ayrıntılı talimatlara dayalı olarak bir fonksiyonun uygulamasını tamamlaması gereken kod tamamlamadır (BigCodeBench-Complete olarak belirtilir). Ancak, çoklu dönüşlü diyalog gibi alt akış uygulamalarını göz önünde bulundurarak, kullanıcılar gereksinimleri daha konuşma dilinde ve daha az ayrıntılı bir şekilde tanımlayabilir. Talimat ayarlı LLM’lerin faydalı olduğu yer burasıdır, çünkü doğal dil talimatlarını takip etmek ve buna göre kod parçacıkları oluşturmak üzere eğitilirler. Modellerin insan niyetlerini gerçekten anlayıp bunları koda çevirip çeviremeyeceğini test etmek için, talimat ayarlı LLM’leri değerlendirmek üzere tasarlanmış BigCodeBench’in daha zorlu bir çeşidi olan BigCodeBench-Instruct’u oluşturduk.[6]
BigCodeBench’teki görevlerin kalitesini sistematik bir “İnsan-LLM iş birliği süreci” ile garanti ediyoruz. “Tohum veri kümesi” olarak ODEX ile başlıyoruz. Bu, kısa ama gerçekçi insan niyetlerini ve Stack Overflow’dan karşılık gelen Python tek satırlık ifadelerini içeriyor. Bu tek satırlık ifadeleri kapsamlı işlev düzeyindeki görevlere genişletmek için GPT-4 kullanıyoruz.[6]
Sonra, çoğu 5 yıldan fazla Python programlama deneyimine sahip 20 insan uzman, GPT-4'ü yürütme tabanlı bir deneme ortamında gönüllü olarak yönlendiriyor. Sürekli olarak sentezlenen görevleri iyileştirmesi ve test vakaları eklemesi talimatını veriyorlar. Görevler ve test vakaları daha sonra yerel bir ortamda inceleniyor, diğer LLM’lerde önceden değerlendiriliyor ve kalitelerini sağlamak için 7 ek insan uzman tarafından çapraz kontrol ediliyor.[6]
Genel kaliteyi doğrulamak için yazarlar, 11 insan uzmanın çözmesi için görev örnekleri alıyor ve %97'lik ortalama bir insan performansı elde ediyor.[6]
Kaynaklar
[1] Swimm Team, (2024), Code Completion in the Age of Generative AI
[https://swimm.io/ai-tools-for-developers/code-completion-in-the-age-of-generative-ai]
[2] Oleg Klimov, (March 27, 2024), Fine-Tuning Code Completion Models: The Easy Way:
[https://refact.ai/blog/2024/fine-tuning-code-completion-models/][3] jordandeklerk, (March 2024), Enhancing Code LLMs for Organizational Use with Single GPU Fine-tuning:
[4] smangrul and sayakpaul, (October 27, 2023), Personal Copilot: Train Your Own Coding Assistant
[https://huggingface.co/blog/personal-copilot]
[5]Huang, Khetan, Yalamanchali and Thandavarayan ,(18 MAR 2024), Fine-tune Code Llama on Amazon SageMaker JumpStart:
[https://aws.amazon.com/tr/blogs/machine-learning/fine-tune-code-llama-on-amazon-sagemaker-jumpstart/]
[6]terryyz, ganler,SivilTaram, huybery, Muennighoff, dpfried, harmdevries, lvwerra, clefourrier, (June 18, 2024), BigCodeBench: The Next Generation of HumanEval:
