Update app.py

app.py

@@ -1,113 +1,391 @@
+# app_new.py — RideSearch (brand-correct trims, cross-brand, smart fallbacks, optional photos)
 
-import os, glob, numpy as np, pandas as pd
+import os, glob, urllib.parse
+import numpy as np
+import 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 & embeddings
+# =========================
 
 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.')
+    if not parts:
+        raise FileNotFoundError("Upload RideSearch_dataset.csv OR the 10 parts RideSearch_part*_small.csv.")
+    df = pd.concat([pd.read_csv(p) for p in parts], ignore_index=True)
+    df.to_csv('RideSearch_dataset.csv', index=False)
+    return df
 
 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_COLS = [
+    '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]
+    txt_ok = os.path.exists('emb_text.npy')
+    num_ok = os.path.exists('emb_num.npy')
+    if txt_ok and num_ok:
+        return np.load('emb_text.npy'), np.load('emb_num.npy')
+
+    from sentence_transformers import SentenceTransformer
+    m = SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')
+    texts = DF['text_record'].astype(str).tolist()
+    Etext = m.encode(texts, batch_size=256, show_progress_bar=True, normalize_embeddings=True)
+    Etext = np.asarray(Etext, dtype='float32'); np.save('emb_text.npy', Etext)
+
+    X = DF[NUM_COLS].copy()
+    if 'zero_to_100_kmh_s' in X.columns:
+        X['zero_to_100_kmh_s'] = -X['zero_to_100_kmh_s'].astype('float32')
+    Xs = StandardScaler().fit_transform(X.values.astype('float32'))
+    Enum = Xs.astype('float32'); np.save('emb_num.npy', Enum)
+    return Etext, Enum
+
+# ==========================================
+# Brand-correct trim display & alias mapping
+# ==========================================
+# Expand this list for the models you’ll demo.
+TRIM_CHOICES = {
+    ("BMW","3 Series"): ["320i","330i","330e","340i","M3"],
+    ("Audi","A3"): ["35 TFSI","40 TFSI","45 TFSI","S3","RS3"],
+    ("Audi","A4"): ["35 TFSI","40 TFSI","45 TFSI","S4","RS4"],
+    ("Mercedes-Benz","C-Class"): ["C200","C220d","C300","AMG C43","AMG C63"],
+    ("Lexus","IS"): ["IS 300","IS 350","IS 500 F SPORT"],
+    ("Toyota","Corolla"): ["L","LE","SE","XSE","GR"],
+    ("Honda","Civic"): ["LX","Sport","EX","Touring","Type R"],
+    ("Volkswagen","Golf"): ["Trendline","Comfortline","Highline","GTI","R"],
+    ("Hyundai","Elantra"): ["SE","SEL","Limited","N Line","N"],
+    ("Kia","Forte"): ["LX","S","EX","GT-Line","GT"],
+    ("Jeep","Wrangler"): ["Sport","Willys","Sahara","Rubicon","392"],
+    ("Land Rover","Defender"): ["90","110","130","X-Dynamic","V8"],
+    ("Mazda","Mazda3"): ["S","Select","Preferred","Premium","Turbo"],
+    ("Mitsubishi","Outlander"): ["ES","SE","SEL","Black Edition","PHEV"],
+    ("Nissan","Rogue"): ["S","SV","SL","Platinum"],
+    ("Peugeot","3008"): ["Active","Allure","GT","GT Pack"],
+    ("Porsche","911"): ["Carrera","Carrera S","GTS","Turbo","GT3"],
+    ("Ram","1500"): ["Tradesman","Big Horn","Laramie","Rebel","Limited"],
+    ("Renault","Clio"): ["Authentique","Expression","Dynamique","RS Line"],
+    ("Seat","Leon"): ["Reference","Style","FR","Cupra"],
+    ("Skoda","Octavia"): ["Active","Ambition","Style","RS"],
+    ("Subaru","Outback"): ["Base","Premium","Limited","Wilderness","Touring"],
+    ("Tesla","Model 3"): ["RWD","Long Range","Performance"],
+    ("Volkswagen","Tiguan"): ["S","SE","SEL","R-Line"],
+    ("Volvo","XC60"): ["Core","Plus","Ultimate","Polestar Engineered"],
+    ("Mini","Cooper"): ["Classic","Signature","Iconic","John Cooper Works"],
+}
+
+# Map display trims to dataset generic categories (Base/Sport/Premium/Performance).
+TRIM_ALIAS_TO_GENERIC = {
+    # BMW 3
+    "320i":"Base","330i":"Sport","330e":"Sport","340i":"Premium","M3":"Performance",
+    # Audi
+    "35 TFSI":"Base","40 TFSI":"Sport","45 TFSI":"Premium","S3":"Performance","RS3":"Performance",
+    "S4":"Performance","RS4":"Performance",
+    # Mercedes C
+    "C200":"Base","C220d":"Base","C300":"Premium","AMG C43":"Performance","AMG C63":"Performance",
+    # Lexus IS
+    "IS 300":"Base","IS 350":"Premium","IS 500 F SPORT":"Performance",
+    # Toyota Corolla
+    "L":"Base","LE":"Base","SE":"Sport","XSE":"Premium","GR":"Performance",
+    # Honda Civic
+    "LX":"Base","Sport":"Sport","EX":"Premium","Touring":"Premium","Type R":"Performance",
+    # VW
+    "Trendline":"Base","Comfortline":"Base","Highline":"Premium","GTI":"Performance","R":"Performance",
+    "S":"Base","SE":"Sport","SEL":"Premium","R-Line":"Performance",
+    # Hyundai Elantra
+    "SE":"Base","SEL":"Base","Limited":"Premium","N Line":"Sport","N":"Performance",
+    # Kia Forte
+    "LX":"Base","S":"Sport","EX":"Premium","GT-Line":"Sport","GT":"Performance",
+    # Jeep Wrangler
+    "Sport":"Base","Willys":"Sport","Sahara":"Premium","Rubicon":"Performance","392":"Performance",
+    # Land Rover Defender
+    "90":"Base","110":"Base","130":"Premium","X-Dynamic":"Premium","V8":"Performance",
+    # Mazda3
+    "S":"Base","Select":"Base","Preferred":"Premium","Premium":"Premium","Turbo":"Performance",
+    # Mitsubishi Outlander
+    "ES":"Base","SE":"Sport","SEL":"Premium","Black Edition":"Premium","PHEV":"Premium",
+    # Nissan Rogue
+    "SV":"Sport","SL":"Premium","Platinum":"Premium",
+    # Peugeot 3008
+    "Active":"Base","Allure":"Premium","GT":"Premium","GT Pack":"Premium",
+    # Porsche 911
+    "Carrera":"Base","Carrera S":"Premium","GTS":"Premium","Turbo":"Performance","GT3":"Performance",
+    # Ram 1500
+    "Tradesman":"Base","Big Horn":"Sport","Laramie":"Premium","Rebel":"Sport","Limited":"Premium",
+    # Renault Clio
+    "Authentique":"Base","Expression":"Sport","Dynamique":"Premium","RS Line":"Performance",
+    # Seat Leon
+    "Reference":"Base","Style":"Sport","FR":"Sport","Cupra":"Performance",
+    # Skoda Octavia
+    "Active":"Base","Ambition":"Sport","Style":"Premium","RS":"Performance",
+    # Subaru Outback
+    "Base":"Base","Premium":"Premium","Limited":"Premium","Wilderness":"Sport","Touring":"Premium",
+    # Tesla Model 3
+    "RWD":"Base","Long Range":"Premium","Performance":"Performance",
+    # Volvo XC60
+    "Core":"Base","Plus":"Premium","Ultimate":"Premium","Polestar Engineered":"Performance",
+    # Mini Cooper
+    "Classic":"Base","Signature":"Premium","Iconic":"Premium","John Cooper Works":"Performance",
+}
+
+def normalize_trim_for_query(make, model, display_trim):
+    if not display_trim:
+        return None
+    # If we know this (make, model), map its display name to a generic token
+    if (make, model) in TRIM_CHOICES and display_trim in TRIM_ALIAS_TO_GENERIC:
+        return TRIM_ALIAS_TO_GENERIC[display_trim]
+    return display_trim  # already generic or unknown model → pass through
+
+def generic_to_display(make, model, generic_trim):
+    """
+    Convert dataset generic trim -> a realistic display trim for that make/model.
+    If unknown, return the generic string unchanged.
+    """
+    if not generic_trim:
+        return ""
+    if (make, model) not in TRIM_CHOICES:
+        return str(generic_trim)
+    # pick the first display alias that maps back to this generic
+    for alias in TRIM_CHOICES[(make, model)]:
+        if TRIM_ALIAS_TO_GENERIC.get(alias) == generic_trim:
+            return alias
+    return str(generic_trim)
+
+# ==============================
+# Dropdowns, filters, formatting
+# ==============================
+
+def models_for(make):
+    if not make:
+        return gr.update(choices=[], value=None)
+    opts = sorted(DF.loc[DF['make'].eq(make), 'model'].dropna().unique().tolist())
+    return gr.update(choices=opts, value=None)
+
+def trim_year(make, model):
+    if make and model and (make, model) in TRIM_CHOICES:
+        trims = TRIM_CHOICES[(make, model)]
+    else:
+        sub = DF
+        if make:  sub = sub[sub['make'] == make]
+        if model: sub = sub[sub['model'] == model]
+        trims = sorted(sub['trim'].astype(str).dropna().unique().tolist())[:20]
+    if make and model:
+        years = sorted(
+            DF.loc[(DF['make'].eq(make)) & (DF['model'].eq(model)), 'year']
+              .dropna().astype(int).unique().tolist()
+        )
+    else:
+        years = []
+    return trims, years
 
-def filt(df, body, fuel, yr_rng, price, safety, rel):
+def on_model_change(make, model):
+    trims, years = trim_year(make, model)
+    return gr.update(choices=trims, value=None), gr.update(choices=years, value=None)
+
+def apply_filters(df, body, fuel, y_min, y_max, p_min, p_max, safety, reliab):
     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)]
+    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'] >= reliab)]
     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]
+def fmt_anchor(r):
+    disp_trim = generic_to_display(r['make'], r['model'], r['trim'])
+    return (f"**{r['make']} {r['model']} {disp_trim} {int(r['year'])}**  \n"
+            f"Body: {r['body_type']} • Fuel: {r['fuel']} • Engine: {r['engine_type']}  \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 • "
+            f"Reliability {int(r['reliability_score'])}/100 • Safety {int(r['safety_rating'])}★")
+
+# ==============
+# Photo helpers
+# ==============
+def placeholder_svg_data_uri(title):
+    # Clean inline SVG placeholder so we don't need internet or image hosting
+    txt = urllib.parse.quote(title)
+    svg = f"""<svg xmlns='http://www.w3.org/2000/svg' width='480' height='320'>
+      <rect width='100%' height='100%' fill='#e8eef7'/>
+      <text x='50%' y='50%' dominant-baseline='middle' text-anchor='middle'
+            font-family='Arial' font-size='26' fill='#223'>
+        {title}
+      </text>
+    </svg>"""
+    return "data:image/svg+xml;utf8," + urllib.parse.quote(svg)
+
+def build_gallery_html(df_rows):
+    # df_rows: pandas DataFrame with rows to render
+    cards = []
+    for _, r in df_rows.iterrows():
+        label = f"{r['make']} {r['model']} {generic_to_display(r['make'], r['model'], r['trim'])}"
+        if 'image_url' in r and isinstance(r['image_url'], str) and r['image_url'].strip():
+            img_src = r['image_url'].strip()
+        else:
+            img_src = placeholder_svg_data_uri(f"{r['make']} {r['model']}")
+        cards.append(f"""
+        <div style="width:240px;margin:6px;border:1px solid #ddd;border-radius:12px;overflow:hidden;background:#fff;">
+          <img src="{img_src}" style="width:240px;height:160px;object-fit:cover;display:block" />
+          <div style="padding:8px 10px;font:14px/1.3 Arial,sans-serif;color:#111">{label}</div>
+        </div>
+        """)
+    return f"<div style='display:flex;flex-wrap:wrap'>{''.join(cards)}</div>"
+
+# ===========================
+# Anchor selection & ranking
+# ===========================
+def anchor_row(make, model, trim_display, year):
+    trim_generic = normalize_trim_for_query(make, model, trim_display)
+    sub = DF.copy()
+    if make:  sub = sub[sub['make'] == make]
+    if model: sub = sub[sub['model'] == model]
+
+    def pick(df_): return None if df_.empty else df_.sort_values('popularity_score', ascending=False).iloc[0]
+
+    # 1) exact
+    exact = sub.copy()
+    if trim_generic: exact = exact[exact['trim'] == trim_generic]
+    if year:         exact = exact[exact['year'] == year]
+    if not exact.empty: return pick(exact)
+
+    # 2) same year (ignore trim)
+    if year:
+        y_only = sub[sub['year'] == year]
+        if not y_only.empty: return pick(y_only)
+
+    # 3) same trim (ignore year)
+    if trim_generic:
+        t_only = sub[sub['trim'] == trim_generic]
+        if not t_only.empty: return pick(t_only)
+
+    # 4) fallback
+    return pick(sub)
+
+def recommend(make, model, trim_display, year, topk, alpha,
+              body, fuel, y_min, y_max, p_min, p_max, safety, reliab,
+              cross_brand_only=True, exclude_same_model=True):
+    a = anchor_row(make, model, trim_display, year)
+    if a is None:
+        return "No match for that combo.", None, "", None
+
+    # candidate pool
+    pool = DF.copy()
+    if cross_brand_only:
+        pool = pool[pool['make'] != a['make']]
+    if exclude_same_model:
+        pool = pool[~((pool['make'] == a['make']) & (pool['model'] == a['model']))]
+
+    pool = apply_filters(pool, body, fuel, int(y_min), int(y_max), int(p_min), int(p_max), int(safety), int(reliab))
+    if pool.empty:
+        return "No cars after filters. Try widening year/price/safety.", None, "", None
+
+    Etext, Enum = ensure_emb()
+    idx_anchor = int(a.name)
+    cand_idx = pool.index.values
+    st = cosine_similarity(Etext[idx_anchor:idx_anchor+1], Etext[cand_idx])[0]
+    sn = cosine_similarity(Enum[idx_anchor:idx_anchor+1],  Enum[cand_idx])[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()
+
+    order = np.argsort(-s)
+    seen = set(); chosen = []
+    for j in order:
+        r = DF.loc[cand_idx[j]]
+        key = (r['make'], r['model'])
+        if key in seen: continue
+        seen.add(key); chosen.append(cand_idx[j])
+        if len(chosen) >= int(topk): break
+
+    if not chosen:
+        return "No recommendations found after constraints.", None, "", None
+
+    sel = DF.loc[chosen].copy()
+    # map generic -> display for table
+    sel['trim_display'] = sel.apply(lambda r: generic_to_display(r['make'], r['model'], r['trim']), axis=1)
+    sim_lookup = {cand_idx[j]: round(float(s[j])*100, 1) for j in order}
+    sel['similarity_%'] = sel.index.map(lambda k: sim_lookup.get(k, 0.0))
+
+    cols = [
+        'name','make','model','trim_display','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_%'
+    ]
+    note = (f"α = {float(alpha):.2f} (text ↔ numeric) • Cross-brand only = {cross_brand_only} "
+            f"• Exclude same model = {exclude_same_model}")
+    gallery = build_gallery_html(sel)
+
+    return fmt_anchor(a), sel[cols], note, gallery
+
+# ============
+# Gradio UI
+# ============
+def build_ui():
+    y_lo, y_hi = int(DF['year'].min()), int(DF['year'].max())
+    p_lo, p_hi = int(DF['price_usd'].min()), int(DF['price_usd'].max())
+
+    with gr.Blocks() as demo:
+        gr.Markdown("# RideSearch — cross-brand recommendations with real trims")
+
+        with gr.Tab("Pick & Recommend"):
+            with gr.Row():
+                mk = gr.Dropdown(sorted(DF['make'].dropna().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)
+            md.change(on_model_change, [mk, md], [tr, yr])
+
+            with gr.Row():
+                body = gr.Dropdown(['Any'] + sorted(DF['body_type'].dropna().unique().tolist()),
+                                   value='Any', label='Body')
+                fuel = gr.Dropdown(['Any'] + sorted(DF['fuel'].dropna().unique().tolist()),
+                                   value='Any', label='Fuel')
+
+            with gr.Row():
+                y_min = gr.Slider(y_lo, y_hi, value=y_lo, step=1, label='Year min')
+                y_max = gr.Slider(y_lo, y_hi, value=y_hi, step=1, label='Year max')
+
+            with gr.Row():
+                p_min = gr.Slider(p_lo, p_hi, value=p_lo, step=500, label='Price min (USD)')
+                p_max = gr.Slider(p_lo, p_hi, value=min(p_hi, 80000), step=500, label='Price max (USD)')
+
+            with gr.Row():
+                safety = gr.Slider(3, 5, value=4, step=1, label='Min Safety ★')
+                reliab = 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')
+
+            with gr.Row():
+                cross = gr.Checkbox(label="Cross-brand only", value=True)
+                xmodel = gr.Checkbox(label="Exclude same model family", value=True)
+
+            go = gr.Button("Recommend")
+            anchor_md = gr.Markdown()
+            table = gr.Dataframe(interactive=False)
+            note = gr.Markdown()
+            gallery = gr.HTML()
+
+            go.click(
+                recommend,
+                [mk, md, tr, yr, topk, alpha, body, fuel, y_min, y_max, p_min, p_max, safety, reliab, cross, xmodel],
+                [anchor_md, table, note, gallery]
+            )
+
+        gr.Markdown("Tip: If you don’t add images, you still get clean placeholders. "
+                    "Add an 'image_url' column to your CSV to show real photos.")
+
+    return demo
+
+demo = build_ui()
+
+if __name__ == "__main__":
+    demo.queue().launch(server_name="0.0.0.0", server_port=7860)