turkish-safety

Turkish Safety - Content Moderation Classifier v5.0

Multi-label classification model for Turkish content moderation

Developed by SiriusAI Tech Brain Team

---

Mission

Empowering digital platforms with AI-driven content safety solutions.

Turkish Safety is an advanced NLP model that analyzes Turkish content in real-time and detects harmful content across 7 different categories. It provides comprehensive content moderation for social media platforms, messaging applications, in-game chats, and community forums.

Why This Model Matters

• 7 Risk Categories: Detects SAFE, GROOMING, SEXUAL, OFFENSIVE, BULLYING, SELF_HARM, and THREAT
• Turkish-First Design: Optimized for Turkish linguistics and cultural context using BERTurk
• Production-Ready: <50ms inference, battle-tested architecture, enterprise-grade reliability
• Multi-Label Intelligence: Smart classification that understands content can belong to multiple categories
• Expert Validation: Curated training data with clear category boundaries and edge case handling

---

Model Overview

---

Performance Metrics

Final Evaluation Results (Epoch 2)

Training Progress

Validation Test Results (86.4% Accuracy)

---

Dataset

Dataset Statistics

Category Distribution (Full Dataset)

Subcategory Breakdown

Data Generation Methodology

1. Synthetic Generation: LLM-based generation with expert-defined category boundaries
2. Hard Negative Mining: Difficult edge cases for boundary discrimination
3. Quality Filtering: Duplicate detection, minimum word count, forbidden token filtering
4. Parallel Processing: 20 concurrent workers with batch size of 50
5. Pass Rate: 97.5% average acceptance rate across all categories

---

Label Definitions

The model classifies text into 7 mutually non-exclusive categories:

Important: Category Boundaries

GROOMING vs SEXUAL Distinction:

• GROOMING: Non-sexual manipulation tactics (trust-building, secrecy, gift promises, meeting requests)
• SEXUAL: Any body-related comments, physical compliments, sexual questions, explicit content

"Kimseye söyleme tamam mı?"  → GROOMING (secrecy/isolation)
"Vücudun çok güzel"          → SEXUAL (body comment)
"Telefon alırım sana"        → GROOMING (gift promise)
"Dudakların çok güzel"       → SEXUAL (body-focused compliment)
"Gel evime yalnızım"         → GROOMING (meeting request/isolation)
"Hiç öpüştün mü?"            → SEXUAL (sexual experience question)

---

Training Procedure

Hyperparameters

Training Environment

Learning Rate Schedule

Peak LR: 2e-5 (after warmup)
Schedule: Cosine with restarts
Final LR: ~1.1e-8

---

Usage

Installation

pip install transformers torch

Quick Start

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch

# Load model
model_name = "hayatiali/turkish-safety"
tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-base-turkish-uncased")
model = AutoModelForSequenceClassification.from_pretrained(model_name)
model.eval()

# Label mapping (MUST match model's id2label)
LABELS = ["SAFE", "OFFENSIVE", "SELF_HARM", "GROOMING", "BULLYING", "SEXUAL", "THREAT"]

def predict(text):
    inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=128)

    with torch.no_grad():
        outputs = model(**inputs)
        # Multi-label: use sigmoid (NOT softmax!)
        probs = torch.sigmoid(outputs.logits)[0].numpy()

    scores = {label: float(prob) for label, prob in zip(LABELS, probs)}
    primary = max(scores, key=scores.get)

    return {"category": primary, "confidence": scores[primary], "all_scores": scores}

# Examples
print(predict("Vücudun çok güzel"))       # → SEXUAL
print(predict("Kimseye söyleme tamam mı")) # → GROOMING
print(predict("Ölmek istiyorum"))          # → SELF_HARM
print(predict("Bugün hava güzel"))         # → SAFE

Production Class

class TurkishSafetyClassifier:
    LABELS = ["SAFE", "OFFENSIVE", "SELF_HARM", "GROOMING", "BULLYING", "SEXUAL", "THREAT"]

    def __init__(self, model_path="hayatiali/turkish-safety"):
        self.tokenizer = AutoTokenizer.from_pretrained("dbmdz/bert-base-turkish-uncased")
        self.model = AutoModelForSequenceClassification.from_pretrained(model_path)
        self.device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
        self.model.to(self.device).eval()

    def predict(self, text: str) -> dict:
        inputs = self.tokenizer(text, return_tensors="pt", truncation=True, max_length=128)
        inputs = {k: v.to(self.device) for k, v in inputs.items()}

        with torch.no_grad():
            logits = self.model(**inputs).logits
            probs = torch.sigmoid(logits)[0].cpu().numpy()

        scores = dict(zip(self.LABELS, probs))
        primary = max(scores, key=scores.get)

        return {
            "category": primary,
            "confidence": scores[primary],
            "scores": scores,
            "action": self._get_action(scores[primary], primary)
        }

    def _get_action(self, score: float, category: str) -> str:
        # Critical categories have lower thresholds
        if category in ["GROOMING", "SEXUAL", "SELF_HARM", "THREAT"]:
            if score > 0.5: return "hard_block"
            if score > 0.3: return "soft_block"

        if score > 0.75: return "hard_block"
        if score > 0.60: return "soft_block"
        if score > 0.45: return "flag"
        if score > 0.30: return "allow_log"
        return "allow"

Batch Inference

def predict_batch(texts: list, batch_size: int = 32) -> list:
    results = []
    for i in range(0, len(texts), batch_size):
        batch = texts[i:i + batch_size]
        inputs = tokenizer(batch, return_tensors="pt", truncation=True, max_length=128, padding=True)
        inputs = {k: v.to(device) for k, v in inputs.items()}

        with torch.no_grad():
            probs = torch.sigmoid(model(**inputs).logits).cpu().numpy()

        for prob in probs:
            scores = dict(zip(LABELS, prob))
            results.append(scores)

    return results

---

Limitations & Known Issues

⚠️ Evaluation Limitations

Note: Two separate evaluation sets exist:

• Automated Test Set: 17,033 samples from test.csv → Macro F1: 0.9165, MCC: 0.9045
• Manual Edge Case Test: 22 hand-picked samples → 86.4% accuracy (19/22 correct)

⚠️ Architectural Limitations

⚠️ Data & Coverage Limitations

⚠️ Production Deployment Considerations

Not Suitable For

• Languages other than Turkish
• Adult content moderation (requires different domain expertise)
• Sole decision-making without human review for high-stakes situations
• Legal evidence or court proceedings
• Detection of sophisticated, multi-turn grooming attempts without additional context layer
• Highly informal/slang-heavy communications without additional preprocessing

---

Ethical Considerations

Intended Use

• Social media content moderation
• Messaging platform safety filters
• Gaming chat moderation
• Community forum monitoring
• Parental control applications
• Research and educational purposes

Risks

• False Negatives: May miss sophisticated grooming attempts
• False Positives: May flag benign content incorrectly
• Automation Bias: Over-reliance on model predictions

Recommendations

1. Human Oversight: Always combine with human review for critical decisions
2. Threshold Calibration: Adjust thresholds based on your risk tolerance
3. Monitoring: Track performance metrics in production
4. Regular Updates: Retrain with new data periodically
5. Transparency: Inform users about automated moderation

---

Technical Specifications

Model Architecture

BertForSequenceClassification(
  (bert): BertModel(
    (embeddings): BertEmbeddings
    (encoder): BertEncoder (12 layers)
    (pooler): BertPooler
  )
  (dropout): Dropout(p=0.1)
  (classifier): Linear(in_features=768, out_features=7)
)

Total Parameters: ~110M
Trainable Parameters: ~110M

Input/Output

• Input: Turkish text (max 128 tokens)
• Output: 7-dimensional probability vector (sigmoid activated)
• Tokenizer: BERTurk WordPiece (32k vocab)

---

Citation

@misc{turkish-safety-2025,
  title={Turkish Safety - Content Moderation Classifier},
  author={SiriusAI Tech Brain Team},
  year={2025},
  publisher={Hugging Face},
  howpublished={\url{https://huggingface.co/hayatiali/turkish-safety}},
  note={Fine-tuned from dbmdz/bert-base-turkish-uncased, Macro F1: 0.9076}
}

---

Model Card Authors

SiriusAI Tech Brain Team

Contact

• Issues: GitHub Issues
• Repository: Omni-Moderation-API

---

Changelog

v5.0 (Current)

• Major dataset expansion: 85,161 samples (68,128 train / 17,033 test)
• Improved metrics: Macro F1: 0.9165, MCC: 0.9045
• Optimized hyperparameters for large dataset (Focal Loss, cosine restarts)
• 67 subcategories across 7 main categories
• 86.4% validation accuracy on edge cases

v4.0

• Initial production release
• 7-category multi-label content safety classification
• Macro F1: 0.9076, MCC: 0.8931
• Training on 30,596 samples
• Clear category boundary definitions (GROOMING vs SEXUAL)
• Optimized for real-time inference (<50ms)

---

License: SiriusAI Tech Premium License v1.0

Commercial Use: Requires Premium License. Contact: [email protected]

Free Use Allowed For:

• Academic research and education
• Non-profit organizations (with approval)
• Evaluation (30 days)

Disclaimer: This model is designed for content moderation and safety applications. Always implement with appropriate safeguards and human oversight. Model predictions should inform decisions, not replace human judgment.