1_t5_small_single_gpu/1. T5-Small on Single GPU.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "2c11dcf5-8a18-49c6-8047-f8a78fc70d74",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "# Introduction\n",
    "\n",
    "LLM fine-tuning almost always requires multiple GPUs to be useful or to be possible at all. But if you're relatively new to deep learning, or you've only trained models on single GPUs before, making the jump to distributed training on multiple GPUs and multiple nodes can be extremely challenging and more than a little frustrating.\n",
    "\n",
    "We're starting with a very small model [t5-small](https://huggingface.co/t5-small) for a few reasons:\n",
    "- Learning about model fine-tuning is a lot less frustrating if you start from a place of less complexity and are able to get results quickly!\n",
    "- When we get to the point of training larger models on distributed systems, we're going to spend a lot of time and energy on *how* to distribute the model, data, etc., across that system. Starting smaller lets us spend some time at the beginning focusing on the training metrics that directly relate to model performance rather than the complexity involved with distributed training. Eventually we will need both, but there's no reason to try to digest all of it all at once!\n",
    "- Starting small and then scaling up will give us a solid intuition of how, when, and why to use the various tools and techniques for training larger models or for using more compute resources to train models faster.\n",
    "\n",
    "## Fine-Tuning t5-small\n",
    "Our goals in this notebook are simple. We want to fine-tune the t5-small model and verify that its behavior has changed as a result of our fine-tuning.\n",
    "\n",
    "The [t5 (text-to-text transfer transformer) family of models](https://blog.research.google/2020/02/exploring-transfer-learning-with-t5.html) was developed by Google Research. It was presented as an advancement over BERT-style models which could output only a class label or a span of the input. t5 allows the same model, loss, and hyperparameters to be used for *any* nlp task. t5 differs from GPT models because it is an encoder-decoder model, while GPT models are decoder-only models.\n",
    "\n",
    "t5-small is a 60 million parameter model. This is *small*: the smallest version of GPT2 has more than twice as many parameters (124M); llama2-7b, one of the most commonly-used models at the time of writing, has more than 116 times as many parameters (7B, hence the name). What does this mean for us? Parameter count strongly impacts the amount of memory required to train a model. Eleuther's [Transformer Math blog post](https://blog.eleuther.ai/transformer-math/#training) has a great overview of the memory costs associated with training models of different sizes. We'll get into this in more detail in a later notebook.\n",
    "\n",
    "## A few things to keep in mind\n",
    "Check out the [Readme](README.md) if you haven't already, as it provides important context for this whole project. If you're looking for a set of absolute best practices for how to train particular models, this isn't the place to find them (though I will link them when I come across them, and will try to make improvements where I can, as long as they don't come at the cost of extra complexity!). The goal is to develop a high-level understanding and intuition on model training and fine-tuning, so you can fairly quickly get to something that *works* and then iterate to make it work *better*.\n",
    "\n",
    "## Compute used in this example\n",
    "I am using a g4dn.4xlarge AWS ec2 instance, which has a single T4 GPU with 16GB VRAM.\n",
    "\n",
    "# 1. Get the model and try some examples\n",
    "Before training the model, it helps to have some sense of its base behavior. Let's take a look. See appendix C of the [t5 paper](https://jmlr.org/papers/volume21/20-074/20-074.pdf) for examples of how to format inputs for various tasks."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "c54649ba-e0cb-4f64-a10b-dd509fc16976",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[43mNote: you may need to restart the kernel using dbutils.library.restartPython() to use updated packages.\u001b[0m\n",
      "Requirement already satisfied: transformers in /databricks/python3/lib/python3.10/site-packages (4.34.0)\n",
      "Collecting transformers\n",
      "  Downloading transformers-4.35.2-py3-none-any.whl (7.9 MB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 7.9/7.9 MB 21.9 MB/s eta 0:00:00\n",
      "Requirement already satisfied: torch in /databricks/python3/lib/python3.10/site-packages (2.0.1+cu118)\n",
      "Collecting torch\n",
      "  Downloading torch-2.1.1-cp310-cp310-manylinux1_x86_64.whl (670.2 MB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 670.2/670.2 MB 1.9 MB/s eta 0:00:00\n",
      "Requirement already satisfied: accelerate in /databricks/python3/lib/python3.10/site-packages (0.23.0)\n",
      "Collecting accelerate\n",
      "  Downloading accelerate-0.25.0-py3-none-any.whl (265 kB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 265.7/265.7 kB 31.9 MB/s eta 0:00:00\n",
      "Requirement already satisfied: packaging>=20.0 in /databricks/python3/lib/python3.10/site-packages (from transformers) (22.0)\n",
      "Requirement already satisfied: huggingface-hub<1.0,>=0.16.4 in /databricks/python3/lib/python3.10/site-packages (from transformers) (0.16.4)\n",
      "Requirement already satisfied: filelock in /databricks/python3/lib/python3.10/site-packages (from transformers) (3.9.0)\n",
      "Requirement already satisfied: requests in /databricks/python3/lib/python3.10/site-packages (from transformers) (2.28.1)\n",
      "Requirement already satisfied: regex!=2019.12.17 in /databricks/python3/lib/python3.10/site-packages (from transformers) (2022.7.9)\n",
      "Requirement already satisfied: tqdm>=4.27 in /databricks/python3/lib/python3.10/site-packages (from transformers) (4.64.1)\n",
      "Requirement already satisfied: tokenizers<0.19,>=0.14 in /databricks/python3/lib/python3.10/site-packages (from transformers) (0.14.0)\n",
      "Requirement already satisfied: pyyaml>=5.1 in /databricks/python3/lib/python3.10/site-packages (from transformers) (6.0)\n",
      "Requirement already satisfied: safetensors>=0.3.1 in /databricks/python3/lib/python3.10/site-packages (from transformers) (0.4.0)\n",
      "Requirement already satisfied: numpy>=1.17 in /databricks/python3/lib/python3.10/site-packages (from transformers) (1.23.5)\n",
      "Requirement already satisfied: networkx in /databricks/python3/lib/python3.10/site-packages (from torch) (2.8.4)\n",
      "Collecting nvidia-nccl-cu12==2.18.1\n",
      "  Downloading nvidia_nccl_cu12-2.18.1-py3-none-manylinux1_x86_64.whl (209.8 MB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 209.8/209.8 MB 3.4 MB/s eta 0:00:00\n",
      "Collecting nvidia-curand-cu12==10.3.2.106\n",
      "  Downloading nvidia_curand_cu12-10.3.2.106-py3-none-manylinux1_x86_64.whl (56.5 MB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 56.5/56.5 MB 10.8 MB/s eta 0:00:00\n",
      "Requirement already satisfied: jinja2 in /databricks/python3/lib/python3.10/site-packages (from torch) (3.1.2)\n",
      "Collecting nvidia-cuda-nvrtc-cu12==12.1.105\n",
      "  Downloading nvidia_cuda_nvrtc_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (23.7 MB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 23.7/23.7 MB 21.3 MB/s eta 0:00:00\n",
      "Requirement already satisfied: fsspec in /databricks/python3/lib/python3.10/site-packages (from torch) (2023.6.0)\n",
      "Collecting nvidia-cudnn-cu12==8.9.2.26\n",
      "  Downloading nvidia_cudnn_cu12-8.9.2.26-py3-none-manylinux1_x86_64.whl (731.7 MB)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-04 13:13:00.531046: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-12-04 13:13:00.531105: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-12-04 13:13:00.531127: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-12-04 13:13:00.538527: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 731.7/731.7 MB 1.8 MB/s eta 0:00:00\n",
      "Collecting nvidia-cusolver-cu12==11.4.5.107\n",
      "  Downloading nvidia_cusolver_cu12-11.4.5.107-py3-none-manylinux1_x86_64.whl (124.2 MB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 124.2/124.2 MB 19.2 MB/s eta 0:00:00\n",
      "Collecting triton==2.1.0\n",
      "  Downloading triton-2.1.0-0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl (89.2 MB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 89.2/89.2 MB 26.7 MB/s eta 0:00:00\n",
      "Requirement already satisfied: typing-extensions in /databricks/python3/lib/python3.10/site-packages (from torch) (4.4.0)\n",
      "Collecting nvidia-nvtx-cu12==12.1.105\n",
      "  Downloading nvidia_nvtx_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (99 kB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 99.1/99.1 kB 22.2 MB/s eta 0:00:00\n",
      "Collecting nvidia-cuda-cupti-cu12==12.1.105\n",
      "  Downloading nvidia_cuda_cupti_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (14.1 MB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 14.1/14.1 MB 91.7 MB/s eta 0:00:00\n",
      "Requirement already satisfied: sympy in /databricks/python3/lib/python3.10/site-packages (from torch) (1.11.1)\n",
      "Collecting nvidia-cufft-cu12==11.0.2.54\n",
      "  Downloading nvidia_cufft_cu12-11.0.2.54-py3-none-manylinux1_x86_64.whl (121.6 MB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 121.6/121.6 MB 20.4 MB/s eta 0:00:00\n",
      "Collecting nvidia-cusparse-cu12==12.1.0.106\n",
      "  Downloading nvidia_cusparse_cu12-12.1.0.106-py3-none-manylinux1_x86_64.whl (196.0 MB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 196.0/196.0 MB 11.9 MB/s eta 0:00:00\n",
      "Collecting nvidia-cublas-cu12==12.1.3.1\n",
      "  Downloading nvidia_cublas_cu12-12.1.3.1-py3-none-manylinux1_x86_64.whl (410.6 MB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 410.6/410.6 MB 3.6 MB/s eta 0:00:00\n",
      "Collecting nvidia-cuda-runtime-cu12==12.1.105\n",
      "  Downloading nvidia_cuda_runtime_cu12-12.1.105-py3-none-manylinux1_x86_64.whl (823 kB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 823.6/823.6 kB 62.9 MB/s eta 0:00:00\n",
      "Collecting nvidia-nvjitlink-cu12\n",
      "  Downloading nvidia_nvjitlink_cu12-12.3.101-py3-none-manylinux1_x86_64.whl (20.5 MB)\n",
      "     ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 20.5/20.5 MB 83.3 MB/s eta 0:00:00\n",
      "Requirement already satisfied: psutil in /databricks/python3/lib/python3.10/site-packages (from accelerate) (5.9.0)\n",
      "Requirement already satisfied: MarkupSafe>=2.0 in /databricks/python3/lib/python3.10/site-packages (from jinja2->torch) (2.1.1)\n",
      "Requirement already satisfied: certifi>=2017.4.17 in /databricks/python3/lib/python3.10/site-packages (from requests->transformers) (2022.12.7)\n",
      "Requirement already satisfied: urllib3<1.27,>=1.21.1 in /databricks/python3/lib/python3.10/site-packages (from requests->transformers) (1.26.14)\n",
      "Requirement already satisfied: charset-normalizer<3,>=2 in /databricks/python3/lib/python3.10/site-packages (from requests->transformers) (2.0.4)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /databricks/python3/lib/python3.10/site-packages (from requests->transformers) (3.4)\n",
      "Requirement already satisfied: mpmath>=0.19 in /databricks/python3/lib/python3.10/site-packages (from sympy->torch) (1.2.1)\n",
      "Installing collected packages: triton, nvidia-nvtx-cu12, nvidia-nvjitlink-cu12, nvidia-nccl-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, nvidia-cusparse-cu12, nvidia-cudnn-cu12, nvidia-cusolver-cu12, transformers, torch, accelerate\n",
      "  Attempting uninstall: triton\n",
      "    Found existing installation: triton 2.0.0\n",
      "    Not uninstalling triton at /databricks/python3/lib/python3.10/site-packages, outside environment /local_disk0/.ephemeral_nfs/envs/pythonEnv-c21882be-297c-4406-a663-9b859108fc42\n",
      "    Can't uninstall 'triton'. No files were found to uninstall.\n",
      "  Attempting uninstall: transformers\n",
      "    Found existing installation: transformers 4.34.0\n",
      "    Not uninstalling transformers at /databricks/python3/lib/python3.10/site-packages, outside environment /local_disk0/.ephemeral_nfs/envs/pythonEnv-c21882be-297c-4406-a663-9b859108fc42\n",
      "    Can't uninstall 'transformers'. No files were found to uninstall.\n",
      "  Attempting uninstall: torch\n",
      "    Found existing installation: torch 2.0.1+cu118\n",
      "    Not uninstalling torch at /databricks/python3/lib/python3.10/site-packages, outside environment /local_disk0/.ephemeral_nfs/envs/pythonEnv-c21882be-297c-4406-a663-9b859108fc42\n",
      "    Can't uninstall 'torch'. No files were found to uninstall.\n",
      "  Attempting uninstall: accelerate\n",
      "    Found existing installation: accelerate 0.23.0\n",
      "    Not uninstalling accelerate at /databricks/python3/lib/python3.10/site-packages, outside environment /local_disk0/.ephemeral_nfs/envs/pythonEnv-c21882be-297c-4406-a663-9b859108fc42\n",
      "    Can't uninstall 'accelerate'. No files were found to uninstall.\n",
      "ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
      "torchvision 0.15.2+cu118 requires torch==2.0.1, but you have torch 2.1.1 which is incompatible.\n",
      "Successfully installed accelerate-0.25.0 nvidia-cublas-cu12-12.1.3.1 nvidia-cuda-cupti-cu12-12.1.105 nvidia-cuda-nvrtc-cu12-12.1.105 nvidia-cuda-runtime-cu12-12.1.105 nvidia-cudnn-cu12-8.9.2.26 nvidia-cufft-cu12-11.0.2.54 nvidia-curand-cu12-10.3.2.106 nvidia-cusolver-cu12-11.4.5.107 nvidia-cusparse-cu12-12.1.0.106 nvidia-nccl-cu12-2.18.1 nvidia-nvjitlink-cu12-12.3.101 nvidia-nvtx-cu12-12.1.105 torch-2.1.1 transformers-4.35.2 triton-2.1.0\n",
      "\u001b[43mNote: you may need to restart the kernel using dbutils.library.restartPython() to use updated packages.\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "%pip install --upgrade transformers torch accelerate\n",
    "dbutils.library.restartPython()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "37ae82d9-587e-4f75-9b30-41f253e0fbbe",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-03 18:33:15.973761: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-12-03 18:33:15.973826: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-12-03 18:33:15.973849: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-12-03 18:33:15.981082: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MIT License\n"
     ]
    }
   ],
   "source": [
    "from transformers import AutoModelForSeq2SeqLM, AutoTokenizer\n",
    "import torch\n",
    "\n",
    "# Load model and tokenizer\n",
    "tokenizer = AutoTokenizer.from_pretrained(\"t5-small\")\n",
    "model = AutoModelForSeq2SeqLM.from_pretrained(\"t5-small\")\n",
    "\n",
    "# Check if GPU is available and move the model to GPU\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model = model.to(device)\n",
    "\n",
    "# Sample text\n",
    "# input_text = \"Translate English to German: The house is wonderful.\"\n",
    "input_text = (\n",
    "    \"question: What is the deepspeed license?  context: DeepSpeed \"\n",
    "    \"is an open source deep learning optimization library for PyTorch. \"\n",
    "    \"The library is designed to reduce computing power and memory use \"\n",
    "    \"and to train large distributed models with better parallelism on \"\n",
    "    \"existing computer hardware. DeepSpeed is optimized for low latency, \"\n",
    "    \"high throughput training. It includes the Zero Redundancy Optimizer \"\n",
    "    \"(ZeRO) for training models with 1 trillion or more parameters. \"\n",
    "    \"Features include mixed precision training, single-GPU, multi-GPU, \"\n",
    "    \"and multi-node training as well as custom model parallelism. The \"\n",
    "    \"DeepSpeed source code is licensed under MIT License and available on GitHub.\"\n",
    ")\n",
    "\n",
    "# Encode and generate response\n",
    "input_ids = tokenizer.encode(input_text, return_tensors=\"pt\").to(device)\n",
    "output_ids = model.generate(input_ids, max_new_tokens=20)[0]\n",
    "\n",
    "# Decode and print the output text\n",
    "output_text = tokenizer.decode(output_ids, skip_special_tokens=True)\n",
    "print(output_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "c46abb2d-7ea5-49b8-9277-ece228ecb165",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "# 2. Pick a Fine-Tuning Task\n",
    "\n",
    "We want to train the model to do something it's not already capable of. Let's see if we can get it to distinguish between a few different programming languages. Is it able to do this now?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "9fbdce04-5fe1-4d4c-bf30-f2522a2038f0",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "df - read.csv('data.csv'\n"
     ]
    }
   ],
   "source": [
    "input_text = \"question: what programming languauage is this?  code: `df <- read.csv('data.csv'); summary(df)`\"\n",
    "\n",
    "# Encode and generate response\n",
    "input_ids = tokenizer.encode(input_text, return_tensors=\"pt\").to(device)\n",
    "output_ids = model.generate(input_ids, max_new_tokens=20)[0]\n",
    "\n",
    "# Decode and print the output text\n",
    "output_text = tokenizer.decode(output_ids, skip_special_tokens=True)\n",
    "print(output_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "387cd971-5d73-4a12-a9cf-ab129f212a3c",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Based on the T5 paper, I couldn't identify a prompt that would elicit this behavior. Furthermore, When T5 was trained, code examples were apparently explicitly excluded. So let's see if we can add this capability.\n",
    "\n",
    "> Some pages inadvertently contained code. Since the curly bracket “{” appears in many programming languages (such as Javascript, widely used on the web) but not in natural text, we removed any pages that contained a curly bracket.\n",
    "\n",
    "We will use the [tiny-codes](https://huggingface.co/datasets/nampdn-ai/tiny-codes) dataset, which includes code snippets along with their corresponding language, as training data. Let's pull down the dataset and do a quick exploratory analysis. Then we will have to do some cleaning and prep to make the code usable for our purposes.\n",
    "\n",
    "# 3. Get and Explore the Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "f7efdd00-6e31-4f70-a818-bb3250ac37a2",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "850085a74f5b4cb0bd2db5bff0be35e0",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "VBox(children=(HTML(value='<center> <img\\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.sv…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from datasets import load_dataset\n",
    "from huggingface_hub import notebook_login\n",
    "# Login\n",
    "notebook_login()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "7d869ea4-90b4-4962-b780-520ba16fb45a",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/databricks/python_shell/dbruntime/huggingface_patches/datasets.py:27: UserWarning: This dataset can not be stored in DBFS because either `cache_dir` or the environment variable `HF_DATASETS_CACHE` is set to a non-DBFS path. If this cluster restarts, all saved dataset information will be lost.\n",
      "  warnings.warn(\n",
      "/databricks/python_shell/dbruntime/huggingface_patches/datasets.py:13: UserWarning: During large dataset downloads, there could be multiple progress bar widgets that can cause performance issues for your notebook or browser. To avoid these issues, use `datasets.utils.logging.disable_progress_bar()` to turn off the progress bars.\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rust                         136961\n",
      "Ruby                         136824\n",
      "JavaScript                   131014\n",
      "Julia                        129402\n",
      "Python                       129063\n",
      "TypeScript                   128653\n",
      "Go                           126016\n",
      "C#                           125478\n",
      "Java                         123994\n",
      "Bash                         122804\n",
      "C++                          120813\n",
      "Neo4j database and Cypher    117589\n",
      "relation database and SQL    103698\n",
      "Name: programming_language, dtype: int64\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Load the dataset\n",
    "tinycodes = load_dataset('nampdn-ai/tiny-codes')\n",
    "\n",
    "# Get the counts of the programming_language column\n",
    "language_counts = tinycodes['train'].to_pandas()['programming_language'].value_counts()\n",
    "\n",
    "# Print the counts\n",
    "print(language_counts)\n",
    "\n",
    "plt.figure(figsize=(10,4))\n",
    "plt.bar(language_counts.index, language_counts.values, alpha=0.8)\n",
    "plt.title('Programming Language Distribution')\n",
    "plt.ylabel('Number of Occurrences', fontsize=12)\n",
    "plt.xlabel('Programming Language', fontsize=12)\n",
    "plt.xticks(rotation=45, ha='right')  # Angle the x-axis labels to 45 degrees and align them to the right\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "df31d5ce-f264-4757-995b-1239a8f04bf3",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "There are no major imbalances and each of these languages has plenty of examples, so we're not going to do any rebalancing. Now let's take a look at what a given example looks like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "21523987-f15d-48a6-996d-b8aca82317a2",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'prompt': 'Develop a C# program snippet to Update Low Online Shopping: Product Availability for Analysis for Experts. Incorporate if/else or switch/case statements to handle various cases related to the Privacy. Dry-run, ensure your control flow logic is clear and well-commented.',\n",
       " 'main_topic': 'Online Shopping',\n",
       " 'subtopic': 'Product Availability',\n",
       " 'adjective': 'Low',\n",
       " 'action_verb': 'Update',\n",
       " 'scenario': 'for Analysis',\n",
       " 'target_audience': 'Experts',\n",
       " 'programming_language': 'C#',\n",
       " 'common_sense_topic': 'Privacy',\n",
       " 'idx': 780696,\n",
       " 'response': 'Here\\'s some sample code that demonstrates how to update low online shopping product availability for analysis by experts while incorporating `if`/`else` or `switch`/`case` statements to handle different privacy scenarios:\\n```c#\\n// Define variables\\nstring customerName = \"John Doe\";\\nbool isMinor = false;\\nDateTime birthDate = new DateTime(1980, 2, 5);\\n\\n// Check whether customer is underage based on their date of birth\\nif (birthDate > DateTime.Today.AddYears(-18))\\n{\\n    Console.WriteLine(\"Customer is not considered a minor\");\\n}\\nelse\\n{\\n    Console.WriteLine(\"Customer is considered a minor\");\\n    isMinor = true;\\n}\\n\\n// Prompt user to enter their ZIP code\\nConsole.Write(\"Enter ZIP code: \");\\nstring zipCode = Console.ReadLine();\\n\\n// Determine which privacy scenario applies based on ZIP code\\nif (zipCode == \"XXXXX\") // Scenario 1: Customer lives within the same state as the retailer\\n{\\n    Console.WriteLine($\"Updating {customerName}\\'s information with latest purchase history...\");\\n}\\nelse if (isMinor && zipCode != \"YYYYY\") //Scenario 2: Minor customer resides outside of the state where they made purchases\\n{\\n    Console.WriteLine($\"Obtaining parental consent from {customerName}\\'s legal guardian before updating their information.\");\\n}\\nelse // All other scenarios\\n{\\n    Console.WriteLine($\"{customerName}\\'s information will remain private.\");\\n}\\n```'}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tinycodes['train'][3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "9164f228-6bf5-47eb-983c-f40e714df4c0",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "Given our goal of creating a language classifier, we only need the `programming_language` field and the `response`. We will also need to transform the response, extracting only the code between the backticks (omitting the language name)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "5e826ae7-9317-4a48-b6dc-9b2d541c5fbb",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "import datasets\n",
    "\n",
    "def preprocess_tinycodes(tinycodes: datasets.DatasetDict):\n",
    "    tinycodes_subset = tinycodes[\"train\"].to_pandas()[\n",
    "        [\"idx\", \"programming_language\", \"response\"]\n",
    "    ]\n",
    "    # Extract code from response\n",
    "    tinycodes_subset[\"code\"] = tinycodes_subset[\"response\"].str.extract(\n",
    "        r\"```[a-zA-Z+#]*\\s+([\\s\\S]*?)```\", expand=False\n",
    "    )\n",
    "    return tinycodes_subset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "1e12ba3e-7f8c-4779-9afe-628401b759e9",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>idx</th>\n",
       "      <th>programming_language</th>\n",
       "      <th>response</th>\n",
       "      <th>code</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1230929</td>\n",
       "      <td>Python</td>\n",
       "      <td>Here is python code which determines high snee...</td>\n",
       "      <td>def determine_high_sneeze_cough_etiquette(isol...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1109988</td>\n",
       "      <td>Rust</td>\n",
       "      <td>Here is a possible implementation of such a fu...</td>\n",
       "      <td>// Define a function called display_extreme_se...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1881323</td>\n",
       "      <td>Ruby</td>\n",
       "      <td>Here’s some sample ruby code which implements ...</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>780696</td>\n",
       "      <td>C#</td>\n",
       "      <td>Here's some sample code that demonstrates how ...</td>\n",
       "      <td>// Define variables\\nstring customerName = \"Jo...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>131131</td>\n",
       "      <td>Julia</td>\n",
       "      <td>Here is a possible implementation of this func...</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1632304</th>\n",
       "      <td>1117266</td>\n",
       "      <td>Java</td>\n",
       "      <td>Here is a possible implementation of this requ...</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1632305</th>\n",
       "      <td>1042904</td>\n",
       "      <td>relation database and SQL</td>\n",
       "      <td>Here is a sample relational database schema an...</td>\n",
       "      <td>CREATE TABLE IF NOT EXISTS `user` (\\n      `id...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1632306</th>\n",
       "      <td>804392</td>\n",
       "      <td>Go</td>\n",
       "      <td>Here is a sample implementation of the functio...</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1632307</th>\n",
       "      <td>1338433</td>\n",
       "      <td>C#</td>\n",
       "      <td>Here is some sample code written in C#:\\n\\n   ...</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1632308</th>\n",
       "      <td>1763917</td>\n",
       "      <td>Ruby</td>\n",
       "      <td>Here is a possible implementation of this idea...</td>\n",
       "      <td># Check low weather: wind speed for decision m...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1632309 rows × 4 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "             idx  ...                                               code\n",
       "0        1230929  ...  def determine_high_sneeze_cough_etiquette(isol...\n",
       "1        1109988  ...  // Define a function called display_extreme_se...\n",
       "2        1881323  ...                                                NaN\n",
       "3         780696  ...  // Define variables\\nstring customerName = \"Jo...\n",
       "4         131131  ...                                                NaN\n",
       "...          ...  ...                                                ...\n",
       "1632304  1117266  ...                                                NaN\n",
       "1632305  1042904  ...  CREATE TABLE IF NOT EXISTS `user` (\\n      `id...\n",
       "1632306   804392  ...                                                NaN\n",
       "1632307  1338433  ...                                                NaN\n",
       "1632308  1763917  ...  # Check low weather: wind speed for decision m...\n",
       "\n",
       "[1632309 rows x 4 columns]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data_test = preprocess_tinycodes(tinycodes)\n",
    "data_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "ed30a3d4-7baf-4fda-b5fe-12ad73a4fc71",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "You'll notice that this is far from perfect: many examples were not captured by this regex match. Let's investigate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "23f95f94-5032-4e68-904c-289ec8cee25a",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>code</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>programming_language</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Bash</th>\n",
       "      <td>18.923651</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C#</th>\n",
       "      <td>20.937535</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>C++</th>\n",
       "      <td>44.289108</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Go</th>\n",
       "      <td>42.364462</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Java</th>\n",
       "      <td>40.571318</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>JavaScript</th>\n",
       "      <td>17.117255</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Julia</th>\n",
       "      <td>22.030571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Neo4j database and Cypher</th>\n",
       "      <td>53.198854</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Python</th>\n",
       "      <td>13.140869</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Ruby</th>\n",
       "      <td>34.818453</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Rust</th>\n",
       "      <td>4.670673</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>TypeScript</th>\n",
       "      <td>3.991357</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>relation database and SQL</th>\n",
       "      <td>39.571641</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                                code\n",
       "programming_language                \n",
       "Bash                       18.923651\n",
       "C#                         20.937535\n",
       "C++                        44.289108\n",
       "Go                         42.364462\n",
       "Java                       40.571318\n",
       "JavaScript                 17.117255\n",
       "Julia                      22.030571\n",
       "Neo4j database and Cypher  53.198854\n",
       "Python                     13.140869\n",
       "Ruby                       34.818453\n",
       "Rust                        4.670673\n",
       "TypeScript                  3.991357\n",
       "relation database and SQL  39.571641"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "# Calculate the percentage of NA for each programming language in data_test\n",
    "na_percent = data_test.groupby(\"programming_language\")[\"code\"].apply(lambda x: x.isna().mean() * 100)\n",
    "\n",
    "# Display the percentage in a dataframe\n",
    "na_percent_df = pd.DataFrame(na_percent)\n",
    "na_percent_df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "30656538-d092-47a8-bd73-5b93664fdf99",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "We would generally spend a lot more time iterating on the data and trying to capture code from a much greater proportion of examples. However, in this case, we're just going to subset to those languages where less than 25% of examples are NA and proceed with the fine tuning. Let's update accordingly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "75de9586-3034-4d60-9b21-f934659cc9e3",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "\n",
    "def extract_code_from_tinycodes(\n",
    "    tinycodes: datasets.DatasetDict, train_frac=0.7, valid_frac=0.2\n",
    "):\n",
    "    # Subset languages to Bash, C#, JavaScript, Julia, Python, Rust, TypeScript\n",
    "    languages = [\"Bash\", \"C#\", \"JavaScript\", \"Julia\", \"Python\", \"Rust\", \"TypeScript\"]\n",
    "    tinycodes_subset = tinycodes[\"train\"].to_pandas()[\n",
    "        [\"idx\", \"programming_language\", \"response\"]\n",
    "    ]\n",
    "    tinycodes_subset = tinycodes_subset[\n",
    "        tinycodes_subset[\"programming_language\"].isin(languages)\n",
    "    ]\n",
    "    # Extract code from response\n",
    "    tinycodes_subset[\"code\"] = tinycodes_subset[\"response\"].str.extract(\n",
    "        r\"```[a-zA-Z+#]*\\s+([\\s\\S]*?)```\", expand=False\n",
    "    )\n",
    "    # Drop rows with missing code\n",
    "    tinycodes_subset = tinycodes_subset.dropna(subset=[\"code\"])\n",
    "\n",
    "    # Shuffle the data\n",
    "    tinycodes_subset = tinycodes_subset.sample(frac=1, random_state=42)\n",
    "    # Split the data into train, valid, and test sets\n",
    "    train, valid, test = np.split(\n",
    "        tinycodes_subset,\n",
    "        [\n",
    "            int(train_frac * len(tinycodes_subset)),\n",
    "            int((train_frac + valid_frac) * len(tinycodes_subset)),\n",
    "        ],\n",
    "    )\n",
    "    # Convert the pandas dataframes back to DatasetDict\n",
    "    tinycodes_subset = datasets.DatasetDict(\n",
    "        {\n",
    "            \"train\": datasets.Dataset.from_pandas(train),\n",
    "            \"valid\": datasets.Dataset.from_pandas(valid),\n",
    "            \"test\": datasets.Dataset.from_pandas(test),\n",
    "        }\n",
    "    )\n",
    "    return tinycodes_subset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "c02b4005-8612-4345-bc60-dea4329a2615",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatasetDict({\n",
       "    train: Dataset({\n",
       "        features: ['idx', 'programming_language', 'response', 'code', '__index_level_0__'],\n",
       "        num_rows: 542106\n",
       "    })\n",
       "    valid: Dataset({\n",
       "        features: ['idx', 'programming_language', 'response', 'code', '__index_level_0__'],\n",
       "        num_rows: 154888\n",
       "    })\n",
       "    test: Dataset({\n",
       "        features: ['idx', 'programming_language', 'response', 'code', '__index_level_0__'],\n",
       "        num_rows: 77444\n",
       "    })\n",
       "})"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tinycodes_subset = extract_code_from_tinycodes(tinycodes)\n",
    "tinycodes_subset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "78d2f867-f421-4ccf-8b37-b88176a6bd93",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Rust          91672\n",
       "TypeScript    86330\n",
       "Python        78563\n",
       "JavaScript    75690\n",
       "Julia         70475\n",
       "Bash          69789\n",
       "C#            69587\n",
       "Name: programming_language, dtype: int64"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# count number of each programming language\n",
    "tinycodes_subset['train'].to_pandas()['programming_language'].value_counts()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "a769f2d0-b126-442a-a1d4-7bd7944067a3",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "We still have a reasonably balanced training set, with between 69,000 and 92,000 examples of each language. Let's proceed! Next we need to preprocess the data for training by adding a prefix specifying the task and then tokenizing the data.\n",
    "\n",
    "## Tokenize the Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "6d0bacdc-390b-445d-8790-07e452519e57",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-12-03 18:48:53.085806: E tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:9342] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
      "2023-12-03 18:48:53.085867: E tensorflow/compiler/xla/stream_executor/cuda/cuda_fft.cc:609] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
      "2023-12-03 18:48:53.085905: E tensorflow/compiler/xla/stream_executor/cuda/cuda_blas.cc:1518] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n",
      "2023-12-03 18:48:53.092029: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n",
      "To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "03c00924cb974e1eabe0b431f1094e8f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Map:   0%|          | 0/542106 [00:00<?, ? examples/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "282ce9542d914d07a9e860dd0bc1ca6f",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Map:   0%|          | 0/154888 [00:00<?, ? examples/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5da61a3e71f541e5ab829a7f995c5a45",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Map:   0%|          | 0/77444 [00:00<?, ? examples/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from transformers import AutoTokenizer\n",
    "\n",
    "tokenizer = AutoTokenizer.from_pretrained(\"t5-small\")\n",
    "\n",
    "\n",
    "def preprocess_function(examples, tokenizer):\n",
    "    prefix = \"question: what programming language is this?  code:\\n\\n\"\n",
    "    inputs = [prefix + ex for ex in examples[\"code\"]]\n",
    "    model_inputs = tokenizer(\n",
    "        inputs, max_length=512, truncation=True, padding=\"max_length\"\n",
    "    )\n",
    "\n",
    "    labels = tokenizer(\n",
    "        text_target=examples[\"programming_language\"],\n",
    "        max_length=128,\n",
    "        truncation=True,\n",
    "        padding=\"max_length\",\n",
    "        add_special_tokens=True,\n",
    "    )\n",
    "\n",
    "    model_inputs[\"labels\"] = labels[\"input_ids\"]\n",
    "    return model_inputs\n",
    "\n",
    "\n",
    "# Assuming 'dataset' is your DatasetDict\n",
    "tokenized_datasets = tinycodes_subset.map(\n",
    "    preprocess_function,\n",
    "    fn_kwargs={\"tokenizer\": tokenizer},\n",
    "    batched=True,\n",
    "    batch_size=4096,\n",
    "    load_from_cache_file=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "2fb2a40a-cbd2-448c-8976-ab434efc114d",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": [
    "# set up dataloaders\n",
    "from torch.utils.data import DataLoader\n",
    "\n",
    "train_dataloader = DataLoader(tokenized_datasets[\"train\"], shuffle=True, batch_size=16)\n",
    "val_dataloader = DataLoader(tokenized_datasets[\"valid\"], batch_size=16)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "7dbff09c-046b-4061-8608-2d6584c33259",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "# Start Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "aacd7588-d5e0-45b4-9d7e-57f89005a1c2",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "    <div>\n",
       "      \n",
       "      <progress value='50823' max='50823' style='width:300px; height:20px; vertical-align: middle;'></progress>\n",
       "      [50823/50823 7:52:09, Epoch 3/3]\n",
       "    </div>\n",
       "    <table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       " <tr style=\"text-align: left;\">\n",
       "      <th>Step</th>\n",
       "      <th>Training Loss</th>\n",
       "      <th>Validation Loss</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>10000</td>\n",
       "      <td>0.000500</td>\n",
       "      <td>0.000561</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>20000</td>\n",
       "      <td>0.000400</td>\n",
       "      <td>0.000407</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>30000</td>\n",
       "      <td>0.000300</td>\n",
       "      <td>0.000386</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>40000</td>\n",
       "      <td>0.000400</td>\n",
       "      <td>0.000346</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>50000</td>\n",
       "      <td>0.000400</td>\n",
       "      <td>0.000346</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table><p>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import mlflow\n",
    "from transformers import Trainer, TrainingArguments, AutoModelForSeq2SeqLM\n",
    "\n",
    "# Check if CUDA is available and set the device accordingly\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "model_name = \"t5-small\"  # Or another T5 variant\n",
    "tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
    "model = AutoModelForSeq2SeqLM.from_pretrained(model_name).to(device)\n",
    "\n",
    "# Define training arguments\n",
    "training_args = TrainingArguments(\n",
    "    output_dir=\"/Volumes/daniel_liden/fine_tune/assets/results/\",\n",
    "    per_device_train_batch_size=32,\n",
    "    per_device_eval_batch_size=32,\n",
    "    num_train_epochs=3,\n",
    "    evaluation_strategy=\"steps\",\n",
    "    eval_steps=1e4,\n",
    "    logging_strategy=\"steps\",\n",
    "    logging_steps=100,\n",
    "    save_strategy=\"epoch\",\n",
    "    logging_dir=\"/Volumes/daniel_liden/fine_tune/assets/logs/\",\n",
    "    learning_rate=2e-5,\n",
    ")\n",
    "\n",
    "# Initialize the Trainer\n",
    "trainer = Trainer(\n",
    "    model=model,\n",
    "    args=training_args,\n",
    "    train_dataset=tokenized_datasets[\"train\"],\n",
    "    eval_dataset=tokenized_datasets[\"valid\"],\n",
    ")\n",
    "\n",
    "\n",
    "# Start training\n",
    "with mlflow.start_run():\n",
    "    trainer.train()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "f30d855d-387a-4814-a990-ac2753dfd663",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7274"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import gc\n",
    "\n",
    "del model\n",
    "del tokenizer\n",
    "del trainer\n",
    "torch.cuda.empty_cache()\n",
    "gc.collect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {},
     "inputWidgets": {},
     "nuid": "7a012e06-5012-4b6a-bb54-3f719c85d8dd",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "# Inference with our fine-tuned model\n",
    "\n",
    "Before we get too far, there are a few important things to point out here:\n",
    "- The choice of training hyperparameters was more-or-less arbitrary. In real life, we would do a lot more experimentation with e.g. batch size, regularization, etc.\n",
    "- Similarily, the data mix was chosen for expediency, not for suitability for the current task. If I had to venture a guess before seeing any results, I would guess that the model learned shortcuts "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "8b3e013f-b578-4bc4-911c-71c6b8db3e7e",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input: question: what programming language is this?  code: def add_a_b(a, b): return a + b\n",
      "Output: Python\n",
      "\n",
      "Input: question: what programming language is this?  code: public class HelloWorld { public static void Main() { Console.WriteLine(\"Hello, World!\"); } }\n",
      "Output: C#\n",
      "\n",
      "Input: question: what programming language is this?  code: #include <iostream> int main() { std::cout << \"Hello, World!\" << std::endl; return 0; }\n",
      "Output: Rust\n",
      "\n",
      "Input: question: what programming language is this?  code: println(\"Hello, World!\")\n",
      "Output: Julia\n",
      "\n",
      "Input: question: what programming language is this?  code: echo \"Hello, World!\"\n",
      "Output: Bash\n",
      "\n",
      "Input: question: what programming language is this?  code: fn main() { println!(\"Hello, World!\"); }\n",
      "Output: Rust\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from transformers import AutoModelForSeq2SeqLM, AutoTokenizer\n",
    "import torch\n",
    "\n",
    "# Load model and tokenizer\n",
    "tokenizer = AutoTokenizer.from_pretrained(\"t5-small\")\n",
    "model = AutoModelForSeq2SeqLM.from_pretrained(\"/Volumes/daniel_liden/fine_tune/assets/results/checkpoint-50823\")\n",
    "\n",
    "# Check if GPU is available and move the model to GPU\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model = model.to(device)\n",
    "\n",
    "input_texts = [\n",
    "    \"question: what programming language is this?  code: def add_a_b(a, b): return a + b\",  # Python\n",
    "    \"question: what programming language is this?  code: public class HelloWorld { public static void Main() { Console.WriteLine(\\\"Hello, World!\\\"); } }\",  # C#\n",
    "    \"question: what programming language is this?  code: #include <iostream> int main() { std::cout << \\\"Hello, World!\\\" << std::endl; return 0; }\",  # C++\n",
    "    \"question: what programming language is this?  code: println(\\\"Hello, World!\\\")\",  # Julia\n",
    "    \"question: what programming language is this?  code: echo \\\"Hello, World!\\\"\",  # Bash\n",
    "    \"question: what programming language is this?  code: fn main() { println!(\\\"Hello, World!\\\"); }\"  # Rust\n",
    "]\n",
    "\n",
    "# Tokenize and encode the batch of input texts\n",
    "input_ids = tokenizer.batch_encode_plus(input_texts, padding=True, return_tensors=\"pt\", truncation=True).to(device)\n",
    "\n",
    "# Generate responses for the batch\n",
    "output_ids = model.generate(input_ids[\"input_ids\"], max_new_tokens=20)\n",
    "\n",
    "# Decode and print the output texts\n",
    "for i, output_id in enumerate(output_ids):\n",
    "    output_text = tokenizer.decode(output_id, skip_special_tokens=True)\n",
    "    print(f\"Input: {input_texts[i]}\")\n",
    "    print(f\"Output: {output_text}\\n\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {},
     "inputWidgets": {},
     "nuid": "a98cf455-7f22-4686-95c0-ad0d7af451f7",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "It misclassified C++ code as Rust code, but otherwise got the examples correct. We've added a new capability to this model. Now the question is...does it still remember how to do what it was trained on before?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "564f395c-8de8-4549-adc6-d17b61aad038",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C#\n"
     ]
    }
   ],
   "source": [
    "input_text = (\n",
    "    \"question: What is the deepspeed license?  context: DeepSpeed \"\n",
    "    \"is an open source deep learning optimization library for PyTorch. \"\n",
    "    \"The library is designed to reduce computing power and memory use \"\n",
    "    \"and to train large distributed models with better parallelism on \"\n",
    "    \"existing computer hardware. DeepSpeed is optimized for low latency, \"\n",
    "    \"high throughput training. It includes the Zero Redundancy Optimizer \"\n",
    "    \"(ZeRO) for training models with 1 trillion or more parameters. \"\n",
    "    \"Features include mixed precision training, single-GPU, multi-GPU, \"\n",
    "    \"and multi-node training as well as custom model parallelism. The \"\n",
    "    \"DeepSpeed source code is licensed under MIT License and available on GitHub.\"\n",
    ")\n",
    "\n",
    "# Encode and generate response\n",
    "input_ids = tokenizer.encode(input_text, return_tensors=\"pt\").to(device)\n",
    "output_ids = model.generate(input_ids, max_new_tokens=20)[0]\n",
    "\n",
    "# Decode and print the output text\n",
    "output_text = tokenizer.decode(output_ids, skip_special_tokens=True)\n",
    "print(output_text)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {},
     "inputWidgets": {},
     "nuid": "d7c72e96-98f1-4421-950e-ba300003b5d4",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "There's an interesting result here: if we try the input above after training for all three epochs, we get an incorrect result. However, if we use the checkpoint saved after only two epochs, it still gets the correct answer. This highlights something really important: fine-tuning on new knowledge or new tasks can make the model \"forget\" its prior training. To get around this, we need to be thoughtful about how much new data we use, how long we train for, how we evaluate the fine-tuned model, and what mixture of data we use for fine-tuning."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {
      "byteLimit": 2048000,
      "rowLimit": 10000
     },
     "inputWidgets": {},
     "nuid": "b1180b26-2d86-4f25-9ee3-b4efc3200eba",
     "showTitle": false,
     "title": ""
    }
   },
   "source": [
    "# Conclusion\n",
    "\n",
    "In this example, we fine-tuned `t5-small` on a new task. The basic process was:\n",
    "- Pick a model and task\n",
    "- Pick a dataset\n",
    "- Process the dataset\n",
    "- Train the model on the processed dataset\n",
    "\n",
    "This omits plenty of important steps we'll get further into in future notebooks. For example:\n",
    "- tuning hyperparameters\n",
    "- thoroughly evaluating the results\n",
    "- tuning training speed/efficiency\n",
    "- monitoring the training loop (we did track the experiment with MLflow but did not configure it in any way for our specific usage)\n",
    "\n",
    "We will get into each of these in future examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "application/vnd.databricks.v1+cell": {
     "cellMetadata": {},
     "inputWidgets": {},
     "nuid": "babab007-fc2b-4dd9-8e48-bfee1b6ff7c3",
     "showTitle": false,
     "title": ""
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "application/vnd.databricks.v1+notebook": {
   "dashboards": [],
   "language": "python",
   "notebookMetadata": {
    "pythonIndentUnit": 4
   },
   "notebookName": "1. T5-Small on Single GPU",
   "widgets": {}
  },
  "kernelspec": {
   "display_name": "Python (mlops)",
   "language": "python",
   "name": "mlops"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}