Upload folder using huggingface_hub

app.py

@@ -81,8 +81,8 @@ from preprocess import process_image_data
 
     # Using the decorator directly on the function definition
 @spaces.GPU
-def predict_ripeness(audio, image, model_path):
-    """Function with GPU acceleration to predict watermelon ripeness"""
+def predict_sugar_content(audio, image, model_path):
+    """Function with GPU acceleration to predict watermelon sugar content in Brix"""
     try:
         # Now check CUDA availability inside the GPU-decorated function
         if torch.cuda.is_available():
@@ -192,38 +192,38 @@ def predict_ripeness(audio, image, model_path):
         print(f"\033[92mDEBUG\033[0m: Running inference on device: {device}")
         if mfcc is not None and processed_image is not None:
             with torch.no_grad():
-                ripeness = model(mfcc, processed_image)
-                print(f"\033[92mDEBUG\033[0m: Prediction successful: {ripeness.item()}")
+                brix_value = model(mfcc, processed_image)
+                print(f"\033[92mDEBUG\033[0m: Prediction successful: {brix_value.item()}")
         else:
             return "Error: Failed to process inputs. Please check the debug logs."
         
         # Format the result with a range display
-        if ripeness is not None:
-            ripeness_value = ripeness.item()
+        if brix_value is not None:
+            brix_score = brix_value.item()
             
             # Create a header with the numerical result
-            result = f"🍉 Predicted Ripeness Score: {ripeness_value:.2f}/13 🍉\n\n"
+            result = f"🍉 Predicted Sugar Content: {brix_score:.1f}° Brix 🍉\n\n"
             
-            # Add ripeness scale visualization
-            result += "Ripeness Scale based on Sugar Content:\n"
+            # Add Brix scale visualization
+            result += "Sugar Content Scale (in °Brix):\n"
             result += "──────────────────────────────────\n"
             
-            # Create the scale display
+            # Create the scale display with Brix ranges
             scale_ranges = [
-                (0, 8, "Underripe"),
-                (8, 9, "Slightly Ripe"),
-                (9, 10, "Moderately Ripe"),
-                (10, 11, "Ripe"),
-                (11, 13, "Very Ripe")
+                (0, 8, "Low Sugar (< 8° Brix)"),
+                (8, 9, "Mild Sweetness (8-9° Brix)"),
+                (9, 10, "Medium Sweetness (9-10° Brix)"),
+                (10, 11, "Sweet (10-11° Brix)"),
+                (11, 13, "Very Sweet (11-13° Brix)")
             ]
             
             # Find which category the prediction falls into
             user_category = None
             for min_val, max_val, category_name in scale_ranges:
-                if min_val <= ripeness_value < max_val:
+                if min_val <= brix_score < max_val:
                     user_category = category_name
                     break
-            if ripeness_value >= scale_ranges[-1][0]:  # Handle edge case
+            if brix_score >= scale_ranges[-1][0]:  # Handle edge case
                 user_category = scale_ranges[-1][2]
             
             # Display the scale with the user's result highlighted
@@ -235,21 +235,21 @@ def predict_ripeness(audio, image, model_path):
             
             result += "──────────────────────────────────\n\n"
             
-            # Add assessment of the watermelon's ripeness
-            if ripeness_value < 8:
-                result += "Assessment: This watermelon is underripe. It may not have developed full flavor yet."
-            elif ripeness_value < 9:
-                result += "Assessment: This watermelon is slightly ripe. You might want to wait a few more days."
-            elif ripeness_value < 10:
-                result += "Assessment: This watermelon has moderate ripeness. It should have decent flavor."
-            elif ripeness_value < 11:
-                result += "Assessment: This watermelon is properly ripe! It should be sweet and juicy."
+            # Add assessment of the watermelon's sugar content
+            if brix_score < 8:
+                result += "Assessment: This watermelon has low sugar content. It may taste bland or slightly bitter."
+            elif brix_score < 9:
+                result += "Assessment: This watermelon has mild sweetness. Acceptable flavor but not very sweet."
+            elif brix_score < 10:
+                result += "Assessment: This watermelon has moderate sugar content. It should have pleasant sweetness."
+            elif brix_score < 11:
+                result += "Assessment: This watermelon has good sugar content! It should be sweet and juicy."
             else:
-                result += "Assessment: This watermelon is perfectly ripe! Excellent choice for maximum sweetness and flavor."
+                result += "Assessment: This watermelon has excellent sugar content! Perfect choice for maximum sweetness and flavor."
                 
             return result
         else:
-            return "Error: Could not predict ripeness. Please try again with different inputs."
+            return "Error: Could not predict sugar content. Please try again with different inputs."
     
     except Exception as e:
         import traceback
@@ -265,25 +265,25 @@ def create_app(model_path):
     """Create and launch the Gradio interface"""
     # Define the prediction function with model path
     def predict_fn(audio, image):
-        return predict_ripeness(audio, image, model_path)
+        return predict_sugar_content(audio, image, model_path)
     
     # Create Gradio interface
-    with gr.Blocks(title="Watermelon Ripeness Predictor", theme=gr.themes.Soft()) as interface:
-        gr.Markdown("# 🍉 Watermelon Ripeness Predictor")
+    with gr.Blocks(title="Watermelon Sugar Content Predictor", theme=gr.themes.Soft()) as interface:
+        gr.Markdown("# 🍉 Watermelon Sugar Content Predictor")
         gr.Markdown("""
-        This app predicts the ripeness of a watermelon based on its sound and appearance.
+        This app predicts the sugar content (in °Brix) of a watermelon based on its sound and appearance.
         
         ## Instructions:
         1. Upload or record an audio of tapping the watermelon
         2. Upload or capture an image of the watermelon
-        3. Click 'Predict' to get the ripeness estimation
+        3. Click 'Predict' to get the sugar content estimation
         """)
         
         with gr.Row():
             with gr.Column():
                 audio_input = gr.Audio(label="Upload or Record Audio", type="numpy")
                 image_input = gr.Image(label="Upload or Capture Image")
-                submit_btn = gr.Button("Predict Ripeness", variant="primary")
+                submit_btn = gr.Button("Predict Sugar Content", variant="primary")
             
             with gr.Column():
                 output = gr.Textbox(label="Prediction Results", lines=12)
@@ -298,6 +298,10 @@ def create_app(model_path):
         ## Tips for best results
         - For audio: Tap the watermelon with your knuckle and record the sound
         - For image: Take a clear photo of the whole watermelon in good lighting
+        
+        ## About Brix Measurement
+        Brix (°Bx) is a measurement of sugar content in a solution. For watermelons, higher Brix values indicate sweeter fruit.
+        The average ripe watermelon has a Brix value between 9-11°.
         """)
     
     return interface
@@ -305,7 +309,7 @@ def create_app(model_path):
 if __name__ == "__main__":
     import argparse
     
-    parser = argparse.ArgumentParser(description="Watermelon Ripeness Prediction App")
+    parser = argparse.ArgumentParser(description="Watermelon Sugar Content Prediction App")
     parser.add_argument(
         "--model_path", 
         type=str,