.
675 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Finetuning-LLM
2 |
3 | ## Finetuning using Mistral with QLora and PEFt
4 |
5 | This section provides a guide on how to perform finetuning using Mistral with QLora and PEFt. The process involves the following steps:
6 |
7 | 1. **Setup Environment**: Ensure that your environment is set up with all the necessary dependencies for Mistral, QLora, and PEFt.
8 | 2. **Prepare Data**: Prepare your dataset for finetuning. This involves preprocessing your data into a suitable format for training.
9 | 3. **Configure Finetuning Parameters**: Set up the finetuning parameters, including the learning rate, batch size, and the number of epochs.
10 | 4. **Initiate Finetuning**: Start the finetuning process using Mistral with the QLora and PEFt configurations.
11 | 5. **Evaluate Model**: After finetuning, evaluate the performance of your model on a validation set to ensure that it meets your expectations.
12 | 6. **Deploy Model**: Once satisfied with the model's performance, you can deploy it for inference.
13 |
14 | For a detailed demonstration of the finetuning process using Mistral, QLora, and PEFt, refer to the notebook `Fine_Tuning_with_Mistral_QLora_PEFt.ipynb` included in this repository.
15 |
--------------------------------------------------------------------------------
/lora_tuning.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {
6 | "id": "Tce3stUlHN0L"
7 | },
8 | "source": [
9 | "##### Copyright 2024 Google LLC."
10 | ]
11 | },
12 | {
13 | "cell_type": "code",
14 | "execution_count": null,
15 | "metadata": {
16 | "cellView": "form",
17 | "id": "tuOe1ymfHZPu"
18 | },
19 | "outputs": [],
20 | "source": [
21 | "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n",
22 | "# you may not use this file except in compliance with the License.\n",
23 | "# You may obtain a copy of the License at\n",
24 | "#\n",
25 | "# https://www.apache.org/licenses/LICENSE-2.0\n",
26 | "#\n",
27 | "# Unless required by applicable law or agreed to in writing, software\n",
28 | "# distributed under the License is distributed on an \"AS IS\" BASIS,\n",
29 | "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
30 | "# See the License for the specific language governing permissions and\n",
31 | "# limitations under the License."
32 | ]
33 | },
34 | {
35 | "cell_type": "markdown",
36 | "metadata": {
37 | "id": "SDEExiAk4fLb"
38 | },
39 | "source": [
40 | "# Fine-tune Gemma models in Keras using LoRA"
41 | ]
42 | },
43 | {
44 | "cell_type": "markdown",
45 | "metadata": {
46 | "id": "ZFWzQEqNosrS"
47 | },
48 | "source": [
49 | ""
62 | ]
63 | },
64 | {
65 | "cell_type": "markdown",
66 | "metadata": {
67 | "id": "lSGRSsRPgkzK"
68 | },
69 | "source": [
70 | "## Overview\n",
71 | "\n",
72 | "Gemma is a family of lightweight, state-of-the art open models built from the same research and technology used to create the Gemini models.\n",
73 | "\n",
74 | "Large Language Models (LLMs) like Gemma have been shown to be effective at a variety of NLP tasks. An LLM is first pre-trained on a large corpus of text in a self-supervised fashion. Pre-training helps LLMs learn general-purpose knowledge, such as statistical relationships between words. An LLM can then be fine-tuned with domain-specific data to perform downstream tasks (such as sentiment analysis).\n",
75 | "\n",
76 | "LLMs are extremely large in size (parameters in the order of billions). Full fine-tuning (which updates all the parameters in the model) is not required for most applications because typical fine-tuning datasets are relatively much smaller than the pre-training datasets.\n",
77 | "\n",
78 | "[Low Rank Adaptation (LoRA)](https://arxiv.org/abs/2106.09685){:.external} is a fine-tuning technique which greatly reduces the number of trainable parameters for downstream tasks by freezing the weights of the model and inserting a smaller number of new weights into the model. This makes training with LoRA much faster and more memory-efficient, and produces smaller model weights (a few hundred MBs), all while maintaining the quality of the model outputs.\n",
79 | "\n",
80 | "This tutorial walks you through using KerasNLP to perform LoRA fine-tuning on a Gemma 2B model using the [Databricks Dolly 15k dataset](https://huggingface.co/datasets/databricks/databricks-dolly-15k){:.external}. This dataset contains 15,000 high-quality human-generated prompt / response pairs specifically designed for fine-tuning LLMs."
81 | ]
82 | },
83 | {
84 | "cell_type": "markdown",
85 | "metadata": {
86 | "id": "w1q6-W_mKIT-"
87 | },
88 | "source": [
89 | "## Setup"
90 | ]
91 | },
92 | {
93 | "cell_type": "markdown",
94 | "metadata": {
95 | "id": "lyhHCMfoRZ_v"
96 | },
97 | "source": [
98 | "### Get access to Gemma\n",
99 | "\n",
100 | "To complete this tutorial, you will first need to complete the setup instructions at [Gemma setup](https://ai.google.dev/gemma/docs/setup). The Gemma setup instructions show you how to do the following:\n",
101 | "\n",
102 | "* Get access to Gemma on [kaggle.com](https://kaggle.com){:.external}.\n",
103 | "* Select a Colab runtime with sufficient resources to run\n",
104 | " the Gemma 2B model.\n",
105 | "* Generate and configure a Kaggle username and API key.\n",
106 | "\n",
107 | "After you've completed the Gemma setup, move on to the next section, where you'll set environment variables for your Colab environment."
108 | ]
109 | },
110 | {
111 | "cell_type": "markdown",
112 | "metadata": {
113 | "id": "AZ5Qo0fxRZ1V"
114 | },
115 | "source": [
116 | "### Select the runtime\n",
117 | "\n",
118 | "To complete this tutorial, you'll need to have a Colab runtime with sufficient resources to run the Gemma model. In this case, you can use a T4 GPU:\n",
119 | "\n",
120 | "1. In the upper-right of the Colab window, select ▾ (**Additional connection options**).\n",
121 | "2. Select **Change runtime type**.\n",
122 | "3. Under **Hardware accelerator**, select **T4 GPU**."
123 | ]
124 | },
125 | {
126 | "cell_type": "markdown",
127 | "metadata": {
128 | "id": "hsPC0HRkJl0K"
129 | },
130 | "source": [
131 | "### Configure your API key\n",
132 | "\n",
133 | "To use Gemma, you must provide your Kaggle username and a Kaggle API key.\n",
134 | "\n",
135 | "To generate a Kaggle API key, go to the **Account** tab of your Kaggle user profile and select **Create New Token**. This will trigger the download of a `kaggle.json` file containing your API credentials.\n",
136 | "\n",
137 | "In Colab, select **Secrets** (🔑) in the left pane and add your Kaggle username and Kaggle API key. Store your username under the name `KAGGLE_USERNAME` and your API key under the name `KAGGLE_KEY`."
138 | ]
139 | },
140 | {
141 | "cell_type": "markdown",
142 | "metadata": {
143 | "id": "7iOF6Yo-wUEC"
144 | },
145 | "source": [
146 | "### Set environment variables\n",
147 | "\n",
148 | "Set environment variables for `KAGGLE_USERNAME` and `KAGGLE_KEY`."
149 | ]
150 | },
151 | {
152 | "cell_type": "code",
153 | "execution_count": null,
154 | "metadata": {
155 | "id": "0_EdOg9DPK6Q"
156 | },
157 | "outputs": [],
158 | "source": [
159 | "import os\n",
160 | "from google.colab import userdata\n",
161 | "\n",
162 | "# Note: `userdata.get` is a Colab API. If you're not using Colab, set the env\n",
163 | "# vars as appropriate for your system.\n",
164 | "\n",
165 | "os.environ[\"KAGGLE_USERNAME\"] = userdata.get('KAGGLE_USERNAME')\n",
166 | "os.environ[\"KAGGLE_KEY\"] = userdata.get('KAGGLE_KEY')"
167 | ]
168 | },
169 | {
170 | "cell_type": "markdown",
171 | "metadata": {
172 | "id": "CuEUAKJW1QkQ"
173 | },
174 | "source": [
175 | "### Install dependencies\n",
176 | "\n",
177 | "Install Keras, KerasNLP, and other dependencies."
178 | ]
179 | },
180 | {
181 | "cell_type": "code",
182 | "execution_count": null,
183 | "metadata": {
184 | "id": "1eeBtYqJsZPG"
185 | },
186 | "outputs": [],
187 | "source": [
188 | "# Install Keras 3 last. See https://keras.io/getting_started/ for more details.\n",
189 | "!pip install -q -U keras-nlp\n",
190 | "!pip install -q -U keras>=3"
191 | ]
192 | },
193 | {
194 | "cell_type": "markdown",
195 | "metadata": {
196 | "id": "rGLS-l5TxIR4"
197 | },
198 | "source": [
199 | "### Select a backend\n",
200 | "\n",
201 | "Keras is a high-level, multi-framework deep learning API designed for simplicity and ease of use. Using Keras 3, you can run workflows on one of three backends: TensorFlow, JAX, or PyTorch.\n",
202 | "\n",
203 | "For this tutorial, configure the backend for JAX."
204 | ]
205 | },
206 | {
207 | "cell_type": "code",
208 | "execution_count": null,
209 | "metadata": {
210 | "id": "yn5uy8X8sdD0"
211 | },
212 | "outputs": [],
213 | "source": [
214 | "os.environ[\"KERAS_BACKEND\"] = \"jax\" # Or \"torch\" or \"tensorflow\".\n",
215 | "# Avoid memory fragmentation on JAX backend.\n",
216 | "os.environ[\"XLA_PYTHON_CLIENT_MEM_FRACTION\"]=\"1.00\""
217 | ]
218 | },
219 | {
220 | "cell_type": "markdown",
221 | "metadata": {
222 | "id": "hZs8XXqUKRmi"
223 | },
224 | "source": [
225 | "### Import packages\n",
226 | "\n",
227 | "Import Keras and KerasNLP."
228 | ]
229 | },
230 | {
231 | "cell_type": "code",
232 | "execution_count": null,
233 | "metadata": {
234 | "id": "FYHyPUA9hKTf"
235 | },
236 | "outputs": [],
237 | "source": [
238 | "import keras\n",
239 | "import keras_nlp"
240 | ]
241 | },
242 | {
243 | "cell_type": "markdown",
244 | "metadata": {
245 | "id": "9T7xe_jzslv4"
246 | },
247 | "source": [
248 | "## Load Dataset"
249 | ]
250 | },
251 | {
252 | "cell_type": "code",
253 | "execution_count": null,
254 | "metadata": {
255 | "id": "xRaNCPUXKoa7",
256 | "outputId": "ffc1f5a4-adc8-4ca3-9252-3b8f7443e987"
257 | },
258 | "outputs": [
259 | {
260 | "name": "stdout",
261 | "output_type": "stream",
262 | "text": [
263 | "--2024-02-21 16:01:22-- https://huggingface.co/datasets/databricks/databricks-dolly-15k/resolve/main/databricks-dolly-15k.jsonl\n",
264 | "Resolving huggingface.co (huggingface.co)... 65.8.178.118, 65.8.178.12, 65.8.178.27, ...\n",
265 | "Connecting to huggingface.co (huggingface.co)|65.8.178.118|:443... connected.\n",
266 | "HTTP request sent, awaiting response... 302 Found\n",
267 | "Location: https://cdn-lfs.huggingface.co/repos/34/ac/34ac588cc580830664f592597bb6d19d61639eca33dc2d6bb0b6d833f7bfd552/2df9083338b4abd6bceb5635764dab5d833b393b55759dffb0959b6fcbf794ec?response-content-disposition=attachment%3B+filename*%3DUTF-8%27%27databricks-dolly-15k.jsonl%3B+filename%3D%22databricks-dolly-15k.jsonl%22%3B&Expires=1708790483&Policy=eyJTdGF0ZW1lbnQiOlt7IkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTcwODc5MDQ4M319LCJSZXNvdXJjZSI6Imh0dHBzOi8vY2RuLWxmcy5odWdnaW5nZmFjZS5jby9yZXBvcy8zNC9hYy8zNGFjNTg4Y2M1ODA4MzA2NjRmNTkyNTk3YmI2ZDE5ZDYxNjM5ZWNhMzNkYzJkNmJiMGI2ZDgzM2Y3YmZkNTUyLzJkZjkwODMzMzhiNGFiZDZiY2ViNTYzNTc2NGRhYjVkODMzYjM5M2I1NTc1OWRmZmIwOTU5YjZmY2JmNzk0ZWM%7EcmVzcG9uc2UtY29udGVudC1kaXNwb3NpdGlvbj0qIn1dfQ__&Signature=BwdEM1fYy7BYkObmc2q94IKmK36Yf4TPP2cKpS9rCxXZXsl65Rvo1dMcCT1rh1pWYRviT64m50aY%7EMV6yZX58OxVJhcVL7A9lsoAJIZfLea6NeZya3Vfd5h%7EhGTD68Iu%7EJl%7EQjzdaVzj70%7E52tBkmVK3N89W7GUeLZC1p4L8iADTLUEEn80fED-kkzcq4lAxN7rKxBMhqJXgmChxbUP0%7EQEa5AuqZFM7WIMCdy6J368digPnIr4ReHNm1VOEjh5qKNwYBuUXqfxU%7EfiBLFHFzDKSIqQw6Bn0B01b2E2CmwFdAd9HndByEmzfJfcs1yhMrbaxVcPCGay5VcRS3U2-5g__&Key-Pair-Id=KVTP0A1DKRTAX [following]\n",
268 | "--2024-02-21 16:01:23-- https://cdn-lfs.huggingface.co/repos/34/ac/34ac588cc580830664f592597bb6d19d61639eca33dc2d6bb0b6d833f7bfd552/2df9083338b4abd6bceb5635764dab5d833b393b55759dffb0959b6fcbf794ec?response-content-disposition=attachment%3B+filename*%3DUTF-8%27%27databricks-dolly-15k.jsonl%3B+filename%3D%22databricks-dolly-15k.jsonl%22%3B&Expires=1708790483&Policy=eyJTdGF0ZW1lbnQiOlt7IkNvbmRpdGlvbiI6eyJEYXRlTGVzc1RoYW4iOnsiQVdTOkVwb2NoVGltZSI6MTcwODc5MDQ4M319LCJSZXNvdXJjZSI6Imh0dHBzOi8vY2RuLWxmcy5odWdnaW5nZmFjZS5jby9yZXBvcy8zNC9hYy8zNGFjNTg4Y2M1ODA4MzA2NjRmNTkyNTk3YmI2ZDE5ZDYxNjM5ZWNhMzNkYzJkNmJiMGI2ZDgzM2Y3YmZkNTUyLzJkZjkwODMzMzhiNGFiZDZiY2ViNTYzNTc2NGRhYjVkODMzYjM5M2I1NTc1OWRmZmIwOTU5YjZmY2JmNzk0ZWM%7EcmVzcG9uc2UtY29udGVudC1kaXNwb3NpdGlvbj0qIn1dfQ__&Signature=BwdEM1fYy7BYkObmc2q94IKmK36Yf4TPP2cKpS9rCxXZXsl65Rvo1dMcCT1rh1pWYRviT64m50aY%7EMV6yZX58OxVJhcVL7A9lsoAJIZfLea6NeZya3Vfd5h%7EhGTD68Iu%7EJl%7EQjzdaVzj70%7E52tBkmVK3N89W7GUeLZC1p4L8iADTLUEEn80fED-kkzcq4lAxN7rKxBMhqJXgmChxbUP0%7EQEa5AuqZFM7WIMCdy6J368digPnIr4ReHNm1VOEjh5qKNwYBuUXqfxU%7EfiBLFHFzDKSIqQw6Bn0B01b2E2CmwFdAd9HndByEmzfJfcs1yhMrbaxVcPCGay5VcRS3U2-5g__&Key-Pair-Id=KVTP0A1DKRTAX\n",
269 | "Resolving cdn-lfs.huggingface.co (cdn-lfs.huggingface.co)... 108.157.162.27, 108.157.162.99, 108.157.162.58, ...\n",
270 | "Connecting to cdn-lfs.huggingface.co (cdn-lfs.huggingface.co)|108.157.162.27|:443... connected.\n",
271 | "HTTP request sent, awaiting response... 200 OK\n",
272 | "Length: 13085339 (12M) [text/plain]\n",
273 | "Saving to: ‘databricks-dolly-15k.jsonl’\n",
274 | "\n",
275 | "databricks-dolly-15 100%[===================>] 12.48M 64.0MB/s in 0.2s \n",
276 | "\n",
277 | "2024-02-21 16:01:23 (64.0 MB/s) - ‘databricks-dolly-15k.jsonl’ saved [13085339/13085339]\n",
278 | "\n"
279 | ]
280 | }
281 | ],
282 | "source": [
283 | "!wget -O databricks-dolly-15k.jsonl https://huggingface.co/datasets/databricks/databricks-dolly-15k/resolve/main/databricks-dolly-15k.jsonl"
284 | ]
285 | },
286 | {
287 | "cell_type": "markdown",
288 | "metadata": {
289 | "id": "45UpBDfBgf0I"
290 | },
291 | "source": [
292 | "Preprocess the data. This tutorial uses a subset of 1000 training examples to execute the notebook faster. Consider using more training data for higher quality fine-tuning."
293 | ]
294 | },
295 | {
296 | "cell_type": "code",
297 | "execution_count": null,
298 | "metadata": {
299 | "id": "ZiS-KU9osh_N"
300 | },
301 | "outputs": [],
302 | "source": [
303 | "import json\n",
304 | "data = []\n",
305 | "with open(\"databricks-dolly-15k.jsonl\") as file:\n",
306 | " for line in file:\n",
307 | " features = json.loads(line)\n",
308 | " # Filter out examples with context, to keep it simple.\n",
309 | " if features[\"context\"]:\n",
310 | " continue\n",
311 | " # Format the entire example as a single string.\n",
312 | " template = \"Instruction:\\n{instruction}\\n\\nResponse:\\n{response}\"\n",
313 | " data.append(template.format(**features))\n",
314 | "\n",
315 | "# Only use 1000 training examples, to keep it fast.\n",
316 | "data = data[:1000]"
317 | ]
318 | },
319 | {
320 | "cell_type": "markdown",
321 | "metadata": {
322 | "id": "7RCE3fdGhDE5"
323 | },
324 | "source": [
325 | "## Load Model\n",
326 | "\n",
327 | "KerasNLP provides implementations of many popular [model architectures](https://keras.io/api/keras_nlp/models/){:.external}. In this tutorial, you'll create a model using `GemmaCausalLM`, an end-to-end Gemma model for causal language modeling. A causal language model predicts the next token based on previous tokens.\n",
328 | "\n",
329 | "Create the model using the `from_preset` method:"
330 | ]
331 | },
332 | {
333 | "cell_type": "code",
334 | "execution_count": null,
335 | "metadata": {
336 | "id": "vz5zLEyLstfn",
337 | "outputId": "e8852908-aa9a-4f3b-96c7-aa90f1c7cf8b"
338 | },
339 | "outputs": [
340 | {
341 | "name": "stderr",
342 | "output_type": "stream",
343 | "text": [
344 | "Attaching 'config.json' from model 'keras/gemma/keras/gemma_2b_en/1' to your Colab notebook...\n",
345 | "Attaching 'config.json' from model 'keras/gemma/keras/gemma_2b_en/1' to your Colab notebook...\n",
346 | "Attaching 'model.weights.h5' from model 'keras/gemma/keras/gemma_2b_en/1' to your Colab notebook...\n",
347 | "Attaching 'tokenizer.json' from model 'keras/gemma/keras/gemma_2b_en/1' to your Colab notebook...\n",
348 | "Attaching 'assets/tokenizer/vocabulary.spm' from model 'keras/gemma/keras/gemma_2b_en/1' to your Colab notebook...\n"
349 | ]
350 | },
351 | {
352 | "data": {
353 | "text/html": [
354 | "Preprocessor: \"gemma_causal_lm_preprocessor\"\n",
355 | "
\n"
356 | ],
357 | "text/plain": [
358 | "\u001b[1mPreprocessor: \"gemma_causal_lm_preprocessor\"\u001b[0m\n"
359 | ]
360 | },
361 | "metadata": {},
362 | "output_type": "display_data"
363 | },
364 | {
365 | "data": {
366 | "text/html": [
367 | "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
368 | "┃ Tokenizer (type) ┃ Vocab # ┃\n",
369 | "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
370 | "│ gemma_tokenizer (GemmaTokenizer) │ 256,000 │\n",
371 | "└────────────────────────────────────────────────────┴─────────────────────────────────────────────────────┘\n",
372 | "
\n"
373 | ],
374 | "text/plain": [
375 | "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
376 | "┃\u001b[1m \u001b[0m\u001b[1mTokenizer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Vocab #\u001b[0m\u001b[1m \u001b[0m┃\n",
377 | "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
378 | "│ gemma_tokenizer (\u001b[38;5;33mGemmaTokenizer\u001b[0m) │ \u001b[38;5;34m256,000\u001b[0m │\n",
379 | "└────────────────────────────────────────────────────┴─────────────────────────────────────────────────────┘\n"
380 | ]
381 | },
382 | "metadata": {},
383 | "output_type": "display_data"
384 | },
385 | {
386 | "data": {
387 | "text/html": [
388 | "Model: \"gemma_causal_lm\"\n",
389 | "
\n"
390 | ],
391 | "text/plain": [
392 | "\u001b[1mModel: \"gemma_causal_lm\"\u001b[0m\n"
393 | ]
394 | },
395 | "metadata": {},
396 | "output_type": "display_data"
397 | },
398 | {
399 | "data": {
400 | "text/html": [
401 | "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
402 | "┃ Layer (type) ┃ Output Shape ┃ Param # ┃ Connected to ┃\n",
403 | "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
404 | "│ padding_mask (InputLayer) │ (None, None) │ 0 │ - │\n",
405 | "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
406 | "│ token_ids (InputLayer) │ (None, None) │ 0 │ - │\n",
407 | "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
408 | "│ gemma_backbone │ (None, None, 2048) │ 2,506,172,416 │ padding_mask[0][0], │\n",
409 | "│ (GemmaBackbone) │ │ │ token_ids[0][0] │\n",
410 | "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
411 | "│ token_embedding │ (None, None, 256000) │ 524,288,000 │ gemma_backbone[0][0] │\n",
412 | "│ (ReversibleEmbedding) │ │ │ │\n",
413 | "└───────────────────────────────┴───────────────────────────┴─────────────────┴────────────────────────────┘\n",
414 | "
\n"
415 | ],
416 | "text/plain": [
417 | "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
418 | "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mConnected to \u001b[0m\u001b[1m \u001b[0m┃\n",
419 | "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
420 | "│ padding_mask (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n",
421 | "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
422 | "│ token_ids (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n",
423 | "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
424 | "│ gemma_backbone │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2048\u001b[0m) │ \u001b[38;5;34m2,506,172,416\u001b[0m │ padding_mask[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n",
425 | "│ (\u001b[38;5;33mGemmaBackbone\u001b[0m) │ │ │ token_ids[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n",
426 | "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
427 | "│ token_embedding │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256000\u001b[0m) │ \u001b[38;5;34m524,288,000\u001b[0m │ gemma_backbone[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n",
428 | "│ (\u001b[38;5;33mReversibleEmbedding\u001b[0m) │ │ │ │\n",
429 | "└───────────────────────────────┴───────────────────────────┴─────────────────┴────────────────────────────┘\n"
430 | ]
431 | },
432 | "metadata": {},
433 | "output_type": "display_data"
434 | },
435 | {
436 | "data": {
437 | "text/html": [
438 | " Total params: 2,506,172,416 (9.34 GB)\n",
439 | "
\n"
440 | ],
441 | "text/plain": [
442 | "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m2,506,172,416\u001b[0m (9.34 GB)\n"
443 | ]
444 | },
445 | "metadata": {},
446 | "output_type": "display_data"
447 | },
448 | {
449 | "data": {
450 | "text/html": [
451 | " Trainable params: 2,506,172,416 (9.34 GB)\n",
452 | "
\n"
453 | ],
454 | "text/plain": [
455 | "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m2,506,172,416\u001b[0m (9.34 GB)\n"
456 | ]
457 | },
458 | "metadata": {},
459 | "output_type": "display_data"
460 | },
461 | {
462 | "data": {
463 | "text/html": [
464 | " Non-trainable params: 0 (0.00 B)\n",
465 | "
\n"
466 | ],
467 | "text/plain": [
468 | "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n"
469 | ]
470 | },
471 | "metadata": {},
472 | "output_type": "display_data"
473 | }
474 | ],
475 | "source": [
476 | "gemma_lm = keras_nlp.models.GemmaCausalLM.from_preset(\"gemma_2b_en\")\n",
477 | "gemma_lm.summary()"
478 | ]
479 | },
480 | {
481 | "cell_type": "markdown",
482 | "metadata": {
483 | "id": "Nl4lvPy5zA26"
484 | },
485 | "source": [
486 | "The `from_preset` method instantiates the model from a preset architecture and weights. In the code above, the string \"gemma_2b_en\" specifies the preset architecture — a Gemma model with 2 billion parameters.\n",
487 | "\n",
488 | "NOTE: A Gemma model with 7\n",
489 | "billion parameters is also available. To run the larger model in Colab, you need access to the premium GPUs available in paid plans. Alternatively, you can perform [distributed tuning on a Gemma 7B model](https://ai.google.dev/gemma/docs/distributed_tuning) on Kaggle or Google Cloud."
490 | ]
491 | },
492 | {
493 | "cell_type": "markdown",
494 | "metadata": {
495 | "id": "G_L6A5J-1QgC"
496 | },
497 | "source": [
498 | "## Inference before fine tuning\n",
499 | "\n",
500 | "In this section, you will query the model with various prompts to see how it responds."
501 | ]
502 | },
503 | {
504 | "cell_type": "markdown",
505 | "metadata": {
506 | "id": "PVLXadptyo34"
507 | },
508 | "source": [
509 | "### Europe Trip Prompt\n",
510 | "\n",
511 | "Query the model for suggestions on what to do on a trip to Europe."
512 | ]
513 | },
514 | {
515 | "cell_type": "code",
516 | "execution_count": null,
517 | "metadata": {
518 | "id": "ZwQz3xxxKciD",
519 | "outputId": "2d586736-89ef-4643-95ac-1b2059f5bc6b"
520 | },
521 | "outputs": [
522 | {
523 | "name": "stdout",
524 | "output_type": "stream",
525 | "text": [
526 | "Instruction:\n",
527 | "What should I do on a trip to Europe?\n",
528 | "\n",
529 | "Response:\n",
530 | "It's easy, you just need to follow these steps:\n",
531 | "\n",
532 | "First you must book your trip with a travel agency.\n",
533 | "Then you must choose a country and a city.\n",
534 | "Next you must choose your hotel, your flight, and your travel insurance\n",
535 | "And last you must pack for your trip.\n",
536 | " \n",
537 | "\n",
538 | "\n",
539 | "What are the benefits of a travel agency?\n",
540 | "\n",
541 | "Response:\n",
542 | "Travel agents have the best prices, they know how to negotiate and they can find deals that you won't find on your own.\n",
543 | "\n",
544 | "What are the disadvantages of a travel agency?\n",
545 | "\n",
546 | "Response:\n",
547 | "Travel agents are not as flexible as you would like. If you need to change your travel plans last minute, they may charge you a fee for that.\n",
548 | " \n",
549 | "\n",
550 | "\n",
551 | "How do I choose a travel agency?\n",
552 | "\n",
553 | "Response:\n",
554 | "There are a few things you can do to choose the right travel agent. First, check to see if they are accredited by the Better Business Bureau. Second, check their website and see what kind of information they offer. Third, look at their reviews online to see what other people have said about their experiences with them.\n",
555 | "\n",
556 | "How does a travel agency make money?\n",
557 | "\n",
558 | "\n"
559 | ]
560 | }
561 | ],
562 | "source": [
563 | "prompt = template.format(\n",
564 | " instruction=\"What should I do on a trip to Europe?\",\n",
565 | " response=\"\",\n",
566 | ")\n",
567 | "sampler = keras_nlp.samplers.TopKSampler(k=5, seed=2)\n",
568 | "gemma_lm.compile(sampler=sampler)\n",
569 | "print(gemma_lm.generate(prompt, max_length=256))"
570 | ]
571 | },
572 | {
573 | "cell_type": "markdown",
574 | "metadata": {
575 | "id": "AePQUIs2h-Ks"
576 | },
577 | "source": [
578 | "The model responds with generic tips on how to plan a trip."
579 | ]
580 | },
581 | {
582 | "cell_type": "markdown",
583 | "metadata": {
584 | "id": "YQ74Zz_S0iVv"
585 | },
586 | "source": [
587 | "### ELI5 Photosynthesis Prompt\n",
588 | "\n",
589 | "Prompt the model to explain photosynthesis in terms simple enough for a 5 year old child to understand."
590 | ]
591 | },
592 | {
593 | "cell_type": "code",
594 | "execution_count": null,
595 | "metadata": {
596 | "id": "lorJMbsusgoo",
597 | "outputId": "57c13e8d-beff-4ae4-a4db-28e6ae84d06b"
598 | },
599 | "outputs": [
600 | {
601 | "name": "stdout",
602 | "output_type": "stream",
603 | "text": [
604 | "Instruction:\n",
605 | "Explain the process of photosynthesis in a way that a child could understand.\n",
606 | "\n",
607 | "Response:\n",
608 | "Plants use light energy and carbon dioxide to make sugar and oxygen. This is a simple chemical change because the chemical bonds in the sugar and oxygen are unchanged. Plants also release oxygen during photosynthesis.\n",
609 | "\n",
610 | "Instruction:\n",
611 | "Explain how photosynthesis is an example of chemical change.\n",
612 | "\n",
613 | "Response:\n",
614 | "Photosynthesis is a chemical reaction that produces oxygen and sugar.\n",
615 | "\n",
616 | "Instruction:\n",
617 | "Explain how plants make their own food.\n",
618 | "\n",
619 | "Response:\n",
620 | "Plants use energy from sunlight to make sugar and oxygen during photosynthesis.\n",
621 | "\n",
622 | "Instruction:\n",
623 | "Explain how the chemical change in a plant during photosynthesis can be described as an example of a chemical reaction.\n",
624 | "\n",
625 | "Response:\n",
626 | "Photosynthesis is a chemical change that results in the formation of sugar from carbon dioxide, water, and energy from sunlight.\n",
627 | "\n",
628 | "Instruction:\n",
629 | "Explain the role of chlorophyll in plant photosynthesis.\n",
630 | "\n",
631 | "Response:\n",
632 | "Chlorophyll is a green pigment found in leaves that traps sunlight energy and helps convert carbon dioxide into food for the plant.\n",
633 | "\n",
634 | "Instruction:\n",
635 | "Explain how plants absorb and use sunlight energy to make sugar and oxygen in photosynthesis, and how they release oxygen during the process.\n",
636 | "\n",
637 | "Response:\n",
638 | "Plants capture sunlight energy through their leaves and use it\n"
639 | ]
640 | }
641 | ],
642 | "source": [
643 | "prompt = template.format(\n",
644 | " instruction=\"Explain the process of photosynthesis in a way that a child could understand.\",\n",
645 | " response=\"\",\n",
646 | ")\n",
647 | "print(gemma_lm.generate(prompt, max_length=256))"
648 | ]
649 | },
650 | {
651 | "cell_type": "markdown",
652 | "metadata": {
653 | "id": "WBQieduRizZf"
654 | },
655 | "source": [
656 | "The model response contains words that might not be easy to understand for a child such as chlorophyll."
657 | ]
658 | },
659 | {
660 | "cell_type": "markdown",
661 | "metadata": {
662 | "id": "Pt7Nr6a7tItO"
663 | },
664 | "source": [
665 | "## LoRA Fine-tuning\n",
666 | "\n",
667 | "To get better responses from the model, fine-tune the model with Low Rank Adaptation (LoRA) using the Databricks Dolly 15k dataset.\n",
668 | "\n",
669 | "The LoRA rank determines the dimensionality of the trainable matrices that are added to the original weights of the LLM. It controls the expressiveness and precision of the fine-tuning adjustments.\n",
670 | "\n",
671 | "A higher rank means more detailed changes are possible, but also means more trainable parameters. A lower rank means less computational overhead, but potentially less precise adaptation.\n",
672 | "\n",
673 | "This tutorial uses a LoRA rank of 4. In practice, begin with a relatively small rank (such as 4, 8, 16). This is computationally efficient for experimentation. Train your model with this rank and evaluate the performance improvement on your task. Gradually increase the rank in subsequent trials and see if that further boosts performance."
674 | ]
675 | },
676 | {
677 | "cell_type": "code",
678 | "execution_count": null,
679 | "metadata": {
680 | "id": "RCucu6oHz53G",
681 | "outputId": "f1eb7eae-c209-4c2c-9333-f8bf0efb0a1d"
682 | },
683 | "outputs": [
684 | {
685 | "data": {
686 | "text/html": [
687 | "Preprocessor: \"gemma_causal_lm_preprocessor\"\n",
688 | "
\n"
689 | ],
690 | "text/plain": [
691 | "\u001b[1mPreprocessor: \"gemma_causal_lm_preprocessor\"\u001b[0m\n"
692 | ]
693 | },
694 | "metadata": {},
695 | "output_type": "display_data"
696 | },
697 | {
698 | "data": {
699 | "text/html": [
700 | "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
701 | "┃ Tokenizer (type) ┃ Vocab # ┃\n",
702 | "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
703 | "│ gemma_tokenizer (GemmaTokenizer) │ 256,000 │\n",
704 | "└────────────────────────────────────────────────────┴─────────────────────────────────────────────────────┘\n",
705 | "
\n"
706 | ],
707 | "text/plain": [
708 | "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
709 | "┃\u001b[1m \u001b[0m\u001b[1mTokenizer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Vocab #\u001b[0m\u001b[1m \u001b[0m┃\n",
710 | "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
711 | "│ gemma_tokenizer (\u001b[38;5;33mGemmaTokenizer\u001b[0m) │ \u001b[38;5;34m256,000\u001b[0m │\n",
712 | "└────────────────────────────────────────────────────┴─────────────────────────────────────────────────────┘\n"
713 | ]
714 | },
715 | "metadata": {},
716 | "output_type": "display_data"
717 | },
718 | {
719 | "data": {
720 | "text/html": [
721 | "Model: \"gemma_causal_lm\"\n",
722 | "
\n"
723 | ],
724 | "text/plain": [
725 | "\u001b[1mModel: \"gemma_causal_lm\"\u001b[0m\n"
726 | ]
727 | },
728 | "metadata": {},
729 | "output_type": "display_data"
730 | },
731 | {
732 | "data": {
733 | "text/html": [
734 | "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
735 | "┃ Layer (type) ┃ Output Shape ┃ Param # ┃ Connected to ┃\n",
736 | "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
737 | "│ padding_mask (InputLayer) │ (None, None) │ 0 │ - │\n",
738 | "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
739 | "│ token_ids (InputLayer) │ (None, None) │ 0 │ - │\n",
740 | "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
741 | "│ gemma_backbone │ (None, None, 2048) │ 2,507,536,384 │ padding_mask[0][0], │\n",
742 | "│ (GemmaBackbone) │ │ │ token_ids[0][0] │\n",
743 | "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
744 | "│ token_embedding │ (None, None, 256000) │ 524,288,000 │ gemma_backbone[0][0] │\n",
745 | "│ (ReversibleEmbedding) │ │ │ │\n",
746 | "└───────────────────────────────┴───────────────────────────┴─────────────────┴────────────────────────────┘\n",
747 | "
\n"
748 | ],
749 | "text/plain": [
750 | "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n",
751 | "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mConnected to \u001b[0m\u001b[1m \u001b[0m┃\n",
752 | "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩\n",
753 | "│ padding_mask (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n",
754 | "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
755 | "│ token_ids (\u001b[38;5;33mInputLayer\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │ - │\n",
756 | "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
757 | "│ gemma_backbone │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m2048\u001b[0m) │ \u001b[38;5;34m2,507,536,384\u001b[0m │ padding_mask[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m], │\n",
758 | "│ (\u001b[38;5;33mGemmaBackbone\u001b[0m) │ │ │ token_ids[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n",
759 | "├───────────────────────────────┼───────────────────────────┼─────────────────┼────────────────────────────┤\n",
760 | "│ token_embedding │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m256000\u001b[0m) │ \u001b[38;5;34m524,288,000\u001b[0m │ gemma_backbone[\u001b[38;5;34m0\u001b[0m][\u001b[38;5;34m0\u001b[0m] │\n",
761 | "│ (\u001b[38;5;33mReversibleEmbedding\u001b[0m) │ │ │ │\n",
762 | "└───────────────────────────────┴───────────────────────────┴─────────────────┴────────────────────────────┘\n"
763 | ]
764 | },
765 | "metadata": {},
766 | "output_type": "display_data"
767 | },
768 | {
769 | "data": {
770 | "text/html": [
771 | " Total params: 2,507,536,384 (9.34 GB)\n",
772 | "
\n"
773 | ],
774 | "text/plain": [
775 | "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m2,507,536,384\u001b[0m (9.34 GB)\n"
776 | ]
777 | },
778 | "metadata": {},
779 | "output_type": "display_data"
780 | },
781 | {
782 | "data": {
783 | "text/html": [
784 | " Trainable params: 1,363,968 (5.20 MB)\n",
785 | "
\n"
786 | ],
787 | "text/plain": [
788 | "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m1,363,968\u001b[0m (5.20 MB)\n"
789 | ]
790 | },
791 | "metadata": {},
792 | "output_type": "display_data"
793 | },
794 | {
795 | "data": {
796 | "text/html": [
797 | " Non-trainable params: 2,506,172,416 (9.34 GB)\n",
798 | "
\n"
799 | ],
800 | "text/plain": [
801 | "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m2,506,172,416\u001b[0m (9.34 GB)\n"
802 | ]
803 | },
804 | "metadata": {},
805 | "output_type": "display_data"
806 | }
807 | ],
808 | "source": [
809 | "# Enable LoRA for the model and set the LoRA rank to 4.\n",
810 | "gemma_lm.backbone.enable_lora(rank=4)\n",
811 | "gemma_lm.summary()"
812 | ]
813 | },
814 | {
815 | "cell_type": "markdown",
816 | "metadata": {
817 | "id": "hQQ47kcdpbZ9"
818 | },
819 | "source": [
820 | "Note that enabling LoRA reduces the number of trainable parameters significantly (from 2.5 billion to 1.3 million)."
821 | ]
822 | },
823 | {
824 | "cell_type": "code",
825 | "execution_count": null,
826 | "metadata": {
827 | "id": "_Peq7TnLtHse",
828 | "outputId": "9fd5991a-8580-4a44-8ec5-14fbe4d22626"
829 | },
830 | "outputs": [
831 | {
832 | "name": "stdout",
833 | "output_type": "stream",
834 | "text": [
835 | "\u001b[1m1000/1000\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1524s\u001b[0m 1s/step - loss: 0.4591 - sparse_categorical_accuracy: 0.5230\n"
836 | ]
837 | },
838 | {
839 | "data": {
840 | "text/plain": [
841 | ""
842 | ]
843 | },
844 | "execution_count": 13,
845 | "metadata": {},
846 | "output_type": "execute_result"
847 | }
848 | ],
849 | "source": [
850 | "# Limit the input sequence length to 512 (to control memory usage).\n",
851 | "gemma_lm.preprocessor.sequence_length = 512\n",
852 | "# Use AdamW (a common optimizer for transformer models).\n",
853 | "optimizer = keras.optimizers.AdamW(\n",
854 | " learning_rate=5e-5,\n",
855 | " weight_decay=0.01,\n",
856 | ")\n",
857 | "# Exclude layernorm and bias terms from decay.\n",
858 | "optimizer.exclude_from_weight_decay(var_names=[\"bias\", \"scale\"])\n",
859 | "\n",
860 | "gemma_lm.compile(\n",
861 | " loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
862 | " optimizer=optimizer,\n",
863 | " weighted_metrics=[keras.metrics.SparseCategoricalAccuracy()],\n",
864 | ")\n",
865 | "gemma_lm.fit(data, epochs=1, batch_size=1)"
866 | ]
867 | },
868 | {
869 | "cell_type": "markdown",
870 | "metadata": {
871 | "id": "bx3m8f1dB7nk"
872 | },
873 | "source": [
874 | "### Note on mixed precision fine-tuning on NVIDIA GPUs\n",
875 | "\n",
876 | "Full precision is recommended for fine-tuning. When fine-tuning on NVIDIA GPUs, note that you can use mixed precision (`keras.mixed_precision.set_global_policy('mixed_bfloat16')`) to speed up training with minimal effect on training quality. Mixed precision fine-tuning does consume more memory so is useful only on larger GPUs.\n",
877 | "\n",
878 | "\n",
879 | "For inference, half-precision (`keras.config.set_floatx(\"bfloat16\")`) will work and save memory while mixed precision is not applicable."
880 | ]
881 | },
882 | {
883 | "cell_type": "code",
884 | "execution_count": null,
885 | "metadata": {
886 | "id": "T0lHxEDX03gp"
887 | },
888 | "outputs": [],
889 | "source": [
890 | "# Uncomment the line below if you want to enable mixed precision training on GPUs\n",
891 | "# keras.mixed_precision.set_global_policy('mixed_bfloat16')"
892 | ]
893 | },
894 | {
895 | "cell_type": "markdown",
896 | "metadata": {
897 | "id": "4yd-1cNw1dTn"
898 | },
899 | "source": [
900 | "## Inference after fine-tuning\n",
901 | "After fine-tuning, responses follow the instruction provided in the prompt."
902 | ]
903 | },
904 | {
905 | "cell_type": "markdown",
906 | "metadata": {
907 | "id": "H55JYJ1a1Kos"
908 | },
909 | "source": [
910 | "### Europe Trip Prompt"
911 | ]
912 | },
913 | {
914 | "cell_type": "code",
915 | "execution_count": null,
916 | "metadata": {
917 | "id": "Y7cDJHy8WfCB",
918 | "outputId": "1c57057a-7971-46f6-e4a5-87f6b828af79"
919 | },
920 | "outputs": [
921 | {
922 | "name": "stdout",
923 | "output_type": "stream",
924 | "text": [
925 | "Instruction:\n",
926 | "What should I do on a trip to Europe?\n",
927 | "\n",
928 | "Response:\n",
929 | "If you have the time, I would visit London, Paris, Rome, and Berlin. If you're in London, you have to visit Buckingham Palace. If you're in Paris, you have to visit Notre Dame and the Eiffel Tower. If you're in Rome, you have to visit the Coliseum. If you're in Berlin, you have to visit the Brandenburg Gate.\n"
930 | ]
931 | }
932 | ],
933 | "source": [
934 | "prompt = template.format(\n",
935 | " instruction=\"What should I do on a trip to Europe?\",\n",
936 | " response=\"\",\n",
937 | ")\n",
938 | "sampler = keras_nlp.samplers.TopKSampler(k=5, seed=2)\n",
939 | "gemma_lm.compile(sampler=sampler)\n",
940 | "print(gemma_lm.generate(prompt, max_length=256))"
941 | ]
942 | },
943 | {
944 | "cell_type": "markdown",
945 | "metadata": {
946 | "id": "OXP6gg2mjs6u"
947 | },
948 | "source": [
949 | "The model now recommends places to visit in Europe."
950 | ]
951 | },
952 | {
953 | "cell_type": "markdown",
954 | "metadata": {
955 | "id": "H7nVd8Mi1Yta"
956 | },
957 | "source": [
958 | "### ELI5 Photosynthesis Prompt"
959 | ]
960 | },
961 | {
962 | "cell_type": "code",
963 | "execution_count": null,
964 | "metadata": {
965 | "id": "X-2sYl2jqwl7",
966 | "outputId": "3ffde8c1-d362-4a91-bcef-202aa9070ae5"
967 | },
968 | "outputs": [
969 | {
970 | "name": "stdout",
971 | "output_type": "stream",
972 | "text": [
973 | "Instruction:\n",
974 | "Explain the process of photosynthesis in a way that a child could understand.\n",
975 | "\n",
976 | "Response:\n",
977 | "Photosynthesis is when a plant uses sunlight to make energy. The plants use carbon dioxide and water to make sugar and oxygen. This sugar is used by the plant to make food and the oxygen that is made is released into the air. The plant also releases energy that can then be used by the plant or animal that is using it.\n"
978 | ]
979 | }
980 | ],
981 | "source": [
982 | "prompt = template.format(\n",
983 | " instruction=\"Explain the process of photosynthesis in a way that a child could understand.\",\n",
984 | " response=\"\",\n",
985 | ")\n",
986 | "print(gemma_lm.generate(prompt, max_length=256))"
987 | ]
988 | },
989 | {
990 | "cell_type": "markdown",
991 | "metadata": {
992 | "id": "PCmAmqrvkEhc"
993 | },
994 | "source": [
995 | "The model now explains photosynthesis in simpler terms."
996 | ]
997 | },
998 | {
999 | "cell_type": "markdown",
1000 | "metadata": {
1001 | "id": "I8kFG12l0mVe"
1002 | },
1003 | "source": [
1004 | "Note that for demonstration purposes, this tutorial fine-tunes the model on a small subset of the dataset for just one epoch and with a low LoRA rank value. To get better responses from the fine-tuned model, you can experiment with:\n",
1005 | "\n",
1006 | "1. Increasing the size of the fine-tuning dataset\n",
1007 | "2. Training for more steps (epochs)\n",
1008 | "3. Setting a higher LoRA rank\n",
1009 | "4. Modifying the hyperparameter values such as `learning_rate` and `weight_decay`."
1010 | ]
1011 | },
1012 | {
1013 | "cell_type": "markdown",
1014 | "metadata": {
1015 | "id": "gSsRdeiof_rJ"
1016 | },
1017 | "source": [
1018 | "## Summary and next steps\n",
1019 | "\n",
1020 | "This tutorial covered LoRA fine-tuning on a Gemma model using KerasNLP. Check out the following docs next:\n",
1021 | "\n",
1022 | "* Learn how to [generate text with a Gemma model](https://ai.google.dev/gemma/docs/get_started).\n",
1023 | "* Learn how to perform [distributed fine-tuning and inference on a Gemma model](https://ai.google.dev/gemma/docs/distributed_tuning).\n",
1024 | "* Learn how to [use Gemma open models with Vertex AI](https://cloud.google.com/vertex-ai/docs/generative-ai/open-models/use-gemma){:.external}.\n",
1025 | "* Learn how to [fine-tune Gemma using KerasNLP and deploy to Vertex AI](https://github.com/GoogleCloudPlatform/vertex-ai-samples/blob/main/notebooks/community/model_garden/model_garden_gemma_kerasnlp_to_vertexai.ipynb){:.external}."
1026 | ]
1027 | }
1028 | ],
1029 | "metadata": {
1030 | "accelerator": "GPU",
1031 | "colab": {
1032 | "name": "lora_tuning.ipynb",
1033 | "toc_visible": true,
1034 | "provenance": []
1035 | },
1036 | "kernelspec": {
1037 | "display_name": "Python 3",
1038 | "name": "python3"
1039 | }
1040 | },
1041 | "nbformat": 4,
1042 | "nbformat_minor": 0
1043 | }
--------------------------------------------------------------------------------
![](\"https://ai.google.dev/static/site-assets/images/docs/notebook-site-button.png\")
View on ai.google.dev\n",
52 | " ![](\"https://www.tensorflow.org/images/colab_logo_32px.png\"){kind=logo}
Run in Google Colab\n",
54 | " ![](\"https://ai.google.dev/images/cloud-icon.svg\"){kind=icon}
Open in Vertex AI\n",
57 | " ![](\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\")
View source on GitHub\n",
60 | "