Amitchim/pachu-tlv-places

PachuMatch — tell us the vibe, we'll find your place in Tel Aviv

Final project · Intro to Data Science · Reichman University · Amit Chimya

🚀 Live app (HF Space)	Amitchim/pachu-match
📦 This dataset	11,228 synthetic Tel Aviv venues + embeddings + app config
🧠 Models	data & answers: Qwen/Qwen3-1.7B · search: BAAI/bge-small-en-v1.5

All venues in this dataset are fictional — generated by an AI model, not real businesses.

Contents: 1. Problem · 2. Synthetic data · 3. EDA (incl. AI mistakes) · 4. Embeddings & recommendation · 5. Generation (RAG) · 6. App · Files · Limitations · AI usage

---

1. The problem

Choosing where to go out in Tel Aviv usually starts from a situation, not a keyword: "somewhere quiet to work on my laptop in Neve Tzedek", "a place for a first date that isn't too loud", "a restaurant where my kids and my parents will both be happy". Map and review apps search by name, cuisine and rating — they don't understand vibe, occasion or who you're with, so the user scrolls through dozens of results.

PachuMatch takes a free-text request and returns:

1. the 3 most similar venues (semantic search with embeddings), and
2. one personal recommendation — a short AI-written explanation of why the top venue fits this request.

user request ──► bge-small embedding ──► FAISS search over 11,228 venues ──► top-3 cards
                       │                                                       │
                       └─► intent classifier (is this a food/drink request?)   └─► #1 venue facts ──► Qwen3-1.7B ──► "Our pick: … because …"

Modality: text → text (retrieval + generation). Why synthetic data: real venue data with rich vibe/occasion attributes is not openly available, so a structured synthetic catalog lets us control the attributes and evaluate the search automatically (we know the ground truth of every venue).

---

2. Synthetic data generation

Notebook: PachuMatch_1_Data_Generation.ipynb

• Model: Qwen/Qwen3-1.7B (Hugging Face, thinking mode off), temperature 0.8, top-p 0.95.
• Structured sampling: every record starts from a random profile (category, neighborhood, cuisine, price, vibe, good-for, features, kosher/vegan/outdoor/dog/late flags) with consistency rules. The model writes the text (name, tagline, description, signature item); the attributes stay as structured columns.
• Prompting: role prompt + 2 randomly sampled few-shot examples + strict JSON output.
• Validation: every answer was parsed; failures were logged by type.
• Prompt iteration: a 20-record pilot revealed a real restaurant name ("Sukiyabashi"), attribute words in names, overuse of "cozy/nestled", and invented opening hours → the prompt was updated before the full run.
• Mode collapse on names: in the full run more than half of the names were repeats of a few popular names. A first fix (random first letter + random inspiration word) was too strict and produced nonsense names ("vazim", "jumblebrick"). The final fix asked for 5 name options in a randomly sampled real Tel Aviv naming style (e.g. "Rina's Table", "Salt & Fig", "Gefen"), inspired by each venue's own signature item and description. original_name and name_regenerated keep this transparent.

---

3. EDA — including the AI mistakes we found

Notebook: PachuMatch_2_EDA.ipynb

Raw generated: 11,520 · valid JSON rate: 99.4% · final clean records: 11,228

Generation outcomes

error	records
valid	11449
tagline_too_long	63
invalid_json	7
no_json	1

AI mistakes found (automatic request-vs-answer checks)

	% of valid records
feature omitted	71.3
neighborhood missing	49.5
name violation	2.5
hallucinated detail	2.1
vibe contradiction	1.4
famous name	0.3
non english	0.1

Cleaning funnel

step	records
raw generated	11520
valid model answers	11449
unique names	11449
unique descriptions	11449
no vibe contradiction	11284
no famous names / non-English	11228

Contradiction check validation: the first rule (any opposite word) produced false positives such as "a lively cafe with a peaceful courtyard"; the final rule requires an opposite word AND no mention of the requested vibe.

Dropped: invalid answers, duplicates, vibe contradictions (misleading data is worse than missing data), famous real names, non-English text. Kept but flagged (flag_* columns): attribute words in names, omitted features, neighborhood not mentioned, invented hours/prices.

Other findings

• Word bias: filler words dominate ("perfect" in ~71% of descriptions). "cozy" appeared in 64% of venues where it was requested, but also in 37% where it was not — despite an explicit instruction to avoid it.
• Code-switching: a few descriptions contained Chinese words (Qwen is trained on a lot of Chinese text) — removed.
• Omissions: 12 attributes do not fit into 2-3 sentences, so yes/no features and the neighborhood are often not mentioned; the structured columns remain the source of truth (this matters again in section 4 — the ablation).

Columns

venue_id, name, tagline, description, signature_item, category, neighborhood, cuisine, price_level (1-4), vibe, good_for, features, kosher, vegan_friendly, outdoor_seating, dog_friendly, open_late, flag_*, name_regenerated, original_name, model, created_at

---

4. Embeddings & recommendation

Notebook: PachuMatch_3_Embeddings.ipynb

Text embedded per venue: name + tagline + description + structured attributes (category, cuisine, neighborhood, vibe, good-for, features, flags). Token length: median 159, max 204 → nothing truncated (model limit 512).

Evaluation: 300 synthetic user requests built from real venues (category + 2 attributes, paraphrased, e.g. "warm and intimate French bakery"). A venue counts as relevant if it satisfies all constraints of the request (median 71 relevant venues per request; a random pick would score P@3 ≈ 0.006).

model	params	encode 11K (GPU)	Precision@3	Hit@3	MRR@10
sentence-transformers/all-MiniLM-L6-v2	23M	22 s	0.421	0.717	0.587
BAAI/bge-small-en-v1.5 ✅	33M	42 s	0.427	0.723	0.621
sentence-transformers/all-mpnet-base-v2	110M	128 s	0.337	0.607	0.516

Winner: BAAI/bge-small-en-v1.5 — best on all metrics, trained specifically for retrieval (short query → longer document, with a query instruction), small enough for a CPU Space. The largest model was the worst: fit to the task beats size.

Robustness — Precision@3 by number of constraints in the request (100 requests per level):

constraints	MiniLM	bge-small	mpnet
1	0.887	0.860	0.743
2	0.623	0.670	0.587
3	0.450	0.493	0.437
4	0.260	0.257	0.213

bge wins at 2–3 constraints (the typical real request); differences at 1 and 4 are within noise. Precision falls sharply as constraints are added — one vector must summarize the whole request → future work: hybrid search (hard filters for exact fields + embeddings for vibe/occasion).

Ablation: name + description only → P@3 0.364; combined text → 0.427 (+17%). The structured attributes restore information the generated descriptions omitted (see the AI mistakes in section 3).

Sanity checks:

• Real requests (e.g. "Cafe in Neve Tzedek where I can work on my laptop" → 3/3 in Neve Tzedek and laptop-friendly). Weakest: requests needing details that are not attributes ("open kitchen").
• Unrelated request ("how to fix a flat bicycle tire") scores 0.47–0.48 vs 0.64–0.88 for real requests → a minimum-similarity floor (see section 6 for why this alone was not enough).
• Self-retrieval (description → its own venue) is only 57% @1. Investigation: not the query instruction (58.5% without it); mainly because venue vectors are built from the combined text (77.5% @1 against name+description vectors), plus near-twin generic descriptions. Kept the combined text because the app's task is need → venue, where it wins.
• t-SNE: venues cluster first by neighborhood, then by category inside each island.

Files: embeddings/venue_embeddings.npy (11,228 × 384, float32, normalized) · embeddings/venue_ids.csv (row order) · embeddings/venues.faiss (FAISS IndexFlatIP — exact search; inner product = cosine on normalized vectors).

---

5. Generation (RAG)

Notebook: PachuMatch_4_Generation.ipynb

The GenAI component is retrieval-augmented generation: the model only sees the request and the facts of the retrieved venue, so it explains a real catalog entry instead of inventing a place. All candidates are small Hugging Face models that can run on a CPU Space (no paid API → no MaaS needed).

Evaluation: 37 test requests (7 hand-written + 30 synthetic) with automatic checks — valid pick, no other venue name (hallucination), no invented numbers (hours/prices), English only, length; plus CPU time.

Iteration 1 — the model picks one of the 3 retrieved venues and explains:

model	all checks OK	pick relevant	CPU time / answer
Qwen/Qwen2.5-0.5B-Instruct	41%	57%	26.6 s
Qwen/Qwen3-0.6B	76%	57%	35.5 s
Qwen/Qwen3-1.7B	81%	63% (picked #1 in 95%)	89.5 s
baseline: always search result #1	–	63%	–

Findings: the model did not pick better than the search itself (it mostly chose #1 — position bias), it was too slow, and it hallucinated details ("rooftop views") or copied a hallucination from the dataset ("happy hour 4–6 PM"). Two checks were also wrong and were fixed: no_other_venue flagged venue names that are ordinary words inside a sentence (e.g. "Mediterranea" inside "Mediterranean") → whole-word matching + a common-word filter; a strict format check was dropped ("Our choice is…" is a fine answer).

Iteration 2 — the search picks #1, the model only explains it, from structured facts only (shorter prompt):

model	all checks OK	CPU total	first word (streamed)
Qwen/Qwen3-0.6B	97%	7.9 s	1.6 s
Qwen/Qwen3-1.7B ✅	100%	22.9 s	4.3 s

Decision: Qwen/Qwen3-1.7B — every answer passed the checks and the explanations were more tailored (0.6B often copied irrelevant facts). The extra time is hidden by streaming (text appears word by word) and cached Quick Starters. Settings: temperature 0.7, top-p 0.8, max 100 new tokens, thinking off. Safety net in the app: if an answer fails the checks, a template built from the venue's facts is shown instead.

Note: the introduction of notebook 4 describes the iteration-1 plan (the model picks among 3); iteration 2 changed this, as documented above and in the notebook's results.

The app reads its settings from app/generation_config.json (embedding model, query prompt, minimum score, generator model, system prompt, generation parameters); app/generation_eval.csv holds every evaluated answer.

---

6. The app (Gradio on a HF Space)

Notebook: PachuMatch_5_App.ipynb · Space: Amitchim/pachu-match

• Reads the dataset from this repo, the embedding model from its HF model repo (BAAI/bge-small-en-v1.5), and the generator from Qwen/Qwen3-1.7B; the embeddings files (venues.faiss, venue_ids.csv) are uploaded to the Space.
• 3 Quick Starters (cached after their first click): Romantic wine bar for a first date · Cafe in Neve Tzedek where I can work on my laptop · Mexican restaurant that's great for the whole family.
• UI: 3 venue cards appear in ~3–4 s, then the recommendation is streamed below them with a visible "AI is still writing…" indicator.

Out-of-scope requests: from a threshold to a classifier

User testing found that "trip to LA" returned restaurants. Calibrating the similarity threshold on 25 on-topic vs 20 off-topic hand-written requests showed the two distributions overlap (location words like "Jaffa" or "Florentin" make any request look similar) — the best threshold was only 80% correct.

Fix: an intent classifier — logistic regression on the same bge embeddings, trained on ~850 template-generated requests (470 in-scope / 382 out-of-scope) and tested on the 45 hand-written requests (held out; different nouns and cities):

	precision	recall
out-of-scope	1.000	0.950
in-scope	0.962	1.000

5-fold CV 0.988 · held-out accuracy 97.8% (vs 80% for the threshold) · only mistake: "how to cook pasta at home". Stored as 385 numbers in app/intent_classifier.json — the app needs no scikit-learn. A re-run reproduced the identical weights.

Deployment issues we hit (documented in notebook 5)

#	problem	cause	fix
1	HTTP 402 on CPU basic	HF stopped free Gradio hosting (July 2026)	HF PRO; tried ZeroGPU
2	startup crash	eager example caching ran with no GPU attached	cache_mode="lazy"
3	"No CUDA GPUs are available" on every request	intermittent ZeroGPU infrastructure error	graceful fallback text + switch to CPU basic
4	everything appeared at once	first hypothesis: CPU starvation (limited threads) — wrong	–
5	still at once, now ~80 s	logs: SSE stream 404 behind Gradio's SSR proxy	ssr_mode=False; thread limit removed
6	unclear progress (user feedback)	default indicator too subtle	custom "Searching… / AI is still writing… Ns" state

Final live check: cards ~4 s, full streamed answer 26 s on CPU basic; out-of-scope → "no good match"; empty → hint; logs clean.

---

Repository files

path	what
data/train-*.parquet	the 11,228 venues
PachuMatch_1_Data_Generation.ipynb … PachuMatch_5_App.ipynb	the 5 project notebooks (with outputs)
embeddings/	venue vectors, row order, FAISS index
app/generation_config.json	app settings (models, prompt, thresholds)
app/generation_eval.csv	generation evaluation (every answer + checks)
app/intent_classifier.json	logistic-regression weights for the intent gate
figures/	all charts in this card

---

Limitations & future work

• Synthetic data from a small model: descriptions can be generic and some instructions are ignored (see the flags). Attributes were sampled uniformly and features per category — not per neighborhood — so e.g. some inland venues have a "sea view". The distribution does not reflect the real Tel Aviv market.
• One vector per request loses precision with many constraints → hybrid search (hard filters + embeddings).
• Speed: a 1.7B model on a 2-vCPU Space takes ~20–30 s per full answer; streaming hides most of it, a GPU or a smaller model would cut it.
• Evaluation uses synthetic and hand-written requests, not real users; next step would be logging real requests and user feedback.

---

AI usage

• Hugging Face models (part of the product): Qwen/Qwen3-1.7B generated the dataset and writes the recommendations; BAAI/bge-small-en-v1.5 embeds venues and requests; all-MiniLM-L6-v2, all-mpnet-base-v2, Qwen2.5-0.5B-Instruct and Qwen3-0.6B were evaluated and not chosen.
• Claude (Anthropic) as a coding assistant, as allowed by the course AI policy: wrote most of the Python code in the notebooks and app.py.
• My part: the product idea and project management — problem framing, design and product decisions, running and checking every step, and testing the app.
• Verification: every number in this card comes from a notebook output; failed attempts are kept in the notebooks rather than deleted.