Track src/train.csv with Git LFS

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+src/train.csv filter=lfs diff=lfs merge=lfs -text

requirements.txt

@@ -0,0 +1,12 @@
+pandas
+numpy
+matplotlib
+seaborn
+scikit-learn
+torch
+transformers
+datasets
+gradio
+ftfy
+accelerate>=0.26.0
+flask

src/app.py

@@ -0,0 +1,61 @@
+from flask import Flask, request, jsonify
+import gradio as gr
+from model import ToxicCommentDetector
+
+app = Flask(__name__)
+detector = ToxicCommentDetector()
+detector.load_models()
+
+@app.route('/predict', methods=['POST'])
+def predict():
+    data = request.json
+    text = data.get('text', '')
+    model_name = data.get('model_name', 'DistilBERT')
+    
+    if not text:
+        return jsonify({"error": "No text provided"}), 400
+    
+    try:
+        results = detector.predict(text, model_name)
+        return jsonify(results)
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+def create_gradio_interface(detector):
+    def predict_toxicity(text, model_name):
+        if not text.strip():
+            return "Please enter some text to analyze."
+        try:
+            results = detector.predict(text, model_name)
+            output = f"🔍 **Analysis Results using {model_name}:**\n\n"
+            for label, score in results.items():
+                emoji = "🚨" if score > 0.5 else "✅"
+                output += f"{emoji} **{label.replace('_', ' ').title()}**: {score:.3f} ({score*100:.1f}%)\n"
+            return output
+        except Exception as e:
+            return f"Error: {str(e)}"
+
+    with gr.Blocks(title="🛡️ Toxic Comment Detector", theme=gr.themes.Soft()) as interface:
+        gr.Markdown("""
+        # 🛡️ Toxic Comment Detector
+        This app uses three different pre-trained models to detect toxicity in comments.
+        Enter your text below and choose a model to get predictions, or compare all models at once!
+        """)
+
+        with gr.Tab("Single Model Prediction"):
+            with gr.Row():
+                with gr.Column():
+                    text_input = gr.Textbox(label="Enter comment to analyze", placeholder="Type your comment here...", lines=3)
+                    model_dropdown = gr.Dropdown(choices=list(detector.models.keys()), label="Select Model", value=list(detector.models.keys())[0])
+                    predict_btn = gr.Button("🔍 Analyze Toxicity", variant="primary")
+
+                with gr.Column():
+                    single_output = gr.Markdown(label="Results")
+
+            predict_btn.click(predict_toxicity, inputs=[text_input, model_dropdown], outputs=single_output)
+
+    return interface
+
+if __name__ == "__main__":
+    interface = create_gradio_interface(detector)
+    interface.launch()

src/model.py

@@ -0,0 +1,176 @@
+import pandas as pd
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+import torch
+
+class ToxicCommentDetector:
+    def __init__(self):
+        # Initialize empty dictionaries for models and tokenizers
+        self.models = {}
+        self.tokenizers = {}
+        self.label_columns = ['toxic', 'severe_toxic', 'obscene', 'threat', 'insult', 'identity_hate']
+
+        self.model_configs = {
+            'DistilBERT': {
+                'name': 'distilbert-base-uncased',
+                'max_len': 128,
+                'batch_size': 16,
+                'epochs': 3,
+                'lr': 2e-5
+            },
+            'RoBERTa': {
+                'name': 'roberta-base',
+                'max_len': 128,
+                'batch_size': 8,
+                'epochs': 3,
+                'lr': 1e-5
+            },
+            'ALBERT': {
+                'name': 'albert-base-v2',
+                'max_len': 128,
+                'batch_size': 16,
+                'epochs': 3,
+                'lr': 3e-5
+            }
+        }
+
+    def load_models(self):
+        """Load pre-trained models and tokenizers."""
+        for model_name, config in self.model_configs.items():
+            print(f"Loading {model_name}...")
+            self.models[model_name] = AutoModelForSequenceClassification.from_pretrained(config['name'], num_labels=len(self.label_columns))
+            self.tokenizers[model_name] = AutoTokenizer.from_pretrained(config['name'])
+        print("✅ Models and tokenizers loaded successfully!")
+
+    def load_and_preprocess_data(self, file_path):
+        """Load and preprocess the dataset."""
+        print(f"📊 Loading dataset from {file_path}...")
+        df = pd.read_csv(file_path)
+        print(f"✅ Dataset loaded successfully! First few rows:\n{df.head()}")
+
+        # Preprocess the data
+        from preprocess import preprocess_data
+        df = preprocess_data(df)
+        print("✅ Data preprocessing completed!")
+        return df
+
+    def train_model(self, model_name, X_train, X_val, y_train, y_val):
+        print(f"\n🚀 Training {model_name}...")
+
+        config = self.model_configs[model_name]
+
+        tokenizer = AutoTokenizer.from_pretrained(config['name'])
+        model = AutoModelForSequenceClassification.from_pretrained(
+            config['name'],
+            num_labels=len(self.label_columns),
+            problem_type="multi_label_classification"
+        )
+
+        train_dataset = ToxicDataset(X_train, y_train, tokenizer, config['max_len'], model_name)
+        val_dataset = ToxicDataset(X_val, y_val, tokenizer, config['max_len'], model_name)
+
+        training_args = TrainingArguments(
+            output_dir=f'./results_{model_name.lower()}',
+            num_train_epochs=config['epochs'],
+            per_device_train_batch_size=config['batch_size'],
+            per_device_eval_batch_size=config['batch_size'],
+            warmup_steps=500,
+            weight_decay=0.01,
+            logging_dir=f'./logs_{model_name.lower()}',
+            logging_steps=100,
+            eval_strategy="steps",
+            eval_steps=500,
+            save_strategy="steps",
+            save_steps=500,
+            load_best_model_at_end=True,
+            metric_for_best_model="auc",
+            greater_is_better=True,
+            learning_rate=config['lr'],
+            adam_epsilon=1e-8,
+            max_grad_norm=1.0,
+            fp16=True if torch.cuda.is_available() else False,
+            dataloader_num_workers=0,
+            save_total_limit=1,
+        )
+
+        trainer = Trainer(
+            model=model,
+            args=training_args,
+            train_dataset=train_dataset,
+            eval_dataset=val_dataset,
+            compute_metrics=compute_metrics,
+            callbacks=[EarlyStoppingCallback(early_stopping_patience=2)]
+        )
+
+        trainer.train()
+
+        self.models[model_name] = model
+        self.tokenizers[model_name] = tokenizer
+
+        eval_results = trainer.evaluate()
+        print(f"✅ {model_name} - Validation AUC: {eval_results['eval_auc']:.4f}, F1: {eval_results['eval_f1']:.4f}")
+
+        return eval_results
+
+    def predict(self, text, model_name):
+        if model_name not in self.models:
+            raise ValueError(f"Model {model_name} not trained yet!")
+
+        model = self.models[model_name]
+        tokenizer = self.tokenizers[model_name]
+
+        device = next(model.parameters()).device
+
+        tokenizer_kwargs = {
+            'text': text,
+            'add_special_tokens': True,
+            'max_length': 128,
+            'padding': 'max_length',
+            'truncation': True,
+            'return_attention_mask': True,
+            'return_tensors': 'pt'
+        }
+
+        if 'distilbert' not in model_name.lower():
+            tokenizer_kwargs['return_token_type_ids'] = True
+
+        inputs = tokenizer.encode_plus(**tokenizer_kwargs)
+
+        for key in inputs:
+            inputs[key] = inputs[key].to(device)
+
+        model.eval()
+        with torch.no_grad():
+            outputs = model(**inputs)
+            predictions = torch.sigmoid(outputs.logits).cpu().numpy()[0]
+
+        results = {}
+        for i, label in enumerate(self.label_columns):
+            results[label] = float(predictions[i])
+
+        return results
+
+    def evaluate_all_models(self, X_test, y_test):
+        results = {}
+
+        for model_name in self.models.keys():
+            print(f"\n🔍 Evaluating {model_name} on test set...")
+
+            model = self.models[model_name]
+            tokenizer = self.tokenizers[model_name]
+
+            test_dataset = ToxicDataset(X_test, y_test, tokenizer, 128, model_name)
+
+            trainer = Trainer(
+                model=model,
+                compute_metrics=compute_metrics,
+            )
+
+            eval_results = trainer.evaluate(test_dataset)
+            results[model_name] = {
+                'auc': eval_results['eval_auc'],
+                'f1': eval_results['eval_f1']
+            }
+
+            print(f"📊 {model_name} - Test AUC: {eval_results['eval_auc']:.4f}, F1: {eval_results['eval_f1']:.4f}")
+
+        return results

src/preprocess.py

@@ -0,0 +1,19 @@
+def clean_text(text):
+    import re
+    import ftfy
+
+    # Replace newlines, tabs, carriage returns with space
+    text = re.sub(r'[\n\r\t]', ' ', text)
+    # Strip leading and trailing whitespace
+    text = text.strip()
+    # Remove excessive spaces
+    text = re.sub(r'\s+', ' ', text)
+    # Fix encoding artifacts
+    text = ftfy.fix_text(text)
+
+    return text
+
+def preprocess_data(df):
+    # Apply cleaning to the 'comment_text' column
+    df['comment_text'] = df['comment_text'].apply(clean_text)
+    return df

src/train.csv

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

src/utils.py

@@ -0,0 +1,22 @@
+def compute_metrics(eval_pred):
+    predictions, labels = eval_pred
+    predictions = torch.sigmoid(torch.tensor(predictions)).numpy()
+
+    # Convert to binary predictions
+    binary_predictions = (predictions > 0.5).astype(int)
+
+    # Calculate metrics
+    auc_scores = []
+    f1_scores = []
+
+    for i in range(labels.shape[1]):
+        if len(np.unique(labels[:, i])) > 1:  # Check if both classes exist
+            auc = roc_auc_score(labels[:, i], predictions[:, i])
+            auc_scores.append(auc)
+            f1 = f1_score(labels[:, i], binary_predictions[:, i])
+            f1_scores.append(f1)
+
+    return {
+        'auc': np.mean(auc_scores),
+        'f1': np.mean(f1_scores)
+    }