Update schema

app.py

@@ -1,12 +1,30 @@
-from concrete.ml.deployment import FHEModelClient
-from pathlib import Path
-import numpy as np
 import gradio as gr
 import requests
-import json
-
 from typing import List
 
+# Define the COLUMN_MIN_MAX as provided
+COLUMN_MIN_MAX = {
+    "Age": (18, 100),
+    "Blood_Glucose_Level": (0, 3),
+    "Blood_Pressure_Systolic": (0, 3),
+    "Blood_Pressure_Diastolic": (0, 3),
+    "BMI": (0, 3),
+    "Condition_Severity": (0, 3),
+    "Gender": (0, 2),
+    "Ethnicity": (0, 5),
+    "Geographic_Location": (0, 6),
+    "Smoking_Status": (0, 2),
+    "Diagnoses_ICD10": (0, 5),
+    "Medications": (0, 7),
+    "Allergies": (0, 5),
+    "Previous_Treatments": (0, 5),
+    "Alcohol_Consumption": (0, 3),
+    "Exercise_Habits": (0, 4),
+    "Diet": (0, 5),
+    "Functional_Status": (0, 2),
+    "Previous_Trial_Participation": (0, 1),
+}
+
 # Define possible categories for fields without predefined categories
 additional_categories = {
     "Gender": ["Male", "Female", "Other"],
@@ -24,9 +42,10 @@ additional_categories = {
     "Previous_Trial_Participation": ["Yes", "No"]
 }
 
-# Define the input components for the researcher form
-min_age_input = gr.Number(label="Minimum Age", value=18)
-max_age_input = gr.Number(label="Maximum Age", value=100)
+# Define the input components for the researcher form with constraints
+min_age_input = gr.Number(label="Minimum Age", value=18, minimum=COLUMN_MIN_MAX["Age"][0], maximum=COLUMN_MIN_MAX["Age"][1])
+max_age_input = gr.Number(label="Maximum Age", value=100, minimum=COLUMN_MIN_MAX["Age"][0], maximum=COLUMN_MIN_MAX["Age"][1])
+
 gender_input = gr.CheckboxGroup(choices=additional_categories["Gender"], label="Gender")
 ethnicity_input = gr.CheckboxGroup(choices=additional_categories["Ethnicity"], label="Ethnicity")
 geographic_location_input = gr.CheckboxGroup(choices=additional_categories["Geographic_Location"], label="Geographic Location")
@@ -34,23 +53,32 @@ diagnoses_icd10_input = gr.CheckboxGroup(choices=additional_categories["Diagnose
 medications_input = gr.CheckboxGroup(choices=additional_categories["Medications"], label="Medications")
 allergies_input = gr.CheckboxGroup(choices=additional_categories["Allergies"], label="Allergies")
 previous_treatments_input = gr.CheckboxGroup(choices=additional_categories["Previous_Treatments"], label="Previous Treatments")
-min_blood_glucose_level_input = gr.Number(label="Minimum Blood Glucose Level", value=0)
-max_blood_glucose_level_input = gr.Number(label="Maximum Blood Glucose Level", value=300)
-min_blood_pressure_systolic_input = gr.Number(label="Minimum Blood Pressure (Systolic)", value=80)
-max_blood_pressure_systolic_input = gr.Number(label="Maximum Blood Pressure (Systolic)", value=200)
-min_blood_pressure_diastolic_input = gr.Number(label="Minimum Blood Pressure (Diastolic)", value=40)
-max_blood_pressure_diastolic_input = gr.Number(label="Maximum Blood Pressure (Diastolic)", value=120)
-min_bmi_input = gr.Number(label="Minimum BMI", value=10)
-max_bmi_input = gr.Number(label="Maximum BMI", value=50)
+
+min_blood_glucose_level_input = gr.Number(label="Minimum Blood Glucose Level", value=0, minimum=COLUMN_MIN_MAX["Blood_Glucose_Level"][0], maximum=COLUMN_MIN_MAX["Blood_Glucose_Level"][1])
+max_blood_glucose_level_input = gr.Number(label="Maximum Blood Glucose Level", value=3, minimum=COLUMN_MIN_MAX["Blood_Glucose_Level"][0], maximum=COLUMN_MIN_MAX["Blood_Glucose_Level"][1])
+
+min_blood_pressure_systolic_input = gr.Number(label="Minimum Blood Pressure (Systolic)", value=0, minimum=COLUMN_MIN_MAX["Blood_Pressure_Systolic"][0], maximum=COLUMN_MIN_MAX["Blood_Pressure_Systolic"][1])
+max_blood_pressure_systolic_input = gr.Number(label="Maximum Blood Pressure (Systolic)", value=3, minimum=COLUMN_MIN_MAX["Blood_Pressure_Systolic"][0], maximum=COLUMN_MIN_MAX["Blood_Pressure_Systolic"][1])
+
+min_blood_pressure_diastolic_input = gr.Number(label="Minimum Blood Pressure (Diastolic)", value=0, minimum=COLUMN_MIN_MAX["Blood_Pressure_Diastolic"][0], maximum=COLUMN_MIN_MAX["Blood_Pressure_Diastolic"][1])
+max_blood_pressure_diastolic_input = gr.Number(label="Maximum Blood Pressure (Diastolic)", value=3, minimum=COLUMN_MIN_MAX["Blood_Pressure_Diastolic"][0], maximum=COLUMN_MIN_MAX["Blood_Pressure_Diastolic"][1])
+
+min_bmi_input = gr.Number(label="Minimum BMI", value=0, minimum=COLUMN_MIN_MAX["BMI"][0], maximum=COLUMN_MIN_MAX["BMI"][1])
+max_bmi_input = gr.Number(label="Maximum BMI", value=3, minimum=COLUMN_MIN_MAX["BMI"][0], maximum=COLUMN_MIN_MAX["BMI"][1])
+
 smoking_status_input = gr.CheckboxGroup(choices=additional_categories["Smoking_Status"], label="Smoking Status")
 alcohol_consumption_input = gr.CheckboxGroup(choices=additional_categories["Alcohol_Consumption"], label="Alcohol Consumption")
 exercise_habits_input = gr.CheckboxGroup(choices=additional_categories["Exercise_Habits"], label="Exercise Habits")
 diet_input = gr.CheckboxGroup(choices=additional_categories["Diet"], label="Diet")
-min_condition_severity_input = gr.Number(label="Minimum Condition Severity", value=1)
-max_condition_severity_input = gr.Number(label="Maximum Condition Severity", value=10)
+
+min_condition_severity_input = gr.Number(label="Minimum Condition Severity", value=0, minimum=COLUMN_MIN_MAX["Condition_Severity"][0], maximum=COLUMN_MIN_MAX["Condition_Severity"][1])
+max_condition_severity_input = gr.Number(label="Maximum Condition Severity", value=3, minimum=COLUMN_MIN_MAX["Condition_Severity"][0], maximum=COLUMN_MIN_MAX["Condition_Severity"][1])
+
 functional_status_input = gr.CheckboxGroup(choices=additional_categories["Functional_Status"], label="Functional Status")
 previous_trial_participation_input = gr.CheckboxGroup(choices=additional_categories["Previous_Trial_Participation"], label="Previous Trial Participation")
 
+# Define the server's URL
+SERVER_URL = "http://127.0.0.1:7860/api/predict"  # Ensure this is the correct endpoint
 
 def encode_categorical_data(data: List[str], category_name: str) -> List[int]:
     """Encodes a list of categorical values into their corresponding indices based on additional_categories."""
@@ -58,12 +86,19 @@ def encode_categorical_data(data: List[str], category_name: str) -> List[int]:
     encoded_data = []
     for value in data:
         if value in sub_cats:
-            encoded_data.append(sub_cats.index(value) + 1)  # Adding 1 to avoid index 0 for valid entries
+            encoded_index = sub_cats.index(value)
+            # Validate that the encoded index is within the specified range
+            min_val, max_val = COLUMN_MIN_MAX.get(category_name, (0, len(sub_cats)-1))
+            if min_val <= encoded_index <= max_val:
+                encoded_data.append(encoded_index)
+            else:
+                print(f"Encoded value for {category_name}='{value}' is out of range. Setting to 0.")
+                encoded_data.append(0)
         else:
-            encoded_data.append(0)  # Encode unmatched as 0
+            print(f"Value '{value}' not recognized in category '{category_name}'. Setting to 0.")
+            encoded_data.append(0)
     return encoded_data
 
-
 def process_researcher_data(
     min_age, max_age, gender, ethnicity, geographic_location, diagnoses_icd10, medications, allergies, previous_treatments,
     min_blood_glucose_level, max_blood_glucose_level, min_blood_pressure_systolic, max_blood_pressure_systolic,
@@ -75,6 +110,9 @@ def process_researcher_data(
     encoded_ethnicity = encode_categorical_data(ethnicity, "Ethnicity")
     encoded_geographic_location = encode_categorical_data(geographic_location, "Geographic_Location")
     encoded_diagnoses_icd10 = encode_categorical_data(diagnoses_icd10, "Diagnoses_ICD10")
+    encoded_medications = encode_categorical_data(medications, "Medications")
+    encoded_allergies = encode_categorical_data(allergies, "Allergies")
+    encoded_previous_treatments = encode_categorical_data(previous_treatments, "Previous_Treatments")
     encoded_smoking_status = encode_categorical_data(smoking_status, "Smoking_Status")
     encoded_alcohol_consumption = encode_categorical_data(alcohol_consumption, "Alcohol_Consumption")
     encoded_exercise_habits = encode_categorical_data(exercise_habits, "Exercise_Habits")
@@ -86,195 +124,66 @@ def process_researcher_data(
     requirements = []
 
     # Add numerical requirements
-    if min_age is not None:
-        requirements.append({
-            "column_name": "Age",
-            "value": int(min_age),
-            "comparison_type": "greater_than"
-        })
-    if max_age is not None:
-        requirements.append({
-            "column_name": "Age",
-            "value": int(max_age),
-            "comparison_type": "less_than"
-        })
-    
-    if min_blood_glucose_level is not None:
-        requirements.append({
-            "column_name": "Blood_Glucose_Level",
-            "value": int(min_blood_glucose_level),
-            "comparison_type": "greater_than"
-        })
-    if max_blood_glucose_level is not None:
-        requirements.append({
-            "column_name": "Blood_Glucose_Level",
-            "value": int(max_blood_glucose_level),
-            "comparison_type": "less_than"
-        })
-    
-    if min_blood_pressure_systolic is not None:
-        requirements.append({
-            "column_name": "Blood_Pressure_Systolic",
-            "value": int(min_blood_pressure_systolic),
-            "comparison_type": "greater_than"
-        })
-    if max_blood_pressure_systolic is not None:
-        requirements.append({
-            "column_name": "Blood_Pressure_Systolic",
-            "value": int(max_blood_pressure_systolic),
-            "comparison_type": "less_than"
-        })
-    
-    if min_blood_pressure_diastolic is not None:
-        requirements.append({
-            "column_name": "Blood_Pressure_Diastolic",
-            "value": int(min_blood_pressure_diastolic),
-            "comparison_type": "greater_than"
-        })
-    if max_blood_pressure_diastolic is not None:
-        requirements.append({
-            "column_name": "Blood_Pressure_Diastolic",
-            "value": int(max_blood_pressure_diastolic),
-            "comparison_type": "less_than"
-        })
-    
-    if min_bmi is not None:
-        requirements.append({
-            "column_name": "BMI",
-            "value": float(min_bmi),
-            "comparison_type": "greater_than"
-        })
-    if max_bmi is not None:
-        requirements.append({
-            "column_name": "BMI",
-            "value": float(max_bmi),
-            "comparison_type": "less_than"
-        })
-    
-    if min_condition_severity is not None:
-        requirements.append({
-            "column_name": "Condition_Severity",
-            "value": int(min_condition_severity),
-            "comparison_type": "greater_than"
-        })
-    if max_condition_severity is not None:
-        requirements.append({
-            "column_name": "Condition_Severity",
-            "value": int(max_condition_severity),
-            "comparison_type": "less_than"
-        })
-
-    # Add categorical requirements
-    for gender_value in encoded_gender:
-        if gender_value > 0:
-            requirements.append({
-                "column_name": "Gender",
-                "value": gender_value,
-                "comparison_type": "equal"
-            })
-    
-    for ethnicity_value in encoded_ethnicity:
-        if ethnicity_value > 0:
+    numerical_fields = [
+        ("Age", min_age, "greater_than"),
+        ("Age", max_age, "less_than"),
+        ("Blood_Glucose_Level", min_blood_glucose_level, "greater_than"),
+        ("Blood_Glucose_Level", max_blood_glucose_level, "less_than"),
+        ("Blood_Pressure_Systolic", min_blood_pressure_systolic, "greater_than"),
+        ("Blood_Pressure_Systolic", max_blood_pressure_systolic, "less_than"),
+        ("Blood_Pressure_Diastolic", min_blood_pressure_diastolic, "greater_than"),
+        ("Blood_Pressure_Diastolic", max_blood_pressure_diastolic, "less_than"),
+        ("BMI", min_bmi, "greater_than"),
+        ("BMI", max_bmi, "less_than"),
+        ("Condition_Severity", min_condition_severity, "greater_than"),
+        ("Condition_Severity", max_condition_severity, "less_than"),
+    ]
+
+    for field, value, comparison in numerical_fields:
+        if value is not None:
+            # Ensure the value is within the specified range
+            min_val, max_val = COLUMN_MIN_MAX.get(field, (None, None))
+            if min_val is not None and max_val is not None:
+                if not (min_val <= value <= max_val):
+                    print(f"Value for {field}={value} is out of range ({min_val}, {max_val}). Adjusting to fit within range.")
+                    value = max(min(value, max_val), min_val)
             requirements.append({
-                "column_name": "Ethnicity",
-                "value": ethnicity_value,
-                "comparison_type": "equal"
+                "column_name": field,
+                "value": value,
+                "comparison_type": comparison
             })
 
-    for location_value in encoded_geographic_location:
-        if location_value > 0:
-            requirements.append({
-                "column_name": "Geographic_Location",
-                "value": location_value,
-                "comparison_type": "equal"
-            })
-
-    for diagnosis_value in encoded_diagnoses_icd10:
-        if diagnosis_value > 0:
-            requirements.append({
-                "column_name": "Diagnoses_ICD10",
-                "value": diagnosis_value,
-                "comparison_type": "equal"
-            })
-
-    for smoking_status_value in encoded_smoking_status:
-        if smoking_status_value > 0:
-            requirements.append({
-                "column_name": "Smoking_Status",
-                "value": smoking_status_value,
-                "comparison_type": "equal"
-            })
-
-    for alcohol_value in encoded_alcohol_consumption:
-        if alcohol_value > 0:
-            requirements.append({
-                "column_name": "Alcohol_Consumption",
-                "value": alcohol_value,
-                "comparison_type": "equal"
-            })
-
-    for exercise_value in encoded_exercise_habits:
-        if exercise_value > 0:
-            requirements.append({
-                "column_name": "Exercise_Habits",
-                "value": exercise_value,
-                "comparison_type": "equal"
-            })
-
-    for diet_value in encoded_diet:
-        if diet_value > 0:
-            requirements.append({
-                "column_name": "Diet",
-                "value": diet_value,
-                "comparison_type": "equal"
-            })
-
-    for status in encoded_functional_status:
-        if status > 0:
-            requirements.append({
-                "column_name": "Functional_Status",
-                "value": status,
-                "comparison_type": "equal"
-            })
-
-    for participation in encoded_previous_trial_participation:
-        if participation > 0:
-            requirements.append({
-                "column_name": "Previous_Trial_Participation",
-                "value": participation,
-                "comparison_type": "equal"
-            })
-
-    # Encode and add non-categorical fields like medications, allergies, previous treatments
-    for medication in medications:
-        encoded_medications = encode_categorical_data([medication], "Medications")
-        for med_value in encoded_medications:
-            if med_value > 0:
-                requirements.append({
-                    "column_name": "Medications",
-                    "value": med_value,
-                    "comparison_type": "equal"
-                })
-
-    for allergy in allergies:
-        encoded_allergies = encode_categorical_data([allergy], "Allergies")
-        for allergy_value in encoded_allergies:
-            if allergy_value > 0:
+    # Add categorical requirements
+    categorical_fields = [
+        ("Gender", encoded_gender, "equal"),
+        ("Ethnicity", encoded_ethnicity, "equal"),
+        ("Geographic_Location", encoded_geographic_location, "equal"),
+        ("Diagnoses_ICD10", encoded_diagnoses_icd10, "equal"),
+        ("Medications", encoded_medications, "equal"),
+        ("Allergies", encoded_allergies, "equal"),
+        ("Previous_Treatments", encoded_previous_treatments, "equal"),
+        ("Smoking_Status", encoded_smoking_status, "equal"),
+        ("Alcohol_Consumption", encoded_alcohol_consumption, "equal"),
+        ("Exercise_Habits", encoded_exercise_habits, "equal"),
+        ("Diet", encoded_diet, "equal"),
+        ("Functional_Status", encoded_functional_status, "equal"),
+        ("Previous_Trial_Participation", encoded_previous_trial_participation, "equal"),
+    ]
+
+    for field, encoded_values, comparison in categorical_fields:
+        min_val, max_val = COLUMN_MIN_MAX.get(field, (0, len(additional_categories[field])-1))
+        for encoded in encoded_values:
+            if min_val <= encoded <= max_val:
                 requirements.append({
-                    "column_name": "Allergies",
-                    "value": allergy_value,
-                    "comparison_type": "equal"
+                    "column_name": field,
+                    "value": encoded,
+                    "comparison_type": comparison
                 })
+            else:
+                print(f"Encoded value {encoded} for {field} is out of range ({min_val}, {max_val}). Skipping.")
 
-    for treatment in previous_treatments:
-        encoded_treatments = encode_categorical_data([treatment], "Previous_Treatments")
-        for treatment_value in encoded_treatments:
-            if treatment_value > 0:
-                requirements.append({
-                    "column_name": "Previous_Treatments",
-                    "value": treatment_value,
-                    "comparison_type": "equal"
-                })
+    # Encode and add non-categorical fields like medications, allergies, previous treatments
+    # Already handled above in categorical_fields
 
     # Construct the payload as a regular dictionary
     payload = {
@@ -282,13 +191,7 @@ def process_researcher_data(
         "requirements": requirements
     }
 
-    # turn the payload into a JSON object
-    payload = json.dumps(payload)
-
-    print("Payload:", payload)
-
-    # Store the server's URL
-    SERVER_URL = "https://ppaihack-match.azurewebsites.net/requirements/create"
+    print("Payload to send:", payload)  # For debugging
 
     # Make the request to the server
     try:
@@ -311,7 +214,6 @@ def process_researcher_data(
 
     return response.get("message", "No message received from server")
 
-
 # Create the Gradio interface for researchers
 researcher_demo = gr.Interface(
     fn=process_researcher_data, 
@@ -330,4 +232,4 @@ researcher_demo = gr.Interface(
 
 # Launch the researcher interface with a public link
 if __name__ == "__main__":
-    researcher_demo.launch(share=True)
+    researcher_demo.launch(share=True)