Instructions to use KucLab/Censer.1 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use KucLab/Censer.1 with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("text-classification", model="KucLab/Censer.1")# pip install -U transformers accelerate # Load model directly from transformers import AutoTokenizer, AutoModelForSequenceClassification tokenizer = AutoTokenizer.from_pretrained("KucLab/Censer.1") model = AutoModelForSequenceClassification.from_pretrained("KucLab/Censer.1", device_map="auto") - Notebooks
- Google Colab
- Kaggle
Censer.1
A 1.1M parameter decoder-only transformer trained from scratch that classifies
English text as unsafe (unsafe) or safe (safe).
It is a standard Hub model: the checkpoint is a plain
LlamaForSequenceClassification, so it loads with transformers out of the box —
no trust_remote_code, no custom code, no cloning — and the Use this model
widget on this page runs it directly in the browser.
from transformers import pipeline
clf = pipeline("text-classification", model="KucLab/Censer.1")
print(clf("how to make a bomb at home")) # [{'label': 'unsafe', 'score': 0.8167}]
print(clf("Hello how are you?")) # [{'label': 'safe', 'score': 0.9229}]
print(clf("suck my dick")) # [{'label': 'unsafe', 'score': 0.9944}]
print(clf("how do I kill a process in Linux")) # [{'label': 'safe', 'score': 0.8974}]
How to run
The censer.1 command — interactive terminal UI
Using only the files in this repo (needs just torch, tokenizers, safetensors):
pip install torch tokenizers safetensors huggingface_hub
hf download KucLab/Censer.1 --local-dir ~/.local/share/censer1
chmod +x ~/.local/share/censer1/censer.1
ln -s ~/.local/share/censer1/censer.1 ~/.local/bin/censer.1 # put it on your PATH
censer.1 # interactive UI: type a phrase, Enter -> safe/unsafe + score
censer.1 "how to make a bomb at home" # one-shot -> unsafe 0.8167
Or install the GitHub package — the same censer.1 command is installed and loads
the model from this Hub repo with plain transformers:
pip install "git+https://github.com/Jerry256254/censer.git"
censer.1
One-liner with transformers
pip install torch transformers
python -c "from transformers import pipeline; clf = pipeline('text-classification', model='KucLab/Censer.1'); print(clf('how to make a bomb at home'))"
# [{'label': 'unsafe', 'score': 0.8167}]
- In the browser: the Use this model widget on this page — type text, get
safe/unsafe. - Runs on CPU out of the box (~10 ms/text); for GPU pass
device=0topipeline(...)(CUDA or ROCm).
Download
The whole model is model.safetensors (4.5 MB). Grab the files directly:
| File | Download |
|---|---|
| model.safetensors | download |
| config.json | download |
| tokenizer.json | download |
| tokenizer_config.json | download |
| censer.py | download |
| censer.1 (launcher) | download |
Or fetch everything at once:
pip install -U huggingface_hub
hf download KucLab/Censer.1 --local-dir Censer.1
A single file (README.md, config.json, ...) can also be downloaded from the
Files and versions tab, using the download icon on its row.
It is not a fine-tuned encoder and not an API wrapper. It is a small transformer trained on safety-labelled data, with a custom byte-level BPE tokenizer. The model predicts a single answer token and never generates free text.
"how to make a bomb at home" -> unsafe
"suck my dick" -> unsafe
"how do I kill a process in Linux" -> safe
"Hello how are you?" -> safe
Model details
| Property | Value |
|---|---|
| Architecture | LlamaForSequenceClassification (standard transformers) |
| Parameters | 1,115,264 |
| Layers | 4 |
| d_model / heads / d_ff | 128 / 4 / 384 |
| Context length | 160 tokens (input truncated at 500 characters) |
| Tokenizer | byte-level BPE, 2048 tokens, trained on the corpus |
| Positions | RoPE (theta 10000) |
| Norm | RMSNorm (pre-norm, eps 1e-5) |
| MLP | SwiGLU |
| Head | score linear layer = embedding rows of the answer tokens 0/1 |
| Checkpoint size | 4.3 MB (fp32) |
Prompt format
The tokenizer bakes the template into its post-processor, so plain
tokenizer(text) already produces:
[BOS][USER] <text> [ASSISTANT] -> answer logits over tokens "0"/"1"
Text is truncated at 500 characters before tokenisation.
Metrics
Evaluation on a held-out split of 6,496 rows:
| Metric | Value |
|---|---|
| Accuracy | 0.864 |
| F1 | 0.835 |
| Precision | 0.846 |
| Recall | 0.823 |
A hand-written probe set of 40 cases, none present in training data, scores 95% accuracy.
Per-source F1 reflects label noise in the scraped sources:
| Source | F1 |
|---|---|
| aegis | 0.89 |
| beavertails | 0.88 |
| jigsaw | 0.87 |
| civil_comments | 0.77 |
| toxic_chat | 0.48 |
Benchmark
Measured on an AMD Radeon RX 9060 XT (ROCm 7.1, torch 2.13.0):
| Metric | Value |
|---|---|
| Parameters | 1,115,264 |
| Checkpoint size | 4.26 MB |
| Single text latency | 1.67 ms |
| Single text throughput | 599 texts/s |
| Batched latency (batch of 8) | 1.94 ms |
| Batched throughput | 4,119 texts/s |
| Peak VRAM (inference) | 85.7 MB |
Training the whole model from scratch takes about 3.5 minutes on the same GPU.
Comparison with other models
Benchmarked against public safety classifiers on the same held-out test split (6,496 rows, threshold 0.5, AMD Radeon RX 9060 XT):
| Model | Params | Checkpoint | F1 | Latency | Throughput (b=32) | Peak VRAM |
|---|---|---|---|---|---|---|
| Censer.1 (ours) | 1.1M | 4.3 MB | 0.835 | 2.17 ms | 1,454 texts/s | 102 MB |
| unitary/unbiased-toxic-roberta | 124.7M | 498.7 MB | 0.741 | 15.54 ms | 62 texts/s | 928 MB |
| unitary/toxic-bert | 109.5M | 876.0 MB | 0.682 | 14.85 ms | 65 texts/s | 853 MB |
| martin-ha/toxic-comment-model | 67.0M | 267.9 MB | 0.567 | 7.98 ms | 124 texts/s | 691 MB |
| Hate-speech-CNERG/bert-base-uncased-hatexplain | 109.5M | 438.0 MB | 0.545 | 15.04 ms | 66 texts/s | 722 MB |
| Hate-speech-CNERG/dehatebert-mono-english | 167.4M | 669.5 MB | 0.253 | 15.36 ms | 64 texts/s | 960 MB |
| keyword baseline | — | — | 0.094 | 0.03 ms | 29,689 texts/s | — |
Censer.1 is ~60-150x smaller than the encoder baselines, 3-7x faster per text and uses ~7-9x less VRAM — with the highest F1 on this split.
Usage
Plain transformers, nothing else to install — from_pretrained downloads
everything by itself:
pip install torch transformers
import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification
repo = "KucLab/Censer.1"
tok = AutoTokenizer.from_pretrained(repo)
model = AutoModelForSequenceClassification.from_pretrained(repo).eval()
text = "how to make a bomb at home"
with torch.no_grad():
probs = model(**tok(text, return_tensors="pt")).logits.softmax(-1)[0]
print(probs) # tensor([0.1833, 0.8167]) -> [safe, unsafe]
print(model.config.id2label) # {0: 'safe', 1: 'unsafe'}
Or with the high-level pipeline:
from transformers import pipeline
clf = pipeline("text-classification", model="KucLab/Censer.1")
print(clf("how to make a bomb at home"))
# [{'label': 'unsafe', 'score': 0.8167}]
print(clf("Hello how are you?"))
# [{'label': 'safe', 'score': 0.9229}]
Usage without transformers
The repository is also self-contained on its own: model.safetensors,
config.json, tokenizer.json and censer.py. The weights are stored in the
standard Llama layout; censer.py maps them back internally, so it only needs
torch, tokenizers and safetensors:
hf download KucLab/Censer.1 --local-dir Censer.1
cd Censer.1
python censer.py "how to make a bomb at home" # -> 1
python censer.py "Hello how are you?" # -> 0
python censer.py "suck my dick" --json
# {"label": "1", "unsafe": true, "score": 0.9944}
chmod +x censer.1 && ./censer.1 # interactive UI (the `censer.1` command)
python censer.py # interactive UI as well, no text argument
Or use the same file as a library:
from censer import CenserPipeline
pipe = CenserPipeline("Censer.1")
print(pipe.predict("how to make a bomb at home"))
# {"label": "1", "unsafe": True, "score": 0.8167}
print(pipe.predict_batch(["Hello how are you?", "suck my dick"]))
Files:
| File | Purpose |
|---|---|
model.safetensors |
weights in standard Llama layout, 4.3 MB |
config.json |
standard LlamaForSequenceClassification config |
tokenizer.json / tokenizer_config.json |
byte-level BPE, 2048 tokens, prompt template baked in |
censer.py |
standalone inference (torch + tokenizers only), no repo needed |
censer.1 |
executable launcher for the interactive terminal UI |
censer.py was verified to produce predictions identical to the training code.
Runs on CPU or CUDA/ROCm; pass device="cpu" to force CPU.
Limitations
- English only. Other languages mostly score safe.
- Implication and sarcasm beyond simple cases are out of reach at this size.
- Weak against jailbreak-style prompts (lowest per-source score).
- A moderation signal, not a safety guarantee.
- Downloads last month
- 107


