Changes nemotron model

README.md

@@ -64,7 +64,7 @@ flowchart TD
     A["📷 Photo from phone"] --> B["🤖 Vision AI\nLlama-3.2-11B-Vision\n(NVIDIA NIM / HF)"]
     B -->|"is it an animal?"| C{Animal detected?}
     C -->|"No"| ERR["❌ Error message\n'No dog or cat identified'"]
-    C -->|"Yes"| D["📝 Structured JSON\nNemotron Mini 4B Instruct normalizes\nspecies · breed · color · condition · marks"]
+    C -->|"Yes"| D["📝 Structured JSON\nNemotron Mini 4B Instruct structures\nspecies · breed · color · condition · marks"]
     D --> E["🔢 Semantic embedding\nall-MiniLM-L6-v2 · 384 dim\n(local, 22M params)"]
     E --> F{Cosine similarity\n≥ 0.80?}
     F -->|"Yes — known animal"| G["➕ New sighting\nadded to existing animal"]

core/ai.py

@@ -1,5 +1,5 @@
 """
-ai.py — Visao + normalizacao de texto, ambas via NVIDIA NIM (ou HF como alternativa).
+ai.py — Visao + estruturacao de texto, ambas via NVIDIA NIM (ou HF como alternativa).
 
 Arquitetura (todos os modelos < 32B):
   - Visao  : meta/llama-3.2-11b-vision-instruct   (11B, NVIDIA NIM)  -> NVIDIA_API_KEY
@@ -7,13 +7,15 @@ Arquitetura (todos os modelos < 32B):
   - Texto  : nvidia/nemotron-mini-4b-instruct      (4B,  NVIDIA NIM)  -> NVIDIA_API_KEY
   - Embed  : sentence-transformers/all-MiniLM-L6-v2 (22M, local/CPU)
 
-Fluxo: o Llama-3.2-11B-Vision enxerga a foto e devolve a descricao bruta. Em
-seguida o Nemotron Mini 4B Instruct (texto puro) normaliza esse JSON para o schema
-estrito (raca da lista permitida, cores simples, condicao, frase de matching).
+Fluxo: o Llama-3.2-11B-Vision enxerga a foto e descreve o animal (texto livre —
+modelos de visao raramente cospem JSON limpo). Em seguida o Nemotron Mini 4B
+Instruct (texto puro) LE essa descricao e EXTRAI o JSON estrito (especie, raca da
+lista permitida, cor, condicao, frase de matching). Cada modelo no que e bom:
+Llama ve, Nemotron estrutura.
 
 Basta a NVIDIA_API_KEY: ela serve tanto para a visao quanto para o Nemotron.
-Se nao houver NVIDIA_API_KEY mas houver HF_TOKEN, a visao usa o HF Serverless
-(sem a etapa de normalizacao do Nemotron).
+Sem NVIDIA_API_KEY mas com HF_TOKEN, a visao usa o HF Serverless e a estruturacao
+cai para o parser local (regex de JSON).
 
 Variaveis de ambiente:
   NVIDIA_API_KEY      — chave NVIDIA NIM (free tier em build.nvidia.com)
@@ -37,54 +39,58 @@ _HF_MODEL         = "meta-llama/Llama-3.2-11B-Vision-Instruct"  # id HF Serverle
 _NIM_VISION_MODEL = "meta/llama-3.2-11b-vision-instruct"        # id NVIDIA NIM (11B, free)
 _NIM_TEXT_MODEL   = "nvidia/nemotron-mini-4b-instruct"          # id NVIDIA NIM (4B, free)
 
-PROMPT = (
-    "Examine this image carefully.\n"
-    "FIRST: Is there a dog or cat clearly visible?\n"
-    "If NO dog or cat is present, respond with exactly: {\"is_animal\": false}\n\n"
-    "If YES, respond with ONLY valid JSON (no markdown, no explanation).\n\n"
-    "For breed_estimate, use visual cues (coat type, ear shape, body build, snout, tail) to pick the SINGLE best match.\n\n"
-    "DOG breeds to choose from (use exact spelling):\n"
+_DOG_BREEDS = (
     "SRD, Labrador Retriever, Golden Retriever, Pitbull, Poodle, Shih Tzu, Rottweiler, "
     "German Shepherd, Bulldog, Dachshund, Chihuahua, Siberian Husky, Border Collie, "
-    "Beagle, Boxer, Maltese, Chow Chow, Akita, Dalmatian, Doberman\n\n"
-    "CAT breeds to choose from (use exact spelling):\n"
+    "Beagle, Boxer, Maltese, Chow Chow, Akita, Dalmatian, Doberman"
+)
+_CAT_BREEDS = (
     "Domestic Shorthair, Domestic Longhair, Siamese, Persian, Maine Coon, Bengal, "
-    "British Shorthair, Ragdoll, Scottish Fold, Turkish Angora, Sphynx, Abyssinian\n\n"
-    "JSON format:\n"
+    "British Shorthair, Ragdoll, Scottish Fold, Turkish Angora, Sphynx, Abyssinian"
+)
+
+# Prompt da VISAO — texto livre permitido (o Nemotron estrutura depois).
+PROMPT = (
+    "Look at this image. Is there a dog or a cat in it?\n"
+    "If there is NO dog and NO cat, reply with exactly: NO ANIMAL\n"
+    "If there is a dog or a cat, describe the most prominent one in 2-3 sentences: "
+    "species (dog or cat), likely breed, size, main color and secondary colors, "
+    "any distinctive marks (collar, scar, patch, missing ear), and apparent condition "
+    "(healthy, thin or injured)."
+)
+
+# Prompt do NEMOTRON — extrai JSON estrito a partir da descricao livre do Llama.
+EXTRACT_PROMPT = (
+    "You convert a free-text animal description into STRICT JSON for a stray-animal database.\n"
+    "Output ONLY a JSON object — no markdown, no explanation.\n\n"
+    "If the description says there is no dog or cat (e.g. 'NO ANIMAL'), output exactly:\n"
+    "{\"is_animal\": false}\n\n"
+    "Otherwise output exactly these keys:\n"
     "{\"is_animal\": true,"
     " \"species\": \"dog or cat\","
-    " \"breed_estimate\": \"exact name from the list above — SRD/Domestic Shorthair only if truly unidentifiable\","
+    " \"breed_estimate\": \"single best match from the lists below\","
     " \"size\": \"small, medium or large\","
-    " \"primary_color\": \"main color: caramel, black, white, gray, brown, golden, orange, tabby, mixed\","
-    " \"secondary_colors\": [\"other visible colors, or empty list\"],"
-    " \"distinctive_marks\": [\"notable features: e.g. white chest patch, red collar, scar, missing ear — or empty list\"],"
+    " \"primary_color\": \"main color\","
+    " \"secondary_colors\": [\"other colors or empty list\"],"
+    " \"distinctive_marks\": [\"notable features or empty list\"],"
     " \"condition\": \"healthy, thin or injured\","
-    " \"description_text\": \"one concise English sentence describing this specific animal for identity matching\"}"
-)
-
-# Nemotron Mini 4B Instruct normaliza a saida da visao para o schema estrito (texto puro).
-NORMALIZE_PROMPT = (
-    "You normalize raw animal descriptions for a stray-animal database.\n"
-    "Given the input JSON, return ONLY a cleaned JSON object with the SAME keys.\n"
-    "Rules:\n"
-    "- breed_estimate must be the single best match from the allowed dog/cat breed lists; "
-    "use SRD (dog) or Domestic Shorthair (cat) only if truly unidentifiable.\n"
-    "- species is 'dog' or 'cat'; size is 'small', 'medium' or 'large'.\n"
-    "- primary_color and secondary_colors are simple lowercase words.\n"
-    "- condition is exactly one of: healthy, thin, injured.\n"
-    "- description_text is ONE concise English sentence for identity matching.\n"
-    "- Do NOT invent details not present in the input. No markdown, no explanation.\n\n"
-    "Input JSON:\n"
+    " \"description_text\": \"one concise English sentence identifying this specific animal\"}\n\n"
+    "DOG breeds (exact spelling): " + _DOG_BREEDS + "\n"
+    "CAT breeds (exact spelling): " + _CAT_BREEDS + "\n"
+    "Use SRD (dog) or Domestic Shorthair (cat) only if the breed is truly unclear.\n"
+    "If several animals appear, structure only the most prominent one.\n"
+    "Do NOT invent details that are not in the description.\n\n"
+    "DESCRIPTION:\n"
 )
 
 
 class AnimalAI:
     def __init__(self):
-        self.vision_mode   = None   # "nim" | "hf"
-        self.vision_model  = None
-        self.vision_client = None   # OpenAI (NIM) ou InferenceClient (HF)
+        self.vision_mode    = None   # "nim" | "hf"
+        self.vision_model   = None
+        self.vision_client  = None   # OpenAI (NIM) ou InferenceClient (HF)
         self.nim_text_model = _NIM_TEXT_MODEL
-        self.nim_client     = None  # OpenAI -> NVIDIA NIM, p/ normalizacao Nemotron
+        self.nim_client     = None   # OpenAI -> NVIDIA NIM, p/ extracao Nemotron
 
         nvidia_key = os.environ.get("NVIDIA_API_KEY", "")
         hf_token   = os.environ.get("HF_TOKEN", "")
@@ -98,7 +104,6 @@ class AnimalAI:
                     api_key=nvidia_key,
                 )
                 self.nim_text_model = os.environ.get("NVIDIA_MODEL", _NIM_TEXT_MODEL)
-                # Visao via NIM (Llama-3.2-11B-Vision)
                 self.vision_mode   = "nim"
                 self.vision_model  = os.environ.get("NVIDIA_VISION_MODEL", _NIM_VISION_MODEL)
                 self.vision_client = self.nim_client
@@ -106,7 +111,7 @@ class AnimalAI:
             except ImportError:
                 log.warning("openai nao instalado")
 
-        # Alternativa: visao via HF Serverless (Llama-3.2-11B-Vision) se nao houver NVIDIA
+        # Alternativa: visao via HF Serverless se nao houver NVIDIA
         if self.vision_client is None and hf_token:
             try:
                 from huggingface_hub import InferenceClient
@@ -141,68 +146,73 @@ class AnimalAI:
             ]
 
             if self.vision_mode == "nim":
-                # NVIDIA NIM — Llama-3.2-11B-Vision (OpenAI-compatible)
                 resp = self.vision_client.chat.completions.create(
                     model=self.vision_model,
                     messages=[{"role": "user", "content": content}],
                     max_tokens=400,
-                    temperature=0.1,
+                    temperature=0.2,
                 )
                 raw = resp.choices[0].message.content or ""
             else:
-                # HuggingFace InferenceClient — suporte nativo a multimodal
                 resp = self.vision_client.chat_completion(
                     messages=[{"role": "user", "content": content}],
                     max_tokens=400,
-                    temperature=0.1,
+                    temperature=0.2,
                 )
                 raw = resp.choices[0].message.content or ""
 
             log.info("Visao resposta: %s", raw[:200])
-            result = self._parse(raw)
 
-            # Rejeição explícita: a IA não viu nenhum animal
-            if result.get("is_animal") is False:
+            # Atalho: visao declarou que nao ha animal
+            if "NO ANIMAL" in raw.upper() and self._extract_json(raw) is None:
                 log.info("IA: nenhum animal detectado na imagem.")
                 return {"is_animal": False, "_ai_success": True}
 
-            # Normalização opcional via Nemotron Mini 4B Instruct (texto puro, NVIDIA NIM)
+            # Estrutura a descricao em JSON (Nemotron preferido; robusto a prosa)
             if self.nim_client is not None:
-                result = self._normalize_with_nemotron(result)
+                result = self._structure_with_nemotron(raw)
+            else:
+                result = self._parse(raw)
+
+            if result.get("is_animal") is False:
+                log.info("IA: nenhum animal detectado (estruturacao).")
+                return {"is_animal": False, "_ai_success": True}
 
             result["is_animal"] = True
-            result["_ai_success"] = True
+            result.setdefault("_ai_success", True)
             return result
 
         except Exception as e:
             log.error("Erro na API de visao: %s", e)
             return self._fallback()
 
-    def _normalize_with_nemotron(self, result: dict) -> dict:
-        """Coage o JSON da visao para o schema estrito usando Nemotron Mini 4B Instruct (texto)."""
+    def _structure_with_nemotron(self, raw_text: str) -> dict:
+        """Extrai JSON estrito da descricao livre da visao usando Nemotron Mini 4B Instruct."""
         try:
-            payload = json.dumps(result, ensure_ascii=False)
             resp = self.nim_client.chat.completions.create(
                 model=self.nim_text_model,
-                messages=[{"role": "user", "content": NORMALIZE_PROMPT + payload}],
-                max_tokens=400,
+                messages=[{"role": "user", "content": EXTRACT_PROMPT + raw_text}],
+                max_tokens=500,
                 temperature=0.2,
                 top_p=0.9,
             )
             msg = resp.choices[0].message
-            raw = (msg.content or "") or (getattr(msg, "reasoning_content", "") or "")
-            cleaned = self._extract_json(raw)
-            if cleaned:
-                for k in ("species", "breed_estimate", "size", "primary_color",
-                          "secondary_colors", "distinctive_marks", "condition",
-                          "description_text"):
-                    if k in cleaned and cleaned[k] not in (None, "", []):
-                        result[k] = cleaned[k]
-                log.info("Nemotron Mini 4B normalizou os campos.")
-            return result
+            out = (msg.content or "") or (getattr(msg, "reasoning_content", "") or "")
+            parsed = self._extract_json(out)
+            if parsed is not None:
+                log.info("Nemotron Mini 4B estruturou o JSON.")
+                parsed["_ai_success"] = True
+                return parsed
+            log.warning("Nemotron nao retornou JSON — tentando parse direto da visao")
         except Exception as e:
-            log.warning("Nemotron normalize falhou, usando saida da visao: %s", e)
-            return result
+            log.warning("Nemotron structure falhou: %s", e)
+
+        # Reservas: JSON direto da visao, senao fallback generico
+        direct = self._extract_json(raw_text)
+        if direct is not None:
+            direct["_ai_success"] = True
+            return direct
+        return self._fallback()
 
     def get_embedding(self, description: dict) -> list:
         """Embedding da descricao. Aleatorio se IA falhou (evita falsos matches)."""