chore: update code structure for improved readability and maintainability

notebook/ai_vs_human/final_archi.md

@@ -1,5 +1,5 @@
 # AI vs Human Text Detector V3 - Final Architecture Summary
-
+dataset = "Pujan-Dev/english_aivshuman"
 **Model Version**: V3  
 **Type**: Hybrid Feature Engineering + TF-IDF Classifier  
 **Output Directory**: `./v3_model/`  

notebook/ai_vs_human_nepali/notebook/Nepali_Ai_vs_Human.ipynb

@@ -0,0 +1,1429 @@
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": 1,
+      "id": "901fc22d",
+      "metadata": {
+        "id": "901fc22d"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/home/pujan/miniconda3/envs/ml/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+            "  from .autonotebook import tqdm as notebook_tqdm\n"
+          ]
+        }
+      ],
+      "source": [
+        "import os\n",
+        "os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'expandable_segments:True'\n",
+        "\n",
+        "import math\n",
+        "import pandas as pd\n",
+        "import torch\n",
+        "from torch.utils.data import Dataset, DataLoader\n",
+        "from transformers import AutoTokenizer, AutoModel, get_linear_schedule_with_warmup\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "from sklearn.metrics import classification_report, f1_score, accuracy_score\n",
+        "import torch.nn as nn\n",
+        "from torch.optim import AdamW"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "id": "70d3c048",
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Columns: ['human_text', 'ai_generated_text']\n",
+            "Prepared dataset shape: (1986, 2)\n",
+            "label\n",
+            "1    996\n",
+            "0    990\n",
+            "Name: count, dtype: int64\n"
+          ]
+        },
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>text</th>\n",
+              "      <th>label</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>हामीले पार्टी एकतापछि कि दुबै पार्टीको सिद्धान...</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>एमाले प्रतिनिधिसभाको प्रत्यक्षतर्फ ८० समानुपात...</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>नेकपा माओवादी केन्द्रका नेता रामनारायण विडारील...</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>प्रदेश नं २ का मुख्यमन्त्रीको रूपमा संघीय समाज...</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>बिहीबार एमालेका अध्यक्ष केपी शर्मा ओली र माओवा...</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "                                                text  label\n",
+              "0  हामीले पार्टी एकतापछि कि दुबै पार्टीको सिद्धान...      0\n",
+              "1  एमाले प्रतिनिधिसभाको प्रत्यक्षतर्फ ८० समानुपात...      0\n",
+              "2  नेकपा माओवादी केन्द्रका नेता रामनारायण विडारील...      1\n",
+              "3  प्रदेश नं २ का मुख्यमन्त्रीको रूपमा संघीय समाज...      1\n",
+              "4  बिहीबार एमालेका अध्यक्�� केपी शर्मा ओली र माओवा...      0"
+            ]
+          },
+          "execution_count": 2,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Load Dataset and convert to binary classification format\n",
+        "DATA_PATH = '../DATASET/new_data.csv'\n",
+        "raw_df = pd.read_csv(DATA_PATH)\n",
+        "print('Columns:', raw_df.columns.tolist())\n",
+        "\n",
+        "required_cols = ['human_text', 'ai_generated_text']\n",
+        "missing = [c for c in required_cols if c not in raw_df.columns]\n",
+        "if missing:\n",
+        "    raise ValueError(f'Missing required columns: {missing}')\n",
+        "\n",
+        "# Build unified training dataframe: text + label (0=Human, 1=AI)\n",
+        "df_human = raw_df[['human_text']].dropna().rename(columns={'human_text': 'text'})\n",
+        "df_human['label'] = 0\n",
+        "\n",
+        "df_ai = raw_df[['ai_generated_text']].dropna().rename(columns={'ai_generated_text': 'text'})\n",
+        "df_ai['label'] = 1\n",
+        "\n",
+        "df = pd.concat([df_human, df_ai], ignore_index=True)\n",
+        "df['text'] = df['text'].astype(str).str.strip()\n",
+        "df = df[df['text'].str.len() > 10].drop_duplicates(subset=['text']).sample(frac=1, random_state=42).reset_index(drop=True)\n",
+        "\n",
+        "print('Prepared dataset shape:', df.shape)\n",
+        "print(df['label'].value_counts())\n",
+        "df.head()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 3,
+      "id": "f93d4c7a",
+      "metadata": {
+        "id": "f93d4c7a"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Nulls in text: 0\n",
+            "Nulls in label: 0\n",
+            "Example text sample:\n",
+            "हामीले पार्टी एकतापछि कि दुबै पार्टीको सिद्धान्त राख्ने कि राख्ने माओवाद र जबज दुबै नराख्ने भन्दा उहाँहरु मान्नु भएन । एमालेका साथीहरुले जवजको विषय उठाउन चाहनुभएन । सिद्धान्तको विषय नै नमिलेपछि पार्टी एकता संयोजन समितिको बैठक रोकियो कार्यदलका एक सदस्\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Quick sanity checks\n",
+        "print('Nulls in text:', int(df['text'].isnull().sum()))\n",
+        "print('Nulls in label:', int(df['label'].isnull().sum()))\n",
+        "print('Example text sample:')\n",
+        "print(df.loc[0, 'text'][:250])"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 4,
+      "id": "ba4a933f",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "ba4a933f",
+        "outputId": "9bf5f0a5-c547-43f1-b8f2-a580024d74a9"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "label\n",
+            "AI       0.501511\n",
+            "Human    0.498489\n",
+            "Name: proportion, dtype: float64\n"
+          ]
+        },
+        {
+          "data": {
+            "text/plain": [
+              "label       \n",
+              "0      count    990.000000\n",
+              "       mean     455.551515\n",
+              "       std       56.825837\n",
+              "       min      299.000000\n",
+              "       25%      418.000000\n",
+              "       50%      458.000000\n",
+              "       75%      494.000000\n",
+              "       max      629.000000\n",
+              "1      count    996.000000\n",
+              "       mean     284.231928\n",
+              "       std       67.165254\n",
+              "       min      103.000000\n",
+              "       25%      238.000000\n",
+              "       50%      282.000000\n",
+              "       75%      331.000000\n",
+              "       max      433.000000\n",
+              "Name: text, dtype: float64"
+            ]
+          },
+          "execution_count": 4,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Class balance\n",
+        "print(df['label'].value_counts(normalize=True).rename({0: 'Human', 1: 'AI'}))\n",
+        "df.groupby('label')['text'].apply(lambda s: s.str.len().describe())"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "id": "d7b48175",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 206
+        },
+        "id": "d7b48175",
+        "outputId": "08bc4562-874c-40c1-d554-1d809a6d0e31"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "<matplotlib.legend.Legend at 0x7fef748b5290>"
+            ]
+          },
+          "execution_count": 5,
+          "metadata": {},
+          "output_type": "execute_result"
+        },
+        {
+          "data": {
+            "image/png": "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",
+            "text/plain": [
+              "<Figure size 900x400 with 1 Axes>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# Visualize text-length distributions by class\n",
+        "df['text_len'] = df['text'].str.len()\n",
+        "ax = df[df['label'] == 0]['text_len'].hist(bins=40, alpha=0.6, label='Human', figsize=(9, 4))\n",
+        "df[df['label'] == 1]['text_len'].hist(bins=40, alpha=0.6, label='AI', ax=ax)\n",
+        "ax.set_title('Text Length Distribution')\n",
+        "ax.set_xlabel('Characters')\n",
+        "ax.set_ylabel('Count')\n",
+        "ax.legend()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "id": "59fe88ce",
+      "metadata": {
+        "id": "59fe88ce"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/html": [
+              "<div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>text</th>\n",
+              "      <th>label</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>हामीले पार्टी एकतापछि कि दुबै पार्टीको सिद्धान...</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>एमाले प्रतिनिधिसभाको प्रत्यक्षतर्फ ८० समानुपात...</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>नेकपा माओवादी केन्द्रका नेता रामनारायण विडारील...</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>प्रदेश नं २ का मुख्यमन्त्रीको रूपमा संघीय समाज...</td>\n",
+              "      <td>1</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>बिहीबार एमालेका अध्यक्ष केपी शर्मा ओली र माओवा...</td>\n",
+              "      <td>0</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "</div>"
+            ],
+            "text/plain": [
+              "                                                text  label\n",
+              "0  हामीले पार्टी एकतापछि कि दुबै पार्टीको सिद्धान...      0\n",
+              "1  एमाले प्रतिनिधिसभाको प्रत्यक्षतर्फ ८० समानुपात...      0\n",
+              "2  नेकपा माओवादी केन्द्रका नेता रामनारायण विडारील...      1\n",
+              "3  प्रदेश नं २ का मुख्यमन्त्रीको रूपमा संघीय समाज...      1\n",
+              "4  बिहीबार एमालेका अध्यक्ष केपी शर्मा ओली र माओवा...      0"
+            ]
+          },
+          "execution_count": 6,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "# Keep only columns needed for training\n",
+        "df = df[['text', 'label']].copy()\n",
+        "df.head()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 7,
+      "id": "434df9a2",
+      "metadata": {
+        "id": "434df9a2"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Using model: distilbert-base-multilingual-cased\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Model/tokenizer config (smaller multilingual model for low-VRAM GPU)\n",
+        "MODEL_NAME = 'distilbert-base-multilingual-cased'\n",
+        "MAX_LEN = 96\n",
+        "\n",
+        "tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)\n",
+        "print('Using model:', MODEL_NAME)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 8,
+      "id": "ef7d53f9",
+      "metadata": {
+        "id": "ef7d53f9"
+      },
+      "outputs": [],
+      "source": [
+        "class NepaliDataset(Dataset):\n",
+        "    def __init__(self, texts, labels):\n",
+        "        self.texts = texts\n",
+        "        self.labels = labels\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        return len(self.texts)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        return {\n",
+        "            'text': self.texts[idx],\n",
+        "            'label': int(self.labels[idx]),\n",
+        "        }"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 9,
+      "id": "134a3fc1",
+      "metadata": {
+        "id": "134a3fc1"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Train: 1588 | Val: 398\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Train/Validation Split\n",
+        "train_texts, val_texts, train_labels, val_labels = train_test_split(\n",
+        "    df['text'].tolist(),\n",
+        "    df['label'].tolist(),\n",
+        "    test_size=0.2,\n",
+        "    random_state=42,\n",
+        "    stratify=df['label'].tolist(),\n",
+        ")\n",
+        "print(f'Train: {len(train_texts)} | Val: {len(val_texts)}')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 10,
+      "id": "dd226ed1",
+      "metadata": {
+        "id": "dd226ed1"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Batch size: 2 | Max length: 96\n"
+          ]
+        }
+      ],
+      "source": [
+        "train_dataset = NepaliDataset(train_texts, train_labels)\n",
+        "val_dataset = NepaliDataset(val_texts, val_labels)\n",
+        "\n",
+        "def collate_batch(batch):\n",
+        "    texts = [item['text'] for item in batch]\n",
+        "    labels = torch.tensor([item['label'] for item in batch], dtype=torch.long)\n",
+        "    enc = tokenizer(\n",
+        "        texts,\n",
+        "        padding=True,\n",
+        "        truncation=True,\n",
+        "        max_length=MAX_LEN,\n",
+        "        return_tensors='pt',\n",
+        "    )\n",
+        "    return {\n",
+        "        'input_ids': enc['input_ids'],\n",
+        "        'attention_mask': enc['attention_mask'],\n",
+        "        'labels': labels,\n",
+        "    }\n",
+        "\n",
+        "BATCH_SIZE = 2\n",
+        "train_loader = DataLoader(\n",
+        "    train_dataset,\n",
+        "    batch_size=BATCH_SIZE,\n",
+        "    shuffle=True,\n",
+        "    collate_fn=collate_batch,\n",
+        "    pin_memory=(torch.cuda.is_available()),\n",
+        ")\n",
+        "val_loader = DataLoader(\n",
+        "    val_dataset,\n",
+        "    batch_size=BATCH_SIZE,\n",
+        "    shuffle=False,\n",
+        "    collate_fn=collate_batch,\n",
+        "    pin_memory=(torch.cuda.is_available()),\n",
+        ")\n",
+        "print('Batch size:', BATCH_SIZE, '| Max length:', MAX_LEN)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 11,
+      "id": "51320951",
+      "metadata": {
+        "id": "51320951"
+      },
+      "outputs": [],
+      "source": [
+        "# === Model ===\n",
+        "class IndicBERTClassifier(nn.Module):\n",
+        "    def __init__(self, dropout=0.2):\n",
+        "        super(IndicBERTClassifier, self).__init__()\n",
+        "        self.bert = AutoModel.from_pretrained(MODEL_NAME)\n",
+        "        if hasattr(self.bert, 'gradient_checkpointing_enable'):\n",
+        "            self.bert.gradient_checkpointing_enable()\n",
+        "        self.dropout = nn.Dropout(dropout)\n",
+        "        self.classifier = nn.Linear(self.bert.config.hidden_size, 2)\n",
+        "\n",
+        "    def forward(self, input_ids, attention_mask):\n",
+        "        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)\n",
+        "        cls_output = outputs.last_hidden_state[:, 0, :]\n",
+        "        cls_output = self.dropout(cls_output)\n",
+        "        return self.classifier(cls_output)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 12,
+      "id": "944f918e",
+      "metadata": {
+        "id": "944f918e"
+      },
+      "outputs": [],
+      "source": [
+        "# Step 8: Create a custom Dataset class\n",
+        "class NepaliTextDataset(Dataset):\n",
+        "    def __init__(self, input_ids, attention_mask, labels):\n",
+        "        self.input_ids = input_ids\n",
+        "        self.attention_mask = attention_mask\n",
+        "        self.labels = labels\n",
+        "\n",
+        "    def __len__(self):\n",
+        "        return len(self.labels)\n",
+        "\n",
+        "    def __getitem__(self, idx):\n",
+        "        return {\n",
+        "            'input_ids': torch.tensor(self.input_ids[idx]),\n",
+        "            'attention_mask': torch.tensor(self.attention_mask[idx]),\n",
+        "            'labels': torch.tensor(self.labels[idx])\n",
+        "        }"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 13,
+      "id": "a9d426e1",
+      "metadata": {
+        "id": "a9d426e1"
+      },
+      "outputs": [
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "Loading weights: 100%|██████████| 100/100 [00:00<00:00, 11666.08it/s]\n",
+            "\u001b[1mDistilBertModel LOAD REPORT\u001b[0m from: distilbert-base-multilingual-cased\n",
+            "Key                     | Status     |  | \n",
+            "------------------------+------------+--+-\n",
+            "vocab_layer_norm.bias   | UNEXPECTED |  | \n",
+            "vocab_transform.weight  | UNEXPECTED |  | \n",
+            "vocab_layer_norm.weight | UNEXPECTED |  | \n",
+            "vocab_transform.bias    | UNEXPECTED |  | \n",
+            "vocab_projector.bias    | UNEXPECTED |  | \n",
+            "\n",
+            "\u001b[3mNotes:\n",
+            "- UNEXPECTED\u001b[3m\t:can be ignored when loading from different task/architecture; not ok if you expect identical arch.\u001b[0m\n"
+          ]
+        }
+      ],
+      "source": [
+        "\n",
+        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+        "model = IndicBERTClassifier().to(device)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 14,
+      "id": "2740c14a",
+      "metadata": {
+        "id": "2740c14a"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Grad accumulation steps: 4\n"
+          ]
+        }
+      ],
+      "source": [
+        "# === Optimizer, Scheduler & Loss ===\n",
+        "optimizer = AdamW(model.parameters(), lr=2e-5, weight_decay=0.01)\n",
+        "loss_fn = nn.CrossEntropyLoss()\n",
+        "\n",
+        "max_epochs = 6\n",
+        "grad_accum_steps = 4  # effective batch = BATCH_SIZE * grad_accum_steps\n",
+        "steps_per_epoch = math.ceil(len(train_loader) / grad_accum_steps)\n",
+        "total_steps = steps_per_epoch * max_epochs\n",
+        "warmup_steps = int(0.1 * total_steps)\n",
+        "scheduler = get_linear_schedule_with_warmup(\n",
+        "    optimizer,\n",
+        "    num_warmup_steps=warmup_steps,\n",
+        "    num_training_steps=total_steps,\n",
+        ")\n",
+        "print('Grad accumulation steps:', grad_accum_steps)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 15,
+      "id": "14ce04bd",
+      "metadata": {
+        "id": "14ce04bd"
+      },
+      "outputs": [],
+      "source": [
+        "# === Training Loop ===\n",
+        "def train(model, loader):\n",
+        "    model.train()\n",
+        "    total_loss = 0\n",
+        "    for batch in loader:\n",
+        "        input_ids = batch['input_ids'].to(device)\n",
+        "        attention_mask = batch['attention_mask'].to(device)\n",
+        "        labels = batch['labels'].to(device)\n",
+        "\n",
+        "        optimizer.zero_grad()\n",
+        "        outputs = model(input_ids, attention_mask)\n",
+        "        loss = loss_fn(outputs, labels)\n",
+        "        loss.backward()\n",
+        "        optimizer.step()\n",
+        "        total_loss += loss.item()\n",
+        "    return total_loss / len(loader)\n",
+        "\n",
+        "# === Evaluation ===\n",
+        "def evaluate(model, loader):\n",
+        "    model.eval()\n",
+        "    preds, true = [], []\n",
+        "    with torch.no_grad():\n",
+        "        for batch in loader:\n",
+        "            input_ids = batch['input_ids'].to(device)\n",
+        "            attention_mask = batch['attention_mask'].to(device)\n",
+        "            labels = batch['labels'].to(device)\n",
+        "\n",
+        "            outputs = model(input_ids, attention_mask)\n",
+        "            pred_labels = torch.argmax(outputs, dim=1)\n",
+        "            preds.extend(pred_labels.cpu().numpy())\n",
+        "            true.extend(labels.cpu().numpy())\n",
+        "\n",
+        "    print(classification_report(true, preds, target_names=[\"Human\", \"AI\"]))\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "d24e91b7",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "d24e91b7",
+        "outputId": "33ef8227-5c71-4c0d-88e7-b1a9e30b45f4"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "\n",
+            "Epoch 1/6\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/tmp/ipykernel_155548/4183901742.py:4: FutureWarning: `torch.cuda.amp.GradScaler(args...)` is deprecated. Please use `torch.amp.GradScaler('cuda', args...)` instead.\n",
+            "  scaler = GradScaler(enabled=use_amp)\n",
+            "/tmp/ipykernel_155548/4183901742.py:17: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
+            "  with autocast(enabled=use_amp):\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Batch 0 | Loss: 0.8206\n",
+            "Batch 50 | Loss: 0.8677\n",
+            "Batch 100 | Loss: 0.8435\n",
+            "Batch 150 | Loss: 0.6523\n",
+            "Batch 200 | Loss: 0.7219\n",
+            "Batch 250 | Loss: 0.5793\n",
+            "Batch 300 | Loss: 0.6833\n",
+            "Batch 350 | Loss: 0.5742\n",
+            "Batch 400 | Loss: 0.4844\n",
+            "Batch 450 | Loss: 0.5671\n",
+            "Batch 500 | Loss: 0.5363\n",
+            "Batch 550 | Loss: 0.5386\n",
+            "Batch 600 | Loss: 0.5520\n",
+            "Batch 650 | Loss: 0.7692\n",
+            "Batch 700 | Loss: 0.4680\n",
+            "Batch 750 | Loss: 0.6353\n",
+            "Train      | Loss: 0.6600 | Acc: 0.5913 | F1: 0.5895\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/tmp/ipykernel_155548/4183901742.py:55: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
+            "  with autocast(enabled=use_amp):\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Validation | Loss: 0.5192 | Acc: 0.8015 | F1: 0.7812\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "       Human       0.75      0.90      0.82       198\n",
+            "          AI       0.88      0.70      0.78       200\n",
+            "\n",
+            "    accuracy                           0.80       398\n",
+            "   macro avg       0.81      0.80      0.80       398\n",
+            "weighted avg       0.81      0.80      0.80       398\n",
+            "\n",
+            "Saved improved checkpoint: model_best.pth\n",
+            "\n",
+            "Epoch 2/6\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/tmp/ipykernel_155548/4183901742.py:17: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
+            "  with autocast(enabled=use_amp):\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Batch 0 | Loss: 0.6078\n",
+            "Batch 50 | Loss: 1.1135\n",
+            "Batch 100 | Loss: 0.3297\n",
+            "Batch 150 | Loss: 0.8473\n",
+            "Batch 200 | Loss: 0.9326\n",
+            "Batch 250 | Loss: 0.5112\n",
+            "Batch 300 | Loss: 0.1645\n",
+            "Batch 350 | Loss: 0.2250\n",
+            "Batch 400 | Loss: 0.7142\n",
+            "Batch 450 | Loss: 0.3741\n",
+            "Batch 500 | Loss: 0.3084\n",
+            "Batch 550 | Loss: 0.1472\n",
+            "Batch 600 | Loss: 0.0679\n",
+            "Batch 650 | Loss: 0.1234\n",
+            "Batch 700 | Loss: 1.1370\n",
+            "Batch 750 | Loss: 0.8843\n",
+            "Train      | Loss: 0.4817 | Acc: 0.7720 | F1: 0.7665\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/tmp/ipykernel_155548/4183901742.py:55: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
+            "  with autocast(enabled=use_amp):\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Validation | Loss: 0.3708 | Acc: 0.8417 | F1: 0.8225\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "       Human       0.78      0.95      0.86       198\n",
+            "          AI       0.94      0.73      0.82       200\n",
+            "\n",
+            "    accuracy                           0.84       398\n",
+            "   macro avg       0.86      0.84      0.84       398\n",
+            "weighted avg       0.86      0.84      0.84       398\n",
+            "\n",
+            "Saved improved checkpoint: model_best.pth\n",
+            "\n",
+            "Epoch 3/6\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/tmp/ipykernel_155548/4183901742.py:17: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
+            "  with autocast(enabled=use_amp):\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Batch 0 | Loss: 0.0415\n",
+            "Batch 50 | Loss: 0.0845\n",
+            "Batch 100 | Loss: 0.0336\n",
+            "Batch 150 | Loss: 0.6389\n",
+            "Batch 200 | Loss: 1.6021\n",
+            "Batch 250 | Loss: 0.0696\n",
+            "Batch 300 | Loss: 0.5184\n",
+            "Batch 350 | Loss: 0.0569\n",
+            "Batch 400 | Loss: 0.8119\n",
+            "Batch 450 | Loss: 1.5121\n",
+            "Batch 500 | Loss: 0.0330\n",
+            "Batch 550 | Loss: 0.0208\n",
+            "Batch 600 | Loss: 1.1329\n",
+            "Batch 650 | Loss: 0.7745\n",
+            "Batch 700 | Loss: 0.0740\n",
+            "Batch 750 | Loss: 1.4907\n",
+            "Train      | Loss: 0.3830 | Acc: 0.8495 | F1: 0.8488\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/tmp/ipykernel_155548/4183901742.py:55: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
+            "  with autocast(enabled=use_amp):\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Validation | Loss: 0.3527 | Acc: 0.8668 | F1: 0.8515\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "       Human       0.80      0.97      0.88       198\n",
+            "          AI       0.97      0.76      0.85       200\n",
+            "\n",
+            "    accuracy                           0.87       398\n",
+            "   macro avg       0.88      0.87      0.87       398\n",
+            "weighted avg       0.88      0.87      0.87       398\n",
+            "\n",
+            "Saved improved checkpoint: model_best.pth\n",
+            "\n",
+            "Epoch 4/6\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/tmp/ipykernel_155548/4183901742.py:17: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
+            "  with autocast(enabled=use_amp):\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Batch 0 | Loss: 1.2321\n",
+            "Batch 50 | Loss: 0.0369\n",
+            "Batch 100 | Loss: 0.0161\n",
+            "Batch 150 | Loss: 0.2000\n",
+            "Batch 200 | Loss: 0.0035\n",
+            "Batch 250 | Loss: 2.3207\n",
+            "Batch 300 | Loss: 0.0022\n",
+            "Batch 350 | Loss: 2.2738\n",
+            "Batch 400 | Loss: 0.0011\n",
+            "Batch 450 | Loss: 0.0075\n",
+            "Batch 500 | Loss: 2.4454\n",
+            "Batch 550 | Loss: 0.3863\n",
+            "Batch 600 | Loss: 0.0038\n",
+            "Batch 650 | Loss: 0.0061\n",
+            "Batch 700 | Loss: 0.0005\n",
+            "Batch 750 | Loss: 0.0182\n",
+            "Train      | Loss: 0.4209 | Acc: 0.8923 | F1: 0.8903\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/tmp/ipykernel_155548/4183901742.py:55: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
+            "  with autocast(enabled=use_amp):\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Validation | Loss: 0.4601 | Acc: 0.8769 | F1: 0.8831\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "       Human       0.92      0.83      0.87       198\n",
+            "          AI       0.84      0.93      0.88       200\n",
+            "\n",
+            "    accuracy                           0.88       398\n",
+            "   macro avg       0.88      0.88      0.88       398\n",
+            "weighted avg       0.88      0.88      0.88       398\n",
+            "\n",
+            "Saved improved checkpoint: model_best.pth\n",
+            "\n",
+            "Epoch 5/6\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/tmp/ipykernel_155548/4183901742.py:17: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
+            "  with autocast(enabled=use_amp):\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Batch 0 | Loss: 0.0010\n",
+            "Batch 50 | Loss: 0.0061\n",
+            "Batch 100 | Loss: 0.0047\n",
+            "Batch 150 | Loss: 0.0201\n",
+            "Batch 200 | Loss: 0.0023\n",
+            "Batch 250 | Loss: 0.0395\n",
+            "Batch 300 | Loss: 0.0011\n",
+            "Batch 350 | Loss: 0.0002\n",
+            "Batch 400 | Loss: 3.2169\n",
+            "Batch 450 | Loss: 4.4883\n",
+            "Batch 500 | Loss: 0.0002\n",
+            "Batch 550 | Loss: 0.0003\n",
+            "Batch 600 | Loss: 0.0000\n",
+            "Batch 650 | Loss: 0.0002\n",
+            "Batch 700 | Loss: 0.0000\n",
+            "Batch 750 | Loss: 4.6367\n",
+            "Train      | Loss: 0.5447 | Acc: 0.9011 | F1: 0.8990\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/tmp/ipykernel_155548/4183901742.py:55: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
+            "  with autocast(enabled=use_amp):\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Validation | Loss: 0.5331 | Acc: 0.9271 | F1: 0.9266\n",
+            "              precision    recall  f1-score   support\n",
+            "\n",
+            "       Human       0.92      0.94      0.93       198\n",
+            "          AI       0.94      0.92      0.93       200\n",
+            "\n",
+            "    accuracy                           0.93       398\n",
+            "   macro avg       0.93      0.93      0.93       398\n",
+            "weighted avg       0.93      0.93      0.93       398\n",
+            "\n",
+            "Saved improved checkpoint: model_best.pth\n",
+            "\n",
+            "Epoch 6/6\n"
+          ]
+        },
+        {
+          "name": "stderr",
+          "output_type": "stream",
+          "text": [
+            "/tmp/ipykernel_155548/4183901742.py:17: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.\n",
+            "  with autocast(enabled=use_amp):\n"
+          ]
+        },
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "Batch 0 | Loss: 0.0000\n"
+          ]
+        }
+      ],
+      "source": [
+        "from torch.cuda.amp import autocast, GradScaler\n",
+        "\n",
+        "use_amp = device.type == 'cuda'\n",
+        "scaler = GradScaler(enabled=use_amp)\n",
+        "\n",
+        "def train_one_epoch(model, loader):\n",
+        "    model.train()\n",
+        "    total_loss = 0.0\n",
+        "    all_preds, all_true = [], []\n",
+        "\n",
+        "    optimizer.zero_grad(set_to_none=True)\n",
+        "    for batch_idx, batch in enumerate(loader):\n",
+        "        input_ids = batch['input_ids'].to(device, non_blocking=True)\n",
+        "        attention_mask = batch['attention_mask'].to(device, non_blocking=True)\n",
+        "        labels = batch['labels'].to(device, non_blocking=True)\n",
+        "\n",
+        "        with autocast(enabled=use_amp):\n",
+        "            logits = model(input_ids, attention_mask=attention_mask)\n",
+        "            loss = loss_fn(logits, labels) / grad_accum_steps\n",
+        "\n",
+        "        scaler.scale(loss).backward()\n",
+        "\n",
+        "        if (batch_idx + 1) % grad_accum_steps == 0 or (batch_idx + 1) == len(loader):\n",
+        "            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)\n",
+        "            scaler.step(optimizer)\n",
+        "            scaler.update()\n",
+        "            scheduler.step()\n",
+        "            optimizer.zero_grad(set_to_none=True)\n",
+        "\n",
+        "        total_loss += loss.item() * grad_accum_steps\n",
+        "        preds = torch.argmax(logits, dim=1)\n",
+        "        all_preds.extend(preds.detach().cpu().numpy())\n",
+        "        all_true.extend(labels.detach().cpu().numpy())\n",
+        "\n",
+        "        if batch_idx % 50 == 0:\n",
+        "            print(f'Batch {batch_idx} | Loss: {(loss.item() * grad_accum_steps):.4f}')\n",
+        "\n",
+        "    avg_loss = total_loss / max(len(loader), 1)\n",
+        "    train_acc = accuracy_score(all_true, all_preds)\n",
+        "    train_f1 = f1_score(all_true, all_preds)\n",
+        "    return avg_loss, train_acc, train_f1\n",
+        "\n",
+        "\n",
+        "def evaluate(model, loader):\n",
+        "    model.eval()\n",
+        "    all_preds, all_true = [], []\n",
+        "    total_loss = 0.0\n",
+        "\n",
+        "    with torch.no_grad():\n",
+        "        for batch in loader:\n",
+        "            input_ids = batch['input_ids'].to(device, non_blocking=True)\n",
+        "            attention_mask = batch['attention_mask'].to(device, non_blocking=True)\n",
+        "            labels = batch['labels'].to(device, non_blocking=True)\n",
+        "\n",
+        "            with autocast(enabled=use_amp):\n",
+        "                logits = model(input_ids, attention_mask=attention_mask)\n",
+        "                loss = loss_fn(logits, labels)\n",
+        "\n",
+        "            total_loss += loss.item()\n",
+        "            preds = torch.argmax(logits, dim=1)\n",
+        "            all_preds.extend(preds.cpu().numpy())\n",
+        "            all_true.extend(labels.cpu().numpy())\n",
+        "\n",
+        "    val_loss = total_loss / max(len(loader), 1)\n",
+        "    val_acc = accuracy_score(all_true, all_preds)\n",
+        "    val_f1 = f1_score(all_true, all_preds)\n",
+        "\n",
+        "    print(f'Validation | Loss: {val_loss:.4f} | Acc: {val_acc:.4f} | F1: {val_f1:.4f}')\n",
+        "    print(classification_report(all_true, all_preds, target_names=['Human', 'AI']))\n",
+        "    return val_loss, val_acc, val_f1\n",
+        "\n",
+        "\n",
+        "# Training with early stopping on validation F1\n",
+        "patience = 2\n",
+        "best_val_f1 = 0.0\n",
+        "epochs_without_improve = 0\n",
+        "\n",
+        "for epoch in range(1, max_epochs + 1):\n",
+        "    print(f'\\nEpoch {epoch}/{max_epochs}')\n",
+        "    if device.type == 'cuda':\n",
+        "        torch.cuda.empty_cache()\n",
+        "\n",
+        "    train_loss, train_acc, train_f1 = train_one_epoch(model, train_loader)\n",
+        "    print(f'Train      | Loss: {train_loss:.4f} | Acc: {train_acc:.4f} | F1: {train_f1:.4f}')\n",
+        "\n",
+        "    val_loss, val_acc, val_f1 = evaluate(model, val_loader)\n",
+        "\n",
+        "    if val_f1 > best_val_f1:\n",
+        "        best_val_f1 = val_f1\n",
+        "        epochs_without_improve = 0\n",
+        "        torch.save(model.state_dict(), 'model_best.pth')\n",
+        "        print('Saved improved checkpoint: model_best.pth')\n",
+        "    else:\n",
+        "        epochs_without_improve += 1\n",
+        "        if epochs_without_improve >= patience:\n",
+        "            print('Early stopping triggered.')\n",
+        "            break\n",
+        "\n",
+        "print(f'Best validation F1: {best_val_f1:.4f}')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "wBIT-kPaswqy",
+      "metadata": {
+        "id": "wBIT-kPaswqy"
+      },
+      "outputs": [],
+      "source": [
+        "# Optional: save current in-memory weights as latest checkpoint\n",
+        "torch.save(model.state_dict(), 'model_latest.pth')\n",
+        "print('Saved: model_latest.pth')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "19b9652c",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "19b9652c",
+        "outputId": "e1b12835-b081-4d46-a909-c92cb3b6d230"
+      },
+      "outputs": [
+        {
+          "data": {
+            "text/plain": [
+              "('./nepali_xlmr_classifier/tokenizer_config.json',\n",
+              " './nepali_xlmr_classifier/special_tokens_map.json',\n",
+              " './nepali_xlmr_classifier/sentencepiece.bpe.model',\n",
+              " './nepali_xlmr_classifier/added_tokens.json',\n",
+              " './nepali_xlmr_classifier/tokenizer.json')"
+            ]
+          },
+          "execution_count": 41,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "tokenizer.save_pretrained(\"./nepali_xlmr_classifier\")"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "eAnrw316iRw8",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "eAnrw316iRw8",
+        "outputId": "04885bb5-4f06-459b-a83c-40f5e00703fe"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "0\n"
+          ]
+        }
+      ],
+      "source": [
+        "def predict(text):\n",
+        "    model.eval()\n",
+        "    inputs = tokenizer(\n",
+        "        text,\n",
+        "        return_tensors='pt',\n",
+        "        truncation=True,\n",
+        "        padding=True,\n",
+        "        max_length=MAX_LEN,\n",
+        "    )\n",
+        "    inputs = {k: v.to(device) for k, v in inputs.items()}\n",
+        "\n",
+        "    with torch.no_grad():\n",
+        "        logits = model(inputs['input_ids'], inputs['attention_mask'])\n",
+        "        probs = torch.softmax(logits, dim=1)\n",
+        "        pred = torch.argmax(probs, dim=1).item()\n",
+        "        confidence = probs[0, pred].item()\n",
+        "\n",
+        "    label = 'AI' if pred == 1 else 'Human'\n",
+        "    return label, confidence\n",
+        "\n",
+        "sample = 'अख्तियार दुरुपयोग अनुसन्धान आयोगले सिन्धुपाल्चोक–२ बाट प्रतिनिधिसभा सदस्य निर्वाचित सांसद तथा पूर्वमन्त्री बस्नेतसहित १६ जना र २ कम्पनी विरुद्ध ३ अर्ब २१ करोडभन्दा बढी बिगो कायम गरी बिहीबार विशेष अदालतमा भ्रष्टाचार मुद्दा दायर गरेको छ ।'\n",
+        "label, conf = predict(sample)\n",
+        "print(f'Prediction: {label} | Confidence: {conf:.4f}')"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "lqGrqG51NiQV",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "lqGrqG51NiQV",
+        "outputId": "6bdae59b-2684-4bd0-f804-d16ebd8272db"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "1\n",
+            "1\n",
+            "1\n",
+            "1\n",
+            "1\n",
+            "1\n",
+            "1\n",
+            "1\n",
+            "1\n",
+            "0\n"
+          ]
+        }
+      ],
+      "source": [
+        "print(predict(\"इन्टरनेटको सुरुवात सन् १९६९ मा अमेरिकी रक्षा मन्त्रालयले निर्माण गरेको ARPANET नामक प्रोजेक्टबाट भएको हो, जसको उद्देश्य आपसी संचारलाई सहज बनाउने थियो र जसले भविष्यमा इन्टरनेटको रूप लियो\"))\n",
+        "\n",
+        "print(predict(\"सुरुमा इन्टरनेट केही वैज्ञानिक तथा सरकारी संस्थाहरूमा सीमित रहेको भए पनि, समयक्रममा यसको पहुँच आम नागरिक, विद्यालय, र व्यवसायिक क्षेत्रमा विस्तार हुँदै गयो\"))\n",
+        "\n",
+        "print(predict(\"ARPANETले कम्प्युटरहरूलाई आपसमा जोड्ने सफल प्रयोग गरेपछि इन्टरनेटको सम्भावना प्रमाणित भयो, जसले गर्दा विश्वभरका अनुसन्धानकर्ताहरू यसप्रति आकर्षित हुन थाले\"))\n",
+        "\n",
+        "print(predict(\"सन् १९९० को दशकमा विश्वव्यापी रूपमा इन्टरनेट विस्तार हुन थालेपछि मानिसहरू सूचनाको आदान–प्रदान, इमेल, र वेबसाइटहरूको प्रयोगमार्फत डिजिटल संसारमा प्रवेश गर्न थाले।\"))\n",
+        "\n",
+        "print(predict(\"इन्टरनेटले शिक्षा, स्वास्थ्य, सञ्चार, मनोरञ्जन, तथा व्यापारजस्ता धेरै क्षेत्रहरूमा अभूतपूर्व परिवर्तन ल्याएको छ, जसले गर्दा मानव जीवन सरल, छरितो र प्रभावकारी बनेको छ।\"))\n",
+        "\n",
+        "print(predict(\"समयसँगै इन्टरनेट एक अत्यावश्यक सेवाको रूपमा विकास भएको छ, जसबिनाको आधुनिक जीवन लगभग असम्भवजस्तै लाग्ने अवस्था सिर्जना भएको छ।\"))\n",
+        "\n",
+        "print(predict(\"आजको युगमा इन्टरनेट केवल सूचना प्राप्तिको माध्यम मात्र नभई ज्ञानको भण्डार, रचनात्मकता प्रदर्शन गर्ने मंच, तथा रोजगार सृजनाको स्रोत पनि बनिसकेको छ।\"))\n",
+        "\n",
+        "print(predict(\"इन्टरनेटको प्रभाव त्यति गहिरो भएको छ कि विद्यालयका बालबालिकादेखि वृद्धसम्म यसको प्रयोगमा संलग्न छन्, जसले डिजिटल विभाजनको अवधारणा जन्माएको छ।\"))\n",
+        "\n",
+        "print(predict(\"इन्टरनेटले विश्वलाई एउटा सानो गाउँमा रूपान्तरण गरेको छ, जहाँ मानिसहरू हजारौं किलोमिटर टाढा भएर पनि एकअर्कासँग प्रत्यक्ष संवाद गर्न सक्छन्।\"))\n",
+        "\n",
+        "print(predict(\"संसदीय समितिले समन्वयकारी भूमिका निर्वाह गर्दै मनसुनजन्य विपद् जोखिम न्यूनीकरण, विपद् प्रतिकार्यका लागि तयारी गर्न तीन तहकै सरकारलाई निर्देशन दिएको छ।\"))\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "X2ePCc5Disrt",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 35
+        },
+        "id": "X2ePCc5Disrt",
+        "outputId": "a4d27689-28cb-43c0-8333-67f2d3a6e097"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "string"
+            },
+            "text/plain": [
+              "'/content/classifier.zip'"
+            ]
+          },
+          "execution_count": 42,
+          "metadata": {},
+          "output_type": "execute_result"
+        }
+      ],
+      "source": [
+        "import shutil\n",
+        "\n",
+        "# Replace 'my_folder' with your folder name or path\n",
+        "folder_path = '/content/nepali_xlmr_classifier'\n",
+        "zip_path = '/content/classifier.zip'\n",
+        "\n",
+        "shutil.make_archive(zip_path.replace('.zip', ''), 'zip', folder_path)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "4BDzVg2gN7xi",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 17
+        },
+        "id": "4BDzVg2gN7xi",
+        "outputId": "ef31798e-24f5-45ad-900f-7528b32ae39f"
+      },
+      "outputs": [
+        {
+          "data": {
+            "application/javascript": "\n    async function download(id, filename, size) {\n      if (!google.colab.kernel.accessAllowed) {\n        return;\n      }\n      const div = document.createElement('div');\n      const label = document.createElement('label');\n      label.textContent = `Downloading \"${filename}\": `;\n      div.appendChild(label);\n      const progress = document.createElement('progress');\n      progress.max = size;\n      div.appendChild(progress);\n      document.body.appendChild(div);\n\n      const buffers = [];\n      let downloaded = 0;\n\n      const channel = await google.colab.kernel.comms.open(id);\n      // Send a message to notify the kernel that we're ready.\n      channel.send({})\n\n      for await (const message of channel.messages) {\n        // Send a message to notify the kernel that we're ready.\n        channel.send({})\n        if (message.buffers) {\n          for (const buffer of message.buffers) {\n            buffers.push(buffer);\n            downloaded += buffer.byteLength;\n            progress.value = downloaded;\n          }\n        }\n      }\n      const blob = new Blob(buffers, {type: 'application/binary'});\n      const a = document.createElement('a');\n      a.href = window.URL.createObjectURL(blob);\n      a.download = filename;\n      div.appendChild(a);\n      a.click();\n      div.remove();\n    }\n  ",
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        },
+        {
+          "data": {
+            "application/javascript": "download(\"download_33034c8f-76d5-48d0-b7cd-3d066ac8e32f\", \"classifier.zip\", 6596694)",
+            "text/plain": [
+              "<IPython.core.display.Javascript object>"
+            ]
+          },
+          "metadata": {},
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "from google.colab import files\n",
+        "\n",
+        "files.download(zip_path)\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "2jJkcOlw_R1k",
+      "metadata": {
+        "id": "2jJkcOlw_R1k"
+      },
+      "outputs": [],
+      "source": [
+        "torch.save(model.state_dict(), \"final_model.pth\")  # AFTER training with classification head\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "xnHr1IDABebZ",
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "xnHr1IDABebZ",
+        "outputId": "95761a2d-56fa-418c-de03-d66d1ae662ee"
+      },
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "The text is predicted to be: Human\n",
+            "1\n",
+            "0\n",
+            "1\n"
+          ]
+        }
+      ],
+      "source": [
+        "# prompt: How to load the model and classifier and use it ? if no other code is in top of this\n",
+        "\n",
+        "# Define the device\n",
+        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
+        "\n",
+        "# Instantiate the model\n",
+        "model = IndicBERTClassifier().to(device)\n",
+        "\n",
+        "# Load the saved state dictionary\n",
+        "# Make sure the path to your saved model file is correct\n",
+        "model_path = \"final_model.pth\" # Or \"model_95_acc.pth\" if you saved that one last\n",
+        "model.load_state_dict(torch.load(model_path, map_location=device))\n",
+        "\n",
+        "# Set the model to evaluation mode\n",
+        "model.eval()\n",
+        "\n",
+        "# Load the tokenizer\n",
+        "tokenizer_path = \"./nepali_xlmr_classifier\" # Make sure this path is correct\n",
+        "tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)\n",
+        "\n",
+        "# Now the model and tokenizer are loaded and ready to be used for predictions.\n",
+        "# You can use the existing `predict` function or write a new one.\n",
+        "\n",
+        "# Example of using the predict function with the loaded model and tokenizer\n",
+        "def predict(text):\n",
+        "    model.eval() # Ensure model is in evaluation mode\n",
+        "    inputs = tokenizer(text, return_tensors='pt', truncation=True, padding=True, max_length=512)\n",
+        "    inputs = {k: v.to(device) for k, v in inputs.items()}\n",
+        "    with torch.no_grad():\n",
+        "        outputs = model(**inputs)\n",
+        "\n",
+        "        # Handle if output is tensor (some versions/models return logits directly)\n",
+        "        logits = outputs if isinstance(outputs, torch.Tensor) else outputs.logits\n",
+        "\n",
+        "        pred = torch.argmax(logits, dim=1).item()\n",
+        "    return pred\n",
+        "\n",
+        "# Example usage with some text\n",
+        "text_to_predict = \"This is a test sentence.\" # Replace with your Nepali text\n",
+        "predicted_class = predict(text_to_predict)\n",
+        "\n",
+        "# Interpret the prediction (assuming 0 for Human, 1 for AI based on your previous code)\n",
+        "class_label = \"Human\" if predicted_class == 0 else \"AI\"\n",
+        "print(f\"The text is predicted to be: {class_label}\")\n",
+        "\n",
+        "# You can test with more examples as you did before\n",
+        "print(predict(\"यी सबै वाक्यहरू इन्टरनेटको विकास, प्रभाव, र चुनौतीहरूको गहिरो सन्दर्भ समेटेर तयार पारिएका छन्। यदि तिमीलाई चाहिएको खण्डमा विशेष विषय (जस्तै शिक्षा, साइबर सुरक्षा, ग्रामीण प्रभाव आदि) चाहिएको हो भने, म त्यही विषयमा केन्द्रित लामो वाक्यहरू पनि दिन सक्छु।\"))\n",
+        "print(predict(\"अख्तियार दुरुपयोग अनुसन्धान आयोगले सिन्धुपाल्चोक–२ बाट प्रतिनिधिसभा सदस्य निर्वाचित सांसद तथा पूर्वमन्त्री बस्नेतसहित १६ जना र २ कम्पनी विरुद्ध ३ अर्ब २१ करोडभन्दा बढी बिगो कायम गरी बिहीबार विशेष अदालतमा भ्रष्टाचार मुद्दा दायर गरेको छ । योसँगै बस्नेत सांसद पदबाट स्वतः निलम्बनमा परेका छन् ।\"))\n",
+        "print(predict(\"इन्टरनेटको सुरुवात सन् १९६९ मा अमेरिकी रक्षा मन्त्रालयले निर्माण गरेको ARPANET नामक प्रोजेक्टबाट भएको हो, जसको उद्देश्य आपसी संचारलाई सहज बनाउने थियो र जसले भविष्यमा इन्टरनेटको रूप लियो\"))\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "id": "gG8fnbqyDUpm",
+      "metadata": {
+        "id": "gG8fnbqyDUpm"
+      },
+      "outputs": [],
+      "source": []
+    }
+  ],
+  "metadata": {
+    "accelerator": "TPU",
+    "colab": {
+      "gpuType": "V28",
+      "provenance": []
+    },
+    "kernelspec": {
+      "display_name": "ml",
+      "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.14"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}

notebook/ai_vs_human_nepali/topic_scrapper.ipynb

@@ -0,0 +1,542 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "4b53d4bc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# # Groq Nepali Rewriter\n",
+    "\n",
+    "# This notebook loads the dataset, builds a Nepali rewrite prompt, tests one sample, and then saves a batch output CSV using the Groq API.\n",
+    "\n",
+    "# Requirements:\n",
+    "# - `GROQ_API_KEY` must be available in `.env`\n",
+    "# - the input file must contain a `paragraph` column"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "6c8dc1cb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import re\n",
+    "import time\n",
+    "from concurrent.futures import ThreadPoolExecutor, as_completed\n",
+    "\n",
+    "import pandas as pd\n",
+    "from dotenv import load_dotenv\n",
+    "from groq import Groq\n",
+    "\n",
+    "load_dotenv()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "019adfa8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "api_key = os.getenv(\"GROQ_API_KEY2\")\n",
+    "if not api_key:\n",
+    "    raise ValueError(\"GROQ_API_KEY not found in .env or environment.\")\n",
+    "\n",
+    "client = Groq(api_key=api_key)\n",
+    "MODEL_NAME = \"llama-3.3-70b-versatile\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "4b4d2bbe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data =pd.read_csv(\"DATASET/topics_1000.csv\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "c36cfbbf",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>id</th>\n",
+       "      <th>topic</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>नेपालमा कृत्रिम बुद्धिमत्ता विकासको वर्तमान अव...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>नेपालको शिक्षा प्रणालीमा डिजिटल प्रविधिको प्रभाव</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3</td>\n",
+       "      <td>काठमाडौँ उपत्यकाको वायु प्रदूषण समस्या</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>4</td>\n",
+       "      <td>नेपालमा जलवायु परिवर्तनका असरहरू</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>5</td>\n",
+       "      <td>ग्रामीण क्षेत्रमा इन्टरनेट पहुँचको विस्तार</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   id                                              topic\n",
+       "0   1  नेपालमा कृत्रिम बुद्धिमत्ता विकासको वर्तमान अव...\n",
+       "1   2   नेपालको शिक्षा प्रणालीमा डिजिटल प्रविधिको प्रभाव\n",
+       "2   3             काठमाडौँ उपत्यकाको वायु प्रदूषण समस्या\n",
+       "3   4                   नेपालमा जलवायु परिवर्तनका असरहरू\n",
+       "4   5         ग्रामीण क्षेत्रमा इन्टरनेट पहुँचको विस्तार"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "b6e226b8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "def build_prompt(paragraph):\n",
+    "    style = [\n",
+    "        \"Use simple and clear language.\",\n",
+    "        \"Make it engaging and interesting to read.\",\n",
+    "        \"Use a conversational tone.\",\n",
+    "        \"Keep the original meaning intact.\",\n",
+    "        \"Avoid complex jargon and technical terms.\",\n",
+    "        \"Use short sentences and paragraphs.\",\n",
+    "        \"Add examples or anecdotes to illustrate points.\",\n",
+    "        \"Use active voice instead of passive voice.\",\n",
+    "        \"Include a call to action or a thought-provoking question at the end.\",\n",
+    "    ]\n",
+    "    selected_style_random_single =  np.random.choice(style, size=len(style), replace=False)  # Select the first 5 style guidelines\n",
+    "    prompt = f\"\"\"\n",
+    "    give me an essay  for the following topics puree nepali ok no enlgish language:\n",
+    "    {paragraph}\n",
+    "    Rewrite the above paragraph in Nepali, following these style guidelines:\n",
+    "    {', '.join(selected_style_random_single)}\n",
+    "    \"\"\"\n",
+    "    return prompt.strip()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "cf16922b",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "नेपालमा कृत्रिम बुद्धिमत्ता विकासको वर्तमान अवस्था\n",
+      "\n",
+      "कृत्रिम बुद्धिमत्ता विकास नेपालको लागि एक नयाँ युग हो । यो प्राविधिक क्षेत्र दिन-प्रतिदिन विकसित हुने क्रममा छ । नेपालमा कृत्रिम बुद्धिमत्ताले विभिन्न क्षेत्रमा परिवर्तन ल्याउने क्षमता राख्दछ । जस्तै: स्वास्थ्य सेवामा, शिक्षामा, वित्तीय सेवामा, तथा उत्पादन क्षेत्रमा ।\n",
+      "\n",
+      "नेपालमा कृत्रिम बुद्धिमत्ताको विकासले नयाँ अवस्था प्राप्त गरिरहेको छ । यो देशमा विभिन्न प्राविधिक कम्पनीहरुले कृत्रिम बुद्धिमत्ताको विकासमा लगनशील छन् । तसर्थ, यसले नेपालमा रोजगारीको अवसर पनि बढाउने छ । उदाहरणको लागि, कृत्रिम बुद्धिमत्ताले स्वास्थ्य सेवामा रोग निदान गर्ने, रोगको उपचार सुझाउने, तथा व्यक्तिको स्वास्थ्य जाँच गर्ने काम गर्नसक्ने छ ।\n",
+      "\n",
+      "कृत्रिम बुद्धिमत्ताको विकासले नेपालको अर्थतन्त्रमा पनि परिवर्तन ल्याउने छ । यसले व्यवसायिक क्षेत्रमा उत्पादनशीलता बढाउने, उत्पादन मुल्य कम गर्ने, तथा गुणस्तर मापन गर्ने काम गर्नसक्ने छ । उदाहरणको लागि, कृत्रिम बुद्धिमत्ताले वित्तीय सेवामा लेनदेनको निरीक्षण गर्ने, धोकाधोकाको मुल्यांकन गर्ने, तथा वित्तीय संस्थाहरुलाई सुझाव दिने काम गर्नसक्ने छ ।\n",
+      "\n",
+      "नेपालमा कृत्रिम बुद्धिमत्ता विकासको वर्तमान अवस्थाले देशलाई एक नयाँ दिशामा लम्बने क्षमता राख्दछ । तर, यसको विकासमा चुनौतिहरु पनि छन् । जस्तै: डाटा सुरक्षा, निजताको हनन, तथा श्रमिकहरुको प्रतिस्पर्धी क्षमता । तसर्थ, नेपालमा कृत्रिम बुद्धिमत्ताको विकासलाई प्रोत्साहित गर्नको लागि, हामीले यसको विकासमा लगनशील कम्पनीहरुलाई साथ दिनु पर्छ । हामीले पनि कृत्रिम बुद्धिमत्ता���ो विकासमा योगदान पुर्याउनुपर्छ ।\n",
+      "\n",
+      "आह, नेपालमा कृत्रिम बुद्धिमत्ता विकासको वर्तमान अवस्थाले देशलाई एक नयाँ दिशामा लम्बने क्षमता राख्दछ । तर, यसको विकासमा हामी के गरिरहेका छौ? हामीले कृत्रिम बुद्धिमत्ताको विकासमा योगदान पुर्याउने छौ कि? हामीले यसको विकासमा चुनौतिहरुलाई मात गर्ने छौ कि? यस प्रश्नको उत्तर हामीसँग छ । आउनうभ, हामी नेपालमा कृत्रिम बुद्धिमत्ताको विकासलाई प्रोत्साहित गरौं । आउनूभ, हामी देशलाई एक नयाँ दिशामा लम्बौं ।\n"
+     ]
+    }
+   ],
+   "source": [
+    "build_prompt = build_prompt\n",
+    "\n",
+    "sample_title = str(data.iloc[0][\"topic\"])\n",
+    "\n",
+    "sample_response = client.chat.completions.create(\n",
+    "    model=MODEL_NAME,\n",
+    "    messages=[{\"role\": \"user\", \"content\": build_prompt(sample_title)}],\n",
+    ")\n",
+    "\n",
+    "generated_text = sample_response.choices[0].message.content.strip()\n",
+    "print(generated_text)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c709f126",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def grok_step3_5_scraper(\n",
+    "    input_file,\n",
+    "    output_file=\"step3_5_grok_nepali.csv\",\n",
+    "    limit=100,\n",
+    "    model=MODEL_NAME,\n",
+    "    requests_per_second=2,\n",
+    "    max_workers=2,\n",
+    "    max_retries=3,\n",
+    "):\n",
+    "    working_df = pd.read_csv(input_file)\n",
+    "    if limit is not None:\n",
+    "        working_df = working_df.head(limit)\n",
+    "\n",
+    "    cols = set(working_df.columns)\n",
+    "    if \"Title\" in cols or \"शीर्षक\" in cols:\n",
+    "        title_col = \"Title\" if \"Title\" in cols else \"शीर्षक\"\n",
+    "        prompt_col = title_col\n",
+    "        if \"Paragraph\" in cols:\n",
+    "            human_col = \"Paragraph\"\n",
+    "        elif \"विवरण\" in cols:\n",
+    "            human_col = \"विवरण\"\n",
+    "        elif \"paragraph\" in cols:\n",
+    "            human_col = \"paragraph\"\n",
+    "        else:\n",
+    "            human_col = prompt_col\n",
+    "    elif \"paragraph\" in cols or \"Paragraph\" in cols or \"विवरण\" in cols:\n",
+    "        prompt_col = (\n",
+    "            \"paragraph\" if \"paragraph\" in cols\n",
+    "            else (\"Paragraph\" if \"Paragraph\" in cols else \"विवरण\")\n",
+    "        )\n",
+    "        human_col = prompt_col\n",
+    "        title_col = prompt_col\n",
+    "    else:\n",
+    "        raise ValueError(\n",
+    "            \"No supported text columns found. Expected one of: Title/शीर्षक with Paragraph/विवरण, or paragraph.\"\n",
+    "        )\n",
+    "\n",
+    "    working_df = working_df.dropna(subset=[human_col]).copy()\n",
+    "\n",
+    "    total_input_rows = len(working_df)\n",
+    "    already_done = 0\n",
+    "\n",
+    "    if os.path.exists(output_file):\n",
+    "        try:\n",
+    "            existing_df = pd.read_csv(output_file)\n",
+    "            already_done = len(existing_df)\n",
+    "        except pd.errors.EmptyDataError:\n",
+    "            already_done = 0\n",
+    "\n",
+    "    if already_done >= total_input_rows:\n",
+    "        print(\n",
+    "            f\"Nothing to do. {already_done} rows already exist in {output_file} (input rows: {total_input_rows}).\"\n",
+    "        )\n",
+    "        return\n",
+    "\n",
+    "    if already_done > 0:\n",
+    "        working_df = working_df.iloc[already_done:].copy()\n",
+    "        print(\n",
+    "            f\"Resuming from row {already_done}. Processing remaining {len(working_df)} rows out of {total_input_rows}.\"\n",
+    "        )\n",
+    "    else:\n",
+    "        print(f\"Loaded {total_input_rows} rows from {input_file}\")\n",
+    "        print(\n",
+    "            f\"Using title column: {title_col} | prompt column: {prompt_col} | human column: {human_col}\"\n",
+    "        )\n",
+    "\n",
+    "    results = []\n",
+    "\n",
+    "    bad_markers = [\n",
+    "        \"error\",\n",
+    "        \"invalid\",\n",
+    "        \"not found\",\n",
+    "        \"decommissioned\",\n",
+    "        \"rate limit\",\n",
+    "        \"api key\",\n",
+    "    ]\n",
+    "\n",
+    "    def is_valid_ai_text(text: str) -> bool:\n",
+    "        if not text:\n",
+    "            return False\n",
+    "        clean_text = text.strip()\n",
+    "        if len(clean_text) < 20:\n",
+    "            return False\n",
+    "        lower_text = clean_text.lower()\n",
+    "        return not any(marker in lower_text for marker in bad_markers)\n",
+    "\n",
+    "    def extract_retry_wait_seconds(error_text: str) -> float:\n",
+    "        match = re.search(r\"try again in\\s*(\\d+)ms\", error_text, re.IGNORECASE)\n",
+    "        if match:\n",
+    "            return int(match.group(1)) / 1000.0 + 0.2\n",
+    "        return 1.5\n",
+    "\n",
+    "    def process_one(idx, title_text, prompt_text, human_text):\n",
+    "        local_client = Groq(api_key=api_key)\n",
+    "\n",
+    "        for attempt in range(max_retries + 1):\n",
+    "            try:\n",
+    "                completion = local_client.chat.completions.create(\n",
+    "                    model=model,\n",
+    "                    messages=[{\"role\": \"user\", \"content\": build_prompt(str(prompt_text))}],\n",
+    "                    temperature=0.2,\n",
+    "                    max_tokens=500,\n",
+    "                )\n",
+    "                ai_text = completion.choices[0].message.content.strip()\n",
+    "\n",
+    "                if not is_valid_ai_text(ai_text):\n",
+    "                    if attempt < max_retries:\n",
+    "                        continue\n",
+    "                    return {\n",
+    "                        \"idx\": idx,\n",
+    "                        \"ok\": False,\n",
+    "                        \"reason\": \"invalid_or_error_text\",\n",
+    "                        \"ai_text\": ai_text,\n",
+    "                    }\n",
+    "\n",
+    "                return {\n",
+    "                    \"idx\": idx,\n",
+    "                    \"ok\": True,\n",
+    "                    \"title\": str(title_text),\n",
+    "                    \"human_text\": str(human_text),\n",
+    "                    \"ai_generated_text\": ai_text,\n",
+    "                }\n",
+    "            except Exception as error:\n",
+    "                error_text = str(error)\n",
+    "                is_rate_limited = (\n",
+    "                    \"rate_limit_exceeded\" in error_text.lower()\n",
+    "                    or \"rate limit reached\" in error_text.lower()\n",
+    "                    or \"429\" in error_text\n",
+    "                )\n",
+    "\n",
+    "                if is_rate_limited and attempt < max_retries:\n",
+    "                    wait_seconds = extract_retry_wait_seconds(error_text)\n",
+    "                    print(\n",
+    "                        f\"Row {idx} rate-limited, retry {attempt + 1}/{max_retries} after {wait_seconds:.2f}s\"\n",
+    "                    )\n",
+    "                    time.sleep(wait_seconds)\n",
+    "                    continue\n",
+    "\n",
+    "                return {\n",
+    "                    \"idx\": idx,\n",
+    "                    \"ok\": False,\n",
+    "                    \"reason\": error_text,\n",
+    "                    \"ai_text\": \"\",\n",
+    "                }\n",
+    "\n",
+    "    rows = list(working_df[[title_col, prompt_col, human_col]].itertuples(index=True, name=None))\n",
+    "    total = len(rows)\n",
+    "\n",
+    "    for start in range(0, total, requests_per_second):\n",
+    "        window = rows[start : start + requests_per_second]\n",
+    "        tick_start = time.time()\n",
+    "\n",
+    "        with ThreadPoolExecutor(max_workers=max_workers) as executor:\n",
+    "            futures = {\n",
+    "                executor.submit(process_one, idx, title_text, prompt_text, human_text): idx\n",
+    "                for idx, title_text, prompt_text, human_text in window\n",
+    "            }\n",
+    "\n",
+    "            for future in as_completed(futures):\n",
+    "                out = future.result()\n",
+    "                if out[\"ok\"]:\n",
+    "                    # Save as id + ai_gen only\n",
+    "                    results.append({\n",
+    "                        \"id\": out[\"idx\"],\n",
+    "                        \"ai_gen\": out[\"ai_generated_text\"]\n",
+    "                    })\n",
+    "                    print(\n",
+    "                        f\"Row {out['idx']}: generated {len(out['ai_generated_text'].split())} words\"\n",
+    "                    )\n",
+    "                else:\n",
+    "                    print(f\"Row {out['idx']} skipped: {out['reason']}\")\n",
+    "\n",
+    "        if len(results) >= 10:\n",
+    "            pd.DataFrame(results)[[\"id\", \"ai_gen\"]].to_csv(\n",
+    "                output_file,\n",
+    "                index=False,\n",
+    "                mode=\"a\",\n",
+    "                header=not os.path.exists(output_file),\n",
+    "            )\n",
+    "            print(f\"Saved {len(results)} valid rows to {output_file}\")\n",
+    "            results = []\n",
+    "\n",
+    "        elapsed = time.time() - tick_start\n",
+    "        if elapsed < 1:\n",
+    "            time.sleep(1 - elapsed)\n",
+    "\n",
+    "    if results:\n",
+    "        pd.DataFrame(results)[[\"id\", \"ai_gen\"]].to_csv(\n",
+    "            output_file,\n",
+    "            index=False,\n",
+    "            mode=\"a\",\n",
+    "            header=not os.path.exists(output_file),\n",
+    "        )\n",
+    "\n",
+    "    print(f\"Finished. Output saved to {output_file}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "29c3627c",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ParserError",
+     "evalue": "Error tokenizing data. C error: Expected 8 fields in line 33, saw 16\n",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mParserError\u001b[0m                               Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[23], line 4\u001b[0m\n\u001b[1;32m      1\u001b[0m output_file \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnews_scrap_new21223123.csv\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m      2\u001b[0m prepared_input \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mDATASET/News_csv/ai_vs_human_input_all.csv\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m----> 4\u001b[0m \u001b[43mgrok_step3_5_scraper\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m      5\u001b[0m \u001b[43m    \u001b[49m\u001b[43minput_file\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mprepared_input\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m      6\u001b[0m \u001b[43m    \u001b[49m\u001b[43moutput_file\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43moutput_file\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m      7\u001b[0m \u001b[43m    \u001b[49m\u001b[43mlimit\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m      8\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmodel\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mMODEL_NAME\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m      9\u001b[0m \u001b[43m    \u001b[49m\u001b[43mrequests_per_second\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m     10\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmax_workers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m     11\u001b[0m \u001b[43m    \u001b[49m\u001b[43mmax_retries\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m,\u001b[49m\n\u001b[1;32m     12\u001b[0m \u001b[43m)\u001b[49m\n\u001b[1;32m     14\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mexists(output_file):\n\u001b[1;32m     15\u001b[0m     pd\u001b[38;5;241m.\u001b[39mread_csv(output_file)\u001b[38;5;241m.\u001b[39mtail()\n",
+      "Cell \u001b[0;32mIn[22], line 45\u001b[0m, in \u001b[0;36mgrok_step3_5_scraper\u001b[0;34m(input_file, output_file, limit, model, requests_per_second, max_workers, max_retries)\u001b[0m\n\u001b[1;32m     43\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m os\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;241m.\u001b[39mexists(output_file):\n\u001b[1;32m     44\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m---> 45\u001b[0m         existing_df \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutput_file\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     46\u001b[0m         already_done \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlen\u001b[39m(existing_df)\n\u001b[1;32m     47\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m pd\u001b[38;5;241m.\u001b[39merrors\u001b[38;5;241m.\u001b[39mEmptyDataError:\n",
+      "File \u001b[0;32m~/miniconda3/envs/ml/lib/python3.11/site-packages/pandas/io/parsers/readers.py:873\u001b[0m, in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, skip_blank_lines, parse_dates, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, low_memory, memory_map, float_precision, storage_options, dtype_backend)\u001b[0m\n\u001b[1;32m    861\u001b[0m kwds_defaults \u001b[38;5;241m=\u001b[39m _refine_defaults_read(\n\u001b[1;32m    862\u001b[0m     dialect,\n\u001b[1;32m    863\u001b[0m     delimiter,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    869\u001b[0m     dtype_backend\u001b[38;5;241m=\u001b[39mdtype_backend,\n\u001b[1;32m    870\u001b[0m )\n\u001b[1;32m    871\u001b[0m kwds\u001b[38;5;241m.\u001b[39mupdate(kwds_defaults)\n\u001b[0;32m--> 873\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/ml/lib/python3.11/site-packages/pandas/io/parsers/readers.py:306\u001b[0m, in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m    303\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m parser\n\u001b[1;32m    305\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m parser:\n\u001b[0;32m--> 306\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mparser\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnrows\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/ml/lib/python3.11/site-packages/pandas/io/parsers/readers.py:1947\u001b[0m, in \u001b[0;36mTextFileReader.read\u001b[0;34m(self, nrows)\u001b[0m\n\u001b[1;32m   1940\u001b[0m nrows \u001b[38;5;241m=\u001b[39m validate_integer(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnrows\u001b[39m\u001b[38;5;124m\"\u001b[39m, nrows)\n\u001b[1;32m   1941\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1942\u001b[0m     \u001b[38;5;66;03m# error: \"ParserBase\" has no attribute \"read\"\u001b[39;00m\n\u001b[1;32m   1943\u001b[0m     (\n\u001b[1;32m   1944\u001b[0m         index,\n\u001b[1;32m   1945\u001b[0m         columns,\n\u001b[1;32m   1946\u001b[0m         col_dict,\n\u001b[0;32m-> 1947\u001b[0m     ) \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# type: ignore[attr-defined]\u001b[39;49;00m\n\u001b[1;32m   1948\u001b[0m \u001b[43m        \u001b[49m\u001b[43mnrows\u001b[49m\n\u001b[1;32m   1949\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1950\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m   1951\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mclose()\n",
+      "File \u001b[0;32m~/miniconda3/envs/ml/lib/python3.11/site-packages/pandas/io/parsers/c_parser_wrapper.py:215\u001b[0m, in \u001b[0;36mCParserWrapper.read\u001b[0;34m(self, nrows)\u001b[0m\n\u001b[1;32m    213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m    214\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlow_memory:\n\u001b[0;32m--> 215\u001b[0m         chunks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_reader\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_low_memory\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnrows\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    216\u001b[0m         \u001b[38;5;66;03m# destructive to chunks\u001b[39;00m\n\u001b[1;32m    217\u001b[0m         data \u001b[38;5;241m=\u001b[39m _concatenate_chunks(chunks, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnames)\n",
+      "File \u001b[0;32mpandas/_libs/parsers.pyx:832\u001b[0m, in \u001b[0;36mpandas._libs.parsers.TextReader.read_low_memory\u001b[0;34m()\u001b[0m\n",
+      "File \u001b[0;32mpandas/_libs/parsers.pyx:897\u001b[0m, in \u001b[0;36mpandas._libs.parsers.TextReader._read_rows\u001b[0;34m()\u001b[0m\n",
+      "File \u001b[0;32mpandas/_libs/parsers.pyx:868\u001b[0m, in \u001b[0;36mpandas._libs.parsers.TextReader._tokenize_rows\u001b[0;34m()\u001b[0m\n",
+      "File \u001b[0;32mpandas/_libs/parsers.pyx:885\u001b[0m, in \u001b[0;36mpandas._libs.parsers.TextReader._check_tokenize_status\u001b[0;34m()\u001b[0m\n",
+      "File \u001b[0;32mpandas/_libs/parsers.pyx:2084\u001b[0m, in \u001b[0;36mpandas._libs.parsers.raise_parser_error\u001b[0;34m()\u001b[0m\n",
+      "\u001b[0;31mParserError\u001b[0m: Error tokenizing data. C error: Expected 8 fields in line 33, saw 16\n"
+     ]
+    }
+   ],
+   "source": [
+    "output_file = \"news_scrap_new21223123.csv\"\n",
+    "prepared_input = \"DATASET/News_csv/ai_vs_human_input_all.csv\"\n",
+    "\n",
+    "grok_step3_5_scraper(\n",
+    "    input_file=prepared_input,\n",
+    "    output_file=output_file,\n",
+    "    limit=10,\n",
+    "    model=MODEL_NAME,\n",
+    "    requests_per_second=2,\n",
+    "    max_workers=2,\n",
+    "    max_retries=3,\n",
+    ")\n",
+    "\n",
+    "if os.path.exists(output_file):\n",
+    "    pd.read_csv(output_file).tail()\n",
+    "else:\n",
+    "    print(f\"No output file found: {output_file}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3c3777e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "ParserError",
+     "evalue": "Error tokenizing data. C error: Expected 8 fields in line 33, saw 16\n",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mParserError\u001b[0m                               Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[14], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m teststes \u001b[38;5;241m=\u001b[39m \u001b[43mpd\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_csv\u001b[49m\u001b[43m(\u001b[49m\u001b[43moutput_file\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241m.\u001b[39mtail()\n",
+      "File \u001b[0;32m~/miniconda3/envs/ml/lib/python3.11/site-packages/pandas/io/parsers/readers.py:873\u001b[0m, in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, skip_blank_lines, parse_dates, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, low_memory, memory_map, float_precision, storage_options, dtype_backend)\u001b[0m\n\u001b[1;32m    861\u001b[0m kwds_defaults \u001b[38;5;241m=\u001b[39m _refine_defaults_read(\n\u001b[1;32m    862\u001b[0m     dialect,\n\u001b[1;32m    863\u001b[0m     delimiter,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    869\u001b[0m     dtype_backend\u001b[38;5;241m=\u001b[39mdtype_backend,\n\u001b[1;32m    870\u001b[0m )\n\u001b[1;32m    871\u001b[0m kwds\u001b[38;5;241m.\u001b[39mupdate(kwds_defaults)\n\u001b[0;32m--> 873\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_read\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilepath_or_buffer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mkwds\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/ml/lib/python3.11/site-packages/pandas/io/parsers/readers.py:306\u001b[0m, in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m    303\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m parser\n\u001b[1;32m    305\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m parser:\n\u001b[0;32m--> 306\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mparser\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnrows\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/ml/lib/python3.11/site-packages/pandas/io/parsers/readers.py:1947\u001b[0m, in \u001b[0;36mTextFileReader.read\u001b[0;34m(self, nrows)\u001b[0m\n\u001b[1;32m   1940\u001b[0m nrows \u001b[38;5;241m=\u001b[39m validate_integer(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mnrows\u001b[39m\u001b[38;5;124m\"\u001b[39m, nrows)\n\u001b[1;32m   1941\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1942\u001b[0m     \u001b[38;5;66;03m# error: \"ParserBase\" has no attribute \"read\"\u001b[39;00m\n\u001b[1;32m   1943\u001b[0m     (\n\u001b[1;32m   1944\u001b[0m         index,\n\u001b[1;32m   1945\u001b[0m         columns,\n\u001b[1;32m   1946\u001b[0m         col_dict,\n\u001b[0;32m-> 1947\u001b[0m     ) \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread\u001b[49m\u001b[43m(\u001b[49m\u001b[43m  \u001b[49m\u001b[38;5;66;43;03m# type: ignore[attr-defined]\u001b[39;49;00m\n\u001b[1;32m   1948\u001b[0m \u001b[43m        \u001b[49m\u001b[43mnrows\u001b[49m\n\u001b[1;32m   1949\u001b[0m \u001b[43m    \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1950\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m:\n\u001b[1;32m   1951\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mclose()\n",
+      "File \u001b[0;32m~/miniconda3/envs/ml/lib/python3.11/site-packages/pandas/io/parsers/c_parser_wrapper.py:215\u001b[0m, in \u001b[0;36mCParserWrapper.read\u001b[0;34m(self, nrows)\u001b[0m\n\u001b[1;32m    213\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m    214\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlow_memory:\n\u001b[0;32m--> 215\u001b[0m         chunks \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_reader\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mread_low_memory\u001b[49m\u001b[43m(\u001b[49m\u001b[43mnrows\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    216\u001b[0m         \u001b[38;5;66;03m# destructive to chunks\u001b[39;00m\n\u001b[1;32m    217\u001b[0m         data \u001b[38;5;241m=\u001b[39m _concatenate_chunks(chunks, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnames)\n",
+      "File \u001b[0;32mpandas/_libs/parsers.pyx:832\u001b[0m, in \u001b[0;36mpandas._libs.parsers.TextReader.read_low_memory\u001b[0;34m()\u001b[0m\n",
+      "File \u001b[0;32mpandas/_libs/parsers.pyx:897\u001b[0m, in \u001b[0;36mpandas._libs.parsers.TextReader._read_rows\u001b[0;34m()\u001b[0m\n",
+      "File \u001b[0;32mpandas/_libs/parsers.pyx:868\u001b[0m, in \u001b[0;36mpandas._libs.parsers.TextReader._tokenize_rows\u001b[0;34m()\u001b[0m\n",
+      "File \u001b[0;32mpandas/_libs/parsers.pyx:885\u001b[0m, in \u001b[0;36mpandas._libs.parsers.TextReader._check_tokenize_status\u001b[0;34m()\u001b[0m\n",
+      "File \u001b[0;32mpandas/_libs/parsers.pyx:2084\u001b[0m, in \u001b[0;36mpandas._libs.parsers.raise_parser_error\u001b[0;34m()\u001b[0m\n",
+      "\u001b[0;31mParserError\u001b[0m: Error tokenizing data. C error: Expected 8 fields in line 33, saw 16\n"
+     ]
+    }
+   ],
+   "source": [
+    "teststes = pd.read_csv(output_file).tail()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "89c46554",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "357ccb81",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "ml",
+   "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.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}