System Ewaluacji LLM i Aplikacja Kulinarna

Dwukomponentowy projekt łączący Framework Ewaluacji LLM (Python, 19 plików, 50 przypadków testowych) z aplikacją mobilną ZjemTo (React Native, 29 ekranów). System wykrywa halucynacje AI, obsługuje modele GPT-4o, Claude i polski Bielik. Zawiera wielowarstwowy system ochrony przed halucynacjami: Judge System, walidację Bielik, Polish Guard i lokalną bazę ~48 przepisów.

Spis treści

• v1.01 — Kwantyzacja Bielika na iPhone
• Opis projektu
• Architektura systemu
• LLM Evaluation Framework
• Aplikacja ZjemTo
• System walki z halucynacjami
• Modele AI i ich odpowiedzialności
• Architektura aplikacji ZjemTo
• Endpointy API serwera
• Badania ewaluacji
• Kluczowe odkrycia techniczne
• Główne funkcje aplikacji
• Przechowywanie danych
• Plany na przyszłość
• Podsumowanie

v1.01 — Kwantyzacja Bielika na iPhone

Status: w fazie badań i planowania

Problem: Chmura przy skalowaniu zabija indie-projekt kosztami, a self-host oznacza kolejki przy większej liczbie użytkowników. Decyzja: model musi działać lokalnie na urządzeniu z ≥ 8 GB RAM (iOS).

Kwantyzacja: IQ2_XXS vs IQ3_XXS

Custom IMatrix na polskiej kuchni

Kalibracja IMatrix na tekstach domenowych zamiast standardowego wikitext:

• Teksty historyczne (np. Compendium Ferculorum)
• Przepisy regionalne
• Dane syntetyczne z polskiej kuchni

Cel: IMatrix określa ważność (importance) poszczególnych wag — kalibracja na polskiej kuchni pozwala zachować precyzję w wagach najistotniejszych dla tej domeny.

Architektura hybrydowa (rozważana)

Input od użytkownika → lekki model w chmurze (np. GPT-4o-mini) → oczyszczony input → Bielik IQ2/IQ3 na telefonie.

Lokalna baza SQLite

Zabezpieczenie na wypadek gdy model skwantyzowany zawiedzie — lokalna baza przepisów jako fallback.

Otwarte pytania

• Jak Bielik 11B wypada w kwantyzacji IQ2_XXS/IQ2_XS? Czy zachowuje spójność?
• Czy architektura Depth Up-Scaling (Mistral) znosi agresywną kwantyzację?
• Czy mniejszy model (np. 7B przy Q4_K_M) nie da lepszych wyników niż 11B przy IQ2?

Opis projektu

Dwukomponentowy projekt łączący:

1. LLM Evaluation Framework — System ewaluacji modeli językowych do ekstrakcji i generowania przepisów kulinarnych
2. ZjemTo — Aplikacja mobilna React Native do odkrywania polskich i międzynarodowych przepisów z wykorzystaniem AI

Projekt zawiera ~150 plików źródłowych, 50 przypadków testowych oraz zaawansowane mechanizmy wykrywania i zapobiegania halucynacjom AI.

Architektura systemu

├── llm-eval-framework/          # System ewaluacji Python
│   ├── config/config.yaml       # Główna konfiguracja
│   ├── src/                     # Moduły ewaluacji (19 plików Python)
│   │   ├── models/              # Runnery modeli AI
│   │   ├── judge/               # Wykrywanie halucynacji
│   │   ├── eval/                # Pipeline ewaluacji
│   │   ├── report/              # Generowanie raportów
│   │   └── utils/               # Cache, logowanie
│   ├── data/eval_cases/         # 50 przypadków testowych
│   ├── results/                 # Wyniki ewaluacji
│   └── tests/                   # Testy jednostkowe
│
├── ZjemTo/                      # Aplikacja React Native
│   ├── src/
│   │   ├── screens/             # 29 ekranów aplikacji
│   │   ├── services/            # Warstwa integracji AI
│   │   ├── components/          # 50+ komponentów UI
│   │   ├── data/                # Przepisy, dane historyczne
│   │   └── config/              # Konfiguracja API
│   ├── server/                  # Backend Express (proxy AI)
│   └── package.json
│
├── semantic_cache.py            # Narzędzie cache Redis
└── README.md

LLM Evaluation Framework

1. Model Runners (src/models/)

2. Pipeline ewaluacji (src/eval/)

3. Wykrywanie halucynacji (src/judge/)

4. Raporty (src/report/)

Dane testowe

50 przypadków ewaluacyjnych podzielonych na 3 okresy:

Aplikacja ZjemTo

Architektura sieciowa

Telefon (Expo Go) → Serwer Express (port 3001) → Ollama (port 11434) dla Bielik
                                               → OpenAI API dla trybu World

Główne ekrany (29 łącznie)

Serwisy AI (src/services/)

Endpointy Express (server/server.js)

System walki z halucynacjami

Halucynacje AI to sytuacje gdy model wymyśla informacje, których nie było w źródle. W kontekście przepisów kulinarnych może to oznaczać:

• Dodawanie składników których nie było w oryginalnym tekście
• Wymyślanie czasów/temperatur gotowania
• Tworzenie kroków przygotowania z powietrza
• Używanie współczesnych składników w przepisach historycznych (anachronizmy)

Warstwa 1: Wykrywanie przez sędziego (Judge System)

Typy halucynacji wykrywane:

Klasyfikacja wagi:

System oceniania:

Początkowa ocena: 100 punktów
Odejmij: HIGH × 20, MEDIUM × 10, LOW × 3
Minimalna ocena: 0

WERDYKT:
- FAIL: Jakakolwiek halucynacja HIGH
- WARN: >=3 halucynacje MEDIUM LUB ocena < 70
- PASS: Ocena >= 70 I brak HIGH I < 3 MEDIUM

Warstwa 2: Walidacja Bielik (validate_extraction)

Specjalna walidacja po ekstrakcji dla modelu Bielik (~97 linii kodu):

1. Dopasowanie rdzeni polskich — obsługuje odmianę (cebula→cebule→cebuli)
2. Usuwanie składników — które nie są śledzalne do źródła OCR
3. Walidacja ilości — sprawdzanie czy podane wartości mają pokrycie
4. Podejście konserwatywne — usuwa tylko gdy BRAK znaczących dopasowań
5. Logowanie — wszystkie usunięte elementy są zapisywane do debugowania

Warstwa 3: Polish Guard (aplikacja ZjemTo)

Wielowarstwowy system strażnika zapobiegający halucynacjom kulturowym w trybie Bielik:

• Baza ~48 polskich potraw do walidacji
• Lista ~70 zabronionych dań obcych: sushi, pizza, pasta, ramen, taco, burrito, curry, pad thai, paella, risotto, lasagne, quiche, croissant, shakshuka, gnocchi, ravioli, schnitzel...
• Test babci: Czy babcia z lat 80-tych mogłaby to ugotować? NIE → ODRZUĆ
• Auto-korekcja: jeśli model zasugeruje obce danie, podmiana na Kotlet schabowy z ziemniakami

Mapowanie składników na polskie potrawy:

Warstwa 4: Sekcje FORBIDDEN w promptach

Każdy prompt ekstrakcyjny i generacyjny zawiera jawne zakazy:

Ekstrakcja (OCR → JSON):

• Zakaz dodawania składników które powinny być (sól, woda, olej)
• Zakaz zgadywania czasów gotowania
• Zakaz dodawania narzędzi niewymienonych w źródle
• Zakaz konwersji lub zaokrąglania ilości

Generacja (JSON → przepis):

• Zakaz wymyślania składników spoza JSON
• Zakaz wymyślania czasów i temperatur
• Zakaz sugestii podania
• Zakaz dodawania kontekstu historycznego

Przepisy historyczne:

• NIGDY: mikser elektryczny, blender, robot kuchenny, lodówka, zamrażarka, mikrofalówka, kuchenka indukcyjna, termomix, multicooker, airfryer

Warstwa 5: Walidacja alergenów (AllergenGuardian)

• 13 kategorii alergenów: gluten, nabiał, orzechy, jaja, ryby, owoce morza, soja, seler, musztarda, sezam, siarczyny, łubin
• Filtrowanie przepisów po alergiach użytkownika
• AI-powered zamienniki składników (GPT-4o)

Warstwa 6: Lokalna baza zapasowa

200+ gotowych polskich przepisów w localDishDatabase (linie 462-809). Używana gdy AI zawiedzie lub timeout. Zawiera: Bigos, Żurek, Pierogi, Gołąbki, Placki... Gwarantuje że użytkownik zawsze coś dostanie.

Parametry modeli minimalizujące halucynacje

Modele AI i ich odpowiedzialności

Modele w Framework ewaluacji

Modele w aplikacji ZjemTo

Dlaczego te modele?

1. Bielik — Polski model, rozumie odmianę, kontekst kulturowy, kuchnię polską
2. GPT-4o — Najlepszy jako sędzia, wysoka dokładność oceny
3. GPT-4o-mini — Szybszy i tańszy dla prostszych operacji (remix, sugestie)
4. Claude — Alternatywa dla porównania, dobra jakość
5. GPT-4o Vision — Analiza obrazów (OCR, zdjęcia lodówki)

Architektura aplikacji ZjemTo

┌─────────────────────────────────────────────────────────────┐
│                    TELEFON (Expo Go)                        │
│                         │                                   │
│                         ▼                                   │
│              ┌─────────────────────┐                        │
│              │   Express Server    │                        │
│              │    (port 3001)      │                        │
│              └──────────┬──────────┘                        │
│                         │                                   │
│         ┌───────────────┼───────────────┐                   │
│         ▼               ▼               ▼                   │
│   ┌──────────┐   ┌──────────┐   ┌──────────────┐           │
│   │  Ollama  │   │  OpenAI  │   │ OpenAI Vision│           │
│   │ (Bielik) │   │ GPT-4o   │   │   GPT-4o     │           │
│   │port 11434│   │ GPT-mini │   │  (obrazy)    │           │
│   └──────────┘   └──────────┘   └──────────────┘           │
└─────────────────────────────────────────────────────────────┘

3 terminale do uruchomienia:

1. Ollama — ollama serve (Bielik na porcie 11434)
2. Serwer Express — node server.js (API na porcie 3001)
3. Expo — npx expo start (frontend mobilny)

Endpointy API serwera

Trzy iteracje badań ewaluacji

BADANIE 1: Baseline (punkt odniesienia)

Halucynacje łącznie: 144 (HIGH: 3, MEDIUM: 101, LOW: 40)

Zidentyfikowane problemy:

• Model domyślał się brakujących składników (sól, pieprz, olej)
• Wymyślał konkretne miary przy braku ilości w źródle
• Rozbudowywał instrukcje o dodatkowe kroki
• Dodawał kontekst historyczny mimo braku w źródle

BADANIE 2: Post-fix v1

Zmiany: temperatura 0.0→0.3, format:json włączony, top_p=0.7

Wniosek: format:json pomógł ze składnikami (-7), ale temperatura 0.3 za wysoka — model zbyt kreatywny

BADANIE 3: Post-fix v2 (finalna)

Zmiany: temperatura 0.1, repeat_penalty=1.1, sekcje FORBIDDEN, walidacja post-ekstrakcyjna

Sukces: Walidacja rdzeni polskich słów + sekcje FORBIDDEN znacząco zredukowały halucynacje

Kluczowe odkrycia techniczne

Dopasowanie rdzeni polskich słów (stem matching)

Polski język ma bogatą odmianę (deklinację). Jeden składnik może występować w wielu formach:

• cebula / cebule / cebuli / cebulę
• pomidor / pomidora / pomidorów / pomidory

Rozwiązanie: Porównywanie pierwszych 4 znaków po normalizacji diakrytyków:

• cebula → cebu ✓
• pomidorów → pomi ✓

Efekt: Redukcja fałszywych odrzuceń o ~40%

Kompromis precyzja vs kreatywność

Główne funkcje aplikacji

Skanowanie składników (kamera)

Użytkownik fotografuje zawartość lodówki. Obraz w base64 trafia do GPT-4o Vision, który rozpoznaje składniki z poziomem pewności (confidence 0.0-1.0). Na podstawie rozpoznanych składników generowany jest przepis — polski (Bielik) lub międzynarodowy (GPT-4o).

HeritageWizard — digitalizacja przepisów rodzinnych

Pięciokrokowy kreator OCR ręcznie pisanych przepisów:

1. Porady dotyczące oświetlenia i czytelności zdjęcia
2. Wyjaśnienie procesu
3. Zdjęcie przepisu (kamera lub galeria)
4. Przetwarzanie: obraz → GPT-4o Vision (OCR) → ekstrakcja tytułu, składników, kroków
5. Podgląd przepisu + pole na notatkę rodzinną + zgoda na użycie w bazie dziedzictwa

Timeout OCR: 90 sekund. Obsługa polskich znaków diakrytycznych. Nieczytelne fragmenty oznaczane jako [nieczytelne].

Odtwórz smak (RecreateTaste)

Użytkownik opisuje wspomnienie kulinarne (np. zupa, którą babcia robiła w niedziele z koperkiem i makaronem). Pipeline dwuetapowy:

• Etap 1: GPT-4o-mini (tani, szybki) — ekstrakcja kontekstu: kandydaci na potrawy, składniki kluczowe, okazja, sezon, region, nastrój
• Etap 2: Bielik (lub GPT-4o jako fallback) — generacja pełnego przepisu na podstawie zidentyfikowanej potrawy

Tryb gotowania (CookingMode)

Pełnoekranowy przewodnik krok po kroku:

• Czytanie głosowe (Text-to-Speech, expo-speech)
• Timer z nakładką (domyślnie 5 min)
• Wysuwany panel składników
• Detekcja trudnych kroków (dopasowanie słów kluczowych)
• Chef's Eye — weryfikacja zdjęcia kroku gotowania przez AI
• Przycisk Zapytaj AI — porada kontekstowa per krok
• Nawigacja: Poprzedni / Następny / Zakończ

DishSwiper — odkrywanie potraw w stylu Tinder

Komponenty z gestami (PanResponder): przesuń w prawo = polub, w lewo = pomiń. Animowane stemple LIKE/NOPE, rotacja kart -8° do +8°, stos 2 kart z efektem paralaksy.

Insta-Plate AI — ocena estetyki jedzenia

Zdjęcie potrawy → GPT-4o Vision → wynik 1-10 z analizą: kompozycja, oświetlenie, kolory, prezentacja. Nakładka z siatką złotego podziału (1.618) podczas fotografowania.

Regiony i przepisy historyczne

• 16 województw ze specjalnościami regionalnymi
• 6 okresów historycznych: średniowiecze (przed 1500), renesans (1500-1700), staropolska (1700-1850), przedwojenna (1918-1939), PRL (1945-1989), współczesna (1989+)
• Każdy okres z ograniczeniami składników i technik (np. średniowiecze: bez ziemniaków i pomidorów)

System grywalizacji

• XP: 50 za posiłek + bonusy za wyzwania (+100) i serie (3 dni: +50, 7 dni: +100, 30 dni: +500)
• 5 poziomów: Kuchenny Nowicjusz → Domowy Kucharz → Szef Kuchni → Mistrz Garnków → Legenda Kuchni
• Odznaki ekologiczne: eco_warrior (10kg jedzenia), planet_hero (50kg CO2), food_rescuer (25kg)
• Śledzenie wpływu ekologicznego: 0.3 kg jedzenia uratowanego / posiłek, 2.5 kg CO2 / kg jedzenia
• Dzienne wyzwania kulinarne

Dodatkowe funkcje

• Skaner paragonów — OCR paragonu, śledzenie wydatków
• Inwentarz lodówki — ręczne śledzenie składników
• Lista zakupów — automatycznie generowana z przepisu
• Ustawienia alergenów — 13 kategorii, filtrowanie przepisów, zamienniki AI
• Podgląd AR — augmented reality talerza (expo-ar)
• Udostępnianie przepisów — expo-sharing

Przechowywanie danych

Klient (AsyncStorage)

Serwer (JSONL)

• Każde zapytanie logowane do server/logs/YYYY-MM-DD.log
• Format: endpoint, model, tokeny, koszt, czas, status
• Przepisy zapisywane do recipes.jsonl (potencjalny RAG)

Plany na przyszłość

Funkcje w przygotowaniu

• Chef's Eye rozszerzony — AI weryfikuje każdy krok gotowania ze zdjęcia
• Głosowe sterowanie — Następny krok, Powtórz, Timer 5 minut
• Społeczność — udostępnianie przepisów rodzinnych
• RAG na przepisach — wyszukiwanie semantyczne po historii

Rozwój Bielika

• Fine-tuning na polskich przepisach
• Obsługa dialektów regionalnych (śląski, kaszubski)
• Lepsze rozumienie archaicznego języka kulinarnego

Rozwój aplikacji

• Wersja iOS (obecnie tylko Android)
• Tryb offline z lokalnym modelem
• Integracja z lodówkami smart (Samsung, LG)

Jakość ewaluacji

• Automatyczne testy regresji po każdej zmianie
• A/B testing promptów
• Dashboard z metrykami w czasie rzeczywistym

Podsumowanie