yazoniak/twitter-emotion-pl-classifier-ONNX

Polish Twitter Emotion Classifier (ONNX)

This is the ONNX FP32 version of yazoniak/twitter-emotion-pl-classifier

This model is an ONNX-converted version of the Polish Twitter Emotion Classifier, optimized for 2x faster inference while maintaining full accuracy. The model was converted using Hugging Face Optimum.

Quick Links

• 🔗 Original PyTorch Model: yazoniak/twitter-emotion-pl-classifier
• 🚀 INT8 Quantized Version: yazoniak/twitter-emotion-pl-classifier-onnx-int8 (75% smaller, 3x faster)
• 📊 Dataset: yazoniak/TwitterEmo-PL-Refined

Model Description

This model predicts 8 emotion and sentiment labels simultaneously for Polish text:

• Emotions: radość (joy), wstręt (disgust), gniew (anger), przeczuwanie (anticipation)
• Sentiment: pozytywny (positive), negatywny (negative), neutralny (neutral)
• Special: sarkazm (sarcasm)

Model Details

Performance

ONNX vs PyTorch Comparison

Note: ONNX has slower cold start (2.6s vs 0.3s) but significantly faster inference.

Model Accuracy

The ONNX model maintains the same accuracy as the original PyTorch model:

For detailed per-label performance, see the original model card.

Numerical Validation

• ✅ Structural Validation: Passed ONNX checker
• ✅ Numerical Accuracy: All tests passed
  • Max absolute difference: 5.65e-06
  • Max relative difference: 1.93e-04

Installation

pip install optimum[onnxruntime] transformers numpy

For GPU support:

pip install optimum[onnxruntime-gpu] transformers numpy

Usage

Quick Start (Command Line)

# Download the inference scripts
wget https://huggingface.co/yazoniak/twitter-emotion-pl-classifier-onnx/resolve/main/predict.py
wget https://huggingface.co/yazoniak/twitter-emotion-pl-classifier-onnx/resolve/main/predict_calibrated.py

# Basic inference
python predict.py "Wspaniały dzień! Jestem bardzo szczęśliwy :)"

# Calibrated inference (recommended for best accuracy)
python predict_calibrated.py "Wspaniały dzień! Jestem bardzo szczęśliwy :)"

Python API - Basic Inference

from optimum.onnxruntime import ORTModelForSequenceClassification
from transformers import AutoTokenizer
import numpy as np
import re

# Load model and tokenizer
model_name = "yazoniak/twitter-emotion-pl-classifier-onnx"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = ORTModelForSequenceClassification.from_pretrained(
    model_name,
    provider="CPUExecutionProvider"  # or "CUDAExecutionProvider" for GPU
)

# Preprocess text (anonymize @mentions - IMPORTANT!)
def preprocess_text(text):
    return re.sub(r"@\w+", "@anonymized_account", text)

text = "@user To jest wspaniały dzień!"
processed_text = preprocess_text(text)

# Tokenize and run inference
inputs = tokenizer(processed_text, return_tensors="pt", truncation=True, max_length=8192)
outputs = model(**inputs)

# Get probabilities (sigmoid for multi-label)
logits = outputs.logits.squeeze().numpy()
probabilities = 1 / (1 + np.exp(-logits))

# Get labels above threshold
labels = [model.config.id2label[i] for i in range(model.config.num_labels)]
threshold = 0.5
predictions = {labels[i]: float(probabilities[i]) 
               for i in range(len(labels)) if probabilities[i] > threshold}

print(predictions)
# Output: {'radość': 0.9758, 'pozytywny': 0.9856}

Python API - Calibrated Inference (Recommended)

For improved accuracy, use temperature scaling and optimal thresholds:

import json
from huggingface_hub import hf_hub_download

# Download calibration artifacts
calib_path = hf_hub_download(
    repo_id="yazoniak/twitter-emotion-pl-classifier-onnx",
    filename="calibration_artifacts.json"
)

with open(calib_path) as f:
    calib = json.load(f)

temperatures = calib["temperatures"]
optimal_thresholds = calib["optimal_thresholds"]

# Apply temperature scaling and optimal thresholds
calibrated_probs = {}
for i, label in enumerate(labels):
    temp = temperatures[label]
    thresh = optimal_thresholds[label]
    
    # Temperature scaling
    calibrated_logit = logits[i] / temp
    prob = 1 / (1 + np.exp(-calibrated_logit))
    
    if prob > thresh:
        calibrated_probs[label] = float(prob)

print(calibrated_probs)

GPU Inference

model = ORTModelForSequenceClassification.from_pretrained(
    "yazoniak/twitter-emotion-pl-classifier-onnx",
    provider="CUDAExecutionProvider"
)

When to Use This Model

Use ONNX FP32 when:

• You need 2x faster inference than PyTorch
• You want full FP32 precision
• You're deploying on CPU servers
• You need cross-platform compatibility

Consider alternatives:

• Original PyTorch: For fine-tuning or GPU training
• ONNX INT8: For even faster inference (3x) and smaller size (75% reduction)

Important Notes

Text Preprocessing

⚠️ The model expects @mentions to be anonymized!

The model was trained with anonymized Twitter mentions. Always preprocess text:

text = re.sub(r"@\w+", "@anonymized_account", text)

The provided scripts (predict.py, predict_calibrated.py) handle this automatically.

Calibration

For best accuracy, use calibrated inference with:

• Temperature scaling (per-label)
• Optimized thresholds (per-label)

See predict_calibrated.py or the calibrated inference example above.

Limitations

• Twitter-specific: Optimized for informal Polish social media text
• Sarcasm detection: Lower performance (F1: 0.53) - inherently difficult
• Context length: Optimal for tweet-length texts (up to 8,192 tokens)
• Formal text: May not generalize well to news or academic writing

For detailed limitations, see the original model card.

Files in This Repository

Citation

@model{yazoniak2025twitteremotionpl,
  title={Polish Twitter Emotion Classifier (RoBERTa-8k)},
  author={yazoniak},
  year={2025},
  publisher={Hugging Face},
  url={https://huggingface.co/yazoniak/twitter-emotion-pl-classifier}
}

Also cite the dataset and base model:

@dataset{yazoniak_twitteremo_pl_refined_2025,
  title={TwitterEmo-PL-Refined: Polish Twitter Emotions (8 labels, refined)},
  author={yazoniak},
  year={2025},
  url={https://huggingface.co/datasets/yazoniak/TwitterEmo-PL-Refined}
}

@inproceedings{bogdanowicz2023twitteremo,
  title={TwitterEmo: Annotating Emotions and Sentiment in Polish Twitter},
  author={Bogdanowicz, S. and Cwynar, H. and Zwierzchowska, A. and Klamra, C. and Kiera{\'s}, W. and Kobyli{\'n}ski, {\L}.},
  booktitle={Computational Science -- ICCS 2023},
  series={Lecture Notes in Computer Science},
  volume={14074},
  publisher={Springer, Cham},
  year={2023},
  doi={10.1007/978-3-031-36021-3_20}
}

License

This model is released under the GNU General Public License v3.0 (GPL-3.0), inherited from the training dataset.

License Chain:

• Base Model (PKOBP/polish-roberta-8k): Apache-2.0
• Training Dataset (TwitterEmo-PL-Refined): GPL-3.0
• Original Model (yazoniak/twitter-emotion-pl-classifier): GPL-3.0
• This ONNX Model: GPL-3.0

Acknowledgments

• Original Model: yazoniak/twitter-emotion-pl-classifier
• Base Model: PKOBP/polish-roberta-8k
• Dataset: CLARIN-PL TwitterEmo
• Conversion: Hugging Face Optimum

Model Version: v1.0-onnx
Last Updated: 2026-01-29