README.md

# 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.