fix: corrigir crash de treinamento e adicionar salvamento de resultados

- Remover quantização 4-bit que causa erro de GPU RAM
- Adicionar salvamento de resultados em logs/ (JSON e TXT)
- Reduzir batch_size para 2 e aumentar gradient_accumulation para 4
- Adicionar tratamento de erros durante treinamento
- Adicionar variáveis de ambiente OMP_NUM_THREADS e PYTORCH_CUDA_ALLOC_CONF
- Usar LoRA apenas (sem quantização) para reduzir memória

train.py

@@ -12,9 +12,12 @@ from transformers import (
     Trainer,
     DataCollatorForLanguageModeling,
 )
-from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
-from transformers import BitsAndBytesConfig
+from peft import LoraConfig, get_peft_model
 import torch
+import os
+import json
+from datetime import datetime
+from pathlib import Path
 
 # Configuração
 MODEL_NAME = "microsoft/Phi-3-mini-4k-instruct"
@@ -25,28 +28,32 @@ OUTPUT_REPO = "beAnalytic/eda-llm-model"
 print(f"Carregando dataset: {DATASET_REPO}")
 dataset = load_dataset(DATASET_REPO)
 
+# 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")
+
 # Carregar modelo e tokenizer
 print(f"Carregando modelo: {MODEL_NAME}")
 tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
 tokenizer.pad_token = tokenizer.eos_token
 
-# Configurar quantização 4-bit
-bnb_config = BitsAndBytesConfig(
-    load_in_4bit=True,
-    bnb_4bit_compute_dtype=torch.float16,
-    bnb_4bit_quant_type="nf4",
-    bnb_4bit_use_double_quant=True,
-)
+# Verificar se há GPU disponível
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"Usando dispositivo: {device}")
 
+# Carregar modelo sem quantização (LoRA é suficiente para reduzir memória)
+# Quantização 4-bit está causando problemas de GPU RAM no HuggingFace Space
+print("Carregando modelo (sem quantização, usando LoRA para eficiência)...")
 model = AutoModelForCausalLM.from_pretrained(
     MODEL_NAME,
-    quantization_config=bnb_config,
-    device_map="auto",
+    torch_dtype=torch.float16 if device == "cuda" else torch.float32,
+    device_map="auto" if device == "cuda" else None,
     trust_remote_code=True,
+    use_cache=False,
 )
 
-# Preparar modelo para LoRA
-model = prepare_model_for_kbit_training(model)
+if device == "cpu":
+    print("⚠️ Modelo carregado em CPU - treinamento será mais lento")
 
 # Configurar LoRA
 peft_config = LoraConfig(
@@ -119,12 +126,16 @@ def tokenize_function(examples):
 train_dataset = train_dataset.map(tokenize_function, batched=True, remove_columns=["text"])
 eval_dataset = eval_dataset.map(tokenize_function, batched=True, remove_columns=["text"])
 
+# Criar diretório de logs
+logs_dir = Path("./logs")
+logs_dir.mkdir(exist_ok=True)
+
 # Configurar argumentos de treinamento
 training_args = TrainingArguments(
     output_dir="./results",
     num_train_epochs=3,
-    per_device_train_batch_size=4,
-    per_device_eval_batch_size=4,
+    per_device_train_batch_size=2,
+    per_device_eval_batch_size=2,
     learning_rate=3e-05,
     warmup_steps=100,
     logging_steps=10,
@@ -133,8 +144,9 @@ training_args = TrainingArguments(
     eval_steps=500,
     save_total_limit=3,
     load_best_model_at_end=True,
-    fp16=True,
-    gradient_accumulation_steps=2,
+    fp16=device == "cuda",
+    gradient_accumulation_steps=4,
+    dataloader_pin_memory=False,
     push_to_hub=True,
     hub_model_id=OUTPUT_REPO,
     hub_strategy="checkpoint",
@@ -157,11 +169,147 @@ trainer = Trainer(
 
 # Treinar
 print("Iniciando treinamento...")
-trainer.train()
+try:
+    train_output = trainer.train()
+except Exception as e:
+    print(f"❌ Erro durante treinamento: {e}")
+    # Tentar salvar resultados mesmo em caso de erro
+    train_output = None
+    
+    # Coletar estado atual se possível
+    try:
+        state = trainer.state
+        final_log_history = state.log_history if hasattr(state, 'log_history') and state.log_history else []
+    except:
+        final_log_history = []
+    
+    # Salvar log de erro
+    error_info = {
+        "timestamp": datetime.utcnow().isoformat() + "Z",
+        "error": str(e),
+        "model_name": MODEL_NAME,
+        "dataset_repo": DATASET_REPO,
+        "status": "failed"
+    }
+    
+    error_file = logs_dir / f"training_error_{datetime.utcnow().strftime('%Y%m%d_%H%M%S')}.json"
+    with open(error_file, 'w', encoding='utf-8') as f:
+        json.dump(error_info, f, indent=2, ensure_ascii=False)
+    print(f"✅ Informações de erro salvas em: {error_file}")
+    
+    raise
+
+# 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 train_output and 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
+
+# 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
+
+# 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:],
+    },
+    "status": "completed",
+}
+
+# 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")
+    
+    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")
+    
+    f.write(f"\nTotal de Steps: {results['total_steps']}\n")
+    f.write(f"Status: {training_info['status']}\n")
+
+print(f"✅ Resumo salvo em: {summary_file}")
 
 # Fazer push final
 print(f"Fazendo push do modelo final para {OUTPUT_REPO}")
-trainer.push_to_hub()
+try:
+    trainer.push_to_hub()
+    print("✅ Push para Hub concluído!")
+except Exception as e:
+    print(f"⚠️ Aviso: Erro ao fazer push para Hub: {e}")
+    print("Os checkpoints estão salvos localmente em ./results")
 
 print("✅ Treinamento concluído!")