size_predictor

app.py

@@ -0,0 +1,139 @@
+import gradio as gr
+import csv
+import os
+from datetime import datetime
+from size_rules import evaluate_size, apply_fit_preference
+
+FEEDBACK_FILE = "feedback.csv"
+
+# Initialize CSV if it doesn't exist
+if not os.path.exists(FEEDBACK_FILE):
+    with open(FEEDBACK_FILE, "w", newline="") as f:
+        writer = csv.writer(f)
+        writer.writerow(["Timestamp", "Chest", "Waist", "Bicep", "Shoulder", "Fit_Pref", "Base_Size", "Predicted_Size", "Feedback"])
+
+def predict_size(chest, waist, bicep, shoulder, fit_pref):
+    data = {
+        "chest": chest,
+        "waist": waist,
+        "bicep": bicep,
+        "shoulder": shoulder
+    }
+    
+    base_size, base_reason = evaluate_size(data)
+    final_size, fit_reason = apply_fit_preference(base_size, fit_pref, data)
+    
+    explanation = {
+        "recommended_size": final_size,
+        "base_size": base_size,
+        "fit_preference": fit_pref,
+        "final_size": final_size,
+        "confidence": "high",
+        "reason": f"{base_reason}. {fit_reason}"
+    }
+    
+    html_output = f"""
+    <div style="
+        background-color: #d1fae5; 
+        color: #065f46; 
+        font-size: 32px; 
+        font-weight: bold; 
+        text-align: center; 
+        border: 2px solid #10b981; 
+        padding: 20px; 
+        border-radius: 8px;
+    ">
+        {final_size}
+    </div>
+    """
+    
+    # Return data for state
+    state_data = {
+        "chest": chest,
+        "waist": waist,
+        "bicep": bicep,
+        "shoulder": shoulder,
+        "fit": fit_pref,
+        "base": base_size,
+        "prediction": final_size
+    }
+    
+    return html_output, explanation, state_data
+
+def save_feedback(vote, data):
+    if not data:
+        return "No prediction data found."
+        
+    try:
+        with open(FEEDBACK_FILE, "a", newline="") as f:
+            writer = csv.writer(f)
+            writer.writerow([
+                datetime.now().isoformat(),
+                data["chest"],
+                data["waist"],
+                data["bicep"],
+                data["shoulder"],
+                data["fit"],
+                data["base"],
+                data["prediction"],
+                vote
+            ])
+        return f"Thanks! for the feedback"
+    except Exception as e:
+        return f"Error saving feedback: {str(e)}"
+
+css = """
+#result-box textarea {
+    font-size: 32px !important;
+}
+"""
+
+with gr.Blocks(title="AI Size Recommendation Engine") as demo:
+    gr.Markdown("# AI Size Recommendation Engine")
+    gr.Markdown("Enter your body measurements (in inches) to get a deterministic size recommendation.")
+    
+    # State to store the last prediction data
+    prediction_state = gr.State()
+    
+    with gr.Row():
+        with gr.Column():
+            chest = gr.Number(label="Chest (inches)", value=38.0, step=0.5)
+            waist = gr.Number(label="Waist (inches)", value=32.0, step=0.5)
+            bicep = gr.Number(label="Bicep (inches)", value=13.0, step=0.5)
+            shoulder = gr.Number(label="Shoulder (inches)", value=46.0, step=0.5)
+            fit = gr.Dropdown(choices=["tight", "regular", "loose"], label="Fit Preference", value="regular")
+            submit_btn = gr.Button("Predict Size", variant="primary")
+            
+        with gr.Column():
+            gr.Markdown("### Recommended Size") 
+            output_size = gr.HTML()
+            output_json = gr.JSON(label="Explainable AI Output")
+            
+            with gr.Row():
+                like_btn = gr.Button("👍 Good Prediction")
+                dislike_btn = gr.Button("👎 Bad Prediction")
+            
+            feedback_msg = gr.Label(label="Feedback Status", visible=False)
+
+    # Prediction event
+    submit_btn.click(
+        fn=predict_size,
+        inputs=[chest, waist, bicep, shoulder, fit],
+        outputs=[output_size, output_json, prediction_state]
+    )
+    
+    # Feedback events
+    like_btn.click(
+        fn=lambda d: save_feedback("Like", d),
+        inputs=[prediction_state],
+        outputs=[feedback_msg]
+    ).then(lambda: gr.Label(visible=True), None, feedback_msg)
+
+    dislike_btn.click(
+        fn=lambda d: save_feedback("Dislike", d),
+        inputs=[prediction_state],
+        outputs=[feedback_msg]
+    ).then(lambda: gr.Label(visible=True), None, feedback_msg)
+
+if __name__ == "__main__":
+    demo.launch()

feedback.csv

@@ -0,0 +1,9 @@
+Timestamp,Chest,Waist,Bicep,Shoulder,Fit_Pref,Base_Size,Predicted_Size,Feedback
+2026-01-02T15:26:54.295743,38,32,13,46,regular,S,M,Like
+2026-01-02T15:26:58.463759,38,32,13,46,regular,S,M,Dislike
+2026-01-02T15:28:21.262074,38,32,13,46,regular,S,M,Like
+2026-01-02T15:28:42.327924,38,32,13,46,regular,S,M,Like
+2026-01-02T15:28:43.110742,38,32,13,46,regular,S,M,Dislike
+2026-01-02T15:28:44.095717,38,32,13,46,regular,S,M,Dislike
+2026-01-02T15:28:44.377499,38,32,13,46,regular,S,M,Dislike
+2026-01-02T15:28:45.495196,38,32,13,46,regular,S,M,Dislike

requirements.txt

@@ -0,0 +1 @@
+gradio

size_chart.py

@@ -0,0 +1,32 @@
+SIZE_CHART = {
+    "XS": {
+        "chest": (34, 36),
+        "waist": (28, 30),
+        "bicep": (11, 12),
+        "shoulder": (42, 44)
+    },
+    "S": {
+        "chest": (36, 38),
+        "waist": (30, 32),
+        "bicep": (12, 13),
+        "shoulder": (44, 46)
+    },
+    "M": {
+        "chest": (38, 40),
+        "waist": (32, 34),
+        "bicep": (13, 14),
+        "shoulder": (46, 48)
+    },
+    "L": {
+        "chest": (40, 42),
+        "waist": (34, 36),
+        "bicep": (14, 15),
+        "shoulder": (48, 50)
+    },
+    "XL": {
+        "chest": (42, 44),
+        "waist": (36, 38),
+        "bicep": (15, 16),
+        "shoulder": (50, 52)
+    }
+}

size_rules.py

@@ -0,0 +1,87 @@
+from size_chart import SIZE_CHART
+
+PRIORITY = ["shoulder", "chest", "waist", "bicep"]
+
+def evaluate_size(measurements):
+    """
+    Evaluates the base size based on measurements.
+    Returns: (size, reason)
+    """
+    ordered_sizes = ["XS", "S", "M", "L", "XL"]
+    
+    for i, size in enumerate(ordered_sizes):
+        limits = SIZE_CHART[size]
+        valid = True
+        
+        # Check if measurements fit within this size's limits
+        for key in PRIORITY:
+            # We strictly check the upper bound. 
+            # If measurement > max, this size is too small.
+            if measurements[key] > limits[key][1]:
+                valid = False
+                break
+                
+        if valid:
+            # This is the smallest size that fits.
+            # Determine reasoning.
+            if i == 0:
+                return size, "Smallest available size fits all measurements."
+            
+            # Check why the previous size failed logic
+            prev_size = ordered_sizes[i-1]
+            prev_limits = SIZE_CHART[prev_size]
+            reasons = []
+            for key in PRIORITY:
+                if measurements[key] > prev_limits[key][1]:
+                    reasons.append(f"{key.capitalize()} ({measurements[key]}) > {prev_size} limit ({prev_limits[key][1]})")
+            
+            reason_str = f"Requires {size} because: " + ", ".join(reasons)
+            return size, reason_str
+
+    # If even XL fails (XL max is exceeded)
+    # We return XL+
+    # Find what exceeded XL
+    xl_limits = SIZE_CHART["XL"]
+    reasons = []
+    for key in PRIORITY:
+        if measurements[key] > xl_limits[key][1]:
+            reasons.append(f"{key.capitalize()} ({measurements[key]}) > XL limit ({xl_limits[key][1]})")
+            
+    return "XL+", "Measurements exceed XL limits: " + ", ".join(reasons)
+
+def apply_fit_preference(base_size, preference, measurements=None):
+    """
+    Applies fit preference to the base size.
+    For 'regular', requires measurements to re-evaluate.
+    Returns: (final_size, reason)
+    """
+    sizes = ["XS", "S", "M", "L", "XL"]
+    
+    if base_size not in sizes:
+        return base_size, "Fit preference not applicable for sizes outside chart"
+
+    idx = sizes.index(base_size)
+    
+    if preference == "tight":
+        return base_size, "Fit: Tight (Kept base size)"
+        
+    if preference == "loose":
+        if idx < len(sizes) - 1:
+            return sizes[idx + 1], "Fit: Loose (Moved up one size)"
+        else:
+            return base_size, "Fit: Loose (Already at max size)"
+            
+    if preference == "regular":
+        if measurements is None:
+            return base_size, "Fit: Regular (No measurements provided for adjustment)"
+            
+        # Add 0.5 inches to all measurements
+        modified_measurements = {k: v + 0.5 for k, v in measurements.items()}
+        new_size, _ = evaluate_size(modified_measurements)
+        
+        if new_size == base_size:
+             return new_size, "Fit: Regular (Adjustment didn't change size)"
+        else:
+             return new_size, f"Fit: Regular (Adjustment pushed size to {new_size})"
+
+    return base_size, "Unknown preference"