Update classifier.py

classifier.py

@@ -1,69 +1,94 @@
-# metrics.py
-import nltk
-from nltk.translate.bleu_score import sentence_bleu
-from rouge_score import rouge_scorer
-from model_loader import metrics_models
+# classifier.py
+import torch
+import time
+from model_loader import classifier_model
+from paraphraser import paraphrase_comment
+from metrics import compute_semantic_similarity, compute_empathy_score
 
-# Download required NLTK data
-nltk.download('punkt')
-
-def compute_semantic_similarity(original, paraphrased):
+def classify_toxic_comment(comment):
     """
-    Compute semantic similarity between the original and paraphrased comment using Sentence-BERT.
-    Returns a similarity score between 0 and 1.
+    Classify a comment as toxic or non-toxic using the fine-tuned XLM-RoBERTa model.
+    If toxic, paraphrase the comment, re-evaluate, and compute essential metrics.
+    Returns the prediction label, confidence, color, toxicity score, bias score, paraphrased comment (if applicable), and its metrics.
     """
-    try:
-        sentence_bert = metrics_models.load_sentence_bert()
-        embeddings = sentence_bert.encode([original, paraphrased])
-        similarity = float(embeddings[0] @ embeddings[1].T)
-        return round(similarity, 2)
-    except Exception as e:
-        print(f"Error computing semantic similarity: {str(e)}")
-        return None
+    start_total = time.time()
+    print("Starting classification...")
 
-def compute_empathy_score(paraphrased):
-    """
-    Compute an empathy score for the paraphrased comment (placeholder).
-    Returns a score between 0 and 1.
-    """
-    try:
-        # Placeholder: Compute empathy based on word presence (e.g., "sorry", "understand")
-        empathy_words = ["sorry", "understand", "care", "help", "support"]
-        words = paraphrased.lower().split()
-        empathy_count = sum(1 for word in words if word in empathy_words)
-        score = empathy_count / len(words) if words else 0
-        return round(score, 2)
-    except Exception as e:
-        print(f"Error computing empathy score: {str(e)}")
-        return None
+    if not comment.strip():
+        return "Error: Please enter a comment.", None, None, None, None, None, None, None, None, None, None
 
-def compute_bleu_score(original, paraphrased):
-    """
-    Compute the BLEU score between the original and paraphrased comment.
-    Returns a score between 0 and 1.
-    """
-    try:
-        reference = [nltk.word_tokenize(original.lower())]
-        candidate = nltk.word_tokenize(paraphrased.lower())
-        score = sentence_bleu(reference, candidate, weights=(0.25, 0.25, 0.25, 0.25))
-        return round(score, 2)
-    except Exception as e:
-        print(f"Error computing BLEU score: {str(e)}")
-        return None
+    # Access the model and tokenizer
+    model = classifier_model.model
+    tokenizer = classifier_model.tokenizer
 
-def compute_rouge_score(original, paraphrased):
-    """
-    Compute ROUGE scores (ROUGE-1, ROUGE-2, ROUGE-L) between the original and paraphrased comment.
-    Returns a dictionary with ROUGE scores.
-    """
-    try:
-        scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
-        scores = scorer.score(original, paraphrased)
-        return {
-            'rouge1': round(scores['rouge1'].fmeasure, 2),
-            'rouge2': round(scores['rouge2'].fmeasure, 2),
-            'rougeL': round(scores['rougeL'].fmeasure, 2)
-        }
-    except Exception as e:
-        print(f"Error computing ROUGE scores: {str(e)}")
-        return None
+    # Tokenize the input comment
+    start_classification = time.time()
+    inputs = tokenizer(comment, return_tensors="pt", truncation=True, padding=True, max_length=512)
+
+    # Run inference
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+
+    # Get the predicted class (0 = non-toxic, 1 = toxic)
+    predicted_class = torch.argmax(logits, dim=1).item()
+    label = "Toxic" if predicted_class == 1 else "Non-Toxic"
+    confidence = torch.softmax(logits, dim=1)[0][predicted_class].item()
+    label_color = "red" if label == "Toxic" else "green"
+
+    # Compute Toxicity Score (approximated as the probability of the toxic class)
+    toxicity_score = torch.softmax(logits, dim=1)[0][1].item()
+    toxicity_score = round(toxicity_score, 2)
+
+    # Simulate Bias Score (placeholder)
+    bias_score = 0.01 if label == "Non-Toxic" else 0.15
+    bias_score = round(bias_score, 2)
+    print(f"Classification took {time.time() - start_classification:.2f} seconds")
+
+    # If the comment is toxic, paraphrase it and compute essential metrics
+    paraphrased_comment = None
+    paraphrased_prediction = None
+    paraphrased_confidence = None
+    paraphrased_color = None
+    paraphrased_toxicity_score = None
+    paraphrased_bias_score = None
+    semantic_similarity = None
+    empathy_score = None
+
+    if label == "Toxic":
+        # Paraphrase the comment
+        start_paraphrase = time.time()
+        paraphrased_comment = paraphrase_comment(comment)
+        print(f"Paraphrasing took {time.time() - start_paraphrase:.2f} seconds")
+
+        # Re-evaluate the paraphrased comment
+        start_reclassification = time.time()
+        paraphrased_inputs = tokenizer(paraphrased_comment, return_tensors="pt", truncation=True, padding=True, max_length=512)
+        with torch.no_grad():
+            paraphrased_outputs = model(**paraphrased_inputs)
+            paraphrased_logits = paraphrased_outputs.logits
+
+        paraphrased_predicted_class = torch.argmax(paraphrased_logits, dim=1).item()
+        paraphrased_label = "Toxic" if paraphrased_predicted_class == 1 else "Non-Toxic"
+        paraphrased_confidence = torch.softmax(paraphrased_logits, dim=1)[0][paraphrased_predicted_class].item()
+        paraphrased_color = "red" if paraphrased_label == "Toxic" else "green"
+        paraphrased_toxicity_score = torch.softmax(paraphrased_logits, dim=1)[0][1].item()
+        paraphrased_toxicity_score = round(paraphrased_toxicity_score, 2)
+        paraphrased_bias_score = 0.01 if paraphrased_label == "Non-Toxic" else 0.15  # Placeholder
+        paraphrased_bias_score = round(paraphrased_bias_score, 2)
+        print(f"Reclassification of paraphrased comment took {time.time() - start_reclassification:.2f} seconds")
+
+        # Compute essential metrics
+        start_metrics = time.time()
+        semantic_similarity = compute_semantic_similarity(comment, paraphrased_comment)
+        empathy_score = compute_empathy_score(paraphrased_comment)
+        print(f"Metrics computation took {time.time() - start_metrics:.2f} seconds")
+
+    print(f"Total processing time: {time.time() - start_total:.2f} seconds")
+
+    return (
+        f"Prediction: {label}", confidence, label_color, toxicity_score, bias_score,
+        paraphrased_comment, f"Prediction: {paraphrased_label}" if paraphrased_comment else None,
+        paraphrased_confidence, paraphrased_color, paraphrased_toxicity_score, paraphrased_bias_score,
+        semantic_similarity, empathy_score
+    )