Text Classification
Transformers
ONNX
Safetensors
llama
safety
content-moderation
multi-label
multilingual
tiny-language-model
from-scratch
distilled
text-embeddings-inference
Instructions to use KucLab/Barist.3 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use KucLab/Barist.3 with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("text-classification", model="KucLab/Barist.3")# pip install -U transformers accelerate # Load model directly from transformers import AutoTokenizer, AutoModelForSequenceClassification tokenizer = AutoTokenizer.from_pretrained("KucLab/Barist.3") model = AutoModelForSequenceClassification.from_pretrained("KucLab/Barist.3", device_map="auto") - Notebooks
- Google Colab
- Kaggle
Download scripts/serve.py from KucLab/Barist.3: direct link, hf CLI and curl.
- Browser
- Download file 4.76 kB
-
https://huggingface.co/KucLab/Barist.3/resolve/main/scripts/serve.py
- Command line
-
hf download hf://KucLab/Barist.3/scripts/serve.py
-
curl -L -o serve.py https://huggingface.co/KucLab/Barist.3/resolve/main/scripts/serve.py
4.76 kB
| """Batch classification API for the Barist.1 Hub bundle (stdlib only, no FastAPI). | |
| python serve.py --port 8000 # serves the local HF bundle dir (run from the bundle root) | |
| CENSER_DIR=/path/to/bundle python scripts/serve.py | |
| Response fields per text: `label` ("safe"/"unsafe"), `unsafe`, `score`, | |
| `categories` (top-2 by priority: sexual_abuse > self_harm > violence/weapons > ... > hate; | |
| unsafe always gets >=1 category), `override` ("must_catch" when the deterministic | |
| pre-filter fired), `needs_review` (jailbreak/legally-ambiguous patterns — review, not a | |
| block), `needs_support` (Linka bezpečí URL when self-harm is indicated, regex or | |
| model score >= 0.3). | |
| Endpoints: | |
| GET /health -> {"status": "ok", "model": ...} | |
| POST /classify -> {"texts": [...]} => {"results": [{label, unsafe, score, categories, chunks}]} | |
| POST /classify-one -> {"text": "..."} => single result | |
| Features: batching, long-input chunking (chunk_tokens/stride), token-bucket | |
| rate limit (env RATE_LIMIT_PER_MIN, default 600), max body size guard. | |
| python serve.py --dir bundle --port 8000 | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| import os | |
| import time | |
| from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer | |
| from pathlib import Path | |
| MAX_BODY = 2 * 1024 * 1024 # 2 MB | |
| class RateLimiter: | |
| def __init__(self, per_min: float) -> None: | |
| self.per_min = per_min | |
| self.tokens = per_min | |
| self.updated = time.monotonic() | |
| self.last_deny = 0.0 | |
| def allow(self, cost: float = 1.0) -> bool: | |
| now = time.monotonic() | |
| self.tokens = min(self.per_min, self.tokens + (now - self.updated) * self.per_min / 60.0) | |
| self.updated = now | |
| if self.tokens >= cost: | |
| self.tokens -= cost | |
| return True | |
| return False | |
| def make_handler(pipe, limiter: RateLimiter, model_name: str): | |
| class Handler(BaseHTTPRequestHandler): | |
| def _json(self, code: int, payload: dict) -> None: | |
| body = json.dumps(payload, ensure_ascii=False).encode("utf-8") | |
| self.send_response(code) | |
| self.send_header("Content-Type", "application/json; charset=utf-8") | |
| self.send_header("Content-Length", str(len(body))) | |
| self.end_headers() | |
| self.wfile.write(body) | |
| def log_message(self, fmt, *args): # quiet | |
| pass | |
| def do_GET(self): | |
| if self.path == "/health": | |
| self._json(200, {"status": "ok", "model": model_name, "device": str(pipe.device)}) | |
| else: | |
| self._json(404, {"error": "not found"}) | |
| def do_POST(self): | |
| if not limiter.allow(): | |
| self._json(429, {"error": "rate limit exceeded"}) | |
| return | |
| length = int(self.headers.get("Content-Length") or 0) | |
| if length > MAX_BODY: | |
| self._json(413, {"error": "body too large"}) | |
| return | |
| try: | |
| payload = json.loads(self.rfile.read(length) or b"{}") | |
| except Exception: | |
| self._json(400, {"error": "invalid json"}) | |
| return | |
| if self.path == "/classify-one": | |
| text = str(payload.get("text", "")) | |
| self._json(200, pipe.predict(text)) | |
| elif self.path == "/classify": | |
| texts = payload.get("texts") | |
| if not isinstance(texts, list) or not texts or len(texts) > 256: | |
| self._json(400, {"error": "texts must be a list of 1..256 strings"}) | |
| return | |
| self._json(200, {"results": pipe.predict_batch([str(t) for t in texts])}) | |
| else: | |
| self._json(404, {"error": "not found"}) | |
| return Handler | |
| def main() -> None: | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--dir", default=os.environ.get("CENSER_DIR", "bundle")) | |
| parser.add_argument("--port", type=int, default=8000) | |
| parser.add_argument("--host", default="0.0.0.0") | |
| parser.add_argument("--device", default=None) | |
| args = parser.parse_args() | |
| import sys | |
| sys.path.insert(0, str(Path(__file__).resolve().parent)) | |
| from censer import CenserPipeline | |
| pipe = CenserPipeline(args.dir, device=args.device) | |
| limiter = RateLimiter(float(os.environ.get("RATE_LIMIT_PER_MIN", "600"))) | |
| server = ThreadingHTTPServer((args.host, args.port), make_handler(pipe, limiter, args.dir)) | |
| print(f"barist.3 serve: model={args.dir} device={pipe.device} on http://{args.host}:{args.port}") | |
| print(" POST /classify {\"texts\": [...]} POST /classify-one {\"text\": ...} GET /health") | |
| server.serve_forever() | |
| if __name__ == "__main__": | |
| main() | |