feat: atualizar train.py com novo formato de prompt EDA e função de inferência

- Adicionar EDA_SYSTEM_PROMPT com regras analíticas focadas em insights
- Simplificar format_prompt() para usar apenas input/output
- Adicionar função analyze_schema() para inferência após treinamento
- Corrigir erros de sintaxe (true -> True)
- Remover lógica complexa de autenticação, manter push_to_hub simples

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow 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
-*.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

Dockerfile

@@ -1,42 +0,0 @@
-FROM huggingface/transformers-pytorch-gpu:latest
-
-WORKDIR /app
-
-# Instalar dependências do sistema
-# python-is-python3 cria automaticamente o symlink python -> python3
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    git \
-    python3 \
-    python3-pip \
-    python-is-python3 \
-    && rm -rf /var/lib/apt/lists/*
-
-# Verificar que python está disponível (entrypoint do NVIDIA precisa)
-RUN python --version && \
-    python3 --version && \
-    echo "✅ Python disponível: $(which python)"
-
-# Instalar dependências Python
-COPY requirements.txt .
-RUN python3 -m pip install --no-cache-dir --upgrade pip && \
-    python3 -m pip install --no-cache-dir -r requirements.txt
-
-# Copiar scripts de treinamento
-COPY train.py /app/train.py
-COPY app.py /app/app.py
-
-# Criar diretório de logs
-RUN mkdir -p /app/logs
-
-# Configurar variáveis de ambiente padrão (podem ser sobrescritas)
-ENV MODEL_NAME=microsoft/Phi-3-mini-4k-instruct
-ENV DATASET_REPO=beAnalytic/eda-training-dataset
-ENV OUTPUT_REPO=beAnalytic/eda-llm-model
-ENV OMP_NUM_THREADS=1
-ENV PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
-
-# Executar treinamento
-# Usar 'python' (que será o symlink para python3 criado acima)
-# O entrypoint do NVIDIA espera 'python' estar disponível
-CMD ["python", "/app/app.py"]
-

README.md

@@ -1,73 +0,0 @@
----
-title: EDA Model Training
-emoji: 🤖
-colorFrom: blue
-colorTo: purple
-sdk: docker
-sdk_version: "latest"
-app_file: app.py
-pinned: false
----
-
-# Treinamento do Modelo EDA
-
-Este Space contém o script de treinamento para o modelo de Análise Exploratória de Dados (EDA).
-
-## Configuração
-
-### Variáveis de Ambiente Obrigatórias
-
-**⚠️ IMPORTANTE**: Configure a variável de ambiente `HF_TOKEN` no Settings do Space para habilitar o push automático dos checkpoints para o Hub.
-
-### Variáveis de Ambiente
-
-Configure as seguintes variáveis de ambiente no Settings do Space:
-
-- **`HF_TOKEN`** (OBRIGATÓRIO): Seu token do HuggingFace com permissões de escrita
-  - Gere em: https://huggingface.co/settings/tokens
-  - Permissões necessárias: `write`
-  - Sem este token, o treinamento funcionará mas os checkpoints não serão enviados ao Hub
-
-- `MODEL_NAME`: Modelo base (padrão: `microsoft/Phi-3-mini-4k-instruct`)
-- `DATASET_REPO`: ID do dataset (padrão: `beAnalytic/eda-training-dataset`)
-- `OUTPUT_REPO`: ID do modelo de saída (padrão: `beAnalytic/eda-llm-model`)
-
-### Como Configurar HF_TOKEN no Space
-
-1. Acesse: https://huggingface.co/spaces/beAnalytic/Training/settings
-2. Vá para a seção **"Repository secrets"**
-3. Clique em **"New secret"**
-4. Nome: `HF_TOKEN`
-5. Valor: Cole seu token do HuggingFace
-6. Clique em **"Add secret"**
-
-**Nota**: O token será usado automaticamente pelo script durante o treinamento.
-
-### Execução
-
-O script `train.py` será executado automaticamente quando o Space for iniciado.
-
-## Estrutura
-
-- `train.py`: Script principal de treinamento
-- `training_config.json`: Configurações de treinamento
-- `requirements.txt`: Dependências Python
-
-## Monitoramento
-
-Acompanhe o progresso do treinamento através dos logs do Space na aba "Logs".
-
-### TensorBoard
-
-O TensorBoard está configurado e rodando na porta 6006 dentro do container. No HuggingFace Space com Docker SDK, apenas a porta 7860 é exposta publicamente, então o TensorBoard não é acessível diretamente via URL.
-
-**Para visualizar métricas**:
-- Durante o treinamento: Acompanhe os logs na aba "Logs"
-- Após o treinamento: Baixe os logs de `./results/` e execute `tensorboard --logdir=./results` localmente
-- Acesse: http://localhost:6006 (após baixar os logs)
-
-Para mais detalhes, consulte [ACESSAR_TENSORBOARD.md](../huggingface_training_config/docs/ACESSAR_TENSORBOARD.md).
-
-## Resultados
-
-O modelo treinado será salvo automaticamente no HuggingFace Hub no repositório especificado em `OUTPUT_REPO`.

app.py

@@ -1,94 +0,0 @@
-#!/usr/bin/env python3
-"""
-App principal para execução no HuggingFace Space.
-Este arquivo executa o treinamento do modelo EDA e inicia o TensorBoard.
-"""
-
-import os
-import subprocess
-import sys
-import threading
-import time
-
-def start_tensorboard():
-    """
-    Inicia o TensorBoard em background, verificando se já está rodando.
-    """
-    # Os logs do TensorBoard são salvos no output_dir (./results) quando report_to=["tensorboard"]
-    # Criar diretório de resultados se não existir
-    results_dir = os.path.join(os.path.dirname(__file__), "results")
-    os.makedirs(results_dir, exist_ok=True)
-    
-    # Verificar se TensorBoard já está rodando na porta 6006
-    import socket
-    port_in_use = False
-    try:
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        result = sock.connect_ex(('0.0.0.0', 6006))
-        if result == 0:
-            port_in_use = True
-        sock.close()
-    except Exception:
-        pass
-    
-    if port_in_use:
-        print("=" * 60)
-        print("⚠️ TensorBoard já está rodando na porta 6006")
-        print("=" * 60)
-        return
-    
-    print("=" * 60)
-    print("Iniciando TensorBoard...")
-    print(f"Logdir: {results_dir}")
-    print("TensorBoard estará disponível na interface do HuggingFace Space")
-    print("=" * 60)
-    
-    # Matar qualquer processo TensorBoard anterior (se houver)
-    os.system("pkill -f 'tensorboard.*6006' 2>/dev/null || true")
-    time.sleep(1)
-    
-    # Iniciar TensorBoard em background
-    # IMPORTANTE: Os logs são salvos em ./results quando report_to=["tensorboard"]
-    # Porta 6006 é a porta padrão do TensorBoard
-    os.system("tensorboard --logdir=results --host=0.0.0.0 --port=6006 > /dev/null 2>&1 &")
-    
-    # Aguardar um pouco para garantir que o TensorBoard iniciou
-    time.sleep(2)
-    print("✅ TensorBoard iniciado em background")
-
-def main():
-    """
-    Executa o script de treinamento.
-    """
-    # Iniciar TensorBoard em thread separada
-    tensorboard_thread = threading.Thread(target=start_tensorboard, daemon=True)
-    tensorboard_thread.start()
-    
-    print("=" * 60)
-    print("Iniciando treinamento do modelo EDA")
-    print("=" * 60)
-    
-    script_path = os.path.join(os.path.dirname(__file__), "train.py")
-    
-    if not os.path.exists(script_path):
-        print(f"❌ Erro: Arquivo {script_path} não encontrado!")
-        sys.exit(1)
-    
-    try:
-        result = subprocess.run(
-            [sys.executable, script_path],
-            check=True,
-            capture_output=False,
-        )
-        print("\n✅ Treinamento concluído com sucesso!")
-        return result.returncode
-    except subprocess.CalledProcessError as e:
-        print(f"\n❌ Erro durante o treinamento: {e}")
-        sys.exit(e.returncode)
-    except KeyboardInterrupt:
-        print("\n⚠️ Treinamento interrompido pelo usuário")
-        sys.exit(130)
-
-if __name__ == "__main__":
-    sys.exit(main())
-

requirements.txt

@@ -1,9 +0,0 @@
-torch>=2.0.0
-transformers>=4.45.0
-datasets>=2.14.0
-peft>=0.8.0
-accelerate>=0.27.0
-bitsandbytes>=0.41.0
-huggingface_hub>=0.20.0
-tensorboard>=2.15.0
-

train.py

@@ -14,107 +14,16 @@ from transformers import (
 )
 from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
 from transformers import BitsAndBytesConfig
-from huggingface_hub import login as hf_login, logout as hf_logout
 import torch
-import os
-import json
-from datetime import datetime
-from pathlib import Path
 
-# Configuração (pode ser sobrescrita por variáveis de ambiente)
-MODEL_NAME = os.getenv("MODEL_NAME", "microsoft/Phi-3-mini-4k-instruct")
-DATASET_REPO = os.getenv("DATASET_REPO", "beAnalytic/eda-training-dataset")
-OUTPUT_REPO = os.getenv("OUTPUT_REPO", "beAnalytic/eda-llm-model")
-HF_TOKEN = os.getenv("HF_TOKEN")
-
-# Autenticar no HuggingFace se token estiver disponível
-# IMPORTANTE: Limpar qualquer token do ambiente se não estiver configurado explicitamente
-push_to_hub_enabled = False
-
-# Primeiro, limpar qualquer autenticação existente para garantir estado limpo
-try:
-    hf_logout()
-except Exception:
-    pass
-
-# Limpar tokens alternativos do ambiente (mantém HF_TOKEN que será usado depois)
-tokens_to_remove = ["HUGGING_FACE_HUB_TOKEN", "HF_HUB_TOKEN", "HUGGINGFACE_HUB_TOKEN"]
-for token_var in tokens_to_remove:
-    if token_var in os.environ:
-        del os.environ[token_var]
-
-# Limpar cache de autenticação (hf_logout já faz isso)
-try:
-    hf_logout()
-except Exception:
-    pass
-
-if HF_TOKEN and HF_TOKEN.strip():
-    print("Autenticando no HuggingFace Hub...")
-    try:
-        hf_login(token=HF_TOKEN, add_to_git_credential=False)
-        print("✅ Autenticação bem-sucedida!")
-        push_to_hub_enabled = True
-    except Exception as e:
-        print(f"⚠️ Aviso: Erro ao autenticar no HuggingFace: {e}")
-        print("O treinamento continuará, mas o push para o Hub será desabilitado.")
-        push_to_hub_enabled = False
-        # Limpar novamente após falha
-        try:
-            hf_logout()
-        except Exception:
-            pass
-else:
-    print("⚠️ Aviso: HF_TOKEN não encontrado ou vazio. O push para o Hub será desabilitado.")
-    print("Configure a variável de ambiente HF_TOKEN no Space para habilitar push automático.")
-    push_to_hub_enabled = False
+# Configuração
+MODEL_NAME = "microsoft/Phi-3-mini-4k-instruct"
+DATASET_REPO = "beAnalytic/eda-training-dataset"
+OUTPUT_REPO = "beAnalytic/eda-llm-model"
 
 # Carregar dataset
 print(f"Carregando dataset: {DATASET_REPO}")
-try:
-    # Tentar carregar o arquivo JSONL expandido diretamente
-    print("Carregando dataset_balanceado_messages_expandido.jsonl...")
-    dataset_raw = load_dataset(
-        DATASET_REPO,
-        data_files={"train": "dataset_balanceado_messages_expandido.jsonl"},
-        verification_mode="no_checks",
-        split="train"
-    )
-    print(f"✅ Arquivo carregado: {len(dataset_raw)} exemplos")
-    
-    # Dividir em train/validation (80/20)
-    print("Dividindo em train/validation (80/20)...")
-    dataset_split = dataset_raw.train_test_split(test_size=0.2, seed=42)
-    dataset = {
-        "train": dataset_split["train"],
-        "validation": dataset_split["test"]
-    }
-    print(f"✅ Dataset preparado: {len(dataset['train'])} exemplos de treino, {len(dataset['validation'])} exemplos de validação")
-    
-except Exception as e:
-    print(f"⚠️ Erro ao carregar arquivo específico: {e}")
-    print("Tentando carregar dataset padrão do repositório...")
-    try:
-        dataset = load_dataset(DATASET_REPO)
-        print(f"✅ Dataset padrão carregado")
-        if "train" not in dataset:
-            # Se não tiver split, criar
-            if len(dataset) == 1:
-                split_name = list(dataset.keys())[0]
-                dataset_raw = dataset[split_name]
-                dataset = dataset_raw.train_test_split(test_size=0.2, seed=42)
-                dataset = {
-                    "train": dataset["train"],
-                    "validation": dataset["test"]
-                }
-                print(f"✅ Dataset dividido: {len(dataset['train'])} treino, {len(dataset['validation'])} validação")
-    except Exception as e2:
-        print(f"❌ Erro ao carregar dataset: {e2}")
-        raise
-
-# Configurar variáveis de ambiente para evitar problemas de memória
-os.environ["OMP_NUM_THREADS"] = "1"
-os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True")
+dataset = load_dataset(DATASET_REPO)
 
 # Carregar modelo e tokenizer
 print(f"Carregando modelo: {MODEL_NAME}")
@@ -134,7 +43,6 @@ model = AutoModelForCausalLM.from_pretrained(
     quantization_config=bnb_config,
     device_map="auto",
     trust_remote_code=True,
-    use_cache=False,
 )
 
 # Preparar modelo para LoRA
@@ -153,50 +61,36 @@ peft_config = LoraConfig(
 model = get_peft_model(model, peft_config)
 
 # Formatar prompts
+EDA_SYSTEM_PROMPT = (
+    "Você é um analista de dados experiente, focado em gerar INSIGHTS e não em descrever processos técnicos.\n\n"
+    "Sua tarefa é realizar uma Análise Exploratória de Dados (EDA) extraindo padrões, tendências e comportamentos relevantes dos dados.\n\n"
+    "REGRAS OBRIGATÓRIAS:\n\n"
+    "1. NÃO descreva etapas técnicas, bibliotecas, código ou ferramentas (pandas, Python, gráficos, etc.).\n"
+    "2. NÃO explique \"como fazer\" a análise.\n"
+    "3. Extraia padrões, tendências e comportamentos relevantes dos dados.\n"
+    "4. Diferencie claramente:\n"
+    "   • Observação (o que é visível nos dados)\n"
+    "   • Interpretação (o que isso pode significar)\n"
+    "   • Insight (qual a implicação prática ou de negócio)\n"
+    "5. Declare explicitamente o nível de confiança de cada insight (alto / médio / baixo).\n"
+    "6. Quando não houver dados suficientes, diga claramente \"não é possível afirmar\".\n\n"
+    "FORMATO OBRIGATÓRIO DA RESPOSTA:\n\n"
+    "Observações:\n"
+    "- …\n\n"
+    "Interpretações:\n"
+    "- …\n\n"
+    "Insights:\n"
+    "- …\n\n"
+    "Nível de confiança:\n"
+    "- …\n\n"
+    "OBJETIVO: Entregar conclusões úteis, claras e acionáveis, como um analista humano experiente faria."
+)
+
 def format_prompt(example):
-    # Suporta dois formatos: messages (ChatML) ou instruction/input/output
-    if "messages" in example:
-        # Formato messages (ChatML)
-        messages = example["messages"]
-        system_content = ""
-        user_content = ""
-        assistant_content = ""
-        
-        for msg in messages:
-            role = msg.get("role", "")
-            content = msg.get("content", "")
-            if role == "system":
-                system_content = content
-            elif role == "user":
-                user_content = content
-            elif role == "assistant":
-                assistant_content = content
-        
-        # Se não houver system, usar padrão
-        if not system_content:
-            system_content = (
-                "Você é um analista de dados sênior realizando uma Análise Exploratória de Dados (EDA) "
-                "com rigor estatístico, honestidade analítica e pensamento crítico.\n\n"
-                "Seu objetivo não é gerar insights a qualquer custo, mas avaliar se os dados possuem "
-                "estrutura informativa, comportamento emergente ou apenas relações estruturais triviais."
-            )
-        
-        prompt = f"<|system|>\n{system_content}\n<|user|>\n{user_content}\n<|assistant|>\n{assistant_content}<|end|>"
-    else:
-        # Formato instruction/input/output (legado)
-        system_prompt = (
-            "Você é um analista de dados sênior realizando uma Análise Exploratória de Dados (EDA) "
-            "com rigor estatístico, honestidade analítica e pensamento crítico.\n\n"
-            "Seu objetivo não é gerar insights a qualquer custo, mas avaliar se os dados possuem "
-            "estrutura informativa, comportamento emergente ou apenas relações estruturais triviais."
-        )
-        
-        instruction = example.get("instruction", "")
-        input_text = example.get("input", "")
-        output_text = example.get("output", "")
-        
-        prompt = f"<|system|>\n{system_prompt}\n<|user|>\n{instruction}\n\n{input_text}\n<|assistant|>\n{output_text}<|end|>"
+    input_text = example.get("input", "")
+    output_text = example.get("output", "")
     
+    prompt = f"<|system|>\n{EDA_SYSTEM_PROMPT}\n<|user|>\n{input_text}\n<|assistant|>\n{output_text}"
     return {"text": prompt}
 
 # Aplicar formatação
@@ -226,50 +120,25 @@ train_dataset = train_dataset.map(tokenize_function, batched=True, remove_column
 eval_dataset = eval_dataset.map(tokenize_function, batched=True, remove_columns=["text"])
 
 # Configurar argumentos de treinamento
-# push_to_hub_enabled já foi definido acima durante a autenticação
-
-# Argumentos base de treinamento
-training_args_dict = {
-    "output_dir": "./results",
-    "num_train_epochs": 3,
-    "per_device_train_batch_size": 2,
-    "per_device_eval_batch_size": 2,
-    "learning_rate": 3e-05,
-    "warmup_steps": 100,
-    "logging_steps": 10,
-    "save_steps": 500,
-    "eval_strategy": "steps",
-    "eval_steps": 500,
-    "save_total_limit": 3,
-    "load_best_model_at_end": True,
-    "fp16": True,
-    "gradient_accumulation_steps": 4,
-    "dataloader_pin_memory": False,
-    "ddp_find_unused_parameters": False,
-}
-
-# Adicionar parâmetros do Hub apenas se autenticado
-# IMPORTANTE: Não passar NENHUM parâmetro relacionado ao Hub quando não há token
-# para evitar que o Trainer tente inicializar o repositório
-if push_to_hub_enabled:
-    training_args_dict.update({
-        "push_to_hub": True,
-        "hub_model_id": OUTPUT_REPO,
-        "hub_strategy": "checkpoint",
-    })
-else:
-    # Garantir explicitamente que push_to_hub está desabilitado
-    # E que hub_model_id é None (não passar o parâmetro pode fazer o Trainer usar um valor padrão)
-    training_args_dict["push_to_hub"] = False
-    training_args_dict["hub_model_id"] = None
-
-training_args = TrainingArguments(**training_args_dict)
-
-if push_to_hub_enabled:
-    print(f"✅ Push para Hub habilitado: {OUTPUT_REPO}")
-else:
-    print("ℹ️ Push para Hub desabilitado (HF_TOKEN não configurado)")
-    print("Os checkpoints serão salvos apenas localmente em ./results")
+training_args = TrainingArguments(
+    output_dir="./results",
+    num_train_epochs=3,
+    per_device_train_batch_size=4,
+    per_device_eval_batch_size=4,
+    learning_rate=3e-05,
+    warmup_steps=100,
+    logging_steps=10,
+    save_steps=500,
+    eval_strategy="steps",
+    eval_steps=500,
+    save_total_limit=3,
+    load_best_model_at_end=True,
+    fp16=True,
+    gradient_accumulation_steps=2,
+    push_to_hub=True,
+    hub_model_id=OUTPUT_REPO,
+    hub_strategy="checkpoint",
+)
 
 # Data collator
 data_collator = DataCollatorForLanguageModeling(
@@ -278,228 +147,69 @@ data_collator = DataCollatorForLanguageModeling(
 )
 
 # Trainer
-# IMPORTANTE: Garantir que não há token no ambiente quando push_to_hub está desabilitado
-# para evitar que o Trainer tente inicializar o repositório durante __init__
-if not push_to_hub_enabled:
-    # Limpar todos os possíveis tokens do ambiente
-    tokens_to_remove = ["HUGGING_FACE_HUB_TOKEN", "HF_HUB_TOKEN", "HUGGINGFACE_HUB_TOKEN"]
-    for token_var in tokens_to_remove:
-        if token_var in os.environ:
-            del os.environ[token_var]
-    
-    # Fazer logout para garantir que não há token no cache
-    try:
-        hf_logout()
-    except Exception:
-        pass
-    
-    # Verificação de segurança - garantir que push_to_hub está False
-    if training_args.push_to_hub:
-        print("⚠️ AVISO: push_to_hub está True mas não há token! Forçando False...")
-        training_args.push_to_hub = False
-    if training_args.hub_model_id is not None:
-        print("⚠️ AVISO: hub_model_id está definido mas não há token! Removendo...")
-        training_args.hub_model_id = None
-
-print(f"🔍 Debug: push_to_hub={training_args.push_to_hub}, hub_model_id={training_args.hub_model_id}")
-print(f"🔍 Debug: push_to_hub_enabled={push_to_hub_enabled}")
-
-# Verificação final: se push_to_hub está False, garantir que não há token no cache
-if not push_to_hub_enabled:
-    # Limpar qualquer token residual do cache
-    try:
-        hf_logout()
-    except Exception:
-        pass
-    
-    # Verificação final dos argumentos
-    if training_args.push_to_hub or training_args.hub_model_id:
-        print("❌ ERRO: push_to_hub ou hub_model_id ainda está definido! Corrigindo...")
-        training_args.push_to_hub = False
-        training_args.hub_model_id = None
-
-print(f"✅ Criando Trainer com push_to_hub={training_args.push_to_hub}, hub_model_id={training_args.hub_model_id}")
-
-# Criar Trainer
-# Se push_to_hub está False, garantir que não há token no cache antes de criar
-if not push_to_hub_enabled:
-    # Última verificação: limpar qualquer token residual
-    try:
-        hf_logout()
-    except Exception:
-        pass
-
-try:
-    trainer = Trainer(
-        model=model,
-        args=training_args,
-        train_dataset=train_dataset,
-        eval_dataset=eval_dataset,
-        data_collator=data_collator,
-    )
-    print("✅ Trainer criado com sucesso!")
-except Exception as e:
-    if "401" in str(e) or "Unauthorized" in str(e):
-        print("❌ ERRO: Trainer tentou autenticar sem token válido!")
-        print("Isso não deveria acontecer. Verificando configuração...")
-        print(f"push_to_hub={training_args.push_to_hub}")
-        print(f"hub_model_id={training_args.hub_model_id}")
-        print(f"push_to_hub_enabled={push_to_hub_enabled}")
-        # Tentar novamente após limpar tudo
-        try:
-            hf_logout()
-        except Exception:
-            pass
-        # Forçar push_to_hub=False novamente
-        training_args.push_to_hub = False
-        training_args.hub_model_id = None
-        print("Tentando criar Trainer novamente com push_to_hub=False...")
-        trainer = Trainer(
-            model=model,
-            args=training_args,
-            train_dataset=train_dataset,
-            eval_dataset=eval_dataset,
-            data_collator=data_collator,
-        )
-    else:
-        raise
-
-# Criar diretório de logs
-logs_dir = Path("./logs")
-logs_dir.mkdir(exist_ok=True)
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_dataset,
+    eval_dataset=eval_dataset,
+    data_collator=data_collator,
+)
 
 # Treinar
 print("Iniciando treinamento...")
-train_output = trainer.train()
-
-# Coletar métricas finais do estado do trainer
-state = trainer.state
-final_log_history = state.log_history if hasattr(state, 'log_history') and state.log_history else []
-
-# Tentar obter loss final de diferentes fontes
-final_train_loss = None
-if hasattr(train_output, 'training_loss'):
-    final_train_loss = train_output.training_loss
-elif final_log_history:
-    for log_entry in reversed(final_log_history):
-        if 'loss' in log_entry and 'eval_loss' not in log_entry:
-            final_train_loss = log_entry.get('loss')
-            break
+trainer.train()
 
-# Buscar últimas métricas de validação
-last_eval_metrics = {}
-if final_log_history:
-    for log_entry in reversed(final_log_history):
-        if 'eval_loss' in log_entry:
-            last_eval_metrics = {k: v for k, v in log_entry.items() if k.startswith('eval_')}
-            break
+# Fazer push final
+print(f"Fazendo push do modelo final para {OUTPUT_REPO}")
+trainer.push_to_hub()
 
-# Coletar informações do treinamento
-training_info = {
-    "timestamp": datetime.utcnow().isoformat() + "Z",
-    "model_name": MODEL_NAME,
-    "dataset_repo": DATASET_REPO,
-    "output_repo": OUTPUT_REPO,
-    "training_config": {
-        "num_train_epochs": training_args.num_train_epochs,
-        "per_device_train_batch_size": training_args.per_device_train_batch_size,
-        "per_device_eval_batch_size": training_args.per_device_eval_batch_size,
-        "gradient_accumulation_steps": training_args.gradient_accumulation_steps,
-        "learning_rate": training_args.learning_rate,
-        "warmup_steps": training_args.warmup_steps,
-        "fp16": training_args.fp16,
-    },
-    "dataset_info": {
-        "train_samples": len(train_dataset),
-        "eval_samples": len(eval_dataset) if eval_dataset else 0,
-    },
-    "training_results": {
-        "final_train_loss": final_train_loss,
-        "final_eval_metrics": last_eval_metrics,
-        "total_steps": len(final_log_history) if final_log_history else 0,
-        "log_history": final_log_history[-50:],  # Últimas 50 entradas
-    },
-    "status": "completed",
-    "push_to_hub_enabled": push_to_hub_enabled,
-}
+print("✅ Treinamento concluído!")
 
-# Salvar resultados em JSON
-results_file = logs_dir / f"training_results_{datetime.utcnow().strftime('%Y%m%d_%H%M%S')}.json"
-with open(results_file, 'w', encoding='utf-8') as f:
-    json.dump(training_info, f, indent=2, ensure_ascii=False)
-print(f"✅ Resultados salvos em: {results_file}")
 
-# Criar resumo em texto legível
-summary_file = logs_dir / f"training_summary_{datetime.utcnow().strftime('%Y%m%d_%H%M%S')}.txt"
-with open(summary_file, 'w', encoding='utf-8') as f:
-    f.write("=" * 80 + "\n")
-    f.write("RESUMO DO TREINAMENTO\n")
-    f.write("=" * 80 + "\n\n")
-    f.write(f"Data/Hora: {training_info['timestamp']}\n")
-    f.write(f"Modelo: {MODEL_NAME}\n")
-    f.write(f"Dataset: {DATASET_REPO}\n")
-    f.write(f"Output: {OUTPUT_REPO}\n\n")
-    
-    f.write("CONFIGURAÇÃO DE TREINAMENTO:\n")
-    f.write("-" * 80 + "\n")
-    config = training_info['training_config']
-    f.write(f"Épocas: {config['num_train_epochs']}\n")
-    f.write(f"Batch Size (train): {config['per_device_train_batch_size']}\n")
-    f.write(f"Batch Size (eval): {config['per_device_eval_batch_size']}\n")
-    f.write(f"Gradient Accumulation Steps: {config['gradient_accumulation_steps']}\n")
-    f.write(f"Learning Rate: {config['learning_rate']}\n")
-    f.write(f"Warmup Steps: {config['warmup_steps']}\n")
-    f.write(f"FP16: {config['fp16']}\n\n")
-    
-    f.write("DATASET:\n")
-    f.write("-" * 80 + "\n")
-    dataset_info = training_info['dataset_info']
-    f.write(f"Amostras de Treino: {dataset_info['train_samples']}\n")
-    f.write(f"Amostras de Validação: {dataset_info['eval_samples']}\n\n")
+def analyze_schema(csv_description: str, model_path: str = None):
+    """
+    Função de inferência - modelo já 'obrigado' a pensar certo.
     
-    f.write("RESULTADOS:\n")
-    f.write("-" * 80 + "\n")
-    results = training_info['training_results']
-    if results['final_train_loss'] is not None:
-        f.write(f"Loss Final (Treino): {results['final_train_loss']:.6f}\n")
-    
-    if results['final_eval_metrics']:
-        f.write("\nMétricas Finais de Validação:\n")
-        for key, value in results['final_eval_metrics'].items():
-            if isinstance(value, float):
-                f.write(f"  {key}: {value:.6f}\n")
-            else:
-                f.write(f"  {key}: {value}\n")
+    Args:
+        csv_description: Descrição do dataset CSV para análise
+        model_path: Caminho para o modelo treinado (opcional, usa modelo atual se None)
+        
+    Returns:
+        Análise EDA gerada pelo modelo treinado
+    """
+    # Se model_path for fornecido, carregar modelo treinado
+    inference_model = model
+    inference_tokenizer = tokenizer
     
-    f.write(f"\nTotal de Steps: {results['total_steps']}\n")
-    f.write(f"Status: {training_info['status']}\n")
-    f.write(f"Push para Hub: {'Sim' if training_info['push_to_hub_enabled'] else 'Não'}\n")
+    if model_path:
+        print(f"Carregando modelo treinado de: {model_path}")
+        inference_tokenizer = AutoTokenizer.from_pretrained(model_path)
+        inference_model = AutoModelForCausalLM.from_pretrained(
+            model_path,
+            device_map="auto",
+            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
+        )
     
-    if results['log_history']:
-        f.write("\n" + "=" * 80 + "\n")
-        f.write("ÚLTIMAS MÉTRICAS DO LOG:\n")
-        f.write("=" * 80 + "\n")
-        for i, log_entry in enumerate(results['log_history'][-10:], 1):
-            f.write(f"\nLog Entry {i}:\n")
-            for key, value in log_entry.items():
-                if isinstance(value, float):
-                    f.write(f"  {key}: {value:.6f}\n")
-                else:
-                    f.write(f"  {key}: {value}\n")
+    prompt = f"""<|system|>
+{EDA_SYSTEM_PROMPT}
+<|user|>
+Analise o seguinte dataset:
+{csv_description}
+<|assistant|>
+"""
 
-print(f"✅ Resumo salvo em: {summary_file}")
+    inputs = inference_tokenizer(prompt, return_tensors="pt").to(inference_model.device)
 
-# Fazer push final apenas se autenticado
-if push_to_hub_enabled:
-    print(f"Fazendo push do modelo final para {OUTPUT_REPO}")
-    try:
-        trainer.push_to_hub()
-        print("✅ Push para Hub concluído!")
-    except Exception as e:
-        print(f"❌ Erro ao fazer push para Hub: {e}")
-        print("Os checkpoints estão salvos localmente em ./results")
-else:
-    print("ℹ️ Push para Hub pulado (HF_TOKEN não configurado)")
-    print("Os checkpoints estão salvos em ./results")
+    output = inference_model.generate(
+        **inputs,
+        max_new_tokens=1200,
+        temperature=0.2,
+        do_sample=False
+    )
 
-print("✅ Treinamento concluído!")
+    return inference_tokenizer.decode(output[0], skip_special_tokens=True)
+
+
+# Exemplo de uso após o treinamento:
+# resultado = analyze_schema("Descrição do seu dataset aqui...")
+# print(resultado)