Update app.py

app.py

@@ -1,9 +1,9 @@
-
 import os, glob, numpy as np, pandas as pd
 from sklearn.metrics.pairwise import cosine_similarity
 from sklearn.preprocessing import StandardScaler
-import gradio as gr, plotly.express as px
+import gradio as gr
 
+# ---------- data loading ----------
 def load_df():
     if os.path.exists('RideSearch_dataset.csv'):
         return pd.read_csv('RideSearch_dataset.csv')
@@ -12,102 +12,168 @@ def load_df():
         df = pd.concat([pd.read_csv(p) for p in parts], ignore_index=True)
         df.to_csv('RideSearch_dataset.csv', index=False)
         return df
-    raise FileNotFoundError('Upload dataset (parts or full) first.')
+    raise FileNotFoundError('Upload dataset (RideSearch_part*_small.csv) or RideSearch_dataset.csv')
 
 DF = load_df()
-NUM = ['horsepower','zero_to_100_kmh_s','seats','cargo_liters','price_usd','popularity_score','comfort_score','reliability_score','tech_score','ownership_cost_score','safety_rating']
 
+NUM = [
+    'horsepower','zero_to_100_kmh_s','seats','cargo_liters','price_usd',
+    'popularity_score','comfort_score','reliability_score','tech_score',
+    'ownership_cost_score','safety_rating'
+]
+
+# ---------- embeddings (lazy build if missing) ----------
 def ensure_emb():
     if not (os.path.exists('emb_text.npy') and os.path.exists('emb_num.npy')):
         from sentence_transformers import SentenceTransformer
         m = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
-        te = m.encode(DF['text_record'].astype(str).tolist(), batch_size=256, show_progress_bar=True, normalize_embeddings=True)
+        te = m.encode(
+            DF['text_record'].astype(str).tolist(),
+            batch_size=256, show_progress_bar=True, normalize_embeddings=True
+        )
         np.save('emb_text.npy', np.asarray(te, dtype='float32'))
-        X = DF[NUM].copy(); X['zero_to_100_kmh_s'] = -X['zero_to_100_kmh_s']
+        X = DF[NUM].copy()
+        X['zero_to_100_kmh_s'] = -X['zero_to_100_kmh_s']  # smaller time = better
         Xs = StandardScaler().fit_transform(X.values.astype('float32'))
         np.save('emb_num.npy', Xs.astype('float32'))
     return np.load('emb_text.npy'), np.load('emb_num.npy')
 
-def mapping():
+# ---------- dependent dropdown maps ----------
+def _map():
     m = {}
     for mk, g in DF.groupby('make'):
         m[mk] = {}
         for md, g2 in g.groupby('model'):
-            m[mk][md] = {'trims': sorted(g2['trim'].astype(str).unique().tolist())[:20], 'years': sorted(g2['year'].astype(int).unique().tolist())}
+            m[mk][md] = {
+                'trims': sorted(g2['trim'].astype(str).unique().tolist())[:20],
+                'years': sorted(g2['year'].astype(int).unique().tolist())
+            }
     return m
-MAP = mapping()
+MAP = _map()
+
+def models_for(mk):
+    # Return a UI update so older Gradio repopulates the choices
+    opts = sorted(MAP.get(mk, {}).keys()) if mk else []
+    return gr.update(choices=opts, value=None)
 
-def models_for(mk): return sorted(MAP.get(mk, {}).keys()) if mk else []
 def trim_year(mk, md):
     d = MAP.get(mk, {}).get(md, {})
     return d.get('trims', []), d.get('years', [])
 
-def anchor(mk, md, tr, yr):
+def _up(a, b):
+    trims, years = trim_year(a, b)
+    return gr.update(choices=trims, value=None), gr.update(choices=years, value=None)
+
+# ---------- helpers ----------
+def anchor_row(mk, md, tr, yr):
     sub = DF.copy()
     if mk: sub = sub[sub['make'] == mk]
     if md: sub = sub[sub['model'] == md]
     if tr: sub = sub[sub['trim'] == tr]
     if yr: sub = sub[sub['year'] == yr]
-    return None if sub.empty else sub.sort_values('popularity_score', ascending=False).iloc[0]
+    if sub.empty: return None
+    return sub.sort_values('popularity_score', ascending=False).iloc[0]
 
-def filt(df, body, fuel, yr_rng, price, safety, rel):
+def apply_filters(df, body, fuel, y_min, y_max, p_min, p_max, safety, rel):
     out = df.copy()
     if body != 'Any': out = out[out['body_type'] == body]
     if fuel != 'Any': out = out[out['fuel'] == fuel]
-    y0, y1 = yr_rng; p0, p1 = price
-    out = out[(out['year'] >= y0) & (out['year'] <= y1) & (out['price_usd'] >= p0) & (out['price_usd'] <= p1)]
+    out = out[(out['year'] >= y_min) & (out['year'] <= y_max)]
+    out = out[(out['price_usd'] >= p_min) & (out['price_usd'] <= p_max)]
     out = out[(out['safety_rating'] >= safety) & (out['reliability_score'] >= rel)]
     return out
 
-def fmt(r):
-    eff = (f"{int(r['city_mpg'])}-{int(r['highway_mpg'])} mpg" if pd.notna(r['city_mpg']) else f"{int(r['range_km'])} km range")
+def fmt_card(r):
+    eff = (f"{int(r['city_mpg'])}-{int(r['highway_mpg'])} mpg"
+           if pd.notna(r['city_mpg']) else f"{int(r['range_km'])} km range")
     return (
         f"**{r['name']}**\n"
         f"- Brand: {r['make']} | Body: {r['body_type']} | Fuel: {r['fuel']}\n"
-        f"- HP: {int(r['horsepower'])} | 0–100: {r['zero_to_100_kmh_s']} s | Price: ${int(r['price_usd']):,}\n"
-        f"- Popularity {int(r['popularity_score'])}/10 • Comfort {int(r['comfort_score'])}/10 • Reliability {int(r['reliability_score'])}/100 • Safety {int(r['safety_rating'])}★"
+        f"- HP: {int(r['horsepower'])} | 0–100: {r['zero_to_100_kmh_s']} s | "
+        f"Price: ${int(r['price_usd']):,}\n"
+        f"- Popularity {int(r['popularity_score'])}/10 • Comfort {int(r['comfort_score'])}/10 • "
+        f"Reliability {int(r['reliability_score'])}/100 • Safety {int(r['safety_rating'])}★"
     )
 
-def rec(mk, md, tr, yr, topk, alpha, body, fuel, yr_rng, price, safety, rel):
-    a = anchor(mk, md, tr, yr)
-    if a is None: return 'No match for that combo.', None, None
-    sub = filt(DF, body, fuel, yr_rng, price, safety, rel)
-    if sub.empty: return 'No cars after filters.', None, None
-    Et, En = ensure_emb(); idx = a.name; cand = sub.index.values
-    st = cosine_similarity(Et[idx:idx+1], Et[cand])[0]; sn = cosine_similarity(En[idx:idx+1], En[cand])[0]
-    s = float(alpha)*st + (1-float(alpha))*sn
+def recommend(mk, md, tr, yr, topk, alpha,
+              body, fuel, y_min, y_max, p_min, p_max, safety, rel):
+    a = anchor_row(mk, md, tr, yr)
+    if a is None:
+        return "No match for that combo.", None, None
+    sub = apply_filters(
+        DF, body, fuel, int(y_min), int(y_max), int(p_min), int(p_max), int(safety), int(rel)
+    )
+    if sub.empty:
+        return "No cars after filters.", None, None
+
+    Et, En = ensure_emb()
+    idx = int(a.name)
+    cand = sub.index.values
+    st = cosine_similarity(Et[idx:idx+1], Et[cand])[0]
+    sn = cosine_similarity(En[idx:idx+1], En[cand])[0]
+    s = float(alpha) * st + (1 - float(alpha)) * sn
+
     import numpy as np
-    if idx in cand: s[np.where(cand==idx)[0][0]] = -1
-    order = np.argsort(-s)[:topk]; sel = DF.loc[cand[order]].copy(); sel['similarity_%'] = (s[order]*100).round(1)
-    cols = ['name','make','model','trim','year','body_type','fuel','engine_type','price_usd','horsepower','zero_to_100_kmh_s','popularity_score','comfort_score','reliability_score','tech_score','ownership_cost_score','safety_rating','similarity_%']
-    return fmt(a), sel[cols], f'α={alpha:.2f}'
+    if idx in cand:
+        s[np.where(cand == idx)[0][0]] = -1
+
+    order = np.argsort(-s)[:topk]
+    sel = DF.loc[cand[order]].copy()
+    sel['similarity_%'] = (s[order]*100).round(1)
+
+    cols = ['name','make','model','trim','year','body_type','fuel','engine_type',
+            'price_usd','horsepower','zero_to_100_kmh_s',
+            'popularity_score','comfort_score','reliability_score','tech_score',
+            'ownership_cost_score','safety_rating','similarity_%']
+    return fmt_card(a), sel[cols], f"α = {alpha:.2f} (text ↔ numeric)"
 
+# ---------- UI (no RangeSlider; use min/max sliders) ----------
 with gr.Blocks() as demo:
-    gr.Markdown('# RideSearch — Pick a car, get similar across brands')
+    gr.Markdown("# RideSearch — pick a car, get similar across brands")
 
-    with gr.Tab('Pick & Recommend'):
+    with gr.Tab("Pick & Recommend"):
         with gr.Row():
-            mk = gr.Dropdown(sorted(DF['make'].unique().tolist()), label='Make')
-            md = gr.Dropdown([], label='Model')
-            tr = gr.Dropdown([], label='Trim (optional)')
-            yr = gr.Dropdown([], label='Year (optional)')
+            mk = gr.Dropdown(sorted(DF['make'].unique().tolist()), label="Make", value=None)
+            md = gr.Dropdown([], label="Model", value=None)
+            tr = gr.Dropdown([], label="Trim (optional)", value=None)
+            yr = gr.Dropdown([], label="Year (optional)", value=None)
         mk.change(models_for, mk, md)
-        def _u(a,b): t,y = trim_year(a,b); return t,y
-        md.change(_u, [mk,md], [tr,yr])
+        md.change(_up, [mk, md], [tr, yr])
+
+        ylo, yhi = int(DF['year'].min()), int(DF['year'].max())
+        plo, phi = int(DF['price_usd'].min()), int(DF['price_usd'].max())
 
         with gr.Row():
             body = gr.Dropdown(['Any']+sorted(DF['body_type'].unique().tolist()), value='Any', label='Body')
             fuel = gr.Dropdown(['Any']+sorted(DF['fuel'].unique().tolist()), value='Any', label='Fuel')
-            yr_rng = gr.RangeSlider(int(DF['year'].min()), int(DF['year'].max()), value=[int(DF['year'].min()), int(DF['year'].max())], step=1, label='Year range')
+
+        with gr.Row():
+            y_min = gr.Slider(ylo, yhi, value=ylo, step=1, label='Year min')
+            y_max = gr.Slider(ylo, yhi, value=yhi, step=1, label='Year max')
+
+        with gr.Row():
+            p_min = gr.Slider(plo, phi, value=plo, step=500, label='Price min (USD)')
+            p_max = gr.Slider(plo, phi, value=min(phi, 60000), step=500, label='Price max (USD)')
+
         with gr.Row():
-            price = gr.RangeSlider(int(DF['price_usd'].min()), int(DF['price_usd'].max()), value=[int(DF['price_usd'].min()), min(int(DF['price_usd'].max()),60000)], step=500, label='Price (USD)')
             safety = gr.Slider(3,5,value=4,step=1,label='Min Safety ★')
             rel = gr.Slider(55,99,value=70,step=1,label='Min Reliability')
+
         with gr.Row():
             topk = gr.Slider(1,10,value=5,step=1,label='Recommendations')
             alpha = gr.Slider(0,1,value=0.7,step=0.05,label='α — Text vs Numeric')
-        btn = gr.Button('Recommend')
-        a = gr.Markdown(); recs = gr.Dataframe(interactive=False); note = gr.Markdown()
-        btn.click(rec, [mk,md,tr,yr,topk,alpha,body,fuel,yr_rng,price,safety,rel], [a,recs,note])
 
-demo.launch()
+        go = gr.Button("Recommend")
+        anchor_md = gr.Markdown()
+        table = gr.Dataframe(interactive=False)
+        note = gr.Markdown()
+
+        go.click(
+            recommend,
+            [mk,md,tr,yr,topk,alpha,body,fuel,y_min,y_max,p_min,p_max,safety,rel],
+            [anchor_md, table, note]
+        )
+
+# Works locally and on Spaces:
+if __name__ == "__main__":
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860)