Add PT-BR Talker POC metadata, scripts and evaluation outputs

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* 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
+eval/aula.wav filter=lfs diff=lfs merge=lfs -text
+eval/hotel.wav filter=lfs diff=lfs merge=lfs -text
+eval/mercado.wav filter=lfs diff=lfs merge=lfs -text
+eval/onibus.wav filter=lfs diff=lfs merge=lfs -text
+eval/padaria.wav filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,74 @@
+---
+license: other
+language:
+- pt
+tags:
+- minimind-o
+- portuguese
+- pt-br
+- text-to-audio
+- mimi
+- experimental
+private: true
+---
+
+# MiniMind-O PT-BR Talker Curriculum 100k POC
+
+Experimental PT-BR fine-tuning bundle metadata for MiniMind-O text/audio work.
+
+**Important:** the large `.pth` checkpoints were prepared locally but could not be uploaded to this private repository because the Hugging Face account hit its private LFS storage limit. This repository therefore contains the reproducibility scripts, evaluation outputs, metadata, file manifest, and checksums. The large files are available locally in the prepared export folder.
+
+## Prepared Local Artifacts
+
+Local export folder:
+
+```text
+hf_exports/minimind-o-ptbr-talker-curriculum-100k-poc/
+```
+
+Prepared checkpoints:
+
+```text
+checkpoints/sft_ptbr_curriculum_100k_textfix_768.pth
+checkpoints/sft_ptbr_curriculum_100k_t2a_repair_768.pth
+checkpoints/sft_ptbr_curriculum_100k_mixed_768.pth
+```
+
+Prepared data:
+
+```text
+data/ptbr_curriculum_100k.jsonl
+data/sft_text_ptbr_curriculum_100k.parquet
+```
+
+See `SHA256SUMS.txt` and `file_manifest.json` for sizes and checksums.
+
+## Evaluation Summary
+
+Final evaluation after textfix + T2A repair + mixed SFT:
+
+```json
+{
+  "rows": 5,
+  "audio_generated": 5,
+  "transcribed": 5,
+  "looks_portuguese": 3,
+  "basic_pass": 5
+}
+```
+
+Manual reading: audio generation works, but PT-BR/relevance is still not production-ready. One sample still mixes English/alucinated content, and several transcriptions remain rough.
+
+## Training Flow
+
+1. Build PT-BR curriculum 100k.
+2. Train textfix from `sft_omni_ptbr_talker`.
+3. Repair T2A on the 6h PT-BR T2A parquet.
+4. Train mixed text + T2A.
+5. Evaluate with generated WAVs and Whisper Medium.
+
+Relevant scripts are included under `tools/`.
+
+## Caveat
+
+These `.pth` files are MiniMind-O native checkpoints, not Hugging Face Transformers model directories. They need the MiniMind-O codebase and matching config/model files to load.

SHA256SUMS.txt

@@ -0,0 +1,4 @@
+366ddb7ec27897f0e19b1a0bc9b96eb0370167864f218158c19958969bd1a8b4  checkpoints/sft_ptbr_curriculum_100k_mixed_768.pth
+f44c4b22dba654d17248330a481f2301ef3366f99fa0c46b0cd025b405714791  checkpoints/sft_ptbr_curriculum_100k_t2a_repair_768.pth
+06edc9718b87502ad67ab5c5e9aaba6d72cd453de460e3cd454e6e80f247c7fe  checkpoints/sft_ptbr_curriculum_100k_textfix_768.pth
+60cfc078f9d79fb67b788d7e178be005ce57d7ed6ad4d3670c6d49619c7104d8  data/sft_text_ptbr_curriculum_100k.parquet

data/sft_text_ptbr_curriculum_100k.parquet

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

eval/aula.wav

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

eval/hotel.wav

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

eval/mercado.wav

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

eval/onibus.wav

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

eval/padaria.wav

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

eval/ptbr_talker_eval.csv

@@ -0,0 +1,6 @@
+answer_text,audio_frames,generated_audio,id,looks_portuguese,non_empty_answer_text,non_empty_transcript,pass_basic,prompt,target_style,transcript,valid_mimi_frames,wav_path,whisper_error
+Você está está uma padaria no Brasil.,36,True,padaria,True,True,True,True,Você está em uma padaria no Brasil. Cumprimente o atendente e peça um café com leite.,"português brasileiro, curto, conversa cotidiana","Logo em Steyr, está aí uma padada no prosaile...",36,eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k/padaria.wav,
+"Você está no mercado na quelque aconoros, o que vocês esta espação.",78,True,mercado,True,True,True,True,Você está no mercado. Pergunte onde ficam as frutas e agradeça de forma natural.,"português brasileiro, educado, sem inglês",Vou listar o meu chegado na quadro com búrbios assistentes. Revista a cipação.,78,eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k/mercado.wav,
+Peça ajuda para encontrar a recepção.,38,True,hotel,False,True,True,True,Você chegou em um hotel. Peça ajuda para encontrar a recepção.,"português brasileiro, simples, uma ou duas frases",Eu ajudo a para encontrar esse de passar,38,eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k/hotel.wav,
+"Paraumum aluno o que significa praticar uma língua todos os dias is indeed a debated topic. In theory, it refers to the principal ingredient, which is a type of algae os, commonly found in the savanna, which is a herbaceous herb. There is no evidence to support this conclusion, as the principal ingredient, which is a",112,True,aula,False,True,True,True,Explique para um aluno o que significa praticar uma língua todos os dias.,"português brasileiro, didático, resposta curta","Pera do mundo, o que se caparicar? Como alhar engloar todos os alhas enteidedadas? E inte...",112,eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k/aula.wav,
+Passaê está no pondto de ônibus.,38,True,onibus,True,True,True,True,Você está no ponto de ônibus. Pergunte se aquele ônibus passa pelo centro.,"português brasileiro, fala cotidiana","Faça a pista, um ponto de Salibus.",38,eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k/onibus.wav,

eval/ptbr_talker_eval.jsonl

@@ -0,0 +1,5 @@
+{"id": "padaria", "prompt": "Você está em uma padaria no Brasil. Cumprimente o atendente e peça um café com leite.", "target_style": "português brasileiro, curto, conversa cotidiana", "answer_text": "Você está está uma padaria no Brasil.", "audio_frames": 36, "valid_mimi_frames": 36, "wav_path": "eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k/padaria.wav", "transcript": "Logo em Steyr, está aí uma padada no prosaile...", "whisper_error": "", "generated_audio": true, "non_empty_transcript": true, "looks_portuguese": true, "non_empty_answer_text": true, "pass_basic": true}
+{"id": "mercado", "prompt": "Você está no mercado. Pergunte onde ficam as frutas e agradeça de forma natural.", "target_style": "português brasileiro, educado, sem inglês", "answer_text": "Você está no mercado na quelque aconoros, o que vocês esta espação.", "audio_frames": 78, "valid_mimi_frames": 78, "wav_path": "eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k/mercado.wav", "transcript": "Vou listar o meu chegado na quadro com búrbios assistentes. Revista a cipação.", "whisper_error": "", "generated_audio": true, "non_empty_transcript": true, "looks_portuguese": true, "non_empty_answer_text": true, "pass_basic": true}
+{"id": "hotel", "prompt": "Você chegou em um hotel. Peça ajuda para encontrar a recepção.", "target_style": "português brasileiro, simples, uma ou duas frases", "answer_text": "Peça ajuda para encontrar a recepção.", "audio_frames": 38, "valid_mimi_frames": 38, "wav_path": "eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k/hotel.wav", "transcript": "Eu ajudo a para encontrar esse de passar", "whisper_error": "", "generated_audio": true, "non_empty_transcript": true, "looks_portuguese": false, "non_empty_answer_text": true, "pass_basic": true}
+{"id": "aula", "prompt": "Explique para um aluno o que significa praticar uma língua todos os dias.", "target_style": "português brasileiro, didático, resposta curta", "answer_text": "Paraumum aluno o que significa praticar uma língua todos os dias is indeed a debated topic. In theory, it refers to the principal ingredient, which is a type of algae os, commonly found in the savanna, which is a herbaceous herb. There is no evidence to support this conclusion, as the principal ingredient, which is a", "audio_frames": 112, "valid_mimi_frames": 112, "wav_path": "eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k/aula.wav", "transcript": "Pera do mundo, o que se caparicar? Como alhar engloar todos os alhas enteidedadas? E inte...", "whisper_error": "", "generated_audio": true, "non_empty_transcript": true, "looks_portuguese": false, "non_empty_answer_text": true, "pass_basic": true}
+{"id": "onibus", "prompt": "Você está no ponto de ônibus. Pergunte se aquele ônibus passa pelo centro.", "target_style": "português brasileiro, fala cotidiana", "answer_text": "Passaê está no pondto de ônibus.", "audio_frames": 38, "valid_mimi_frames": 38, "wav_path": "eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k/onibus.wav", "transcript": "Faça a pista, um ponto de Salibus.", "whisper_error": "", "generated_audio": true, "non_empty_transcript": true, "looks_portuguese": true, "non_empty_answer_text": true, "pass_basic": true}

eval/summary.json

@@ -0,0 +1,9 @@
+{
+  "rows": 5,
+  "audio_generated": 5,
+  "transcribed": 5,
+  "looks_portuguese": 3,
+  "basic_pass": 5,
+  "csv": "eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k/ptbr_talker_eval.csv",
+  "jsonl": "eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k/ptbr_talker_eval.jsonl"
+}

file_manifest.json

@@ -0,0 +1,82 @@
+[
+  {
+    "path": "README.md",
+    "size": 2231
+  },
+  {
+    "path": "SHA256SUMS.txt",
+    "size": 467
+  },
+  {
+    "path": "checkpoints/sft_ptbr_curriculum_100k_mixed_768.pth",
+    "size": 236159657
+  },
+  {
+    "path": "checkpoints/sft_ptbr_curriculum_100k_t2a_repair_768.pth",
+    "size": 236160652
+  },
+  {
+    "path": "checkpoints/sft_ptbr_curriculum_100k_textfix_768.pth",
+    "size": 236160055
+  },
+  {
+    "path": "data/ptbr_curriculum_100k.jsonl",
+    "size": 63039962
+  },
+  {
+    "path": "data/sft_text_ptbr_curriculum_100k.parquet",
+    "size": 6016108
+  },
+  {
+    "path": "eval/aula.wav",
+    "size": 430124
+  },
+  {
+    "path": "eval/hotel.wav",
+    "size": 145964
+  },
+  {
+    "path": "eval/mercado.wav",
+    "size": 299564
+  },
+  {
+    "path": "eval/onibus.wav",
+    "size": 145964
+  },
+  {
+    "path": "eval/padaria.wav",
+    "size": 138284
+  },
+  {
+    "path": "eval/ptbr_talker_eval.csv",
+    "size": 2165
+  },
+  {
+    "path": "eval/ptbr_talker_eval.jsonl",
+    "size": 3242
+  },
+  {
+    "path": "eval/summary.json",
+    "size": 277
+  },
+  {
+    "path": "metadata.json",
+    "size": 372
+  },
+  {
+    "path": "tools/build_ptbr_conversation_curriculum.py",
+    "size": 14188
+  },
+  {
+    "path": "tools/eval_minimind_talker_ptbr.py",
+    "size": 7967
+  },
+  {
+    "path": "tools/run_talker_finetune_phases.py",
+    "size": 15193
+  },
+  {
+    "path": "tools/validate_talker_finetune_phases.py",
+    "size": 11771
+  }
+]

metadata.json

@@ -0,0 +1,14 @@
+{
+  "name": "minimind-o-ptbr-talker-curriculum-100k-poc",
+  "date": "2026-05-23",
+  "base": "MiniMind-O 768 native checkpoint",
+  "status": "experimental_poc",
+  "final_eval": {
+    "rows": 5,
+    "audio_generated": 5,
+    "transcribed": 5,
+    "looks_portuguese": 3,
+    "basic_pass": 5
+  },
+  "known_issue": "PT-BR quality and relevance still fail for production use."
+}

tools/build_ptbr_conversation_curriculum.py

@@ -0,0 +1,354 @@
+import argparse
+import json
+import random
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+SYSTEM_TUTOR = (
+    "Você é um tutor educacional em português brasileiro. "
+    "Responda sempre em português brasileiro, de forma curta, natural, correta e sem misturar idiomas."
+)
+
+SYSTEM_ROLEPLAY = (
+    "Você é um personagem em uma simulação de conversa cotidiana em português brasileiro. "
+    "Mantenha o papel, responda de forma curta e natural, e nunca misture inglês."
+)
+
+
+SCENARIOS = [
+    {
+        "name": "padaria",
+        "assistant_role": "atendente de padaria",
+        "user_role": "cliente",
+        "places": ["padaria do bairro", "balcão da padaria", "cafeteria pequena"],
+        "items": ["café com leite", "pão francês", "suco de laranja", "misto quente", "bolo de cenoura"],
+        "turns": [
+            ("Bom dia, você pode me atender?", "Bom dia! Claro, em que posso ajudar?"),
+            ("Quero {item}, por favor.", "Perfeito. Você prefere consumir aqui ou levar?"),
+            ("Para levar. Quanto fica?", "Fica {price} reais. Posso colocar em uma sacola."),
+            ("Pode sim. Aceita cartão?", "Aceitamos cartão, Pix e dinheiro."),
+            ("Obrigado, tenha um bom dia.", "Eu que agradeço. Bom dia e volte sempre."),
+        ],
+    },
+    {
+        "name": "mercado",
+        "assistant_role": "funcionário de mercado",
+        "user_role": "cliente",
+        "places": ["mercado", "supermercado", "mercearia"],
+        "items": ["frutas", "arroz", "leite", "pão de forma", "produtos de limpeza"],
+        "turns": [
+            ("Oi, você trabalha aqui?", "Trabalho sim. Como posso ajudar?"),
+            ("Onde ficam as {item}?", "Ficam no corredor {aisle}, perto da entrada."),
+            ("Tem alguma promoção hoje?", "Tem sim, algumas ofertas estão sinalizadas nas prateleiras."),
+            ("Obrigado pela ajuda.", "Por nada. Qualquer dúvida, pode me chamar."),
+            ("Vou procurar lá então.", "Certo. Espero que encontre o que precisa."),
+        ],
+    },
+    {
+        "name": "hotel",
+        "assistant_role": "recepcionista de hotel",
+        "user_role": "hóspede",
+        "places": ["hotel", "pousada", "recepção"],
+        "items": ["quarto", "café da manhã", "elevador", "reserva", "chave"],
+        "turns": [
+            ("Boa noite, acabei de chegar.", "Boa noite! Seja bem-vindo. Você tem reserva?"),
+            ("Tenho reserva em meu nome.", "Certo, posso conferir seu documento?"),
+            ("Claro. Onde fica a recepção principal?", "Fica logo à direita, depois do sofá."),
+            ("E o café da manhã?", "O café é servido das {hour} às {hour2}, no salão principal."),
+            ("Obrigado pelas informações.", "Disponha. Tenha uma ótima estadia."),
+        ],
+    },
+    {
+        "name": "ônibus",
+        "assistant_role": "passageiro local",
+        "user_role": "pessoa no ponto",
+        "places": ["ponto de ônibus", "terminal", "rua principal"],
+        "items": ["centro", "shopping", "hospital", "faculdade", "estação"],
+        "turns": [
+            ("Com licença, esse ônibus passa pelo {item}?", "Passa sim, mas ele dá uma volta antes."),
+            ("Você sabe quanto tempo demora?", "Normalmente demora uns {minutes} minutos."),
+            ("Preciso pagar em dinheiro?", "Pode pagar com cartão de transporte ou dinheiro."),
+            ("Esse ponto é o correto?", "É sim. Você só precisa esperar a linha {line}."),
+            ("Obrigado pela ajuda.", "De nada. Boa viagem."),
+        ],
+    },
+    {
+        "name": "farmácia",
+        "assistant_role": "atendente de farmácia",
+        "user_role": "cliente",
+        "places": ["farmácia", "drogaria", "balcão"],
+        "items": ["protetor solar", "curativo", "soro fisiológico", "termômetro", "vitamina"],
+        "turns": [
+            ("Boa tarde, preciso de ajuda.", "Boa tarde. O que você procura?"),
+            ("Estou procurando {item}.", "Temos sim. Fica naquela prateleira à esquerda."),
+            ("Você pode me mostrar?", "Claro, eu acompanho você até lá."),
+            ("Tem uma opção mais barata?", "Temos esta opção, que costuma sair por {price} reais."),
+            ("Obrigado, vou levar.", "Perfeito. Pode passar no caixa quando quiser."),
+        ],
+    },
+    {
+        "name": "restaurante",
+        "assistant_role": "garçom",
+        "user_role": "cliente",
+        "places": ["restaurante", "lanchonete", "mesa"],
+        "items": ["prato do dia", "água sem gás", "suco natural", "salada", "sobremesa"],
+        "turns": [
+            ("Olá, posso fazer um pedido?", "Claro. O que você gostaria?"),
+            ("Quero {item}, por favor.", "Ótima escolha. Deseja algo para beber?"),
+            ("Uma água, por favor.", "Certo. Vou trazer seu pedido em alguns minutos."),
+            ("Quanto tempo demora?", "Deve levar cerca de {minutes} minutos."),
+            ("Tudo bem, obrigado.", "Eu que agradeço. Já volto com o pedido."),
+        ],
+    },
+]
+
+
+TUTOR_FACTS = [
+    ("fotossíntese", "Fotossíntese é quando a planta usa luz para produzir alimento.", "ciências"),
+    ("evaporação", "Evaporação é quando a água líquida vira vapor.", "ciências"),
+    ("substantivo", "Substantivo é a palavra que nomeia seres, lugares, objetos ou ideias.", "português"),
+    ("verbo", "Verbo indica ação, estado ou fenômeno da natureza.", "português"),
+    ("democracia", "Democracia é um regime em que o povo participa das decisões.", "história"),
+    ("paisagem", "Paisagem é tudo que podemos observar em um lugar.", "geografia"),
+    ("resumo", "Resumo reúne as ideias principais de um texto.", "hábitos de estudo"),
+    ("revisão", "Revisão ajuda a lembrar e organizar o conteúdo estudado.", "hábitos de estudo"),
+]
+
+
+def render(template, rng):
+    return template.format(
+        item=rng.choice(
+            [
+                "frutas", "café", "pão", "água", "reserva", "centro", "curativo", "leite",
+                "queijo", "bolo", "arroz", "feijão", "maçãs", "banana", "remédio",
+                "protetor solar", "sabonete", "lanche", "suco", "salada", "sobremesa",
+                "elevador", "recepção", "terminal", "hospital", "faculdade", "shopping",
+            ]
+        ),
+        price=f"{rng.randint(6, 89)}",
+        aisle=rng.randint(1, 48),
+        hour=rng.choice(["seis", "sete", "oito", "nove", "dez"]),
+        hour2=rng.choice(["dez", "onze", "meio-dia"]),
+        minutes=str(rng.randint(4, 55)),
+        line=str(rng.randint(100, 899)),
+    )
+
+
+def normalize(text):
+    return " ".join(text.strip().split())
+
+
+def existing_qa_rows(paths):
+    for path in paths:
+        p = Path(path)
+        if not p.exists():
+            continue
+        with p.open("r", encoding="utf-8") as f:
+            for line in f:
+                if not line.strip():
+                    continue
+                try:
+                    row = json.loads(line)
+                except Exception:
+                    continue
+                q = normalize(row.get("question") or row.get("prompt") or "")
+                a = normalize(row.get("answer") or row.get("response") or "")
+                if q and a and len(a.split()) <= 30:
+                    yield {
+                        "source": "existing_qa",
+                        "subject": row.get("subject", "geral"),
+                        "conversations": [
+                            {"role": "system", "content": SYSTEM_TUTOR},
+                            {"role": "user", "content": q},
+                            {"role": "assistant", "content": a},
+                        ],
+                    }
+
+
+def tutor_row(rng):
+    term, answer, subject = rng.choice(TUTOR_FACTS)
+    question = rng.choice(
+        [
+            f"O que é {term}?",
+            f"Explique {term} de forma simples.",
+            f"Me diga em poucas palavras o que significa {term}.",
+            f"Como eu posso entender {term}?",
+        ]
+    )
+    return {
+        "source": "synthetic_tutor",
+        "subject": subject,
+        "conversations": [
+            {"role": "system", "content": SYSTEM_TUTOR},
+            {"role": "user", "content": question},
+            {"role": "assistant", "content": answer},
+        ],
+    }
+
+
+def roleplay_row(rng):
+    scenario = rng.choice(SCENARIOS)
+    detail = rng.choice(
+        [
+            "em uma manhã movimentada",
+            "no fim da tarde",
+            "com pouco tempo disponível",
+            "falando com calma",
+            "em uma situação de prática de idioma",
+            "com atendimento educado",
+        ]
+    )
+    neighborhood = rng.choice(
+        [
+            "Centro", "Liberdade", "Pinheiros", "Savassi", "Boa Viagem", "Botafogo",
+            "Moema", "Copacabana", "Água Verde", "Asa Norte", "Ponta Verde",
+        ]
+    )
+    system = (
+        f"{SYSTEM_ROLEPLAY} Cenário: {rng.choice(scenario['places'])}. "
+        f"Seu papel: {scenario['assistant_role']}. Papel do usuário: {scenario['user_role']}. "
+        f"Detalhe: {detail}, no bairro {neighborhood}."
+    )
+    turns = [{"role": "system", "content": system}]
+    for user, assistant in scenario["turns"]:
+        turns.append({"role": "user", "content": render(user, rng)})
+        turns.append({"role": "assistant", "content": render(assistant, rng)})
+    return {
+        "source": "synthetic_roleplay",
+        "subject": scenario["name"],
+        "conversations": turns,
+    }
+
+
+def anti_english_row(rng):
+    topic = rng.choice(["padaria", "hotel", "mercado", "ônibus", "aula de português"])
+    user = rng.choice(
+        [
+            f"Can you answer in English about {topic}?",
+            f"Explique em português, mas eu escrevi market e bus sem querer.",
+            f"Responda só em português: how do I ask for help in a {topic}?",
+            f"Estou praticando português. Não use inglês quando falar de {topic}.",
+        ]
+    )
+    assistant = rng.choice(
+        [
+            "Claro. Vamos praticar só em português brasileiro, com frases curtas e naturais.",
+            "Tudo bem. Vou responder apenas em português brasileiro e manter a conversa simples.",
+            "Combinado. Vou evitar inglês e seguir o contexto da situação.",
+            "Perfeito. Vamos continuar em português brasileiro, de forma clara e natural.",
+        ]
+    )
+    return {
+        "source": "anti_english",
+        "subject": topic,
+        "conversations": [
+            {"role": "system", "content": SYSTEM_ROLEPLAY},
+            {"role": "user", "content": user},
+            {"role": "assistant", "content": assistant},
+        ],
+    }
+
+
+def math_row(rng):
+    a = rng.randint(2, 999)
+    b = rng.randint(2, 999)
+    op = rng.choice(["mais", "menos", "vezes"])
+    if op == "mais":
+        answer = f"{a} mais {b} é {a + b}."
+    elif op == "menos":
+        x, y = max(a, b), min(a, b)
+        answer = f"{x} menos {y} é {x - y}."
+        a, b = x, y
+    else:
+        a = rng.randint(2, 50)
+        b = rng.randint(2, 50)
+        answer = f"{a} vezes {b} é {a * b}."
+    return {
+        "source": "synthetic_math",
+        "subject": "matemática",
+        "conversations": [
+            {"role": "system", "content": SYSTEM_TUTOR},
+            {"role": "user", "content": f"Quanto é {a} {op} {b}?"},
+            {"role": "assistant", "content": answer},
+        ],
+    }
+
+
+def row_key(row):
+    return json.dumps(row["conversations"], ensure_ascii=False, sort_keys=True)
+
+
+def build_rows(args):
+    rng = random.Random(args.seed)
+    rows = []
+    seen = set()
+
+    for row in existing_qa_rows(args.include_jsonl):
+        key = row_key(row)
+        if key not in seen:
+            seen.add(key)
+            rows.append(row)
+        if len(rows) >= args.count:
+            return rows
+
+    generators = [roleplay_row, roleplay_row, anti_english_row, tutor_row, math_row]
+    attempts = 0
+    while len(rows) < args.count and attempts < args.count * 40:
+        attempts += 1
+        row = rng.choice(generators)(rng)
+        key = row_key(row)
+        if key in seen:
+            continue
+        seen.add(key)
+        rows.append(row)
+    return rows
+
+
+def write_jsonl(rows, path):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def write_parquet(rows, path):
+    conversations = [json.dumps(row["conversations"], ensure_ascii=False) for row in rows]
+    metadata = [json.dumps({"source": row["source"], "subject": row["subject"]}, ensure_ascii=False) for row in rows]
+    n = len(rows)
+    table = pa.table(
+        {
+            "conversations": pa.array(conversations, type=pa.large_string()),
+            "answer_audios": pa.array([[] for _ in range(n)], type=pa.list_(pa.list_(pa.int64()))),
+            "question_audios": pa.array([[] for _ in range(n)]),
+            "ref_audios": pa.array([[] for _ in range(n)], type=pa.list_(pa.int64())),
+            "spk_emb": pa.array([[] for _ in range(n)], type=pa.list_(pa.float64())),
+            "metadata": pa.array(metadata, type=pa.large_string()),
+        }
+    )
+    path.parent.mkdir(parents=True, exist_ok=True)
+    pq.write_table(table, path)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Build a larger PT-BR text SFT curriculum.")
+    parser.add_argument("--count", type=int, default=100000)
+    parser.add_argument("--seed", type=int, default=20260523)
+    parser.add_argument("--include-jsonl", nargs="*", default=["data_ptbr/manifests/tutor_text_sft_50k.jsonl"])
+    parser.add_argument("--out-jsonl", default="data_ptbr/manifests/ptbr_curriculum_100k.jsonl")
+    parser.add_argument("--out-parquet", default="data_ptbr/parquet/sft_text_ptbr_curriculum_100k.parquet")
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    rows = build_rows(args)
+    write_jsonl(rows, Path(args.out_jsonl))
+    write_parquet(rows, Path(args.out_parquet))
+    print(json.dumps({"rows": len(rows), "jsonl": args.out_jsonl, "parquet": args.out_parquet}, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()

tools/eval_minimind_talker_ptbr.py

@@ -0,0 +1,217 @@
+import argparse
+import csv
+import json
+import sys
+from pathlib import Path
+
+import torch
+import soundfile as sf
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from eval_omni import init_model  # noqa: E402
+
+
+PROMPTS = [
+    {
+        "id": "padaria",
+        "prompt": "Você está em uma padaria no Brasil. Cumprimente o atendente e peça um café com leite.",
+        "target_style": "português brasileiro, curto, conversa cotidiana",
+    },
+    {
+        "id": "mercado",
+        "prompt": "Você está no mercado. Pergunte onde ficam as frutas e agradeça de forma natural.",
+        "target_style": "português brasileiro, educado, sem inglês",
+    },
+    {
+        "id": "hotel",
+        "prompt": "Você chegou em um hotel. Peça ajuda para encontrar a recepção.",
+        "target_style": "português brasileiro, simples, uma ou duas frases",
+    },
+    {
+        "id": "aula",
+        "prompt": "Explique para um aluno o que significa praticar uma língua todos os dias.",
+        "target_style": "português brasileiro, didático, resposta curta",
+    },
+    {
+        "id": "onibus",
+        "prompt": "Você está no ponto de ônibus. Pergunte se aquele ônibus passa pelo centro.",
+        "target_style": "português brasileiro, fala cotidiana",
+    },
+]
+
+
+def clean_answer(tokenizer, token_ids):
+    text = tokenizer.decode(token_ids, skip_special_tokens=True)
+    return " ".join(text.replace("\n", " ").split())
+
+
+def generate_one(model, tokenizer, args, sample):
+    messages = [{"role": "user", "content": sample["prompt"]}]
+    inputs_text = tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True,
+        open_thinking=False,
+    )
+    input_ids = tokenizer(inputs_text).data["input_ids"]
+    x = torch.tensor(input_ids, dtype=torch.long, device=args.device)[None, ...]
+
+    audio_frames = []
+    last_tokens = None
+    with torch.no_grad():
+        iterator = model.generate(
+            x,
+            tokenizer.eos_token_id,
+            max_new_tokens=args.max_new_tokens,
+            temperature=args.temperature,
+            top_p=args.top_p,
+            stream=True,
+            return_audio_codes=True,
+            open_thinking=False,
+            audio_inputs=None,
+            audio_lens=None,
+            pixel_values=None,
+            ref_codes=None,
+            spk_emb=None,
+        )
+        for token_ids, audio_frame in iterator:
+            if token_ids is not None:
+                last_tokens = token_ids[0].tolist()
+            if audio_frame:
+                audio_frames.append(audio_frame)
+
+    answer_text = clean_answer(tokenizer, last_tokens or [])
+    codes = [frame for frame in audio_frames if frame and len(frame) == 8]
+    wav_path = None
+
+    if codes:
+        mimi_codes = torch.tensor(codes, dtype=torch.long).T.unsqueeze(0).to(args.device)
+        filtered = torch.where(mimi_codes >= 2049, torch.zeros_like(mimi_codes), mimi_codes)
+        with torch.no_grad():
+            audio = model.mimi_model.decode(filtered).audio_values
+        wav_path = Path(args.output_dir) / f"{sample['id']}.wav"
+        sf.write(wav_path, audio.squeeze().detach().float().cpu().numpy(), args.sample_rate)
+
+    return {
+        "id": sample["id"],
+        "prompt": sample["prompt"],
+        "target_style": sample["target_style"],
+        "answer_text": answer_text,
+        "audio_frames": len(audio_frames),
+        "valid_mimi_frames": len(codes),
+        "wav_path": str(wav_path) if wav_path else "",
+    }
+
+
+def transcribe_rows(rows, args):
+    try:
+        import whisper
+    except Exception as exc:
+        for row in rows:
+            row["whisper_error"] = f"whisper unavailable: {exc}"
+        return rows
+
+    model = whisper.load_model(args.whisper_model)
+    for row in rows:
+        wav_path = row.get("wav_path")
+        if not wav_path:
+            row["transcript"] = ""
+            row["whisper_error"] = "no wav generated"
+            continue
+        try:
+            result = model.transcribe(wav_path, language="pt", fp16=args.device.startswith("cuda"))
+            row["transcript"] = " ".join(result.get("text", "").split())
+            row["whisper_error"] = ""
+        except Exception as exc:
+            row["transcript"] = ""
+            row["whisper_error"] = str(exc)
+    return rows
+
+
+def classify_row(row):
+    transcript = (row.get("transcript") or "").strip()
+    answer = (row.get("answer_text") or "").strip()
+    generated_audio = bool(row.get("wav_path")) and Path(row["wav_path"]).exists()
+    has_pt_hint = any(ch in transcript.lower() for ch in "ãõçáéíóúâêôà") or any(
+        word in transcript.lower().split()
+        for word in ["voce", "você", "obrigado", "onde", "cafe", "café", "onibus", "ônibus", "centro"]
+    )
+    row["generated_audio"] = generated_audio
+    row["non_empty_transcript"] = bool(transcript)
+    row["looks_portuguese"] = bool(transcript and has_pt_hint)
+    row["non_empty_answer_text"] = bool(answer)
+    row["pass_basic"] = bool(generated_audio and transcript and answer)
+    return row
+
+
+def write_outputs(rows, args):
+    out_dir = Path(args.output_dir)
+    jsonl_path = out_dir / "ptbr_talker_eval.jsonl"
+    csv_path = out_dir / "ptbr_talker_eval.csv"
+    summary_path = out_dir / "summary.json"
+
+    with jsonl_path.open("w", encoding="utf-8") as f:
+        for row in rows:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+    fieldnames = sorted({key for row in rows for key in row})
+    with csv_path.open("w", encoding="utf-8", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+
+    summary = {
+        "rows": len(rows),
+        "audio_generated": sum(1 for row in rows if row.get("generated_audio")),
+        "transcribed": sum(1 for row in rows if row.get("non_empty_transcript")),
+        "looks_portuguese": sum(1 for row in rows if row.get("looks_portuguese")),
+        "basic_pass": sum(1 for row in rows if row.get("pass_basic")),
+        "csv": str(csv_path),
+        "jsonl": str(jsonl_path),
+    }
+    summary_path.write_text(json.dumps(summary, ensure_ascii=False, indent=2), encoding="utf-8")
+    return summary
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Generate and transcribe PT-BR MiniMind Talker samples.")
+    parser.add_argument("--load_from", default="model")
+    parser.add_argument("--save_dir", default="out")
+    parser.add_argument("--weight", default="sft_omni_ptbr_talker")
+    parser.add_argument("--hidden_size", type=int, default=768)
+    parser.add_argument("--num_hidden_layers", type=int, default=8)
+    parser.add_argument("--use_moe", type=int, default=0)
+    parser.add_argument("--output-dir", default="eval_ptbr/minimind_talker_ptbr_eval")
+    parser.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
+    parser.add_argument("--max-new-tokens", type=int, default=180)
+    parser.add_argument("--temperature", type=float, default=0.55)
+    parser.add_argument("--top-p", type=float, default=0.8)
+    parser.add_argument("--sample-rate", type=int, default=24000)
+    parser.add_argument("--whisper-model", default="medium")
+    parser.add_argument("--limit", type=int, default=len(PROMPTS))
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    Path(args.output_dir).mkdir(parents=True, exist_ok=True)
+    model, tokenizer = init_model(args)
+
+    rows = []
+    for sample in PROMPTS[: args.limit]:
+        print(f"[eval] {sample['id']}: {sample['prompt']}", flush=True)
+        row = generate_one(model, tokenizer, args, sample)
+        rows.append(row)
+
+    rows = transcribe_rows(rows, args)
+    rows = [classify_row(row) for row in rows]
+    summary = write_outputs(rows, args)
+    print(json.dumps(summary, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()

tools/run_talker_finetune_phases.py

@@ -0,0 +1,356 @@
+import argparse
+import json
+import shlex
+import subprocess
+from pathlib import Path
+
+
+PHASES = [
+    {
+        "id": "phase0_preflight",
+        "title": "Preflight remoto",
+        "estimate": "2 min",
+        "gpu_hours": 0.0,
+        "kind": "validation",
+    },
+    {
+        "id": "phase1_poc_tucano_q4",
+        "title": "POC texto Tucano2 Q4",
+        "estimate": "3-5 min",
+        "gpu_hours": 0.05,
+        "kind": "benchmark",
+    },
+    {
+        "id": "phase2_text_mimi_manifest",
+        "title": "Dataset texto -> Mimi",
+        "estimate": "1-3 min",
+        "gpu_hours": 0.0,
+        "kind": "data",
+    },
+    {
+        "id": "phase3_minimind_talker_t2a",
+        "title": "Fine-tune MiniMind Talker T2A",
+        "estimate": "1-3 h",
+        "gpu_hours": 2.0,
+        "kind": "train",
+    },
+    {
+        "id": "phase4_minimind_eval_whisper",
+        "title": "Avaliação Mimi + Whisper",
+        "estimate": "15-40 min",
+        "gpu_hours": 0.5,
+        "kind": "eval",
+    },
+    {
+        "id": "phase5_simple_text_mimi_talker",
+        "title": "Protótipo Talker separado",
+        "estimate": "20-90 min",
+        "gpu_hours": 1.0,
+        "kind": "train",
+    },
+    {
+        "id": "phase6_report",
+        "title": "Relatório e página",
+        "estimate": "2 min",
+        "gpu_hours": 0.0,
+        "kind": "report",
+    },
+    {
+        "id": "phase7_ptbr_curriculum_dataset",
+        "title": "Currículo PT-BR 100k",
+        "estimate": "2-5 min",
+        "gpu_hours": 0.0,
+        "kind": "data",
+    },
+    {
+        "id": "phase8_ptbr_textfix_sft",
+        "title": "SFT textual PT-BR ampliado",
+        "estimate": "30-90 min",
+        "gpu_hours": 0.8,
+        "kind": "train",
+    },
+    {
+        "id": "phase9_ptbr_t2a_repair",
+        "title": "Reparo T2A após textfix",
+        "estimate": "5-20 min",
+        "gpu_hours": 0.2,
+        "kind": "train",
+    },
+    {
+        "id": "phase10_ptbr_mixed_sft",
+        "title": "SFT misto texto + áudio",
+        "estimate": "40-120 min",
+        "gpu_hours": 1.0,
+        "kind": "train",
+    },
+    {
+        "id": "phase11_ptbr_eval_after_mixed",
+        "title": "Reavaliação PT-BR pós-misto",
+        "estimate": "10-30 min",
+        "gpu_hours": 0.4,
+        "kind": "eval",
+    },
+]
+
+
+def shell_join(parts):
+    return " ".join(shlex.quote(str(part)) for part in parts)
+
+
+def remote_command(args, script):
+    return ["ssh", "-p", str(args.ssh_port), args.remote, f"bash -lc {shlex.quote(script)}"]
+
+
+def phase_script(args, phase_id):
+    repo = shlex.quote(args.repo)
+    if phase_id == "phase0_preflight":
+        return (
+            f"cd {repo} && "
+            "nvidia-smi --query-gpu=name,memory.used,memory.total,utilization.gpu --format=csv,noheader && "
+            "test -f trainer/train_sft_omni.py && "
+            f"test -f {shlex.quote(args.t2a_parquet)} && "
+            f"test -f out/{shlex.quote(args.from_weight)}_768.pth && "
+            "test -f tools_ptbr/eval_generated_with_whisper.py && "
+            "echo PHASE0_OK"
+        )
+    if phase_id == "phase1_poc_tucano_q4":
+        return (
+            f"cd {repo} && "
+            "CUDA_VISIBLE_DEVICES=0 .venv/bin/python tools_ptbr/poc_voice/run_tucano2_tts_poc.py "
+            f"--merged-model {shlex.quote(args.tucano_merged_model)} "
+            "--quantization bnb4 --bnb-4bit-use-double-quant "
+            "--scenarios padaria hotel mercado "
+            "--tts-backend none "
+            f"--out-dir {shlex.quote(args.poc_out_dir)}"
+        )
+    if phase_id == "phase2_text_mimi_manifest":
+        return (
+            f"cd {repo} && "
+            ".venv/bin/python tools_ptbr/talker_text_mimi/build_text_mimi_manifest.py "
+            f"--input-parquet {shlex.quote(args.t2a_parquet)} "
+            f"--out-jsonl {shlex.quote(args.text_mimi_manifest)} "
+            "--min-frames 8 --max-frames 120"
+        )
+    if phase_id == "phase3_minimind_talker_t2a":
+        return (
+            f"cd {repo}/trainer && "
+            "CUDA_VISIBLE_DEVICES=0 ../.venv/bin/python -m torch.distributed.run "
+            f"--master_port {args.master_port} --nproc_per_node 1 train_sft_omni.py "
+            f"--learning_rate {args.talker_lr} "
+            f"--data_path {shlex.quote('../' + args.t2a_parquet if not args.t2a_parquet.startswith('../') else args.t2a_parquet)} "
+            f"--epochs {args.talker_epochs} "
+            f"--batch_size {args.talker_batch_size} "
+            f"--accumulation_steps {args.talker_accumulation_steps} "
+            f"--max_seq_len {args.max_seq_len} "
+            "--use_compile 0 "
+            f"--from_weight {shlex.quote(args.from_weight)} "
+            f"--save_weight {shlex.quote(args.save_weight)} "
+            "--freeze_backbone all --mode all --use_moe 0 "
+            "--grad_clip 1.0 --save_interval 500 --log_interval 50"
+        )
+    if phase_id == "phase4_minimind_eval_whisper":
+        return (
+            f"cd {repo} && "
+            ".venv/bin/python tools_ptbr/eval_minimind_talker_ptbr.py --load_from model --save_dir out "
+            f"--weight {shlex.quote(args.save_weight)} "
+            "--hidden_size 768 --num_hidden_layers 8 --use_moe 0 "
+            "--temperature 0.55 --top-p 0.8 --max-new-tokens 180 "
+            "--whisper-model medium "
+            f"--output-dir {shlex.quote(args.minimind_eval_dir)}"
+        )
+    if phase_id == "phase5_simple_text_mimi_talker":
+        return (
+            f"cd {repo} && "
+            ".venv/bin/python tools_ptbr/talker_text_mimi/train_simple_text_mimi_talker.py "
+            f"--train-jsonl {shlex.quote(args.text_mimi_manifest)} "
+            f"--out-dir {shlex.quote(args.simple_talker_out_dir)} "
+            "--tokenizer Polygl0t/Tucano2-qwen-1.5B-Instruct "
+            "--max-text-tokens 96 --max-frames 96 "
+            "--text-dim 384 --hidden-size 512 --layers 4 --heads 8 "
+            f"--epochs {args.simple_talker_epochs} "
+            f"--batch-size {args.simple_talker_batch_size} "
+            "--grad-accum 4 --learning-rate 3e-4 --log-steps 20 --fp16"
+        )
+    if phase_id == "phase6_report":
+        return (
+            f"cd {repo} && "
+            "python - <<'PY'\n"
+            "import json\n"
+            "from pathlib import Path\n"
+            "items = {}\n"
+            "for path in ['eval_ptbr/poc_voice_tucano_sft_q4/smoke_missing', "
+            f"{args.poc_out_dir!r} + '/summary.json', "
+            f"{args.minimind_eval_dir!r} + '/summary.json', "
+            f"{args.minimind_eval_dir!r} + '/ptbr_talker_eval.csv', "
+            f"{args.simple_talker_out_dir!r} + '/talker.pt']:\n"
+            "    p = Path(path)\n"
+            "    items[str(p)] = p.exists()\n"
+            "Path('eval_ptbr/talker_finetune_phase_status.json').write_text(json.dumps(items, indent=2), encoding='utf-8')\n"
+            "print(json.dumps(items, indent=2))\n"
+            "PY"
+        )
+    if phase_id == "phase7_ptbr_curriculum_dataset":
+        return (
+            f"cd {repo} && "
+            ".venv/bin/python tools_ptbr/build_ptbr_conversation_curriculum.py "
+            f"--count {args.curriculum_count} "
+            f"--out-jsonl {shlex.quote(args.curriculum_jsonl)} "
+            f"--out-parquet {shlex.quote(args.curriculum_parquet)} "
+            "--include-jsonl data_ptbr/manifests/tutor_text_sft_50k.jsonl"
+        )
+    if phase_id == "phase8_ptbr_textfix_sft":
+        return (
+            f"cd {repo}/trainer && "
+            "CUDA_VISIBLE_DEVICES=0 ../.venv/bin/python -m torch.distributed.run "
+            f"--master_port {args.textfix_master_port} --nproc_per_node 1 train_sft_omni.py "
+            "--learning_rate 1e-5 "
+            f"--data_path {shlex.quote('../' + args.curriculum_parquet if not args.curriculum_parquet.startswith('../') else args.curriculum_parquet)} "
+            "--epochs 1 --batch_size 32 --accumulation_steps 1 "
+            f"--max_seq_len {args.max_seq_len} --use_compile 0 "
+            f"--from_weight {shlex.quote(args.save_weight)} "
+            f"--save_weight {shlex.quote(args.curriculum_textfix_weight)} "
+            "--freeze_backbone none --mode all --use_moe 0 "
+            "--grad_clip 1.0 --save_interval 1000 --log_interval 100"
+        )
+    if phase_id == "phase9_ptbr_t2a_repair":
+        return (
+            f"cd {repo}/trainer && "
+            "CUDA_VISIBLE_DEVICES=0 ../.venv/bin/python -m torch.distributed.run "
+            f"--master_port {args.repair_master_port} --nproc_per_node 1 train_sft_omni.py "
+            "--learning_rate 5e-5 "
+            f"--data_path {shlex.quote('../' + args.t2a_parquet if not args.t2a_parquet.startswith('../') else args.t2a_parquet)} "
+            "--epochs 1 --batch_size 16 --accumulation_steps 1 "
+            f"--max_seq_len {args.max_seq_len} --use_compile 0 "
+            f"--from_weight {shlex.quote(args.curriculum_textfix_weight)} "
+            f"--save_weight {shlex.quote(args.curriculum_repair_weight)} "
+            "--freeze_backbone all --mode all --use_moe 0 "
+            "--grad_clip 1.0 --save_interval 500 --log_interval 50"
+        )
+    if phase_id == "phase10_ptbr_mixed_sft":
+        data_path = (
+            f"../{args.curriculum_parquet if not args.curriculum_parquet.startswith('../') else args.curriculum_parquet[3:]},"
+            f"../{args.t2a_parquet if not args.t2a_parquet.startswith('../') else args.t2a_parquet[3:]}"
+        )
+        return (
+            f"cd {repo}/trainer && "
+            "CUDA_VISIBLE_DEVICES=0 ../.venv/bin/python -m torch.distributed.run "
+            f"--master_port {args.mixed_master_port} --nproc_per_node 1 train_sft_omni.py "
+            "--learning_rate 1e-5 "
+            f"--data_path {shlex.quote(data_path)} "
+            "--epochs 1 --batch_size 16 --accumulation_steps 2 "
+            f"--max_seq_len {args.max_seq_len} --use_compile 0 "
+            f"--from_weight {shlex.quote(args.curriculum_repair_weight)} "
+            f"--save_weight {shlex.quote(args.curriculum_mixed_weight)} "
+            "--freeze_backbone last1 --mode all --use_moe 0 "
+            "--grad_clip 1.0 --save_interval 1000 --log_interval 100"
+        )
+    if phase_id == "phase11_ptbr_eval_after_mixed":
+        return (
+            f"cd {repo} && "
+            ".venv/bin/python tools_ptbr/eval_minimind_talker_ptbr.py --load_from model --save_dir out "
+            f"--weight {shlex.quote(args.curriculum_mixed_weight)} "
+            "--hidden_size 768 --num_hidden_layers 8 --use_moe 0 "
+            "--temperature 0.45 --top-p 0.75 --max-new-tokens 120 "
+            "--whisper-model medium "
+            f"--output-dir {shlex.quote(args.curriculum_eval_dir)}"
+        )
+    raise ValueError(f"Unknown phase: {phase_id}")
+
+
+def phase_command(args, phase_id):
+    return remote_command(args, phase_script(args, phase_id))
+
+
+def selected_phases(args):
+    if args.phase == "all":
+        return [phase["id"] for phase in PHASES]
+    return [args.phase]
+
+
+def write_plan(args):
+    payload = {
+        "remote": args.remote,
+        "repo": args.repo,
+        "phases": [
+            {
+                **phase,
+                "command": shell_join(phase_command(args, phase["id"])),
+            }
+            for phase in PHASES
+        ],
+        "totals": {
+            "estimated_gpu_hours": round(sum(phase["gpu_hours"] for phase in PHASES), 2),
+            "wall_clock_prediction": "3-6 h para rodar tudo com 6h PT-BR; 1-2 dias se incluir debug de áudio/escuta.",
+        },
+    }
+    out = Path(args.plan_json)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(json.dumps({"plan_json": str(out), "phases": len(PHASES)}, ensure_ascii=False, indent=2))
+
+
+def run_phase(args, phase_id):
+    command = phase_command(args, phase_id)
+    print(f"\n## {phase_id}")
+    print(shell_join(command))
+    if args.execute:
+        subprocess.run(command, check=True)
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Run or print PT-BR Talker fine-tuning phases.")
+    parser.add_argument(
+        "phase",
+        choices=["all"] + [phase["id"] for phase in PHASES],
+        nargs="?",
+        default="phase0_preflight",
+    )
+    parser.add_argument("--execute", action="store_true")
+    parser.add_argument("--write-plan", action="store_true")
+    parser.add_argument("--plan-json", default="talker_finetune_checklist/phases.json")
+    parser.add_argument("--remote", default="root@194.228.55.129")
+    parser.add_argument("--ssh-port", type=int, default=33445)
+    parser.add_argument("--repo", default="/workspace/minimind-o")
+    parser.add_argument("--t2a-parquet", default="data_ptbr/parquet/sft_t2a_ptbr_poc.parquet")
+    parser.add_argument(
+        "--tucano-merged-model",
+        default="out_tucano2/tucano2_1p5b_instruct_lora_gemini20_pass_1811/merged",
+    )
+    parser.add_argument("--poc-out-dir", default="eval_ptbr/poc_voice_tucano_sft_q4")
+    parser.add_argument("--text-mimi-manifest", default="data_ptbr/talker_text_mimi/train_poc.jsonl")
+    parser.add_argument("--from-weight", default="sft_omni")
+    parser.add_argument("--save-weight", default="sft_omni_ptbr_talker")
+    parser.add_argument("--talker-lr", type=float, default=2e-5)
+    parser.add_argument("--talker-epochs", type=int, default=2)
+    parser.add_argument("--talker-batch-size", type=int, default=16)
+    parser.add_argument("--talker-accumulation-steps", type=int, default=2)
+    parser.add_argument("--max-seq-len", type=int, default=512)
+    parser.add_argument("--master-port", type=int, default=29560)
+    parser.add_argument("--minimind-eval-dir", default="eval_ptbr/minimind_talker_ptbr_eval")
+    parser.add_argument("--minimind-whisper-csv", default="eval_ptbr/minimind_talker_ptbr_whisper.csv")
+    parser.add_argument("--simple-talker-out-dir", default="checkpoints/text_mimi_talker_poc")
+    parser.add_argument("--simple-talker-epochs", type=int, default=5)
+    parser.add_argument("--simple-talker-batch-size", type=int, default=8)
+    parser.add_argument("--curriculum-count", type=int, default=100000)
+    parser.add_argument("--curriculum-jsonl", default="data_ptbr/manifests/ptbr_curriculum_100k.jsonl")
+    parser.add_argument("--curriculum-parquet", default="data_ptbr/parquet/sft_text_ptbr_curriculum_100k.parquet")
+    parser.add_argument("--curriculum-textfix-weight", default="sft_ptbr_curriculum_100k_textfix")
+    parser.add_argument("--curriculum-repair-weight", default="sft_ptbr_curriculum_100k_t2a_repair")
+    parser.add_argument("--curriculum-mixed-weight", default="sft_ptbr_curriculum_100k_mixed")
+    parser.add_argument("--curriculum-eval-dir", default="eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k")
+    parser.add_argument("--textfix-master-port", type=int, default=29571)
+    parser.add_argument("--repair-master-port", type=int, default=29572)
+    parser.add_argument("--mixed-master-port", type=int, default=29573)
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    if args.write_plan:
+        write_plan(args)
+    for phase_id in selected_phases(args):
+        run_phase(args, phase_id)
+
+
+if __name__ == "__main__":
+    main()

tools/validate_talker_finetune_phases.py

@@ -0,0 +1,264 @@
+import argparse
+import json
+import subprocess
+from pathlib import Path
+
+
+REMOTE_SCRIPT = r'''
+import csv
+import json
+import re
+from pathlib import Path
+
+status = {}
+
+def item(key, ok, label, detail="", artifacts=None):
+    status[key] = {
+        "ok": bool(ok),
+        "label": label,
+        "detail": detail,
+        "artifacts": artifacts or [],
+    }
+
+repo = Path(".")
+
+preflight_files = [
+    Path("trainer/train_sft_omni.py"),
+    Path("data_ptbr/parquet/sft_t2a_ptbr_poc.parquet"),
+    Path("out/sft_omni_768.pth"),
+    Path("tools_ptbr/eval_generated_with_whisper.py"),
+]
+item(
+    "phase0_preflight",
+    all(p.exists() for p in preflight_files),
+    "Preflight remoto",
+    ", ".join(f"{p}:{'ok' if p.exists() else 'missing'}" for p in preflight_files),
+)
+
+poc_summary = Path("eval_ptbr/poc_voice_tucano_sft_q4_smoke/summary.json")
+if not poc_summary.exists():
+    poc_summary = Path("eval_ptbr/poc_voice_tucano_sft_q4/summary.json")
+if poc_summary.exists():
+    try:
+        summary = json.loads(poc_summary.read_text(encoding="utf-8"))
+    except Exception:
+        summary = {}
+    item("phase1_poc_tucano_q4", True, "POC texto Tucano2 Q4", json.dumps(summary, ensure_ascii=False), [str(poc_summary)])
+else:
+    item("phase1_poc_tucano_q4", False, "POC texto Tucano2 Q4", "summary.json não encontrado")
+
+try:
+    import pyarrow.parquet as pq
+    t2a = Path("data_ptbr/parquet/sft_t2a_ptbr_poc.parquet")
+    text = Path("data_ptbr/parquet/sft_text_tutor_ptbr_50k.parquet")
+    manifest = Path("data_ptbr/talker_text_mimi/train_poc.jsonl")
+    t2a_rows = pq.read_table(t2a).num_rows if t2a.exists() else 0
+    text_rows = pq.read_table(text).num_rows if text.exists() else 0
+    manifest_rows = sum(1 for _ in manifest.open("r", encoding="utf-8")) if manifest.exists() else 0
+    ok = t2a_rows >= 2000 and manifest_rows >= 1000 and text_rows >= 50000
+    detail = f"T2A={t2a_rows} linhas; manifest texto->Mimi={manifest_rows}; SFT textual={text_rows}"
+    item("phase2_text_mimi_manifest", ok, "Dataset e manifest", detail, [str(t2a), str(text), str(manifest)])
+except Exception as exc:
+    item("phase2_text_mimi_manifest", False, "Dataset e manifest", f"erro ao ler parquet/jsonl: {exc}")
+
+ckpt = Path("out/sft_omni_ptbr_talker_768.pth")
+latest = Path("logs/talker_phase3.latest")
+log_path = Path(latest.read_text(encoding="utf-8").strip()) if latest.exists() else None
+log_text = log_path.read_text(encoding="utf-8", errors="replace") if log_path and log_path.exists() else ""
+ok_train = ckpt.exists() and ckpt.stat().st_size > 100_000_000 and "Epoch:[2/2](174/174)" in log_text
+detail_train = f"checkpoint={'ok' if ckpt.exists() else 'missing'}; size_mb={round(ckpt.stat().st_size/1024/1024,1) if ckpt.exists() else 0}; log={log_path or 'missing'}"
+item("phase3_minimind_talker_t2a", ok_train, "Fine-tune Talker", detail_train, [str(ckpt), str(log_path) if log_path else ""])
+
+eval_dir = Path("eval_ptbr/minimind_talker_ptbr_eval")
+eval_summary = eval_dir / "summary.json"
+eval_csv = eval_dir / "ptbr_talker_eval.csv"
+wav_files = sorted(eval_dir.glob("*.wav")) if eval_dir.exists() else []
+eval_detail = "avaliação ainda não rodada"
+eval_ok = False
+if eval_summary.exists():
+    try:
+        summary = json.loads(eval_summary.read_text(encoding="utf-8"))
+    except Exception:
+        summary = {}
+    eval_ok = summary.get("audio_generated", 0) > 0 and summary.get("transcribed", 0) > 0
+    eval_detail = json.dumps(summary, ensure_ascii=False)
+item("phase4_minimind_eval_whisper", eval_ok, "Geração de áudio + Whisper", eval_detail, [str(eval_summary), str(eval_csv)] + [str(p) for p in wav_files[:5]])
+
+quality_rows = []
+if eval_csv.exists():
+    expected = {
+        "padaria": ["padaria", "café", "cafe", "atendente"],
+        "mercado": ["mercado", "frutas", "onde"],
+        "hotel": ["hotel", "recepção", "recepcao"],
+        "aula": ["língua", "lingua", "praticar", "todos os dias"],
+        "onibus": ["ônibus", "onibus", "centro"],
+    }
+    english_or_hallucination = {
+        "the", "is", "surface", "volcano", "volcanic", "earth", "mythical", "creature",
+        "lord", "rings", "estate", "san diego", "parent", "peak", "despair", "auxiliary",
+    }
+    with eval_csv.open(encoding="utf-8") as f:
+        for row in csv.DictReader(f):
+            text = f"{row.get('answer_text','')} {row.get('transcript','')}".lower()
+            keys = expected.get(row.get("id", ""), [])
+            keyword_ok = any(key in text for key in keys)
+            english_bad = any(re.search(rf"\b{re.escape(word)}\b", text) for word in english_or_hallucination)
+            nonlatin_bad = bool(re.search(r"[\u3040-\u30ff\u3400-\u9fff\uac00-\ud7af�]", text))
+            too_long = len(text.split()) > 95
+            ok = bool(row.get("generated_audio") == "True" and row.get("transcript") and keyword_ok and not english_bad and not nonlatin_bad and not too_long)
+            issues = []
+            if not keyword_ok:
+                issues.append("baixa relevância")
+            if english_bad:
+                issues.append("inglês/alucinação")
+            if nonlatin_bad:
+                issues.append("caracteres não PT-BR")
+            if too_long:
+                issues.append("resposta longa")
+            quality_rows.append((row.get("id", ""), ok, ", ".join(issues) or "ok"))
+quality_ok = bool(quality_rows) and all(ok for _, ok, _ in quality_rows)
+quality_detail = "; ".join(f"{name}:{'ok' if ok else issue}" for name, ok, issue in quality_rows) if quality_rows else "sem CSV de avaliação"
+item(
+    "phase4_quality_ptbr",
+    quality_ok,
+    "Qualidade PT-BR e relevância",
+    quality_detail,
+    [str(eval_csv)],
+)
+
+simple_ckpt = Path("checkpoints/text_mimi_talker_poc/talker.pt")
+smoke_ckpt = Path("/tmp/text_mimi_talker_smoke/talker.pt")
+item(
+    "phase5_simple_text_mimi_talker",
+    simple_ckpt.exists() or smoke_ckpt.exists(),
+    "Protótipo Talker separado",
+    f"full={simple_ckpt.exists()}; smoke={smoke_ckpt.exists()}",
+    [str(simple_ckpt), str(smoke_ckpt)],
+)
+
+report = Path("eval_ptbr/talker_finetune_phase_status.json")
+item("phase6_report", report.exists(), "Relatório final", f"status_json={report.exists()}", [str(report)])
+
+curriculum = Path("data_ptbr/parquet/sft_text_ptbr_curriculum_100k.parquet")
+curriculum_jsonl = Path("data_ptbr/manifests/ptbr_curriculum_100k.jsonl")
+try:
+    import pyarrow.parquet as pq
+    curriculum_rows = pq.read_table(curriculum).num_rows if curriculum.exists() else 0
+except Exception:
+    curriculum_rows = 0
+item(
+    "phase7_ptbr_curriculum_dataset",
+    curriculum_rows >= 100000,
+    "Currículo PT-BR 100k",
+    f"linhas={curriculum_rows}",
+    [str(curriculum), str(curriculum_jsonl)],
+)
+
+pipeline_latest = Path("logs/ptbr_curriculum_pipeline.latest")
+pipeline_log_path = Path(pipeline_latest.read_text(encoding="utf-8").strip()) if pipeline_latest.exists() else None
+pipeline_log = pipeline_log_path.read_text(encoding="utf-8", errors="replace") if pipeline_log_path and pipeline_log_path.exists() else ""
+
+for key, label, weight, marker in [
+    ("phase8_ptbr_textfix_sft", "SFT textual PT-BR ampliado", "sft_ptbr_curriculum_100k_textfix", "===== PHASE9"),
+    ("phase9_ptbr_t2a_repair", "Reparo T2A após textfix", "sft_ptbr_curriculum_100k_t2a_repair", "===== PHASE10"),
+    ("phase10_ptbr_mixed_sft", "SFT misto texto + áudio", "sft_ptbr_curriculum_100k_mixed", "===== PHASE11"),
+]:
+    ckpt_path = Path(f"out/{weight}_768.pth")
+    complete = marker in pipeline_log
+    item(
+        key,
+        ckpt_path.exists() and ckpt_path.stat().st_size > 100_000_000 and complete,
+        label,
+        f"checkpoint={'ok' if ckpt_path.exists() else 'missing'}; complete={complete}; size_mb={round(ckpt_path.stat().st_size/1024/1024,1) if ckpt_path.exists() else 0}",
+        [str(ckpt_path), str(pipeline_log_path) if pipeline_log_path else ""],
+    )
+
+eval2_dir = Path("eval_ptbr/minimind_talker_ptbr_eval_curriculum_100k")
+eval2_summary = eval2_dir / "summary.json"
+eval2_csv = eval2_dir / "ptbr_talker_eval.csv"
+eval2_wavs = sorted(eval2_dir.glob("*.wav")) if eval2_dir.exists() else []
+eval2_ok = False
+eval2_detail = "avaliação ainda não rodada"
+if eval2_summary.exists():
+    try:
+        summary = json.loads(eval2_summary.read_text(encoding="utf-8"))
+    except Exception:
+        summary = {}
+    eval2_ok = summary.get("audio_generated", 0) > 0 and summary.get("transcribed", 0) > 0
+    eval2_detail = json.dumps(summary, ensure_ascii=False)
+item(
+    "phase11_ptbr_eval_after_mixed",
+    eval2_ok,
+    "Reavaliação PT-BR pós-misto",
+    eval2_detail,
+    [str(eval2_summary), str(eval2_csv)] + [str(p) for p in eval2_wavs[:5]],
+)
+
+quality2_rows = []
+if eval2_csv.exists():
+    expected = {
+        "padaria": ["padaria", "café", "cafe", "atendente"],
+        "mercado": ["mercado", "frutas", "onde"],
+        "hotel": ["hotel", "recepção", "recepcao"],
+        "aula": ["língua", "lingua", "praticar", "todos os dias"],
+        "onibus": ["ônibus", "onibus", "centro"],
+    }
+    bad_words = {
+        "the", "is", "surface", "volcano", "volcanic", "earth", "mythical", "creature",
+        "lord", "rings", "estate", "san diego", "parent", "peak", "despair", "auxiliary",
+    }
+    with eval2_csv.open(encoding="utf-8") as f:
+        for row in csv.DictReader(f):
+            text = f"{row.get('answer_text','')} {row.get('transcript','')}".lower()
+            keys = expected.get(row.get("id", ""), [])
+            keyword_ok = any(key in text for key in keys)
+            english_bad = any(re.search(rf"\b{re.escape(word)}\b", text) for word in bad_words)
+            nonlatin_bad = bool(re.search(r"[\u3040-\u30ff\u3400-\u9fff\uac00-\ud7af�]", text))
+            too_long = len(text.split()) > 95
+            ok = bool(row.get("generated_audio") == "True" and row.get("transcript") and keyword_ok and not english_bad and not nonlatin_bad and not too_long)
+            issues = []
+            if not keyword_ok:
+                issues.append("baixa relevância")
+            if english_bad:
+                issues.append("inglês/alucinação")
+            if nonlatin_bad:
+                issues.append("caracteres não PT-BR")
+            if too_long:
+                issues.append("resposta longa")
+            quality2_rows.append((row.get("id", ""), ok, ", ".join(issues) or "ok"))
+quality2_ok = bool(quality2_rows) and all(ok for _, ok, _ in quality2_rows)
+quality2_detail = "; ".join(f"{name}:{'ok' if ok else issue}" for name, ok, issue in quality2_rows) if quality2_rows else "sem CSV de avaliação"
+item("phase11_quality_ptbr_after_mixed", quality2_ok, "Qualidade PT-BR pós-misto", quality2_detail, [str(eval2_csv)])
+
+print(json.dumps(status, ensure_ascii=False, indent=2))
+'''
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Validate remote PT-BR Talker fine-tuning phases.")
+    parser.add_argument("--remote", default="root@194.228.55.129")
+    parser.add_argument("--ssh-port", type=int, default=33445)
+    parser.add_argument("--repo", default="/workspace/minimind-o")
+    parser.add_argument("--out-json", default="talker_finetune_checklist/validation_status.json")
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+    command = [
+        "ssh",
+        "-p",
+        str(args.ssh_port),
+        args.remote,
+        f"cd {args.repo} && .venv/bin/python -",
+    ]
+    result = subprocess.run(command, input=REMOTE_SCRIPT, text=True, capture_output=True, check=True)
+    status = json.loads(result.stdout)
+    out = Path(args.out_json)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(status, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(json.dumps(status, ensure_ascii=False, indent=2))
+
+
+if __name__ == "__main__":
+    main()