{ "cells": [ { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "🦥 Unsloth: Will patch your computer to enable 2x faster free finetuning.\n", "Unsloth: Failed to patch Gemma3ForConditionalGeneration.\n", "🦥 Unsloth Zoo will now patch everything to make training faster!\n", "INFO 05-29 15:16:51 [importing.py:53] Triton module has been replaced with a placeholder.\n", "INFO 05-29 15:16:51 [__init__.py:239] Automatically detected platform cuda.\n" ] } ], "source": [ "import os\n", "import json\n", "import csv\n", "import re\n", "import emoji\n", "import html\n", "import os\n", "import random\n", "from unsloth import FastLanguageModel # Tool for loading the model\n", "from datasets import Dataset\n", "from trl import SFTTrainer # For supervised fine-tuning\n", "from transformers import TrainingArguments # For configuring training parameters\n", "from unsloth import is_bfloat16_supported # Check if bfloat16 is supported\n", "import math\n", "import torch\n", "from tqdm import tqdm\n", "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score # Evaluation metrics\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 1. Data Preprocessing" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "def process_tweets(csv_file, label):\n", " tweets_with_labels = []\n", " # Regular expressions for removing URLs and line breaks\n", " url_pattern = re.compile(r'https?://\\S+|www\\.\\S+')\n", " newline_pattern = re.compile(r'\\n')\n", " \n", " # Check if file exists\n", " if not os.path.exists(csv_file):\n", " print(f\"File not found: {csv_file}\")\n", " return tweets_with_labels # Return empty list or handle error\n", "\n", " try:\n", " with open(csv_file, mode='r', encoding='utf-8') as file:\n", " reader = csv.DictReader(file)\n", " for row in reader:\n", " tweet_text = row.get('Tweet')\n", " if tweet_text:\n", " # Decode HTML entities, e.g., & → &\n", " cleaned_text = html.unescape(tweet_text)\n", "\n", " # Remove mentions (@user)\n", " cleaned_text = re.sub(r'@\\w+', '', cleaned_text)\n", " \n", " # Remove leading hashtags\n", " cleaned_text = re.sub(r'^(#\\w+\\s*)+', '', cleaned_text)\n", "\n", " # Remove URLs and line breaks\n", " cleaned_text = url_pattern.sub(r'', cleaned_text)\n", " cleaned_text = newline_pattern.sub(r' ', cleaned_text) # Replace newlines with space\n", " \n", " # Remove emojis using emoji library\n", " cleaned_text = emoji.replace_emoji(cleaned_text, '')\n", " \n", " # Remove remaining non-ASCII characters\n", " cleaned_text = re.sub(r'[^\\x00-\\x7F]+', '', cleaned_text)\n", "\n", " cleaned_text = cleaned_text.strip() # Remove leading/trailing spaces\n", " \n", " # Add to list if not empty\n", " if cleaned_text:\n", " tweets_with_labels.append({\"text\": cleaned_text, \"label\": label})\n", " except Exception as e:\n", " print(f\"Error processing file {csv_file}: {e}\")\n", " \n", " return tweets_with_labels" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# Process all CSV files in a given directory\n", "def process_directory_tweets(directory_path, label):\n", " processed_data = []\n", " print(f\"Processing directory: {directory_path}\")\n", " if not os.path.isdir(directory_path):\n", " print(f\"Directory not found: {directory_path}\")\n", " return processed_data\n", "\n", " try:\n", " csv_files = [f for f in os.listdir(directory_path) if f.endswith('.csv')]\n", " for file_name in csv_files:\n", " file_path = os.path.join(directory_path, file_name)\n", " print(f\"Processing file: {file_path}\")\n", " processed_data_single_file = process_tweets(file_path, label)\n", " processed_data.extend(processed_data_single_file)\n", " except Exception as e:\n", " print(f\"Error processing directory {directory_path}: {e}\")\n", " \n", " return processed_data" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Processing directory: Datasets/Negative CSV\n", "Processing file: Datasets/Negative CSV/hatewomen.csv\n", "Processing file: Datasets/Negative CSV/hatemen.csv\n", "Processing file: Datasets/Negative CSV/menaretrash.csv\n", "Processing file: Datasets/Negative CSV/Misandry.csv\n", "Processing file: Datasets/Negative CSV/womenarebaddrivers.csv\n", "Processing file: Datasets/Negative CSV/womenarestupid.csv\n", "Processing directory: Datasets/Positive CSV\n", "Processing file: Datasets/Positive CSV/equalityofsexes.csv\n", "Processing file: Datasets/Positive CSV/breastfeeding.csv\n", "Processing file: Datasets/Positive CSV/genderpaygap.csv\n", "Processing file: Datasets/Positive CSV/lgbtq.csv\n", "Cleaned data saved to cleaned_trained_data.json\n", "Total processed tweets: 1885\n" ] } ], "source": [ "# Paths to folders containing CSV files\n", "negative_data_directory = 'Datasets/Negative CSV'\n", "positive_data_directory = 'Datasets/Positive CSV'\n", "\n", "all_processed_data = []\n", "\n", "# Process negative samples\n", "all_processed_data.extend(process_directory_tweets(negative_data_directory, 1))\n", "\n", "# Process positive samples\n", "all_processed_data.extend(process_directory_tweets(positive_data_directory, 0))\n", "\n", "# Shuffle all processed data\n", "random.shuffle(all_processed_data)\n", "\n", "# Save cleaned data to JSON file\n", "output_json_file = 'cleaned_trained_data.json'\n", "with open(output_json_file, 'w', encoding='utf-8') as f:\n", " json.dump(all_processed_data, f, ensure_ascii=False, indent=4)\n", "\n", "print(f\"Cleaned data saved to {output_json_file}\")\n", "\n", "# Print total number of processed tweets\n", "print(f\"Total processed tweets: {len(all_processed_data)}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 2.Train the model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.1 Evaluate function" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# Model evaluation function\n", "def evaluate_model(model, tokenizer, evaluation_data, instruction):\n", " \"\"\"Evaluate model performance using accuracy, precision, recall, and F1 score (binary labels)\"\"\"\n", " model.eval()\n", " true_labels_list = []\n", " pred_labels_list = []\n", " \n", " print(\"\\nEvaluating model...\")\n", " with torch.no_grad():\n", " for item in tqdm(evaluation_data, desc=\"Evaluating\"):\n", " tweet_text = item.get(\"text\")\n", " true_label_numeric = item.get(\"label\")\n", " \n", " if tweet_text is None or true_label_numeric is None:\n", " continue\n", " \n", " prompt = f\"Instruction: {instruction}\\nInput: {tweet_text}\\nOutput:\"\n", " inputs = tokenizer(prompt, return_tensors=\"pt\", truncation=True, max_length=2048)\n", " inputs = {k: v.to(model.device) for k, v in inputs.items()} \n", " \n", " outputs = model.generate(\n", " **inputs,\n", " max_new_tokens=10,\n", " pad_token_id=tokenizer.pad_token_id,\n", " eos_token_id=tokenizer.eos_token_id\n", " )\n", " \n", " response = tokenizer.decode(outputs[0], skip_special_tokens=True)\n", " \n", " try:\n", " output_start = response.rindex(\"Output:\")\n", " output_text = response[output_start + 7:].strip()\n", " pred_label = output_text.split()[0].strip()\n", " if pred_label not in ['1', '0']:\n", " pred_label = ''\n", "\n", " except (ValueError, IndexError):\n", " pred_label = \"\"\n", " \n", " true_labels_list.append(str(true_label_numeric))\n", " if pred_label == '1':\n", " pred_label_for_list = '1'\n", " elif pred_label == '0':\n", " pred_label_for_list = '0'\n", " else:\n", " if true_label_numeric == 1:\n", " pred_label_for_list = '0'\n", " else:\n", " pred_label_for_list = '1'\n", "\n", " pred_labels_list.append(pred_label_for_list)\n", " \n", " # Calculate evaluation metrics\n", " if len(true_labels_list) > 0:\n", " true_labels_list = [str(label) for label in true_labels_list]\n", " pred_labels_list = [str(label) for label in pred_labels_list]\n", "\n", " accuracy = accuracy_score(true_labels_list, pred_labels_list)\n", " try:\n", " precision = precision_score(true_labels_list, pred_labels_list, pos_label='1', zero_division=0)\n", " except ValueError:\n", " precision = 0.0\n", " try:\n", " recall = recall_score(true_labels_list, pred_labels_list, pos_label='1', zero_division=0)\n", " except ValueError:\n", " recall = 0.0\n", " try:\n", " f1 = f1_score(true_labels_list, pred_labels_list, pos_label='1', zero_division=0)\n", " except ValueError:\n", " f1 = 0.0\n", "\n", " print(f\"Total samples: {len(true_labels_list)}\")\n", " print(f\"Accuracy: {accuracy:.4f}\")\n", " print(f\"Precision: {precision:.4f}\")\n", " print(f\"Recall: {recall:.4f}\")\n", " print(f\"F1 Score: {f1:.4f}\")\n", " else:\n", " accuracy = 0.0\n", " print(\"\\nNo valid evaluation data found.\")\n", " \n", " return accuracy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.2 Prepare Train Data" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "==((====))== Unsloth 2025.3.19: Fast Qwen2 patching. Transformers: 4.51.3. vLLM: 0.8.5.post1.\n", " \\\\ /| NVIDIA GeForce RTX 4090. Num GPUs = 1. Max memory: 23.65 GB. Platform: Linux.\n", "O^O/ \\_/ \\ Torch: 2.6.0+cu124. CUDA: 8.9. CUDA Toolkit: 12.4. Triton: 3.2.0\n", "\\ / Bfloat16 = TRUE. FA [Xformers = 0.0.29.post2. FA2 = False]\n", " \"-____-\" Free license: http://github.com/unslothai/unsloth\n", "Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Sliding Window Attention is enabled but not implemented for `eager`; unexpected results may be encountered.\n" ] } ], "source": [ "# Load cleaned JSON data\n", "with open(\"cleaned_trained_data.json\", \"r\", encoding='utf-8') as f:\n", " all_data = json.load(f)\n", "\n", "# Split into training and test set (90% training, 10% test)\n", "train_size = int(len(all_data) * 0.9)\n", "train_data = all_data[:train_size]\n", "test_data = all_data[train_size:]\n", "\n", "# Load pretrained model and tokenizer\n", "max_seq_length = 2048\n", "dtype = None\n", "load_in_4bit = True \n", "\n", "model, tokenizer= FastLanguageModel.from_pretrained(\n", " model_name = \"Qwen2.5-0.5B-Instruct\",\n", " max_seq_length = max_seq_length,\n", " dtype = dtype,\n", " load_in_4bit = load_in_4bit\n", ")\n", "EOS_TOKEN = tokenizer.eos_token\n", "# Instruction: output 1 or 0\n", "instruction = \"Determine whether the following sentence contains gender discrimination. Reply with \\\"1\\\" for yes and \\\"0\\\" for no. Only reply 1 or 0.\"" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# Prepare training data\n", "instruction_texts = [] \n", "for item in train_data:\n", " tweet_text = item.get(\"text\")\n", " label_numeric = item.get(\"label\")\n", " \n", " if tweet_text is not None and label_numeric is not None:\n", " formatted_text = f\"Instruction: {instruction}\\nInput: {tweet_text}\\nOutput: {label_numeric}\" + EOS_TOKEN\n", " instruction_texts.append(formatted_text)\n", "\n", "dataset = {\"text\": instruction_texts}\n", "dataset_length = len(instruction_texts)\n", "dataset = Dataset.from_dict(dataset)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.3 Evaluate the original model" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Evaluating model before fine-tuning...\n", "\n", "Evaluating model...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Evaluating: 100%|██████████| 189/189 [01:05<00:00, 2.91it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Total samples: 189\n", "Accuracy: 0.3598\n", "Precision: 0.3820\n", "Recall: 0.3400\n", "F1 Score: 0.3598\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] }, { "data": { "text/plain": [ "0.35978835978835977" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Evaluate model before fine-tuning\n", "print(\"Evaluating model before fine-tuning...\")\n", "evaluate_model(model, tokenizer, test_data, instruction)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.4 Set training parameters and start training" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Unsloth 2025.3.19 patched 24 layers with 24 QKV layers, 24 O layers and 24 MLP layers.\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "997a050dc2cc45e483c9a9e294560b31", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Unsloth: Tokenizing [\"text\"] (num_proc=8): 0%| | 0/1696 [00:00\n", " \n", " \n", " [81/81 00:56, Epoch 3/4]\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
StepTraining Loss
14.146500
24.192900
33.768500
43.255000
52.900000
62.549800
72.242000
82.203500
92.146200
102.018900
111.989000
121.857400
132.118600
141.811500
151.952500
161.812100
172.013800
182.018100
191.921000
202.001900
212.025800
222.135500
232.134300
241.941200
251.799700
261.916200
271.850200
281.803900
291.737700
301.795500
311.783700
321.767300
331.645700
341.844800
351.869500
361.774400
371.738200
381.716500
391.789400
401.832900
411.721500
421.842900
431.798900
441.740200
451.504900
461.657100
471.746300
481.871300
491.618300
501.792900
511.688400
521.628700
531.735000
541.637300
551.551300
561.483200
571.799100
581.477300
591.582500
601.582300
611.439400
621.627500
631.364500
641.684800
651.543600
661.651500
671.550500
681.679900
691.590700
701.656000
711.589100
721.766400
731.619300
741.521700
751.523600
761.524700
771.558300
781.625100
791.596000
801.478600
811.586800

" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Set the model to training mode and enable gradient computation (usually activates dropout and other training-related mechanisms)\n", "FastLanguageModel.for_training(model)\n", "\n", "# Apply LoRA (Low-Rank Adaptation) for parameter-efficient fine-tuning\n", "model = FastLanguageModel.get_peft_model(\n", " model,\n", " r = 16, # Rank of LoRA; higher values give more expressive power but require more trainable parameters\n", " target_modules = [\"q_proj\", \"k_proj\", \"v_proj\", \"o_proj\",\n", " \"gate_proj\", \"up_proj\", \"down_proj\"], # Names of modules where LoRA layers will be inserted\n", " lora_alpha = 64, # Scaling factor for adjusting the output of LoRA layers\n", " lora_dropout = 0, # Dropout probability for LoRA layers; 0 means no dropout\n", " bias = \"none\", # Whether to train bias terms; \"none\" means do not train them\n", " use_gradient_checkpointing = \"unsloth\", # Enable gradient checkpointing to save memory, using unsloth implementation\n", " random_state = 3407, # Random seed for reproducibility\n", " use_rslora = False, # Whether to use reparameterized structured LoRA (disabled here)\n", " loftq_config = None, # Configuration for quantization; LoftQ is not used here\n", ")\n", "\n", "# Calculate steps per epoch (dataset length divided by effective batch size per step)\n", "steps_per_epoch = math.ceil(dataset_length / (32 * 2)) # batch_size=32, gradient_accumulation=2 → effective batch=64\n", "max_steps = steps_per_epoch * 3 # Set total training steps to cover 3 epochs\n", "\n", "# Create a supervised fine-tuning trainer (SFTTrainer)\n", "trainer = SFTTrainer(\n", " model=model, # The model to be trained\n", " tokenizer=tokenizer, # The tokenizer\n", " train_dataset=dataset, # Training dataset\n", " dataset_text_field=\"text\", # Field in the dataset used for training\n", " max_seq_length=max_seq_length, # Maximum input sequence length\n", " dataset_num_proc=8, # Number of processes for preprocessing\n", " packing=False, # Whether to pack multiple samples together; False means each sample is processed separately\n", " args=TrainingArguments( # Training hyperparameter configuration\n", " per_device_train_batch_size=32, # Batch size per device\n", " gradient_accumulation_steps=2, # Accumulate gradients every 2 batches (simulate larger batch size)\n", " warmup_steps=5, # Number of warmup steps for learning rate\n", " max_steps=max_steps, # Total number of training steps\n", " learning_rate=2e-4, # Initial learning rate\n", " fp16=not is_bfloat16_supported(), # Use fp16 if bfloat16 is not supported (to save memory)\n", " bf16=is_bfloat16_supported(), # Use bfloat16 if supported (more stable)\n", " logging_steps=1, # Log every training step\n", " optim=\"adamw_torch\", # Use AdamW optimizer (PyTorch implementation)\n", " weight_decay=0.01, # Weight decay factor to prevent overfitting\n", " lr_scheduler_type=\"linear\", # Linear learning rate scheduler\n", " seed=3407, # Random seed\n", " output_dir=\"outputs\", # Output directory for models and logs\n", " report_to=\"none\", # Do not use external logging tools like wandb\n", " ),\n", ")\n", "\n", "# Start training\n", "trainer_stats = trainer.train() # Begin training" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Plotting training loss curve...\n" ] }, { "data": { "image/png": "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", "text/plain": [ "

" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Extract and plot the loss curve\n", "print(\"\\nPlotting training loss curve...\")\n", "logging_history = trainer.state.log_history\n", "steps = []\n", "losses = []\n", "for entry in logging_history:\n", " if 'loss' in entry:\n", " steps.append(entry['step'])\n", " losses.append(entry['loss'])\n", "\n", "if steps and losses:\n", " plt.figure(figsize=(10, 6))\n", " plt.plot(steps, losses)\n", " plt.xlabel(\"Training Step\")\n", " plt.ylabel(\"Training Loss\")\n", " plt.title(\"Training Loss Curve\")\n", " plt.grid(True)\n", " plt.show()\n", "else:\n", " print(\"Not enough loss data to plot the curve.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 2.5 Evaluate the fine-tuned model" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Evaluating the fine-tuned model...\n", "\n", "Evaluating model...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Evaluating: 100%|██████████| 189/189 [00:33<00:00, 5.58it/s]" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Total samples: 189\n", "Accuracy: 0.9524\n", "Precision: 0.9505\n", "Recall: 0.9600\n", "F1 Score: 0.9552\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] }, { "data": { "text/plain": [ "0.9523809523809523" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Evaluate the fine-tuned model (directly using the pre-split test set)\n", "print(\"\\nEvaluating the fine-tuned model...\")\n", "evaluate_model(model, tokenizer, test_data, instruction)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 3. Save the fine-tuned model" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Saving the fine-tuned model locally to: finetuned_model\n", "Unsloth: Merging 4bit and LoRA weights to 16bit...\n", "Unsloth: Will use up to 643.81 out of 1007.51 RAM for saving.\n", "Unsloth: Saving model... This might take 5 minutes ...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "100%|██████████| 24/24 [00:00<00:00, 122.66it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Unsloth: Saving tokenizer... Done.\n", "Done.\n", "Model saved successfully.\n", "Model training and evaluation completed!\n" ] } ], "source": [ "# Save the fine-tuned model\n", "output_dir = \"finetuned_model\"\n", "os.makedirs(output_dir, exist_ok=True)\n", "print(f\"\\nSaving the fine-tuned model locally to: {output_dir}\")\n", "model.save_pretrained_merged(output_dir, tokenizer, save_method = \"merged_16bit\")\n", "print(\"Model saved successfully.\")\n", "\n", "print(\"Model training and evaluation completed!\")" ] } ], "metadata": { "kernelspec": { "display_name": "base", "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.10.8" } }, "nbformat": 4, "nbformat_minor": 2 }