Upload folder using huggingface_hub

README.md

@@ -0,0 +1,142 @@
+---
+language: en
+tags:
+- emotion-classification
+- multilabel-classification
+- text-classification
+- pytorch
+- transformers
+datasets:
+- emotion
+metrics:
+- f1
+- accuracy
+library_name: transformers
+pipeline_tag: text-classification
+---
+
+# Multilabel Emotion Classification Model - FirstTimeUp
+
+This model is fine-tuned for multilabel emotion classification using distilbert-base-uncased as the base model.
+
+## Model Details
+- **Model Name**: FirstTimeUp
+- **Base Model**: distilbert-base-uncased
+- **Task**: Multilabel Emotion Classification
+- **Emotions**: amusement, anger, annoyance, caring, confusion, disappointment, disgust, embarrassment, excitement, fear, gratitude, joy, love, sadness
+- **Total Parameters**: 66,373,646
+- **Trainable Parameters**: 66,373,646
+
+## Quick Start
+
+### Installation
+```bash
+pip install torch transformers huggingface_hub
+```
+
+### Usage
+
+```python
+# Download the repository
+from huggingface_hub import snapshot_download
+import sys
+import os
+
+# Download model files
+model_path = snapshot_download(repo_id="EnJiZ/FirstTimeUp")
+
+# Add to path and import
+sys.path.append(model_path)
+from model import predict_emotions
+
+# Predict emotions
+text = "I am so happy and excited!"
+emotions = predict_emotions(text, model_path)
+print(emotions)
+```
+
+### Advanced Usage
+
+```python
+import torch
+from transformers import AutoTokenizer
+import sys
+sys.path.append(model_path)
+from model import MultiLabelEmotionClassifier, load_model
+
+# Load model manually
+model, config = load_model(model_path)
+tokenizer = AutoTokenizer.from_pretrained(model_path)
+
+# Custom prediction with different threshold
+def custom_predict(text, threshold=0.3):
+    encoding = tokenizer(
+        text,
+        truncation=True,
+        padding='max_length',
+        max_length=128,
+        return_tensors='pt'
+    )
+    
+    model.eval()
+    with torch.no_grad():
+        logits = model(encoding['input_ids'], encoding['attention_mask'])
+        probabilities = torch.sigmoid(logits)
+        predictions = (probabilities > threshold).int()
+    
+    emotion_labels = ['amusement', 'anger', 'annoyance', 'caring', 'confusion', 'disappointment', 'disgust', 'embarrassment', 'excitement', 'fear', 'gratitude', 'joy', 'love', 'sadness']
+    result = {emotion: {
+        'predicted': bool(pred), 
+        'probability': float(prob)
+    } for emotion, pred, prob in zip(emotion_labels, predictions[0], probabilities[0])}
+    return result
+
+# Example with probabilities
+result = custom_predict("I feel great today!", threshold=0.3)
+print(result)
+```
+
+## Model Architecture
+- **Base**: distilbert-base-uncased
+- **Classification Head**: Linear layer with dropout (dropout_rate=0.3)
+- **Loss Function**: BCEWithLogitsLoss
+- **Activation**: Sigmoid (for multilabel classification)
+
+## Training Details
+- **Epochs**: 3
+- **Batch Size**: 32
+- **Learning Rate**: 2e-05
+- **Max Sequence Length**: 128
+- **Optimizer**: AdamW with weight decay (0.01)
+- **Scheduler**: Linear warmup + decay
+
+## Files in this Repository
+- `config.json`: Model configuration
+- `pytorch_model.bin`: Model weights
+- `tokenizer.json`, `tokenizer_config.json`: Tokenizer files
+- `model.py`: Custom model class and utility functions
+- `README.md`: This file
+
+## Performance
+- **Task**: Multilabel Emotion Classification
+- **Metrics**: F1-Score (Micro & Macro), Accuracy
+- **Validation Strategy**: 80/20 train-validation split
+
+## Supported Emotions
+amusement, anger, annoyance, caring, confusion, disappointment, disgust, embarrassment, excitement, fear, gratitude, joy, love, sadness
+
+## License
+This model is released under the Apache 2.0 license.
+
+## Citation
+```bibtex
+@misc{firsttimeup2024,
+  title={FirstTimeUp: Multilabel Emotion Classification Model},
+  author={EnJiZ},
+  year={2024},
+  url={https://huggingface.co/EnJiZ/FirstTimeUp}
+}
+```
+
+## Contact
+For questions or issues, please open an issue in the repository.

config.json

@@ -0,0 +1,28 @@
+{
+  "architectures": [
+    "MultiLabelEmotionClassifier"
+  ],
+  "model_type": "custom_multilabel_emotion",
+  "base_model": "distilbert-base-uncased",
+  "num_labels": 14,
+  "emotion_labels": [
+    "amusement",
+    "anger",
+    "annoyance",
+    "caring",
+    "confusion",
+    "disappointment",
+    "disgust",
+    "embarrassment",
+    "excitement",
+    "fear",
+    "gratitude",
+    "joy",
+    "love",
+    "sadness"
+  ],
+  "max_position_embeddings": 128,
+  "dropout_rate": 0.3,
+  "torch_dtype": "float32",
+  "transformers_version": "4.21.0"
+}

model.py

@@ -0,0 +1,93 @@
+
+import torch
+import torch.nn as nn
+from transformers import AutoTokenizer, AutoModel, AutoConfig
+
+class MultiLabelEmotionClassifier(nn.Module):
+    def __init__(self, model_name, num_labels, dropout_rate=0.3):
+        super().__init__()
+        
+        # Load pre-trained model
+        self.config = AutoConfig.from_pretrained(model_name)
+        self.transformer = AutoModel.from_pretrained(model_name)
+        
+        # Classifier head
+        self.dropout = nn.Dropout(dropout_rate)
+        self.classifier = nn.Linear(self.config.hidden_size, num_labels)
+        
+        # Initialize weights
+        self._init_weights()
+    
+    def _init_weights(self):
+        """Initialize classifier weights"""
+        nn.init.normal_(self.classifier.weight, std=0.02)
+        nn.init.zeros_(self.classifier.bias)
+    
+    def forward(self, input_ids, attention_mask):
+        # Get transformer outputs
+        outputs = self.transformer(
+            input_ids=input_ids,
+            attention_mask=attention_mask
+        )
+        
+        # Use [CLS] token representation
+        pooled_output = outputs.last_hidden_state[:, 0]  # [CLS] token
+        
+        # Apply dropout and classifier
+        pooled_output = self.dropout(pooled_output)
+        logits = self.classifier(pooled_output)
+        
+        return logits
+
+def load_model(model_path="."):
+    """Load the custom model"""
+    import json
+    import os
+    
+    # Load config
+    with open(os.path.join(model_path, "config.json"), "r") as f:
+        config = json.load(f)
+    
+    # Initialize model
+    model = MultiLabelEmotionClassifier(
+        model_name=config["base_model"],
+        num_labels=config["num_labels"],
+        dropout_rate=config["dropout_rate"]
+    )
+    
+    # Load weights
+    checkpoint = torch.load(os.path.join(model_path, "pytorch_model.bin"), map_location="cpu")
+    model.load_state_dict(checkpoint["model_state_dict"])
+    
+    return model, config
+
+def predict_emotions(text, model_path=".", threshold=0.5):
+    """Predict emotions for given text"""
+    # Load model and tokenizer
+    model, config = load_model(model_path)
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+    
+    # Tokenize input
+    encoding = tokenizer(
+        text,
+        truncation=True,
+        padding='max_length',
+        max_length=config["max_position_embeddings"],
+        return_tensors='pt'
+    )
+    
+    # Predict
+    model.eval()
+    with torch.no_grad():
+        logits = model(encoding['input_ids'], encoding['attention_mask'])
+        probabilities = torch.sigmoid(logits)
+        predictions = (probabilities > threshold).int()
+    
+    # Format results
+    emotion_labels = config["emotion_labels"]
+    result = {emotion: bool(pred) for emotion, pred in zip(emotion_labels, predictions[0])}
+    return result
+
+# Example usage:
+# emotions = predict_emotions("I am so happy and excited!")
+# print(emotions)

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0541799e9cfe7ba672cff94a74980d64db9081560c1f9842311038ad753fc5ba
+size 265462608

pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d68b6f0217225e55b1a08e8d458499abd02a16a2ffeb12ba90269e41c78c126
+size 265536674

special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

tokenizer_config.json

@@ -0,0 +1,56 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": false,
+  "cls_token": "[CLS]",
+  "do_lower_case": true,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "DistilBertTokenizer",
+  "unk_token": "[UNK]"
+}