Upload 4 files

Readme.md

@@ -0,0 +1,138 @@
+# Project SecureAi Labs
+
+This project is designed for fine-tuning language models using the Unsloth library with LoRA adapters, and it provides utilities for training, testing, and formatting data for various models like Phi-3, Gemma, and Meta-Llama.
+
+## Table of Contents
+1. [Prerequisites](#prerequisites)
+2. [File Descriptions](#file-descriptions)
+   - [TRAINER.ipynb](#traineripynb)
+   - [TESTER.ipynb](#testeripynb)
+   - [dataFormat.ipynb](#dataformatipynb)
+3. [Usage](#usage)
+   - [Environment Setup](#environment-setup)
+   - [Training a Model](#training-a-model)
+   - [Testing the Model](#testing-the-model)
+   - [Formatting Data](#formatting-data)
+4. [Additional Resources](#additional-resources)
+
+---
+
+## Prerequisites
+
+Before running the project, ensure you have the following:
+- A [Hugging Face](https://huggingface.co) account and token.
+- Google Colab or a local environment with Python 3.x and CUDA support.
+- Installed packages like `unsloth`, `huggingface_hub`, `peft`, `trl`, and others (automatically installed in the notebooks).
+
+NOTE GPU Requirements:
+
+```python
+models = [
+    'Phi-3.5-mini-instruct-bnb-4bit', # |Min Training Gpu : T4, Min Testing GPU: T4, Max Model size : 14.748 GB|
+    'gemma-2-27b-it-bnb-4bit',  # |Min Training Gpu: A100, Min Testing GPU: L4, Max Model size: 39.564GB|
+    'Meta-Llama-3.1-8B-Instruct-bnb-4bit' # |Min Training Gpu: T4, Min Testing GPU: T4, Max Model size : 22.168GB|
+]
+```
+
+Refer to the [Unsloth Documentation](https://unsloth.ai/) for more details.
+
+## File Descriptions
+
+### 1. `TRAINER.ipynb`
+
+This notebook is responsible for training a language model with LoRA adapters using the Unsloth library. The core functionality includes:
+- Loading a pre-trained model from Hugging Face using `FastLanguageModel`.
+- Attaching LoRA adapters for efficient fine-tuning of large models.
+- Setting training configurations (e.g., learning rate, number of epochs, batch size) using the `SFTTrainer` from the `transformers` library.
+- Optionally, resuming training from the last checkpoint.
+- Uploading checkpoints and models to Hugging Face during or after training.
+
+#### How to Use:
+1. Open this notebook in Google Colab or a similar environment.
+2. Ensure you have set up your Hugging Face token (refer to the section below for setup).
+3. Customize the training parameters if needed.
+4. Run the notebook cells to train the model.
+
+### 2. `TESTER.ipynb`
+
+This notebook handles the evaluation of a fine-tuned model. It allows testing the model's accuracy and efficiency on a test dataset using pre-defined metrics like accuracy, precision, recall, and F1 score. It provides the following functionalities:
+- Loads the fine-tuned model with its LoRA adapters.
+- Defines a function to evaluate the model's predictions on a test dataset.
+- Outputs accuracy and other classification metrics.
+- Displays confusion matrices for better insight into model performance.
+
+#### How to Use:
+1. Load this notebook in your environment.
+2. Specify the test dataset and model details.
+3. Run the evaluation loop to get accuracy, predictions, and metrics visualizations.
+
+### 3. `dataFormat.ipynb`
+
+This notebook formats datasets into the correct structure for training and testing models. It provides functionality to map raw text data into a format suitable for language model training, particularly for multi-turn conversations:
+- Formats conversations into a chat-based template using Unsloth's `chat_templates`.
+- Maps data fields like "role", "content", and user/assistant conversations.
+- Prepares the dataset for tokenization and input to the model.
+
+#### How to Use:
+1. Open the notebook and specify the dataset you wish to format.
+2. Adjust any template settings based on the model you're using.
+3. Run the notebook to output the formatted dataset.
+
+---
+
+## Usage
+
+### Environment Setup
+
+1. **Install Unsloth**:
+   The following command is included in the notebooks to install Unsloth:
+   ```bash
+   !pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
+   ```
+
+2. **Install Additional Dependencies**:
+   These dependencies are also required:
+   ```bash
+   !pip install --no-deps xformers==0.0.27 trl peft accelerate bitsandbytes triton
+   ```
+
+3. **Hugging Face Token Setup**:
+   - Add your Hugging Face token as an environment variable in Google Colab or in your local environment.
+   - Use the Hugging Face token to download models and upload checkpoints:
+     ```python
+     from google.colab import userdata
+     from huggingface_hub import login
+     login(userdata.get('TOKEN'))
+     ```
+
+### Training a Model
+
+1. Open `TRAINER.ipynb`.
+2. Customize the model, template, and LoRA settings in the notebook.
+3. Set training configurations (e.g., epochs, learning rate).
+4. Run the notebook to start the training process.
+
+The model will automatically be saved at checkpoints and uploaded to Hugging Face.
+
+### Testing the Model
+
+1. Load `TESTER.ipynb` in your environment.
+2. Load the fine-tuned model with LoRA adapters.
+3. Specify a test dataset in the appropriate format.
+4. Run the evaluation function to get predictions, accuracy, and other metrics.
+
+### Formatting Data
+
+1. Use `dataFormat.ipynb` to format raw data into a training-friendly structure.
+2. Map the conversation fields using the `formatting_prompts_func`.
+3. Output the formatted data and use it in the training or testing notebooks.
+
+---
+
+## Additional Resources
+
+- Unsloth Documentation: [Unsloth.ai](https://unsloth.ai/)
+- Hugging Face Security Tokens: [Hugging Face Tokens](https://huggingface.co/docs/hub/en/security-tokens)
+- For issues, please refer to each library's official documentation or GitHub pages.
+
+---

dataFormat.ipynb

@@ -0,0 +1,127 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "fe805f91",
+   "metadata": {},
+   "source": [
+    "This script is used to convert the Ton iot datasets into jsonl that can be used by the tokenizer in the training and testing scripts in order to be in the correct format to train the models."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "4dc6bc25",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import csv\n",
+    "import json\n",
+    "\n",
+    "# Path to desired file to be converted\n",
+    "csv_file = 'train_test_network.csv'\n",
+    "\n",
+    "# Name of file to be written to\n",
+    "jsonl_file = 'train_test_network.jsonl'\n",
+    "\n",
+    "with open(csv_file, 'r') as f, open(jsonl_file, 'w') as jsonl_f:\n",
+    "    reader = csv.DictReader(f)\n",
+    "    \n",
+    "    for row in reader:\n",
+    "        # Normalize the label to ensure comparison is case-insensitive\n",
+    "        label = row['type'].strip().lower()\n",
+    "        \n",
+    "        # For converting the dataset to binary. If you are doing multi-class comment out this line\n",
+    "        label = 'normal' if label == 'normal' else 'attack'\n",
+    "\n",
+    "        \n",
+    "        # Construct the user message by concatenating all relevant fields\n",
+    "        user_message = \", \".join([f\"{key}: {value}\" for key, value in row.items() if key != 'label' and key != 'type'])\n",
+    "        \n",
+    "        # Create the conversation in the desired format\n",
+    "        conversation = {\n",
+    "            \"conversations\": [\n",
+    "                {\"from\": \"human\", \"value\": user_message},\n",
+    "                {\"from\": \"gpt\", \"value\": label}\n",
+    "            ]\n",
+    "        }\n",
+    "        \n",
+    "        # Write each conversation as a JSON object in a new line\n",
+    "        jsonl_f.write(json.dumps(conversation) + \"\\n\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4444baf3",
+   "metadata": {},
+   "source": [
+    "Output will look like:\n",
+    "\n",
+    "```\n",
+    "{\"conversations\": [{\"from\": \"human\", \"value\": \"\\ufeffsrc_ip: 192.168.1.192, src_port: 5353, dst_ip: 224.0.0.251, dst_port: 5353, proto: udp, service: dns, duration: 0, src_bytes: 0, dst_bytes: 0, conn_state: S0, missed_bytes: 0, src_pkts: 1, src_ip_bytes: 73, dst_pkts: 0, dst_ip_bytes: 0, dns_query: _ipps._tcp.local, dns_qclass: 1, dns_qtype: 12, dns_rcode: 0, dns_AA: F, dns_RD: F, dns_RA: F, dns_rejected: F, ssl_version: -, ssl_cipher: -, ssl_resumed: -, ssl_established: -, ssl_subject: -, ssl_issuer: -, http_trans_depth: -, http_method: -, http_uri: -, http_version: -, http_request_body_len: 0, http_response_body_len: 0, http_status_code: 0, http_user_agent: -, http_orig_mime_types: -, http_resp_mime_types: -, weird_name: -, weird_addl: -, weird_notice: -\"}, {\"from\": \"gpt\", \"value\": \"normal\"}]}\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0a36087b",
+   "metadata": {},
+   "source": [
+    "If you want to Split datasets and save them seperately in order to upload them to huggingface use this. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "19944860",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load dataset from the JSONL file\n",
+    "dataset = load_dataset('json', data_files=jsonl_file, split='train')\n",
+    "\n",
+    "# Split the dataset\n",
+    "split_dataset = dataset.train_test_split(test_size=0.2)  # 20% test data\n",
+    "\n",
+    "# Access the training and testing splits\n",
+    "train_dataset = split_dataset['train']\n",
+    "test_dataset = split_dataset['test']\n",
+    "\n",
+    "# Define paths for saving the datasets\n",
+    "jsonl_train = 'train_network.jsonl'\n",
+    "jsonl_test = 'test_network.jsonl'\n",
+    "\n",
+    "# Save train_dataset to JSONL file\n",
+    "with open(jsonl_train, 'w') as train_f:\n",
+    "    for example in train_dataset:\n",
+    "        train_f.write(json.dumps(example) + \"\\n\")\n",
+    "\n",
+    "# Save test_dataset to JSONL file\n",
+    "with open(jsonl_test, 'w') as test_f:\n",
+    "    for example in test_dataset:\n",
+    "        test_f.write(json.dumps(example) + \"\\n\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}