Upload NLP_Colab_Template.ipynb

NLP_Colab_Template.ipynb

@@ -0,0 +1,372 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "18562384",
+   "metadata": {},
+   "source": [
+    "# HaUI Olympic AI 2025 — NLP Colab Template\n",
+    "\n",
+    "**Mục tiêu:** Khung notebook end-to-end, *tuân thủ quy chế*: (1) **không** dùng dữ liệu ngoài, (2) **chỉ** fine-tune **checkpoint tiền huấn luyện tổng quát** (chưa fine-tune đúng tác vụ), (3) **không** đụng `test` cho huấn luyện/tuning, (4) tái lập hoàn toàn trên Colab/Kaggle.\n",
+    "\n",
+    "> **TODO trước khi chạy**: Đặt dữ liệu vào `/content/data/` theo tên file bạn dùng bên dưới (vd. `train.csv`, `dev.csv`, `test.csv`). Điều chỉnh `CFG` cho phù hợp.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "077202e5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# %%capture\n",
+    "# If running on fresh Colab, uncomment to install core libs\n",
+    "# !pip install --upgrade pip\n",
+    "# !pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121\n",
+    "# !pip install transformers==4.43.4 datasets==2.19.0 accelerate==0.33.0 evaluate==0.4.2\n",
+    "# !pip install scikit-learn==1.4.2 pandas==2.2.2 numpy==1.26.4 tqdm==4.66.4 nltk==3.8.1\n",
+    "\n",
+    "import os, sys, platform, random, time, math, json\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "\n",
+    "import torch\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "\n",
+    "import transformers\n",
+    "from transformers import (\n",
+    "    AutoConfig, AutoTokenizer, AutoModelForSequenceClassification,\n",
+    "    DataCollatorWithPadding, Trainer, TrainingArguments, set_seed\n",
+    ")\n",
+    "\n",
+    "from sklearn.metrics import accuracy_score, f1_score, classification_report\n",
+    "\n",
+    "print('Python:', sys.version)\n",
+    "print('PyTorch:', torch.__version__)\n",
+    "print('Transformers:', transformers.__version__)\n",
+    "print('CUDA available:', torch.cuda.is_available())\n",
+    "if torch.cuda.is_available():\n",
+    "    print('GPU:', torch.cuda.get_device_name(0))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9b86b5c5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dataclasses import dataclass\n",
+    "\n",
+    "@dataclass\n",
+    "class CFG:\n",
+    "    model_name: str = 'xlm-roberta-base'   # base LM, pretrain tổng quát\n",
+    "    num_labels: int = 2                     # <-- TODO: chỉnh theo số lớp\n",
+    "    max_length: int = 256\n",
+    "    train_path: str = '/content/data/train.csv'  # TODO: chỉnh đường dẫn\n",
+    "    dev_path: str = '/content/data/dev.csv'      # hoặc None nếu dùng CV\n",
+    "    test_path: str = '/content/data/test.csv'\n",
+    "    text_col: str = 'text'                  # TODO: tên cột văn bản\n",
+    "    label_col: str = 'label'                # TODO: tên cột nhãn (int 0..K-1)\n",
+    "\n",
+    "    seed: int = 42\n",
+    "    epochs: int = 3\n",
+    "    train_bs: int = 16\n",
+    "    eval_bs: int = 32\n",
+    "    lr: float = 2e-5\n",
+    "    wd: float = 0.01\n",
+    "    grad_accum: int = 1\n",
+    "    fp16: bool = True\n",
+    "    warmup_ratio: float = 0.06\n",
+    "    logging_steps: int = 50\n",
+    "    save_total_limit: int = 2\n",
+    "    output_dir: str = '/content/outputs'\n",
+    "    push_to_hub: bool = False  # phải tắt nếu internet whitelist hạn chế\n",
+    "\n",
+    "os.makedirs(CFG.output_dir, exist_ok=True)\n",
+    "\n",
+    "def seed_everything(seed: int):\n",
+    "    set_seed(seed)\n",
+    "    random.seed(seed)\n",
+    "    np.random.seed(seed)\n",
+    "    torch.manual_seed(seed)\n",
+    "    torch.cuda.manual_seed_all(seed)\n",
+    "    print(f'Seeded with {seed}')\n",
+    "\n",
+    "seed_everything(CFG.seed)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6b0c3d70",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Expect CSV with at least [text_col, label_col] for train/dev; test has [text_col] (no labels).\n",
+    "def read_df(path, required_cols=None):\n",
+    "    df = pd.read_csv(path)\n",
+    "    if required_cols:\n",
+    "        for c in required_cols:\n",
+    "            if c not in df.columns:\n",
+    "                raise ValueError(f'Missing column {c} in {path}. Columns: {df.columns.tolist()}')\n",
+    "    return df\n",
+    "\n",
+    "train_df = read_df(CFG.train_path, [CFG.text_col, CFG.label_col])\n",
+    "dev_df = read_df(CFG.dev_path, [CFG.text_col, CFG.label_col]) if os.path.exists(CFG.dev_path) else None\n",
+    "test_df = read_df(CFG.test_path, [CFG.text_col]) if os.path.exists(CFG.test_path) else None\n",
+    "\n",
+    "print('Train shape:', train_df.shape)\n",
+    "if dev_df is not None: print('Dev shape:', dev_df.shape)\n",
+    "if test_df is not None: print('Test shape:', test_df.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "32c6e1f5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import re\n",
+    "import unicodedata\n",
+    "\n",
+    "# Simple normalization — adjust to match task/language\n",
+    "CONTRACTIONS = {\n",
+    "    \"it's\": \"it is\", \"don't\": \"do not\", \"I'm\": \"I am\", \"can't\": \"cannot\",\n",
+    "    \"that's\": \"that is\", \"there's\": \"there is\", \"he's\": \"he is\", \"she's\": \"she is\",\n",
+    "}\n",
+    "\n",
+    "def normalize_text(s: str):\n",
+    "    if not isinstance(s, str):\n",
+    "        return ''\n",
+    "    # NFKC normalize\n",
+    "    s = unicodedata.normalize('NFKC', s)\n",
+    "    # expand contractions (lower-level example; consider multilingual handling)\n",
+    "    tmp = []\n",
+    "    for tok in s.split():\n",
+    "        key = tok.lower()\n",
+    "        tmp.append(CONTRACTIONS.get(key, tok))\n",
+    "    s = ' '.join(tmp)\n",
+    "    # collapse spaces\n",
+    "    s = re.sub(r'\\s+', ' ', s).strip()\n",
+    "    return s\n",
+    "\n",
+    "# Apply preview (do NOT overwrite original; create a processed column for tokenization)\n",
+    "train_df['proc_text'] = train_df[CFG.text_col].astype(str).map(normalize_text)\n",
+    "if dev_df is not None:\n",
+    "    dev_df['proc_text'] = dev_df[CFG.text_col].astype(str).map(normalize_text)\n",
+    "if test_df is not None:\n",
+    "    test_df['proc_text'] = test_df[CFG.text_col].astype(str).map(normalize_text)\n",
+    "\n",
+    "train_df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f5b0a5c4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tokenizer = AutoTokenizer.from_pretrained(CFG.model_name, use_fast=True)\n",
+    "\n",
+    "class NLPDataset(Dataset):\n",
+    "    def __init__(self, df, has_labels=True):\n",
+    "        self.df = df.reset_index(drop=True)\n",
+    "        self.has_labels = has_labels\n",
+    "    def __len__(self):\n",
+    "        return len(self.df)\n",
+    "    def __getitem__(self, idx):\n",
+    "        row = self.df.iloc[idx]\n",
+    "        text = row['proc_text']\n",
+    "        enc = tokenizer(\n",
+    "            text,\n",
+    "            max_length=CFG.max_length,\n",
+    "            truncation=True,\n",
+    "            padding=False\n",
+    "        )\n",
+    "        if self.has_labels:\n",
+    "            enc['labels'] = int(row[CFG.label_col])\n",
+    "        return {k: torch.tensor(v) for k, v in enc.items()}\n",
+    "\n",
+    "train_ds = NLPDataset(train_df, has_labels=True)\n",
+    "dev_ds = NLPDataset(dev_df, has_labels=True) if dev_df is not None else None\n",
+    "test_ds = NLPDataset(test_df, has_labels=False) if test_df is not None else None\n",
+    "\n",
+    "collator = DataCollatorWithPadding(tokenizer=tokenizer)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c0343b24",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "config = AutoConfig.from_pretrained(CFG.model_name, num_labels=CFG.num_labels)\n",
+    "model = AutoModelForSequenceClassification.from_pretrained(\n",
+    "    CFG.model_name,\n",
+    "    config=config\n",
+    ")\n",
+    "\n",
+    "def compute_metrics(eval_pred):\n",
+    "    logits, labels = eval_pred\n",
+    "    preds = logits.argmax(axis=-1)\n",
+    "    acc = accuracy_score(labels, preds)\n",
+    "    f1m = f1_score(labels, preds, average='macro')\n",
+    "    f1w = f1_score(labels, preds, average='weighted')\n",
+    "    return {'accuracy': acc, 'f1_macro': f1m, 'f1_weighted': f1w}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7a8e57d0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "training_args = TrainingArguments(\n",
+    "    output_dir=CFG.output_dir,\n",
+    "    per_device_train_batch_size=CFG.train_bs,\n",
+    "    per_device_eval_batch_size=CFG.eval_bs,\n",
+    "    gradient_accumulation_steps=CFG.grad_accum,\n",
+    "    num_train_epochs=CFG.epochs,\n",
+    "    learning_rate=CFG.lr,\n",
+    "    weight_decay=CFG.wd,\n",
+    "    warmup_ratio=CFG.warmup_ratio,\n",
+    "    evaluation_strategy='steps' if dev_df is not None else 'no',\n",
+    "    save_strategy='steps' if dev_df is not None else 'epoch',\n",
+    "    logging_steps=CFG.logging_steps,\n",
+    "    save_total_limit=CFG.save_total_limit,\n",
+    "    load_best_model_at_end=True if dev_df is not None else False,\n",
+    "    metric_for_best_model='f1_macro',\n",
+    "    fp16=CFG.fp16,\n",
+    "    report_to=[]  # avoid online reporting\n",
+    ")\n",
+    "\n",
+    "trainer = Trainer(\n",
+    "    model=model,\n",
+    "    args=training_args,\n",
+    "    train_dataset=train_ds,\n",
+    "    eval_dataset=dev_ds if dev_ds is not None else None,\n",
+    "    tokenizer=tokenizer,\n",
+    "    data_collator=collator,\n",
+    "    compute_metrics=compute_metrics if dev_ds is not None else None\n",
+    ")\n",
+    "\n",
+    "if dev_df is not None:\n",
+    "    print('Starting training with eval...')\n",
+    "else:\n",
+    "    print('Starting training (no eval set provided; consider internal CV).')\n",
+    "\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "63964aac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "if dev_df is not None:\n",
+    "    eval_res = trainer.evaluate()\n",
+    "    print('Evaluation:', eval_res)\n",
+    "    # Detailed report\n",
+    "    preds = trainer.predict(dev_ds)\n",
+    "    y_true = preds.label_ids\n",
+    "    y_pred = preds.predictions.argmax(-1)\n",
+    "    print(classification_report(y_true, y_pred, digits=4))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "790ceec6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create submission: id + prediction (adjust column names as your platform requires)\n",
+    "if test_df is not None:\n",
+    "    test_pred = trainer.predict(test_ds)\n",
+    "    test_labels = test_pred.predictions.argmax(-1)\n",
+    "    sub = pd.DataFrame({\n",
+    "        'id': np.arange(len(test_labels)),\n",
+    "        'prediction': test_labels\n",
+    "    })\n",
+    "    sub_path = os.path.join(CFG.output_dir, 'submission.csv')\n",
+    "    sub.to_csv(sub_path, index=False)\n",
+    "    print('Saved:', sub_path)\n",
+    "    display(sub.head())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "09ccd875",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# %% Optional: Stratified K-Fold CV (skeleton)\n",
+    "# from sklearn.model_selection import StratifiedKFold\n",
+    "# skf = StratifiedKFold(n_splits=5, shuffle=True, random_state=CFG.seed)\n",
+    "# oof_preds = np.zeros((len(train_df), CFG.num_labels))\n",
+    "# for fold, (trn_idx, val_idx) in enumerate(skf.split(train_df, train_df[CFG.label_col])):\n",
+    "#     print(f'Fold {fold+1}')\n",
+    "#     trn_df = train_df.iloc[trn_idx].reset_index(drop=True)\n",
+    "#     val_df = train_df.iloc[val_idx].reset_index(drop=True)\n",
+    "#     # Rebuild datasets, model, trainer per fold ...\n",
+    "#     # Aggregate oof_preds and evaluate macro-F1 for model selection.\n",
+    "# pass"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0e0338f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import importlib, pkgutil\n",
+    "def pkg_version(name):\n",
+    "    try:\n",
+    "        mod = importlib.import_module(name)\n",
+    "        return getattr(mod, '__version__', 'unknown')\n",
+    "    except Exception:\n",
+    "        return 'not-installed'\n",
+    "\n",
+    "print({\n",
+    "    'python': sys.version,\n",
+    "    'torch': pkg_version('torch'),\n",
+    "    'transformers': pkg_version('transformers'),\n",
+    "    'datasets': pkg_version('datasets'),\n",
+    "    'accelerate': pkg_version('accelerate'),\n",
+    "    'evaluate': pkg_version('evaluate'),\n",
+    "    'sklearn': pkg_version('sklearn'),\n",
+    "    'pandas': pkg_version('pandas'),\n",
+    "    'numpy': pkg_version('numpy'),\n",
+    "    'nltk': pkg_version('nltk'),\n",
+    "})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "558db3d6",
+   "metadata": {},
+   "source": [
+    "## ✅ Submission Checklist\n",
+    "\n",
+    "- [ ] **Không** dùng dữ liệu ngoài BTC.\n",
+    "- [ ] Checkpoint **tổng quát** (chưa fine-tune đúng tác vụ).\n",
+    "- [ ] Tách `train/dev` đúng; **không** đụng `test` cho tuning.\n",
+    "- [ ] Notebook chạy **end-to-end** từ đầu, tạo `submission.csv` trong `CFG.output_dir`.\n",
+    "- [ ] Ghi rõ `CFG`, seed, siêu tham số, phiên bản thư viện (cell Reproducibility).\n",
+    "- [ ] Thời gian chạy & VRAM phù hợp Colab/Kaggle.\n"
+   ]
+  }
+ ],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}