Upload app.py

app.py

@@ -0,0 +1,113 @@
+
+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
+
+def load_df():
+    if os.path.exists('RideSearch_dataset.csv'):
+        return pd.read_csv('RideSearch_dataset.csv')
+    parts = sorted(glob.glob('RideSearch_part*_small.csv'))
+    if parts:
+        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.')
+
+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']
+
+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)
+        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']
+        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():
+    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())}
+    return m
+MAP = mapping()
+
+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):
+    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]
+
+def filt(df, body, fuel, yr_rng, price, 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['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")
+    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'])}★"
+    )
+
+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
+    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}'
+
+with gr.Blocks() as demo:
+    gr.Markdown('# RideSearch — Pick a car, get similar across brands')
+
+    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.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])
+
+        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():
+            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()