{ "cells": [ { "cell_type": "code", "execution_count": null, "id": "64e1aacd", "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import numpy as np\n", "import torch\n", "from torch.utils.data import Dataset, DataLoader\n", "from transformers import AutoTokenizer, AutoModelForSequenceClassification\n", "from torch.optim import AdamW\n", "from transformers import get_linear_schedule_with_warmup\n", "from sklearn.model_selection import train_test_split\n", "from sklearn.metrics import classification_report, f1_score\n", "import os\n", "\n", "# ── Config ────────────────────────────────────────────────────────────────────\n", "MODEL_NAME = \"emilyalsentzer/Bio_ClinicalBERT\"\n", "MAX_LEN = 128\n", "BATCH_SIZE = 32\n", "EPOCHS = 3\n", "LR = 2e-5\n", "SAVE_DIR = \"./clinicalbert_icd_classifier\"\n", "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", "print(f\"Using device: {DEVICE}\")\n", "\n", "# ── 1. Load & split data ──────────────────────────────────────────────────────\n", "df = pd.read_csv(\"training_data_combined.csv\")\n", "df = df[['text', 'label']].dropna()\n", "df['label'] = df['label'].astype(int)\n", "\n", "train_df, val_df = train_test_split(\n", " df, test_size=0.1, random_state=42, stratify=df['label']\n", ")\n", "print(f\"Train: {len(train_df)} | Val: {len(val_df)}\")\n", "print(\"Train label dist:\\n\", train_df['label'].value_counts())\n", "\n", "# ── 2. Dataset ────────────────────────────────────────────────────────────────\n", "class ClinicalDataset(Dataset):\n", " def __init__(self, texts, labels, tokenizer, max_len):\n", " self.texts = texts.tolist()\n", " self.labels = labels.tolist()\n", " self.tokenizer = tokenizer\n", " self.max_len = max_len\n", "\n", " def __len__(self):\n", " return len(self.texts)\n", "\n", " def __getitem__(self, idx):\n", " encoding = self.tokenizer(\n", " self.texts[idx],\n", " max_length=self.max_len,\n", " padding='max_length',\n", " truncation=True,\n", " return_tensors='pt'\n", " )\n", " return {\n", " 'input_ids': encoding['input_ids'].squeeze(),\n", " 'attention_mask': encoding['attention_mask'].squeeze(),\n", " 'label': torch.tensor(self.labels[idx], dtype=torch.long)\n", " }\n", "\n", "# ── 3. Layer freezing ─────────────────────────────────────────────────────────\n", "def set_trainable_layers(model, n_trainable_layers):\n", " \"\"\"\n", " Freeze everything, then unfreeze:\n", " - classifier head (always)\n", " - last n_trainable_layers encoder layers\n", " \"\"\"\n", " # Freeze all\n", " for param in model.parameters():\n", " param.requires_grad = False\n", "\n", " # Always unfreeze classifier\n", " for param in model.classifier.parameters():\n", " param.requires_grad = True\n", "\n", " # Unfreeze last n encoder layers\n", " total_layers = len(model.bert.encoder.layer)\n", " for i in range(total_layers - n_trainable_layers, total_layers):\n", " for param in model.bert.encoder.layer[i].parameters():\n", " param.requires_grad = True\n", "\n", " trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)\n", " total = sum(p.numel() for p in model.parameters())\n", " print(f\" Trainable params: {trainable:,} / {total:,}\")\n", "\n", "# ── 4. Evaluation ─────────────────────────────────────────────────────────────\n", "def evaluate(model, loader, loss_fn):\n", " model.eval()\n", " all_preds, all_labels = [], []\n", " total_loss = 0\n", "\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['label'].to(DEVICE)\n", "\n", " outputs = model(input_ids=input_ids, attention_mask=attention_mask)\n", " loss = loss_fn(outputs.logits, labels)\n", " total_loss += loss.item()\n", "\n", " preds = torch.argmax(outputs.logits, dim=1)\n", " all_preds.extend(preds.cpu().numpy())\n", " all_labels.extend(labels.cpu().numpy())\n", "\n", " avg_loss = total_loss / len(loader)\n", " f1 = f1_score(all_labels, all_preds, average='macro')\n", " return avg_loss, f1, all_preds, all_labels\n", "\n", "# ── 5. Tokenizer & model ──────────────────────────────────────────────────────\n", "tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)\n", "model = AutoModelForSequenceClassification.from_pretrained(\n", " MODEL_NAME,\n", " num_labels=2\n", ").to(DEVICE)\n", "\n", "# Class imbalance weights\n", "neg_count = (train_df['label'] == 0).sum()\n", "pos_count = (train_df['label'] == 1).sum()\n", "pos_weight = neg_count / pos_count\n", "class_weights = torch.tensor([1.0, pos_weight], dtype=torch.float).to(DEVICE)\n", "loss_fn = torch.nn.CrossEntropyLoss(weight=class_weights)\n", "print(f\"Class weights → neg: 1.0 | pos: {pos_weight:.2f}\")\n", "\n", "# ── 6. DataLoaders ────────────────────────────────────────────────────────────\n", "train_dataset = ClinicalDataset(train_df['text'], train_df['label'], tokenizer, MAX_LEN)\n", "val_dataset = ClinicalDataset(val_df['text'], val_df['label'], tokenizer, MAX_LEN)\n", "\n", "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, num_workers=2)\n", "val_loader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=False, num_workers=2)\n", "\n", "# ── 7. Gradual unfreezing schedule ───────────────────────────────────────────\n", "# Epoch 1: classifier head only\n", "# Epoch 2: unfreeze last 4 encoder layers\n", "# Epoch 3: unfreeze last 8 encoder layers\n", "UNFREEZE_SCHEDULE = {0: 0, 1: 4, 2: 8}\n", "\n", "os.makedirs(SAVE_DIR, exist_ok=True)\n", "best_val_f1 = 0\n", "\n", "# ── 8. Training loop ──────────────────────────────────────────────────────────\n", "for epoch in range(EPOCHS):\n", " print(f\"\\n{'='*60}\")\n", " print(f\"Epoch {epoch+1}/{EPOCHS}\")\n", "\n", " # Apply freezing schedule\n", " n_unfreeze = UNFREEZE_SCHEDULE[epoch]\n", " print(f\" Unfreezing last {n_unfreeze} encoder layers + classifier\")\n", " set_trainable_layers(model, n_trainable_layers=n_unfreeze)\n", "\n", " # Rebuild optimizer for updated trainable params\n", " optimizer = AdamW(\n", " filter(lambda p: p.requires_grad, model.parameters()),\n", " lr=LR,\n", " weight_decay=0.01\n", " )\n", "\n", " # Rebuild scheduler for remaining steps\n", " remaining_epochs = EPOCHS - epoch\n", " total_steps = len(train_loader) * remaining_epochs\n", " scheduler = get_linear_schedule_with_warmup(\n", " optimizer,\n", " num_warmup_steps=int(0.1 * total_steps),\n", " num_training_steps=total_steps\n", " )\n", "\n", " # Train\n", " model.train()\n", " total_train_loss = 0\n", "\n", " for step, batch in enumerate(train_loader):\n", " input_ids = batch['input_ids'].to(DEVICE)\n", " attention_mask = batch['attention_mask'].to(DEVICE)\n", " labels = batch['label'].to(DEVICE)\n", "\n", " optimizer.zero_grad()\n", " outputs = model(input_ids=input_ids, attention_mask=attention_mask)\n", " loss = loss_fn(outputs.logits, labels)\n", " loss.backward()\n", "\n", " torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)\n", " optimizer.step()\n", " scheduler.step()\n", "\n", " total_train_loss += loss.item()\n", "\n", " if step % 200 == 0:\n", " print(f\" Step {step:>4}/{len(train_loader)} | Loss: {loss.item():.4f}\")\n", "\n", " avg_train_loss = total_train_loss / len(train_loader)\n", "\n", " # Evaluate\n", " val_loss, val_f1, val_preds, val_labels = evaluate(model, val_loader, loss_fn)\n", "\n", " print(f\"\\n Train Loss : {avg_train_loss:.4f}\")\n", " print(f\" Val Loss : {val_loss:.4f}\")\n", " print(f\" Val Macro F1: {val_f1:.4f}\")\n", " print(f\"\\n{classification_report(val_labels, val_preds, target_names=['not_codable', 'codable'])}\")\n", "\n", " # Save best checkpoint\n", " if val_f1 > best_val_f1:\n", " best_val_f1 = val_f1\n", " model.save_pretrained(SAVE_DIR)\n", " tokenizer.save_pretrained(SAVE_DIR)\n", " print(f\" ✓ Saved best model (F1={val_f1:.4f}) → {SAVE_DIR}\")\n", "\n", "print(f\"\\nTraining complete. Best Val Macro F1: {best_val_f1:.4f}\")\n", "\n", "# ── 9. Inference on test files ────────────────────────────────────────────────\n", "def predict_csv(test_csv_path, model_dir=SAVE_DIR):\n", " tokenizer = AutoTokenizer.from_pretrained(model_dir)\n", " model = AutoModelForSequenceClassification.from_pretrained(model_dir).to(DEVICE)\n", " model.eval()\n", "\n", " df = pd.read_csv(test_csv_path)\n", " texts = df['text'].fillna('').tolist()\n", "\n", " all_preds, all_probs = [], []\n", "\n", " for i in range(0, len(texts), BATCH_SIZE):\n", " batch_texts = texts[i:i + BATCH_SIZE]\n", " encoding = tokenizer(\n", " batch_texts,\n", " max_length=MAX_LEN,\n", " padding=True,\n", " truncation=True,\n", " return_tensors='pt'\n", " ).to(DEVICE)\n", "\n", " with torch.no_grad():\n", " outputs = model(**encoding)\n", " probs = torch.softmax(outputs.logits, dim=1)\n", " preds = torch.argmax(probs, dim=1)\n", "\n", " all_preds.extend(preds.cpu().numpy())\n", " all_probs.extend(probs[:, 1].cpu().numpy())\n", "\n", " df['predicted_label'] = all_preds\n", " df['confidence'] = np.round(all_probs, 4)\n", "\n", " out_path = test_csv_path.replace('.csv', '_predictions.csv')\n", " df.to_csv(out_path, index=False)\n", " print(f\"Saved → {out_path}\")\n", " return df\n", "\n", "# Run on all test files\n", "import glob\n", "for test_file in sorted(glob.glob('test*_text_only.csv')):\n", " print(f\"\\nRunning inference on {test_file}\")\n", " predict_csv(test_file)" ] } ], "metadata": { "language_info": { "name": "python" } }, "nbformat": 4, "nbformat_minor": 5 }