Merge pull request #1734 from jasonrandrews/review

First review of LLM fine-tuning for web applications Learning Path.

Author: jasonrandrews

content/learning-paths/embedded-and-microcontrollers/llm-fine-tuning-for-web-applications/_index.md

@@ -1,32 +1,32 @@
 ---
-title: LLM Fine-Tuning for Web Applications
+title: LLM fine-tuning for web applications
 
 draft: true
 cascade:
     draft: true
 
 minutes_to_complete: 60
 
-who_is_this_for: This learning path provides an introduction for developers and data scientists new to fine-tuning large language models (LLMs) and looking to develop a fine-tuned LLM for web applications. Fine-tuning involves adapting a pre-trained LLM to specific tasks or domains by training it on domain-specific data and optimizing its responses for accuracy and relevance. For web applications, fine-tuning enables personalized interactions, enhanced query handling, and improved contextual understanding, making AI-driven features more effective. This session will cover key concepts, techniques, tools, and best practices, ensuring a structured approach to building a fine-tuned LLM that aligns with real-world web application requirements.
+who_is_this_for: This is an introductory topic for developers and data scientists new to fine-tuning large language models (LLMs) and looking to develop a fine-tuned LLM for web applications. 
 
 learning_objectives: 
     - Learn the basics of large language models (LLMs) and how fine-tuning enhances model performance for specific use cases.
     - Understand full fine-tuning, parameter-efficient fine-tuning (e.g., LoRA, QLoRA, PEFT), and instruction-tuning.
     - Learn when to use different fine-tuning approaches based on model size, task complexity, and computational constraints.
     - Learn how to curate, clean, and preprocess domain-specific datasets for optimal fine-tuning.
     - Understand dataset formats, tokenization, and annotation techniques for improving model learning.
-    - Implementing Fine-Tuning with Popular Frameworks like Hugging Face Transformers and PyTorch for LLM fine-tuning.
+    - Implement fine-tuning with frameworks like Hugging Face Transformers and PyTorch.
 
 prerequisites:
-    - An AWS Graviton4 r8g.16xlarge instance to test Arm performance optimizations, or any [Arm based instance](/learning-paths/servers-and-cloud-computing/csp/) from a cloud service provider or an on-premise Arm server or Arm based laptop.
-    - Basic Understanding of Machine Learning & Deep Learning (Familiarity with concepts like supervised learning, neural networks, transfer learning and Understanding of model training, validation, & overfitting concepts).
-    - Familiarity with Deep Learning Frameworks (Experience with PyTorch for building, training neural networks and Knowledge of Hugging Face Transformers for working with pre-trained LLMs.
+    - An AWS Graviton4 instance. You can substitute any Arm based Linux computer. Refer to [Get started with Arm-based cloud instances](/learning-paths/servers-and-cloud-computing/csp/) for more information about cloud service providers offering Arm-based instances. 
+    - Basic understanding of machine learning and deep learning. 
+    - Familiarity with deep learning frameworks such as PyTorch and Hugging Face Transformers. 
 
 author: Parichay Das
 
 ### Tags
 skilllevels: Introductory
-subjects: GenAI
+subjects: ML
 armips:
     - Neoverse
 

content/learning-paths/embedded-and-microcontrollers/llm-fine-tuning-for-web-applications/how-to-0.md

@@ -0,0 +1,102 @@
+---
+title: Create a Jupyter notebook on an Arm server
+weight: 3
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+You can use a Jupyter notebook running on an Arm server for fine-tuning LLMs.
+
+## Install a Jupyter notebook on an Arm server
+
+Follow the steps below to create, configure, and connect to a Jupyter notebook on an Arm server. 
+
+### Before you begin
+
+You need an Arm server or other Arm Linux machine to run a Jupyter notebook. 
+
+You can use an AWS Graviton4 `r8g.16xlarge` instance to perform fine tuning or a similar Arm server. Refer to [Get started with Arm-based cloud instances](/learning-paths/servers-and-cloud-computing/csp/) for more information about cloud service providers offering Arm-based instances. 
+
+The instructions are provided for Ubuntu 24.04, but other Linux distributions are possible. 
+
+Make sure you can connect by SSH to the Arm server. 
+
+Jupyter notebooks run on port 8888. You can open this port or use SSH port forwarding. 
+
+Install the required software:
+
+```console
+sudo apt-get update
+sudo apt-get install python3-pip python3-venv python3-dev python-is-python3 -y
+```
+
+Create a Python virtual environment by running:
+
+```bash
+python -m venv venv
+source venv/bin/activate
+```
+
+In your virtual environment, install Jupyter:
+
+```bash
+pip install jupyter
+```
+
+### Configure a Jupyter notebook
+
+Generate a Jupyter configuration file with the command below:
+
+```console
+jupyter notebook --generate-config
+```
+
+Use a text edit to edit the configuration file:
+
+```console
+~/.jupyter/jupyter_notebook_config.py
+```
+    
+Modify the configuration file to include the lines below:
+
+```console
+c.NotebookApp.ip = '0.0.0.0'
+c.NotebookApp.port = 8888
+c.NotebookApp.open_browser = False
+c.NotebookApp.notebook_dir = '/home/ubuntu'
+```
+
+### Open port 888 
+
+To access the Jupyter notebook you need to either open port 8888 in the security group or use SSH port forwarding. 
+
+If you are using a cloud instance, add an incoming rule for TCP access to port 8888 from your IP address. Refer to the cloud service provider documentation for security groups. 
+
+If you want to use SSH port forwarding, you can connect to the Arm server using:
+
+```console
+ssh -i <ssh-private-key> -L 8888:localhost:8888 <user>@<ip-address> 
+```
+
+### Start Jupyter notebook
+
+Start the Jupyter notebook using:
+
+```console
+jupyter notebook
+```
+
+URLs are printed in the terminal output. 
+
+If you are using SSH port forwarding copy the URL with 127.0.0.0 and if you are opening port 8888 copy the URL with the IP address of the Arm server.
+
+### Connect to the Jupyter notebook using your browser
+
+Open a web browser on your local machine and paste the copied URL into the address bar and press enter.
+
+You are now connected to Jupyter notebook running on your Arm server.
+
+Click `File` from the menu and navigate to `New` select `Notebook`. For the kernel select `Python 3`.
+
+You see an empty cell in your notebook, and you are ready to use your Jupyter notebook for fine-tuning LLMs.

content/learning-paths/embedded-and-microcontrollers/llm-fine-tuning-for-web-applications/how-to-1.md

@@ -1,42 +1,57 @@
 ---
-title: Overview
+title: What is fine-tuning?
 weight: 2
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## What is Fine-Tuning
-Fine-tuning in the context of large language models (LLMs) refers to the process of further training a pre-trained LLM on domain-specific or task-specific data to enhance its performance for a particular application. LLMs, such as GPT, BERT, and LLaMA, are initially trained on massive corpora containing billions of tokens, enabling them to develop a broad linguistic understanding. Fine-tuning refines this knowledge by exposing the model to specialized datasets, allowing it to generate more contextually relevant and accurate responses. Rather than training an LLM from scratch, fine-tuning leverages the pre-existing knowledge embedded in the model, optimizing it for specific use cases such as customer support, content generation, legal document analysis, or medical text processing. This approach significantly reduces computational requirements and data needs while improving adaptability and efficiency in real-world applications. 
+Fine-tuning in the context of large language models (LLMs) refers to the process of further training a pre-trained LLM on domain-specific or task-specific data to enhance its performance for a particular application. LLMs, such as GPT, BERT, and LLaMA, are initially trained on massive corpora containing billions of tokens, enabling them to develop a broad linguistic understanding. 
 
-## Advantage of Fine-Tuning
-Fine-tuning is essential for optimizing large language models (LLMs) to meet specific application requirements, enhance performance, and reduce computational costs. While pre-trained LLMs have broad linguistic capabilities, they may not always produce domain-specific, contextually accurate, or application-tailored responses
-- Customization for Specific Domains
-- Improved Response Quality and Accuracy
-- Task-Specific Adaptation
-- Reduction in Computational and Data Requirements
-- Enhanced Efficiency in Real-World Applications
-- Alignment with Ethical, Regulatory, and Organizational Guidelines
+Fine-tuning refines this knowledge by exposing the model to specialized datasets, allowing it to generate more contextually relevant and accurate responses. Rather than training an LLM from scratch, fine-tuning leverages the pre-existing knowledge embedded in the model, optimizing it for specific use cases such as customer support, content generation, legal document analysis, or medical text processing. 
+
+This approach significantly reduces computational requirements and data needs while improving adaptability and efficiency in real-world applications. 
+
+## Advantages of fine-tuning
+
+Fine-tuning is essential for optimizing large language models (LLMs) to meet specific application requirements, enhance performance, and reduce computational costs. While pre-trained LLMs have broad linguistic capabilities, they may not always produce domain-specific, contextually accurate, or application-tailored responses.
+
+The advantages of fine-tuning include:
+
+- Customization for specific domains
+- Improved response quality and accuracy
+- Task-specific adaptation
+- Reduction in computational and data requirements
+- Enhanced efficiency in real-world applications
+- Alignment with ethical, regulatory, and organizational guidelines
 
 ## Fine-Tuning Methods
-Fine-tuning LLM uses different techniques based on the various use cases, computational constraints, and efficiency requirements. Below are the key fine-tuning methods:
+
+Fine-tuning LLMs uses different techniques based on the various use cases, computational constraints, and efficiency requirements. 
+
+Below are the key fine-tuning methods:
 
 ### Full Fine-Tuning (Supervised Learning Approach)
-It involves updating all parameters of the LLM using task-specific data, requiring significant computational power and large labeled datasets, which provides the highest level of customization.
+
+Full fine-tuning involves updating all parameters of the LLM using task-specific data, requiring significant computational power and large labeled datasets, which provides the highest level of customization.
 
 ### Instruction Fine-Tuning
-Instruction fine-tuning is a supervised learning method. A pre-trained large language model (LLM) is further trained on instruction-response pairs to improve its ability to follow human instructions accurately. Instruction Fine-Tuning has some key features using Labeled Instruction-Response Pairs, Enhances Model Alignment with Human Intent, Commonly Used in Chatbots and AI Assistants, and Prepares Models for Zero-Shot and Few-Shot Learning.
+
+Instruction fine-tuning is a supervised learning method. A pre-trained large language model (LLM) is further trained on instruction-response pairs to improve its ability to follow human instructions accurately. Instruction fine-tuning has some key features using labeled instruction-response pairs, enhances model alignment with human intent. It is commonly used in chatbots and AI Assistants, and prepares models for zero-shot and few-shot learning.
 
 ### Parameter-Efficient Fine-Tuning (PEFT)
-It is a optimized approaches that reduce the number of trainable parameters while maintaining high performance:
+
+PEFT is an optimized approach that reduces the number of trainable parameters while maintaining high performance.
+
+Some approaches are:
 
 - ###### LoRA (Low-Rank Adaptation)
     - Introduces small trainable weight matrices (rank decomposition) while freezing the main model weights.
-    - It will significantly reduce GPU memory usage and training time.
+    - Significantly reduces GPU memory usage and training time.
 
 - ###### QLoRA (Quantized LoRA)
-    - It will use quantization (e.g., 4-bit or 8-bit precision) to reduce memory footprint while applying LoRA fine-tuning.
-    - It is Ideal for fine-tuning large models on limited hardware.
+    - Uses quantization (e.g., 4-bit or 8-bit precision) to reduce memory footprint while applying LoRA fine-tuning.
+    - Ideal for fine-tuning large models on limited hardware.
 
 - ###### Adapter Layers
     - Inserts small trainable layers between existing layers of the model and Keeps most parameters frozen, reducing computational overhead.
@@ -45,21 +60,24 @@ It is a optimized approaches that reduce the number of trainable parameters whil
     - Fine-tunes models based on human preferences using reinforcement learning.
 
 - ###### Domain-Specific Fine-Tuning
-    - Fine-tunes the LLM with domain-specific datasets and Improves accuracy and relevance in specialized applications.
+    - Fine-tunes the LLM with domain-specific datasets and improves accuracy and relevance in specialized applications.
 
 - ###### Multi-Task Learning (MTL) Fine-Tuning
     - Trains the model on multiple tasks simultaneously, enabling generalization across different applications.
 
 
+## Fine-Tuning Implementation  
 
-## Fine-Tuning Implementaion 
 The following steps need to be performed to implement fine-tuning:
 
+-   Base model selection: Choose a pre-trained model based on your use cases. You can find pre-trained models on [Hugging Face](https://huggingface.co/)
+-   Fine-tuning method finalization: Select the most appropriate fine-tuning method (supervised, instruction-based, PEFT) based on your use case and dataset. You can typically find various datasets on [Hugging Face](https://huggingface.co/datasets) and [Kaggle](https://www.kaggle.com/datasets).
+-   Dataset preparation: Organize your data for your use case-specific training, ensuring it aligns with the model's required format.
+-   Training: Utilize frameworks such as TensorFlow and PyTorch to fine-tune the model.
+-   Evaluate: Evaluate the model, refine it as needed, and retrain to enhance performance.
+
+The steps are depicted in Figure 1 below:
 
-![example image alt-text#center](1.png "Figure 1. Fine-Tuning Implementaion")
+![example image alt-text#center](1.png "Figure 1. Fine-Tuning Implementation")
 
--   Base Model Selection: Choose a pre-trained model based on your use cases. You can find pre-trained models at [Hugging Face](https://huggingface.co/)
--   Fine-Tuning Method Finalization: Select the most appropriate fine-tuning method (e.g., supervised, instruction-based, PEFT) based on your use case and dataset. You can typically find various datasets on [Hugging Face](https://huggingface.co/datasets) and [Kaggle](https://www.kaggle.com/datasets).
--   Dataset Prepration:Organize your data for your use case-specific training, ensuring it aligns with the model's required format.
--   Training:Utilize frameworks such as TensorFlow and PyTorch to fine-tune the model.
--   Evaluate: Evaluate the model, refine it as needed, and retrain to enhance performance
+With this background you are ready to get started with fine-tuning.

content/learning-paths/embedded-and-microcontrollers/llm-fine-tuning-for-web-applications/how-to-2.md

@@ -1,47 +1,60 @@
 ---
-title: Fine Tuning Large Language Model - Setup Environment 
-weight: 3
+title: Set up for fine tuning a large language model 
+
+weight: 4
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Fine Tuning Large Language Model - Setup Environment
+All of the commands are meant to be copied into a cell in your Jupyter notebook. 
+
+Copy each command into a cell, and use `Shift + Enter` to run the cell. After the cell is run, advance to the next command and enter it in a new cell. 
+
+## Install the required libraries
 
-#### Plartform Required 
-An AWS Graviton4 r8g.16xlarge instance to test Arm performance optimizations, or any [Arm based instance](/learning-paths/servers-and-cloud-computing/csp/) from a cloud service provider or an on-premise Arm server or Arm based laptop.
+The following commands install the necessary libraries, including Hugging Face Transformers, Datasets, and fine-tuning methods. These libraries facilitate model loading, training, and fine-tuning. 
 
-#### Set Up Required Libraries
-The following commands install the necessary libraries for the task, including Hugging Face Transformers, Datasets, and fine-tuning methods. These libraries facilitate model loading, training, and fine-tuning
 
-###### The transformers library (by Hugging Face) provides pre-trained LLMs
+Install the Hugging Face transformers library to access pre-trained LLMs.
+
 ```python
 !pip install transformers
-
 ```
-###### This installs transformers along with PyTorch, ensuring that models are trained and fine-tuned using the Torch backend.
+
+Install transformers along with PyTorch, ensuring that models are trained and fine-tuned using the Torch backend.
+
 ```python
 !pip install transformers[torch]
 ```
-###### The datasets library (by Hugging Face) provides access to a vast collection of pre-built datasets
+
+The datasets library (by Hugging Face) provides access to a vast collection of pre-built datasets.
 
 ```python
 !pip install datasets
 ```
-###### The evaluate library provides metrics for model performance assessment
+
+The evaluate library provides metrics for model performance assessment.
 
 ```python
 !pip install evaluate
 ```
-###### Speed up fine-tuning of Large Language Models (LLMs)
-[Unsloth](https://huggingface.co/unsloth) is a library designed to speed up fine-tuning of Large Language Models (LLMs) while reducing computational costs. It optimizes training efficiency, particularly for LoRA (Low-Rank Adaptation) fine-tuning 
+
+### Speed up fine-tuning of Large Language Models (LLMs)
+
+[Unsloth](https://huggingface.co/unsloth) is a library designed to speed up fine-tuning of Large Language Models (LLMs) while reducing computational costs. It optimizes training efficiency, particularly for LoRA (Low-Rank Adaptation) fine-tuning .
+
+
+First, use the `%%capture` command, a Jupyter Notebook magic command that suppresses the output of a cell.
+
 ```python
 %%capture
-# %%capture is a Jupyter Notebook magic command that suppresses the output of a cell.
-
 ```
-##### Uninstalls the existing Unsloth installation and installs the latest version directly from the GitHub repository
+
+Next, uninstall the existing Unsloth and install the latest version directly from the GitHub repository.
 
 ```python
 !pip uninstall unsloth -y && pip install --upgrade --no-cache-dir "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
-```
+```
+
+You have now installed the required software for fine-tuning.