Upload app.py

app.py

@@ -1295,14 +1295,7 @@ def train_model_lora(
 
         # ── Dataset: carregar do disco ou tokenizar ────────────────────────
         tokenized_path = os.path.join(output_dir, "tokenized_dataset")
-#----------------------------------------------------------------------------
-        # Depois de tokenizar o dataset
-        if os.path.exists(tokenized_path):
-            HF_BUCKET_DATASET = "hf://buckets/Fedir-Ilina/Train_CPU/tokenized_dataset"  # definir nome do bucket
-            upload_to_bucket(tokenized_path, HF_BUCKET_DATASET)
-            log_success("Dataset tokenizado enviado ao Bucket Hugging Face!")
-            training_logs.append("Dataset tokenizado enviado ao Bucket Hugging Face.")
-#----------------------------------------------------------------------------
+
         if os.path.exists(tokenized_path):
             log_info("Dataset tokenizado encontrado no disco. A carregar...")
             tokenized_datasets = load_from_disk(tokenized_path)
@@ -1346,7 +1339,6 @@ def train_model_lora(
 
         training_args = TrainingArguments(
             output_dir=output_dir,
-            logging_dir="/tmp/tensorboard_logs",
             num_train_epochs=_epochs_for_trainer,
             per_device_train_batch_size=BASE_BATCH_SIZE,
             per_device_eval_batch_size=BASE_EVAL_SIZE,
@@ -1436,65 +1428,33 @@ def train_model_lora(
 #-----------------------------------------------------------------------------
         try:
             log_success("Configuração do Trainer concluída. A iniciar o treino...")
-            train_progress.update({
-                "status": "training",
-                "message": "Iniciando o treinamento do modelo..."
-            })
-
+            train_progress.update({"status": "training", "message": "Iniciando o treinamento do modelo..."})
             trainer_output = trainer.train(resume_from_checkpoint=resume_from_trainer_checkpoint)
 
-            # -------------------------------
-            # Salvar adapter LoRA localmente
-            # -------------------------------
             lora_model_path = os.path.join(output_dir, "lora_model")
             os.makedirs(lora_model_path, exist_ok=True)
-
             model.save_pretrained(lora_model_path)
             tokenizer.save_pretrained(lora_model_path)
             training_logs.append("Adapter LoRA salvo com sucesso!")
 
-            # ================================================
-            #  ENVIAR LoRA PARA BUCKET
-            # ================================================
-            HF_BUCKET_LORA = "hf://buckets/Fedir-Ilina/Train_CPU/lora_adapter"
-
-            try:
-                upload_to_bucket(lora_model_path, HF_BUCKET_LORA)
-                log_success(f"Adapter LoRA enviado ao Bucket: {HF_BUCKET_LORA}")
-                training_logs.append("Adapter LoRA enviado ao Bucket HF com sucesso!")
-            except Exception as bucket_error:
-                log_warning(f"Falha ao enviar LoRA para Bucket: {bucket_error}")
-                training_logs.append(f"Erro no upload para Bucket: {bucket_error}")
-
-            # ---------------------------------
-            # Avaliação final do modelo
-            # ---------------------------------
             log_info("A avaliar o modelo final no dataset de validação...")
             final_metrics = trainer.evaluate()
-
             eval_loss = final_metrics.get("eval_loss")
             if eval_loss is not None:
                 perplexity = math.exp(eval_loss)
                 log_success("Avaliação Final Concluída:")
                 log_info(f"  -> Eval Loss: {eval_loss:.4f}")
                 log_info(f"  -> Perplexity: {perplexity:.4f}")
-
                 with open(os.path.join(output_dir, "final_metrics.txt"), "w") as f:
                     f.write(f"Eval Loss: {eval_loss}\nPerplexity: {perplexity}\n")
-
             else:
                 log_warning("Não foi possível obter 'eval_loss' das métricas finais.")
 
-            train_progress.update({
-                "status": "awaiting_merge",
-                "percent": 100,
-                "message": "Treino concluído. LoRA salvo. Decida a próxima ação."
-            })
 
+            train_progress.update({"status": "awaiting_merge", "percent": 100, "message": "Treino concluído. LoRA salvo. Decida a próxima ação."})
             training_logs.append("Treino concluído. Adapter LoRA salvo em " + lora_model_path)
             log_success("Treino concluído. Adapter LoRA salvo. Aguardando decisão (merge ou continuar).")
-
-        except RuntimeError as e:
+        except RuntimeError as e:        
             msg = str(e)
             training_logs.append(f"Erro durante treino: {msg}")
             train_progress["status"] = "error"
@@ -1506,18 +1466,17 @@ def train_model_lora(
         train_progress.update({"status": "error", "message": f"Erro crítico no treino: {e}"})
         traceback.print_exc()
         return
+
 #----------------------------------------------------
-TENSORBOARD_LOGDIR = "/tmp/tensorboard_logs"
+TENSORBOARD_LOGDIR = r"C:\Users\ilina\startup\Treinamento\feramenta-treino\trained_model_output\logs"
 TENSORBOARD_PORT = 6006
 
-os.makedirs(TENSORBOARD_LOGDIR, exist_ok=True)
-
 def run_tensorboard():
+    # Lança o TensorBoard em thread separada para não bloquear
     subprocess.Popen([
         "tensorboard",
         f"--logdir={TENSORBOARD_LOGDIR}",
-        f"--port={TENSORBOARD_PORT}",
-        "--host=0.0.0.0"
+        f"--port={TENSORBOARD_PORT}"
     ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 #-----------------------------------------------------------
 #----------------------
@@ -1546,17 +1505,6 @@ def guess_lora_targets(model):
 @app.route('/api/train', methods=['POST'])
 def handle_train_request():
     global all_data
-    # 🟩 INÍCIO — adiciona estas linhas aqui:
-    train_progress.clear()
-    train_progress.update({
-        "status": "running",
-        "percent": 0,
-        "start_time": time.time(),
-        "message": "A preparar treino…"
-    })
-    training_logs.clear()
-    epoch_losses.clear()
-    # 🟩 FIM — estas linhas são obrigatórias para a UI atualizar    
     try:
         model_path = request.form.get('model_path')
         epochs = int(request.form.get('epochs'))
@@ -1569,18 +1517,7 @@ def handle_train_request():
         if not all([model_path, epochs, uploaded_files]):
             return jsonify({"status": "error", "message": "Faltam parâmetros: modelo, épocas ou ficheiros."}), 400
 
-        # --- RESET do estado de UI do treino ---
-        training_logs.clear()
-        epoch_losses.clear()
-        train_progress.update({
-            "status":  "running",
-            "percent": 0,
-            "message": "A preparar dados…",
-            "start_time": time.time(),       # ⏱️ marca o início real deste treino
-            "run_id": int(time.time())       # opcional: id da sessão
-        })
-
-        # Carregar dados
+        # Limpa os dados de treinos anteriores
         all_data = []
         for file in uploaded_files:
             try:
@@ -1591,7 +1528,7 @@ def handle_train_request():
                     if not line.strip(): continue
                     if file.filename.endswith('.jsonl'):
                         all_data.append(json.loads(line))
-                    else:
+                    else: # Assume .txt ou outros formatos de texto
                         all_data.append({"text": line.strip()})
             except Exception as e:
                 return jsonify({"status": "error", "message": f"Erro ao ler ficheiro {file.filename}: {e}"}), 400
@@ -1606,11 +1543,8 @@ def handle_train_request():
         training_logs.append(f"[DEBUG] OUTPUT_DIR: {output_dir}")
         training_logs.append(f"[DEBUG] FILES: {os.listdir(os.getcwd())}")
 
-        # Inicia o treino em thread
-        thread = Thread(
-            target=train_model_lora, 
-            args=(all_data, epochs, model_path, output_dir, ACCUMULATION_STEPS, DATALOADER_WORKERS, "new_train")
-        )
+        # Passar um flag indicando que é um "novo" treino (ou re-treino)
+        thread = Thread(target=train_model_lora, args=(all_data, epochs, model_path, output_dir, ACCUMULATION_STEPS, DATALOADER_WORKERS, "new_train"))
         thread.start()
 
         return jsonify({"status": "started", "message": "Requisição de treino recebida. O processo foi iniciado."})
@@ -1774,10 +1708,12 @@ def train_status():
     epoch_list = epoch_losses
     logs_tail = training_logs[-200:] if len(training_logs) > 200 else training_logs[:]
 
-    # Acrescentar info a partir do estado atual (apenas nesta resposta, não suja os logs reais)
+    # Acrescentar as linhas pedidas (apenas texto; simples)
     if CURRENT_ACCUM_STEPS is not None:
         origem = LAST_ACCUM_ORIGIN or "desconhecido"
         logs_tail.append(f"[INFO] gradient_accumulation_steps atual: {CURRENT_ACCUM_STEPS} ({origem})")
+
+        # opcional: mostrar Effective Batch
         if BASE_BATCH_SIZE_EFFECTIVE:
             eb = BASE_BATCH_SIZE_EFFECTIVE * CURRENT_ACCUM_STEPS
             logs_tail.append(f"[INFO] Effective Batch (base={BASE_BATCH_SIZE_EFFECTIVE}) = {eb}")
@@ -1785,16 +1721,11 @@ def train_status():
     if TOTAL_TRAIN_STEPS is not None:
         logs_tail.append(f"[INFO] total_train_steps desta execução: {TOTAL_TRAIN_STEPS}")
 
-    # ⏱ TEMPO DECORRIDO REAL
-    start_time = train_progress.get("start_time")
-    elapsed_seconds = int(time.time() - start_time) if start_time else None
-
     return jsonify({
         "progress": progress,
         "status": status,
         "epoch_losses": epoch_list,
-        "logs": logs_tail,
-        "elapsed_seconds": elapsed_seconds
+        "logs": logs_tail
     })
 
 #---------------------------------------
@@ -1959,12 +1890,7 @@ def decide_merge():
                         log_warning(f"Erro ao ler trainer_state.json do checkpoint: {e}. Assumindo 0 épocas completadas.")
 
             # Atualiza o status de progresso para indicar que o treino vai continuar
-            train_progress.update({
-                "status": "continuing_training",
-                "message": f"Continuando treino por mais {epochs_to_add} épocas...",
-                "start_time": time.time(),   # ⏱️ reinicia o relógio para esta sessão de continuação
-                "run_id": int(time.time())   # opcional
-            })            
+            train_progress.update({"status": "continuing_training", "message": f"Continuando treino por mais {epochs_to_add} épocas..."})
             
             thread = Thread(
                 target=train_model_lora,
@@ -2268,5 +2194,7 @@ def create_model():
     # O modelo real é carregado no início do treino via train_model_lora
     return jsonify({"status": "ok", "message": f"Modelo '{model_name}' será carregado ao iniciar o treino."})
 #---------------------------------------------------------------
+#if __name__ == "__main__" and os.environ.get("WERKZEUG_RUN_MAIN") == "true":
+    # código de inicialização
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=7860, debug=False)