File size: 7,035 Bytes

---
license: mit
language:
  - hi
tags:
  - token-classification
  - onnx
  - char-cnn
  - hinglish
  - devanagari
  - indian-numbering
  - webgpu
library_name: custom
pipeline_tag: token-classification
datasets:
  - athrvk/gpu-sankhya-gold
---

# gpu-sankhya

A small char-level CNN that extracts Indian informal number/currency
shorthand -- Hinglish (romanised Hindi), Devanagari Hindi, Devanagari
Marathi, Gujarati, and Indian-English amount phrases like `sava lakh`, `dedh crore`, `डेढ़ लाख`,
`सवा करोड़`, `દોઢ લાખ`, `2.5L`, `20k`, `2-3 lakh` -- from free text, and turns each
match into a clean numeric value via a deterministic arithmetic core (the
model never predicts the value directly).

- npm package (runtime, ships this model quantized inline):
  https://www.npmjs.com/package/gpu-sankhya
- source / training code:
  https://github.com/athrvk/gpu-sankhya
- live demo: https://huggingface.co/spaces/athrvk/gpu-sankhya-demo
- gold evaluation sets: https://huggingface.co/datasets/athrvk/gpu-sankhya-gold

This model card describes weights version `v0.8.0` (arch `v2`).

## Architecture

A dilated/residual char-CNN over per-character embeddings:

- embedding dim: 16
- conv channels: 48
- 5 conv layers:
  1. kernel 5, dilation 1, residual no
  2. kernel 3, dilation 1, residual yes
  3. kernel 3, dilation 2, residual yes
  4. kernel 3, dilation 4, residual yes
  5. kernel 3, dilation 8, residual yes
- vocab: 170 characters (union of every shipped language pack)
- output classes: 120 (BIO span tag + semantic token class)
- parameters: 40,475

A deterministic arithmetic core (not part of this model) then evaluates
the decoded token sequence into a value: prefix semantics (sava = x1.25,
dedh = x1.5, paune = subtract 1/4 from the next cardinal, ...), additive
combination of descending units, multiplicative combination of ascending
units, and range handling.

## Files

| file | size |
| --- | ---: |
| `charset.json` | 1,425 bytes |
| `classes.json` | 1,571 bytes |
| `gold_metrics_json_float32.json` | 7,336 bytes |
| `gold_metrics_json_int8.json` | 7,338 bytes |
| `gold_metrics_torch.json` | 7,336 bytes |
| `kaggle_metrics.json` | 26,135 bytes |
| `matrix.md` | 872 bytes |
| `sankhya.onnx` | 164,545 bytes |
| `sankhya.pt` | 172,214 bytes |
| `sankhya.weights.int8.json` | 60,720 bytes |
| `sankhya.weights.json` | 405,469 bytes |

- `sankhya.pt` -- torch checkpoint (vocab, classes, arch, channels, state_dict)
- `sankhya.onnx` -- ONNX graph, for interop/inspection
- `sankhya.weights.json` -- float32 weights, human-readable JSON
- `sankhya.weights.int8.json` -- int8-quantized weights (what the npm
  package and this card's accuracy numbers use)
- `charset.json`, `classes.json` -- standalone vocab/class tables
- `gold_metrics_*.json` -- per-file + combined gold evaluation (torch,
  float32 JSON, int8 JSON)
- `matrix.md`, `kaggle_metrics.json` -- training/sweep provenance from the
  Kaggle GPU run that produced this checkpoint

## Accuracy

Evaluated with the int8-quantized weights (what ships in the npm package)
against the hand-written gold sets (`gold_<lang>.jsonl` -- see the
[dataset card](athrvk/gpu-sankhya-gold)):

| gold set | examples | spans | value_acc | precision | recall | F1 |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| gold.jsonl | 227 | 199 | 0.9598 | 0.9550 | 0.9598 | 0.9574 |
| gold_deva.jsonl | 186 | 155 | 0.9677 | 0.9868 | 0.9677 | 0.9772 |
| gold_mr.jsonl | 173 | 135 | 0.9852 | 0.9852 | 0.9852 | 0.9852 |
| gold_gu.jsonl | 162 | 118 | 0.9322 | 0.9658 | 0.9576 | 0.9617 |
| **combined** | 748 | 607 | **0.9621** | 0.9719 | 0.9671 | 0.9694 |

Negatives (zero-gold-span examples): 170, false
positives: 0 (0.00%).

Per-category value accuracy (combined):

| category | spans | value_acc |
| --- | ---: | ---: |
| digits | 145 | 0.9724 |
| words | 462 | 0.9589 |
| prefix | 104 | 0.9808 |
| range | 49 | 0.9592 |
| currency | 117 | 0.9658 |
| multi_unit | 28 | 0.9643 |
| symbol_unit | 50 | 1.0000 |
| mixed_script | 3 | 1.0000 |
| long | 16 | 0.8750 |

## Usage

### JavaScript (recommended -- ships this model quantized, no download)

```js
import { parse } from "gpu-sankhya";

parse("sava lakh");
// [{ span: "sava lakh", value: 125000, unit: "lakh", ... }]
```

### Python (numpy reference forward pass)

```python
import numpy as np
from sankhya import np_infer, decode, core, charset
from sankhya.train import build_char_to_id

weights_json = json.load(open("sankhya.weights.int8.json"))
weights = np_infer.load_weights_int8_json(weights_json)
char_to_id = build_char_to_id(weights_json["charset"])
unk = char_to_id.get("<unk>", 1)

text = charset.normalize_text("sava lakh")
ids = np_infer.pad_ids([char_to_id.get(c, unk) for c in text])
bio_logits, cls_logits = np_infer.forward(weights, np.array(ids))
n = len(text)
bio_pred = bio_logits[:n].argmax(-1).tolist()
cls_pred = cls_logits[:n].argmax(-1).tolist()
bio_probs = np_infer.softmax(bio_logits[:n]).tolist()

spans = decode.decode_spans(text, bio_pred, cls_pred, bio_probs=bio_probs)
for span in spans:
    result = core.evaluate(span["tokens"])
    print(text[span["start"]:span["end"]], result.value)
```

See `python/README.md` in the source repo for the full training/export
pipeline and `sankhya.eval_gold` for a ready-made evaluation CLI.

## Training

Trained 20 epochs on 200,000 synthetic examples generated from the
`hi_latn` (romanised Hindi), `hi_deva` (Devanagari Hindi), `mr_deva`
(Devanagari Marathi), and `gu_gujr` (Gujarati) grammar packs, mixed
0.32/0.26/0.21/0.21 with a 10%
cross-pack share, plus out-of-vocab
"unk noise" augmentation (emoji, CJK, Cyrillic, other symbols inserted as
O-labelled context) so the `<unk>` embedding actually gets gradient
signal. Batch size 128, lr 3e-3. Architecture and channel count (`v2`,
48 channels) were chosen by a config/seed sweep, picking the config with
the highest mean int8 combined gold value_acc across >= 3 seeds (seed
spread is +/-1-2 points), then the seed by val accuracy within a 0.005 tie
band, then higher int8 combined gold F1, then lower negatives
false-positive rate. Full recipe, sweep evidence, and reproduction
commands: `python/README.md` in the source repo.

## Limitations

- JavaScript string indices count UTF-16 code units, so astral characters
  (e.g. some emoji) occupy 2 code units -- span offsets from the JS
  runtime account for this, but consumers indexing raw strings themselves
  should be aware of it.
- The model occasionally produces spurious spans on unfamiliar words near
  number-ish context (a measured trade-off from the out-of-vocab noise
  training -- see Accuracy above).
- Long multi-term/mixed-numeral constructs and multi-number range phrases
  ("तीस पैंतीस हज़ार", "three n half lakh") are the weakest category
  (`long`/`range` value_acc above).
- Scoped to Indian languages: currently Hinglish, Devanagari Hindi,
  Devanagari Marathi, and Gujarati only; other Indian languages are
  planned (see the source repo's roadmap).