boltuix
/

NeuroFeel

@@ -1,536 +1,55 @@
----
-license: apache-2.0
-language:
-- en
-metrics:
-- precision
-- recall
-- f1
-- accuracy
-new_version: v1.0
-datasets:
-- custom
-- chatgpt
-pipeline_tag: text-classification
-library_name: transformers
-tags:
-- emotion
-- classification
-- text-classification
-- neurobert
-- emojis
-- emotions
-- v1.0
-- sentiment-analysis
-- nlp
-- lightweight
-- chatbot
-- social-media
-- mental-health
-- short-text
-- emotion-detection
-- transformers
-- real-time
-- expressive
-- ai
-- machine-learning
-- english
-- inference
-- edge-ai
-- smart-replies
-- tone-analysis
-- contextual-ai
-- wearable-ai
-base_model:
-- neurobert
----
-![Banner](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhgHs4EXWBZuQWWC-bfliV2jHZN7wsgn810HEf42UuUbdPgV9aLVIq7Hiv7sWr0aqsB5aTkiylPkytpOpimhp8Atuo3Q_kO5C6uZTuQf4YEWklXqE7jQiUfZlENL5AjNgvnpLxuBg628ztR4w276TEv8Vr9u7ER7wr6i6A8W14UQ8diNBrsS0zVMVYZVYk/s4000/neurofeel-emotions.jpg)
-# 😊 NeuroFeel — Lightweight NeuroBERT for Real-Time Emotion Detection 🌟
-[![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-yellow.svg)](https://www.apache.org/licenses/LICENSE-2.0)
-[![Model Size](https://img.shields.io/badge/Size-~25MB-blue)](#)
-[![Tasks](https://img.shields.io/badge/Tasks-Emotion%20Detection%20%7C%20Text%20Classification%20%7C%20Sentiment%20Analysis-orange)](#)
-[![Inference Speed](https://img.shields.io/badge/Optimized%20For-Edge%20Devices-green)](#)
-## Table of Contents
-- 📖 [Overview](#overview)
-- ✨ [Key Features](#key-features)
-- 💫 [Supported Emotions](#supported-emotions)
-- 🧠 [Model Architecture](#model-architecture)
-- ⚙️ [Installation](#installation)
-- 📥 [Download Instructions](#download-instructions)
-- 🚀 [Quickstart: Emotion Detection](#quickstart-emotion-detection)
-- 📊 [Evaluation](#evaluation)
-- 💡 [Use Cases](#use-cases)
-- 🖥️ [Hardware Requirements](#hardware-requirements)
-- 📚 [Training Details](#training-details)
-- 🔧 [Fine-Tuning Guide](#fine-tuning-guide)
-- ⚖️ [Comparison to Other Models](#comparison-to-other-models)
-- 🏷️ [Tags](#tags)
-- 📄 [License](#license)
-- 🙏 [Credits](#credits)
-- 💬 [Support & Community](#support--community)
-- ✍️ [Contact](#contact)
-![Banner](https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEhgHs4EXWBZuQWWC-bfliV2jHZN7wsgn810HEf42UuUbdPgV9aLVIq7Hiv7sWr0aqsB5aTkiylPkytpOpimhp8Atuo3Q_kO5C6uZTuQf4YEWklXqE7jQiUfZlENL5AjNgvnpLxuBg628ztR4w276TEv8Vr9u7ER7wr6i6A8W14UQ8diNBrsS0zVMVYZVYk/s4000/neurofeel-emotions.jpg)
-## Overview
-`NeuroFeel` is a **lightweight** NLP model built on **NeuroBERT**, fine-tuned for **short-text emotion detection** on **edge and IoT devices**. With a quantized size of **~25MB** and **~7M parameters**, it classifies text into **13 nuanced emotional categories** (e.g., Happiness, Sadness, Anger, Love) with high precision. Optimized for **low-latency** and **offline operation**, NeuroFeel is perfect for privacy-focused applications like chatbots, social media sentiment analysis, mental health monitoring, and contextual AI in resource-constrained environments such as wearables, smart home devices, and mobile apps.
-- **Model Name**: NeuroFeel
-- **Size**: ~25MB (quantized)
-- **Parameters**: ~7M
-- **Architecture**: Lightweight NeuroBERT (4 layers, hidden size 256, 8 attention heads)
-- **Description**: Compact 4-layer, 256-hidden model for emotion detection
-- **License**: Apache-2.0 — free for commercial and personal use
-## Key Features
-- ⚡ **Ultra-Compact Design**: ~25MB footprint for devices with limited storage.
-- 🧠 **Rich Emotion Detection**: Classifies 13 emotions with expressive emoji mappings.
-- 📶 **Offline Capability**: Fully functional without internet connectivity.
-- ⚙️ **Real-Time Inference**: Optimized for CPUs, mobile NPUs, and microcontrollers.
-- 🌍 **Versatile Applications**: Supports emotion detection, sentiment analysis, and tone analysis for short texts.
-- 🔒 **Privacy-First**: On-device processing ensures user data stays local.
-## Supported Emotions
-NeuroFeel classifies text into one of 13 emotional categories, each paired with an emoji for enhanced interpretability:
-| Emotion    | Emoji |
-|------------|-------|
-| Sadness    | 😢    |
-| Anger      | 😠    |
-| Love       | ❤️    |
-| Surprise   | 😲    |
-| Fear       | 😱    |
-| Happiness  | 😄    |
-| Neutral    | 😐    |
-| Disgust    | 🤢    |
-| Shame      | 🙈    |
-| Guilt      | 😔    |
-| Confusion  | 😕    |
-| Desire     | 🔥    |
-| Sarcasm    | 😏    |
-## Model Architecture
-NeuroFeel is derived from **NeuroBERT**, a lightweight transformer model optimized for edge computing. Key architectural details:
-- **Layers**: 4 transformer layers for reduced computational complexity.
-- **Hidden Size**: 256, balancing expressiveness and efficiency.
-- **Attention Heads**: 8, enabling robust contextual understanding.
-- **Parameters**: ~7M, significantly fewer than standard BERT models.
-- **Quantization**: INT8 quantization for minimal memory usage and fast inference.
-- **Vocabulary Size**: 30,522 tokens, compatible with NeuroBERT’s tokenizer.
-- **Max Sequence Length**: 64 tokens, ideal for short-text inputs like social media posts or chatbot messages.
-This architecture ensures NeuroFeel delivers high accuracy for emotion detection while maintaining compatibility with resource-constrained devices like Raspberry Pi, ESP32, or mobile NPUs.
-## Installation
-Install the required dependencies:
-```bash
-pip install transformers torch
-```
-Ensure your environment supports Python 3.6+ and has ~25MB of storage for model weights.
-## Download Instructions
-1. **Via Hugging Face**:
-   - Access the model at [boltuix/NeuroFeel](https://huggingface.co/boltuix/NeuroFeel).
-   - Download the model files (~25MB) or clone the repository:
-     ```bash
-     git clone https://huggingface.co/boltuix/NeuroFeel
-     ```
-2. **Via Transformers Library**:
-   - Load the model directly in Python:
-     ```python
-     from transformers import AutoModelForSequenceClassification, AutoTokenizer
-     model = AutoModelForSequenceClassification.from_pretrained("boltuix/NeuroFeel")
-     tokenizer = AutoTokenizer.from_pretrained("boltuix/NeuroFeel")
-     ```
-3. **Manual Download**:
-   - Download quantized model weights (Safetensors format) from the Hugging Face model hub.
-   - Extract and integrate into your edge/IoT application.
-## Quickstart: Emotion Detection
-### Basic Inference Example
-Classify emotions in short text inputs using the Hugging Face pipeline:
-```python
-from transformers import pipeline
-# Load the fine-tuned NeuroFeel model
-sentiment_analysis = pipeline("text-classification", model="boltuix/NeuroFeel")
-# Analyze emotion
-result = sentiment_analysis("i love you")
-print(result)
-```
-**Output**:
-```python
-[{'label': 'Love', 'score': 0.8563215732574463}]
-```
-This indicates the emotion is **Love ❤️** with **85.63%** confidence.
-### Extended Example with Emoji Mapping
-Enhance the output with human-readable emotions and emojis:
-```python
-from transformers import pipeline
-# Load the fine-tuned NeuroFeel model
-sentiment_analysis = pipeline("text-classification", model="boltuix/NeuroFeel")
-# Define label-to-emoji mapping
-label_to_emoji = {
-    "Sadness": "😢",
-    "Anger": "😠",
-    "Love": "❤️",
-    "Surprise": "😲",
-    "Fear": "😱",
-    "Happiness": "😄",
-    "Neutral": "😐",
-    "Disgust": "🤢",
-    "Shame": "🙈",
-    "Guilt": "😔",
-    "Confusion": "😕",
-    "Desire": "🔥",
-    "Sarcasm": "😏"
-}
-# Input text
-text = "i love you"
-# Analyze emotion
-result = sentiment_analysis(text)[0]
-label = result["label"].capitalize()
-emoji = label_to_emoji.get(label, "❓")
-# Output
-print(f"Text: {text}")
-print(f"Predicted Emotion: {label} {emoji}")
-print(f"Confidence: {result['score']:.2%}")
-```
-**Output**:
-```plaintext
-Text: i love you
-Predicted Emotion: Love ❤️
-Confidence: 85.63%
-```
-*Note*: Fine-tune the model for domain-specific tasks to boost accuracy.
-## Evaluation
-NeuroFeel was evaluated on an emotion classification task using 13 short-text samples relevant to IoT, social media, and mental health contexts. The model predicts one of 13 emotion labels, with success defined as the correct label being predicted.
-### Test Sentences
-| Sentence | Expected Emotion |
-|----------|------------------|
-| I love you so much! | Love |
-| This is absolutely disgusting! | Disgust |
-| I'm so happy with my new phone! | Happiness |
-| Why does this always break? | Anger |
-| I feel so alone right now. | Sadness |
-| What just happened?! | Surprise |
-| I'm terrified of this update failing. | Fear |
-| Meh, it's just okay. | Neutral |
-| I shouldn't have said that. | Shame |
-| I feel bad for forgetting. | Guilt |
-| Wait, what does this mean? | Confusion |
-| I really want that new gadget! | Desire |
-| Oh sure, like that's gonna work. | Sarcasm |
-### Evaluation Code
-```python
-from transformers import pipeline
-# Load the fine-tuned NeuroFeel model
-sentiment_analysis = pipeline("text-classification", model="boltuix/NeuroFeel")
-# Define label-to-emoji mapping
-label_to_emoji = {
-    "Sadness": "😢",
-    "Anger": "😠",
-    "Love": "❤️",
-    "Surprise": "😲",
-    "Fear": "😱",
-    "Happiness": "😄",
-    "Neutral": "😐",
-    "Disgust": "🤢",
-    "Shame": "🙈",
-    "Guilt": "😔",
-    "Confusion": "😕",
-    "Desire": "🔥",
-    "Sarcasm": "😏"
-}
-# Test data
-tests = [
-    ("I love you so much!", "Love"),
-    ("This is absolutely disgusting!", "Disgust"),
-    ("I'm so happy with my new phone!", "Happiness"),
-    ("Why does this always break?", "Anger"),
-    ("I feel so alone right now.", "Sadness"),
-    ("What just happened?!", "Surprise"),
-    ("I'm terrified of this update failing.", "Fear"),
-    ("Meh, it's just okay.", "Neutral"),
-    ("I shouldn't have said that.", "Shame"),
-    ("I feel bad for forgetting.", "Guilt"),
-    ("Wait, what does this mean?", "Confusion"),
-    ("I really want that new gadget!", "Desire"),
-    ("Oh sure, like that's gonna work.", "Sarcasm")
-]
-results = []
-# Run tests
-for text, expected in tests:
-    result = sentiment_analysis(text)[0]
-    predicted = result["label"].capitalize()
-    confidence = result["score"]
-    emoji = label_to_emoji.get(predicted, "❓")
-    results.append({
-        "sentence": text,
-        "expected": expected,
-        "predicted": predicted,
-        "confidence": confidence,
-        "emoji": emoji,
-        "pass": predicted == expected
-    })
-# Print results
-for r in results:
-    status = "✅ PASS" if r["pass"] else "❌ FAIL"
-    print(f"\n🔍 {r['sentence']}")
-    print(f"🎯 Expected: {r['expected']}")
-    print(f"🔝 Predicted: {r['predicted']} {r['emoji']} (Confidence: {r['confidence']:.4f})")
-    print(status)
-# Summary
-pass_count = sum(r["pass"] for r in results)
-print(f"\n🎯 Total Passed: {pass_count}/{len(tests)}")
-```
-### Sample Results (Hypothetical)
-- **Sentence**: I love you so much!
-  **Expected**: Love
-  **Predicted**: Love ❤️ (Confidence: 0.8563)
-  **Result**: ✅ PASS
-- **Sentence**: I feel so alone right now.
-  **Expected**: Sadness
-  **Predicted**: Sadness 😢 (Confidence: 0.8021)
-  **Result**: ✅ PASS
-- **Total Passed**: ~12/13 (varies with fine-tuning).
-NeuroFeel excels in classifying a wide range of emotions in short texts, particularly in IoT, social media, and mental health contexts. Fine-tuning enhances performance on subtle emotions like Sarcasm or Shame.
-### Evaluation Metrics
-| Metric     | Value (Approx.)       |
-|------------|-----------------------|
-| ✅ Accuracy | ~92–96% on 13-class emotion tasks |
-| 🎯 F1 Score | Balanced for multi-class classification |
-| ⚡ Latency  | <40ms on Raspberry Pi 4 |
-| 📏 Recall   | Competitive for lightweight models |
-*Note*: Metrics depend on hardware and fine-tuning. Test on your target device for precise results.
-## Use Cases
-NeuroFeel is tailored for **edge and IoT scenarios** requiring real-time emotion detection for short texts. Key applications include:
-- **Chatbot Emotion Understanding**: Detect user emotions, e.g., “I love you” (predicts “Love ❤️”) to tailor responses.
-- **Social Media Sentiment Tagging**: Analyze posts, e.g., “This is disgusting!” (predicts “Disgust 🤢”) for moderation or trend analysis.
-- **Mental Health Context Detection**: Monitor mood, e.g., “I feel so alone” (predicts “Sadness 😢”) for wellness apps or crisis alerts.
-- **Smart Replies and Reactions**: Suggest replies, e.g., “I’m so happy!” (predicts “Happiness 😄”) for positive emojis or animations.
-- **Emotional Tone Analysis**: Adjust IoT settings, e.g., “I’m terrified!” (predicts “Fear 😱”) to dim lights or play calming music.
-- **Voice Assistants**: Local emotion-aware parsing, e.g., “Why does it break?” (predicts “Anger 😠”) to prioritize fixes.
-- **Toy Robotics**: Emotion-driven interactions, e.g., “I really want that!” (predicts “Desire 🔥”) for engaging animations.
-- **Fitness Trackers**: Analyze feedback, e.g., “Wait, what?” (predicts “Confusion 😕”) to clarify instructions.
-- **Wearable Devices**: Real-time mood tracking, e.g., “I’m stressed out” (predicts “Fear 😱”) to suggest breathing exercises.
-- **Smart Home Automation**: Contextual responses, e.g., “I’m so tired” (predicts “Sadness 😢”) to adjust lighting or music.
-- **Customer Support Bots**: Detect frustration, e.g., “This is ridiculous!” (predicts “Anger 😠”) to escalate to human agents.
-- **Educational Tools**: Analyze student feedback, e.g., “I don’t get it” (predicts “Confusion 😕”) to offer tailored explanations.
-## Hardware Requirements
-- **Processors**: CPUs, mobile NPUs, or microcontrollers (e.g., ESP32-S3, Raspberry Pi 4, Snapdragon NPUs)
-- **Storage**: ~25MB for model weights (quantized, Safetensors format)
-- **Memory**: ~70MB RAM for inference
-- **Environment**: Offline or low-connectivity settings
-Quantization ensures efficient memory usage, making NeuroFeel ideal for resource-constrained devices.
-## Training Details
-NeuroFeel was fine-tuned on a **custom emotion dataset** augmented with **ChatGPT-generated data** to enhance diversity and robustness. Key training details:
-- **Dataset**:
-  - **Custom Emotion Dataset**: ~10,000 labeled short-text samples covering 13 emotions (e.g., Happiness, Sadness, Love). Sourced from social media posts, IoT user feedback, and chatbot interactions.
-  - **ChatGPT-Augmented Data**: Synthetic samples generated to balance underrepresented emotions (e.g., Sarcasm, Shame) and improve generalization.
-  - **Preprocessing**: Lowercasing, emoji removal, and tokenization with NeuroBERT’s tokenizer (max length: 64 tokens).
-- **Training Process**:
-  - **Base Model**: NeuroBERT, pre-trained on general English text for masked language modeling.
-  - **Fine-Tuning**: Supervised training for 13-class emotion classification using cross-entropy loss.
-  - **Hyperparameters**:
-    - Epochs: 5
-    - Batch Size: 16
-    - Learning Rate: 2e-5
-    - Optimizer: AdamW
-    - Scheduler: Linear warmup (10% of steps)
-  - **Hardware**: Fine-tuned on a single NVIDIA A100 GPU, but inference optimized for edge devices.
-  - **Quantization**: Post-training INT8 quantization to reduce model size to ~25MB and improve inference speed.
-- **Data Augmentation**:
-  - Synonym replacement and back-translation to enhance robustness.
-  - Synthetic negative sampling to improve detection of nuanced emotions like Guilt or Confusion.
-- **Validation**:
-  - Split: 80% train, 10% validation, 10% test.
-  - Validation F1 score: ~0.93 across 13 classes.
-Fine-tuning on domain-specific data is recommended to optimize performance for specific use cases (e.g., mental health apps or smart home devices).
-## Fine-Tuning Guide
-To adapt NeuroFeel for custom emotion detection tasks:
-1. **Prepare Dataset**: Collect labeled data with 13 emotion categories.
-2. **Fine-Tune with Hugging Face**:
-   ```python
-    # !pip install transformers datasets torch --upgrade
-    import torch
-    from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
-    from datasets import Dataset
-    import pandas as pd
-    # 1. Prepare the sample emotion dataset
-    data = {
-        "text": [
-            "I love you so much!",
-            "This is absolutely disgusting!",
-            "I'm so happy with my new phone!",
-            "Why does this always break?",
-            "I feel so alone right now."
-        ],
-        "label": [2, 7, 5, 1, 0]  # Emotions: 0 to 12
-    }
-    df = pd.DataFrame(data)
-    dataset = Dataset.from_pandas(df)
-    # 2. Load tokenizer and model
-    model_name = "boltuix/NeuroFeel"
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=13)
-    # 3. Tokenize the dataset
-    def tokenize_function(examples):
-        return tokenizer(examples["text"], padding="max_length", truncation=True, max_length=64)
-    tokenized_dataset = dataset.map(tokenize_function, batched=True)
-    # 4. Manually convert all fields to PyTorch tensors
-    def to_torch_format(example):
-        return {
-            "input_ids": torch.tensor(example["input_ids"]),
-            "attention_mask": torch.tensor(example["attention_mask"]),
-            "label": torch.tensor(example["label"])
-        }
-    tokenized_dataset = tokenized_dataset.map(to_torch_format)
-    # 5. Define training arguments
-    training_args = TrainingArguments(
-        output_dir="./neurofeel_results",
-        num_train_epochs=5,
-        per_device_train_batch_size=16,
-        logging_dir="./neurofeel_logs",
-        logging_steps=10,
-        save_steps=100,
-        eval_strategy="no",
-        learning_rate=2e-5,
-        report_to="none"
-    )
-    # 6. Initialize Trainer
-    trainer = Trainer(
-        model=model,
-        args=training_args,
-        train_dataset=tokenized_dataset,
-    )
-    # 7. Fine-tune the model
-    trainer.train()
-    # 8. Save the fine-tuned model
-    model.save_pretrained("./fine_tuned_neurofeel")
-    tokenizer.save_pretrained("./fine_tuned_neurofeel")
-    # 9. Example inference
-    text = "I'm thrilled with the update!"
-    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=64)
-    model.eval()
-    with torch.no_grad():
-        outputs = model(**inputs)
-        logits = outputs.logits
-        predicted_class = torch.argmax(logits, dim=1).item()
-    labels = ["Sadness", "Anger", "Love", "Surprise", "Fear", "Happiness", "Neutral", "Disgust", "Shame", "Guilt", "Confusion", "Desire", "Sarcasm"]
-    print(f"Predicted emotion for '{text}': {labels[predicted_class]}")
-   ```
-3. **Deploy**: Export to ONNX or TensorFlow Lite for edge devices.
-## Comparison to Other Models
-| Model           | Parameters | Size   | Edge/IoT Focus | Tasks Supported                     |
-|-----------------|------------|--------|----------------|-------------------------------------|
-| NeuroFeel       | ~7M        | ~25MB  | High           | Emotion Detection, Classification   |
-| NeuroBERT       | ~7M        | ~30MB  | High           | MLM, NER, Classification            |
-| BERT-Lite       | ~2M        | ~10MB  | High           | MLM, NER, Classification            |
-| DistilBERT      | ~66M       | ~200MB | Moderate       | MLM, NER, Classification, Sentiment |
-NeuroFeel is specialized for 13-class emotion detection, offering superior performance for short-text sentiment analysis on edge devices compared to general-purpose models like NeuroBERT, while being far more efficient than DistilBERT.
-## Tags
-`#NeuroFeel` `#edge-nlp` `#emotion-detection` `#on-device-ai` `#offline-nlp`
-`#mobile-ai` `#sentiment-analysis` `#text-classification` `#emojis` `#emotions`
-`#lightweight-transformers` `#embedded-nlp` `#smart-device-ai` `#low-latency-models`
-`#ai-for-iot` `#efficient-neurobert` `#nlp2025` `#context-aware` `#edge-ml`
-`#smart-home-ai` `#emotion-aware` `#voice-ai` `#eco-ai` `#chatbot` `#social-media`
-`#mental-health` `#short-text` `#smart-replies` `#tone-analysis` `#wearable-ai`
-## License
-**Apache-2.0 License**: Free to use, modify, and distribute for personal and commercial purposes. See [LICENSE](https://www.apache.org/licenses/LICENSE-2.0) for details.
-## Credits
-- **Base Model**: [neurobert](https://huggingface.co/neurobert)
-- **Optimized By**: Boltuix, fine-tuned and quantized for edge AI applications
-- **Library**: Hugging Face `transformers` team for model hosting and tools
-## Support & Community
-For issues, questions, or contributions:
-- Visit the [Hugging Face model page](https://huggingface.co/boltuix/NeuroFeel)
-- Open an issue on the [repository](https://huggingface.co/boltuix/NeuroFeel)
-- Join discussions on Hugging Face or contribute via pull requests
-- Check the [Transformers documentation](https://huggingface.co/docs/transformers) for guidance
-We welcome community feedback to enhance NeuroFeel for IoT and edge applications!
-## Contact
-- 📬 Email: [boltuix@gmail.com](mailto:boltuix@gmail.com)

+{
+  "architectures": [
+    "BertForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 256,
+  "id2label": {
+    "0": "happiness",
+    "1": "disgust",
+    "2": "guilt",
+    "3": "love",
+    "4": "anger",
+    "5": "fear",
+    "6": "surprise",
+    "7": "confusion",
+    "8": "desire",
+    "9": "neutral",
+    "10": "sadness",
+    "11": "sarcasm",
+    "12": "shame"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 1024,
+  "label2id": {
+    "happiness": 0,
+    "disgust": 1,
+    "guilt": 2,
+    "love": 3,
+    "anger": 4,
+    "fear": 5,
+    "surprise": 6,
+    "confusion": 7,
+    "desire": 8,
+    "neutral": 9,
+    "sadness": 10,
+    "sarcasm": 11,
+    "shame": 12
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 4,
+  "num_hidden_layers": 8,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "problem_type": "single_label_classification",
+  "torch_dtype": "float32",
+  "transformers_version": "4.51.3",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}