# RoBERTa-Base Model for Emotion Classification

This repository hosts a fine-tuned version of the RoBERTa model for emotion classification tasks. The model has been trained to accurately classify text into six emotion categories, making it suitable for sentiment analysis and emotional content understanding.

---

## Model Details

- **Model Name:** RoBERTa-Base for Emotion Classification  
- **Model Architecture:** RoBERTa Base  
- **Task:** Emotion Classification  
- **Dataset:** Hugging Face Emotion Dataset  
- **Quantization:** Float16 version available  
- **Fine-tuning Framework:** Hugging Face Transformers

---

## Usage

### Installation

```
pip install transformers torch
```

### Loading the Model

```
from transformers import RobertaTokenizer, RobertaForSequenceClassification
import torch
import re

# Load model and tokenizer
model_path = "emotion-model"  # or "quantized-emotion-model" for the quantized version
model = RobertaForSequenceClassification.from_pretrained(model_path)
tokenizer = RobertaTokenizer.from_pretrained(model_path)

# Set device
device = 'cuda' if torch.cuda.is_available() else 'cpu'
model = model.to(device)
```

### Prediction Function

```
def predict_emotions(texts, model, tokenizer, device='cpu'):
    """
    Predicts emotion labels for input text(s) using a fine-tuned transformer model.

    Args:
        texts (str or List[str]): A single string or list of strings to classify.
        model: Trained transformer model.
        tokenizer: Corresponding tokenizer.
        device (str): 'cpu' or 'cuda'. Default is 'cpu'.

    Returns:
        List[str]: List of predicted emotion labels.
    """
    # Ensure model is on correct device
    model.to(device)

    # If a single string is passed, convert to list
    if isinstance(texts, str):
        texts = [texts]

    # Preprocess: simple text cleaning
    def preprocess(text):
        text = text.lower()
        text = re.sub(r"http\S+|www\S+|https\S+", '', text)
        text = re.sub(r'\@\w+|\#', '', text)
        text = re.sub(r"[^a-zA-Z0-9\s.,!?']", '', text)
        text = re.sub(r'\s+', ' ', text).strip()
        return text

    cleaned_texts = [preprocess(t) for t in texts]

    # Tokenize
    inputs = tokenizer(cleaned_texts, padding=True, truncation=True, return_tensors="pt").to(device)

    # Inference
    model.eval()
    with torch.no_grad():
        outputs = model(**inputs)
        preds = torch.argmax(outputs.logits, dim=1).tolist()

    # Emotion dataset label map
    label_map = {
        0: "sadness",
        1: "joy",
        2: "love",
        3: "anger",
        4: "fear",
        5: "surprise"
    }

    return [label_map[p] for p in preds]
```

### Example Usage

```
# Example texts
sample_texts = [
    "I'm so happy about the new job opportunity!",
    "I can't believe they cancelled my favorite show. This is terrible.",
    "The sunset over the mountains took my breath away. It was magnificent!"
]

# Run predictions
results = predict_emotions(sample_texts, model, tokenizer, device)

# Show results
for text, emotion in zip(sample_texts, results):
    print(f"Text: {text}\nPredicted Emotion: {emotion}\n")
```

---

## Performance Metrics

- **Accuracy:** 0.94
- **F1 Score:** 0.939736  
- **Precision:** 0.941654  
- **Recall:** 0.94

---

## Fine-Tuning Details

### Dataset

The model was fine-tuned on the Hugging Face Emotion dataset which contains text labeled with six emotion categories:
- sadness
- joy
- love
- anger
- fear
- surprise

### Training Configuration

- **Epochs:** 3  
- **Batch Size:** 16  
- **Learning Rate:** 2e-5  
- **Max Length:** 128 tokens   
- **Evaluation Strategy:** epoch
- **Weight Decay:** 0.01
- **Optimizer:** AdamW

### Quantization

A quantized version of the model is available using PyTorch's float16 format to reduce model size and improve inference efficiency.

---

## Repository Structure

```
.
├── emotion-model/               # Full-precision model
│   ├── config.json           
│   ├── model.safetensors     
│   ├── tokenizer_config.json    
│   ├── special_tokens_map.json
│   ├── vocab.json
│   └── merges.txt
├── quantized-emotion-model/     # Quantized model (float16)
│   ├── config.json           
│   ├── model.safetensors     
│   ├── tokenizer_config.json    
│   ├── special_tokens_map.json
│   ├── vocab.json
│   └── merges.txt
└── README.md                    # Model documentation
```

---

## Limitations

- The model may not generalize well to domains outside the fine-tuning dataset.
- Emotion detection can be subjective and context-dependent.
- The quantized version may show minor accuracy degradation compared to the full-precision model.

---

## Contributing

Contributions are welcome! Feel free to open an issue or PR for improvements, fixes, or feature extensions.