---
license: mit
language:
- bo
tags:
- image-classification
- tibetan
- ocr
- cnn
- pytorch
library_name: pytorch
---

# Namsel BUDA CNN — Tibetan Character Classifier

Lightweight CNN for Tibetan character recognition, replacing the hand-crafted feature pipeline of the [Namsel OCR](https://escholarship.org/uc/item/6d5781k5) system with learned CNN features used in [TradutorBUDA](https://tashirabten.github.io/BUDA_APPs_Port/).

**94.47% validation accuracy** on 1,020 Tibetan character classes. Trained on 47,777 samples derived from the Namsel OCR project dataset. Exported to ONNX (FP32 and INT8) for CPU deployment.

## Model Files

| File | Size | Description |
|------|------|-------------|
| `best_model.pth` | 4.30 MB | PyTorch checkpoint (recommended) |
| `best_model.onnx` | 1.35 MB | ONNX FP32 export |
| `best_model_int8.onnx` | 0.37 MB | ONNX INT8 quantized (fastest on CPU) |
| `label_mapping.json` | — | Class index ↔ label mapping (1,020 classes) |

## Architecture — TibetanCNN

CPU-optimized CNN with depthwise separable convolutions and residual connections.

```
Input (1 × 32 × 32 grayscale)
→ Stem:  Conv2d(1→32, 3×3) + BN + ReLU          [32 × 32 × 32]
→ Down1: DepthwiseSeparableConv(32→64, stride=2)  [64 × 16 × 16]
→ Res1:  ResidualBlock(64)                        [64 × 16 × 16]
→ Down2: DepthwiseSeparableConv(64→128, stride=2) [128 × 8 × 8]
→ Res2:  ResidualBlock(128)                       [128 × 8 × 8]
→ Down3: DepthwiseSeparableConv(128→256,stride=2) [256 × 4 × 4]
→ GlobalAveragePool → Dropout(0.3) → FC(256→1020)
```

- **Parameters:** 353,596 (~8–18× fewer than standard convolutions)
- **Inference:** < 5 ms per character on CPU

## Results

| Model | Val Accuracy | Parameters | Training Time |
|-------|-------------|------------|---------------|
| TibetanCNN (this model) | **94.47%** | 353,596 | 10.1 min |
| CNN+Transformer (comparison) | 95.52% | 491,708 | 18.2 min |

The CNN+Transformer hybrid achieves +1.05% accuracy but uses 39% more parameters and takes 80% longer to train. For CPU OCR deployment, the lightweight CNN with ONNX/INT8 is the practical choice.

## Dataset

- **Source:** [Namsel OCR project](https://github.com/max-lancaster/namsel) training data
- **Total samples:** 47,777 (after deduplication)
- **Classes:** 1,020 Tibetan character classes
- **Image format:** 32×32 binary (black/white) glyphs, 1 channel
- **Split:** 85% train (40,611) / 15% validation (7,166), stratified

Data sources within the dataset:
- `font-draw-samples`: 16,320 synthetically rendered samples
- `pkl files`: 19,613 additional character data
- `ui_samples`: 9,229 UI-extracted samples
- `normalized_3216_to_3232`: 7,117 resized/normalized characters
- `tibcharsamples`: 1,619 manually collected images
- `symbols`: 15 punctuation/special symbols

## Training Configuration

- **Optimizer:** AdamW (lr=1e-3, weight_decay=1e-4)
- **LR Schedule:** 5-epoch linear warmup → cosine annealing to 1e-6
- **Loss:** CrossEntropyLoss with class weighting + label smoothing (0.1)
- **Augmentation:** Mixup (alpha=0.2)
- **Mixed precision:** AMP/BF16 on NVIDIA A100 (40 GB)
- **Batch size:** 512
- **Epochs:** 100 (early stopping patience=15, did not trigger)
- **Best epoch:** 90

## Usage

### PyTorch

```python
import torch
import numpy as np
from model import TibetanCNN
import json

with open("label_mapping.json") as f:
    mapping = json.load(f)

checkpoint = torch.load("best_model.pth", map_location="cpu", weights_only=False)
model = TibetanCNN(num_classes=mapping["num_classes"], dropout=0.3)
model.load_state_dict(checkpoint["model_state_dict"])
model.eval()

# image: numpy array of shape (32, 32), binary pixels (0 or 1)
img_tensor = torch.tensor(image, dtype=torch.float32).unsqueeze(0).unsqueeze(0)  # [1,1,32,32]
with torch.no_grad():
    logits = model(img_tensor)
pred_idx = logits.argmax(dim=1).item()
pred_label = mapping["idx_to_label"][str(pred_idx)]
```

### ONNX (CPU, fastest with INT8)

```python
import onnxruntime as ort
import numpy as np

session = ort.InferenceSession("best_model_int8.onnx", providers=["CPUExecutionProvider"])

# image: numpy array (32, 32), float32, values 0.0 or 1.0
img = image.astype(np.float32).reshape(1, 1, 32, 32)
logits = session.run(None, {"image": img})[0]
pred_idx = logits.argmax(axis=1)[0]
```

### Using predict.py

```python
from predict import TibetanCNNPredictor

predictor = TibetanCNNPredictor("best_model.pth", "label_mapping.json")
top3 = predictor.predict_top_k(image_array, k=3)
# returns list of (label_idx, confidence) tuples
```

## Background

Tibetan script OCR is an underserved area in document digitization. The original Namsel OCR system (Rowinski, 2016) used hand-crafted features (Zernike moments, Sobel gradients, pixel transition counts) with a scikit-learn classifier, struggling with font variation and low-quality images.

This model replaces that pipeline with learned CNN features, achieving significantly higher accuracy and better generalization across font styles.

## References

- Rowinski, T. "Namsel OCR" (2016). https://escholarship.org/uc/item/6d5781k5
- Wang et al. "Unsupervised Tibetan Historical Document Recognition" (2024). https://www.mdpi.com/2076-3417/14/5/2142
- Loshchilov & Hutter. "Decoupled Weight Decay Regularization" (ICLR 2019). https://arxiv.org/abs/1711.05101
- Zhang et al. "mixup: Beyond Empirical Risk Minimization" (ICLR 2018). https://arxiv.org/abs/1710.09412