Upload 5 files

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,2007 @@
+#app.py
+import os            
+import sys
+import subprocess
+# Forçar versões compatíveis
+subprocess.check_call([sys.executable, "-m", "pip", "install", "--upgrade", "urllib3<2.0", "charset_normalizer<3.4"])
+import warnings  # IMPORT NECESSÁRIO antes de usar
+from requests.packages.urllib3.exceptions import DependencyWarning
+# Ignorar o warning do requests
+warnings.simplefilter('ignore', DependencyWarning)
+# No topo do seu ficheiro Python
+BASE_PATH = os.path.dirname(os.path.abspath(__file__))
+# Forçar o output_dir para um local fixo e absoluto
+FINAL_OUTPUT_DIR = os.path.join(BASE_PATH, "trained_model_output")
+import torch
+import logging
+import json
+import chardet
+import math
+import psutil
+import traceback
+import time
+import threading
+import webbrowser
+import platform
+import cpuinfo
+import statistics
+import glob
+import ctypes as ct
+import importlib
+import inspect
+import torch.nn as nn
+
+# keyboard é opcional (não disponível em HF Spaces / ambientes headless)
+try:
+    import keyboard
+    _KEYBOARD_AVAILABLE = True
+except Exception:
+    _KEYBOARD_AVAILABLE = False
+#import intel_extension_for_pytorch as ipex
+
+from typing import Dict, Union, Any
+#webview.create_window("train-12-ok.py", "index-6.html") #iterface autonomo
+#webview.start()
+# Desativa os logs de informação do oneDNN (nível 1) e avisos (nível 2)
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '0'
+
+#import warnings
+#import tensorflow as tf
+#'0' = Mostra todas as mensagens (padrão).
+#'1' = Filtra as mensagens de INFO.
+#'2' = Filtra as mensagens de INFO e WARNING.
+#'3' = Filtra todas as mensagens, incluindo ERROR.
+# Suprimir avisos Python
+warnings.filterwarnings("ignore", category=UserWarning, module='tensorflow')
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+# Ajusta logger do TensorFlow
+#tf.get_logger().setLevel('ERROR')
+
+from datetime import timedelta
+from datetime import datetime
+from contextlib import suppress
+from threading import Thread
+from flask import Flask, render_template, request, jsonify
+from contextlib import contextmanager
+
+# Importações do Hugging Face
+from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer
+from transformers import TrainerCallback, TrainerState, TrainerControl
+from datasets import Dataset, load_from_disk # type: ignore
+from peft import LoraConfig, get_peft_model, PeftModel, TaskType # type: ignore
+from transformers import DataCollatorForLanguageModeling
+from flask import send_from_directory
+#------------------------------------------------------
+from warnings import warn as log_warning 
+from config_manager import _load_constants_from_file, map_backend_to_frontend, update_python_constants
+#pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cpu 
+#---------------------
+app = Flask(__name__)
+all_data = []
+#--------------------
+print("-" * 80)
+#-----------------------------------------------------------
+def _ts():
+    return datetime.now().strftime("%H:%M:%S")
+
+# -------------------------
+# Deteção P/E cross-platform
+# -------------------------
+def detect_core_types():
+    """
+    Tenta:
+      1) Windows: EfficiencyClass (Windows 11 expõe isto; em máquinas homogéneas virá tudo Efficiency=0).
+      2) Linux: sysfs core_type (1=Atom/E, 2=Core/P; 0=Unknown).
+      3) Fallback: assume homogéneo → todos P, E vazio.
+
+    Retorna (P_IDS, E_IDS, meta_dict).
+    """
+    logical = psutil.cpu_count(logical=True) or os.cpu_count() or 1
+    # 1) Windows EfficiencyClass
+    if platform.system() == "Windows":
+        try:
+            RELATION_PROCESSOR_CORE = 0
+
+            class GROUP_AFFINITY(ct.Structure):
+                _fields_ = [("Mask", ct.c_ulonglong),
+                            ("Group", ct.c_ushort),
+                            ("Reserved", ct.c_ushort * 3)]
+
+            class PROCESSOR_RELATIONSHIP(ct.Structure):
+                _fields_ = [("Flags", ct.c_ubyte),
+                            ("EfficiencyClass", ct.c_ubyte),
+                            ("Reserved", ct.c_ubyte * 20),
+                            ("GroupCount", ct.c_ushort)]
+                # seguido inline por GROUP_AFFINITY[GroupCount]
+
+            class SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX_HEADER(ct.Structure):
+                _fields_ = [("Relationship", ct.c_int),
+                            ("Size", ct.c_ulong)]
+
+            GetLPIEx = ct.windll.kernel32.GetLogicalProcessorInformationEx
+            GetLPIEx.restype = ct.c_bool
+            GetLPIEx.argtypes = [ct.c_int, ct.c_void_p, ct.POINTER(ct.c_ulong)]
+
+            buf_size = ct.c_ulong(0)
+            GetLPIEx(RELATION_PROCESSOR_CORE, None, ct.byref(buf_size))
+            if buf_size.value:
+                buf = (ct.c_byte * buf_size.value)()
+                if GetLPIEx(RELATION_PROCESSOR_CORE, ct.byref(buf), ct.byref(buf_size)):
+                    eff_by_logical = {}
+                    offset = 0
+                    single_group = (logical <= 64)
+                    while offset < buf_size.value:
+                        header = SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX_HEADER.from_buffer(buf, offset)
+                        size = header.Size
+                        if header.Relationship == RELATION_PROCESSOR_CORE:
+                            pr = PROCESSOR_RELATIONSHIP.from_buffer(buf, offset + ct.sizeof(header))
+                            eff = pr.EfficiencyClass  # 0 = mais performante (P), >0 = mais eficiente (E)
+                            ga_offset = offset + ct.sizeof(header) + ct.sizeof(PROCESSOR_RELATIONSHIP)
+                            for i in range(pr.GroupCount):
+                                ga = GROUP_AFFINITY.from_buffer(buf, ga_offset + i * ct.sizeof(GROUP_AFFINITY))
+                                mask = ga.Mask
+                                if single_group:
+                                    # Mapear bits 0..63 para logical ids 0..63
+                                    for bit in range(64):
+                                        if (mask >> bit) & 1:
+                                            eff_by_logical[bit] = eff
+                                else:
+                                    # Em sistemas multi-grupo (>64 lógicos), mapa global é mais complexo.
+                                    # Como alteração mínima, ignoramos (cai para fallback se não mapear nada).
+                                    pass
+                        offset += size
+
+                    if eff_by_logical:
+                        p_ids = sorted([i for i in range(logical) if eff_by_logical.get(i, 0) == 0])
+                        e_ids = sorted([i for i in range(logical) if eff_by_logical.get(i, 0) > 0])
+                        return p_ids, e_ids, {"method": "windows_efficiencyclass", "notes": []}
+        except Exception as e:
+            # continua para Linux/fallback
+            pass
+
+    # 2) Linux sysfs core_type
+    if platform.system() == "Linux":
+        try:
+            p_ids, e_ids, unknown = [], [], []
+            for cpu in range(logical):
+                path = f"/sys/devices/system/cpu/cpu{cpu}/topology/core_type"
+                try:
+                    with open(path, "r") as f:
+                        val = f.read().strip()
+                except FileNotFoundError:
+                    val = None
+                if val is None:
+                    # sysfs não disponível → sai para fallback
+                    p_ids = e_ids = []
+                    break
+                try:
+                    t = int(val)
+                except ValueError:
+                    t = 0
+                # Kernel moderno: 1=Atom(E), 2=Core(P), 0=Unknown
+                if t == 2:
+                    p_ids.append(cpu)
+                elif t == 1:
+                    e_ids.append(cpu)
+                else:
+                    unknown.append(cpu)
+            if p_ids or e_ids:
+                notes = []
+                if unknown:
+                    notes.append(f"{len(unknown)} CPUs com core_type=Unknown (tratados como P).")
+                    p_ids.extend(unknown)  # escolha conservadora: desconhecidos como P
+                    p_ids = sorted(p_ids)
+                return sorted(p_ids), sorted(e_ids), {"method": "linux_core_type", "notes": notes}
+        except Exception:
+            pass
+
+    # 3) Fallback: homogéneo
+    return list(range(logical)), [], {"method": "homogeneous_fallback", "notes": []}
+
+# -------------------------
+# Mapa de siblings (HT) por core físico
+# -------------------------
+def get_core_siblings():
+    """
+    Retorna lista de listas: cada sublista são os logical IDs que pertencem ao mesmo core físico.
+    """
+    logical = psutil.cpu_count(logical=True) or 1
+
+    if platform.system() == "Windows":
+        try:
+            RELATION_PROCESSOR_CORE = 0
+
+            class GROUP_AFFINITY(ct.Structure):
+                _fields_ = [("Mask", ct.c_ulonglong),
+                            ("Group", ct.c_ushort),
+                            ("Reserved", ct.c_ushort * 3)]
+
+            class PROCESSOR_RELATIONSHIP(ct.Structure):
+                _fields_ = [("Flags", ct.c_ubyte),
+                            ("EfficiencyClass", ct.c_ubyte),
+                            ("Reserved", ct.c_ubyte * 20),
+                            ("GroupCount", ct.c_ushort)]
+
+            class SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX_HEADER(ct.Structure):
+                _fields_ = [("Relationship", ct.c_int),
+                            ("Size", ct.c_ulong)]
+
+            GetLPIEx = ct.windll.kernel32.GetLogicalProcessorInformationEx
+            GetLPIEx.restype = ct.c_bool
+            GetLPIEx.argtypes = [ct.c_int, ct.c_void_p, ct.POINTER(ct.c_ulong)]
+
+            buf_size = ct.c_ulong(0)
+            GetLPIEx(RELATION_PROCESSOR_CORE, None, ct.byref(buf_size))
+            if not buf_size.value:
+                return []
+
+            buf = (ct.c_byte * buf_size.value)()
+            if not GetLPIEx(RELATION_PROCESSOR_CORE, ct.byref(buf), ct.byref(buf_size)):
+                return []
+
+            # Cada entrada RelationProcessorCore descreve UM core físico e a(s) máscara(s) dos seus logical processors.
+            siblings = []
+            offset = 0
+            single_group = (logical <= 64)
+            while offset < buf_size.value:
+                header = SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX_HEADER.from_buffer(buf, offset)
+                size = header.Size
+                if header.Relationship == RELATION_PROCESSOR_CORE:
+                    pr = PROCESSOR_RELATIONSHIP.from_buffer(buf, offset + ct.sizeof(header))
+                    ga_offset = offset + ct.sizeof(header) + ct.sizeof(PROCESSOR_RELATIONSHIP)
+                    core_logicals = []
+                    for i in range(pr.GroupCount):
+                        ga = GROUP_AFFINITY.from_buffer(buf, ga_offset + i * ct.sizeof(GROUP_AFFINITY))
+                        mask = ga.Mask
+                        if single_group:
+                            for bit in range(64):
+                                if (mask >> bit) & 1:
+                                    core_logicals.append(bit)
+                        else:
+                            # Multi-grupo: mapping global não é trivial; manter simples
+                            for bit in range(64):
+                                if (mask >> bit) & 1:
+                                    core_logicals.append(bit)  # aproximação
+                    if core_logicals:
+                        siblings.append(sorted(set(core_logicals)))
+                offset += size
+
+            # Ordena por menor logical id para estabilidade
+            siblings = sorted(siblings, key=lambda s: min(s) if s else 1e9)
+            return siblings
+        except Exception:
+            return []
+
+    elif platform.system() == "Linux":
+        sibs = []
+        try:
+            for cpu in range(logical):
+                path = f"/sys/devices/system/cpu/cpu{cpu}/topology/thread_siblings_list"
+                try:
+                    with open(path, "r") as f:
+                        txt = f.read().strip()
+                except FileNotFoundError:
+                    return []
+                # Ex.: "0,6" ou "0-1,6-7"
+                items = []
+                for part in txt.split(","):
+                    if "-" in part:
+                        a, b = part.split("-")
+                        items.extend(range(int(a), int(b) + 1))
+                    else:
+                        items.append(int(part))
+                sibs.append(sorted(set(items)))
+            # Deduplica sublistas iguais
+            uniq = []
+            seen = set()
+            for s in sibs:
+                t = tuple(s)
+                if t not in seen:
+                    seen.add(t)
+                    uniq.append(s)
+            uniq = sorted(uniq, key=lambda s: min(s))
+            return uniq
+        except Exception:
+            return []
+
+    return []
+
+def order_by_physical_first(candidates, siblings_map):
+    """
+    Reordena 'candidates' para usar primeiro 1 logical por core físico (evita usar siblings logo de início).
+    Se 'siblings_map' estiver vazio, retorna candidatos ordenados naturalmente.
+    """
+    if not siblings_map:
+        return sorted(candidates)
+
+    cand_set = set(candidates)
+    # 1ª passagem: 1 por core
+    first_pass = []
+    for group in siblings_map:
+        pick = next((x for x in group if x in cand_set), None)
+        if pick is not None:
+            first_pass.append(pick)
+
+    # 2ª passagem: restantes (siblings), preservando ordem por grupo
+    others = []
+    for group in siblings_map:
+        for x in group:
+            if x in cand_set and x not in first_pass:
+                others.append(x)
+
+    # Mantém qualquer candidato que não esteja no mapa (ex.: detection parcial)
+    leftovers = [x for x in sorted(candidates) if x not in first_pass and x not in others]
+    return first_pass + others + leftovers
+
+# =========================================================================
+# 1️. Configuração base de hardware, Otimização e Hiperparâmetros
+# =========================================================================
+# --- 1.1 Hardware ---
+LOGICAL_CPUS = psutil.cpu_count(logical=True) or os.cpu_count() or 16
+PHYSICAL_CPUS = psutil.cpu_count(logical=False) or max(1, LOGICAL_CPUS // 2)
+TOTAL_RAM_GB = psutil.virtual_memory().total / (1024 ** 3)
+#--------------------------------------------------------------------------------------------------------------------------------------
+# ===============================================================
+# Ajuste de performance (auto/manual)
+# ===============================================================
+OMP_THREADS_UTILIZATION = 0.85
+DETECTION_PERFORMANCE = "auto"  # "auto" | "manual"
+CORES_UTILIZATION = 1.0
+
+# --------------------
+def compute_effective_cores(cpu_count: int, utilization: float) -> int:
+    eff = int(math.floor(cpu_count * utilization))
+    return max(1, min(eff, cpu_count))
+
+
+EFFECTIVE_LOGICAL_CPUS = compute_effective_cores(LOGICAL_CPUS, CORES_UTILIZATION)
+
+# --------------------
+# --- Detectar núcleos P/E ---
+_DET_P_full, _DET_E_full, _META = detect_core_types()  # Renomeado para indicar que são os full detections
+
+# NOVO: Filtrar P/E-cores para estarem dentro do limite de EFFECTIVE_LOGICAL_CPUS
+_DET_P = [i for i in _DET_P_full if i < EFFECTIVE_LOGICAL_CPUS]
+_DET_E = [i for i in _DET_E_full if i < EFFECTIVE_LOGICAL_CPUS]
+
+
+
+# ===============================================================
+# Ajuste entre modo auto/manual (apenas meta-informação de arranque)
+# ===============================================================
+_AUTO_META = "manual"
+OMP_THREADS_PLACEHOLDER = compute_effective_cores(EFFECTIVE_LOGICAL_CPUS, OMP_THREADS_UTILIZATION)
+if DETECTION_PERFORMANCE.lower() == "auto":
+    omp_threads = OMP_THREADS_PLACEHOLDER
+    total_detected_filtered = (len(_DET_P or []) + len(_DET_E or []))
+    if total_detected_filtered == 0:
+        _AUTO_META = "auto (fallback homogéneo)"
+    else:
+        p_ratio = len(_DET_P) / total_detected_filtered if total_detected_filtered > 0 else 0
+        if p_ratio >= 0.5:
+            _AUTO_META = f"auto (balanceado P/E → OMP={omp_threads})"
+        else:
+            _AUTO_META = f"auto (balanceado E-heavy → OMP={omp_threads})"
+else:
+    _AUTO_META = "manual"
+
+# Log informativo (mantém o teu estilo)
+print(f"[INFO] [{_ts()}] Modo de desempenho: {DETECTION_PERFORMANCE} ({_AUTO_META})")
+
+
+# --- 1.2 Otimização de Threads/Processos ---
+def compute_omp_threads(cpu_count, utilization):
+    threads = int(math.floor(cpu_count * utilization))
+    return max(1, min(threads, cpu_count))
+
+
+# OMP passa a respeitar o teto de núcleos permitidos por CORES_UTILIZATION
+OMP_THREADS = compute_omp_threads(EFFECTIVE_LOGICAL_CPUS, OMP_THREADS_UTILIZATION)
+
+# --------------------
+# Seleção para tensores (OMP): usar P primeiro; se faltar, completar com E (com ordenação física primeiro)
+siblings = get_core_siblings()
+ordered_P = order_by_physical_first(_DET_P, siblings)
+ordered_E = order_by_physical_first(_DET_E, siblings)
+
+needed = OMP_THREADS
+P_CORE_IDS = []
+if ordered_P:
+    takeP = ordered_P[:min(needed, len(ordered_P))]
+    P_CORE_IDS.extend(takeP)
+    needed -= len(takeP)
+
+# Completar com E-cores se necessário
+if needed > 0 and ordered_E:
+    takeE = [i for i in ordered_E if i not in P_CORE_IDS][:needed]
+    P_CORE_IDS.extend(takeE)
+    needed -= len(takeE)
+
+# Fallback homogéneo: se nada acima preencheu (ex.: sem deteção ou P/E fora do range), usa os primeiros N
+if not P_CORE_IDS:
+    # Agora limitado ao espaço permitido (0..EFFECTIVE_LOGICAL_CPUS-1)
+    P_CORE_IDS = list(range(min(OMP_THREADS, EFFECTIVE_LOGICAL_CPUS)))
+# Isso garante que P_CORE_IDS nunca exceda EFFECTIVE_LOGICAL_CPUS
+
+# Secundários (DataLoader): 1) E não usados, 2) P não usados, 3) quaisquer outros restantes
+used = set(P_CORE_IDS)
+secondary = []
+
+
+# IDs disponíveis dentro do limite efetivo
+available_ids_in_effective_range = set(range(EFFECTIVE_LOGICAL_CPUS))
+
+# 1) E que sobraram e estão dentro do range efetivo
+secondary.extend([i for i in (_DET_E or []) if i not in used and i in available_ids_in_effective_range])
+# 2) P que sobraram e estão dentro do range efetivo
+secondary.extend([i for i in (_DET_P or []) if i not in used and i in available_ids_in_effective_range])
+# 3) Restantes (caso deteção seja homogénea/fallback)
+secondary.extend([i for i in available_ids_in_effective_range
+                  if i not in used
+                  and (i not in (_DET_P or []))
+                  and (i not in (_DET_E or []))])
+
+# Remover duplicados preservando ordem
+_seen = set()
+REMAINING_CORE_IDS = [x for x in secondary if not (x in _seen or _seen.add(x))]
+
+
+# O número de workers deve refletir exatamente os cores sobrantes e nunca exceder o que sobra dos efetivos
+max_workers_possible = max(0, EFFECTIVE_LOGICAL_CPUS - len(P_CORE_IDS))
+DATALOADER_WORKERS = min(len(REMAINING_CORE_IDS), max_workers_possible)
+
+# <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
+# Variáveis de ambiente (mantidas)
+os.environ["OMP_NUM_THREADS"] = str(OMP_THREADS)
+os.environ["MKL_NUM_THREADS"] = str(OMP_THREADS)
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+
+# --- Afinidade (mantida) ---
+def set_affinity(core_ids):
+    try:
+        if platform.system() == "Linux":
+            os.sched_setaffinity(0, set(core_ids))
+        elif platform.system() == "Windows":
+            psutil.Process().cpu_affinity(core_ids)
+    except Exception as e:
+        print(f"[WARN] [{_ts()}] Não foi possível definir afinidade: {e}")
+
+
+
+# Mantém a ordem: P usados primeiro (prioridade), depois secundários
+# Garante que os core_ids são únicos e estão dentro do limite.
+# O conjunto final de IDs passados para afinidade deve ser <= EFFECTIVE_LOGICAL_CPUS
+final_affinity_cores = sorted(list(set(P_CORE_IDS + REMAINING_CORE_IDS)))
+# Filtra para garantir que nenhum ID exceda EFFECTIVE_LOGICAL_CPUS
+final_affinity_cores = [i for i in final_affinity_cores if i < EFFECTIVE_LOGICAL_CPUS]
+set_affinity(final_affinity_cores)
+
+# --------------------
+# Evita duplicação de logs quando Flask recarrega
+if os.environ.get("WERKZEUG_RUN_MAIN") != "true":
+    _LOGS_PRINTED = True
+
+SEC_E = []
+SEC_P = []
+SEC_OTHER = []
+# --------------------
+# Logs informativos detalhados (simplificados, evita repetições)
+if not globals().get("_LOGS_PRINTED", False):
+    _LOGS_PRINTED = True  # marca que já imprimimos uma vez
+    print(f"[INFO] [{_ts()}] Método de deteção: {_META.get('method')}")
+    if _META.get("notes"):
+        for n in _META["notes"]:
+            print(f"[INFO] [{_ts()}] Nota: {n}")
+
+    has_e = bool(_DET_E)
+    # Aqui, _DET_P e _DET_E já estão filtrados para serem <= EFFECTIVE_LOGICAL_CPUS
+    print(f"[INFO] [{_ts()}] Detetados (filtrados) → P: {len(_DET_P)} | E: {len(_DET_E)}")
+
+    # --- Breakdown do que foi realmente usado
+    P_USED_FROM_P = [i for i in P_CORE_IDS if i in (_DET_P or [])]
+    P_USED_FROM_E = [i for i in P_CORE_IDS if i in (_DET_E or [])]
+    SEC_E = [i for i in REMAINING_CORE_IDS if i in (_DET_E or [])]
+    SEC_P = [i for i in REMAINING_CORE_IDS if i in (_DET_P or [])]
+    SEC_OTHER = [i for i in REMAINING_CORE_IDS if (i not in (_DET_P or [])) and (i not in (_DET_E or []))]
+
+    # Tensores
+    if has_e:
+        # P_USED_FROM_P e P_USED_FROM_E já estão corretos devido ao filtro de _DET_P e _DET_E
+        print(
+            f"[INFO] [{_ts()}] Tensores (OMP={OMP_THREADS}) → "
+            f"P: {len(P_USED_FROM_P)} {sorted(P_USED_FROM_P)}"
+            + (f", +E: {len(P_USED_FROM_E)} {sorted(P_USED_FROM_E)}" if P_USED_FROM_E else "")
+        )
+    else:
+        print(f"[INFO] [{_ts()}] Tensores (OMP={OMP_THREADS}) [homogéneo] → {len(P_CORE_IDS)} {sorted(P_CORE_IDS)}")
+
+
+    # Secundários (DataLoader)
+    if has_e:
+        if SEC_E:
+            print(f"[INFO] [{_ts()}] Secundário/DataLoader → E: {len(SEC_E)} {sorted(SEC_E)}")
+        if SEC_P:
+            print(f"[INFO] [{_ts()}] Secundário/DataLoader → P: {len(SEC_P)} {sorted(SEC_P)}")
+        if SEC_OTHER:
+            print(f"[INFO] [{_ts()}] Secundário/DataLoader → Outros: {len(SEC_OTHER)} {sorted(SEC_OTHER)}")
+    else:
+        print(f"[INFO] [{_ts()}] Cores restantes (homogéneo) → {len(REMAINING_CORE_IDS)} {sorted(REMAINING_CORE_IDS)}")
+        print("-" * 80)
+    print(
+        f"[INFO] [{_ts()}] LOGICAL_CPUS: {LOGICAL_CPUS} | PHYSICAL_CPUS: {PHYSICAL_CPUS} | "
+        f"TOTAL_RAM_GB: {TOTAL_RAM_GB:.2f}"
+    )
+    print(f"[INFO] [{_ts()}] Cores Utilization (global): {CORES_UTILIZATION:.2%} → efetivos: {EFFECTIVE_LOGICAL_CPUS}")
+    print(f"[INFO] [{_ts()}] OMP Threads Utilization: {OMP_THREADS_UTILIZATION:.2%}")
+    print(f"[INFO] [{_ts()}] OMP Threads: {OMP_THREADS}, Dataloader Workers: {DATALOADER_WORKERS}")
+    if DATALOADER_WORKERS == 0:
+        print(f"[INFO] [{_ts()}] Sem cores sobrantes para DataLoader (todos {EFFECTIVE_LOGICAL_CPUS} alocados a OMP).")
+
+    # Verificação final da soma
+    total_allocated = len(set(P_CORE_IDS + REMAINING_CORE_IDS))
+    print(
+        f"[INFO] [{_ts()}] Total de núcleos alocados (OMP + DataLoader): {total_allocated} "
+        f"(de {EFFECTIVE_LOGICAL_CPUS} efetivos)"
+    )
+    print("-" * 80)    
+    print(f"[INFO] [{_ts()}] Iniciando processo de treino...\n")
+    print("-" * 80)
+
+#--------------------------------------------------------------------------------------------------
+#--------------------------------------------------------------------------------------------------
+# --- 1.3 Parâmetros base do treino ---
+BASE_BATCH_SIZE = 1                          # Valor base para o batch size (reduzido para CPU)
+INITIAL_ACCUMULATION_MIN_STEPS = 2
+INITIAL_ACCUMULATION_MAX_STEPS = 4
+BASE_EVAL_SIZE = 2                           # Batch size para avaliação (reduzido para CPU)
+BASE_LEARNING_RATE = 5e-5                    # 2e-5
+LR_SCHEDULER_TYPE = "constant_with_warmup"   # (HF: cosine + warmap) cosine
+WARMUP_RATIO = 0.03                          # ~3% dos 4012 steps ≈ 120
+LOGGIN_STEPS = 25
+SAVE_STRATEGY = "steps"
+SAVE_STEPS = 2
+EVAL_STEPS = 2
+#MAX_GRAD_NORM = 1.0
+WEIGHT_DECAY = 0.1
+OPTIM = "adamw_torch"
+
+# --- 1.4 Utilização de RAM ---
+TARGET_RAM_UTILIZATION = 0.95  # Limite máximo de uso da RAM total
+
+# --- 1.5 Parâmetros para Ajuste Dinâmico do Batch Size (ajustar_accumulation_steps) ---
+# Estimação: custo empírico de RAM por batch (ajuste este valor)
+ESTIMATED_BATCH_GB = 0.30   #0.4 llama
+ 
+# Utilização de RAM alvo para o cálculo de acumulação de gradientes
+TARGET_ACCUMULATION_RAM_UTILIZATION = TARGET_RAM_UTILIZATION # Reutiliza a RAM geral
+
+# --- 1.6 Parâmetros para MAX_LEN Dinâmico (ajustar_max_len) ---
+BASE_MAX_LEN = 256
+TARGET_MAX_LEN_UTILIZATION = 0.65  #0.65
+MAX_LEN_INCREMENT = 128
+MAX_LEN_CAP = 256
+
+# Valores padrão ajustáveis
+DEFAULT_FALLBACK_CAP = 8192        # ou MAX_LEN_CTX, se preferires
+TOKENIZER_SENTINEL_CAP = 10_000_000
+
+# Custo empírico de RAM para o dataset (ajuste estes valores)
+ESTIMATED_BASE_DATASET_RAM_GB = 1.6
+COST_PER_INCREMENT_GB = 0.30  #0.45 llama
+
+# --- 1.7 Parâmetros para DynamicAccumulationCallback ---
+DYNAMIC_ACCUMULATION_MAX_STEPS = 256        # Limite superior para gradient_accumulation_steps (usado na função e no callback)
+DYNAMIC_ACCUMULATION_TARGET_UTIL = 0.95     # Target de RAM no callback (não usado diretamente, mas mantido para clareza)
+DYNAMIC_ACCUMULATION_HIGH_RAM_LIMIT = 90.5    # Porcentagem de RAM para começar a reduzir o step
+DYNAMIC_ACCUMULATION_LOW_RAM_LIMIT = 40.0     # Porcentagem de RAM para começar a aumentar o step
+
+# --- 1.8 Ganchos opcionais para PyTorch (se estiver disponível) ---
+from contextlib import suppress
+
+with suppress(ImportError):
+    import torch
+    # Alinhar threads de Torch com OMP para evitar oversubscription
+    if hasattr(torch, "set_num_threads"):
+        torch.set_num_threads(max(1, OMP_THREADS))
+    if hasattr(torch, "set_num_interop_threads"):
+        # Interop baixo ajuda a estabilidade — normalmente 1 ou 2 é suficiente.
+        torch.set_num_interop_threads(max(1, min(2, DATALOADER_WORKERS)))
+
+# --- 1.9 Outros parâmetros  -
+OPTIMIZER_REFRESH_INTERVAL = 300  # segundos
+# =========================================================================
+# 2️.Configuração Inicial e Cálculos
+# =========================================================================
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+# --- Funções de Ajuste Dinâmico ---
+def ajustar_accumulation_steps(
+    base_batch: int = BASE_BATCH_SIZE, 
+    target_utilization: float = TARGET_ACCUMULATION_RAM_UTILIZATION,
+    estimated_batch_gb: float = ESTIMATED_BATCH_GB,
+    min_steps: int = INITIAL_ACCUMULATION_MIN_STEPS,
+    max_steps: int = INITIAL_ACCUMULATION_MAX_STEPS
+) -> int:
+    """
+    Ajusta gradient_accumulation_steps com base na RAM disponível (somente no arranque).
+    Respeita limites próprios e separados da fase dinâmica.
+    """
+    mem = psutil.virtual_memory()
+    free_gb = mem.available / (1024 ** 3)
+    
+    available_ram_for_batch_gb = TOTAL_RAM_GB * target_utilization
+    max_batches_fit = int(available_ram_for_batch_gb / estimated_batch_gb)
+
+    steps = max(min_steps, min(max_batches_fit // base_batch, max_steps))
+
+    logging.info(f"Memória usada: {mem.percent:.1f}% ({free_gb:.1f} GB livres)")
+    logging.info(f"Ajustando gradient_accumulation_steps (inicial) → {steps}")
+    
+    return steps
+#----------------------------------------------------------
+def ajustar_max_len(
+    tokenizer_model_max_length: int, 
+    target_utilization: float = TARGET_MAX_LEN_UTILIZATION, 
+    base_max_len: int = BASE_MAX_LEN, 
+    increment: int = MAX_LEN_INCREMENT, 
+    max_cap: int = MAX_LEN_CAP,
+    estimated_base_dataset_ram_gb: float = ESTIMATED_BASE_DATASET_RAM_GB,
+    cost_per_increment_gb: float = COST_PER_INCREMENT_GB
+) -> int:
+    """
+    Ajusta automaticamente MAX_LEN conforme RAM disponível e limite do modelo.
+    """
+    # RAM que pode ser usada para o dataset tokenizado
+    target_dataset_ram_gb = TOTAL_RAM_GB * target_utilization
+    current_max_len = base_max_len
+
+    if target_dataset_ram_gb < estimated_base_dataset_ram_gb:
+        log_warning(f"RAM disponível ({target_dataset_ram_gb:.1f} GB) é menor que a RAM estimada para MAX_LEN base ({estimated_base_dataset_ram_gb:.1f} GB). Usando MAX_LEN={base_max_len}.")
+        return min(base_max_len, tokenizer_model_max_length)
+
+    # Quantidade de RAM que podemos usar para expandir o MAX_LEN além do custo base
+    expandable_ram_gb = target_dataset_ram_gb - estimated_base_dataset_ram_gb
+    
+    if expandable_ram_gb > 0:
+        num_increments = int(expandable_ram_gb / cost_per_increment_gb)
+        current_max_len += num_increments * increment
+    
+    # Limitar pelo MAX_LEN_CAP e pelo limite do modelo
+    final_max_len = min(current_max_len, max_cap, tokenizer_model_max_length)
+    
+#    logging.info(f"RAM total: {TOTAL_RAM_GB:.1f} GB. RAM alvo para dataset: {target_dataset_ram_gb:.1f} GB.")
+#    logging.info(f"Ajustando MAX_LEN dinamicamente -> {final_max_len} (limite do modelo: {tokenizer_model_max_length})")
+    
+    logging.info(
+    f"RAM total: {TOTAL_RAM_GB:.1f} GB. RAM alvo para dataset: {target_dataset_ram_gb:.1f} GB.")
+    logging.info(
+    f"Ajustando MAX_LEN dinamicamente -> {final_max_len} "
+    f"(limite efetivo do modelo/tokenizer: {tokenizer_model_max_length})"
+)
+    
+    return final_max_len
+
+# ==============================
+# 3.Optimizer Refresh Callback
+# ==============================
+class OptimizerRefreshCallback(TrainerCallback):
+    def __init__(self, refresh_interval_sec: int = OPTIMIZER_REFRESH_INTERVAL):
+        self.refresh_interval = refresh_interval_sec
+        self.last_refresh_time = time.time()
+
+    def on_step_end(self, args, state, control, **kwargs):
+        trainer = kwargs.get("trainer", None)
+        if trainer is None:
+            return control
+
+        now = time.time()
+        elapsed = now - self.last_refresh_time
+
+        if elapsed >= self.refresh_interval:
+            logging.info(f"🔄 Refresh do otimizador após {elapsed:.1f}s (passo {state.global_step})")
+
+            # Faz o refresh
+            if hasattr(trainer, "scaler") and trainer.scaler is not None:
+                trainer.scaler.step(trainer.optimizer)
+                trainer.scaler.update()
+            else:
+                trainer.optimizer.step()
+
+            trainer.optimizer.zero_grad()
+            self.last_refresh_time = now
+
+        return control
+
+# ========================================================
+# 4.CALLBACK DINÂMICO PARA AJUSTE DE GRADIENT ACCUMULATION
+# ========================================================
+class DynamicAccumulationCallback(TrainerCallback):
+    def __init__(
+        self,
+        base_batch: int = BASE_BATCH_SIZE,
+        max_steps: int = DYNAMIC_ACCUMULATION_MAX_STEPS,
+        high_ram_limit: int = DYNAMIC_ACCUMULATION_HIGH_RAM_LIMIT,
+        low_ram_limit: int = DYNAMIC_ACCUMULATION_LOW_RAM_LIMIT,
+        step_interval: int = 5,         # nº de steps entre verificações
+        time_interval: int = 240         # intervalo mínimo em segundos (10 min)
+    ):
+        self.base_batch = base_batch
+        self.max_steps = max_steps
+        self.high_ram_limit = high_ram_limit
+        self.low_ram_limit = low_ram_limit
+        self.step_interval = step_interval
+        self.time_interval = time_interval
+
+        # controle interno
+        self.last_check_step = 0
+        self.last_check_time = time.time()
+
+    def on_step_end(self, args, state, control, **kwargs):
+        global CURRENT_ACCUM_STEPS
+
+        current_step = state.global_step
+        now = time.time()
+
+        # --- 1️⃣ Verifica se há override manual ativo ---
+        if CURRENT_ACCUM_STEPS is not None:
+            adjusted_steps = max(1, min(self.max_steps, CURRENT_ACCUM_STEPS))
+            args.gradient_accumulation_steps = adjusted_steps
+            effective_batch = adjusted_steps * self.base_batch
+
+            train_progress["current_accum_steps"] = adjusted_steps
+            logging.info(
+                f"🧭 Ajuste manual aplicado → gradient_accumulation_steps = {adjusted_steps} "
+                f"(Effective Batch: {effective_batch})"
+            )
+            CURRENT_ACCUM_STEPS = None            
+          
+            return control
+
+        # --- 2️⃣ Verifica se já passou o intervalo mínimo ---
+        step_diff = current_step - self.last_check_step
+        time_diff = now - self.last_check_time
+
+        if step_diff < self.step_interval and time_diff < self.time_interval:
+            # ainda não é hora de checar novamente
+            return control
+
+        # Atualiza controle de tempo e step
+        self.last_check_step = current_step
+        self.last_check_time = now
+
+        # --- 3️⃣ Ajuste automático baseado na RAM ---
+        mem = psutil.virtual_memory()
+        used = mem.percent
+
+        current_steps = args.gradient_accumulation_steps
+
+        # RAM alta → reduzir steps
+        if used > self.high_ram_limit and current_steps > 1:
+            new_steps = max(1, math.floor(current_steps / 1.6))
+            args.gradient_accumulation_steps = new_steps
+            new_effective_batch = new_steps * self.base_batch  # ✅ novo valor após ajuste
+
+            train_progress["current_accum_steps"] = new_steps
+            logging.warning(
+                f"⚠️ RAM alta ({used:.1f}%) → diminuindo accumulation_steps "
+                f"de {current_steps} para {new_steps} "
+                f"(Effective Batch: {new_effective_batch})"
+            )
+
+        # RAM ociosa → aumentar steps
+        elif used < self.low_ram_limit and current_steps < self.max_steps:
+            new_steps = current_steps + 1
+            args.gradient_accumulation_steps = new_steps
+            new_effective_batch = new_steps * self.base_batch  # ✅ recalculado após aumento
+
+            train_progress["current_accum_steps"] = new_steps
+            logging.info(
+                f"💡 RAM ociosa ({used:.1f}%) → aumentando accumulation_steps "
+                f"de {current_steps} para {new_steps} "
+                f"(Effective Batch: {new_effective_batch})"
+            )
+
+
+        return control
+#----------------------------
+# Sistema de Logs Coloridos
+class Colors:
+    HEADER = "\033[95m"
+    OKBLUE = "\033[94m"
+    OKCYAN = "\033[96m"
+    OKGREEN = "\033[92m"
+    WARNING = "\033[93m"
+    FAIL = "\033[91m"
+    ENDC = "\033[0m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+
+def log_info(msg):
+    time_str = datetime.now().strftime("%H:%M:%S")
+    print(f"{Colors.OKCYAN}[INFO]{Colors.ENDC} [{time_str}] {msg}")
+    training_logs.append(f"[INFO] [{time_str}] {msg}")
+
+def log_success(msg):
+    time_str = datetime.now().strftime("%H:%M:%S")
+    print(f"{Colors.OKGREEN}[SUCESSO]{Colors.ENDC} [{time_str}] {msg}")
+    training_logs.append(f"[SUCESSO] [{time_str}] {msg}")
+
+def log_warning(msg):
+    time_str = datetime.now().strftime("%H:%M:%S")
+    print(f"{Colors.WARNING}[AVISO]{Colors.ENDC} [{time_str}] {msg}")
+    training_logs.append(f"[AVISO] [{time_str}] {msg}")
+
+def log_error(msg):
+    time_str = datetime.now().strftime("%H:%M:%S")
+    print(f"{Colors.FAIL}[ERRO]{Colors.ENDC} [{time_str}] {msg}")
+    training_logs.append(f"[ERRO] [{time_str}] {msg}")
+
+def log_step(msg, step=None, percent=None):
+    time_str = datetime.now().strftime("%H:%M:%S")
+    prefix = f"[{time_str}]"
+    progress = f" | Passo {step}" if step is not None else ""
+    pct = f" ({percent:.1f}%)" if percent is not None else ""
+    print(f"{Colors.OKBLUE}{prefix}{Colors.ENDC} {msg}{progress}{pct}")
+    training_logs.append(f"{prefix} {msg}{progress}{pct}")
+ 
+#---------------------------------------------------------------
+# Pega o logger padrão do Python
+# logger = logging.getLogger(__name__) # (Comentado porque você usa funções customizadas)
+# Global trackers para o cálculo de tempo
+g_last_step_time = [time.time()]
+g_last_step_logged = [-1]
+
+class SimpleStepTimerCallback(TrainerCallback):
+    """
+    Loga o tempo gasto em cada passo individual APENAS em segundos.
+    Usa o logger do Trainer para que se misture com os logs normais.
+    """
+    def on_step_begin(self, args, state, control, **kwargs):
+        # Reinicia o tempo no início de cada passo para cálculo preciso
+        if state.is_local_process_zero:
+            g_last_step_time[0] = time.time()
+            g_last_step_logged[0] = state.global_step
+
+    def on_step_end(self, args, state, control, **kwargs):
+        if not state.is_local_process_zero:
+            return
+
+        step = state.global_step
+        
+        # Evita logar o passo '0' se on_step_begin não foi executado antes
+        if step == 0:
+            return
+
+        # O tempo inicial foi registrado em on_step_begin para este passo.
+        now = time.time()
+        elapsed_for_this_step = now - g_last_step_time[0]
+        
+        # --- Geração da Mensagem Apenas em Segundos ---
+        # Formata o tempo para ter no máximo 3 casas decimais, por exemplo: 9.605s
+        time_str = f"{elapsed_for_this_step:.3f}s" 
+
+        msg = (
+            f"PASSO: - - | {step}/{state.max_steps} |                  "
+            f"Tempo: | {time_str} |"
+        )
+        
+        # O ponto crucial: Logar a mensagem usando o logger do Trainer 
+        # (Trainer.log é o método do Trainer que faz o logging apropriado)
+        if hasattr(self, 'trainer') and hasattr(self.trainer, 'log'):
+             # Se a callback tiver acesso direto ao trainer (como acontece em implementações mais modernas)
+             self.trainer.log({"step_time": elapsed_for_this_step, "log_msg": msg})
+        else:
+             # Se for uma implementação mais simples que usa args, state, control, podemos usar o logger global
+             # Este é um fallback, mas o melhor é usar o logger do transformers
+             logger = kwargs.get('logger', None) # Tenta obter o logger se passado nos kwargs
+             if logger:
+                 logger.info(f">> {msg}")
+             else:
+                 # Se você tiver configurado um logger global no seu script:
+                 # import logging
+                 # logging.info(f">> {msg}")
+                 # OU: Para garantir que apareça onde os seus outros logs de data e IP aparecem, 
+                 # use o logging padrão do Python.
+                 import logging
+                 logging.info(f">> {msg}")
+        
+        # Opcional: Registar também na sua lista de logs geral, usando log_info.
+        # log_info(msg)
+
+#----------------------------------------------------
+# Callback para logs detalhados do treino
+#----------------------------------------------------
+last_log_time = [time.time()]
+last_logged_step = {"step": -1}
+
+class LogCallback(TrainerCallback):
+    def on_log(self, args, state, control, logs=None, **kwargs):
+        global train_progress
+        if not state.is_local_process_zero or not logs:
+            return
+
+        step = state.global_step
+        total_steps = state.max_steps
+        loss = logs.get("loss")
+        eval_loss = logs.get("eval_loss")
+        lr = logs.get("learning_rate")
+        accum = train_progress.get("current_accum_steps", args.gradient_accumulation_steps)
+
+        # Evita repetir o log para o mesmo step
+        if step == last_logged_step["step"]:
+            return
+        last_logged_step["step"] = step
+
+        now = time.time()
+        elapsed = now - last_log_time[0]
+        last_log_time[0] = now
+
+        if loss is not None and total_steps > 0:
+            percent = (step / total_steps * 100)
+            mem = psutil.virtual_memory()
+            free_gb = mem.available / (1024**3)
+            msg = (
+                f"Treino: step {step}/{total_steps} | Perda: {loss:.4f} | "
+                f"Tempo/step: {elapsed:.2f}s | Memória usada: {mem.percent:.1f}% | "
+                f"LR: {lr:.2e} | Accum: {accum} |"                
+            )
+            log_step(msg, step=step, percent=percent)
+            train_progress.update({
+                "current": step,
+                "total": total_steps,
+                "percent": int(percent),
+                "status": "training",
+                "message": msg
+            })
+
+        elif eval_loss is not None:
+            msg = f"Avaliação: step {step}/{total_steps} | Eval Loss: {eval_loss:.4f}"
+            try:
+                perplexity = math.exp(eval_loss) if eval_loss < 20 else float("inf")
+                msg += f" | Perplexidade: {perplexity:.2f}"
+            except:
+                pass
+            log_info(msg)
+            train_progress["message"] = msg
+#--------------------------------------------------------------
+    def on_epoch_end(self, args, state, control, **kwargs):
+        global epoch_losses
+        if state.is_local_process_zero:
+            # Encontrar o log da época mais recente que contenha a perda de treino
+            # Ou o log de avaliação da época, se houver
+            epoch_log_loss = next((log for log in reversed(state.log_history) if 'loss' in log and 'epoch' in log and int(log['epoch']) == int(state.epoch) and 'eval_loss' not in log), None)
+            epoch_log_eval_loss = next((log for log in reversed(state.log_history) if 'eval_loss' in log and 'epoch' in log and int(log['epoch']) == int(state.epoch)), None)
+
+            loss_msg = ""
+            if epoch_log_loss and 'loss' in epoch_log_loss:
+                loss = epoch_log_loss['loss']
+                loss_msg += f"Perda Média de Treino: {loss:.4f}"
+                # Adicionar apenas o loss de treino para a lista de perdas de época
+                epoch_losses.append({"epoch": int(state.epoch), "loss": loss})
+            
+            if epoch_log_eval_loss and 'eval_loss' in epoch_log_eval_loss:
+                eval_loss = epoch_log_eval_loss['eval_loss']
+                if loss_msg:
+                    loss_msg += " | "
+                loss_msg += f"Perda de Avaliação: {eval_loss:.4f}"
+                
+            if loss_msg:
+                log_success(f"Fim da Época {int(state.epoch)} | {loss_msg}")
+            else:
+                log_success(f"Fim da Época {int(state.epoch)}")
+
+#--------------------------------------------------
+# Variáveis Globais
+model = None  # variável global
+tokenizer = None
+
+train_progress = {
+    "current": 0, 
+    "total": 1, 
+    "percent": 0, 
+    "status": "not started", 
+    "message": "Aguardando início do treino."
+}
+training_logs = []   # se já usas este array, mantém; (ver #3 para acrescentar linhas nele)
+epoch_losses = []
+all_data = []        # Armazena os dados do último treino para poder continuar
+
+chat_model = None
+chat_tokenizer = None
+CURRENT_ACCUM_STEPS = None
+#CURRENT_ACCUM_STEPS = 1  # Valor inicial padrão
+
+# --- NOVOS CAMPOS (para interface mostrar info de accumulation e nº total de passos) ---
+LAST_ACCUM_ORIGIN = None         # "manual" | "auto" | None
+TOTAL_TRAIN_STEPS = None         # total de passos desta execução (após tokenização/Trainer)
+BASE_BATCH_SIZE_EFFECTIVE = 4    # (opcional) mantém aqui para calcular Effective Batch no /status
+
+# -------------------------------------------------
+training_logs.append(f"[INFO] accumulation inicial = {CURRENT_ACCUM_STEPS} (auto)")
+# --- Execução dos Cálculos Iniciais ---
+ACCUMULATION_STEPS = ajustar_accumulation_steps()
+EFFECTIVE_BATCH_SIZE = BASE_BATCH_SIZE * ACCUMULATION_STEPS
+
+LAST_ACCUM_ORIGIN = "auto"  # indica que veio do ajuste automático
+BASE_BATCH_SIZE_EFFECTIVE = EFFECTIVE_BATCH_SIZE
+
+#----------------------------
+# Função principal de treino
+#----------------------------
+def train_model_lora(
+    file_data, epochs, model_path, output_dir, accumulation_steps,
+    dataloader_workers, mode, lora_adapter_to_load=None,
+    initial_epochs_completed=0, train_mode="new_train"
+):
+    """
+    Função principal de treino LoRA (Low-Rank Adaptation)
+    Corrigido para evitar IndentationError e melhorar a legibilidade.
+    """
+    # ---------------- VARIÁVEIS GLOBAIS ----------------
+    global training_logs, train_progress, epoch_losses
+    training_logs.clear()
+    train_progress.update({
+        "status": "loading",
+        "percent": 0,
+        "message": "Iniciando processo de treino..."
+    })
+    log_info("Iniciando processo de treino...")
+    all_data = file_data
+
+    # ---------------- LOGGING INICIAL ----------------
+    # log_info(f"CPU: {CPU_COUNT} núcleos, {TOTAL_RAM_GB:.1f} GB RAM")
+    log_info(f"OMP Threads: {OMP_THREADS}, Dataloader Workers: {DATALOADER_WORKERS}")
+    log_info(f"Batch base: {BASE_BATCH_SIZE}, Steps iniciais: {ACCUMULATION_STEPS}")
+    log_info(f"Batch efetivo inicial: {EFFECTIVE_BATCH_SIZE}")
+
+    # ----------------------------------------------------
+    # O status inicial é "starting" ou "resuming"
+    initial_status_message = "Iniciando processo de treino..."
+    if lora_adapter_to_load:
+        initial_status_message = "Retomando treino a partir de adaptador LoRA salvo..."
+    
+    train_progress = {
+        "current": 0,
+        "total": 1,
+        "percent": 0,
+        "status": "starting",
+        "message": initial_status_message
+    }
+    log_info(initial_status_message)
+
+    # Guarda os dados para a função 'continuar'
+    all_data = file_data  # Atualiza a global all_data com os dados atuais do treino
+
+    # ----------------------------------------------------
+    # Função auxiliar: detectar camadas LoRA automaticamente
+    def guess_lora_targets(model):
+        names = {name for name, _ in model.named_modules()}
+        if any("q_proj" in n and "v_proj" in n for n in names):
+            return ["q_proj", "v_proj"]
+        if any("query_key_value" in n for n in names):
+            return ["query_key_value"]
+        if any("Wqkv" in n for n in names):
+            return ["Wqkv"]
+        if any("c_attn" in n for n in names):
+            return ["c_attn"]
+        log_warning("Não foi possível detetar os target_modules. Usando ['q_proj', 'v_proj'] por defeito.")
+        return ["q_proj", "v_proj"]
+
+    # ----------------------------------------------------
+    # BLOCO NOVO PARA XPU
+    """
+    Seleção de dispositivo (CPU / CUDA / XPU)
+    Este patch substitui o bloco onde escolhes device_map/dtype durante o carregamento do modelo.
+    Adiciona a opção "xpu" antes de cair para CUDA/CPU.
+    """
+
+    # ----------------------------------------------------
+    # Bloco 1: Carregar Modelo e Tokenizer
+    try:
+        log_step("A carregar modelo e tokenizer base...")
+
+        os.makedirs("offload", exist_ok=True)
+        
+        global tokenizer
+        tokenizer = AutoTokenizer.from_pretrained(model_path, use_fast=True)
+
+        # Garantir tokens especiais e consistência
+        log_info(f"Tokens antes do ajuste: PAD={tokenizer.pad_token}, EOS={tokenizer.eos_token}, BOS={tokenizer.bos_token}")
+        if tokenizer.pad_token is None:
+            tokenizer.add_special_tokens({'pad_token': '<PAD>'})
+        if tokenizer.eos_token is None:
+            tokenizer.add_special_tokens({'eos_token': '</s>'})
+        if tokenizer.bos_token is None:
+            tokenizer.add_special_tokens({'bos_token': '<s>'})
+        if tokenizer.unk_token is None:
+            tokenizer.add_special_tokens({'unk_token': '<unk>'})
+        log_info(
+            f"Tokens após ajuste: PAD={tokenizer.pad_token}, "
+            f"EOS={tokenizer.eos_token}, BOS={tokenizer.bos_token}, "
+            f"UNK={tokenizer.unk_token}"
+        )
+
+        # ------- Substituído para XPU ----------
+        # Seleção de dispositivo (CPU / CUDA / XPU)
+        use_xpu = hasattr(torch, "xpu") and torch.xpu.is_available()
+        if use_xpu:
+            # Em Intel, BF16 costuma ser a melhor escolha
+            model_dtype = torch.bfloat16
+            model_device_map = {"": "xpu"}
+            print(f"[INFO] [{_ts()}] Device selecionado: XPU (Intel iGPU) | dtype={model_dtype}")
+        elif torch.cuda.is_available():
+            model_dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
+            model_device_map = "auto"
+            print(f"[INFO] [{_ts()}] Device selecionado: CUDA | dtype={model_dtype}")
+        else:
+            model_dtype = torch.bfloat16  # bf16 em CPU é ~2x mais rápido que float32
+            model_device_map = "cpu"
+            print(f"[INFO] [{_ts()}] Device selecionado: CPU | dtype={model_dtype}")
+
+        # Carregar modelo base
+        model = AutoModelForCausalLM.from_pretrained(
+            model_path,
+            device_map=model_device_map,
+            offload_folder="offload",
+            dtype=model_dtype,
+            low_cpu_mem_usage=True
+        )
+
+        # Fallback: se o device_map não moveu o modelo (versões antigas)
+        if use_xpu:
+            try:
+                model.to("xpu")
+            except Exception as e:
+                print(f"[WARN] [{_ts()}] .to('xpu') falhou (Transformers antigo?). "
+                      f"A continuar com device_map… Detalhe: {e}")
+
+        model.resize_token_embeddings(len(tokenizer))
+        model.config.use_cache = False
+        model.gradient_checkpointing_enable()  # economiza memória e acelera CPU
+        # ------- Fim do bloco novo XPU ----------
+    
+#-------------------------------------------------
+        # --- Variáveis para controle de fluxo ---
+        resume_from_trainer_checkpoint = None
+        lora_adapter_path_final = os.path.join(output_dir, "lora_model")
+        lora_adapter_to_load_for_training = None   # Variável para controlar qual LoRA carregar para o treino
+        lora_model_loaded_for_initial_eval = False # Adicione esta variável para controle
+    
+#---------------------------------------------------------------------              
+        # --- Lógica de 4 opções ---
+        # Prioridade: 
+        #1. Checkpoint do Trainer
+        #2. LoRA Final Salvo
+        #3. LoRA passado como parâmetro (para continuar)
+        #4. Novo LoRA
+
+        # 1. Tentar encontrar o checkpoint mais recente do Trainer
+        checkpoint_dirs = [d for d in os.listdir(output_dir) if d.startswith("checkpoint-")]
+        if checkpoint_dirs:
+            checkpoint_dirs.sort(key=lambda x: int(x.split('-')[1]), reverse=True)
+            latest_candidate_checkpoint_dir = os.path.join(output_dir, checkpoint_dirs[0])
+
+            trainer_state_exists = os.path.exists(os.path.join(latest_candidate_checkpoint_dir, "trainer_state.json"))
+            lora_adapter_exists_in_checkpoint = (
+                os.path.exists(os.path.join(latest_candidate_checkpoint_dir, "adapter_model.safetensors")) or
+                os.path.exists(os.path.join(latest_candidate_checkpoint_dir, "adapter_model.bin"))
+            )
+
+            if trainer_state_exists and lora_adapter_exists_in_checkpoint:
+                resume_from_trainer_checkpoint = latest_candidate_checkpoint_dir
+                lora_adapter_to_load_for_training = latest_candidate_checkpoint_dir # Usar este LoRA para o treino
+                log_info(f"Opção 1: Encontrado checkpoint COMPLETO do Trainer em: {resume_from_trainer_checkpoint}. O treino será retomado daqui.")
+
+                # Extrair initial_epochs_completed do trainer_state.json
+                trainer_state_path = os.path.join(resume_from_trainer_checkpoint, "trainer_state.json")
+                if os.path.exists(trainer_state_path):
+                    with open(trainer_state_path, 'r') as f:
+                        trainer_state = json.load(f)
+                        initial_epochs_completed = int(trainer_state.get('epoch', 0))
+                        log_info(f"Checkpoint do Trainer encontrado. Épocas já completadas: {initial_epochs_completed}")
+                else:
+                    log_warning(f"trainer_state.json não encontrado em {resume_from_trainer_checkpoint}. Assumindo 0 épocas completadas.")
+            else:
+                log_info(f"Diretório '{latest_candidate_checkpoint_dir}' encontrado, mas NÃO é um checkpoint COMPLETO do Trainer (faltam trainer_state.json ou arquivos do adaptador LoRA).")
+
+#------------------------------------------------------------------------------------------------------------------------------------------------
+        # 2. Se não encontrou checkpoint do Trainer, tentar carregar um modelo LoRA final salvo (para avaliação/decisão)
+        # Esta opção deve ter prioridade sobre o LoRA final salvo, se o usuário explicitamente pediu para continuar com um LoRA.
+        if not resume_from_trainer_checkpoint and os.path.exists(lora_adapter_path_final) and any(os.scandir(lora_adapter_path_final)):
+            try:
+        # Carrega o LoRA final para avaliação/decisão, mas não para retomar o treino do Trainer
+                model = PeftModel.from_pretrained(model, lora_adapter_path_final, device_map=model_device_map)
+                for name, param in model.named_parameters():
+                    if "lora" in name:
+                        param.requires_grad = True
+                        
+                lora_adapter_to_load_for_training = lora_adapter_to_load # Usar este LoRA para o treino
+                log_info(f"Opção 2: Carregado adaptador LoRA de '{lora_adapter_to_load}' para continuar o treino.")
+                # Se estamos continuando, precisamos saber as épocas já completadas.
+                # Se lora_adapter_to_load é um checkpoint, podemos tentar ler o trainer_state.json
+                # Caso contrário, assumimos que é um LoRA final e o treino começa "do zero" em termos de Trainer state.
+                if "checkpoint-" in lora_adapter_to_load: # Se o LoRA passado é um checkpoint
+                    trainer_state_path = os.path.join(lora_adapter_to_load, "trainer_state.json")
+                    if os.path.exists(trainer_state_path):
+                        with open(trainer_state_path, 'r') as f:
+                            trainer_state = json.load(f)
+                            initial_epochs_completed = int(trainer_state.get('epoch', 0))
+                            log_info(f"LoRA de checkpoint encontrado. Épocas já completadas: {initial_epochs_completed}")
+                    else:
+                        log_warning(f"trainer_state.json não encontrado em {lora_adapter_to_load}. Assumindo 0 épocas completadas para continuação.")
+                else:
+                    # Se é um LoRA final, não há estado de Trainer para retomar, então initial_epochs_completed permanece 0
+                    log_info("LoRA final carregado para continuação. Treino do Trainer começará do zero.")
+
+            except Exception as e:
+                log_error(f"Falha ao carregar LoRA de '{lora_adapter_to_load}' para continuar o treino: {e}. Iniciando um novo LoRA.")
+                lora_adapter_to_load = None
+                lora_adapter_to_load_for_training = None # Resetar para criar um novo LoRA                        
+                        
+        # 3. Se não há checkpoint do Trainer nem LoRA final, mas um LoRA foi passado para continuar
+        # Esta opção só deve ser considerada se NENHUMA das opções anteriores foi ativada.
+        if not resume_from_trainer_checkpoint and not lora_adapter_to_load_for_training and os.path.exists(lora_adapter_path_final) and any(os.scandir(lora_adapter_path_final)):
+            try:
+                # Carrega o LoRA final para avaliação/decisão, mas não para retomar o treino do Trainer
+                model = PeftModel.from_pretrained(model, lora_adapter_path_final, device_map=model_device_map)
+                for name, param in model.named_parameters():
+                    if "lora" in name:
+                        param.requires_grad = True
+                lora_model_loaded_for_initial_eval = True
+                lora_adapter_to_load_for_training = lora_adapter_path_final # Usar este LoRA para o treino
+                log_info(f"Opção 3: Carregado adaptador LoRA final de: {lora_adapter_path_final}. Será avaliado e aguardará decisão do usuário.")
+                # Se carregamos um LoRA final, não há estado de Trainer para retomar, então initial_epochs_completed permanece 0
+                initial_epochs_completed = 0 # Garante que é 0 se não veio de um checkpoint completo
+            except Exception as e:
+                log_warning(f"Falha ao carregar LoRA final de {lora_adapter_path_final}: {e}. Prosseguindo sem ele.")
+                lora_adapter_path_final = None
+                lora_model_loaded_for_initial_eval = False
+                lora_adapter_to_load_for_training = None # Resetar para criar um novo LoRA
+        
+        # --- Carregar o LoRA no modelo base ANTES de inicializar o Trainer ---
+        # Este bloco garante que o modelo base tenha o LoRA aplicado antes do Trainer ser instanciado.
+        # Ele só deve ser executado se um LoRA foi identificado para ser carregado
+        # E se o modelo ainda não é um PeftModel (ou seja, não foi carregado nas opções 1, 2 ou 3 acima)
+        if lora_adapter_to_load_for_training and not isinstance(model, PeftModel):
+            try:
+                model = PeftModel.from_pretrained(model, lora_adapter_to_load_for_training, device_map=model_device_map)
+                for name, param in model.named_parameters():
+                    if "lora" in name:
+                        param.requires_grad = True
+                log_info(f"Aplicado adaptador LoRA '{lora_adapter_to_load_for_training}' ao modelo base.")
+            except Exception as e:
+                log_error(f"Falha crítica ao aplicar LoRA '{lora_adapter_to_load_for_training}' ao modelo base: {e}. Iniciando um novo LoRA.")
+                lora_adapter_to_load_for_training = None
+                resume_from_trainer_checkpoint = None # Não podemos retomar o Trainer se o LoRA falhou
+                initial_epochs_completed = 0 # Resetar se falhou        
+ 
+        # 4. Se nenhuma das opções acima, criar um novo adaptador LoRA
+        if not lora_adapter_to_load_for_training: # Se nenhum LoRA foi carregado/selecionado
+            targets = guess_lora_targets(model)
+            lora_config = LoraConfig(
+                r=16, lora_alpha=32, target_modules=targets, lora_dropout=0.05, bias="none", task_type=TaskType.CAUSAL_LM
+            )
+            model = get_peft_model(model, lora_config)
+            log_info(f"Opção 1: Nenhum checkpoint ou LoRA anterior encontrado. Novo adaptador LoRA criado (targets={targets}).")
+            resume_from_trainer_checkpoint = None # Se é um novo LoRA, não há estado de Trainer para retomar
+
+        if hasattr(model, "print_trainable_parameters"):
+            model.print_trainable_parameters()
+        else:
+            log_warning("print_trainable_parameters() não disponível neste modelo base.")
+
+#-----------------------
+# Antes de calcular total_target_epochs, ajuste initial_epochs_completed
+# Determine o número de épocas que o Trainer deve executar
+        # Este é o valor que será passado para num_train_epochs do TrainingArguments
+        if train_mode == "new_train":
+            # Para um novo treino, o Trainer deve executar 'epochs' vezes.
+            # initial_epochs_completed é 0, o que é handled pelo Trainer.
+            num_epochs_for_trainer = float(epochs) 
+            log_info(f"Modo 'new_train' detectado. O treino será executado por {num_epochs_for_trainer} épocas.")
+            
+        elif train_mode == "continue_train":
+            # Para continuar, o Trainer deve executar até o 'initial_epochs_completed + epochs' total.
+            # Se você quer fazer mais 'X' épocas, o total final será initial_epochs_completed + X.
+            num_epochs_for_trainer = float(initial_epochs_completed + epochs) 
+            log_info(f"Modo 'continue_train' detectado. Treino retomará da época {initial_epochs_completed} e visa um total de {num_epochs_for_trainer} épocas.")
+            
+        else: # Default para new_train
+            log_warning(f"Modo de treino desconhecido: {train_mode}. Assumindo 'new_train'.")
+            num_epochs_for_trainer = float(epochs)
+            
+#-----------------------
+        model.train()
+        total_target_epochs = initial_epochs_completed + epochs
+        
+      # ----------- Preparar/tokenizar dataset ----------- 
+        tokenized_path = os.path.join(output_dir, "tokenized_dataset")
+        
+        # --- CHAMADA PARA AJUSTAR MAX_LEN DINAMICAMENTE --- desativado ver função em baixo ativa
+        # Chamar a função de ajuste de MAX_LEN aqui, antes de tokenizar
+        # Passar o limite do tokenizer para a função
+        
+        # vereficar nomes das funçoes - podem estar erradas
+        # --- Após carregar modelo e tokenizer -----------------------------
+        # Sanear limites de contexto do modelo e do tokenizer
+
+        # 1) Modelo
+        max_len_model = getattr(model.config, "max_position_embeddings", None)
+        if not (isinstance(max_len_model, int) and max_len_model > 0):
+            max_len_model = DEFAULT_FALLBACK_CAP
+
+        # 2) Tokenizer
+        tok_max_len_raw = getattr(tokenizer, "model_max_length", None)
+        if (tok_max_len_raw is None 
+            or not isinstance(tok_max_len_raw, int) 
+            or tok_max_len_raw <= 0 
+            or tok_max_len_raw > TOKENIZER_SENTINEL_CAP):
+            tok_max_len_raw = DEFAULT_FALLBACK_CAP
+
+        # 3) Limite efetivo
+        effective_model_max_len = min(max_len_model, tok_max_len_raw)
+
+        # 4) Ajuste dinâmico com o teu orçamento de RAM
+        DYNAMIC_MAX_LEN = ajustar_max_len(
+            tokenizer_model_max_length=effective_model_max_len,
+            target_utilization=TARGET_MAX_LEN_UTILIZATION,
+            base_max_len=BASE_MAX_LEN,
+            increment=MAX_LEN_INCREMENT,
+            max_cap=MAX_LEN_CAP,
+            estimated_base_dataset_ram_gb=ESTIMATED_BASE_DATASET_RAM_GB,
+            cost_per_increment_gb=COST_PER_INCREMENT_GB
+        )
+        logging.info(f"MAX_LEN dinâmico definido para: {DYNAMIC_MAX_LEN}")
+
+# ------------------------------------------------------------------        
+        
+        if os.path.exists(tokenized_path):
+            log_info("Dataset tokenizado encontrado no disco. A carregar...")
+            tokenized_datasets = load_from_disk(tokenized_path)
+            # Verificar se o MAX_LEN do dataset carregado é compatível com o DYNAMIC_MAX_LEN
+            
+            pass # Carrega o dataset existente
+        else:
+            training_data = []
+            for item in file_data:
+                text = None
+                if "prompt" in item and "completion" in item:
+                    prompt = item.get("prompt", "")
+                    completion = item.get("completion", "")
+                    if isinstance(prompt, str) and isinstance(completion, str) and prompt and completion:
+                        text = f"<s>[INST] {prompt.strip()} [/INST] {completion.strip()}</s>"
+                elif "text" in item and isinstance(item["text"], str) and item["text"].strip():
+                    text = f"<s>{item['text'].strip()}</s>"
+                if text:
+                    training_data.append({"text": text})
+                    
+            if not training_data:
+                log_error("Nenhum dado válido encontrado para treino após formatação.")
+                train_progress.update({"status": "error", "message": "Nenhum dado válido para treino."})
+                return
+
+            dataset = Dataset.from_list(training_data)
+            
+            # --- USAR O DYNAMIC_MAX_LEN AQUI ---
+            def tokenize_function(examples):
+                return tokenizer(examples["text"], truncation=True, max_length=DYNAMIC_MAX_LEN, padding=False)
+
+            tokenized_datasets = dataset.map(
+                tokenize_function,
+                batched=True,
+                num_proc=DATALOADER_WORKERS,
+                remove_columns=dataset.column_names,
+            )
+            tokenized_datasets.save_to_disk(tokenized_path)
+            log_success(f"Dataset tokenizado salvo em {tokenized_path} com MAX_LEN={DYNAMIC_MAX_LEN}")
+
+        split_dataset = tokenized_datasets.train_test_split(test_size=0.1, seed=42)
+        train_dataset = split_dataset["train"]
+        eval_dataset = split_dataset["test"]
+
+        data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)
+        
+        # ----------- TrainingArguments -----------
+        training_args = TrainingArguments(
+            output_dir=output_dir,
+            num_train_epochs=num_epochs_for_trainer,
+            #num_train_epochs=epochs,
+            per_device_train_batch_size=BASE_BATCH_SIZE,
+            per_device_eval_batch_size=BASE_EVAL_SIZE,            
+            gradient_accumulation_steps=ACCUMULATION_STEPS, 
+            learning_rate=BASE_LEARNING_RATE, 
+            warmup_ratio=WARMUP_RATIO,
+            lr_scheduler_type=LR_SCHEDULER_TYPE,   #"constant_with_warmup",
+            weight_decay=WEIGHT_DECAY,
+            logging_steps=LOGGIN_STEPS,
+            save_strategy=SAVE_STRATEGY,
+            save_steps=SAVE_STEPS,
+            eval_steps=EVAL_STEPS,
+            optim=OPTIM,    #adamw_hf, "adamw_torch", "cosine"
+            dataloader_num_workers=DATALOADER_WORKERS,
+            bf16=False,
+            #gradient_checkpointing=True,
+            max_grad_norm=1.0,
+            report_to="none",
+            save_total_limit=3,
+            seed=42,
+        )
+#------------------------------------------------------------  
+        # Como inicializar o callback com os valores corretos
+        _requested_dynacc_args = {
+            "base_batch": BASE_BATCH_SIZE,
+            "max_steps": DYNAMIC_ACCUMULATION_MAX_STEPS,
+            "target_util": DYNAMIC_ACCUMULATION_TARGET_UTIL,
+        }
+        try:
+            sig = inspect.signature(DynamicAccumulationCallback.__init__)
+            supported_params = [p for p in sig.parameters.keys() if p != "self"]
+            dynacc_kwargs = {k: v for k, v in _requested_dynacc_args.items() if k in supported_params}
+        except Exception:
+            dynacc_kwargs = {
+                "base_batch": BASE_BATCH_SIZE,
+                "max_steps": DYNAMIC_ACCUMULATION_MAX_STEPS,
+            }
+
+#-----------------------------
+        trainer = Trainer(
+            model=model,
+            args=training_args,
+            # processing_class=tokenizer, # Removido conforme sugestão
+            train_dataset=train_dataset,
+            eval_dataset=eval_dataset,
+            data_collator=data_collator,
+            #peft_config=lora_config,
+            callbacks=[LogCallback(), DynamicAccumulationCallback, SimpleStepTimerCallback, 
+            OptimizerRefreshCallback(refresh_interval_sec=OPTIMIZER_REFRESH_INTERVAL)]
+        )
+# === Iniciar a thread de monitorização ANTES do treino ===
+        _hotkey_thread = threading.Thread(
+            target=_iniciar_monitor_hotkeys,
+            args=(model, tokenizer, trainer, output_dir, True),
+            daemon=True
+        )
+        _hotkey_thread.start()
+        
+        # --- ADD: registar accumulation atual (se já calculado antes do treino)
+        if CURRENT_ACCUM_STEPS is not None:
+            origem = LAST_ACCUM_ORIGIN or "desconhecido"
+            training_logs.append(f"[INFO] gradient_accumulation_steps atual (pré-train): {CURRENT_ACCUM_STEPS} ({origem})")
+            try:
+                # se tiveres a base aqui; caso contrário usa BASE_BATCH_SIZE
+                base_bsz = BASE_BATCH_SIZE_EFFECTIVE if 'BASE_BATCH_SIZE_EFFECTIVE' in globals() and BASE_BATCH_SIZE_EFFECTIVE else BASE_BATCH_SIZE
+                eb = base_bsz * CURRENT_ACCUM_STEPS
+                training_logs.append(f"[INFO] Effective Batch inicial (base={base_bsz}) = {eb}")
+            except Exception:
+                pass
+        # --- END ADD
+
+        try:
+            log_success("Configuração do Trainer concluída. A iniciar o treino...")
+            train_progress.update({"status": "training", "message": "Iniciando o treinamento do modelo..."})
+            trainer_output = trainer.train(resume_from_checkpoint=resume_from_trainer_checkpoint)
+
+            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!")
+
+            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.")
+
+            # --- ADD: resumo final com steps e accumulation/EB
+            try:
+                # tentar ler steps efetivos do Trainer ao final
+                steps_final = None
+                if hasattr(trainer, "state") and getattr(trainer.state, "global_step", None) is not None:
+                    steps_final = trainer.state.global_step
+                elif hasattr(trainer, "state") and getattr(trainer.state, "max_steps", None):
+                    steps_final = trainer.state.max_steps
+                if steps_final is not None and isinstance(steps_final, int) and steps_final > 0:
+                    TOTAL_TRAIN_STEPS = steps_final  # ajusta se necessário
+                origem = LAST_ACCUM_ORIGIN or "desconhecido"
+                base_bsz = BASE_BATCH_SIZE_EFFECTIVE if 'BASE_BATCH_SIZE_EFFECTIVE' in globals() and BASE_BATCH_SIZE_EFFECTIVE else BASE_BATCH_SIZE
+                eb = (base_bsz * CURRENT_ACCUM_STEPS) if CURRENT_ACCUM_STEPS else None
+
+                training_logs.append("[SUCESSO] Treino concluído (resumo):")
+                training_logs.append(f" - total_train_steps = {TOTAL_TRAIN_STEPS}")
+                if CURRENT_ACCUM_STEPS is not None:
+                    training_logs.append(f" - gradient_accumulation_steps final = {CURRENT_ACCUM_STEPS} ({origem})")
+                if eb is not None:
+                    training_logs.append(f" - Effective Batch final (base={base_bsz}) = {eb}")
+            except Exception as _e:
+                training_logs.append(f"[AVISO] não foi possível gerar resumo final detalhado ({_e})")
+            # --- END ADD
+
+            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:        
+            msg = str(e)
+            training_logs.append(f"Erro durante treino: {msg}")
+            train_progress["status"] = "error"
+            log_error(f"Erro de Runtime durante o treino: {e}")
+            traceback.print_exc()
+
+    except Exception as e:
+        log_error(f"Erro crítico durante o treino: {e}")
+        train_progress.update({"status": "error", "message": f"Erro crítico no treino: {e}"})
+        traceback.print_exc()
+        return
+
+#----------------------------------------------------
+TENSORBOARD_LOGDIR = r"C:\Users\ilina\startup\Treinamento\feramenta-treino\trained_model_output\logs"
+TENSORBOARD_PORT = 6006
+
+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}"
+    ], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+#-----------------------------------------------------------
+#----------------------
+# Rotas FLASK
+#----------------------
+@app.route('/')
+def home():
+    """ Rota principal que serve o ficheiro index.html. """
+    return render_template('index-6.html')
+#---------------------------------------
+def guess_lora_targets(model):
+    """
+    Função auxiliar para identificar automaticamente os módulos alvo para LoRA.
+    Analisa camadas lineares no modelo e retorna uma lista de nomes de camadas candidatas.
+    """
+    targets = []
+    for name, module in model.named_modules():
+        if isinstance(module, torch.nn.Linear) and module.weight.requires_grad:
+            targets.append(name)
+    if not targets:
+        targets = ["q_proj", "v_proj"]  # fallback padrão usado por PEFT
+    return targets
+    
+# ROTA DE TREINAMENTO
+#-------------------------------------
+@app.route('/api/train', methods=['POST'])
+def handle_train_request():
+    global all_data
+    try:
+        model_path = request.form.get('model_path')
+        epochs = int(request.form.get('epochs'))
+        uploaded_files = request.files.getlist('files')
+        
+        logging.info(f"🚀 Novo treino iniciado")
+        logging.info(f"Modelo: {model_path}")
+        logging.info(f"Épocas: {epochs}")
+
+        if not all([model_path, epochs, uploaded_files]):
+            return jsonify({"status": "error", "message": "Faltam parâmetros: modelo, épocas ou ficheiros."}), 400
+
+        # Limpa os dados de treinos anteriores
+        all_data = []
+        for file in uploaded_files:
+            try:
+                raw_content = file.read()
+                encoding = chardet.detect(raw_content)['encoding'] or 'utf-8'
+                content = raw_content.decode(encoding)
+                for line in content.splitlines():
+                    if not line.strip(): continue
+                    if file.filename.endswith('.jsonl'):
+                        all_data.append(json.loads(line))
+                    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
+
+        if not all_data:
+            return jsonify({"status": "error", "message": "Nenhum dado válido encontrado nos ficheiros."}), 400
+
+        output_dir = os.path.join(os.getcwd(), "trained_model_output")
+        os.makedirs(output_dir, exist_ok=True)
+
+        training_logs.append(f"[DEBUG] CWD: {os.getcwd()}")
+        training_logs.append(f"[DEBUG] OUTPUT_DIR: {output_dir}")
+        training_logs.append(f"[DEBUG] FILES: {os.listdir(os.getcwd())}")
+
+        # 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."})
+
+    except Exception as e:
+        return jsonify({"status": "error", "message": f"Erro no servidor: {e}"}), 500
+#-------------------------------------------
+@app.route("/api/train_status")
+def train_status():
+    progress = train_progress.get("percent", 0)
+    status = train_progress.get("status", "")
+    epoch_list = epoch_losses
+    logs_tail = training_logs[-200:] if len(training_logs) > 200 else training_logs[:]
+
+    # 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}")
+
+    if TOTAL_TRAIN_STEPS is not None:
+        logs_tail.append(f"[INFO] total_train_steps desta execução: {TOTAL_TRAIN_STEPS}")
+
+    return jsonify({
+        "progress": progress,
+        "status": status,
+        "epoch_losses": epoch_list,
+        "logs": logs_tail
+    })
+
+#---------------------------------------
+@app.route('/api/load_lora_chat', methods=['POST'])    
+def load_lora_chat():
+    try:
+        data = request.get_json()
+        model_path = data.get("model_path")
+        if not model_path or "C:/" in model_path:
+             return jsonify({"status": "error", "message": "Caminho do modelo inválido para Linux (HF Spaces). Use o ID do Hugging Face."}), 400
+
+        output_dir = os.path.join(os.getcwd(), "trained_model_output")
+        lora_model_path = os.path.join(output_dir, "lora_model")
+
+        if not os.path.exists(lora_model_path):
+             return jsonify({"status": "error", "message": f"LoRA não encontrado em: {lora_model_path}"}), 404
+
+        # Determinar dtype e device_map
+        if torch.cuda.is_available():
+            model_dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
+            model_device_map = "auto"
+        else:
+            model_dtype = torch.bfloat16
+            model_device_map = "cpu"
+
+        # Carregar o tokenizer do LoRA primeiro para obter o tamanho de vocabulário correto
+        tokenizer = AutoTokenizer.from_pretrained(lora_model_path, use_fast=True)
+
+        base_model = AutoModelForCausalLM.from_pretrained(
+            model_path,
+            dtype=model_dtype,
+            device_map=model_device_map,
+            low_cpu_mem_usage=True
+        )
+
+        # CORREÇÃO: Redimensionar o modelo base para o tamanho do vocabulário do tokenizer do LoRA
+        base_model.resize_token_embeddings(len(tokenizer))
+        
+        lora_model = PeftModel.from_pretrained(base_model, lora_model_path, device_map=model_device_map)
+        
+        chat_model = lora_model
+        chat_tokenizer = tokenizer
+        
+        log_success("Modelo LoRA carregado com sucesso para chat (sem merge).")
+        train_progress.update({"status": "awaiting_merge", "message": "Modelo LoRA carregado para chat. Decida a próxima ação."})
+
+        return jsonify({"status": "ok", "message": "Modelo LoRA carregado para chat (sem merge)."})
+    except Exception as e:
+        log_error(f"Erro ao carregar LoRA para chat: {e}")
+        train_progress.update({"status": "error", "message": f"Erro ao carregar LoRA para chat: {e}"}) 
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+#--------------------------------------------
+@app.route('/api/decide_merge', methods=['POST'])
+def decide_merge():
+    global chat_model, chat_tokenizer, train_progress
+    try:
+        decision = request.form.get('decision')
+        model_path = request.form.get('model_path')
+        output_dir = os.path.join(os.getcwd(), "trained_model_output")
+        lora_model_path = os.path.join(output_dir, "lora_model")
+
+        if torch.cuda.is_available():
+            model_dtype = torch.bfloat16 if torch.cuda.is_bf16_supported() else torch.float16
+            model_device_map = "auto"
+        else:
+            model_dtype = torch.bfloat16
+            model_device_map = "cpu"
+
+        if decision == "merge":
+            log_info("Iniciando o merge do adapter LoRA com o modelo base...")
+            train_progress.update({"status": "merging", "message": "Iniciando a fusão do adapter LoRA..."})
+
+            # Carregar o tokenizer do LoRA primeiro para obter o tamanho de vocabulário correto
+            tokenizer = AutoTokenizer.from_pretrained(lora_model_path, use_fast=True)
+
+            base_model = AutoModelForCausalLM.from_pretrained(
+                model_path,
+                dtype=model_dtype,
+                device_map=model_device_map,
+                low_cpu_mem_usage=True
+            )
+            # CORREÇÃO: Redimensionar o modelo base para o tamanho do vocabulário do tokenizer do LoRA
+            base_model.resize_token_embeddings(len(tokenizer))
+
+            lora_model = PeftModel.from_pretrained(base_model, lora_model_path)
+            merged_model = lora_model.merge_and_unload()
+
+            final_model_path = os.path.join(output_dir, "merged_model")
+            os.makedirs(final_model_path, exist_ok=True)
+            merged_model.save_pretrained(final_model_path, safe_serialization=True)
+
+            # O tokenizer já foi carregado acima
+            tokenizer.save_pretrained(final_model_path)
+
+            chat_model = merged_model
+            chat_tokenizer = tokenizer
+
+            log_success("Modelo fundido com sucesso e pronto para o chat!")
+            train_progress.update({"status": "finished", "percent": 100, "message": "Modelo LoRA fundido e salvo."})
+            return jsonify({"status": "merged", "message": "Modelo fundido com sucesso."})
+
+#-----------------------------------------------------------------------------------------
+        elif decision == "continue":
+            log_info("A continuar o treino por mais épocas a partir do adapter salvo...")
+            epochs_to_add = int(request.form.get('epochs', 1)) # Renomeado para clareza
+
+            if not os.path.exists(lora_model_path):
+                log_error("Nenhum adapter LoRA encontrado para retomar o treino.")
+                train_progress.update({"status": "continuing_training", "message": f"Continuando treino por mais {epochs_to_add} épocas..."})
+                return jsonify({"status": "error", "message": "Nenhum adapter LoRA encontrado para retomar o treino."}), 400
+
+            # --- Determinar épocas já completadas ---
+            initial_epochs_completed = 0
+            output_dir = os.path.join(os.getcwd(), "trained_model_output") # Certifique-se que output_dir está definido
+            checkpoint_dirs = [d for d in os.listdir(output_dir) if d.startswith("checkpoint-")]
+            if checkpoint_dirs:
+                checkpoint_dirs.sort(key=lambda x: int(x.split('-')[1]), reverse=True)
+                latest_candidate_checkpoint_dir = os.path.join(output_dir, checkpoint_dirs[0])
+                trainer_state_path = os.path.join(latest_candidate_checkpoint_dir, "trainer_state.json")
+                if os.path.exists(trainer_state_path):
+                    try:
+                        with open(trainer_state_path, 'r') as f:
+                            trainer_state = json.load(f)
+                            initial_epochs_completed = int(trainer_state.get('epoch', 0))
+                            log_info(f"Detectado que {initial_epochs_completed} épocas foram completadas no último checkpoint.")
+                    except Exception as e:
+                        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..."})
+            
+            thread = Thread(
+                target=train_model_lora,
+                args=(
+                    all_data,
+                    epochs_to_add,
+                    model_path,
+                    output_dir,
+                    ACCUMULATION_STEPS,
+                    DATALOADER_WORKERS,
+                    "continue_train",
+                    lora_model_path,
+                    initial_epochs_completed,
+                    "continue_train"
+                )
+            )
+            thread.start()
+
+            return jsonify({
+                "status": "continued",
+                "message": f"Treino adicional de {epochs_to_add} épocas iniciado."
+            })
+
+        else:
+            log_warning(f"Decisão inválida para /decide_merge: {decision}")
+            train_progress.update({"status": "error", "message": f"Decisão inválida: {decision}"})
+            return jsonify({"status": "error", "message": "Decisão inválida."}), 400
+
+    except Exception as e:
+        log_error(f"Erro durante o merge/continuação: {e}")
+        train_progress.update({"status": "error", "message": f"Erro durante o merge/continuação: {e}"})
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+#--------------------------------------------
+@app.route('/api/chat', methods=['POST'])
+def handle_chat():
+    global chat_model, chat_tokenizer
+    if not chat_model or not chat_tokenizer:
+        return jsonify({
+            "response": "ERRO: O modelo ainda não está carregado. Faça o 'merge' ou 'load_lora_chat' primeiro."
+        }), 400
+    try:
+        data = request.get_json()
+        prompt = data.get('prompt')
+        if not prompt:
+            return jsonify({"response": "Erro: 'prompt' não foi enviado."}), 400
+
+        formatted_prompt = f"<s>[INST] {prompt} [/INST]"
+        inputs = chat_tokenizer(formatted_prompt, return_tensors="pt").to(chat_model.device)
+
+        outputs = chat_model.generate(
+            **inputs,
+            max_new_tokens=256,
+            num_return_sequences=1,
+            eos_token_id=chat_tokenizer.eos_token_id,
+            pad_token_id=chat_tokenizer.eos_token_id,
+            do_sample=True,
+            temperature=0.01, # <--- Sugestão: Reduzir temperatura para respostas mais determinísticas
+            top_p=0.9,
+        )
+        response_full = chat_tokenizer.decode(outputs[0], skip_special_tokens=True)
+        response_only = response_full.split("[/INST]")[-1].strip()
+
+        return jsonify({"response": response_only})
+    except Exception as e:
+        return jsonify({"response": f"Erro interno no chat: {str(e)}"}), 500
+
+#----------------------------------------------------
+@app.post("/api/tensorboard/start")
+def start_tensorboard():
+    threading.Thread(target=run_tensorboard, daemon=True).start()
+    return jsonify({"status": "ok", "url": f"http://localhost:{TENSORBOARD_PORT}"}), 200
+    
+# =========================================================================
+# ROTAS DE DIRETORIO DO OUTPUT
+# =========================================================================
+@app.route('/api/model_dir', methods=['GET'])
+def list_model_dir():
+    try:
+        # Tenta vários caminhos possíveis no Hugging Face
+        paths_to_check = [
+            os.path.join(os.getcwd(), "trained_model_output"),
+            "/app/trained_model_output",
+            "./trained_model_output"
+        ]
+        
+        target = paths_to_check[0]
+        for p in paths_to_check:
+            if os.path.exists(p):
+                target = p
+                break
+        
+        # Se não existir, cria agora para o botão não falhar
+        if not os.path.exists(target):
+            os.makedirs(target, exist_ok=True)
+            return jsonify({"files": ["Pasta criada agora. Está vazia."]}), 200
+        
+        files_list = []
+        for root, dirs, filenames in os.walk(target):
+            for f in filenames:
+                rel_path = os.path.relpath(os.path.join(root, f), target)
+                files_list.append(rel_path)
+        
+        if not files_list:
+            return jsonify({"files": ["Pasta encontrada, mas não tem ficheiros lá dentro."]}), 200
+            
+        return jsonify({"files": sorted(files_list)}), 200
+
+    except Exception as e:
+        return jsonify({"files": [f"Erro ao ler pasta: {str(e)}"]}), 200 # Retornamos 200 para o JS não dar erro
+#-------------------------------------------------------------------------
+
+
+@app.route('/api/download/<path:filename>')
+def download_file(filename):
+    # Caminho absoluto para a pasta de output
+    directory = os.path.join(os.getcwd(), "trained_model_output")
+    
+    # send_from_directory é seguro e evita que utilizadores acedam a pastas do sistema
+    try:
+        return send_from_directory(directory, filename, as_attachment=True)
+    except Exception as e:
+        return str(e), 404
+  
+# =========================================================================
+# ROTAS DE CONFIGURAÇÃO (GET para Ler, POST para Guardar)
+# =========================================================================
+
+# Rota GET: Lê os valores mais recentes do código Python (Recarregar Config. do Servidor)
+@app.route('/api/config', methods=['GET'])
+def get_config():
+    # 1. Lê as constantes do ficheiro .py
+    constants = _load_constants_from_file()
+    
+    # 2. Mapeia para o formato JSON do Frontend
+    config_data = map_backend_to_frontend(constants)
+    
+    # 3. Envia os dados
+    return jsonify(config_data)
+
+# Rota POST: Recebe os novos valores da UI e atualiza o código Python (Guardar Configuração)
+
+@app.route('/api/config', methods=['POST'])
+def save_config():
+    try:
+        # Recebe os dados JSON do Front-end
+        new_data = request.json
+        
+        # 1. Lógica de proteção / confirmação (Implementada no Front-end via prompt/confirmação)
+        # O Front-end deve tratar a confirmação antes de enviar o POST.
+        # Aqui, apenas processamos a escrita.
+        
+        if not new_data:
+             return jsonify({"error": "Dados inválidos."}), 400
+
+        # 2. Atualiza as constantes no ficheiro Python
+        success = update_python_constants(new_data)
+        
+        if success:
+            # O ideal é recarregar a config para garantir que o que foi salvo é retornado
+            constants = _load_constants_from_file()
+            config_data = map_backend_to_frontend(constants)
+            
+            return jsonify(config_data), 200 # Retorna a config atualizada
+        else:
+            return jsonify({"error": "Falha ao escrever no ficheiro de configuração."}), 500
+
+    except Exception as e:
+        print(f"Erro ao guardar config: {e}")
+        return jsonify({"error": str(e)}), 500
+
+#------------------------------------
+@app.post("/api/adjust_accumulation")
+def adjust_accumulation():
+    """
+    Ajuste manual relativo do gradient_accumulation_steps.
+    Usa o valor atual real do treino se CURRENT_ACCUM_STEPS não estiver definido.
+    Envia { "action": "auto" } para voltar ao modo automático.
+    """
+    global CURRENT_ACCUM_STEPS
+
+    data = request.get_json(force=True)
+    delta = int(data.get("delta", 0))
+    action = data.get("action")
+
+    # Modo automático
+    if action == "auto":
+        CURRENT_ACCUM_STEPS = None
+        logging.info("🔄 Modo automático de accumulation reativado.")
+        return jsonify({"status": "ok", "mode": "auto", "message": "Modo automático reativado."})
+
+    # Se CURRENT_ACCUM_STEPS ainda não definido, usa valor atual do treino
+    if CURRENT_ACCUM_STEPS is None:
+        CURRENT_ACCUM_STEPS = train_progress.get("current_accum_steps", 16)  # valor padrão caso não exista
+
+    # Aplica delta e limita
+    CURRENT_ACCUM_STEPS = max(1, min(DYNAMIC_ACCUMULATION_MAX_STEPS, CURRENT_ACCUM_STEPS + delta))
+
+    logging.info(f"🎚 Ajuste manual recebido → CURRENT_ACCUM_STEPS = {CURRENT_ACCUM_STEPS} (delta={delta})")
+
+    return jsonify({
+        "status": "ok",
+        "current_steps": CURRENT_ACCUM_STEPS,
+        "mode": "manual"
+    })
+
+#----------------------------------------------------
+model = None  # variável global
+
+@app.route('/api/create_model', methods=['POST'])
+def create_model():
+    global model
+    data = request.json
+    model_name = data.get("model_name")
+    if not model_name:
+        return jsonify({"status": "error", "message": "model_name não fornecido."}), 400
+    # 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)

config_manager.py

@@ -0,0 +1,193 @@
+# config_manager.py
+
+import json
+import os
+import re
+
+# Caminho para o ficheiro principal de onde vamos ler as CONSTANTES
+# Altere para o caminho correto do seu arquivo com as constantes (ex: train-6-ok.py)
+CONFIG_FILE_PATH = 'train-6-ok.py' 
+
+def _load_constants_from_file():
+    """Lê todas as CONSTANTES (ALL_CAPS) do ficheiro Python e retorna um dicionário."""
+    constants = {}
+    
+    # Lista de constantes que têm de ser tratadas como booleanos
+    BOOL_CONSTANTS = ["ALLOW_SLEEP_ON_CHANGE"]
+
+    try:
+        with open(CONFIG_FILE_PATH, 'r', encoding='utf-8') as f:
+            content = f.read()
+    except FileNotFoundError:
+        print(f"ERRO: Ficheiro de configuração não encontrado em {CONFIG_FILE_PATH}")
+        return constants
+
+    # Expressão regular para encontrar constantes (NOME_CONSTANTE = valor)
+    # Ignora linhas comentadas
+    matches = re.findall(r'^\s*([A-Z_]+)\s*=\s*(.*)', content, re.MULTILINE)
+    
+    for name, value_str in matches:
+        # Tenta converter para o tipo correto (Int, Float, Bool)
+        try:
+            if name in BOOL_CONSTANTS:
+                constants[name] = value_str.strip().lower() == "true"
+                
+            elif re.match(r'^"?-?\d+"?$', value_str.strip()):
+                constants[name] = int(value_str.strip().replace('"','').replace("'", ""))
+            elif re.match(r'^"?-?\d+\.\d+"?$', value_str.strip()):
+                constants[name] = float(value_str.strip().replace('"','').replace("'", ""))
+
+            # Adicione mais lógica de conversão se necessário (ex: strings)
+            else:
+                constants[name] = value_str.strip().replace("'", "").replace('"', '') # Simplificação para strings/outros
+        except Exception:
+            # Em caso de erro, armazena como string original
+            constants[name] = value_str.strip().replace("'", "").replace('"', '')
+
+    return constants
+#-------------------      
+def map_backend_to_frontend(constants):
+    """Mapeia as constantes do Backend para a estrutura JSON do Frontend de forma segura."""
+
+    def safe_int(value, default=0):
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            return default
+
+    def safe_float(value, default=0.0):
+        try:
+            return float(value)
+        except (ValueError, TypeError):
+            return default
+
+    return {
+        "preset": "custom",
+        "ramcfg": {
+            "base_batch": safe_int(constants.get('BASE_BATCH_SIZE', 4)),
+            "max_steps": safe_int(constants.get('DYNAMIC_ACCUMULATION_MAX_STEPS', 64)),
+            "target_utilization": safe_float(constants.get('TARGET_RAM_UTILIZATION', 0.9)),
+            "estimated_batch_gb": safe_float(constants.get('ESTIMATED_BATCH_GB', 0.40)),
+            "min_headroom_gb": 1.0,
+            "hysteresis": safe_int(constants.get('DYNAMIC_ACCUMULATION_HIGH_RAM_LIMIT', 85)) / 100.0,
+            "ema_alpha": safe_float(constants.get('DYNAMIC_ACCUMULATION_TARGET_UTIL', 0.95)),
+            "patience": 4,
+            "cooldown_s": 20.0,
+            "min_decision_interval_s": 2.0,
+            "emergency_threshold_pct": safe_int(constants.get('DYNAMIC_ACCUMULATION_LOW_RAM_LIMIT', 71)),
+            "warmup_steps": 100,
+            "allow_sleep_on_change": False,
+            "sleep_s": 0.5,
+            "total_ram_gb": safe_float(constants.get('TOTAL_RAM_GB', None))
+        },
+        "mlcfg": {
+            "base_max_len": safe_int(constants.get('BASE_MAX_LEN', 256)),
+            "target_utilization": safe_float(constants.get('TARGET_MAX_LEN_UTILIZATION', 0.65)),
+            "increment": safe_int(constants.get('MAX_LEN_INCREMENT', 128)),
+            "cap": safe_int(constants.get('MAX_LEN_CAP', 512)),
+            "estimated_base_dataset_ram_gb": safe_float(constants.get('ESTIMATED_BASE_DATASET_RAM_GB', 2)),
+            "cost_per_increment_gb": safe_float(constants.get('COST_PER_INCREMENT_GB', 0.45)),
+            "total_ram_gb": safe_float(constants.get('TOTAL_RAM_GB', None))
+        },
+        "training": {
+            "base_lr": safe_float(constants.get('BASE_LEARNING_RATE', 2e-5)),
+            "base_eval_size": safe_int(constants.get('BASE_EVAL_SIZE', 32)),
+            "optimizer": constants.get('OPTIM', "adamw_torch"),
+            "scheduler": constants.get('IR_SCHEDULER_TYPE', "constant_with_warmup"),
+            "log_steps": safe_int(constants.get('LOGGIN_STEPS', 25)),
+            "save_strategy": constants.get('SAVE_STRATEGY', "steps"),
+            "save_steps": safe_int(constants.get('SAVE_STEPS', 50)),
+            "eval_steps": safe_int(constants.get('EVAL_STEPS', 50))
+        }
+    }
+
+def update_python_constants(new_data):
+    """Atualiza as constantes no ficheiro Python original com os novos valores."""
+    
+    # 1. Mapear de volta a estrutura aninhada para CONSTANTES
+    # Use o nome da constante no código, não o nome do campo na UI   
+    # Mapeamento do JSON (UI keys) para Python (CONST_NAMES)
+    mapping = {
+        # ramcfg
+        "base_batch": "BASE_BATCH_SIZE",
+        "max_steps": "DYNAMIC_ACCUMULATION_MAX_STEPS",
+        "target_utilization": "TARGET_RAM_UTILIZATION",
+        "estimated_batch_gb": "ESTIMATED_BATCH_GB",
+        "hysteresis": "DYNAMIC_ACCUMULATION_HIGH_RAM_LIMIT",
+        "ema_alpha": "DYNAMIC_ACCUMULATION_TARGET_UTIL",
+        "emergency_threshold_pct": "DYNAMIC_ACCUMULATION_LOW_RAM_LIMIT",
+        # mlcfg
+        "base_max_len": "BASE_MAX_LEN",
+        "target_utilization_ml": "TARGET_MAX_LEN_UTILIZATION",
+        "increment": "MAX_LEN_INCREMENT",
+        "cap": "MAX_LEN_CAP",
+        "estimated_base_dataset_ram_gb": "ESTIMATED_BASE_DATASET_RAM_GB",
+        "cost_per_increment_gb": "COST_PER_INCREMENT_GB",
+        # training
+        "base_lr": "BASE_LEARNING_RATE",
+        "base_eval_size": "BASE_EVAL_SIZE",
+        "optimizer": "OPTIM",
+        "scheduler": "IR_SCHEDULER_TYPE",
+        "log_steps": "LOGGIN_STEPS",
+        "save_strategy": "SAVE_STRATEGY",
+        "save_steps": "SAVE_STEPS",
+        "eval_steps": "EVAL_STEPS"
+    }
+  
+    updates = {}
+    for ui_key, const_name in mapping.items():
+        if ui_key in new_data.get('ramcfg', {}):
+            val = new_data['ramcfg'][ui_key]
+            # Converte 'hysteresis' de volta para porcentagem
+            if ui_key == "hysteresis":
+                updates[const_name] = int(val * 100)
+            # Outras conversões...
+            else:
+                updates[const_name] = val
+        elif ui_key in new_data.get('mlcfg', {}):
+            updates[const_name] = new_data['mlcfg'][ui_key]
+
+
+    # 2. Ler o conteúdo atual do ficheiro
+    try:
+        with open(CONFIG_FILE_PATH, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+    except FileNotFoundError:
+        return False
+
+    # 3. Reescrever o ficheiro com os novos valores
+    new_lines = []
+    updated_names = set()
+
+    for line in lines:
+        match = re.match(r'^\s*([A-Z_]+)\s*=\s*(.*)', line)
+        if match:
+            name = match.group(1)
+            # Se for uma das constantes que queremos atualizar, substitui a linha
+            if name in updates:
+                new_value = updates[name]
+                # Formata o valor de volta para string no formato Python
+                if isinstance(new_value, str):
+                    formatted_value = f'"{new_value}"'
+                elif isinstance(new_value, bool):
+                    formatted_value = str(new_value).capitalize()
+                else:
+                    formatted_value = str(new_value)
+                    
+                new_lines.append(f"{name} = {formatted_value}\n")
+                updated_names.add(name)
+                continue # Pula a linha original
+        
+        # Mantém a linha inalterada (código, comentários, imports, etc.)
+        new_lines.append(line)
+
+    # 4. Escrever de volta
+    try:
+        with open(CONFIG_FILE_PATH, 'w', encoding='utf-8') as f:
+            f.writelines(new_lines)
+        return True
+    except Exception as e:
+        print(f"ERRO ao escrever no ficheiro: {e}")
+        return False
+        
+# Fim de config_manager.py

templates/index-6.html

@@ -0,0 +1,553 @@
+<!DOCTYPE html>
+<html lang="pt-PT">
+<head>
+  <meta charset="utf-8" />
+  <title>Treino de IA Local e Chat</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <script src="https://cdn.tailwindcss.com"></script>
+  <style>
+    :root{
+      --bg:#0f1218; --fg:#e8eef6; --muted:#9fb3ca; --panel:#161b22; --accent:#2ea043; --accent2:#1f6feb; --warn:#d29922; --err:#f85149;
+      --border:#30363d; --chip:#21262d;
+      --mono: ui-monospace, SFMono-Regular, Menlo, Consolas, "Liberation Mono", monospace;
+      --sans: Inter, Segoe UI, system-ui, -apple-system, Roboto, "Helvetica Neue", Arial, "Noto Sans", "Segoe UI Emoji", "Apple Color Emoji", sans-serif;
+    }
+    *{box-sizing:border-box}
+    html,body{height:100%}
+    body{margin:0;background:var(--bg);color:var(--fg);font-family:var(--sans);line-height:1.45}
+    header{padding:16px 20px;border-bottom:1px solid var(--border);background:linear-gradient(180deg, #111723, #0f1218);}
+    h1{margin:0;font-size:20px}
+    h2{margin:0 0 10px;font-size:18px}
+    h3{margin:16px 0 8px;font-size:15px;color:var(--muted)}
+    main{display:grid;grid-template-columns:0.65fr 1fr;gap:16px;padding:16px}
+    @media (max-width:1100px){main{grid-template-columns:1fr}}
+    .card{background:var(--panel);border:1px solid var(--border);border-radius:10px;overflow:hidden}
+    .card header{display:flex;align-items:center;justify-content:space-between;padding:12px 14px;border-bottom:1px solid var(--border);background:#121720}
+    .card .content{padding:14px}
+    .row{display:grid;grid-template-columns:repeat(12,1fr);gap:12px}
+    .col-12{grid-column:span 12}.col-8{grid-column:span 8}.col-6{grid-column:span 6}.col-4{grid-column:span 4}.col-3{grid-column:span 3}.col-2{grid-column:span 2}
+    label{display:block;font-size:12px;color:var(--muted);margin-bottom:6px}
+    input[type="text"],input[type="number"],select{width:100%;padding:10px 10px;border:1px solid var(--border);border-radius:8px;background:#0c1117;color:var(--fg);font-family:var(--mono)}
+    input[type="checkbox"]{transform:scale(1.1)}
+    .hint{font-size:11px;color:#7aa2d6;margin-top:4px}
+    .btn{display:inline-flex;align-items:center;gap:8px;padding:10px 12px;border:1px solid var(--border);border-radius:8px;background:var(--chip);color:var(--fg);cursor:pointer}
+    .btn:hover{filter:brightness(1.08)}
+    .btn-primary{background:var(--accent2);border-color:#2855a3}
+    .btn-success{background:var(--accent);border-color:#25834c}
+    .btn-warn{background:#3a2d12;border-color:#5c4620;color:#ffd479}
+    .btn-danger{background:#3b1416;border-color:#6a1c21;color:#ffb4b7}
+    .btn-ghost{background:transparent}
+    .toolbar{display:flex;flex-wrap:wrap;gap:8px}
+    .chips{display:flex;flex-wrap:wrap;gap:8px}
+    .chip{padding:6px 10px;border-radius:999px;background:var(--chip);border:1px solid var(--border);font-size:12px}
+    .grid2{display:grid;grid-template-columns:1fr 1fr;gap:12px}
+    .kbd{font-family:var(--mono);padding:1px 6px;border-radius:6px;background:#0c1117;border:1px solid var(--border)}
+    .log{font-family:var(--mono);white-space:pre-wrap;background:#0a0e14;border:1px solid var(--border);border-radius:8px;padding:10px;height:200px;overflow:auto}
+    .muted{color:var(--muted)}
+    .pill{padding:3px 8px;border-radius:999px;border:1px solid var(--border);background:#0a0e14;color:var(--muted);font-size:12px}
+    .ok{color:#7ee787}.warn{color:#ffd479}.err{color:#ff7b72}
+    .footer{padding:12px 16px;color:var(--muted);border-top:1px solid var(--border);font-size:12px}
+  </style>
+</head>
+<body>
+  <header>
+    <h1>Treino de IA Local e Chat</h1>
+  </header>
+
+  <main>
+    <section class="card">
+      <header>
+        <h2>Configuração Dinâmica</h2>
+        <div class="chips">
+          <span id="ramSummary" class="chip">RAM target: —</span>
+          <span id="mlSummary" class="chip">MAX_LEN: —</span>
+        </div>
+      </header>
+      <div class="content">
+        <div class="row">
+          <div class="col-12" style="display:flex;align-items:flex-end;gap:8px">
+            <button class="btn btn-success" id="saveCfgBtn">💾 Guardar Configuração</button>
+            <button class="btn btn-ghost" id="refreshBtn">↻ Recarregar Config. do Servidor</button>
+          </div>
+        </div>
+
+        <!-- NOVO: HARDWARE -->
+        <h3>1. Hardware (Automático)</h3>
+        <div class="row">
+            <div class="col-3">
+                <label for="cpu_count">CPU_COUNT</label>
+                <input type="number" id="cpu_count" disabled />
+            </div>
+            <div class="col-3">
+                <label for="omp_threads">OMP_THREADS</label>
+                <input type="number" id="omp_threads" disabled />
+                <div class="hint">Nº de threads usadas para tensores.</div>
+            </div>
+            <div class="col-3">
+                <label for="dataloader_workers">DATALOADER_WORKERS</label>
+                <input type="number" id="dataloader_workers" disabled />
+                <div class="hint">Nº de processos para carregar dados.</div>
+            </div>
+             <div class="col-3">
+                <label for="total_ram_gb">TOTAL_RAM_GB</label>
+                <input type="text" id="total_ram_gb" disabled />
+            </div>
+        </div>
+
+        <!-- NOVO: PARÂMETROS BASE DE TREINO -->
+        <h3>2. Parâmetros Base de Treino</h3>
+        <div class="row">
+          <div class="col-3">
+            <label for="base_batch">BASE_BATCH_SIZE (por dispositivo)</label>
+            <input type="number" id="base_batch" min="1" step="1" />
+          </div>
+          <div class="col-3">
+            <label for="base_eval_size">BASE_EVAL_SIZE</label>
+            <input type="number" id="base_eval_size" min="1" step="1" />
+          </div>
+          <div class="col-3">
+            <label for="base_learning_rate">BASE_LEARNING_RATE</label>
+            <input type="number" id="base_learning_rate" min="1e-6" max="1e-3" step="1e-6" />
+          </div>
+          <div class="col-3">
+            <label for="lr_scheduler_type">LR_SCHEDULER_TYPE</label>
+            <select id="lr_scheduler_type">
+              <option value="constant_with_warmup">constant_with_warmup</option>
+              <option value="cosine">cosine</option>
+              <option value="linear">linear</option>
+              <option value="constant">constant</option>
+            </select>
+          </div>
+        </div>
+        
+        <!-- SECÇÃO ATUALIZADA: RAM / Accumulation Steps -->
+        <h3>3. Ajuste Dinâmico (RAM / Gradient Accumulation)</h3>
+        <div class="row">
+          <div class="col-3">
+            <label for="max_steps">DYNAMIC_ACCUMULATION_MAX_STEPS</label>
+            <input type="number" id="max_steps" min="1" step="1" />
+            <div class="hint">Limite superior para acumulação de gradientes.</div>
+          </div>
+          <div class="col-3">
+            <label for="estimated_batch_gb">ESTIMATED_BATCH_GB</label>
+            <input type="number" id="estimated_batch_gb" min="0.01" step="0.01" />
+            <div class="hint">Custo de RAM por batch (ajuste fino necessário).</div>
+          </div>
+
+          <div class="col-3">
+            <label for="high_ram_limit_pct">HIGH_RAM_LIMIT (%)</label>
+            <input type="number" id="high_ram_limit_pct" min="70" max="95" step="1" />
+            <div class="hint">RAM % para **reduzir** `accumulation_steps`.</div>
+          </div>
+          <div class="col-3">
+            <label for="low_ram_limit_pct">LOW_RAM_LIMIT (%)</label>
+            <input type="number" id="low_ram_limit_pct" min="50" max="80" step="1" />
+            <div class="hint">RAM % para **aumentar** `accumulation_steps`.</div>
+          </div>
+        </div>
+
+        <!-- MAX_LEN Dinâmico -->
+        <h3>4. MAX_LEN Dinâmico</h3>
+        <div class="row">
+          <div class="col-3">
+            <label for="base_max_len">BASE_MAX_LEN</label>
+            <input type="number" id="base_max_len" min="32" step="32" />
+          </div>
+          <div class="col-3">
+            <label for="ml_target_utilization">TARGET_MAX_LEN_UTILIZATION</label>
+            <input type="number" id="ml_target_utilization" min="0.4" max="0.9" step="0.01" />
+            <div class="hint">Fração da RAM para dataset tokenizado.</div>
+          </div>
+          <div class="col-3">
+            <label for="increment">MAX_LEN_INCREMENT</label>
+            <input type="number" id="increment" min="16" step="16" />
+          </div>
+          <div class="col-3">
+            <label for="cap">MAX_LEN_CAP</label>
+            <input type="number" id="cap" min="64" step="32" />
+          </div>
+
+          <div class="col-3">
+            <label for="estimated_base_dataset_ram_gb">ESTIMATED_BASE_DATASET_RAM_GB</label>
+            <input type="number" id="estimated_base_dataset_ram_gb" min="0.1" step="0.1" />
+          </div>
+          <div class="col-3">
+            <label for="cost_per_increment_gb">COST_PER_INCREMENT_GB</label>
+            <input type="number" id="cost_per_increment_gb" min="0.05" step="0.05" />
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <section class="card">
+      <header>
+        <h2>Treinar IA com Ficheiros</h2>
+        <div class="chips">
+          <span class="pill" id="trainerState">estado: inativo</span>
+        </div>
+      </header>
+      <div class="content">
+        <div class="row">
+          <div class="col-12">
+            <label for="model_path">Caminho do Modelo Base</label>
+            <input type="text" id="model_path" placeholder="/caminho/para/modelo" />
+          </div>
+          <div class="col-12">
+            <label for="train_files">Ficheiros de Treino (.jsonl)</label>
+            <input type="file" id="train_files" multiple accept=".jsonl" />
+          </div>
+          <div class="col-4">
+            <label for="epochs">Número de Épocas</label>
+            <input type="number" id="epochs" min="1" step="1" value="1" />
+          </div>
+		
+					<div class="col-8" style="display:flex;align-items:flex-end;gap:8px;flex-wrap:wrap">
+						<button class="btn btn-primary" id="startBtn">🚀 Iniciar Treino</button>
+						<button class="btn btn-warn" id="reduceBtn">➖ Reduzir (-1)</button>
+						<button class="btn btn-success" id="increaseBtn">➕ Aumentar (+1)</button>
+					</div>
+
+					<div class="col-8" style="display:flex;align-items:flex-end;gap:8px;flex-wrap:wrap;margin-top:8px">
+						<button class="btn" id="mergeBtn">🔗 Fazer Merge</button>
+						<button class="btn" id="continueBtn">🔁 Continuar (+1 Época)</button>
+						<button class="btn" id="testBtn">🧠 Testar Modelo (sem Merge)</button>
+						<button class="btn" id="tensorboardBtn">📈 Ver Gráfico (TensorBoard)</button>
+						<button class="btn" id="modelDirBtn">📂 Ver output_dir</button>
+					</div>
+					
+        </div>
+
+					<div class="mt-2 w-full bg-gray-200 rounded-full h-3">
+						<div id="progressBar" class="bg-indigo-500 h-3 rounded-full transition-all duration-300" style="width: 0%;"></div>
+					</div>
+					
+					<h3>Status do Treino</h3>
+					<div id="trainingBox" class="bg-gray-800" style="height: 500px; overflow-y: auto; white-space: pre-wrap; border: 1px solid #ccc; padding: 10px;">
+          À espera do início do treino…					
+				 </div>
+				 
+					<h3>Conteúdo do Diretório do Modelo</h3>
+					<div id="modelDirBox"
+							 class="bg-gray-900"
+							 style="height:200px;overflow-y:auto;border:1px solid #444;padding:10px;font-family:monospace;">
+					A carregar conteúdo do diretório...
+					</div>				
+      </div>
+    </section>
+  </main>
+  
+  <section class="footer">
+    Dica: passa o rato por cima dos rótulos para ver dicas. Endpoints esperados: 
+    <span class="kbd">GET/POST /api/config</span>, 
+    <span class="kbd">POST /api/train</span>, 
+    <span class="kbd">POST /api/merge</span>, 
+    <span class="kbd">POST /api/continue</span>, 
+    <span class="kbd">POST /api/test</span>, 
+    <span class="kbd">GET /api/progress</span>, 
+    <span class="kbd">GET /api/logs</span>.
+
+	<script>
+		// =========================
+		// CONFIGURAÇÃO DE ENDPOINTS
+		// =========================
+		const API = {
+			config:              '/api/config',
+			train:               '/api/train',
+			merge:               '/api/decide_merge',
+			cont:                '/api/decide_merge',
+			test:                '/api/load_lora_chat',
+			train_status:        '/api/train_status',
+			tensorboard:         '/api/tensorboard/start',
+			adjust_accumulation: '/api/adjust_accumulation',
+			model_dir: 					 '/api/model_dir'
+		};
+
+		// Estado local da configuração
+		let cfg = {};
+
+		// =========================
+		// HELPERS
+		// =========================
+		const $ = id => document.getElementById(id);
+		const toNumber = (id, def=0) => { const el = $(id); if(!el) return def; const v = parseFloat(el.value); return Number.isFinite(v)?v:def; };
+		const toBool = (id, def=false) => { const el = $(id); return el?el.checked:def; };
+		const setElementValue = (id, value) => { const el = $(id); if(!el) return false; if(el.type==='checkbox'){ el.checked=!!value; } else { el.value=value??''; } return true; };
+		const getElementValue = id => { const el = $(id); if(!el) return null; return el.type==='checkbox'?el.checked:el.value; };
+
+		// =========================
+		// UI <-> CFG
+		// =========================
+		const FIELD_MAP = {
+			cpu_count:'cpu_count', omp_threads:'omp_threads', dataloader_workers:'dataloader_workers',
+			total_ram_gb:'total_ram_gb', base_batch:'base_batch_size', base_eval_size:'base_eval_size',
+			base_learning_rate:'base_learning_rate', lr_scheduler_type:'lr_scheduler_type',
+			max_steps:'dynamic_accumulation_max_steps', estimated_batch_gb:'estimated_batch_gb',
+			high_ram_limit_pct:'dynamic_accumulation_high_ram_limit', low_ram_limit_pct:'dynamic_accumulation_low_ram_limit',
+			base_max_len:'base_max_len', ml_target_utilization:'target_max_len_utilization',
+			increment:'max_len_increment', cap:'max_len_cap',
+			estimated_base_dataset_ram_gb:'estimated_base_dataset_ram_gb', cost_per_increment_gb:'cost_per_increment_gb'
+		};
+
+		function applyCfgToForm(){
+			for(const [elId, cfgKey] of Object.entries(FIELD_MAP)){
+				if(cfg[cfgKey] !== undefined) setElementValue(elId, cfg[cfgKey]);
+			}
+			// chips resumo
+		  const ramEl = $('ramSummary'); if(ramEl && cfg.target_ram_utilization) ramEl.textContent = `RAM target: ${(cfg.target_ram_utilization*100).toFixed(0)}%`;
+			const mlEl  = $('mlSummary');  if(mlEl  && cfg.max_len_cap)            mlEl.textContent  = `MAX_LEN: ${cfg.max_len_cap}`;
+		}
+
+		function readFormToCfg(){
+			for(const [elId, cfgKey] of Object.entries(FIELD_MAP)){
+				const v = getElementValue(elId);
+				if(v !== null) cfg[cfgKey] = v;
+			}
+		}
+
+		// =========================
+		// FETCH / SAVE CONFIG
+		// =========================
+		async function fetchConfigFromServer(){
+			try{
+				const r = await fetch(API.config, {cache:'no-store'});
+				if(!r.ok) throw new Error('HTTP '+r.status);
+				cfg = await r.json();
+				applyCfgToForm();
+			} catch(e){
+				console.warn('Não foi possível carregar config do servidor:', e);
+			}
+		}
+
+		async function saveConfigToServer(){
+			readFormToCfg();
+			try{
+				const r = await fetch(API.config, {method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify(cfg)});
+				if(!r.ok) throw new Error('HTTP '+r.status);
+				const trainingBox = $('trainingBox');
+				if(trainingBox) { trainingBox.textContent += '\n✅ Configuração guardada.'; trainingBox.scrollTop = trainingBox.scrollHeight; }
+			} catch(e){
+				console.error('Erro ao guardar config:', e);
+				const trainingBox = $('trainingBox');
+				if(trainingBox) { trainingBox.textContent += '\n❌ Falha ao guardar config.'; }
+			}
+		}
+
+		// =========================
+		// TREINO / OPERAÇÕES
+		// =========================
+		async function startTraining(){
+			const fd = new FormData();
+			fd.append('model_path', $('model_path')?.value||'');
+			fd.append('epochs', $('epochs')?.value||'1');
+			for(const f of $('train_files')?.files||[]) fd.append('files',f,f.name);
+
+			try {
+				const r = await fetch(API.train,{method:'POST',body:fd});
+				if(!r.ok) throw new Error('HTTP '+r.status);
+				showMessage('🚀 Treino iniciado.', 'success'); 
+				startPolling();
+			} catch(e){
+				console.error(e); 
+				showMessage('❌ Falha ao iniciar treino.', 'error');
+			}
+		}
+
+		async function doMerge(){
+			const fd = new FormData();
+			fd.append('decision','merge');
+			fd.append('model_path', $('model_path')?.value||'');
+			try{
+				const r=await fetch(API.merge,{method:'POST',body:fd});
+				if(!r.ok) throw new Error('HTTP '+r.status);
+				showMessage('Merge solicitado.','success');
+			} catch(e){console.error(e); showMessage('Falha ao pedir merge.','error');}
+		}
+
+		async function doContinue(){
+			const fd = new FormData();
+			fd.append('decision','continue');
+			fd.append('model_path', $('model_path')?.value||'');
+			fd.append('epochs','1');
+			try{
+				const r=await fetch(API.cont,{method:'POST',body:fd});
+				if(!r.ok) throw new Error('HTTP '+r.status);
+				showMessage('Continuação iniciada.','success');
+				startPolling();
+			} catch(e){console.error(e); showMessage('Falha ao continuar treino.','error');}
+		}
+
+		async function doTest(){
+			const body = JSON.stringify({
+				model_path: $('model_path')?.value||'',
+				output_dir: 'trained_model_output'
+			});
+			try{
+				const r=await fetch(API.test,{method:'POST',headers:{'Content-Type':'application/json'},body});
+				if(!r.ok) throw new Error('HTTP '+r.status);
+				showMessage('Modelo carregado para teste.','success');
+			} catch(e){console.error(e); showMessage('Falha ao testar.','error');}
+		}
+		async function openTensorBoard(){ try{ const r=await fetch('/api/tensorboard/start',{method:'POST'}); if(!r.ok) throw new Error('HTTP '+r.status); const data=await r.json(); const url=data.url||'http://localhost:6006'; showMessage('TensorBoard iniciado.','success'); setTimeout(()=>window.open(url,'_blank'),1000);} catch(e){console.error(e);showMessage('Falha ao iniciar TensorBoard.','error');} }
+
+		// =========================
+		// POLLING TRAIN STATUS
+		// =========================
+		let pollTimer = null;
+
+		function showMessage(msg, type = 'info') {
+			const trainingBox = $('trainingBox');
+			if(!trainingBox) return;
+			const prefix = type === 'success' ? '✅' :
+										 type === 'error'   ? '❌' :
+										 type === 'warning' ? '⚠️' : 'ℹ️';
+			trainingBox.textContent += `\n${prefix} ${msg}`;
+			trainingBox.scrollTop = trainingBox.scrollHeight;
+		}
+
+		function startPolling() {
+			if (pollTimer) return;
+
+			pollTimer = setInterval(async () => {
+				try {
+					const r = await fetch(API.train_status, { cache: 'no-store' });
+					if (!r.ok) throw new Error('HTTP ' + r.status);
+					const data = await r.json();
+
+					let content = '🚀 Treino iniciado\n';
+
+					// Progresso e estado
+					if (data.progress !== undefined) {
+						const pct = typeof data.progress === 'object' ? data.progress.percent : data.progress;
+						content += `Progresso: ${pct}%\n`;
+						const progressBar = $('progressBar');
+						if (progressBar) progressBar.style.width = `${pct}%`;
+					}
+
+					
+					if (data.status) content += `Estado: ${data.status}\n`;
+
+					// Epoch losses
+					if (data.epoch_losses && data.epoch_losses.length > 0) {
+						content += `Loss por época: ${data.epoch_losses.join(', ')}\n`;
+					}
+
+					// Logs
+					if (data.logs && data.logs.length > 0) {
+						content += 'Logs recentes:\n' + data.logs.join('\n');
+					} else {
+						content += 'Logs ainda não recebidos...\n';
+					}
+
+					trainingBox.textContent = content;
+					trainingBox.scrollTop = trainingBox.scrollHeight;
+
+				} catch (e) {
+					console.error('Erro ao atualizar treinamento:', e);
+					showMessage('Erro ao obter estado do treino.', 'error');
+				}
+			}, 1500);
+		}
+
+		// =========================
+		// MANUAL ADJUSTMENT ACCUMULATION
+		// =========================
+		async function manualAdjustAccumulation(delta){
+			try{
+				const r = await fetch(API.adjust_accumulation,{
+					method:'POST',
+					headers:{'Content-Type':'application/json'},
+					body: JSON.stringify({delta})
+				});
+				if(!r.ok) throw new Error('HTTP '+r.status);
+				const res = await r.json();
+				showMessage(`Gradient Accumulation ajustado: ${res.current_steps}`,'success');
+			}catch(e){ console.error(e); showMessage('Falha ao ajustar accumulation_steps.','error'); }
+		}
+
+		// =========================
+		// DIRETORIO DO MODELO 
+		// =========================
+
+		async function loadModelDir(){
+				const box = $('modelDirBox');
+				if(!box) return;
+
+				box.innerHTML = '<div class="muted">A carregar estrutura de pastas...</div>';
+
+				try {
+						const r = await fetch(API.model_dir, {cache:'no-store'});
+						const data = await r.json();
+
+						if(!data.files || data.files.length === 0){
+								box.innerHTML = '<div class="warn">Diretório vazio.</div>';
+								return;
+						}
+
+						box.innerHTML = ''; // Limpa a caixa
+						let lastFolder = "";
+
+						data.files.forEach(file => {
+								// Verifica se o ficheiro está dentro de uma pasta (tem uma "/")
+								const parts = file.split('/');
+								const isInsideFolder = parts.length > 1;
+								const currentFolder = isInsideFolder ? parts.slice(0, -1).join('/') : "Raiz do Modelo";
+								const fileName = parts[parts.length - 1];
+
+								// Se mudámos de pasta, cria um cabeçalho visual para a nova pasta
+								if (currentFolder !== lastFolder) {
+										const folderHeader = document.createElement('div');
+										folderHeader.style = "background: #21262d; color: #7aa2d6; padding: 4px 8px; margin-top: 10px; font-weight: bold; border-radius: 4px; font-size: 11px; border-left: 3px solid #1f6feb;";
+										folderHeader.innerHTML = `📁 PASTA: ${currentFolder}`;
+										box.appendChild(folderHeader);
+										lastFolder = currentFolder;
+								}
+
+								// Cria a linha do ficheiro
+								const row = document.createElement('div');
+								row.style = "display:flex; justify-content:space-between; align-items:center; padding:4px 8px; border-bottom:1px solid #30363d; margin-left: 10px;";
+								
+								row.innerHTML = `
+										<span style="color: #e8eef6; font-size: 12px;">${fileName}</span>
+										<a href="/api/download/${file}" download style="color:#58a6ff; text-decoration:none; font-size: 11px; background: #161b22; padding: 2px 6px; border-radius: 4px; border: 1px solid #30363d;">📥 Download</a>
+								`;
+								box.appendChild(row);
+						});
+
+				} catch(e) {
+						box.innerHTML = `<div class="err">Erro ao organizar pastas: ${e.message}</div>`;
+				}
+		}
+
+
+
+
+
+
+		// =========================
+		// EVENT LISTENERS
+		// =========================
+		window.addEventListener('DOMContentLoaded',()=>{
+			['saveCfgBtn','refreshBtn','startBtn','mergeBtn','continueBtn','testBtn','tensorboardBtn','reduceBtn','increaseBtn', 'modelDirBtn'].forEach(id=>{	
+				
+				const el=$(id); if(!el) return;
+				switch(id){
+					case 'saveCfgBtn': el.addEventListener('click',saveConfigToServer); break;
+					case 'refreshBtn': el.addEventListener('click',fetchConfigFromServer); break;
+					case 'startBtn': el.addEventListener('click',startTraining); break;
+					case 'mergeBtn': el.addEventListener('click',doMerge); break;
+					case 'continueBtn': el.addEventListener('click',doContinue); break;
+					case 'testBtn': el.addEventListener('click',doTest); break;
+					case 'tensorboardBtn': el.addEventListener('click',openTensorBoard); break;
+					case 'reduceBtn': el.addEventListener('click',()=>manualAdjustAccumulation(-1)); break;
+					case 'increaseBtn': el.addEventListener('click',()=>manualAdjustAccumulation(1)); break;
+					case 'modelDirBtn': el.addEventListener('click',loadModelDir); break;
+				}
+			});
+			fetchConfigFromServer();
+		});
+
+	</script>
+</body>
+</html>
+
+