diff --git a/1_t5_small_single_gpu/1. T5-Small on Single GPU.ipynb b/1_t5_small_single_gpu/1. T5-Small on Single GPU.ipynb index 5485e59..fb0be2c 100644 --- a/1_t5_small_single_gpu/1. T5-Small on Single GPU.ipynb +++ b/1_t5_small_single_gpu/1. T5-Small on Single GPU.ipynb @@ -29,7 +29,7 @@ "\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. A an oft-cited heuristic for model training is that you need GPU memory (VRAM) in Gigabytes greater than or equal to the number of parameters in billions times 16. So a 1 Billion parameter model would require approximately 16GB of VRAM for training. t5-small is a 0.06B parameter model and thus requires only around 0.96GB of VRAM for training. Again--we're starting *very small*.\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", @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -58,27 +58,121 @@ }, "outputs": [ { - "output_type": "stream", "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\nRequirement already satisfied: transformers in /databricks/python3/lib/python3.10/site-packages (4.34.0)\nCollecting 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\nRequirement already satisfied: torch in /databricks/python3/lib/python3.10/site-packages (2.0.1+cu118)\nCollecting 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\nRequirement already satisfied: accelerate in /databricks/python3/lib/python3.10/site-packages (0.23.0)\nCollecting 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\nRequirement already satisfied: packaging>=20.0 in /databricks/python3/lib/python3.10/site-packages (from transformers) (22.0)\nRequirement already satisfied: huggingface-hub<1.0,>=0.16.4 in /databricks/python3/lib/python3.10/site-packages (from transformers) (0.16.4)\nRequirement already satisfied: filelock in /databricks/python3/lib/python3.10/site-packages (from transformers) (3.9.0)\nRequirement already satisfied: requests in /databricks/python3/lib/python3.10/site-packages (from transformers) (2.28.1)\nRequirement already satisfied: regex!=2019.12.17 in /databricks/python3/lib/python3.10/site-packages (from transformers) (2022.7.9)\nRequirement already satisfied: tqdm>=4.27 in /databricks/python3/lib/python3.10/site-packages (from transformers) (4.64.1)\nRequirement already satisfied: tokenizers<0.19,>=0.14 in /databricks/python3/lib/python3.10/site-packages (from transformers) (0.14.0)\nRequirement already satisfied: pyyaml>=5.1 in /databricks/python3/lib/python3.10/site-packages (from transformers) (6.0)\nRequirement already satisfied: safetensors>=0.3.1 in /databricks/python3/lib/python3.10/site-packages (from transformers) (0.4.0)\nRequirement already satisfied: numpy>=1.17 in /databricks/python3/lib/python3.10/site-packages (from transformers) (1.23.5)\nRequirement already satisfied: networkx in /databricks/python3/lib/python3.10/site-packages (from torch) (2.8.4)\nCollecting 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\nCollecting 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\nRequirement already satisfied: jinja2 in /databricks/python3/lib/python3.10/site-packages (from torch) (3.1.2)\nCollecting 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\nRequirement already satisfied: fsspec in /databricks/python3/lib/python3.10/site-packages (from torch) (2023.6.0)\nCollecting 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" + "\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" ] }, { - "output_type": "stream", "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\n2023-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\n2023-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\n2023-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.\nTo enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + "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" ] }, { - "output_type": "stream", "name": "stdout", "output_type": "stream", "text": [ - " ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 731.7/731.7 MB 1.8 MB/s eta 0:00:00\nCollecting 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\nCollecting 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\nRequirement already satisfied: typing-extensions in /databricks/python3/lib/python3.10/site-packages (from torch) (4.4.0)\nCollecting 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\nCollecting 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\nRequirement already satisfied: sympy in /databricks/python3/lib/python3.10/site-packages (from torch) (1.11.1)\nCollecting 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\nCollecting 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\nCollecting 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\nCollecting 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\nCollecting 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\nRequirement already satisfied: psutil in /databricks/python3/lib/python3.10/site-packages (from accelerate) (5.9.0)\nRequirement already satisfied: MarkupSafe>=2.0 in /databricks/python3/lib/python3.10/site-packages (from jinja2->torch) (2.1.1)\nRequirement already satisfied: certifi>=2017.4.17 in /databricks/python3/lib/python3.10/site-packages (from requests->transformers) (2022.12.7)\nRequirement already satisfied: urllib3<1.27,>=1.21.1 in /databricks/python3/lib/python3.10/site-packages (from requests->transformers) (1.26.14)\nRequirement already satisfied: charset-normalizer<3,>=2 in /databricks/python3/lib/python3.10/site-packages (from requests->transformers) (2.0.4)\nRequirement already satisfied: idna<4,>=2.5 in /databricks/python3/lib/python3.10/site-packages (from requests->transformers) (3.4)\nRequirement already satisfied: mpmath>=0.19 in /databricks/python3/lib/python3.10/site-packages (from sympy->torch) (1.2.1)\nInstalling 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.\nERROR: 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.\ntorchvision 0.15.2+cu118 requires torch==2.0.1, but you have torch 2.1.1 which is incompatible.\nSuccessfully 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" + " ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 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" ] } ], @@ -89,7 +183,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -104,15 +198,17 @@ }, "outputs": [ { - "output_type": "stream", "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\n2023-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\n2023-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\n2023-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.\nTo enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + "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" ] }, { - "output_type": "stream", "name": "stdout", "output_type": "stream", "text": [ @@ -178,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -193,7 +289,6 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", "output_type": "stream", "text": [ @@ -239,7 +334,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -254,7 +349,6 @@ }, "outputs": [ { - "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "850085a74f5b4cb0bd2db5bff0be35e0", @@ -278,7 +372,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -293,23 +387,36 @@ }, "outputs": [ { - "output_type": "stream", "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" + "/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" ] }, { - "output_type": "stream", "name": "stdout", "output_type": "stream", "text": [ - "Rust 136961\nRuby 136824\nJavaScript 131014\nJulia 129402\nPython 129063\nTypeScript 128653\nGo 126016\nC# 125478\nJava 123994\nBash 122804\nC++ 120813\nNeo4j database and Cypher 117589\nrelation database and SQL 103698\nName: programming_language, dtype: int64\n" + "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" ] }, { - "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ @@ -361,7 +468,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -376,7 +483,6 @@ }, "outputs": [ { - "output_type": "execute_result", "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", @@ -421,7 +527,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -451,7 +557,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -466,7 +572,6 @@ }, "outputs": [ { - "output_type": "execute_result", "data": { "text/html": [ "
\n", @@ -623,7 +728,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -638,7 +743,6 @@ }, "outputs": [ { - "output_type": "execute_result", "data": { "text/html": [ "
\n", @@ -777,7 +881,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -836,7 +940,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -851,7 +955,6 @@ }, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "DatasetDict({\n", @@ -882,7 +985,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -897,7 +1000,6 @@ }, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "Rust 91672\n", @@ -942,7 +1044,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -957,15 +1059,17 @@ }, "outputs": [ { - "output_type": "stream", "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\n2023-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\n2023-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\n2023-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.\nTo enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + "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" ] }, { - "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "03c00924cb974e1eabe0b431f1094e8f", @@ -980,7 +1084,6 @@ "output_type": "display_data" }, { - "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "282ce9542d914d07a9e860dd0bc1ca6f", @@ -995,7 +1098,6 @@ "output_type": "display_data" }, { - "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5da61a3e71f541e5ab829a7f995c5a45", @@ -1047,7 +1149,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -1089,7 +1191,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -1104,7 +1206,6 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", "output_type": "stream", "text": [ @@ -1112,7 +1213,6 @@ ] }, { - "output_type": "display_data", "data": { "text/html": [ "\n", @@ -1210,7 +1310,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -1225,7 +1325,6 @@ }, "outputs": [ { - "output_type": "execute_result", "data": { "text/plain": [ "7274" @@ -1267,7 +1366,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -1282,11 +1381,27 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", "output_type": "stream", "text": [ - "Input: question: what programming language is this? code: def add_a_b(a, b): return a + b\nOutput: Python\n\nInput: question: what programming language is this? code: public class HelloWorld { public static void Main() { Console.WriteLine(\"Hello, World!\"); } }\nOutput: C#\n\nInput: question: what programming language is this? code: #include int main() { std::cout << \"Hello, World!\" << std::endl; return 0; }\nOutput: Rust\n\nInput: question: what programming language is this? code: println(\"Hello, World!\")\nOutput: Julia\n\nInput: question: what programming language is this? code: echo \"Hello, World!\"\nOutput: Bash\n\nInput: question: what programming language is this? code: fn main() { println!(\"Hello, World!\"); }\nOutput: Rust\n\n" + "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 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" ] } ], @@ -1341,7 +1456,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": { @@ -1356,7 +1471,6 @@ }, "outputs": [ { - "output_type": "stream", "name": "stdout", "output_type": "stream", "text": [ @@ -1436,7 +1550,7 @@ }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": {}, @@ -1461,9 +1575,9 @@ "widgets": {} }, "kernelspec": { - "display_name": "env", + "display_name": "Python (mlops)", "language": "python", - "name": "python3" + "name": "mlops" }, "language_info": { "codemirror_mode": { @@ -1475,7 +1589,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.6" + "version": "3.11.4" } }, "nbformat": 4, diff --git a/2_gpt2_single_gpu/2. GPT2 on a single GPU.ipynb b/2_gpt2_single_gpu/2. GPT2 on a single GPU.ipynb index 538ab76..702f94a 100644 --- a/2_gpt2_single_gpu/2. GPT2 on a single GPU.ipynb +++ b/2_gpt2_single_gpu/2. GPT2 on a single GPU.ipynb @@ -20,12 +20,12 @@ "- Input: `The boy hid behind`, Target: `the`\n", "- Input: `The boy hid behind the`, Target: `tree`.\n", "\n", - "This requires us to preprocess our data and pass it along to the model somewhat differently, which will be the subject of this notebook. We will still limit this example to training on a single GPU (an a10 with 24GB VRAM). We will use the [gpt2](https://huggingface.co/gpt2) model with 124M parameters. Recalling the heuristic that training requires VRAM in GB ≥ 16 times the number of parameters in billions, we require .124 * 16 ≅ 2GB VRAM, so we should not be VRAM constrained." + "This requires us to preprocess our data and pass it along to the model somewhat differently, which will be the subject of this notebook. We will still limit this example to training on a single GPU (an a10 with 24GB VRAM). We will use the [gpt2](https://huggingface.co/gpt2) model with 124M parameters. Later, we will work though Eleuther's [Transformer Math blog post](https://blog.eleuther.ai/transformer-math/#training) to understand the memory costs associated with training this model under different conditions and verify that it matches our experience." ] }, { "cell_type": "code", - "execution_count": 0, + "execution_count": null, "metadata": { "application/vnd.databricks.v1+cell": { "cellMetadata": {}, @@ -48,6 +48,15 @@ }, "notebookName": "2. GPT2 on a single GPU", "widgets": {} + }, + "kernelspec": { + "display_name": "myenv", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.10.11" } }, "nbformat": 4,