Complete handwriting recognition project

- Analysis notebook with EDA and 5 detailed charts
- Training notebook for Google Colab GPU
- README with documentation
- Clean project structure

.gitignore

@@ -0,0 +1,33 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Virtual environments
+venv/
+env/
+ENV/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Model files
+models/
+*.pth
+*.pkl
+
+# Data
+archive/
+data/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

README.md

@@ -0,0 +1,121 @@
+# Handwriting Recognition
+
+Complete handwriting recognition system using CNN-BiLSTM-CTC on the IAM dataset.
+
+## 📁 Files
+
+### 1. **analysis.ipynb** - Dataset Analysis
+- Exploratory Data Analysis (EDA)
+- 5 detailed charts saved to `charts/` folder
+- Run locally or on Colab (no GPU needed)
+
+### 2. **train_colab.ipynb** - Model Training (GPU)
+- **⚡ Google Colab GPU compatible**
+- Full training pipeline
+- CNN-BiLSTM-CTC model (~9.1M parameters)
+- Automatic model saving
+- Download trained model for deployment
+
+## 🚀 Quick Start
+
+### Option 1: Analyze Dataset (Local/Colab)
+```bash
+jupyter notebook analysis.ipynb
+```
+- No GPU needed
+- Generates 5 EDA charts
+- Fast (~2 minutes)
+
+### Option 2: Train Model (Google Colab GPU)
+
+1. **Upload `train_colab.ipynb` to Google Colab**
+2. **Change runtime to GPU:**
+   - Runtime → Change runtime type → GPU (T4 recommended)
+3. **Run all cells**
+4. **Download trained model** (last cell)
+
+**Training Time:** ~1-2 hours for 20 epochs on T4 GPU
+
+## 📊 Charts Generated
+
+From `analysis.ipynb`:
+1. `charts/01_sample_images.png` - 10 sample handwritten texts
+2. `charts/02_text_length_distribution.png` - Text statistics
+3. `charts/03_image_dimensions.png` - Image analysis
+4. `charts/04_character_frequency.png` - Character distribution
+5. `charts/05_summary_statistics.png` - Summary table
+
+## 🎯 Model Details
+
+**Architecture:**
+- **CNN**: 7 convolutional blocks (feature extraction)
+- **BiLSTM**: 2 layers, 256 hidden units (sequence modeling)
+- **CTC Loss**: Alignment-free training
+
+**Dataset:** Teklia/IAM-line (Hugging Face)
+- Train: 6,482 samples
+- Validation: 976 samples
+- Test: 2,915 samples
+
+**Metrics:**
+- **CER** (Character Error Rate)
+- **WER** (Word Error Rate)
+
+## 💾 Model Files
+
+After training in Colab:
+- `best_model.pth` - Trained model weights
+- `training_history.png` - Loss/CER/WER plots
+- `predictions.png` - Sample predictions
+
+## 📦 Requirements
+
+```
+torch>=2.0.0
+datasets>=2.14.0
+pillow>=9.5.0
+numpy>=1.24.0
+matplotlib>=3.7.0
+seaborn>=0.13.0
+jupyter>=1.0.0
+jiwer>=3.0.0
+```
+
+## 🔧 Usage
+
+### Load Trained Model
+```python
+import torch
+
+# Load checkpoint
+checkpoint = torch.load('best_model.pth')
+char_mapper = checkpoint['char_mapper']
+
+# Create model
+from train_colab import CRNN  # Copy model class
+model = CRNN(num_chars=len(char_mapper.chars))
+model.load_state_dict(checkpoint['model_state_dict'])
+model.eval()
+
+# Predict
+# ... (preprocessing + inference)
+```
+
+## 📝 Notes
+
+- **GPU strongly recommended** for training (use Colab T4)
+- Training on CPU will be extremely slow (~20x slower)
+- Colab free tier: 12-hour limit, sufficient for 20 epochs
+- Model checkpoint includes character mapper for deployment
+
+## 🎓 Training Tips
+
+1. **Start with fewer epochs** (5-10) to test
+2. **Monitor CER/WER** - stop if not improving
+3. **Increase epochs** if still improving (up to 50)
+4. **Save checkpoint** before Colab disconnects
+5. **Download model immediately** after training
+
+## 📄 License
+
+Dataset: IAM Database (research use)

requirements.txt

@@ -0,0 +1,8 @@
+torch>=2.0.0
+datasets>=2.14.0
+pillow>=9.5.0
+numpy>=1.24.0
+matplotlib>=3.7.0
+seaborn>=0.13.0
+jupyter>=1.0.0
+jiwer>=3.0.0

train_colab.ipynb

@@ -0,0 +1,524 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Handwriting Recognition Training (Google Colab GPU)\n",
+    "## CNN-BiLSTM-CTC Model on IAM Dataset\n",
+    "\n",
+    "**Runtime:** GPU (Runtime → Change runtime type → GPU)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Setup & Installations"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Install required packages\n",
+    "!pip install -q datasets transformers jiwer\n",
+    "\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.optim as optim\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "from datasets import load_dataset\n",
+    "import numpy as np\n",
+    "from PIL import Image\n",
+    "from tqdm import tqdm\n",
+    "from jiwer import cer, wer\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Check GPU\n",
+    "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
+    "print(f\"✓ Using device: {device}\")\n",
+    "if torch.cuda.is_available():\n",
+    "    print(f\"  GPU: {torch.cuda.get_device_name(0)}\")\n",
+    "    print(f\"  Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.2f} GB\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Model Architecture"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CRNN(nn.Module):\n",
+    "    \"\"\"CNN-BiLSTM-CTC for Handwriting Recognition\"\"\"\n",
+    "    \n",
+    "    def __init__(self, img_height=128, num_chars=80, hidden_size=256, num_layers=2):\n",
+    "        super(CRNN, self).__init__()\n",
+    "        \n",
+    "        # CNN Feature Extractor\n",
+    "        self.cnn = nn.Sequential(\n",
+    "            nn.Conv2d(1, 64, 3, padding=1), nn.BatchNorm2d(64), nn.ReLU(), nn.MaxPool2d(2, 2),\n",
+    "            nn.Conv2d(64, 128, 3, padding=1), nn.BatchNorm2d(128), nn.ReLU(), nn.MaxPool2d(2, 2),\n",
+    "            nn.Conv2d(128, 256, 3, padding=1), nn.BatchNorm2d(256), nn.ReLU(),\n",
+    "            nn.Conv2d(256, 256, 3, padding=1), nn.BatchNorm2d(256), nn.ReLU(), nn.MaxPool2d((2, 1)),\n",
+    "            nn.Conv2d(256, 512, 3, padding=1), nn.BatchNorm2d(512), nn.ReLU(),\n",
+    "            nn.Conv2d(512, 512, 3, padding=1), nn.BatchNorm2d(512), nn.ReLU(), nn.MaxPool2d((2, 1)),\n",
+    "            nn.Conv2d(512, 512, 2), nn.BatchNorm2d(512), nn.ReLU(),\n",
+    "        )\n",
+    "        \n",
+    "        self.map2seq = nn.Linear(512 * 7, hidden_size)\n",
+    "        self.rnn = nn.LSTM(hidden_size, hidden_size, num_layers, bidirectional=True, \n",
+    "                           dropout=0.3 if num_layers > 1 else 0, batch_first=True)\n",
+    "        self.fc = nn.Linear(hidden_size * 2, num_chars + 1)\n",
+    "    \n",
+    "    def forward(self, x):\n",
+    "        conv = self.cnn(x)\n",
+    "        b, c, h, w = conv.size()\n",
+    "        conv = conv.permute(0, 3, 1, 2).reshape(b, w, c * h)\n",
+    "        seq = self.map2seq(conv)\n",
+    "        rnn_out, _ = self.rnn(seq)\n",
+    "        output = self.fc(rnn_out)\n",
+    "        return torch.nn.functional.log_softmax(output, dim=2)\n",
+    "\n",
+    "print(\"✓ Model architecture defined\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Character Mapper"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class CharacterMapper:\n",
+    "    def __init__(self):\n",
+    "        chars = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 .,;:!?\\'\"()-')\n",
+    "        self.chars = sorted(list(chars))\n",
+    "        self.char2idx = {c: i+1 for i, c in enumerate(self.chars)}\n",
+    "        self.idx2char = {i+1: c for i, c in enumerate(self.chars)}\n",
+    "        self.idx2char[0] = ''  # CTC blank\n",
+    "        self.num_classes = len(self.chars) + 1\n",
+    "    \n",
+    "    def encode(self, text):\n",
+    "        return [self.char2idx[c] for c in text if c in self.char2idx]\n",
+    "    \n",
+    "    def decode(self, indices):\n",
+    "        chars, prev = [], None\n",
+    "        for idx in indices:\n",
+    "            if idx != 0 and idx != prev and idx in self.idx2char:\n",
+    "                chars.append(self.idx2char[idx])\n",
+    "            prev = idx\n",
+    "        return ''.join(chars)\n",
+    "\n",
+    "char_mapper = CharacterMapper()\n",
+    "print(f\"✓ Character mapper: {char_mapper.num_classes} classes\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Dataset & DataLoader"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class IAMDataset(Dataset):\n",
+    "    def __init__(self, split='train', img_height=128):\n",
+    "        self.img_height = img_height\n",
+    "        self.dataset = load_dataset(\"Teklia/IAM-line\", split=split)\n",
+    "        print(f\"  Loaded {len(self.dataset)} samples\")\n",
+    "    \n",
+    "    def __len__(self):\n",
+    "        return len(self.dataset)\n",
+    "    \n",
+    "    def __getitem__(self, idx):\n",
+    "        sample = self.dataset[idx]\n",
+    "        img = sample['image'].convert('L')\n",
+    "        text = sample['text']\n",
+    "        \n",
+    "        # Resize\n",
+    "        w, h = img.size\n",
+    "        new_w = int(self.img_height * (w / h))\n",
+    "        img = img.resize((new_w, self.img_height), Image.Resampling.LANCZOS)\n",
+    "        \n",
+    "        # Normalize\n",
+    "        img = np.array(img, dtype=np.float32) / 255.0\n",
+    "        img = (img - 0.5) / 0.5\n",
+    "        img = torch.FloatTensor(img).unsqueeze(0)\n",
+    "        \n",
+    "        target = torch.LongTensor(char_mapper.encode(text))\n",
+    "        return img, target, len(target), text\n",
+    "\n",
+    "def collate_fn(batch):\n",
+    "    images, targets, target_lengths, texts = zip(*batch)\n",
+    "    max_w = max(img.shape[2] for img in images)\n",
+    "    b, h = len(images), images[0].shape[1]\n",
+    "    \n",
+    "    padded_imgs = torch.zeros(b, 1, h, max_w)\n",
+    "    input_lengths = []\n",
+    "    \n",
+    "    for i, img in enumerate(images):\n",
+    "        w = img.shape[2]\n",
+    "        padded_imgs[i, :, :, :w] = img\n",
+    "        input_lengths.append((w // 4) - 1)\n",
+    "    \n",
+    "    return {\n",
+    "        'images': padded_imgs,\n",
+    "        'targets': torch.cat(targets) if targets[0].numel() > 0 else torch.LongTensor([]),\n",
+    "        'target_lengths': torch.LongTensor(target_lengths),\n",
+    "        'input_lengths': torch.LongTensor(input_lengths),\n",
+    "        'texts': texts\n",
+    "    }\n",
+    "\n",
+    "print(\"Loading datasets...\")\n",
+    "train_dataset = IAMDataset('train')\n",
+    "val_dataset = IAMDataset('validation')\n",
+    "\n",
+    "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, collate_fn=collate_fn, num_workers=2)\n",
+    "val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, collate_fn=collate_fn, num_workers=2)\n",
+    "\n",
+    "print(f\"✓ Train batches: {len(train_loader)}, Val batches: {len(val_loader)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Training Functions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def decode_predictions(outputs, char_mapper):\n",
+    "    _, max_indices = torch.max(outputs, dim=2)\n",
+    "    return [char_mapper.decode(idx.cpu().numpy().tolist()) for idx in max_indices]\n",
+    "\n",
+    "def compute_metrics(preds, truths):\n",
+    "    valid = [(p, g) for p, g in zip(preds, truths) if p and g]\n",
+    "    if not valid:\n",
+    "        return 0.0, 0.0\n",
+    "    preds, truths = zip(*valid)\n",
+    "    try:\n",
+    "        return cer(truths, preds), wer(truths, preds)\n",
+    "    except:\n",
+    "        return 0.0, 0.0\n",
+    "\n",
+    "def train_epoch(model, loader, criterion, optimizer, device, epoch):\n",
+    "    model.train()\n",
+    "    total_loss = 0\n",
+    "    pbar = tqdm(loader, desc=f\"Epoch {epoch}\")\n",
+    "    \n",
+    "    for batch in pbar:\n",
+    "        images = batch['images'].to(device)\n",
+    "        targets = batch['targets'].to(device)\n",
+    "        input_lengths = batch['input_lengths']\n",
+    "        target_lengths = batch['target_lengths']\n",
+    "        \n",
+    "        outputs = model(images)\n",
+    "        outputs = outputs.permute(1, 0, 2)  # CTC format\n",
+    "        \n",
+    "        loss = criterion(outputs, targets, input_lengths, target_lengths)\n",
+    "        \n",
+    "        optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        torch.nn.utils.clip_grad_norm_(model.parameters(), 5.0)\n",
+    "        optimizer.step()\n",
+    "        \n",
+    "        total_loss += loss.item()\n",
+    "        pbar.set_postfix({'loss': f'{loss.item():.4f}'})\n",
+    "    \n",
+    "    return total_loss / len(loader)\n",
+    "\n",
+    "def validate(model, loader, criterion, device):\n",
+    "    model.eval()\n",
+    "    total_loss = 0\n",
+    "    all_preds, all_truths = [], []\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        for batch in tqdm(loader, desc=\"Validating\"):\n",
+    "            images = batch['images'].to(device)\n",
+    "            targets = batch['targets'].to(device)\n",
+    "            input_lengths = batch['input_lengths']\n",
+    "            target_lengths = batch['target_lengths']\n",
+    "            texts = batch['texts']\n",
+    "            \n",
+    "            outputs = model(images)\n",
+    "            outputs_ctc = outputs.permute(1, 0, 2)\n",
+    "            loss = criterion(outputs_ctc, targets, input_lengths, target_lengths)\n",
+    "            total_loss += loss.item()\n",
+    "            \n",
+    "            preds = decode_predictions(outputs, char_mapper)\n",
+    "            all_preds.extend(preds)\n",
+    "            all_truths.extend(texts)\n",
+    "    \n",
+    "    avg_loss = total_loss / len(loader)\n",
+    "    cer_score, wer_score = compute_metrics(all_preds, all_truths)\n",
+    "    \n",
+    "    # Show examples\n",
+    "    print(\"\\nExample predictions:\")\n",
+    "    for i in range(min(3, len(all_preds))):\n",
+    "        print(f\"  GT:   {all_truths[i]}\")\n",
+    "        print(f\"  Pred: {all_preds[i]}\")\n",
+    "    \n",
+    "    return avg_loss, cer_score, wer_score\n",
+    "\n",
+    "print(\"✓ Training functions ready\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. Train Model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Hyperparameters\n",
+    "EPOCHS = 20\n",
+    "LEARNING_RATE = 0.001\n",
+    "\n",
+    "# Create model\n",
+    "model = CRNN(img_height=128, num_chars=len(char_mapper.chars), hidden_size=256, num_layers=2)\n",
+    "model = model.to(device)\n",
+    "print(f\"Model: {sum(p.numel() for p in model.parameters()):,} parameters\")\n",
+    "\n",
+    "# Loss & Optimizer\n",
+    "criterion = nn.CTCLoss(blank=0, zero_infinity=True)\n",
+    "optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)\n",
+    "scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='min', factor=0.5, patience=3)\n",
+    "\n",
+    "# Training loop\n",
+    "history = {'train_loss': [], 'val_loss': [], 'val_cer': [], 'val_wer': []}\n",
+    "best_cer = float('inf')\n",
+    "\n",
+    "print(f\"\\n{'='*60}\")\n",
+    "print(f\"Starting training: {EPOCHS} epochs\")\n",
+    "print(f\"{'='*60}\\n\")\n",
+    "\n",
+    "for epoch in range(1, EPOCHS + 1):\n",
+    "    print(f\"\\nEpoch {epoch}/{EPOCHS}\")\n",
+    "    print(\"-\" * 60)\n",
+    "    \n",
+    "    # Train\n",
+    "    train_loss = train_epoch(model, train_loader, criterion, optimizer, device, epoch)\n",
+    "    print(f\"Train Loss: {train_loss:.4f}\")\n",
+    "    \n",
+    "    # Validate\n",
+    "    val_loss, val_cer, val_wer = validate(model, val_loader, criterion, device)\n",
+    "    print(f\"Val Loss: {val_loss:.4f}, CER: {val_cer:.4f}, WER: {val_wer:.4f}\")\n",
+    "    \n",
+    "    # Save history\n",
+    "    history['train_loss'].append(train_loss)\n",
+    "    history['val_loss'].append(val_loss)\n",
+    "    history['val_cer'].append(val_cer)\n",
+    "    history['val_wer'].append(val_wer)\n",
+    "    \n",
+    "    # Scheduler\n",
+    "    scheduler.step(val_loss)\n",
+    "    \n",
+    "    # Save best\n",
+    "    if val_cer < best_cer:\n",
+    "        best_cer = val_cer\n",
+    "        torch.save({\n",
+    "            'epoch': epoch,\n",
+    "            'model_state_dict': model.state_dict(),\n",
+    "            'optimizer_state_dict': optimizer.state_dict(),\n",
+    "            'val_cer': val_cer,\n",
+    "            'val_wer': val_wer,\n",
+    "            'char_mapper': char_mapper,\n",
+    "        }, 'best_model.pth')\n",
+    "        print(f\"✓ Saved best model (CER: {val_cer:.4f})\")\n",
+    "\n",
+    "print(f\"\\n{'='*60}\")\n",
+    "print(f\"Training Complete! Best CER: {best_cer:.4f}\")\n",
+    "print(f\"{'='*60}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 7. Plot Training History"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, axes = plt.subplots(1, 3, figsize=(18, 5))\n",
+    "\n",
+    "# Loss\n",
+    "axes[0].plot(history['train_loss'], label='Train', marker='o')\n",
+    "axes[0].plot(history['val_loss'], label='Val', marker='s')\n",
+    "axes[0].set_xlabel('Epoch')\n",
+    "axes[0].set_ylabel('Loss')\n",
+    "axes[0].set_title('Loss')\n",
+    "axes[0].legend()\n",
+    "axes[0].grid(alpha=0.3)\n",
+    "\n",
+    "# CER\n",
+    "axes[1].plot(history['val_cer'], label='CER', marker='o', color='green')\n",
+    "axes[1].set_xlabel('Epoch')\n",
+    "axes[1].set_ylabel('Character Error Rate')\n",
+    "axes[1].set_title('CER (lower is better)')\n",
+    "axes[1].legend()\n",
+    "axes[1].grid(alpha=0.3)\n",
+    "\n",
+    "# WER\n",
+    "axes[2].plot(history['val_wer'], label='WER', marker='s', color='orange')\n",
+    "axes[2].set_xlabel('Epoch')\n",
+    "axes[2].set_ylabel('Word Error Rate')\n",
+    "axes[2].set_title('WER (lower is better)')\n",
+    "axes[2].legend()\n",
+    "axes[2].grid(alpha=0.3)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('training_history.png', dpi=150)\n",
+    "plt.show()\n",
+    "\n",
+    "print(f\"✓ Final metrics: CER={history['val_cer'][-1]:.4f}, WER={history['val_wer'][-1]:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 8. Inference / Prediction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load best model\n",
+    "checkpoint = torch.load('best_model.pth')\n",
+    "model.load_state_dict(checkpoint['model_state_dict'])\n",
+    "model.eval()\n",
+    "\n",
+    "print(f\"✓ Loaded best model (Epoch {checkpoint['epoch']}, CER: {checkpoint['val_cer']:.4f})\")\n",
+    "\n",
+    "# Test on validation samples\n",
+    "test_batch = next(iter(val_loader))\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    images = test_batch['images'].to(device)\n",
+    "    outputs = model(images)\n",
+    "    predictions = decode_predictions(outputs, char_mapper)\n",
+    "\n",
+    "# Visualize predictions\n",
+    "fig, axes = plt.subplots(5, 1, figsize=(16, 15))\n",
+    "\n",
+    "for i in range(5):\n",
+    "    img = test_batch['images'][i, 0].cpu().numpy()\n",
+    "    img = (img * 0.5) + 0.5  # Denormalize\n",
+    "    \n",
+    "    gt = test_batch['texts'][i]\n",
+    "    pred = predictions[i]\n",
+    "    \n",
+    "    axes[i].imshow(img, cmap='gray')\n",
+    "    axes[i].set_title(f\"GT: {gt}\\nPrediction: {pred}\", fontsize=11, loc='left')\n",
+    "    axes[i].axis('off')\n",
+    "\n",
+    "plt.suptitle('Predictions on Validation Set', fontsize=16, fontweight='bold')\n",
+    "plt.tight_layout()\n",
+    "plt.savefig('predictions.png', dpi=150)\n",
+    "plt.show()\n",
+    "\n",
+    "print(\"\\n✓ Predictions saved to 'predictions.png'\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 9. Download Model (Optional)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Download model to local machine\n",
+    "from google.colab import files\n",
+    "\n",
+    "print(\"Downloading model...\")\n",
+    "files.download('best_model.pth')\n",
+    "print(\"\\n✓ Model downloaded! Use it for deployment.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "## Summary\n",
+    "\n",
+    "### ✓ Training Complete!\n",
+    "\n",
+    "**Model:**\n",
+    "- Architecture: CNN-BiLSTM-CTC\n",
+    "- Parameters: ~9.1M\n",
+    "- Trained on: IAM-line dataset\n",
+    "\n",
+    "**Files Generated:**\n",
+    "- `best_model.pth` - Best model checkpoint\n",
+    "- `training_history.png` - Loss/CER/WER plots\n",
+    "- `predictions.png` - Sample predictions\n",
+    "\n",
+    "**Next Steps:**\n",
+    "1. Download `best_model.pth` for deployment\n",
+    "2. Use it in API/frontend applications\n",
+    "3. Fine-tune with more epochs if needed"
+   ]
+  }
+ ],
+ "metadata": {
+  "accelerator": "GPU",
+  "colab": {
+   "gpuType": "T4",
+   "provenance": []
+  },
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}