The Weekend Builder's Intensive

[out:json][timeout:25];
// all cafes in a small bounding box (south,west,north,east)
node["amenity"="cafe"](40.700,-74.020,40.730,-73.990);
out body;

import ollama

reply = ollama.chat(
    model="gemma3:12b",
    messages=[{"role": "user", "content": "Say hello in one short sentence."}],
)
print(reply["message"]["content"])

You are a data cleaner for Points of Interest (POIs).
For the raw record below, return ONE JSON object with these fields:
- name: cleaned business name (Title Case, no extra symbols)
- category: one of [cafe, restaurant, shop, pharmacy, bank, hotel, other]
- address: a single tidy line, or "" if unknown
- lat: number or null
- lon: number or null
- confidence: 0.0-1.0 — how sure YOU are this is correct and complete.
  Be calibrated: 0.9 means you'd be right ~9 times in 10.

Rules:
- Return JSON only. No commentary, no markdown.
- If a field is unknown, use "" or null. Do not invent data.

EXAMPLE INPUT:  {"nm":"joe's  COFFEE","type":"coffee shop","addr":"12 main st"}
EXAMPLE OUTPUT: {"name":"Joe's Coffee","category":"cafe","address":"12 Main St","lat":null,"lon":null,"confidence":0.78}

RAW RECORD:
<PASTE ONE RECORD HERE>

from pydantic import BaseModel
from typing import Optional
import ollama

class POI(BaseModel):
    name: str
    category: str
    address: str
    lat: Optional[float]
    lon: Optional[float]
    confidence: float

def extract_one(raw_record: str, prompt_template: str) -> POI:
    resp = ollama.chat(
        model="gemma3:12b",
        messages=[{"role": "user",
                   "content": prompt_template.replace("<PASTE ONE RECORD HERE>", raw_record)}],
        format=POI.model_json_schema(),   # enforce the shape
        options={"temperature": 0},        # consistent output
    )
    return POI.model_validate_json(resp["message"]["content"])

import json, csv
from poi_schema import POI, extract_one   # from 2.6

PROMPT = open("extraction_prompt.txt").read()   # from 2.5
THRESHOLD = 0.6                                   # tune later

def run(input_json_path, output_csv_path):
    raw = json.load(open(input_json_path))         # ingest
    records = raw.get("elements", raw)             # OSM uses "elements"
    kept, flagged = [], []

    for rec in records:
        try:
            poi = extract_one(json.dumps(rec), PROMPT)   # extract + score
        except Exception as e:
            flagged.append({"error": str(e), "record": rec})
            continue
        if poi.confidence >= THRESHOLD:
            kept.append(poi.model_dump())
        else:
            flagged.append(poi.model_dump())

    with open(output_csv_path, "w", newline="") as f:
        cols = ["name","category","address","lat","lon","confidence"]
        w = csv.DictWriter(f, fieldnames=cols)
        w.writeheader()
        for r in kept:
            w.writerow({k: r.get(k, "") for k in cols})

    print(f"Kept {len(kept)} POIs, flagged {len(flagged)} for review.")

if __name__ == "__main__":
    run("raw_pois.json", "pois.csv")

id,name,category,address,lat,lon
1,Joe's Coffee,cafe,12 Main St,40.71,-74.00
2,City Pharmacy,pharmacy,5 Oak Ave,40.72,-74.01
3,...

import pandas as pd

def norm(s):
    return str(s).strip().lower()

def evaluate(pred_csv, gold_csv):
    pred = pd.read_csv(pred_csv)
    gold = pd.read_csv(gold_csv)
    gold_names = set(norm(n) for n in gold["name"])
    pred_names = [norm(n) for n in pred["name"]]

    tp = sum(1 for n in pred_names if n in gold_names)
    fp = sum(1 for n in pred_names if n not in gold_names)
    fn = sum(1 for n in gold_names if n not in set(pred_names))

    precision = tp / (tp + fp) if (tp + fp) else 0
    recall    = tp / (tp + fn) if (tp + fn) else 0
    f1 = 2*precision*recall/(precision+recall) if (precision+recall) else 0

    print(f"Precision: {precision:.2f}")
    print(f"Recall:    {recall:.2f}")
    print(f"F1:        {f1:.2f}")
    return precision, recall, f1

if __name__ == "__main__":
    evaluate("pois.csv", "golden.csv")