Add OpenDB_Compliments_Merged folder with 11 files

OpenDB_Compliments_Merged/.gitattributes

@@ -0,0 +1,60 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.avro filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mds filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+# Video files - compressed
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.webm filter=lfs diff=lfs merge=lfs -text

OpenDB_Compliments_Merged/README.md

@@ -0,0 +1,61 @@
+---
+language:
+- en
+- fr
+license: mit
+task_categories:
+- text-classification
+- tabular-classification
+tags:
+- grocery
+- deduplication
+- retail
+- food
+pretty_name: Bilingual Grocery Product Deduplication
+---
+
+# Bilingual Grocery Product Deduplication Dataset
+
+## Dataset Summary
+This dataset contains a fully deduplicated, canonical list of bilingual (English and French) grocery products. The original raw data consisted of noisy grocery inventory records with varying formats, typos, languages, and branding.
+
+This repository provides the final cleaned dataset, the mapping of raw barcodes to canonical IDs, and a side-by-side comparison file to review the deduplication results. The deduplication was performed using a high-precision "Name-First" architecture combining token-overlap heuristics, multilingual embeddings, and Large Language Model (LLM) reasoning.
+
+## File Structure
+
+| File | Description |
+|---|---|
+| `canonical_products.parquet` | The clean, deduplicated database of the 1,109 unique canonical products, complete with averaged nutritional data. |
+| `product_mapping.parquet` | The lookup table mapping every original 13-digit barcode (`code`) to its new `canonical_product_id`. |
+| `deduplicated_comparison.csv` | A flat, human-readable CSV that joins the original data side-by-side with the new canonical groupings. Excellent for human review of the "before and after" state. |
+| `Deduplication_Pipeline_Documentation.docx` | Comprehensive documentation outlining the v3 pipeline architecture, the modifier vetoes, the LLM usage, and final metrics. |
+| `preprocess.py` | Phase 1 of the pipeline: Strict text normalization, cleaning, and exact-matching. Drops unnamed rows. |
+| `candidate_gen.py` | Phase 2 of the pipeline: Generates fuzzy-match candidate pairs using a 0.65 Jaccard overlap threshold, bilingual embeddings, and applies hardcoded Modifier/Ingredient Vetoes. |
+| `llm_grouper.py` | Phase 3 of the pipeline: Feeds the surviving ambiguous clusters to the LLM for atomic, semantic grouping to prevent chain-merging. |
+| `llm_utils.py` | A custom LLM load balancer that routes requests between Groq, OpenRouter, NVIDIA, and Ollama, handling rate limits and JSON parsing. |
+| `generate_outputs.py` | Phase 4 of the pipeline: Reads the final canonical JSON and builds the resulting Parquet and CSV dataset files. |
+
+## Methodology (The v3 "Name-First" Architecture)
+
+The dataset was constructed using a highly defensive deduplication pipeline designed to prioritize precision over recall (i.e., strictly avoiding the merging of different flavours, heat levels, or base ingredients).
+
+1. **Phase 1: Strict Normalization & Exact Match**
+   - Stripped brand prefixes (e.g., "Compliments", "Sensations").
+   - Fixed French encoding artifacts and normalized casing/plurals.
+   - Grouped all exact textual matches automatically. Unnamed barcode rows were intentionally dropped from the deduplication pool to prevent nutrition-based pollution.
+
+2. **Phase 2: High-Confidence Candidate Generation & Vetoes**
+   - Pairs were generated using a strict **Jaccard Token Overlap** threshold (≥ 0.65). 
+   - Multilingual embeddings (`paraphrase-multilingual-MiniLM-L12-v2`) were selectively applied *only* to cross-language (English ↔ French) pairs.
+   - **Modifier Veto:** Before any candidate was approved, it passed through a rigorous check against hardcoded lists of flavours, heat levels, fat percentages, and core ingredient nouns. E.g., If a candidate pair consisted of *Cherry Jelly Powder* and *Lime Jelly Powder*, the flavour mismatch triggered an auto-veto.
+
+3. **Phase 3: Group-Based LLM Judging**
+   - Surviving ambiguous candidates were clustered into connected components.
+   - These small clusters were passed to an LLM (Llama 3.3 70B / Llama 3.1 8B). The LLM evaluated entire groups atomically to explicitly prevent transitive chain-merging (where A=B and B=C incorrectly causes A=C).
+
+## Results
+- **Original Dataset:** 2,078 rows (1,322 named products, 756 unnamed)
+- **Final Canonical Products:** 1,109
+- **Safe Deduplication Rate:** 46.6% (on named products)
+
+The pipeline successfully resolved complex typos (e.g., *Two Bite Brownines* -> *TWO-BITE Brownies*) and bilingual equivalents (e.g., *Fromage Cottage* -> *Cottage Cheese*), while successfully isolating specific product varieties (e.g., separating *Lemon Lime Sparkling Water* from *Orange Sparkling Water*).

OpenDB_Compliments_Merged/candidate_gen.py

@@ -0,0 +1,197 @@
+import json
+import re
+from collections import defaultdict
+import numpy as np
+from fastembed import TextEmbedding
+
+# ── Configuration ────────────────────────────────────────────────────────────
+JACCARD_THRESHOLD = 0.65
+EMBEDDING_THRESHOLD = 0.88
+
+STOPWORDS = {'and','with','de','du','le','la','les','des','au','aux','et','en',
+             'une','un','a','the','in','of','from','for','to','by','no','not',
+             '%','g','ml','kg','l','oz','lb','pack','pkg','box','bag','can'}
+
+FRENCH_MARKERS = ['de ', 'du ', 'le ', 'la ', 'les ', 'des ', 'au ', 'aux ', 'et ', 'en ',
+                  'une ', 'un ', 'avec ', 'sans ', 'beurre', 'fromage', 'lait', 'poulet',
+                  'boeuf', 'porc', 'canneberge', 'fraise', 'framboise', 'citron', 'pomme',
+                  'crème', 'sauce', 'soupe', 'bouillon', 'vinaigre', 'moutarde', 'chocolat',
+                  'noir', 'suisse', 'amande', 'noix', 'mélange', 'riz', 'thon', 'séchée', 'pain']
+
+MODIFIER_CATEGORIES = {
+    'FLAVOUR': {'cherry', 'lime', 'lemon', 'orange', 'raspberry', 'strawberry', 'blueberry',
+                'mango', 'peach', 'grape', 'apple', 'pineapple', 'coconut', 'vanilla', 'chocolate',
+                'caramel', 'maple', 'honey', 'garlic', 'herb', 'original', 'plain', 'cinnamon',
+                'ginger', 'mint', 'limeade', 'tangerine', 'blackberry', 'watermelon', 'cranberry',
+                'banana', 'hazelnut', 'almond', 'mocha', 'cola', 'root', 'cream'},
+    'HEAT':    {'hot', 'spicy', 'mild', 'medium', 'sweet', 'smoky'},
+    'SALT':    {'salted', 'unsalted', 'salt free', 'low sodium', 'no salt', 'reduced sodium'},
+    'FAT':     {'lean', 'extra lean', 'skim', 'whole', '1%', '2%', '3.25%', '5%', '7%', '14%', '18%',
+                'light', 'low fat', 'fat free', 'reduced fat', 'full fat'},
+    'DIET':    {'diet', 'sugar free', 'zero', 'decaf', 'caffeine free'},
+    'SIZE':    {'mini', 'large', 'extra large', 'medium', 'small', 'jumbo', 'thin', 'thick'},
+    'PROCESS': {'dark', 'milk', 'white', 'semi sweet', 'artificial', 'real', 'pure'},
+    'TEXTURE': {'smooth', 'crunchy', 'chunky', 'sliced', 'whole', 'diced', 'crushed', 'shredded',
+                'grated', 'minced', 'ground', 'halves', 'pieces', 'strips', 'sticks', 'flaked'},
+}
+
+MODIFIER_MAP = {}
+for cat, words in MODIFIER_CATEGORIES.items():
+    for w in words:
+        MODIFIER_MAP[w] = cat
+
+INGREDIENT_NOUNS = {
+    'chicken', 'turkey', 'beef', 'pork', 'lamb', 'fish', 'tuna', 'salmon', 'shrimp', 'cod', 'pollock', 'sole',
+    'canola', 'sunflower', 'sesame', 'olive', 'coconut', 'avocado',
+    'cheddar', 'mozzarella', 'havarti', 'swiss', 'asiago', 'parmesan', 'feta', 'goat',
+    'almond', 'cashew', 'peanut', 'walnut', 'pecan', 'pistachio',
+    'kidney', 'black', 'navy', 'chickpea', 'lentil',
+    'rice', 'wheat', 'oat', 'corn', 'barley', 'rye',
+    'strawberry', 'cherry', 'lemon', 'lime', 'orange', 'raspberry', 'blueberry', 'blackberry', 'cranberry',
+    'tomato', 'carrot', 'pea', 'spinach', 'broccoli', 'mushroom',
+}
+
+
+def tokenize(s):
+    # s is already normalized from Phase 1, just split and remove stopwords
+    tokens = s.split()
+    return [t for t in tokens if t not in STOPWORDS and len(t) > 1]
+
+def get_modifiers(tokens):
+    result = defaultdict(list)
+    for t in tokens:
+        if t in MODIFIER_MAP:
+            result[MODIFIER_MAP[t]].append(t)
+    return dict(result)
+
+def modifier_veto(tokens_a, tokens_b):
+    mods_a = get_modifiers(tokens_a)
+    mods_b = get_modifiers(tokens_b)
+    
+    # 1. Check modifier categories
+    for cat in set(mods_a) & set(mods_b):
+        vals_a = set(mods_a[cat])
+        vals_b = set(mods_b[cat])
+        if vals_a != vals_b:
+            return True, f"Differ on {cat}: {vals_a} vs {vals_b}"
+            
+    # 2. Check ingredient nouns
+    ing_a = {t for t in tokens_a if t in INGREDIENT_NOUNS}
+    ing_b = {t for t in tokens_b if t in INGREDIENT_NOUNS}
+    if ing_a and ing_b and ing_a != ing_b:
+        return True, f"Differ on INGREDIENT: {ing_a} vs {ing_b}"
+        
+    return False, ""
+
+def is_french(name):
+    nl = name.lower()
+    return any(m in nl for m in FRENCH_MARKERS)
+
+def run_phase_2_candidate_gen():
+    print("Loading named_groups.json...")
+    with open('named_groups.json', 'r', encoding='utf-8') as f:
+        groups = json.load(f)
+        
+    names = [g['normalized_key'] for g in groups]
+    tokenized = {n: tokenize(n) for n in names}
+    is_fr = {n: is_french(n) for n in names}
+    
+    print(f"Total unique names: {len(names)}")
+    
+    edges = set()
+    
+    # ── PASS A: Jaccard (Same Language / General) ────────────────────────────
+    print("Running Pass A: Jaccard similarity...")
+    jaccard_candidates = 0
+    vetoed = 0
+    for i in range(len(names)):
+        for j in range(i + 1, len(names)):
+            na, nb = names[i], names[j]
+            ta, tb = tokenized[na], tokenized[nb]
+            
+            if not ta or not tb: continue
+            
+            inter = set(ta) & set(tb)
+            union = set(ta) | set(tb)
+            j = len(inter) / len(union) if union else 0
+            
+            if j >= JACCARD_THRESHOLD:
+                jaccard_candidates += 1
+                is_vetoed, _ = modifier_veto(ta, tb)
+                if not is_vetoed:
+                    edges.add((na, nb))
+                else:
+                    vetoed += 1
+                    
+    print(f"  Jaccard >= {JACCARD_THRESHOLD} pairs: {jaccard_candidates}")
+    print(f"  Vetoed by modifiers: {vetoed}")
+    print(f"  Jaccard pairs accepted: {jaccard_candidates - vetoed}")
+    
+    # ── PASS B: Bilingual Embeddings ──────────────────────────────────────────
+    print("\nRunning Pass B: Bilingual Embeddings...")
+    cross_lang_pairs = [(i, j) for i in range(len(names)) for j in range(i + 1, len(names))
+                        if is_fr[names[i]] != is_fr[names[j]]]
+                        
+    print(f"  Identified {len(cross_lang_pairs)} cross-language pairs to test.")
+    
+    if cross_lang_pairs:
+        print("  Generating embeddings (fastembed)...")
+        model = TextEmbedding("sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")
+        embeddings = np.array(list(model.embed(names)))
+        # Normalize embeddings to calculate cosine similarity via dot product
+        norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
+        embeddings = embeddings / norms
+        
+        bilingual_accepted = 0
+        for i, j in cross_lang_pairs:
+            na, nb = names[i], names[j]
+            sim = np.dot(embeddings[i], embeddings[j])
+            
+            if sim >= EMBEDDING_THRESHOLD:
+                # Add without English modifier veto (because one is French)
+                edges.add((na, nb))
+                bilingual_accepted += 1
+                
+        print(f"  Bilingual pairs accepted (sim >= {EMBEDDING_THRESHOLD}): {bilingual_accepted}")
+
+    # ── Connected Components ──────────────────────────────────────────────────
+    print("\nBuilding candidate clusters (Connected Components)...")
+    
+    adj = defaultdict(set)
+    for u, v in edges:
+        adj[u].add(v)
+        adj[v].add(u)
+        
+    visited = set()
+    clusters = []
+    
+    for node in names:
+        if node not in visited and node in adj:
+            cluster = set()
+            stack = [node]
+            while stack:
+                curr = stack.pop()
+                if curr not in cluster:
+                    cluster.add(curr)
+                    stack.extend(adj[curr] - cluster)
+            visited.update(cluster)
+            clusters.append(sorted(list(cluster)))
+            
+    # Add isolated nodes as their own cluster of 1 (so they aren't lost)
+    for node in names:
+        if node not in visited:
+            clusters.append([node])
+            
+    print(f"Total clusters for LLM: {len(clusters)}")
+    multi_clusters = [c for c in clusters if len(c) > 1]
+    print(f"  Singletons: {len(clusters) - len(multi_clusters)}")
+    print(f"  Multi-item clusters (need judging): {len(multi_clusters)}")
+    
+    # Save the clusters
+    with open('candidate_clusters.json', 'w', encoding='utf-8') as f:
+        json.dump(clusters, f, indent=2, ensure_ascii=False)
+        
+    print("Saved candidate_clusters.json")
+
+if __name__ == "__main__":
+    run_phase_2_candidate_gen()

OpenDB_Compliments_Merged/canonical_products.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cbd92ffe6f14e449d65e027d32ba94069ff7367083727d9eb9c597c82bdf14a8
+size 28351

OpenDB_Compliments_Merged/generate_outputs.py

@@ -0,0 +1,147 @@
+"""
+generate_outputs.py — Phase 4: Output Generation
+
+Reads:   final_groups.json
+         original.parquet (read-only, for original product names)
+Writes:  canonical_products.parquet   — deduplicated product list
+         product_mapping.parquet      — every code → canonical_product_id
+         deduplicated_comparison.csv  — side-by-side view for human review
+"""
+
+import json
+import pandas as pd
+
+FINAL_IN       = "final_groups.json"
+ORIGINAL_IN    = "original.parquet"
+CANON_OUT      = "canonical_products.parquet"
+MAPPING_OUT    = "product_mapping.parquet"
+COMPARISON_OUT = "deduplicated_comparison.csv"
+
+
+def main():
+    print(f"Loading {FINAL_IN}...")
+    with open(FINAL_IN, "r", encoding="utf-8") as f:
+        final_groups: list = json.load(f)
+    print(f"  {len(final_groups)} canonical groups")
+
+    print(f"Loading {ORIGINAL_IN}...")
+    df_orig = pd.read_parquet(ORIGINAL_IN)
+    print(f"  {len(df_orig)} original rows")
+
+    # ── Build canonical_products table ─────────────────────────────────────────
+    canonical_rows = []
+    mapping_rows   = []
+
+    for cid, group in enumerate(final_groups, start=1):
+        canon_name = group["canonical_name"]
+        nutr       = group.get("avg_nutrition", {})
+        num_codes  = len(group.get("codes", []))
+
+        canonical_rows.append({
+            "canonical_product_id": cid,
+            "canonical_name"      : canon_name,
+            "num_codes"           : num_codes,
+            "energy_kcal_100g"    : nutr.get("energy_kcal_100g"),
+            "fat_100g"            : nutr.get("fat_100g"),
+            "proteins_100g"       : nutr.get("proteins_100g"),
+            "sugars_100g"         : nutr.get("sugars_100g"),
+            "carbohydrates_100g"  : nutr.get("carbohydrates_100g"),
+        })
+
+        for code in group["codes"]:
+            mapping_rows.append({
+                "code"                : str(code),
+                "canonical_product_id": cid,
+                "canonical_name"      : canon_name,
+            })
+
+    df_canon   = pd.DataFrame(canonical_rows)
+    df_mapping = pd.DataFrame(mapping_rows)
+
+    # ── Integrity check ────────────────────────────────────────────────────────
+    print("\nRunning integrity checks...")
+    orig_codes = set(df_orig["code"].astype(str))
+    map_codes  = set(df_mapping["code"])
+
+    missing_in_map  = orig_codes - map_codes
+    extra_in_map    = map_codes - orig_codes
+    duplicate_codes = df_mapping[df_mapping.duplicated("code", keep=False)]
+
+    if missing_in_map:
+        print(f"  ⚠️  {len(missing_in_map)} original codes NOT in mapping!")
+    else:
+        print("  ✅ All original codes present in mapping.")
+
+    if extra_in_map:
+        print(f"  ⚠️  {len(extra_in_map)} extra codes in mapping (not in original)!")
+    else:
+        print("  ✅ No extra codes in mapping.")
+
+    if len(duplicate_codes) > 0:
+        print(f"  ⚠️  {len(duplicate_codes)} duplicate codes found in mapping!")
+    else:
+        print("  ✅ All codes in mapping are unique.")
+
+    # ── Save parquets ─────────────────────────────────────────────────────────
+    df_canon.to_parquet(CANON_OUT, index=False)
+    df_mapping.to_parquet(MAPPING_OUT, index=False)
+    print(f"\n  Saved → {CANON_OUT}  ({len(df_canon)} canonical products)")
+    print(f"  Saved → {MAPPING_OUT}  ({len(df_mapping)} code mappings)")
+
+    # ── Build comparison CSV ───────────────────────────────────────────────────
+    # Join original data with mapping
+    df_orig_str = df_orig.copy()
+    df_orig_str["code"] = df_orig_str["code"].astype(str)
+
+    df_comparison = df_orig_str.merge(df_mapping[["code", "canonical_product_id", "canonical_name"]], on="code", how="left")
+
+    # Parse nutriments JSON to flat columns for the CSV
+    import json as _json
+
+    def get_nutr_val(nutr_json, key):
+        if not nutr_json or pd.isna(nutr_json):
+            return None
+        try:
+            d = _json.loads(nutr_json)
+            return d.get(key)
+        except Exception:
+            return None
+
+    df_comparison["energy_kcal_100g"] = df_comparison["nutriments"].apply(lambda x: get_nutr_val(x, "energy-kcal_100g"))
+    df_comparison["fat_100g"]         = df_comparison["nutriments"].apply(lambda x: get_nutr_val(x, "fat_100g"))
+    df_comparison["proteins_100g"]    = df_comparison["nutriments"].apply(lambda x: get_nutr_val(x, "proteins_100g"))
+    df_comparison["sugars_100g"]      = df_comparison["nutriments"].apply(lambda x: get_nutr_val(x, "sugars_100g"))
+
+    # Select & order columns for readability
+    csv_cols = [
+        "canonical_product_id",
+        "canonical_name",
+        "product_name",        # original messy name
+        "code",
+        "brand",
+        "serving_size",
+        "energy_kcal_100g",
+        "fat_100g",
+        "proteins_100g",
+        "sugars_100g",
+    ]
+    df_csv = df_comparison[csv_cols].sort_values(["canonical_name", "product_name"])
+    df_csv.to_csv(COMPARISON_OUT, index=False, encoding="utf-8-sig")
+    print(f"  Saved → {COMPARISON_OUT}  ({len(df_csv)} rows)")
+
+    # ── Print summary ─────────────────────────────────────────────────────────
+    print("\n=== FINAL RESULTS ===")
+    print(f"Original rows          : {len(df_orig)}")
+    print(f"Canonical products     : {len(df_canon)}")
+    reduction = (1 - len(df_canon) / len(df_orig)) * 100
+    print(f"Deduplication rate     : {reduction:.1f}%")
+    print()
+    print("Top 10 largest groups:")
+    top10 = df_canon.sort_values("num_codes", ascending=False).head(10)
+    print(top10[["canonical_name", "num_codes"]].to_string(index=False))
+
+    print("\n✅ Phase 4 complete. All outputs generated.")
+
+
+if __name__ == "__main__":
+    main()

OpenDB_Compliments_Merged/llm_grouper.py

@@ -0,0 +1,137 @@
+import json
+import time
+import pandas as pd
+from llm_utils import call_llm
+
+def merge_groups_data(members, named_groups_dict, canonical_name):
+    """Combines the data from multiple Phase 1 groups into a single canonical group."""
+    all_codes = []
+    all_original_names = []
+    nutri_sums = {'energy_kcal_100g': 0, 'fat_100g': 0, 'proteins_100g': 0, 'sugars_100g': 0, 'carbohydrates_100g': 0}
+    nutri_counts = {k: 0 for k in nutri_sums}
+    
+    for m in members:
+        g = named_groups_dict[m]
+        all_codes.extend(g['codes'])
+        all_original_names.extend(g['original_names'])
+        for k, v in g['avg_nutrition'].items():
+            nutri_sums[k] += v
+            nutri_counts[k] += 1
+            
+    avg_nutri = {}
+    for k, v in nutri_sums.items():
+        if nutri_counts[k] > 0:
+            avg_nutri[k] = v / nutri_counts[k]
+            
+    return {
+        "canonical_name": canonical_name,
+        "codes": list(set(all_codes)),
+        "original_names": list(set(all_original_names)),
+        "avg_nutrition": avg_nutri
+    }
+
+def run_phase_3_llm_grouper():
+    print("Loading candidate_clusters.json and named_groups.json...")
+    with open('candidate_clusters.json', 'r', encoding='utf-8') as f:
+        clusters = json.load(f)
+    with open('named_groups.json', 'r', encoding='utf-8') as f:
+        named_groups = json.load(f)
+        
+    named_groups_dict = {g['normalized_key']: g for g in named_groups}
+    
+    singletons = [c for c in clusters if len(c) == 1]
+    multi_clusters = [c for c in clusters if len(c) > 1]
+    
+    print(f"Total singletons (auto-accepted): {len(singletons)}")
+    print(f"Total multi-clusters to judge: {len(multi_clusters)}")
+    
+    final_groups = []
+    
+    # Process singletons
+    for s in singletons:
+        key = s[0]
+        display = named_groups_dict[key]['display_name']
+        final_groups.append(merge_groups_data([key], named_groups_dict, display.title()))
+        
+    # Process multi-clusters via LLM
+    BATCH_SIZE = 10
+    total_batches = (len(multi_clusters) + BATCH_SIZE - 1) // BATCH_SIZE
+    
+    system_prompt = """You are a product deduplication expert for a Canadian grocery store.
+Your job is to take clusters of similar product names and group the ones that are EXACTLY the same product.
+Be conservative — if unsure, keep them SEPARATE.
+
+RULES:
+1. SAME product = same item, just different formatting, word order, or language:
+  MERGE: "Cottage Cheese" + "COTTAGE CHEESE" + "Fromage Cottage"
+  MERGE: "Black Forest Ham" + "Natural Black Forest Ham" + "Black forest ham"
+  MERGE: "Extra Lean Ground Beef" + "Compliments Extra Lean Ground Beef"
+
+2. DIFFERENCES = ALWAYS SEPARATE:
+  SEPARATE: Flavour (Cherry vs Lime vs Strawberry)
+  SEPARATE: Texture (Smooth vs Crunchy, Sliced vs Whole)
+  SEPARATE: Heat (Hot vs Mild)
+  SEPARATE: Animal/Ingredient (Chicken vs Turkey, Canola vs Sunflower)
+  SEPARATE: Fat/Diet (2% vs 7%, Diet vs Regular)
+  SEPARATE: Process (Vanilla vs Artificial Vanilla)
+  SEPARATE: Salt (Salted vs Unsalted)
+
+When in doubt -> SEPARATE.
+Output JSON format ONLY:
+[
+  {
+    "cluster_id": "the provided cluster id",
+    "groups": [
+      {
+        "canonical_name": "English Title Case Name",
+        "members": ["exact name 1", "exact name 2"]
+      }
+    ]
+  }
+]
+Every input name must appear in exactly one subgroup.
+"""
+
+    for i in range(0, len(multi_clusters), BATCH_SIZE):
+        batch = multi_clusters[i:i+BATCH_SIZE]
+        batch_num = (i // BATCH_SIZE) + 1
+        
+        prompt_data = []
+        for j, cluster in enumerate(batch):
+            prompt_data.append({
+                "cluster_id": f"batch_{batch_num}_cluster_{j}",
+                "names_to_group": cluster
+            })
+            
+        user_prompt = "Process these clusters:\n" + json.dumps(prompt_data, indent=2, ensure_ascii=False)
+        
+        print(f"  Batch {batch_num}/{total_batches} ({len(batch)} clusters)...", end="", flush=True)
+        try:
+            data = call_llm(user_prompt, system_prompt)
+            
+            # Process LLM decisions
+            for cluster_out in data:
+                for grp in cluster_out.get('groups', []):
+                    canon = grp.get('canonical_name', 'Unknown')
+                    members = grp.get('members', [])
+                    # Filter out hallucinations
+                    valid_members = [m for m in members if m in named_groups_dict]
+                    if valid_members:
+                        final_groups.append(merge_groups_data(valid_members, named_groups_dict, canon))
+            print(" ✓")
+        except Exception as e:
+            print(f" ERROR: {e}")
+            # Fallback: keep them separate
+            for cluster in batch:
+                for member in cluster:
+                    display = named_groups_dict[member]['display_name']
+                    final_groups.append(merge_groups_data([member], named_groups_dict, display.title()))
+                    
+    print("\nSaving final_groups.json...")
+    with open('final_groups.json', 'w', encoding='utf-8') as f:
+        json.dump(final_groups, f, indent=2, ensure_ascii=False)
+    
+    print(f"Final canonical groups: {len(final_groups)}")
+
+if __name__ == "__main__":
+    run_phase_3_llm_grouper()

OpenDB_Compliments_Merged/llm_utils.py

@@ -0,0 +1,115 @@
+"""
+llm_utils.py — Shared LLM load balancer for the deduplication pipeline.
+
+Provider priority:
+  1. Ollama (local) — primary, no rate limits, no cost
+  2. Groq           — backup, fast, 100K daily token limit
+  3. NVIDIA         — backup, rate limited
+
+Usage:
+    from llm_utils import call_llm
+    result = call_llm("Your prompt here")   # returns parsed JSON or raises
+"""
+
+import json
+import time
+import random
+import os
+import httpx
+from openai import OpenAI
+
+# ── Provider configuration ─────────────────────────────────────────────────────
+PROVIDERS = [
+    {
+        "name": "Groq",
+        "client": OpenAI(
+            base_url="https://api.groq.com/openai/v1",
+            api_key=os.environ.get("GROQ_API_KEY", "your-groq-api-key-here"),
+            timeout=httpx.Timeout(30.0),
+        ),
+        "model": "llama-3.3-70b-versatile",
+    },
+    {
+        "name": "OpenRouter",
+        "client": OpenAI(
+            base_url="https://openrouter.ai/api/v1",
+            api_key=os.environ.get("OPENROUTER_API_KEY", "your-openrouter-api-key-here"),
+            timeout=httpx.Timeout(60.0),
+        ),
+        "model": "meta-llama/llama-3.1-8b-instruct",
+    },
+    {
+        "name": "NVIDIA",
+        "client": OpenAI(
+            base_url="https://integrate.api.nvidia.com/v1",
+            api_key=os.environ.get("NVIDIA_API_KEY", "your-nvidia-api-key-here"),
+            timeout=httpx.Timeout(30.0),
+        ),
+        "model": "meta/llama-3.1-70b-instruct",
+    },
+    {
+        "name": "Ollama (Local)",
+        "client": OpenAI(
+            base_url="http://localhost:11434/v1",
+            api_key="ollama",
+            timeout=httpx.Timeout(300.0),
+        ),
+        "model": "llama3.1",
+    },
+]
+
+SYSTEM_PROMPT = (
+    "You are a helpful data processing assistant. "
+    "Output ONLY valid JSON with no markdown, no code fences, no extra text."
+)
+
+
+def _strip_fences(text: str) -> str:
+    """Extract JSON array or object from text."""
+    text = text.strip()
+    # Find the first [ or { and the last ] or }
+    first_idx = min([i for i, c in enumerate(text) if c in '[{'] or [0])
+    last_idx = max([i for i, c in enumerate(text) if c in ']}'] or [len(text)-1])
+    return text[first_idx:last_idx+1].strip()
+
+
+def call_llm(prompt: str, system_prompt: str = None, max_retries: int = 3) -> any:
+    """
+    Send a prompt to the LLM and return the parsed JSON response.
+
+    Tries each provider in order. If all providers fail on an attempt,
+    backs off exponentially before the next attempt.
+
+    Raises RuntimeError if all retries across all providers are exhausted.
+    """
+    sys_prompt = system_prompt if system_prompt else SYSTEM_PROMPT
+    for attempt in range(1, max_retries + 1):
+        for provider in PROVIDERS:
+            try:
+                completion = provider["client"].chat.completions.create(
+                    model=provider["model"],
+                    messages=[
+                        {"role": "system", "content": sys_prompt},
+                        {"role": "user", "content": prompt},
+                    ],
+                    temperature=0,
+                    top_p=0.95,
+                    max_tokens=4096,
+                    stream=False,
+                )
+                raw = completion.choices[0].message.content or ""
+                cleaned = _strip_fences(raw)
+                parsed = json.loads(cleaned)
+                return parsed
+
+            except json.JSONDecodeError as e:
+                print(f"  [{provider['name']}] JSON parse error: {e}")
+                print(f"  Raw response: {raw[:300]}")
+            except Exception as e:
+                print(f"  [{provider['name']}] Error: {e}")
+
+        backoff = attempt * 10
+        print(f"  All providers failed on attempt {attempt}/{max_retries}. Backing off {backoff}s...")
+        time.sleep(backoff)
+
+    raise RuntimeError("All LLM providers exhausted with no successful response.")

OpenDB_Compliments_Merged/preprocess.py

@@ -0,0 +1,120 @@
+import pandas as pd
+import json
+import re
+import unicodedata
+
+BRAND_PREFIXES = [
+    'compliments',
+    'our compliments',
+    'nos compliments',
+    'naturally simple',
+    'sensations compliments',
+    'sensations',
+    'compliment'
+]
+
+def fix_mojibake(text):
+    """Fix common UTF-8 encoding artifacts found in the dataset."""
+    if not isinstance(text, str):
+        return text
+    try:
+        # If it was double-encoded UTF-8 read as latin-1
+        return text.encode('latin1').decode('utf-8')
+    except (UnicodeEncodeError, UnicodeDecodeError):
+        # Fallback to manual replacements if strict decoding fails
+        return text.replace('é', 'é').replace('è', 'è').replace('ô', 'ô').replace('â', 'â').replace('Γ£ô', '')
+
+def strip_accents(text):
+    return ''.join(c for c in unicodedata.normalize('NFD', text) if unicodedata.category(c) != 'Mn')
+
+def generate_comparison_key(name):
+    """Generate a highly normalized string used purely for exact-matching."""
+    if not isinstance(name, str) or not name.strip():
+        return ""
+        
+    s = name.lower().strip()
+    s = fix_mojibake(s)
+    s = strip_accents(s)
+    
+    # Strip non-alphanumeric characters
+    s = re.sub(r'[^\w\s]', ' ', s)
+    s = re.sub(r'\s+', ' ', s).strip()
+    
+    # Remove brand prefixes
+    for brand in BRAND_PREFIXES:
+        if s.startswith(brand + ' '):
+            s = s[len(brand)+1:].strip()
+            
+    # Simple plural normalization: if last word ends in 's' and isn't 'ss', strip it
+    words = s.split()
+    if words:
+        last = words[-1]
+        if len(last) > 3 and last.endswith('s') and not last.endswith('ss'):
+            words[-1] = last[:-1]
+        s = ' '.join(words)
+        
+    return s
+
+def clean_display_name(name):
+    """Clean the name for display purposes (keep accents and plurals, just fix encoding)."""
+    if not isinstance(name, str):
+        return ""
+    s = fix_mojibake(name)
+    s = re.sub(r'\s+', ' ', s).strip()
+    return s
+
+def run_phase_1():
+    print("Loading original.parquet...")
+    df = pd.read_parquet('original.parquet')
+    total_original = len(df)
+    
+    # Drop completely unnamed rows
+    df = df[df['product_name'].notna() & (df['product_name'].str.strip() != '')].copy()
+    total_named = len(df)
+    
+    print(f"Dropped {total_original - total_named} unnamed products.")
+    print(f"Processing {total_named} named products.")
+    
+    # Create the display name and comparison key
+    df['clean_name'] = df['product_name'].apply(clean_display_name)
+    df['compare_key'] = df['product_name'].apply(generate_comparison_key)
+    
+    # Save the working copy (original is untouched)
+    df.to_parquet('working.parquet')
+    
+    # Group by exact match on compare_key
+    grouped = df.groupby('compare_key')
+    
+    groups_out = []
+    for key, group in grouped:
+        if not key:
+            continue
+        # Use the most frequent clean_name as the representative display name
+        display_name = group['clean_name'].value_counts().index[0]
+        
+        # Aggregate nutrition (mean of available numerical data)
+        nutri_cols = ['energy_kcal_100g', 'fat_100g', 'proteins_100g', 'sugars_100g', 'carbohydrates_100g']
+        avg_nutri = {}
+        for col in nutri_cols:
+            if col in group.columns:
+                val = group[col].mean()
+                if pd.notna(val):
+                    avg_nutri[col] = float(val)
+                    
+        groups_out.append({
+            "normalized_key": key,
+            "display_name": display_name,
+            "codes": group['code'].tolist(),
+            "original_names": group['product_name'].unique().tolist(),
+            "avg_nutrition": avg_nutri
+        })
+        
+    print(f"Exact match grouping reduced {total_named} named products to {len(groups_out)} unique groups.")
+    
+    with open('named_groups.json', 'w', encoding='utf-8') as f:
+        json.dump(groups_out, f, indent=2, ensure_ascii=False)
+        
+    print("Saved working.parquet and named_groups.json")
+
+if __name__ == "__main__":
+    run_phase_1()

OpenDB_Compliments_Merged/product_mapping.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:005b5c808e58887322d8fb1212f6106e696a40a774c011a4aab7805df1d5a878
+size 37460