update

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/Multidimensional_Multilevel_Bias_Detection.iml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/venv" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9 (Multidimensional_Multilevel_Bias_Detection)" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/Multidimensional_Multilevel_Bias_Detection.iml" filepath="$PROJECT_DIR$/.idea/Multidimensional_Multilevel_Bias_Detection.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

README.md

@@ -1,13 +1 @@
----
-title: Multidimensional Multilevel Bias Detection
-emoji: 🏆
-colorFrom: red
-colorTo: red
-sdk: streamlit
-sdk_version: 1.21.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# text-bias-classification

app.py

@@ -0,0 +1,26 @@
+import streamlit as st
+from bias_detector import Detector
+
+st.title("Multidimensional Multilevel Bias Detection")
+
+level = st.selectbox("Select the Bias Levels:", ("Token","Sentence"))
+dimension = st.selectbox("Select the Bias Dimensions:", ("All","Gender","Religion","Race","Profession"))
+detector = Detector(level,dimension)
+target_sentence = st.text_input("Input the sentence you want to detect:")
+
+def format_results(results):
+    formatted = ""
+    for result in results:
+        for text, pred in result.items():
+            formatted += f"**Text**: {text}\n\n"
+            formatted += "**Predictions**:\n"
+            for token, labels in pred.items():
+                formatted += f"- Token: `{token}`\n"
+                for label, score in labels.items():
+                    formatted += f"    - Label: `{label}`, Score: `{score}`\n"
+    return formatted
+
+if st.button("Detect"):
+    results = detector.predict([target_sentence])
+    formatted_results = format_results(results)
+    st.markdown(f"## Detection Results: \n\n {formatted_results}")

bias_detector/__init__.py

@@ -0,0 +1 @@
+from .bias_detector import Detector

bias_detector/bias_detector.py

@@ -0,0 +1,162 @@
+import time
+import requests
+from typing import List
+import os
+class Detector:
+    """
+    A class for detecting various forms of bias in text using pre-trained models.
+    """
+
+    def __init__(self, classifier, model_type):
+        """
+        Initializes the detector with a specific model.
+
+        Args:
+            classifier (str): The type of classifier to use.
+            model_type (str): The type of the model to use.
+        """
+
+        # Maps classifiers to their available models
+        self.classifier_model_mapping = {
+                "Token": {
+                    "All": "wu981526092/Token-Level-Multidimensional-Bias-Detector",
+                    "Race": "wu981526092/Token-Level-Race-Bias-Detector",
+                    "Gender": "wu981526092/Token-Level-Gender-Bias-Detector",
+                    "Profession": "wu981526092/Token-Level-Profession-Bias-Detector",
+                    "Religion": "wu981526092/Token-Level-Religion-Bias-Detector",
+                },
+                "Sentence": {
+                    "All":None,
+                    "Religion": "wu981526092/Sentence-Level-Religion-Bias-Detector",
+                    "Profession": "wu981526092/Sentence-Level-Profession-Bias-Detector",
+                    "Race": "wu981526092/Sentence-Level-Race-Bias-Detector",
+                    "Gender": "wu981526092/Sentence-Level-Gender-Bias-Detector",
+                }
+        }
+
+        self.SD_SL_label_mapping = {
+            'LABEL_0': 'stereotype',
+            'LABEL_1': 'anti-stereotype',
+            'LABEL_2': 'unrelated'
+        }
+
+        self.MD_SL_label_mapping = {
+            'LABEL_0': 'unrelated',
+            'LABEL_1': 'stereotype_gender',
+            'LABEL_2': 'anti-stereotype_gender',
+            'LABEL_3': 'stereotype_race',
+            'LABEL_4': 'anti-stereotype_race',
+            'LABEL_5': 'stereotype_profession',
+            'LABEL_6': 'anti-stereotype_profession',
+            'LABEL_7': 'stereotype_religion',
+            'LABEL_8': 'anti-stereotype_religion'
+        }
+
+        self.classifier = classifier
+        self.model_type = model_type
+
+        if classifier not in self.classifier_model_mapping:
+            raise ValueError(f"Invalid classifier. Expected one of: {list(self.classifier_model_mapping.keys())}")
+
+        if model_type not in self.classifier_model_mapping[classifier]:
+            raise ValueError(
+                f"Invalid model_type for {classifier}. Expected one of: {list(self.classifier_model_mapping[classifier].keys())}")
+
+        self.model_path = self.classifier_model_mapping[classifier][model_type]
+
+        # Create the API endpoint from the model path
+        self.API_URL = f"https://api-inference.huggingface.co/models/{self.model_path}"
+        API_token = os.getenv("BIAS_DETECTOR_API_KEY")
+        #API_token = "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"
+        # Add authorization token (if required)
+        self.headers = {"Authorization": f"Bearer {API_token}"} # Replace `your_api_token` with your token
+
+    import time
+
+    import time
+
+    def query(self, payload, max_retries=5, wait_time=5):
+        retries = 0
+
+        while retries <= max_retries:
+            response = requests.post(self.API_URL, headers=self.headers, json=payload).json()
+
+            # If the model is loading, wait for the estimated time and retry
+            if 'error' in response and 'estimated_time' in response:
+                print(f"Model is currently loading. Waiting for {response['estimated_time']} seconds.")
+                time.sleep(response['estimated_time'])
+                retries += 1
+                continue
+
+            # If the service is unavailable, wait for some time and retry
+            if 'error' in response and response['error'] == "Service Unavailable":
+                print(f"Service is unavailable. Waiting for {wait_time} seconds before retrying...")
+                time.sleep(wait_time)
+                retries += 1
+                continue
+
+            # If any other error is received, raise a RuntimeError
+            if 'error' in response:
+                raise RuntimeError(f"Error: {response['error']}")
+
+            return response
+
+        # If the maximum number of retries has been reached and the request is still failing, raise a RuntimeError
+        raise RuntimeError(f"Error: Service Unavailable. Failed after {max_retries} retries.")
+
+    def predict(self, texts: List[str]):
+        """
+        Predicts the bias of the given text or list of texts.
+
+        Args:
+            texts (List[str]): A list of strings to analyze.
+
+        Returns:
+            A list of dictionaries. Each dictionary contains the 'label' and 'score' for each text.
+        """
+        if not all(isinstance(text, str) for text in texts):
+            raise ValueError("All elements in 'texts' should be of str type")
+
+        results = []
+
+        # Prepare the payload
+        payload = {"inputs": texts}
+
+        # Query the API
+        try:
+            predictions = self.query(payload)
+        except RuntimeError as e:
+            print("Prediction failed due to a RuntimeError")
+            raise e
+        except Exception as e:
+            print("Prediction failed due to an unknown error")
+            raise e
+
+        # Process the predictions
+        for text, prediction in zip(texts, predictions):
+            # Check if an error occurred while loading the model
+            if 'error' in prediction:
+                print(f"Error for text '{text}': {prediction['error']}")
+                results.append({text: {'error': prediction['error']}})
+            else:
+                result = {}
+                if self.classifier == 'Token':
+                    for item in prediction:
+                        result[item['word']] = {item['entity_group']: item['score']}
+                elif self.classifier == 'Sentence' and self.model_type == 'All':
+                    result = {self.MD_SL_label_mapping.get(item['label'].split('__')[-1], 'unknown'): item['score'] for item in
+                              prediction}
+                else:
+                    result = {self.SD_SL_label_mapping.get(item['label'].split('__')[-1], 'unknown'): item['score'] for item in
+                              prediction}
+                results.append({text: result})
+
+        return results
+
+
+if __name__ == '__main__':
+    detector_test = Detector("Sentence","Gender")
+    test_data = ["The girl performed poorly at reading in school.","Sir is an address showing respect for a person. It usually refers to a male."]
+    result = detector_test.predict(test_data)
+    print(result)
+    print(result[1][test_data[1]])

requirements

@@ -0,0 +1 @@
+requests