Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,3 @@
+*.xlsx
+.gradio/
+emotion_model/

README.md

@@ -1,12 +1,97 @@
----
-title: Twitter Emotion And Target Prediction
-emoji: 🌖
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.1.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Twitter_Emotion_and_Target_Prediction
+app_file: run_gradio_v3.py
+sdk: gradio
+sdk_version: 5.1.0
+---
+# Tweet Emotion and Target Prediction
+
+This project implements a machine learning pipeline for predicting the emotion and target of tweets. It includes model training, data preprocessing, data augmentation, inference, and a Gradio-based web interface for easy interaction.
+
+## Project Structure
+
+- `train_model_v2.py`: Trains the emotion classification model using a fine-tuned RoBERTa model.
+- `inference.py`: Implements the prediction pipeline using the trained models.
+- `run_gradio_v3.py`: Creates a Gradio web interface for interactive predictions.
+
+## Setup and Installation
+
+1. Clone this repository:
+   ```bash
+   git clone https://github.com/yourusername/tweet-emotion-target-prediction.git
+   cd tweet-emotion-target-prediction
+   ```
+
+2. Install the required packages:
+   ```bash
+   pip install pandas numpy scikit-learn transformers datasets torch gradio joblib imbalanced-learn xgboost
+   ```
+
+3. Download the dataset file `NLP Engineer Assignment Dataset (1) (1) (1) (1).xlsx` and place it in the project root directory.
+
+## Training the Models
+
+### Emotion Classification Model
+
+Run the following command to train the emotion classification model:
+
+```bash
+python train_model_v2.py
+```
+
+This script will:
+- **Preprocess the data**: Apply basic cleaning techniques and tokenization.
+- **Data augmentation**: Use oversampling techniques to handle class imbalance, ensuring the model learns well from underrepresented emotions.
+- **Fine-tune a RoBERTa model**: Use the `cardiffnlp/twitter-roberta-base-sentiment` for transfer learning, fine-tuning it on the tweet emotion dataset.
+- **Save artifacts**: The fine-tuned RoBERTa model and tokenizer will be saved for inference.
+
+## Data Augmentation and Handling Imbalance
+
+- **Random Word Drop**: A function that removes a random subset of words from the input text.
+   - This operation is probabilistically applied to reduce the highest class' dominance and augment the lower classes.
+
+- **Synonym Replacement**: A function leveraging the WordNet corpus to replace random words with their synonyms, generating alternative versions of the input text.
+   - Synonym replacement is more heavily applied to the minority classes to balance the dataset.
+
+- **Augmentation Strategy**: 
+   - The largest class undergoes minimal augmentation, while the smaller classes receive extra augmentation (both word drop and synonym replacement). The smallest class gets further augmentation by combining both techniques (word drop after synonym replacement).
+
+## Running Inference
+
+To process the test data and generate predictions, run:
+
+```bash
+python inference.py
+```
+
+This script will:
+- **Load the trained models**: Load both the target classification and emotion classification models.
+- **Process the test data**: The test dataset is preprocessed similarly to the training dataset.
+- **Generate predictions**: Predictions for both target and emotion are produced for each tweet.
+- **Save the results**: The predictions are saved to `test_results.csv` for analysis.
+
+## Launching the Gradio Interface
+
+To launch the Gradio web interface for interactive predictions, run:
+
+```bash
+python run_gradio_v2.py
+```
+
+This will start a local server and provide a URL to access the web interface.
+
+## Model Details
+
+### Emotion Classification Model
+- **Model Architecture**: Fine-tuned `RoBERTa` model ("cardiffnlp/twitter-roberta-base-sentiment").
+- **Data Augmentation**: Uses SMOTE and other oversampling methods to handle imbalanced class distribution.
+- **Transfer Learning**: Leverages pre-trained `RoBERTa` for sentiment analysis, fine-tuning it on emotion-labeled tweet data.
+
+## Gradio Interface
+
+The Gradio interface provides:
+- **Input field** for tweet text.
+- **Text analysis**: Displays word count, character count, hashtags, mentions, URLs, emojis in the tweet.
+- **Predicted target and emotion**: Real-time display of predictions based on user input.
+- **Emotion probabilities**: Displays the probability distribution of the predicted emotions.
+- **Summary table of predictions**: A table summarizing the tweet text, predicted target, emotion, and associated probabilities.

inference.py

@@ -0,0 +1,96 @@
+
+import os
+import numpy as np
+from transformers import AutoTokenizer, AutoModel, AutoModelForSequenceClassification
+import pandas as pd
+import torch
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Check if CUDA is available and set the device
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+print(f"Using device: {device}")
+
+
+# Load the model and tokenizer
+model_path = "./emotion_model"
+hub_path = "dasdristanta13/twitter-emotion-model"
+if os.path.isdir(model_path):
+    emotion_model = AutoModelForSequenceClassification.from_pretrained(model_path)
+    emotion_tokenizer = AutoTokenizer.from_pretrained(model_path)
+else:
+    emotion_model = AutoModelForSequenceClassification.from_pretrained(hub_path)
+    emotion_tokenizer = AutoTokenizer.from_pretrained(hub_path)
+
+# Move the model to the appropriate device
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+emotion_model = emotion_model.to(device)
+
+# Load a pre-trained sentence transformer model for semantic similarity
+semantic_model = AutoModel.from_pretrained('sentence-transformers/all-MiniLM-L6-v2')
+semantic_tokenizer = AutoTokenizer.from_pretrained('sentence-transformers/all-MiniLM-L6-v2')
+semantic_model = semantic_model.to(device)
+
+target_mapping = {
+    'Google': 'Google',
+    'Apple': 'Apple',
+    'iPad': 'Apple',
+    'iPhone': 'Apple',
+    'Other Google product or service': 'Google',
+    'Other Apple product or service': 'Apple',
+    'Android': 'Google',
+    'Android App': 'Google',
+    'iPad or iPhone App': 'Apple',
+}
+
+def get_embedding(text):
+    inputs = semantic_tokenizer(text, return_tensors='pt', padding=True, truncation=True, max_length=128)
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+    with torch.no_grad():
+        outputs = semantic_model(**inputs)
+    return outputs.last_hidden_state.mean(dim=1).cpu().numpy()
+
+def predict_target(text):
+    text_embedding = get_embedding(text)
+    target_embeddings = {target: get_embedding(target) for target in target_mapping.keys()}
+
+    similarities = {target: cosine_similarity(text_embedding, emb)[0][0] for target, emb in target_embeddings.items()}
+    predicted_target = max(similarities, key=similarities.get)
+
+    return predicted_target
+
+def predict_emotion(text, target):
+    combined_input = f"{text} [SEP] {target}"
+    inputs = emotion_tokenizer(combined_input, return_tensors="pt", truncation=True, padding=True)
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+
+    with torch.no_grad():
+        outputs = emotion_model(**inputs)
+
+    probabilities = outputs.logits.softmax(dim=-1).squeeze().cpu().numpy()
+
+    emotion_labels = ['Negative emotion', 'Positive emotion','No emotion']
+    predicted_emotion = emotion_labels[np.argmax(probabilities)]
+
+    return predicted_emotion, {label: float(prob) for label, prob in zip(emotion_labels, probabilities)}
+
+def process_test_data(test_df):
+    results = []
+    for _, row in test_df.iterrows():
+        text = row['Tweet']
+        predicted_target = predict_target(text)
+        predicted_emotion, emotion_probs = predict_emotion(text, predicted_target)
+
+        results.append({
+            'Tweet': text,
+            'Predicted Target': predicted_target,
+            'Predicted Emotion': predicted_emotion,
+            'Emotion Probabilities': emotion_probs
+        })
+
+    return pd.DataFrame(results)
+
+if __name__ == "__main__":
+    test_df = pd.read_excel('NLP Engineer Assignment Dataset (1) (1) (1) (1).xlsx', sheet_name='Test')
+    results_df = process_test_data(test_df)
+    results_df.to_csv('test_results.csv', index=False)
+    print("Results saved to test_results.csv")

requirements.txt

@@ -0,0 +1,10 @@
+pandas 
+numpy 
+scikit-learn 
+transformers 
+datasets 
+torch 
+gradio 
+joblib 
+imbalanced-learn 
+xgboost

run_gradio_v3.py

@@ -0,0 +1,105 @@
+import gradio as gr
+from inference import predict_target, predict_emotion
+import pandas as pd
+import re
+from PIL import Image
+
+def predict(text):
+    predicted_target = predict_target(text)
+    predicted_emotion, emotion_probs = predict_emotion(text, predicted_target)
+    
+    summary_df = pd.DataFrame({
+        "Aspect": ["Target", "Emotion"],
+        "Prediction": [predicted_target, predicted_emotion]
+    })
+    
+    return predicted_target, predicted_emotion, emotion_probs, summary_df
+
+def analyze_text(text):
+    word_count = len(text.split())
+    char_count = len(text)
+    
+    hashtags = re.findall(r'#\w+', text)
+    mentions = re.findall(r'@\w+', text)
+    urls = re.findall(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', text)
+    emojis = re.findall(r'[\U0001F600-\U0001F64F\U0001F300-\U0001F5FF\U0001F680-\U0001F6FF\U0001F1E0-\U0001F1FF]', text)
+    
+    analysis = f"""Word count: {word_count}
+Character count: {char_count}
+Hashtags: {len(hashtags)} {', '.join(hashtags)}
+Mentions: {len(mentions)} {', '.join(mentions)}
+URLs: {len(urls)}
+Emojis: {len(emojis)} {''.join(emojis)}"""
+    
+    return analysis
+
+def load_readme():
+    with open("README.md", "r") as file:
+        return file.read()
+
+logo = Image.open("freepik__pixel-art-8bits-create-an-icon-for-tweet-sentiment__72933.jpeg")
+logo.thumbnail((100, 100))
+
+with gr.Blocks(title="Tweet Analysis Dashboard") as iface:
+    page = gr.State("inference")
+    
+    with gr.Row():
+        gr.Markdown("# Tweet Analysis Dashboard")
+        gr.Image(logo, scale=1, min_width=100)
+    
+    with gr.Row():
+        inference_btn = gr.Button("Inference")
+        readme_btn = gr.Button("README")
+    
+    with gr.Column() as inference_page:
+        gr.Markdown("## Tweet Emotion and Target Prediction")
+        gr.Markdown("Enter a tweet to predict its target and emotion, and get additional text analysis.")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                input_text = gr.Textbox(label="Tweet Text", lines=5)
+                submit_btn = gr.Button("Analyze")
+            with gr.Column(scale=1):
+                text_analysis = gr.Textbox(label="Text Analysis", interactive=False)
+        
+        with gr.Row():
+            target_output = gr.Textbox(label="Predicted Target")
+            emotion_output = gr.Textbox(label="Predicted Emotion")
+        
+        emotion_probs_output = gr.Label(label="Emotion Probabilities")
+        summary_output = gr.Dataframe(label="Prediction Summary", headers=["Aspect", "Prediction"])
+    
+    with gr.Column(visible=False) as readme_page:
+        readme_content = gr.Markdown(load_readme())
+    
+    def show_inference():
+        return {
+            inference_page: gr.update(visible=True),
+            readme_page: gr.update(visible=False),
+            page: "inference"
+        }
+    
+    def show_readme():
+        return {
+            inference_page: gr.update(visible=False),
+            readme_page: gr.update(visible=True),
+            page: "readme"
+        }
+    
+    inference_btn.click(show_inference, outputs=[inference_page, readme_page, page])
+    readme_btn.click(show_readme, outputs=[inference_page, readme_page, page])
+    
+    submit_btn.click(
+        fn=predict,
+        inputs=input_text,
+        outputs=[target_output, emotion_output, emotion_probs_output, summary_output]
+    )
+    
+    submit_btn.click(
+        fn=analyze_text,
+        inputs=input_text,
+        outputs=text_analysis
+    )
+
+if __name__ == "__main__":
+    iface.launch(share=True,debug=True)

train_model_v2.py

@@ -0,0 +1,246 @@
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
+from datasets import Dataset
+import torch
+import joblib
+from sklearn.metrics import classification_report
+import numpy as np
+import re
+import wandb
+from imblearn.over_sampling import RandomOverSampler
+import random
+from nltk.corpus import wordnet
+import nltk
+from warnings import filterwarnings
+filterwarnings('ignore')
+
+nltk.download('wordnet', quiet=True)
+wandb.init(mode="disabled")
+
+def clean_text(text):
+    text = re.sub(r'@\w+', '', text)
+    text = re.sub(r'#\w+', '', text)
+    text = re.sub(r'{links}', '', text)
+    text = re.sub(r'http\S+|www.\S+', '', text)
+    text = re.sub(r'[^A-Za-z0-9\s]', ' ', text)
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+def preprocess_data(df):
+    df.columns = ['text', 'target', 'emotion']
+    df = df[df['emotion'] != 'I can\'t tell']
+    df = df[~df['text'].isna()].reset_index(drop=True)
+
+    target_mapping = {
+        'Google': 'Google',
+        'Apple': 'Apple',
+        'iPad': 'iPad',
+        'iPhone': 'iPhone',
+        'Other Google product or service': 'Google',
+        'Other Apple product or service': 'Apple',
+        'Android': 'Android',
+        'Android App': 'Android App',
+        'iPad or iPhone App': 'iPad or iPhone App',
+    }
+
+    df['new_text'] = df['text'].apply(clean_text)
+    df['new_target'] = df['target'].apply(lambda x: target_mapping.get(x, 'No Product'))
+    df['target'] = df['target'].fillna('No Product')
+
+    return df
+
+def compute_metrics(eval_pred):
+    logits, labels = eval_pred
+    predictions = np.argmax(logits, axis=-1)
+    return {
+        'accuracy': (predictions == labels).mean(),
+    }
+
+def random_word_drop(text, max_words=3):
+    words = text.split()
+    if len(words) <= max_words:
+        return text
+    num_to_drop = random.randint(1, min(max_words, len(words) - 1))
+    drop_indices = random.sample(range(len(words)), num_to_drop)
+    return ' '.join([word for i, word in enumerate(words) if i not in drop_indices])
+
+def synonym_replacement(text, n=1):
+    words = text.split()
+    new_words = words.copy()
+    random_word_list = list(set([word for word in words if word.isalnum()]))
+    random.shuffle(random_word_list)
+    num_replaced = 0
+    for random_word in random_word_list:
+        synonyms = []
+        for syn in wordnet.synsets(random_word):
+            for l in syn.lemmas():
+                synonyms.append(l.name())
+        if len(synonyms) >= 1:
+            synonym = random.choice(list(set(synonyms)))
+            new_words = [synonym if word == random_word else word for word in new_words]
+            num_replaced += 1
+        if num_replaced >= n:
+            break
+    return ' '.join(new_words)
+
+def print_class_distribution(df, stage):
+    class_dist = df['sentiment_label'].value_counts().sort_index()
+    total = len(df)
+    print(f"\nClass distribution - {stage}:")
+    for label, count in class_dist.items():
+        percentage = (count / total) * 100
+        print(f"Class {label}: {count} ({percentage:.2f}%)")
+
+def augment_data(df):
+    class_counts = df['sentiment_label'].value_counts()
+    max_class = class_counts.idxmax()
+    min_class = class_counts.idxmin()
+
+    augmented_data = []
+    for _, row in df.iterrows():
+        # Original data
+        augmented_data.append({
+            'new_text': row['new_text'],
+            'new_target': row['new_target'],
+            'sentiment_label': row['sentiment_label']
+        })
+
+        # Augment less for the highest class
+        if row['sentiment_label'] == max_class:
+            if random.random() < 0.4:  # 50% chance to augment
+                new_text = random_word_drop(row['new_text'])
+                augmented_data.append({
+                    'new_text': new_text,
+                    'new_target': row['new_target'],
+                    'sentiment_label': row['sentiment_label']
+                })
+        else:
+            # Random word drop
+            new_text = random_word_drop(row['new_text'])
+            augmented_data.append({
+                'new_text': new_text,
+                'new_target': row['new_target'],
+                'sentiment_label': row['sentiment_label']
+            })
+
+            # Synonym replacement
+            new_text = synonym_replacement(row['new_text'])
+            augmented_data.append({
+                'new_text': new_text,
+                'new_target': row['new_target'],
+                'sentiment_label': row['sentiment_label']
+            })
+
+        # Extra augmentation for the lowest class
+        if row['sentiment_label'] == min_class:
+            new_text = random_word_drop(synonym_replacement(row['new_text']))
+            augmented_data.append({
+                'new_text': new_text,
+                'new_target': row['new_target'],
+                'sentiment_label': row['sentiment_label']
+            })
+
+    augmented_df = pd.DataFrame(augmented_data)
+    augmented_df['combined_input'] = augmented_df['new_text'] + " [SEP] " + augmented_df['new_target']
+    return augmented_df
+
+def balance_data(df):
+    X = df[['combined_input']]
+    y = df['sentiment_label']
+
+    ros = RandomOverSampler(random_state=42)
+    X_resampled, y_resampled = ros.fit_resample(X, y)
+
+    balanced_df = pd.DataFrame({
+        'combined_input': X_resampled['combined_input'],
+        'sentiment_label': y_resampled
+    })
+
+    return balanced_df
+
+def train_model_v2(df):
+    emo_dict = {'Negative emotion': 0, 'Positive emotion': 1, 'No emotion toward brand or product': 2}
+    df['sentiment_label'] = df['emotion'].apply(lambda x: emo_dict[x])
+
+    train_data, val_data = train_test_split(df, test_size=0.2, stratify=df['sentiment_label'], random_state=42)
+
+    print_class_distribution(train_data, "Before augmentation and balancing")
+
+    # Augment and balance only the training data
+    train_data = augment_data(train_data)
+    print_class_distribution(train_data, "After augmentation")
+
+    train_data = balance_data(train_data)
+    print_class_distribution(train_data, "After balancing")
+
+    val_data['combined_input'] = val_data['new_text'] + " [SEP] " + val_data['new_target']
+
+    train_data = train_data[['combined_input', 'sentiment_label']]
+    val_data = val_data[['combined_input', 'sentiment_label']]
+
+    tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
+
+    def preprocess_function(examples):
+        tokenized_inputs = tokenizer(examples['combined_input'], padding='max_length', truncation=True, max_length=128)
+        tokenized_inputs['labels'] = examples['sentiment_label']
+        return tokenized_inputs
+
+    train_dataset = Dataset.from_pandas(train_data)
+    val_dataset = Dataset.from_pandas(val_data[['combined_input', 'sentiment_label']])
+
+    train_dataset = train_dataset.map(preprocess_function, batched=True)
+    val_dataset = val_dataset.map(preprocess_function, batched=True)
+
+    model = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment", num_labels=3)
+
+    for name, param in model.named_parameters():
+        if not any(layer in name for layer in ['encoder.layer.11', 'encoder.layer.10','encoder.layer.9','encoder.layer.8', 'pooler', 'classifier']):
+            param.requires_grad = False
+
+    training_args = TrainingArguments(
+        output_dir='./results',
+        evaluation_strategy="epoch",
+        save_strategy="epoch",
+        logging_steps=50,
+        learning_rate=1e-5,
+        per_device_train_batch_size=256,
+        per_device_eval_batch_size=256,
+        num_train_epochs=8,
+        weight_decay=0.01,
+        logging_strategy="steps",
+        load_best_model_at_end=True,
+        report_to="none",
+        metric_for_best_model="eval_loss",
+    )
+
+    trainer = Trainer(
+        model=model,
+        args=training_args,
+        train_dataset=train_dataset,
+        eval_dataset=val_dataset,
+        tokenizer=tokenizer,
+        compute_metrics=compute_metrics
+    )
+
+    trainer.train()
+
+    # Save the model and tokenizer
+    output_dir = "./emotion_model"
+    trainer.save_model(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+    print(f"Model and tokenizer saved to {output_dir}")
+
+    # Generate and print classification report
+    predictions = trainer.predict(val_dataset)
+    preds = np.argmax(predictions.predictions, axis=-1)
+    labels = predictions.label_ids
+
+    print("\nClassification Report:")
+    print(classification_report(labels, preds, target_names=list(emo_dict.keys())))
+
+if __name__ == "__main__":
+    df = pd.read_excel('NLP Engineer Assignment Dataset (1) (1) (1) (1).xlsx', sheet_name='Train')
+    processed_df = preprocess_data(df)
+    train_model_v2(processed_df)