Create app.py

app.py

@@ -0,0 +1,155 @@
+import gradio as gr
+import torch
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"Use of: {device}")
+
+# Available models
+MODELS = {
+    "Aubins/distil-bumble-bert": "Aubins/distil-bumble-bert",
+    # Add models here
+}
+
+# Labels mapping
+id2label = {0: "BIASED", 1: "NEUTRAL"}
+label2id = {"BIASED": 0, "NEUTRAL": 1}
+
+# Cache for loaded models
+loaded_models = {}
+
+def load_model(model_name: str):
+    """
+    Load a model and its tokenizer if not already cached
+    
+    Args:
+        model_name (str): The name of the model to load.
+        
+    Returns:
+        model, tokenizer: The loaded model and tokenizer
+    """
+    if model_name not in loaded_models:
+        try:
+            model_path = MODELS[model_name]
+            
+            # Load model and tokenizer
+            model = AutoModelForSequenceClassification.from_pretrained(
+                model_path, 
+                num_labels=2,
+                id2label=id2label,
+                label2id=label2id
+            ).to(device)
+            tokenizer = AutoTokenizer.from_pretrained(model_path)
+            
+            loaded_models[model_name] = (model, tokenizer)
+            return model, tokenizer
+        
+        except Exception as e:
+            return f"Error loading model: {str(e)}"
+    
+    return loaded_models[model_name]
+
+def analyze_text(text: str, model_name: str):
+    """
+    Analyzes text for bias and neutrality
+    
+    Args:
+        text (str): The text to analyze.
+        model_name (str): The name of the model to use.
+        
+    Returns:
+        dict, str: A dictionary of confidence scores for each label, and a message.
+    """
+    if not text.strip():
+        return {"Empty text": 1.0}, "Please enter a text to be analyzed."
+    
+    # Load model
+    result = load_model(model_name)
+    if isinstance(result, str): 
+        return {"Error": 1.0}, result
+    
+    model, tokenizer = result
+    
+    try:
+        # Tokenization
+        inputs = tokenizer(
+            text, 
+            return_tensors="pt", 
+            truncation=True, 
+            padding=True,
+            max_length=512
+        )
+
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+        
+        # Prediction
+        model.eval()
+        with torch.no_grad():
+            outputs = model(**inputs)
+
+        logits = outputs.logits[0]
+        probabilities = torch.nn.functional.softmax(logits, dim=0)
+        predicted_class = torch.argmax(logits).item()
+        
+        predicted_label = id2label[predicted_class]
+        
+        confidence_map = {
+            "Neutral": probabilities[1].item(), 
+            "Biased": probabilities[0].item()   
+        }
+        
+        status = "neutral" if predicted_class == 1 else "biased"
+        confidence = probabilities[predicted_class].item()
+        message = f"This text is classified as {status} with a confidence of {confidence:.2%}."
+        
+        return confidence_map, message
+    
+    except Exception as e:
+        return {"Error": 1.0}, f"Analysis error: {str(e)}"
+
+# Interface Gradio
+with gr.Blocks(title="Objectivity detector in texts") as app:
+    gr.Markdown("# Objectivity detector in texts")
+    gr.Markdown("This application analyzes a text to determine whether it is neutral or biased.")
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            model_dropdown = gr.Dropdown(
+                choices=list(MODELS.keys()), 
+                label="Select a model", 
+                value=list(MODELS.keys())[0]
+            )
+            
+            text_input = gr.Textbox(
+                placeholder="Enter the text to be analyzed...", 
+                label="Text to analyze",
+                lines=10
+            )
+            
+            analyze_button = gr.Button("Analyze the text")
+        
+        with gr.Column(scale=2):
+            confidence_output = gr.Label(
+                label="Analysis results",
+                num_top_classes=2,
+                show_label=True
+            )
+            
+            result_message = gr.Textbox(label="Detailed results")
+    
+    analyze_button.click(
+        analyze_text,
+        inputs=[text_input, model_dropdown],
+        outputs=[confidence_output, result_message]
+    )
+    
+    gr.Markdown("## How to use this application")
+    gr.Markdown("""
+    1. Select an analysis model from the drop-down menu
+    2. Enter or paste the text to be analyzed into the text box (in English only).
+    3. Click on “Analyze the text”.
+    4. The result is displayed with a visual indication
+    """)
+
+if __name__ == "__main__":
+    app.launch()