updated the model card

README.md

@@ -83,21 +83,99 @@ Potential downstream uses include:
 Use the code below to get started with the model.
 
 ```python
+# How to Get Started with the Model
+
 import torch
 from transformers import RobertaTokenizer, RobertaForSequenceClassification
-import json
 
-# Load the model, tokenizer, and configuration
+# Load the model and tokenizer
 model_path = "MMADS/MoralFoundationsClassifier"
 model = RobertaForSequenceClassification.from_pretrained(model_path)
 tokenizer = RobertaTokenizer.from_pretrained(model_path)
 
-# Load label names
-with open(f"{model_path}/label_names.json", 'r') as f:
-    label_names = json.load(f)
-
-# Your function to make predictions
-### ...
+# Define label names based on Moral Foundations Theory
+# Each foundation has a virtue (positive) and vice (negative) dimension
+label_names = [
+    "care_virtue",      # Compassion, kindness, nurturing
+    "care_vice",        # Harm, cruelty, suffering
+    "fairness_virtue",  # Justice, equality, reciprocity
+    "fairness_vice",    # Cheating, inequality, injustice
+    "loyalty_virtue",   # Loyalty, patriotism, self-sacrifice
+    "loyalty_vice",     # Betrayal, treason, disloyalty
+    "authority_virtue", # Respect, tradition, order
+    "authority_vice",   # Subversion, disobedience, chaos
+    "sanctity_virtue",  # Purity, sanctity, nobility
+    "sanctity_vice"     # Degradation, contamination, impurity
+]
+
+# Function to make predictions
+def predict_moral_foundations(texts, threshold=0.65):
+    """
+    Predict moral foundations present in a batch of texts.
+    
+    Args:
+        texts (list of str): A list of input texts to analyze.
+        threshold (float): Probability threshold for positive prediction (default: 0.65).
+    
+    Returns:
+        list of dict: A list of dictionaries, one for each input text.
+    """
+    # Tokenize and prepare input
+    # The tokenizer handles a list of strings automatically, creating a batch.
+    inputs = tokenizer(texts, return_tensors="pt", truncation=True, 
+                       padding=True, max_length=512)
+    
+    # Move to GPU if available
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device)
+    inputs = {k: v.to(device) for k, v in inputs.items()}
+    
+    # Get predictions
+    with torch.no_grad():
+        outputs = model(**inputs)
+        logits = outputs.logits
+        probabilities = torch.sigmoid(logits)
+    
+    # Format results for the entire batch
+    all_results = []
+    batch_probs = probabilities.cpu().numpy()
+    
+    for single_text_probs in batch_probs:
+        results = {}
+        for i, label in enumerate(label_names):
+            results[label] = {
+                "probability": float(single_text_probs[i]),
+                "predicted": bool(single_text_probs[i] > threshold)
+            }
+        all_results.append(results)
+    
+    return all_results
+
+# Example usage with a list of texts
+texts = [
+    "You don't actually believe what you're saying.",
+    "People are calling you stupid but you're just good old fashioned lying.",
+    "Even if you've never held employment in your life there is no way you think employers just hand out sick days whenever their employees feel like it.",
+    "Troll on."
+]
+all_predictions = predict_moral_foundations(texts)
+
+# Display detected foundations for each text
+for i, text in enumerate(texts):
+    print(f"Analyzing: '{text}'")
+    print("Detected moral foundations:")
+    
+    predictions = all_predictions[i]
+    detected_foundations = False
+    for foundation, data in predictions.items():
+        if data['predicted']:
+            print(f"  - {foundation}: {data['probability']:.3f}")
+            detected_foundations = True
+    
+    if not detected_foundations:
+        print("  - None")
+        
+    print("-" * 30) # Separator for clarity
 
 ```