Update src/streamlit_app.py

src/streamlit_app.py

@@ -5,28 +5,88 @@ from sklearn.preprocessing import StandardScaler
 from sklearn.neighbors import KNeighborsRegressor
 
 # ---------------------------
-# Load / generate dataset (NO CHANGE)
+# Page config & macOS-like styling
 # ---------------------------
+st.set_page_config(
+    page_title="Car Mod Performance Estimator — macOS Edition",
+    page_icon="🚘",
+    layout="wide"
+)
+
+st.markdown(
+    """
+    <style>
+    /* macOS-like system font and gentle background */
+    html, body, #root, .main {
+        font-family: -apple-system, "SF Pro Text", "Segoe UI", Roboto, "Helvetica Neue", Arial;
+        background: linear-gradient(180deg, #f7f8fa 0%, #eef1f6 100%);
+        color: #0b1220;
+    }
+
+    /* Frosted panels */
+    .frost {
+        background: rgba(255,255,255,0.72);
+        border-radius: 14px;
+        padding: 18px;
+        box-shadow: 0 8px 24px rgba(14, 21, 47, 0.06);
+        border: 1px solid rgba(13, 22, 39, 0.04);
+    }
+
+    /* Headline */
+    .headline {
+        display:flex;
+        align-items:center;
+        gap:12px;
+        margin-bottom:6px;
+    }
+    .headline h1 { margin: 0; font-size: 1.6rem; }
+    .headline p { margin: 0; color:#6b7280; font-size:0.95rem; }
+
+    /* Small chips */
+    .chip {
+        display:inline-block;
+        padding:6px 10px;
+        margin:4px 6px 4px 0;
+        border-radius:999px;
+        background: rgba(14,165,233,0.10);
+        color:#0369a1;
+        border: 1px solid rgba(14,165,233,0.18);
+        font-size:0.85rem;
+    }
+
+    /* subtle footer text */
+    .muted { color:#6b7280; font-size:0.9rem; }
+
+    /* metric cards adapt */
+    .metric-card {
+        background: linear-gradient(180deg, rgba(255,255,255,0.85), rgba(250,250,250,0.75));
+        border-radius: 12px;
+        padding: 12px;
+        box-shadow: 0 6px 20px rgba(14,21,47,0.04);
+        border: 1px solid rgba(13,22,39,0.03);
+    }
+
+    </style>
+    """,
+    unsafe_allow_html=True
+)
 
-@st.cache_resource
-def generate_and_train_model(n=400):
-    """Generates dataset and trains the model, cached for performance."""
+# ---------------------------
+# Synthetic data & model (unchanged logic)
+# ---------------------------
+def generate_dataset(n=400):
     np.random.seed(42)
     data = []
-
     for _ in range(n):
         engine = np.random.choice([1.6, 2.0, 2.5, 3.0, 3.5, 5.0])
         cyl = np.random.choice([4, 6, 8])
         base_hp = int(engine * cyl * np.random.uniform(18, 22))
-
         intake = np.random.choice([0, 1, 2])          # stock/CAI/perf
         exhaust = np.random.choice([0, 1, 2])         # stock/catback/straight
         induction = np.random.choice([0, 1, 2])       # none/turbo/super
         fuel = np.random.choice([0, 1, 2, 3])         # 87/91/93/E85
         tune = np.random.choice([0, 1, 2])            # none/mild/aggressive
         altitude = np.random.uniform(0, 2000)
-
-        # Synthetic HP gain logic
         hp_gain = (
             intake * np.random.uniform(3, 10) +
             exhaust * np.random.uniform(5, 20) +
@@ -36,153 +96,264 @@ def generate_and_train_model(n=400):
             altitude * 0.01 +
             np.random.uniform(-3, 3)
         )
-
         data.append([engine, cyl, base_hp, intake, exhaust, induction, fuel, tune, altitude, hp_gain])
-
     columns = ["engine", "cyl", "base_hp", "intake", "exhaust", "induction", "fuel", "tune", "altitude", "hp_gain"]
-    df = pd.DataFrame(data, columns=columns)
-
-    # Train model
-    X = df.drop("hp_gain", axis=1)
-    y = df["hp_gain"]
-
-    scaler = StandardScaler()
-    X_scaled = scaler.fit_transform(X)
-
-    model = KNeighborsRegressor(n_neighbors=5, weights='distance')
-    model.fit(X_scaled, y)
-    
-    return scaler, model
-
-scaler, model = generate_and_train_model()
-
-# ---------------------------
-# Streamlit UI (REVISED)
-# ---------------------------
-
-# Use a wide layout and set an exciting title/icon
-st.set_page_config(layout="wide")
-st.title("🚀 Turbo-Tuner: Performance Estimator")
-st.markdown("### Predict the **horsepower gain** from your engine modifications using K-NN Regression.")
-
-st.divider()
-
-# --- INPUT SECTION ---
-
-# Group base car specs and modification specs using columns and containers
-col_base, col_mods = st.columns(2)
-
-# Base Car Specifications (Column 1)
-with col_base:
-    with st.container(border=True):
-        st.subheader("🏎️ Base Car Specs")
-        st.markdown("---")
-        
-        # Use columns for a compact layout
-        col_base_1, col_base_2 = st.columns(2)
-        
-        with col_base_1:
-            engine = st.selectbox("Engine Displacement (L)", [1.6, 2.0, 2.5, 3.0, 3.5, 5.0], help="Volume of the engine cylinders.")
-        
-        with col_base_2:
-            cyl = st.selectbox("Cylinders", [4, 6, 8], help="Number of engine cylinders.")
-            
-        base_hp = st.number_input(
-            "Base Horsepower (HP)", 
-            min_value=80, max_value=700, 
-            value=200, 
-            step=10,
-            help="Your car's factory horsepower rating."
-        )
-        
-        altitude = st.slider(
-            "Altitude (meters above sea level)", 
-            0, 2000, 200, 
-            help="Higher altitude typically reduces power."
-        )
+    return pd.DataFrame(data, columns=columns)
+
+df = generate_dataset()
+
+X = df.drop("hp_gain", axis=1)
+y = df["hp_gain"]
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+model = KNeighborsRegressor(n_neighbors=5, weights='distance')
+model.fit(X_scaled, y)
+
+# ---------------------------
+# UI - Header
+# ---------------------------
+st.markdown(
+    """
+    <div class="headline">
+        <div style="font-size:1.6rem;">🚘</div>
+        <div>
+            <h1>Car Mod Performance — macOS UI</h1>
+            <p>Interactive estimator with extra tuning parameters — realistic, lightweight, and stylish.</p>
+        </div>
+    </div>
+    """,
+    unsafe_allow_html=True
+)
+
+# ---------------------------
+# Main layout: left (controls) and right (dashboard)
+# ---------------------------
+left, right = st.columns([1.05, 1])
+
+with left:
+    st.markdown('<div class="frost">', unsafe_allow_html=True)
+    st.subheader("🔧 Build & Tune")
+    col1, col2 = st.columns(2)
+
+    # Engine choices: displacement + configuration (I4..V12)
+    engine_disp_options = [0.8,1.0,1.2,1.4,1.6,1.8,2.0,2.2,2.4,2.5,2.8,3.0,3.2,3.5,4.0,4.4,5.0,6.0,8.0]
+    engine_disp = col1.selectbox("Engine Displacement (L)", engine_disp_options, index=engine_disp_options.index(2.0) if 2.0 in engine_disp_options else 0)
+
+    engine_config = col2.selectbox("Engine Layout", ["I4","I6","V6","V8","V10","V12"], index=0)
+    # Map layout -> cylinders
+    layout_to_cyl = {"I4":4,"I6":6,"V6":6,"V8":8,"V10":10,"V12":12}
+    cyl = layout_to_cyl[engine_config]
+
+    base_hp = st.number_input("Base Horsepower (stock)", min_value=60, max_value=1200, value=int(max(90, round(engine_disp * cyl * 20))), step=1)
+
+    # Vehicle weight & perception
+    weight_kg = st.number_input("Vehicle Weight (kg)", min_value=700, max_value=4000, value=1500)
+    weight_reduction = st.slider("Weight Reduction (%) — (mods / lightening)", 0, 40, 0)
 
-# Modification Specs (Column 2)
-with col_mods:
-    with st.container(border=True):
-        st.subheader("🔧 Planned Modifications")
-        st.markdown("---")
-        
-        # Use two columns for modification parts
-        mod_col_1, mod_col_2 = st.columns(2)
-        
-        with mod_col_1:
-            intake = st.selectbox("Intake System", ["Stock", "Cold Air", "Performance"])
-            exhaust = st.selectbox("Exhaust System", ["Stock", "Cat-back", "Straight Pipe"])
-            induction = st.selectbox("Forced Induction", ["None", "Turbo", "Supercharger"])
-            
-        with mod_col_2:
-            fuel = st.selectbox("Fuel Octane/Type", ["87", "91", "93", "E85"])
-            tune = st.selectbox("ECU Tune Level", ["None", "Mild", "Aggressive"])
-            # Placeholder to balance the layout
-            st.write(" ")
-
-# --- PREDICTION LOGIC ---
-
-# Map categorical to numeric
+    st.markdown("---")
+    st.markdown("#### 🧩 Bolt-ons & Induction")
+
+    intake = st.selectbox("Intake", ["Stock", "Cold Air", "Performance"])
+    exhaust = st.selectbox("Exhaust", ["Stock", "Cat-back", "Straight Pipe"])
+    exhaust_dia = st.slider("Exhaust Diameter (mm)", 40, 120, 60)
+
+    induction = st.selectbox("Forced Induction", ["None", "Turbo", "Twin-Turbo", "Supercharger", "Twincharged"])
+    # boost only relevant if induction present
+    boost_psi = st.slider("Target Boost (psi) — (only if turbo/super)", 0, 40, 8)
+
+    turbo_size = st.selectbox("Turbo Size (mm) — (if applicable)", ["N/A","Shr. 45-50","Small 50-60","Medium 60-70","Large 70+"])
+    intercooler = st.selectbox("Intercooler", ["None","Air-to-Air","Air-to-Water"])
+    meth = st.checkbox("Methanol Injection (Wet Kit)", value=False)
+
+    st.markdown("---")
+    st.markdown("#### ⚙️ Internal & ECU")
+    cam = st.selectbox("Cam Profile", ["Stock", "Road", "Race"])
+    headers = st.selectbox("Headers", ["Stock", "Performance"])
+    intake_manifold = st.selectbox("Intake Manifold", ["Stock", "High-flow"])
+    tune = st.selectbox("ECU Tune Level", ["None", "Mild", "Aggressive"])
+
+    st.markdown("---")
+    st.markdown("#### ⛽ Fuel & Environment")
+    fuel = st.selectbox("Fuel Octane / Type", ["87","91","93","E85"])
+    altitude = st.slider("Altitude (meters)", 0, 3000, 200)
+
+    st.markdown("---")
+    st.markdown('<div class="muted">Tip: The ML model uses a synthetic dataset — results are approximate and for educational/estimation use only.</div>', unsafe_allow_html=True)
+    st.markdown('</div>', unsafe_allow_html=True)
+
+# ---------------------------
+# Map categorical to numeric (for model input)
+# ---------------------------
 intake_map = {"Stock":0, "Cold Air":1, "Performance":2}
 exhaust_map = {"Stock":0, "Cat-back":1, "Straight Pipe":2}
-induction_map = {"None":0, "Turbo":1, "Supercharger":2}
+# collapse twin-turbo and twincharged to turbo/supercharger categories for model
+induction_model_map = {"None":0, "Turbo":1, "Twin-Turbo":1, "Supercharger":2, "Twincharged":2}
 fuel_map = {"87":0, "91":1, "93":2, "E85":3}
 tune_map = {"None":0, "Mild":1, "Aggressive":2}
 
-input_data = np.array([[
-    engine,
+input_for_model = np.array([[
+    engine_disp,
     cyl,
     base_hp,
-    intake_map[intake],
-    exhaust_map[exhaust],
-    induction_map[induction],
-    fuel_map[fuel],
-    tune_map[tune],
+    intake_map.get(intake,0),
+    exhaust_map.get(exhaust,0),
+    induction_model_map.get(induction,0),
+    fuel_map.get(fuel,0),
+    tune_map.get(tune,0),
     altitude
 ]])
 
-# Ensure input_data is a DataFrame for feature names if needed, but array works for scaling
-# X.columns is not accessible here, so use the trained scaler directly
-input_scaled = scaler.transform(input_data)
-pred = model.predict(input_scaled)[0]
+# Predict base gain from the trained model
+input_scaled = scaler.transform(input_for_model)
+pred_base = float(model.predict(input_scaled)[0])
 
-new_hp = base_hp + pred
-
-# --- OUTPUT SECTION ---
+# ---------------------------
+# Heuristic extra gains from new advanced params
+# (We add these on top of model prediction to reflect advanced bolt-ons)
+# ---------------------------
+# cam, headers, intake manifold contributions
+cam_gain_map = {"Stock":0.0, "Road":5.0, "Race":12.0}
+headers_gain_map = {"Stock":0.0, "Performance":6.0}
+intake_manifold_gain = {"Stock":0.0, "High-flow":4.0}
+intercooler_gain_map = {"None":0.0, "Air-to-Air":4.0, "Air-to-Water":6.5}
+turbo_size_map = {"N/A":0.0, "Shr. 45-50":2.5, "Small 50-60":6.0, "Medium 60-70":12.0, "Large 70+":20.0}
+
+cam_gain = cam_gain_map.get(cam, 0.0)
+headers_gain = headers_gain_map.get(headers, 0.0)
+intake_man_gain = intake_manifold_gain.get(intake_manifold, 0.0)
+intercooler_gain = intercooler_gain_map.get(intercooler, 0.0)
+turbo_size_gain = turbo_size_map.get(turbo_size, 0.0)
+
+# boost contribution: if induction present, boost * factor; twin turbo gives more but is captured by induction choice
+if induction in ["Turbo", "Twin-Turbo"]:
+    boost_gain = boost_psi * 1.9  # psi-to-hp rough factor for turbo setups (heuristic)
+elif induction in ["Supercharger", "Twincharged"]:
+    boost_gain = boost_psi * 1.4  # superchargers typically have different curve
+else:
+    boost_gain = 0.0
+
+# methanol injection
+meth_gain = 10.0 if meth else 0.0
+
+# exhaust diameter small effect (larger diameter -> small gain if engine can flow)
+exhaust_dia_gain = max(0.0, (exhaust_dia - 55) * 0.08)
+
+# combined extra heuristic
+extra_gain = (
+    cam_gain +
+    headers_gain +
+    intake_man_gain +
+    intercooler_gain +
+    turbo_size_gain +
+    boost_gain * 0.9 +   # scale down a bit to avoid massive overestimates
+    meth_gain +
+    exhaust_dia_gain
+)
+
+# final predicted gain: model base + heuristic extra
+pred_total_gain = pred_base + extra_gain
+new_hp = base_hp + pred_total_gain
+
+# account for realistic minimums
+pred_total_gain = max(pred_total_gain, -5.0)  # avoid negative crazy values
+new_hp = max(new_hp, 30.0)
+
+# power-to-weight (hp per ton)
+effective_weight = weight_kg * (1 - weight_reduction / 100.0)
+hp_per_ton = new_hp / (effective_weight / 1000.0)
 
-st.divider()
-st.subheader("🎯 Prediction Results")
+# ---------------------------
+# Right panel: Dashboard (macOS style cards)
+# ---------------------------
+with right:
+    st.markdown('<div class="frost">', unsafe_allow_html=True)
+    st.subheader("📊 Performance Dashboard")
+
+    # Top metrics
+    k1, k2, k3 = st.columns(3)
+    k1.metric("Estimated HP Gain", f"{pred_total_gain:.1f} HP")
+    k2.metric("New Estimated Horsepower", f"{new_hp:.1f} HP")
+    k3.metric("HP / Ton", f"{hp_per_ton:.1f}")
+
+    # Build quick summary chips
+    st.markdown(
+        f"""
+        <div style="margin-top:10px;">
+            <span class="chip">Engine: {engine_disp}L • {engine_config}</span>
+            <span class="chip">Intake: {intake}</span>
+            <span class="chip">Exhaust: {exhaust} ({exhaust_dia}mm)</span>
+            <span class="chip">Induction: {induction} • Boost: {boost_psi}psi</span>
+            <span class="chip">Tune: {tune}</span>
+            <span class="chip">Fuel: {fuel}</span>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
 
-# Use three columns for the key metrics for impact
-metric_col_1, metric_col_2, metric_col_3 = st.columns(3)
+    st.markdown("---")
 
-# Display estimated HP gain
-with metric_col_1:
-    st.metric(
-        label="🔥 Estimated HP Gain", 
-        value=f"{pred:.1f} HP",
-        delta=f"{(pred / base_hp * 100):.1f}% over base",
-        delta_color="normal" if pred > 0 else "inverse" # Green if gain, Red if loss
-    )
+    # small two-column charts & info
+    left_panel, right_panel = st.columns([1, 1])
 
-# Display new total HP
-with metric_col_2:
-    st.metric(
-        label="🏁 New Total Horsepower", 
-        value=f"{new_hp:.1f} HP"
-    )
+    with left_panel:
+        st.markdown('<div class="metric-card">', unsafe_allow_html=True)
+        st.write("Power Curve Snapshot")
+        st.bar_chart(
+            pd.DataFrame(
+                {"HP": [base_hp, base_hp + pred_base, new_hp]},
+                index=["Stock", "Model Gain", "Final"]
+            )
+        )
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    with right_panel:
+        st.markdown('<div class="metric-card">', unsafe_allow_html=True)
+        st.write("Tuning Contribution Breakdown")
+        breakdown = pd.DataFrame({
+            "component": ["Model base", "Cam", "Headers", "Intake Manifold", "Intercooler", "Turbo Size", "Boost", "Meth", "Exhaust Dia"],
+            "hp": [pred_base, cam_gain, headers_gain, intake_man_gain, intercooler_gain, turbo_size_gain, boost_gain * 0.9, meth_gain, exhaust_dia_gain]
+        })
+        st.dataframe(breakdown.style.format("{:.1f}").hide_index(), height=220)
+        st.markdown('</div>', unsafe_allow_html=True)
+
+    st.markdown("---")
+    # performance badge description
+    perf_text = "Balanced cruiser"
+    if pred_total_gain < 15:
+        perf_text = "Mild improvement — street friendly"
+    elif pred_total_gain < 50:
+        perf_text = "Noticeable power — spirited driving"
+    else:
+        perf_text = "Serious power — track-capable build"
+
+    st.markdown(f"### ⚡ Build verdict: **{perf_text}**")
+    st.write("Power-to-weight and HP gain are quick indicators — actual drivability depends on gearing, cooling, and reliability.")
+
+    st.markdown("<div class='muted'>Tip: This estimator combines a synthetic ML model plus simple heuristics for extra bolt-ons. For precise dyno numbers consult a professional tuner.</div>", unsafe_allow_html=True)
+
+    st.markdown("</div>", unsafe_allow_html=True)
 
-# Display a comparison chart
-with metric_col_3:
-    # A small area chart can be more dynamic than a bar chart for this comparison
-    chart_data = pd.DataFrame(
-        {"Horsepower": [base_hp, new_hp]},
-        index=["Base HP", "Modified HP"]
-    )
-    st.area_chart(chart_data)
+# ---------------------------
+# Optional: show dataset / debug
+# ---------------------------
+with st.expander("🔎 Peek training data & model info"):
+    st.write("Sample synthetic dataset (used to train the toy estimator):")
+    st.dataframe(df.head(10))
+    st.write("- Model: KNeighborsRegressor (distance weighted)")
+    st.write("- Additional bolt-on gains computed with lightweight heuristics")
+    st.write("- Use this for estimation and learning, not as a dyno replacement.")
 
+# ---------------------------
+# Footer
+# ---------------------------
+st.markdown(
+    """
+    <div style="margin-top:14px; text-align:center;">
+        <span class="muted">Made for learning — treat numbers as estimates. Enjoy tuning! 🍏</span>
+    </div>
+    """,
+    unsafe_allow_html=True
+)
 
-st.success(f"Prediction complete! Your **{base_hp} HP** car is estimated to be **{new_hp:.1f} HP** with these modifications.")
-st.caption("Disclaimer: This is a synthetic prediction based on a simplified model and generated data. Use for fun!")