From 7f1ec4d31f883c3bcc5625d0a818e2b2043ebaa4 Mon Sep 17 00:00:00 2001 From: Emre Albayrak <70805503+emre570@users.noreply.github.com> Date: Thu, 24 Oct 2024 20:01:59 +0300 Subject: [PATCH 1/5] TR Translation of "Fine-tuning a Code LLM on Custom Code on a single GPU" --- notebooks/tr-TR/_toctree.yml | 9 + .../fine_tuning_code_llm_on_single_gpu.ipynb | 1127 +++++++++++++++++ 2 files changed, 1136 insertions(+) create mode 100644 notebooks/tr-TR/_toctree.yml create mode 100644 notebooks/tr-TR/fine_tuning_code_llm_on_single_gpu.ipynb diff --git a/notebooks/tr-TR/_toctree.yml b/notebooks/tr-TR/_toctree.yml new file mode 100644 index 00000000..903ca565 --- /dev/null +++ b/notebooks/tr-TR/_toctree.yml @@ -0,0 +1,9 @@ +- title: Açık-Kaynak YZ Tarif Kitabı + sections: + - local: index + title: Açık-Kaynak YZ Tarif Kitabı + +- title: LLM Tarifleri + sections: + - local: fine_tuning_code_llm_on_single_gpu + title: Kod Dil Modelini Tek GPU'da Fine-Tune Etmek \ No newline at end of file diff --git a/notebooks/tr-TR/fine_tuning_code_llm_on_single_gpu.ipynb b/notebooks/tr-TR/fine_tuning_code_llm_on_single_gpu.ipynb new file mode 100644 index 00000000..75cce586 --- /dev/null +++ b/notebooks/tr-TR/fine_tuning_code_llm_on_single_gpu.ipynb @@ -0,0 +1,1127 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "FNdZ-kD0l78P" + }, + "source": [ + "# Kod Dil Modelini Tek GPU'da Fine-Tune Etmek\n", + "\n", + "_[Maria Khalusova](https://github.com/MKhalusova) tarafından hazırlanmıştır._\n", + "\n", + "Codex, StarCoder ve Code Llama gibi açık kaynak dil modelleri genel programlama ilkelerine ve sözdizimine uygun kod üretme konusunda harikadır, ancak bir kuruluşun dahili kurallarıyla uyumlu olmayabilir veya özel kütüphanelerden haberdar olmayabilir.\n", + "\n", + "Bu not defterinde, bir modelin bağlamsal farkındalığını artırmak ve kuruluşunuzun ihtiyaçları için kullanılabilirliğini artırmak amacıyla özel kod tabanlarında bir kod dil modeline nasıl ince ayar yapabileceğinizi göstereceğiz. Kod dil modelleri oldukça büyük olduğundan, geleneksel bir şekilde ince ayar yapmak kaynakları tüketebilir. Endişelenmeyin! Fine-tune işlemini tek bir GPU'ya sığacak şekilde nasıl optimize edebileceğinizi göstereceğiz.\n", + "\n", + "\n", + "## Veri Seti\n", + "\n", + "Bu örnek için GitHub'daki en iyi 10 Hugging Face public repo'larını seçtik. Görseller, ses dosyaları, sunumlar gibi kod içermeyen dosyaları verilerden hariç tuttuk. Jupyter not defterleri için yalnızca kod içeren hücreleri tuttuk. Ortaya çıkan kod, Hugging Face Hub'da [`smangrul/hf-stack-v1`](https://huggingface.co/datasets/smangrul/hf-stack-v1) bağlantısı altında bulabileceğiniz bir veri seti olarak saklanıyor. Bu veri seti repo'nun kimliğini, dosya yolunu ve dosya içeriğini içeriyor.\n", + "\n", + "\n", + "## Model\n", + "\n", + "Bu rehberde 1 milyar parametreli ve 80'den fazla programlama dilinde eğitilmiş [`bigcode/starcoderbase-1b`](https://huggingface.co/bigcode/starcoderbase-1b) modelini seçiyoruz. Bu model yayıncı tarafından korumaya sahip, bu nedenle bu not defterini tam olarak bu modelle çalıştırmayı planlıyorsanız, modelin sayfasından erişim sağlamanız gerekir. Erişim izninizi aldıktan sonra, Hugging Face hesabınıza giriş yapın.\n", + "\n", + "**Not:** Eğer fine-tune edilmiş modelinizi Hugging Face Hub'a yüklemek istiyorsanız, `write` izni olan bir token girmeniz gerekli." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "bPlCJYDK6vrF" + }, + "outputs": [], + "source": [ + "from huggingface_hub import notebook_login\n", + "\n", + "notebook_login()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WMVe_c8q43Qo" + }, + "source": [ + "Başlamak için gerekli tüm kütüphaneleri yükleyelim. Gördüğünüz gibi, `transformers` ve `datasets` kütüphanelerine ek olarak, eğitimi optimize etmek için `peft`, `bitsandbytes` ve `flash-attn` kullanacağız.\n", + "\n", + "Parametre açısından verimli eğitim teknikleri kullanarak, bu dizüstü bilgisayarı tek bir A100 High-RAM GPU üzerinde çalıştırabiliriz." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Fp7i8WMCjKJG" + }, + "outputs": [], + "source": [ + "!pip install -q transformers datasets peft bitsandbytes flash-attn" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "16EdABzt3_Ig" + }, + "source": [ + "Şimdi biraz değişken tanımlayalım. Değerlerini istediğiniz gibi değiştirebilirsiniz." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "hru3G-CLmqis" + }, + "outputs": [], + "source": [ + "MODEL=\"bigcode/starcoderbase-1b\" # Hugging Face Hub model adı\n", + "DATASET=\"smangrul/hf-stack-v1\" # Hugging Face Hub'daki veri seti\n", + "DATA_COLUMN=\"content\" # kod içeriğinin olduğu sütun adı\n", + "\n", + "SEQ_LENGTH=2048 # Karakter uzunluğu\n", + "\n", + "# Eğitim argümanları\n", + "MAX_STEPS=2000 # max_steps\n", + "BATCH_SIZE=16 # batch_size\n", + "GR_ACC_STEPS=1 # gradient_accumulation_steps\n", + "LR=5e-4 # learning_rate\n", + "LR_SCHEDULER_TYPE=\"cosine\" # lr_scheduler_type\n", + "WEIGHT_DECAY=0.01 # weight_decay\n", + "NUM_WARMUP_STEPS=30 # num_warmup_steps\n", + "EVAL_FREQ=100 # eval_freq\n", + "SAVE_FREQ=100 # save_freq\n", + "LOG_FREQ=25 # log_freq\n", + "OUTPUT_DIR=\"peft-starcoder-lora-a100\" # output_dir\n", + "BF16=True # bf16\n", + "FP16=False # no_fp16\n", + "\n", + "# FIM dönüşüm argümanları\n", + "FIM_RATE=0.5 # fim_rate\n", + "FIM_SPM_RATE=0.5 # fim_spm_rate\n", + "\n", + "# LORA argümanları\n", + "LORA_R=8 # lora_r\n", + "LORA_ALPHA=32 # lora_alpha\n", + "LORA_DROPOUT=0.0 # lora_dropout\n", + "LORA_TARGET_MODULES=\"c_proj,c_attn,q_attn,c_fc,c_proj\" # lora_target_modules\n", + "\n", + "# bitsandbytes config argümanları\n", + "USE_NESTED_QUANT=True # use_nested_quant\n", + "BNB_4BIT_COMPUTE_DTYPE=\"bfloat16\"# bnb_4bit_compute_dtype\n", + "\n", + "SEED=0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "FyZSXTbJrcnC" + }, + "outputs": [], + "source": [ + "from transformers import (\n", + " AutoModelForCausalLM,\n", + " AutoTokenizer,\n", + " Trainer,\n", + " TrainingArguments,\n", + " logging,\n", + " set_seed,\n", + " BitsAndBytesConfig,\n", + ")\n", + "\n", + "set_seed(SEED)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pO7F5L5AtKo1" + }, + "source": [ + "## Veri setinin hazırlanması" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1LmrIZqP0oUE" + }, + "source": [ + "Verileri yükleyerek başlayalım. Veri setinin oldukça büyük olması muhtemel olduğundan, streaming modunu etkinleştirdiğinizden emin olun. Streaming, tüm veri setini bir kerede indirmek yerine veri seti üzerinde işlem yaptıkça verileri kademeli olarak yüklememizi sağlar.\n", + "\n", + "İlk 4000 örneği validation set (doğrulama kümesi) olarak ayıracağız ve geri kalan her şey eğitim verisi olacak." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4oJZvZb-1J88" + }, + "outputs": [], + "source": [ + "from datasets import load_dataset\n", + "import torch\n", + "from tqdm import tqdm\n", + "\n", + "\n", + "dataset = load_dataset(\n", + " DATASET,\n", + " data_dir=\"data\",\n", + " split=\"train\",\n", + " streaming=True,\n", + ")\n", + "\n", + "valid_data = dataset.take(4000)\n", + "train_data = dataset.skip(4000)\n", + "train_data = train_data.shuffle(buffer_size=5000, seed=SEED)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sLQ8t0LM2GR6" + }, + "source": [ + "Bu adımda, veri seti hala isteğe bağlı uzunlukta kod içeren ham veriler içeriyor. Eğitim için sabit uzunlukta girdilere ihtiyacımız var. Bir metin dosyası akışından (stream) sabit uzunlukta token yığınları döndürecek bir Iterable veri kümesi oluşturalım.\n", + "\n", + "İlk olarak, veri setindeki token başına ortalama karakter sayısını tahmin edelim, bu daha sonra text buffer'daki 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, hesaplama maliyetini düşürürken, genel karakter-token oranının makul bir tahminini sağlayacaktır." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KCiAvydztNsu", + "outputId": "cabf7fd0-a922-4371-cbc6-60ee99ef7469" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 400/400 [00:10<00:00, 39.87it/s] " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The character to token ratio of the dataset is: 2.43\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "tokenizer = AutoTokenizer.from_pretrained(MODEL, trust_remote_code=True)\n", + "\n", + "def chars_token_ratio(dataset, tokenizer, data_column, nb_examples=400):\n", + " \"\"\"\n", + " Veri kümesindeki token başına ortalama karakter sayısını tahmin eder.\n", + " \"\"\"\n", + "\n", + " total_characters, total_tokens = 0, 0\n", + " for _, example in tqdm(zip(range(nb_examples), iter(dataset)), total=nb_examples):\n", + " total_characters += len(example[data_column])\n", + " total_tokens += len(tokenizer(example[data_column]).tokens())\n", + "\n", + " return total_characters / total_tokens\n", + "\n", + "\n", + "chars_per_token = chars_token_ratio(train_data, tokenizer, DATA_COLUMN)\n", + "print(f\"The character to token ratio of the dataset is: {chars_per_token:.2f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "6F13VGobB3Ma" + }, + "source": [ + "Karakter-token oranı, metin tokenizasyonunun kalitesinin bir göstergesi olarak da kullanılabilir. Örneğin, karakter-token oranının 1,0 olması her karakterin bir token ile temsil edildiği anlamına gelir ki bu çok anlamlı değildir. Bu da zayıf bir tokenizasyona işaret eder. Standart İngilizce metinde bir token tipik olarak yaklaşık dört karaktere eşdeğerdir, yani karakter-token oranı 4,0 civarındadır. Kod veri setinde daha düşük bir oran bekleyebiliriz, ancak genel olarak konuşursak, 2,0 ile 3,5 arasında bir sayı yeterince iyi kabul edilebilir." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rcwYFRPpwxea" + }, + "source": [ + "**Opsiyonel FIM dönüşümleri**\n", + "\n", + "Autoregressive dil modelleri tipik olarak soldan sağa doğru sekanslar üretir. Model, FIM dönüşümlerini uygulayarak metni doldurmayı da öğrenebilir. Teknik hakkında daha fazla bilgi edinmek için [“Efficient Training of Language Models to Fill in the Middle” makalesine](https://arxiv.org/pdf/2207.14255.pdf) göz atın.\n", + "\n", + "FIM dönüşümlerini burada tanımlayacağız ve Iterable veri setini oluştururken bunları kullanacağız. Ancak, dönüşümleri kullanmak istemiyorsanız, `fim_rate` değerini 0 olarak ayarlayabilirsiniz." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zmejYvEKw1E-" + }, + "outputs": [], + "source": [ + "import functools\n", + "import numpy as np\n", + "\n", + "\n", + "# FIM dönüşümleri için önek, sonek ve orta için özel belirteçlerin belirteç kimliklerini almak için yardımcı fonksiyon.\n", + "@functools.lru_cache(maxsize=None)\n", + "def get_fim_token_ids(tokenizer):\n", + " try:\n", + " FIM_PREFIX, FIM_MIDDLE, FIM_SUFFIX, FIM_PAD = tokenizer.special_tokens_map[\"additional_special_tokens\"][1:5]\n", + " suffix_tok_id, prefix_tok_id, middle_tok_id, pad_tok_id = (\n", + " tokenizer.vocab[tok] for tok in [FIM_SUFFIX, FIM_PREFIX, FIM_MIDDLE, FIM_PAD]\n", + " )\n", + " except KeyError:\n", + " suffix_tok_id, prefix_tok_id, middle_tok_id, pad_tok_id = None, None, None, None\n", + " return suffix_tok_id, prefix_tok_id, middle_tok_id, pad_tok_id\n", + "\n", + "\n", + "# https://github.com/bigcode-project/Megatron-LM/blob/6c4bf908df8fd86b4977f54bf5b8bd4b521003d1/megatron/data/gpt_dataset.py adresinden uyarlanmıştır.\n", + "def permute(\n", + " sample,\n", + " np_rng,\n", + " suffix_tok_id,\n", + " prefix_tok_id,\n", + " middle_tok_id,\n", + " pad_tok_id,\n", + " fim_rate=0.5,\n", + " fim_spm_rate=0.5,\n", + " truncate_or_pad=False,\n", + "):\n", + " \"\"\"\n", + " Bir örnek (token listesi) alarak iki FIM modu yardımıyla fim_rate olasılığı ile bir FIM dönüşümü gerçekleştirir:\n", + " PSM ve SPM (fim_spm_rate olasılığı ile).\n", + " \"\"\"\n", + "\n", + " # if koşulu fim_rate olasılığı ile tetiklenecektir\n", + " # Bu, FIM dönüşümlerinin fim_rate olasılığına sahip örneklere uygulanacağı anlamına gelir\n", + " if np_rng.binomial(1, fim_rate):\n", + "\n", + " # boundaries dizisinde saklanan rastgele oluşturulmuş indekslere göre örneği önek, orta ve sonek olarak ayırır.\n", + " boundaries = list(np_rng.randint(low=0, high=len(sample) + 1, size=2))\n", + " boundaries.sort()\n", + "\n", + " prefix = np.array(sample[: boundaries[0]], dtype=np.int64)\n", + " middle = np.array(sample[boundaries[0] : boundaries[1]], dtype=np.int64)\n", + " suffix = np.array(sample[boundaries[1] :], dtype=np.int64)\n", + "\n", + " if truncate_or_pad:\n", + " # önek, orta ve sonek belirten tokenleri dikkate alarak örneğin yeni toplam uzunluğunu hesaplar\n", + " new_length = suffix.shape[0] + prefix.shape[0] + middle.shape[0] + 3\n", + " diff = new_length - len(sample)\n", + "\n", + " # yeni uzunluk ile orijinal uzunluk arasında bir uzunluk farkı varsa aktarma veya kesme\n", + " if diff > 0:\n", + " if suffix.shape[0] <= diff:\n", + " return sample, np_rng\n", + " suffix = suffix[: suffix.shape[0] - diff]\n", + " elif diff < 0:\n", + " suffix = np.concatenate([suffix, np.full((-1 * diff), pad_tok_id)])\n", + "\n", + " # FIM dönüşümlerinin fim_spm_rateapply SPM varyantının olasılığı ile\n", + " # SPM: sonek, önek, orta\n", + " if np_rng.binomial(1, fim_spm_rate):\n", + " new_sample = np.concatenate(\n", + " [\n", + " [prefix_tok_id, suffix_tok_id],\n", + " suffix,\n", + " [middle_tok_id],\n", + " prefix,\n", + " middle,\n", + " ]\n", + " )\n", + " # Aksi takdirde, FIM dönüşümlerinin PSM varyantını uygulayın\n", + " # PSM: önek, sonek, orta\n", + " else:\n", + "\n", + " new_sample = np.concatenate(\n", + " [\n", + " [prefix_tok_id],\n", + " prefix,\n", + " [suffix_tok_id],\n", + " suffix,\n", + " [middle_tok_id],\n", + " middle,\n", + " ]\n", + " )\n", + " else:\n", + " # FIM dönüşümlerini uygulamama\n", + " new_sample = sample\n", + "\n", + " return list(new_sample), np_rng\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AwW5FviD9xBH" + }, + "source": [ + "Sabit uzunlukta token yığınları döndürecek bir Iterable veri seti olan `ConstantLengthDataset`i tanımlayalım. Bunu yapmak için, boyut sınırlarına ulaşana kadar orijinal veri setinden bir buffer metin okuyacağız ve ardından ham metni tokenize edilmiş girdilere dönüştürmek için tokenizer uygulayacağız. İsteğe bağlı olarak, bazı diziler üzerinde FIM dönüşümleri gerçekleştireceğiz (etkilenen dizilerin oranı `fim_rate` tarafından kontrol edilir).\n", + "\n", + "Tanımlandıktan sonra, hem eğitim hem de validation verilerinden `ConstantLengthDataset` örnekleri oluşturabiliriz." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "AgDW-692wzOl" + }, + "outputs": [], + "source": [ + "from torch.utils.data import IterableDataset\n", + "from torch.utils.data.dataloader import DataLoader\n", + "import random\n", + "\n", + "# Bir metin dosyası akışından sabit uzunlukta token parçaları döndüren bir Iterable veri seti oluşturur.\n", + "\n", + "class ConstantLengthDataset(IterableDataset):\n", + " \"\"\"\n", + " Metin dosyalarının akışından sabit uzunlukta token parçaları döndüren yinelenebilir veri seti.\n", + " Argümanlar:\n", + " tokenizer (Tokenizer): Verileri işlemek için kullanılan işleyicidir.\n", + " veri seti (dataset.Dataset): Metin dosyaları içeren veri seti.\n", + " infinite (bool): True ise, veri seti sona ulaştıktan sonra iterator sıfırlanır, aksi takdirde durur.\n", + " seq_length (int): Döndürülecek token sekanslarının uzunluğu.\n", + " num_of_sequences (int): Buffer'da tutulacak token sequence sayısı.\n", + " chars_per_token (int): Metin buffer'ındaki token sayısını tahmin etmek için kullanılan token başına karakter sayısı.\n", + " fim_rate (float): Numunenin FIM ile permüle edileceği oran (0,0 ila 1,0).\n", + " fim_spm_rate (float): SPM kullanacak FIM permütasyonlarının oranı (0.0 ila 1.0).\n", + " seed (int): Rastgele sayı üreteci için seed.\n", + " \"\"\"\n", + "\n", + " def __init__(\n", + " self,\n", + " tokenizer,\n", + " dataset,\n", + " infinite=False,\n", + " seq_length=1024,\n", + " num_of_sequences=1024,\n", + " chars_per_token=3.6,\n", + " content_field=\"content\",\n", + " fim_rate=0.5,\n", + " fim_spm_rate=0.5,\n", + " seed=0,\n", + " ):\n", + " self.tokenizer = tokenizer\n", + " self.concat_token_id = tokenizer.eos_token_id\n", + " self.dataset = dataset\n", + " self.seq_length = seq_length\n", + " self.infinite = infinite\n", + " self.current_size = 0\n", + " self.max_buffer_size = seq_length * chars_per_token * num_of_sequences\n", + " self.content_field = content_field\n", + " self.fim_rate = fim_rate\n", + " self.fim_spm_rate = fim_spm_rate\n", + " self.seed = seed\n", + "\n", + " (\n", + " self.suffix_tok_id,\n", + " self.prefix_tok_id,\n", + " self.middle_tok_id,\n", + " self.pad_tok_id,\n", + " ) = get_fim_token_ids(self.tokenizer)\n", + " if not self.suffix_tok_id and self.fim_rate > 0:\n", + " print(\"FIM is not supported by tokenizer, disabling FIM\")\n", + " self.fim_rate = 0\n", + "\n", + " def __iter__(self):\n", + " iterator = iter(self.dataset)\n", + " more_examples = True\n", + " np_rng = np.random.RandomState(seed=self.seed)\n", + " while more_examples:\n", + " buffer, buffer_len = [], 0\n", + " while True:\n", + " if buffer_len >= self.max_buffer_size:\n", + " break\n", + " try:\n", + " buffer.append(next(iterator)[self.content_field])\n", + " buffer_len += len(buffer[-1])\n", + " except StopIteration:\n", + " if self.infinite:\n", + " iterator = iter(self.dataset)\n", + " else:\n", + " more_examples = False\n", + " break\n", + " tokenized_inputs = self.tokenizer(buffer, truncation=False)[\"input_ids\"]\n", + " all_token_ids = []\n", + "\n", + " for tokenized_input in tokenized_inputs:\n", + " # opsiyonel FIM permütasyonları\n", + " if self.fim_rate > 0:\n", + " tokenized_input, np_rng = permute(\n", + " tokenized_input,\n", + " np_rng,\n", + " self.suffix_tok_id,\n", + " self.prefix_tok_id,\n", + " self.middle_tok_id,\n", + " self.pad_tok_id,\n", + " fim_rate=self.fim_rate,\n", + " fim_spm_rate=self.fim_spm_rate,\n", + " truncate_or_pad=False,\n", + " )\n", + "\n", + " all_token_ids.extend(tokenized_input + [self.concat_token_id])\n", + " examples = []\n", + " for i in range(0, len(all_token_ids), self.seq_length):\n", + " input_ids = all_token_ids[i : i + self.seq_length]\n", + " if len(input_ids) == self.seq_length:\n", + " examples.append(input_ids)\n", + " random.shuffle(examples)\n", + " for example in examples:\n", + " self.current_size += 1\n", + " yield {\n", + " \"input_ids\": torch.LongTensor(example),\n", + " \"labels\": torch.LongTensor(example),\n", + " }\n", + "\n", + "\n", + "train_dataset = ConstantLengthDataset(\n", + " tokenizer,\n", + " train_data,\n", + " infinite=True,\n", + " seq_length=SEQ_LENGTH,\n", + " chars_per_token=chars_per_token,\n", + " content_field=DATA_COLUMN,\n", + " fim_rate=FIM_RATE,\n", + " fim_spm_rate=FIM_SPM_RATE,\n", + " seed=SEED,\n", + ")\n", + "eval_dataset = ConstantLengthDataset(\n", + " tokenizer,\n", + " valid_data,\n", + " infinite=False,\n", + " seq_length=SEQ_LENGTH,\n", + " chars_per_token=chars_per_token,\n", + " content_field=DATA_COLUMN,\n", + " fim_rate=FIM_RATE,\n", + " fim_spm_rate=FIM_SPM_RATE,\n", + " seed=SEED,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rxev1sk6tRW9" + }, + "source": [ + "## Modelin Hazırlanması" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UCtWV-U42Eq_" + }, + "source": [ + "Veriler hazırlandığına göre, şimdi modeli yükleme zamanı! Modelin kuantize edilmiş versiyonunu yükleyeceğiz.\n", + "\n", + "Kuantizasyon verileri daha az bitle temsil ettiğinden bellek kullanımını azaltmamızı sağlar. Modeli kuantize etmek için `transformers` ile güzel bir entegrasyona sahip `bitsandbytes` kütüphanesini kullanacağız. Tek yapmamız gereken bir `bitsandbytes` config tanımlamak ve ardından modeli yüklerken bunu kullanmak.\n", + "\n", + "4 bit kuantizasyonun farklı varyantları vardır, ancak genellikle daha iyi performans için NF4 kuantizasyonu kullanmanızı öneririz (`bnb_4bit_quant_type=“nf4”`).\n", + "\n", + "`bnb_4bit_use_double_quant` seçeneği, parametre başına ek 0,4 bit tasarruf etmek için ilkinden sonra ikinci bir kuantizasyon ekler.\n", + "\n", + "Niceleme hakkında daha fazla bilgi edinmek için [“Making LLMs even more accessible with bitsandbytes, 4-bit quantization and QLoRA” blog post](https://huggingface.co/blog/4bit-transformers-bitsandbytes) adresine göz atın.\n", + "\n", + "Tanımlandıktan sonra, modelin kuantize edilmiş versiyonunu yüklemek için yapılandırmayı `from_pretrained` yöntemine aktarın." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "XuwoX6U2DUvK" + }, + "outputs": [], + "source": [ + "from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training\n", + "from peft.tuners.lora import LoraLayer\n", + "\n", + "load_in_8bit = False\n", + "\n", + "# 4-bit kuantize işlemi\n", + "compute_dtype = getattr(torch, BNB_4BIT_COMPUTE_DTYPE)\n", + "\n", + "bnb_config = BitsAndBytesConfig(\n", + " load_in_4bit=True,\n", + " bnb_4bit_quant_type=\"nf4\",\n", + " bnb_4bit_compute_dtype=compute_dtype,\n", + " bnb_4bit_use_double_quant=USE_NESTED_QUANT,\n", + ")\n", + "\n", + "device_map = {\"\": 0}\n", + "\n", + "model = AutoModelForCausalLM.from_pretrained(\n", + " MODEL,\n", + " load_in_8bit=load_in_8bit,\n", + " quantization_config=bnb_config,\n", + " device_map=device_map,\n", + " use_cache=False, # Gradient Checkpoint kullanacağız\n", + " trust_remote_code=True,\n", + " use_flash_attention_2=True,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bO9e2FV8D8ZF" + }, + "source": [ + "Eğitim için kuantize edilmiş bir model kullanırken, modeli ön işleme tabi tutmak amacıyla `prepare_model_for_kbit_training()` fonksiyonunu çağırmamız gerekiyor." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Qb_eB4xzEDBk" + }, + "outputs": [], + "source": [ + "model = prepare_model_for_kbit_training(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lmnLjPZpDVtg" + }, + "source": [ + "Artık kuantize model hazır olduğuna göre, bir LoRA yapılandırması ayarlayabiliriz. LoRA, eğitilebilir parametrelerin sayısını önemli ölçüde azaltarak fine-tune yapmayı daha verimli hale getirir.\n", + "\n", + "LoRA tekniğini kullanarak bir modeli eğitmek için, temel modeli `PeftModel` olarak çağırmamız gerekir. Bu, `LoraConfig` ile LoRA yapılandırmasını tanımlamayı ve `LoraConfig` kullanarak orijinal modeli `get_peft_model()` ile çağırmayı içerir.\n", + "\n", + "LoRA ve parametreleri hakkında daha fazla bilgi edinmek için [PEFT dokümantasyonuna](https://huggingface.co/docs/peft/conceptual_guides/lora) bakabilirsiniz." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_pAUU2FR2Gey", + "outputId": "63328c2b-e693-49b1-ce0a-3ca8722f852a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "trainable params: 5,554,176 || all params: 1,142,761,472 || trainable%: 0.4860310866343243\n" + ] + } + ], + "source": [ + "# Lora config ayarları\n", + "peft_config = LoraConfig(\n", + " lora_alpha=LORA_ALPHA,\n", + " lora_dropout=LORA_DROPOUT,\n", + " r=LORA_R,\n", + " bias=\"none\",\n", + " task_type=\"CAUSAL_LM\",\n", + " target_modules=LORA_TARGET_MODULES.split(\",\"),\n", + ")\n", + "\n", + "model = get_peft_model(model, peft_config)\n", + "model.print_trainable_parameters()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tHe7AElXzXVV" + }, + "source": [ + "Gördüğünüz gibi LoRA tekniğini uyguladığımızda artık parametrelerin %1'inden daha azını eğitmemiz gerekecek." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "T_CqVydc40IM" + }, + "source": [ + "## Modelin Eğitilmesi" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Q_iN2khjrbD3" + }, + "source": [ + "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.\n", + "\n", + "Bir `Trainer` objesi oluşturmak için, eğitim konfigürasyonu tanımlamamız gerekiyor. En önemlisi, eğitimi yapılandırmak için tüm öznitelikleri içeren bir sınıf olan `TrainingArguments`'tır.\n", + "\n", + "Bunlar, çalıştırabileceğiniz diğer tüm model eğitimlerine benziyor, bu nedenle burada ayrıntılara girmeyeceğiz." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "65QHS8l1tKQe" + }, + "outputs": [], + "source": [ + "train_data.start_iteration = 0\n", + "\n", + "\n", + "training_args = TrainingArguments(\n", + " output_dir=f\"Your_HF_username/{OUTPUT_DIR}\",\n", + " dataloader_drop_last=True,\n", + " evaluation_strategy=\"steps\",\n", + " save_strategy=\"steps\",\n", + " max_steps=MAX_STEPS,\n", + " eval_steps=EVAL_FREQ,\n", + " save_steps=SAVE_FREQ,\n", + " logging_steps=LOG_FREQ,\n", + " per_device_train_batch_size=BATCH_SIZE,\n", + " per_device_eval_batch_size=BATCH_SIZE,\n", + " learning_rate=LR,\n", + " lr_scheduler_type=LR_SCHEDULER_TYPE,\n", + " warmup_steps=NUM_WARMUP_STEPS,\n", + " gradient_accumulation_steps=GR_ACC_STEPS,\n", + " gradient_checkpointing=True,\n", + " fp16=FP16,\n", + " bf16=BF16,\n", + " weight_decay=WEIGHT_DECAY,\n", + " push_to_hub=True,\n", + " include_tokens_per_second=True,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kB_fLRex09ut" + }, + "source": [ + "Son adım olarak `Trainer` objesini oluşturun ve `train` metodunu çağırın." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "rS3nVwhUC69O", + "outputId": "61a5bdb2-b7d0-4aed-8290-4bf20c2ccd38" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training...\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " [2000/2000 4:16:10, Epoch 1/9223372036854775807]\n", + "
\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
StepTraining LossValidation Loss
1005.5246007.456872
2005.6178007.262190
3005.1291006.410039
4005.0522006.306774
5005.2029006.117062
6004.6541006.018349
7005.1002006.000355
8005.0498005.889457
9004.5412005.813823
10005.0007005.834208
11005.0265005.781939
12004.4118005.720596
13004.7825005.736376
14004.9802005.712276
15004.3687005.689637
16004.8847005.675920
17004.9144005.662421
18004.2487005.660122
19004.7984005.664026
20004.7042005.655665

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "TrainOutput(global_step=2000, training_loss=4.885598585128784, metrics={'train_runtime': 15380.3075, 'train_samples_per_second': 2.081, 'train_steps_per_second': 0.13, 'train_tokens_per_second': 4261.033, 'total_flos': 4.0317260660736e+17, 'train_loss': 4.885598585128784, 'epoch': 1.0})" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "trainer = Trainer(\n", + " model=model, args=training_args, train_dataset=train_dataset, eval_dataset=eval_dataset\n", + ")\n", + "\n", + "print(\"Training...\")\n", + "trainer.train()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aAERlCnt1PEW" + }, + "source": [ + "Fine-tune edilmiş modelinizi Hugging Face Hub hesabınıza yükleyebilirsiniz." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "1h7_AUTTDwE1" + }, + "outputs": [], + "source": [ + "trainer.push_to_hub()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KBVH7uFOM_UF" + }, + "source": [ + "## Inference\n", + "\n", + "Model Hub'a yüklendikten sonra, inference için kullanabiliriz. Bunu yapmak için önce orijinal temel modeli ve onun tokenizer'ını başlatırız. Sonra, fine-tune edilmiş ağırlıkları temel modelle birleştirmemiz gerekir." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "jtL37piINBFe" + }, + "outputs": [], + "source": [ + "from peft import PeftModel\n", + "import torch\n", + "\n", + "# önce orijinal modeli yükleyin\n", + "tokenizer = AutoTokenizer.from_pretrained(MODEL, trust_remote_code=True)\n", + "base_model = AutoModelForCausalLM.from_pretrained(\n", + " MODEL,\n", + " quantization_config=None,\n", + " device_map=None,\n", + " trust_remote_code=True,\n", + " torch_dtype=torch.bfloat16,\n", + ").cuda()\n", + "\n", + "# fine-tune edilmiş ağırlıkları orijinal model ile birleştirin\n", + "peft_model_id = f\"Your_HF_username/{OUTPUT_DIR}\"\n", + "model = PeftModel.from_pretrained(base_model, peft_model_id)\n", + "model.merge_and_unload()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3USQ2suvDi9M" + }, + "source": [ + "Şimdi inference için birleştirilmiş modeli kullanabiliriz. Kolaylık olması açısından, bir `get_code_completion` tanımlayacağız - metin oluşturma parametreleriyle deneme yapmaktan çekinmeyin :)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "RoTGpNbjDeWI" + }, + "outputs": [], + "source": [ + "def get_code_completion(prefix, suffix):\n", + " text = prompt = f\"\"\"{prefix}{suffix}\"\"\"\n", + " model.eval()\n", + " outputs = model.generate(\n", + " input_ids=tokenizer(text, return_tensors=\"pt\").input_ids.cuda(),\n", + " max_new_tokens=128,\n", + " temperature=0.2,\n", + " top_k=50,\n", + " top_p=0.95,\n", + " do_sample=True,\n", + " repetition_penalty=1.0,\n", + " )\n", + " return tokenizer.batch_decode(outputs, skip_special_tokens=True)[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0kMJiGDfDrBf" + }, + "source": [ + "Şimdi kod tamamlanmasını sağlamak için yapmamız gereken tek şey `get_code_complete` fonksiyonunu çağırmak ve tamamlanmasını istediğimiz ilk birkaç satırı önek olarak, boş bir dizeyi de sonek olarak geçirmek." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nXlco2_-YcvM", + "outputId": "41c411ad-b7dc-4277-f975-c173888234bb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "from peft import LoraConfig, TaskType, get_peft_model\n", + "from transformers import AutoModelForCausalLM\n", + "peft_config = LoraConfig(\n", + " task_type=TaskType.CAUSAL_LM,\n", + " r=8,\n", + " lora_alpha=32,\n", + " target_modules=[\"q_proj\", \"v_proj\"],\n", + " lora_dropout=0.1,\n", + " bias=\"none\",\n", + " modules_to_save=[\"q_proj\", \"v_proj\"],\n", + " inference_mode=False,\n", + ")\n", + "model = AutoModelForCausalLM.from_pretrained(\"gpt2\")\n", + "model = get_peft_model(model, peft_config)\n", + "model.print_trainable_parameters()\n" + ] + } + ], + "source": [ + "prefix = \"\"\"from peft import LoraConfig, TaskType, get_peft_model\n", + "from transformers import AutoModelForCausalLM\n", + "peft_config = LoraConfig(\n", + "\"\"\"\n", + "suffix =\"\"\"\"\"\"\n", + "\n", + "print(get_code_completion(prefix, suffix))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ql2563kGlnmu" + }, + "source": [ + "Bu not defterinde daha önce PEFT kütüphanesini kullanmış biri olarak, `LoraConfig` oluşturmak için üretilen sonucun oldukça iyi olduğunu görebilirsiniz!\n", + "\n", + "Inference için modeli çağırdığımız hücreye geri dönerseniz ve fine-tune edilmiş ağırlıkları birleştirdiğimiz satırları yorum satırına eklerseniz, orijinal modelin tam olarak aynı önek için ne üreteceğini görebilirsiniz:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "29xxp1eHTgJ9", + "outputId": "c6d597a2-01da-4d25-a32f-3a551212c5b4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "from peft import LoraConfig, TaskType, get_peft_model\n", + "from transformers import AutoModelForCausalLM\n", + "peft_config = LoraConfig(\n", + " model_name_or_path=\"facebook/wav2vec2-base-960h\",\n", + " num_labels=1,\n", + " num_features=1,\n", + " num_hidden_layers=1,\n", + " num_attention_heads=1,\n", + " num_hidden_layers_per_attention_head=1,\n", + " num_attention_heads_per_hidden_layer=1,\n", + " hidden_size=1024,\n", + " hidden_dropout_prob=0.1,\n", + " hidden_act=\"gelu\",\n", + " hidden_act_dropout_prob=0.1,\n", + " hidden\n" + ] + } + ], + "source": [ + "prefix = \"\"\"from peft import LoraConfig, TaskType, get_peft_model\n", + "from transformers import AutoModelForCausalLM\n", + "peft_config = LoraConfig(\n", + "\"\"\"\n", + "suffix =\"\"\"\"\"\"\n", + "\n", + "print(get_code_completion(prefix, suffix))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Pwy2ZC7U8Ema" + }, + "source": [ + "Python syntax'ı olmasına rağmen, orijinal modelin `LoraConfig`'in ne yapması gerektiği konusunda hiçbir anlayışının olmadığını görebilirsiniz." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CATYE8pp2drQ" + }, + "source": [ + "Bu tür fine-tune'ların tam bir fine-tune ile nasıl karşılaştırıldığını ve bu tür bir modeli VS Code'da Inference Endpoints veya yerel olarak co-pilot olarak nasıl kullanacağınızı öğrenmek için [\"Personal Copilot: Train Your Own Coding Assistant\" blog yazısına](https://huggingface.co/blog/personal-copilot) göz atın. Bu not defteri orijinal blog yazısını tamamlar." + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "gpuType": "A100", + "machine_shape": "hm", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 1c3f1973774b33023808bd5302aa9c6b5ff25def Mon Sep 17 00:00:00 2001 From: Emre Albayrak <70805503+emre570@users.noreply.github.com> Date: Sun, 27 Oct 2024 13:21:15 +0300 Subject: [PATCH 2/5] Made changes Made changes from reviews and some small adjustments --- .../fine_tuning_code_llm_on_single_gpu.ipynb | 28 ++++++++++--------- 1 file changed, 15 insertions(+), 13 deletions(-) diff --git a/notebooks/tr-TR/fine_tuning_code_llm_on_single_gpu.ipynb b/notebooks/tr-TR/fine_tuning_code_llm_on_single_gpu.ipynb index 75cce586..9354df33 100644 --- a/notebooks/tr-TR/fine_tuning_code_llm_on_single_gpu.ipynb +++ b/notebooks/tr-TR/fine_tuning_code_llm_on_single_gpu.ipynb @@ -10,19 +10,19 @@ "\n", "_[Maria Khalusova](https://github.com/MKhalusova) tarafından hazırlanmıştır._\n", "\n", - "Codex, StarCoder ve Code Llama gibi açık kaynak dil modelleri genel programlama ilkelerine ve sözdizimine uygun kod üretme konusunda harikadır, ancak bir kuruluşun dahili kurallarıyla uyumlu olmayabilir veya özel kütüphanelerden haberdar olmayabilir.\n", + "Codex, StarCoder ve Code Llama gibi açık kaynak dil modelleri genel programlama ilkelerine ve sözdizimine uygun kod üretme konusunda harikadırlar. Fakat bu modeller, bir kuruluşun dahili kurallarıyla uyumlu olmayabilir veya özel kütüphanelerden haberdar olmayabilir.\n", "\n", - "Bu not defterinde, bir modelin bağlamsal farkındalığını artırmak ve kuruluşunuzun ihtiyaçları için kullanılabilirliğini artırmak amacıyla özel kod tabanlarında bir kod dil modeline nasıl ince ayar yapabileceğinizi göstereceğiz. Kod dil modelleri oldukça büyük olduğundan, geleneksel bir şekilde ince ayar yapmak kaynakları tüketebilir. Endişelenmeyin! Fine-tune işlemini tek bir GPU'ya sığacak şekilde nasıl optimize edebileceğinizi göstereceğiz.\n", + "Bu notebook'ta, bir modelin bağlamsal farkındalığını artırmak ve kuruluşunuzun ihtiyaçları için kullanılabilirliğini artırmak amacıyla özel kod tabanlarında bir kod dil modeline nasıl fine-tune yapabileceğinizi göstereceğiz. Kod dil modelleri oldukça büyük olduğundan, geleneksel bir şekilde fine-tune yapmak kaynakları tüketebilir. Endişelenmeyin! Fine-tune işlemini tek bir GPU'ya sığacak şekilde nasıl optimize edebileceğinizi göstereceğiz.\n", "\n", "\n", "## Veri Seti\n", "\n", - "Bu örnek için GitHub'daki en iyi 10 Hugging Face public repo'larını seçtik. Görseller, ses dosyaları, sunumlar gibi kod içermeyen dosyaları verilerden hariç tuttuk. Jupyter not defterleri için yalnızca kod içeren hücreleri tuttuk. Ortaya çıkan kod, Hugging Face Hub'da [`smangrul/hf-stack-v1`](https://huggingface.co/datasets/smangrul/hf-stack-v1) bağlantısı altında bulabileceğiniz bir veri seti olarak saklanıyor. Bu veri seti repo'nun kimliğini, dosya yolunu ve dosya içeriğini içeriyor.\n", + "Bu örnek için GitHub'daki en iyi 10 Hugging Face public repo'larını seçtik. Görseller, ses dosyaları, sunumlar gibi kod içermeyen dosyaları verilerden hariç tuttuk. Jupyter notebook'lar için yalnızca kod içeren hücreleri tuttuk. Ortaya çıkan kod, Hugging Face Hub'da [`smangrul/hf-stack-v1`](https://huggingface.co/datasets/smangrul/hf-stack-v1) bağlantısı altında bulabileceğiniz bir veri seti olarak mevcut. Bu veri seti repo'nun kimliğini, dosya yolunu ve dosya içeriğini içeriyor.\n", "\n", "\n", "## Model\n", "\n", - "Bu rehberde 1 milyar parametreli ve 80'den fazla programlama dilinde eğitilmiş [`bigcode/starcoderbase-1b`](https://huggingface.co/bigcode/starcoderbase-1b) modelini seçiyoruz. Bu model yayıncı tarafından korumaya sahip, bu nedenle bu not defterini tam olarak bu modelle çalıştırmayı planlıyorsanız, modelin sayfasından erişim sağlamanız gerekir. Erişim izninizi aldıktan sonra, Hugging Face hesabınıza giriş yapın.\n", + "Bu rehber için 1 milyar parametreli ve 80'den fazla programlama dilinde eğitilmiş [`bigcode/starcoderbase-1b`](https://huggingface.co/bigcode/starcoderbase-1b) modelini seçiyoruz. Bu model, yayıncı tarafından korumaya sahip, bu nedenle bu notebook'u tam olarak bu modelle çalıştırmayı planlıyorsanız, modelin sayfasından erişim sağlamanız gerekir. Erişim izninizi aldıktan sonra, Hugging Face hesabınıza giriş yapın.\n", "\n", "**Not:** Eğer fine-tune edilmiş modelinizi Hugging Face Hub'a yüklemek istiyorsanız, `write` izni olan bir token girmeniz gerekli." ] @@ -48,7 +48,7 @@ "source": [ "Başlamak için gerekli tüm kütüphaneleri yükleyelim. Gördüğünüz gibi, `transformers` ve `datasets` kütüphanelerine ek olarak, eğitimi optimize etmek için `peft`, `bitsandbytes` ve `flash-attn` kullanacağız.\n", "\n", - "Parametre açısından verimli eğitim teknikleri kullanarak, bu dizüstü bilgisayarı tek bir A100 High-RAM GPU üzerinde çalıştırabiliriz." + "Parametre açısından verimli eğitim teknikleri kullanarak, bu notebook'u tek bir A100 High-RAM GPU üzerinde çalıştırabiliriz." ] }, { @@ -68,7 +68,7 @@ "id": "16EdABzt3_Ig" }, "source": [ - "Şimdi biraz değişken tanımlayalım. Değerlerini istediğiniz gibi değiştirebilirsiniz." + "Şimdi biraz hiperparametre tanımlayalım. Değerlerini istediğiniz gibi değiştirebilirsiniz." ] }, { @@ -153,7 +153,9 @@ "id": "1LmrIZqP0oUE" }, "source": [ - "Verileri yükleyerek başlayalım. Veri setinin oldukça büyük olması muhtemel olduğundan, streaming modunu etkinleştirdiğinizden emin olun. Streaming, tüm veri setini bir kerede indirmek yerine veri seti üzerinde işlem yaptıkça verileri kademeli olarak yüklememizi sağlar.\n", + "Verileri yükleyerek başlayalım. Veri setinin oldukça büyük olması muhtemel olduğundan, streaming modunu etkinleştirdiğinizden emin olun. \n", + "\n", + "Streaming modu, tüm veri setini bir kerede indirmek yerine veri seti üzerinde işlem yaptıkça verileri kademeli olarak yüklememizi sağlar.\n", "\n", "İlk 4000 örneği validation set (doğrulama kümesi) olarak ayıracağız ve geri kalan her şey eğitim verisi olacak." ] @@ -191,7 +193,7 @@ "source": [ "Bu adımda, veri seti hala isteğe bağlı uzunlukta kod içeren ham veriler içeriyor. Eğitim için sabit uzunlukta girdilere ihtiyacımız var. Bir metin dosyası akışından (stream) sabit uzunlukta token yığınları döndürecek bir Iterable veri kümesi oluşturalım.\n", "\n", - "İlk olarak, veri setindeki token başına ortalama karakter sayısını tahmin edelim, bu daha sonra text buffer'daki 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, hesaplama maliyetini düşürürken, genel karakter-token oranının makul bir tahminini sağlayacaktır." + "İlk olarak, veri setindeki token başına ortalama karakter sayısını tahmin edelim, bu daha sonra text buffer'daki token sayısını tahmin etmemize yardımcı olacaktır. Varsayılan olarak, veri setinden yalnızca 400 örnek (`nb_examples`) alacağız. Tüm veri setinin yalnızca bir alt kümesini kullanmak, hesaplama maliyetini düşürürken, genel karakter-token oranının makul bir tahminini sağlayacaktır." ] }, { @@ -375,9 +377,9 @@ "id": "AwW5FviD9xBH" }, "source": [ - "Sabit uzunlukta token yığınları döndürecek bir Iterable veri seti olan `ConstantLengthDataset`i tanımlayalım. Bunu yapmak için, boyut sınırlarına ulaşana kadar orijinal veri setinden bir buffer metin okuyacağız ve ardından ham metni tokenize edilmiş girdilere dönüştürmek için tokenizer uygulayacağız. İsteğe bağlı olarak, bazı diziler üzerinde FIM dönüşümleri gerçekleştireceğiz (etkilenen dizilerin oranı `fim_rate` tarafından kontrol edilir).\n", + "Sabit uzunlukta token yığınları döndürecek bir Iterable veri seti olan `ConstantLengthDataset`'i tanımlayalım. Bunu yapmak için, boyut sınırlarına ulaşana kadar orijinal veri setinden bir buffer metin okuyacağız ve ardından ham metni tokenize edilmiş girdilere dönüştürmek için tokenizer uygulayacağız. İsteğe bağlı olarak, bazı diziler üzerinde FIM dönüşümleri gerçekleştireceğiz (etkilenen dizilerin oranı `fim_rate` tarafından kontrol edilir).\n", "\n", - "Tanımlandıktan sonra, hem eğitim hem de validation verilerinden `ConstantLengthDataset` örnekleri oluşturabiliriz." + "Tanımlandıktan sonra, hem eğitim hem de doğrulama verilerinden `ConstantLengthDataset` örnekleri oluşturabiliriz." ] }, { @@ -544,7 +546,7 @@ "\n", "Niceleme hakkında daha fazla bilgi edinmek için [“Making LLMs even more accessible with bitsandbytes, 4-bit quantization and QLoRA” blog post](https://huggingface.co/blog/4bit-transformers-bitsandbytes) adresine göz atın.\n", "\n", - "Tanımlandıktan sonra, modelin kuantize edilmiş versiyonunu yüklemek için yapılandırmayı `from_pretrained` yöntemine aktarın." + "Tanımlandıktan sonra, modelin kuantize edilmiş versiyonunu yüklemek için yapılandırmayı `from_pretrained` metoduna aktarın." ] }, { @@ -1040,7 +1042,7 @@ "id": "Ql2563kGlnmu" }, "source": [ - "Bu not defterinde daha önce PEFT kütüphanesini kullanmış biri olarak, `LoraConfig` oluşturmak için üretilen sonucun oldukça iyi olduğunu görebilirsiniz!\n", + "Bu notebook'ta daha önce PEFT kütüphanesini kullanmış biri olarak, `LoraConfig` oluşturmak için üretilen sonucun oldukça iyi olduğunu görebilirsiniz!\n", "\n", "Inference için modeli çağırdığımız hücreye geri dönerseniz ve fine-tune edilmiş ağırlıkları birleştirdiğimiz satırları yorum satırına eklerseniz, orijinal modelin tam olarak aynı önek için ne üreteceğini görebilirsiniz:" ] @@ -1103,7 +1105,7 @@ "id": "CATYE8pp2drQ" }, "source": [ - "Bu tür fine-tune'ların tam bir fine-tune ile nasıl karşılaştırıldığını ve bu tür bir modeli VS Code'da Inference Endpoints veya yerel olarak co-pilot olarak nasıl kullanacağınızı öğrenmek için [\"Personal Copilot: Train Your Own Coding Assistant\" blog yazısına](https://huggingface.co/blog/personal-copilot) göz atın. Bu not defteri orijinal blog yazısını tamamlar." + "Bu tür fine-tune'ların tam bir fine-tune ile nasıl karşılaştırıldığını ve bu tür bir modeli VS Code'da Inference Endpoints veya yerel olarak co-pilot olarak nasıl kullanacağınızı öğrenmek için [\"Personal Copilot: Train Your Own Coding Assistant\" blog yazısına](https://huggingface.co/blog/personal-copilot) göz atın. Bu notebook orijinal blog yazısını tamamlar." ] } ], From fd2b71eb9fc7edf6e319c1d117a8456b5b0168c1 Mon Sep 17 00:00:00 2001 From: Cemal Emre Albayrak <70805503+emre570@users.noreply.github.com> Date: Sun, 27 Oct 2024 22:22:23 +0300 Subject: [PATCH 3/5] Edited toctree and file naming --- notebooks/{tr-TR => tr}/_toctree.yml | 0 .../{tr-TR => tr}/fine_tuning_code_llm_on_single_gpu.ipynb | 4 +++- 2 files changed, 3 insertions(+), 1 deletion(-) rename notebooks/{tr-TR => tr}/_toctree.yml (100%) rename notebooks/{tr-TR => tr}/fine_tuning_code_llm_on_single_gpu.ipynb (99%) diff --git a/notebooks/tr-TR/_toctree.yml b/notebooks/tr/_toctree.yml similarity index 100% rename from notebooks/tr-TR/_toctree.yml rename to notebooks/tr/_toctree.yml diff --git a/notebooks/tr-TR/fine_tuning_code_llm_on_single_gpu.ipynb b/notebooks/tr/fine_tuning_code_llm_on_single_gpu.ipynb similarity index 99% rename from notebooks/tr-TR/fine_tuning_code_llm_on_single_gpu.ipynb rename to notebooks/tr/fine_tuning_code_llm_on_single_gpu.ipynb index 9354df33..8987c979 100644 --- a/notebooks/tr-TR/fine_tuning_code_llm_on_single_gpu.ipynb +++ b/notebooks/tr/fine_tuning_code_llm_on_single_gpu.ipynb @@ -8,7 +8,9 @@ "source": [ "# Kod Dil Modelini Tek GPU'da Fine-Tune Etmek\n", "\n", - "_[Maria Khalusova](https://github.com/MKhalusova) tarafından hazırlanmıştır._\n", + "_Yazar: [Maria Khalusova](https://github.com/MKhalusova)_\n", + "\n", + "_Çeviren: [Emre Albayrak](https://github.com/emre570)_\n", "\n", "Codex, StarCoder ve Code Llama gibi açık kaynak dil modelleri genel programlama ilkelerine ve sözdizimine uygun kod üretme konusunda harikadırlar. Fakat bu modeller, bir kuruluşun dahili kurallarıyla uyumlu olmayabilir veya özel kütüphanelerden haberdar olmayabilir.\n", "\n", From 672b4ba11447a1222454ca6270e1445eef7ed05e Mon Sep 17 00:00:00 2001 From: Cemal Emre Albayrak <70805503+emre570@users.noreply.github.com> Date: Sun, 27 Oct 2024 23:02:30 +0300 Subject: [PATCH 4/5] More changes --- notebooks/tr/fine_tuning_code_llm_on_single_gpu.ipynb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/notebooks/tr/fine_tuning_code_llm_on_single_gpu.ipynb b/notebooks/tr/fine_tuning_code_llm_on_single_gpu.ipynb index 8987c979..3340b34b 100644 --- a/notebooks/tr/fine_tuning_code_llm_on_single_gpu.ipynb +++ b/notebooks/tr/fine_tuning_code_llm_on_single_gpu.ipynb @@ -924,7 +924,7 @@ "source": [ "## Inference\n", "\n", - "Model Hub'a yüklendikten sonra, inference için kullanabiliriz. Bunu yapmak için önce orijinal temel modeli ve onun tokenizer'ını başlatırız. Sonra, fine-tune edilmiş ağırlıkları temel modelle birleştirmemiz gerekir." + "Model Hub'a yüklendikten sonra, inference için kullanılabilir. Bunu yapmak için önce orijinal temel modeli ve onun tokenizer'ını başlatırız. Sonra, fine-tune edilmiş ağırlıkları temel modelle birleştirmemiz gerekir." ] }, { @@ -992,7 +992,7 @@ "id": "0kMJiGDfDrBf" }, "source": [ - "Şimdi kod tamamlanmasını sağlamak için yapmamız gereken tek şey `get_code_complete` fonksiyonunu çağırmak ve tamamlanmasını istediğimiz ilk birkaç satırı önek olarak, boş bir dizeyi de sonek olarak geçirmek." + "Şimdi, kodun tamamlanmasını sağlamak için yapmamız gereken tek şey `get_code_complete` fonksiyonunu çağırmak ve tamamlanmasını istediğimiz ilk birkaç satırı önek olarak, boş bir dizeyi de sonek olarak geçirmek." ] }, { @@ -1046,7 +1046,7 @@ "source": [ "Bu notebook'ta daha önce PEFT kütüphanesini kullanmış biri olarak, `LoraConfig` oluşturmak için üretilen sonucun oldukça iyi olduğunu görebilirsiniz!\n", "\n", - "Inference için modeli çağırdığımız hücreye geri dönerseniz ve fine-tune edilmiş ağırlıkları birleştirdiğimiz satırları yorum satırına eklerseniz, orijinal modelin tam olarak aynı önek için ne üreteceğini görebilirsiniz:" + "Modeli inference için başlattığımız hücreye geri dönersek ve fine-tune edilmiş ağırlıkları birleştirdiğimiz satırları yorum satırı yaparsak, orijinal modelin tam olarak aynı önek için ne üreteceğini görebilirsiniz:" ] }, { From 54d74e1d8bcda653dbd83182b9c5fde2bb57efb5 Mon Sep 17 00:00:00 2001 From: Cemal Emre Albayrak <70805503+emre570@users.noreply.github.com> Date: Sun, 27 Oct 2024 23:12:56 +0300 Subject: [PATCH 5/5] Update _toctree.yml --- notebooks/tr/_toctree.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/notebooks/tr/_toctree.yml b/notebooks/tr/_toctree.yml index d7fc4d8b..119c5b06 100644 --- a/notebooks/tr/_toctree.yml +++ b/notebooks/tr/_toctree.yml @@ -5,6 +5,12 @@ - local: index title: Genel Bakış + - title: LLM Tarifleri + isExpanded: false + sections: + - local: fine_tuning_code_llm_on_single_gpu + title: Kod Dil Modelini Tek GPU'da Fine-Tune Etmek + - title: Bilgisayarlı Görü Uygulamaları isExpanded: false sections: