Update app.py

app.py

@@ -30,26 +30,67 @@ DEFAULT_BASAL_RATES = {
     "18:00-24:00": 0.7
 }
 
+# Global variable to store food name vocabulary
+food_name_vocabulary = None
+
 # -------------------------------------------------
 # Load Food Data from Hugging Face Dataset
 # -------------------------------------------------
 
 def load_food_data(dataset_name="Anupam007/Diabetic", local_csv="food_data.csv"):
+    """Loads food data from Hugging Face Dataset or a local CSV."""
     try:
-        ...
+        # Try loading from local CSV first
+        if os.path.exists(local_csv):
+            food_data = pd.read_csv(local_csv)
+            print(f"Loaded food data from local CSV: {local_csv}")
+        else:
+            # Load from Hugging Face Dataset
+            dataset = load_dataset(dataset_name)
+            food_data = dataset['train'].to_pandas()
+            print(f"Loaded food data from Hugging Face Dataset: {dataset_name}")
+
+        # Normalize column names to lowercase and remove spaces
+        food_data.columns = [col.lower().replace(' ', '') for col in food_data.columns]
+
+        # Remove unnamed columns
+        food_data = food_data.loc[:, ~food_data.columns.str.contains('^unnamed')]
+
+        # Normalize food_name column to lowercase: Crucial for matching
+        if 'food_name' in food_data.columns:
+            food_data['food_name'] = food_data['food_name'].str.lower()
+            print("Unique Food Names in Dataset:")
+            print(food_data['food_name'].unique())
+        else:
+            print("Warning: 'food_name' column not found in dataset.")
+            food_data = pd.DataFrame({
+            'food_category': ['starch'],
+            'food_subcategory': ['bread'],
+            'food_name': ['white bread'],  # lowercase default
+            'serving_description': ['servingsize'],
+            'serving_amount': [29],
+            'serving_unit': ['g'],
+            'carbohydrate_grams': [15],
+            'notes': ['default']
+        })
+
+        #Print first 5 rows to check columns and values
+        print("First 5 rows of loaded data:")
+        print(food_data.head())
+
         return food_data
 
     except Exception as e:
         print(f"Error loading data: {e}")
         # Provide minimal default data in case of error
         food_data = pd.DataFrame({
-            'food_category': ['unknown'],
-            'food_subcategory': ['unknown'],
-            'food_name': ['unknown'], # lowercase default
-            'serving_description': ['unknown'],
-            'serving_amount': [1],
-            'serving_unit': ['serving'],
-            'carbohydrate_grams': [0],
+            'food_category': ['starch'],
+            'food_subcategory': ['bread'],
+            'food_name': ['white bread'], # lowercase default
+            'serving_description': ['servingsize'],
+            'serving_amount': [29],
+            'serving_unit': ['g'],
+            'carbohydrate_grams': [15],
             'notes': ['default']
         })
         return food_data
@@ -72,39 +113,60 @@ except Exception as e:
     processor = None
     model = None
 
+def load_food_name_vocabulary(dataset_name="Anupam007/Diabetic"):
+    """Loads the food name vocabulary from the dataset."""
+    global food_name_vocabulary  # Use global keyword to modify the global variable
+    try:
+        dataset = load_dataset(dataset_name)
+        food_data = dataset['train'].to_pandas()
+        food_data['food_name'] = food_data['food_name'].str.lower()
+        food_name_vocabulary = food_data['food_name'].unique().tolist()
+        print("Food name vocabulary loaded.")
+        return food_name_vocabulary
+
+    except Exception as e:
+        print(f"Error loading food name vocabulary: {e}")
+        food_name_vocabulary = []  # Initialize to empty list in case of error
+        return food_name_vocabulary
+
 def classify_food(image):
-    """Classify food image using the pre-trained model"""
-    print("classify_food function called") # Check if this function is even called
+    """Classify food image using the pre-trained model, only return names from the allowed vocabulary."""
+    global food_name_vocabulary  # Access global vocabulary
+
+    if food_name_vocabulary is None:
+        load_food_name_vocabulary() # Load vocab if not already loaded
+
     try:
         if not model_loaded:
-            print("Model not loaded, returning 'Unknown'")
-            return "Unknown"
-
-        print(f"Image type: {type(image)}") # Check the type of the image
+            print("Model not loaded, returning None")
+            return None
 
         if isinstance(image, np.ndarray):
-            print("Image is a numpy array, converting to PIL Image")
             image = Image.fromarray(image)
 
-        print(f"Image mode: {image.mode}") # Check image mode (e.g., RGB, L)
-
         image = processor(images=image, return_tensors="pt")
-        print(f"Processed image: {image}")  # Print the output of the processor
 
         with torch.no_grad():
             outputs = model(**image)
         predicted_idx = torch.argmax(outputs.logits, dim=-1).item()
-        food_name = model.config.id2label.get(predicted_idx, "Unknown Food")
-        print(f"Predicted food name: {food_name}") # Print the predicted food name
-        return food_name.lower()  # Convert classification to lowercase
+        predicted_food_name = model.config.id2label.get(predicted_idx, None) # Get the predicted name OR None if not available
+
+        if predicted_food_name and predicted_food_name.lower() in food_name_vocabulary:
+            print(f"Predicted food name: {predicted_food_name.lower()}")
+            return predicted_food_name.lower()
+        else:
+            print(f"Predicted food name {predicted_food_name} not in dataset vocabulary.")
+            return None  # Or some other special value like "unknown_food"
 
     except Exception as e:
-        print(f"Classify food error: {e}")  # Print the full error message
-        return "Unknown"  # If an exception arises make sure to create a default case
+        print(f"Classify food error: {e}")
+        return None
 
 
 def get_food_nutrition(food_name: str, food_data, portion_size: float = 1.0) -> Optional[Dict[str, Any]]:
     """Get carbohydrate content for the given food""" #No USDA anymore
+    if food_name is None: #If food is none, immediately return None to avoid an error.
+        return None
     try:
         # First try the local CSV database
         food_name_lower = food_name.lower() # Ensure input is also lowercase
@@ -319,53 +381,26 @@ def diabetes_dashboard(initial_glucose, food_image, stress_level, sleep_hours, t
 
         # 1. Food Classification and Carb Calculation
         food_name = classify_food(food_image)  # This line is now inside the function
+
+        if food_name is None:
+            return (
+                "Food not recognized. Please choose a different image, or add this item to your dataset.",
+                "No insulin calculations available",
+                None,
+                None,
+                None
+            )
+
         print(f"Classified food name: {food_name}")  # Debugging: What is classified as? # Corrected indentation
         nutrition_info = get_food_nutrition(food_name, food_data, portion_size)  # Changed to pass in data
         if not nutrition_info:
-            # Try with generic categories if specific food not found
-            generic_terms = food_name.split()
-            for term in generic_terms:
-                nutrition_info = get_food_nutrition(term, food_data, portion_size)  # Changed to pass in data
-                if nutrition_info:
-                    break
-
-            if not nutrition_info:
-                # Food not found, add to DataFrame if user provided the data
-                if new_food_name:
-                    new_row = pd.DataFrame([{
-                        'food_category': new_food_category,
-                        'food_subcategory': new_food_subcategory,
-                        'food_name': new_food_name.lower(),  # Ensure lowercase
-                        'serving_description': new_serving_description,
-                        'serving_amount': new_serving_amount,
-                        'serving_unit': new_serving_unit,
-                        'carbohydrate_grams': new_carbohydrate_grams,
-                        'notes': new_notes
-                    }])
-                    food_data = pd.concat([food_data, new_row], ignore_index=True)
-
-                    # Save the updated food_data to the local CSV (or HF Dataset - implement that function)
-                    food_data.to_csv("food_data.csv", index=False)  # Save locally
-                    print(f"Added {new_food_name} to the database and saved to food_data.csv")
-
-                    # Now try to get nutrition info again
-                    nutrition_info = get_food_nutrition(new_food_name, food_data, portion_size)
-                    if not nutrition_info:
-                        return (
-                            f"Added {new_food_name} to database, but still could not retrieve nutrition information. Verify data.",
-                            "No insulin calculations available",
-                            None,
-                            None,
-                            None
-                        )
-                else:
-                    return (
-                        f"Could not find nutrition information for: {food_name}. Please add it using the 'Add New Food' tab and provide the data.",  # User prompt
-                        "No insulin calculations available",
-                        None,
-                        None,
-                        None
-                    )
+            return (
+                f"Could not find nutrition information for: {food_name} in the local database",  # Removed USDA ref
+                "No insulin calculations available",
+                None,
+                None,
+                None
+            )
 
         # 2. Insulin Calculations
         try:
@@ -615,6 +650,8 @@ def compute_metrics(eval_pred):
 
 #     # trainer.save_model("food_classifier") # save locally
 #     # trainer.push_to_hub()  # upload to HF Hub
-#     app.launch(share=True)
+
+# before app launch, load food name vocabulary
 if __name__ == "__main__":
+    load_food_name_vocabulary()
     app.launch(share=True)