hayatiali/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. 1.Synthetic Generation: LLM-based generation with expert-defined category boundaries
2. 2.Hard Negative Mining: Difficult edge cases for boundary discrimination
3. 3.Quality Filtering: Duplicate detection, minimum word count, forbidden token filtering
4. 4.Parallel Processing: 20 concurrent workers with batch size of 50
5. 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. 1.Human Oversight: Always combine with human review for critical decisions
2. 2.Threshold Calibration: Adjust thresholds based on your risk tolerance
3. 3.Monitoring: Track performance metrics in production
4. 4.Regular Updates: Retrain with new data periodically
5. 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: info@siriusaitech.com

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.