Delete app.py

app.py

@@ -1,173 +0,0 @@
-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
-
-# ---------- data loading ----------
-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 (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'
-]
-
-# ---------- 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)
-        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']  # 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')
-
-# ---------- 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())
-            }
-    return m
-MAP = _map()
-
-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', [])
-
-# ---------- filtering & rec ----------
-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]
-    if sub.empty: return None
-    return sub.sort_values('popularity_score', ascending=False).iloc[0]
-
-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]
-    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_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 | "
-        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 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
-
-    # remove self if included
-    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_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")
-
-    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 _up(a,b):
-            t, y = trim_year(a,b); return t, y
-        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')
-
-        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():
-            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')
-
-        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]
-        )
-
-# IMPORTANT for Hugging Face Spaces: do NOT call demo.launch()
-demo
-# --- run locally AND in Spaces ---
-if __name__ == "__main__":
-    demo.queue().launch(server_name="0.0.0.0", server_port=7860)