Upload app.py

app.py

@@ -91,6 +91,7 @@ def detect_core_types():
     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:
@@ -106,7 +107,6 @@ def detect_core_types():
                             ("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),
@@ -135,13 +135,11 @@ def detect_core_types():
                                 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).
+                                    # Multi-grupo (>64 lógicos): mapping global complexo, cai para fallback.
                                     pass
                         offset += size
 
@@ -149,9 +147,8 @@ def detect_core_types():
                         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
+        except Exception:
+            pass  # continua para Linux/fallback
 
     # 2) Linux sysfs core_type
     if platform.system() == "Linux":
@@ -160,12 +157,11 @@ def detect_core_types():
             for cpu in range(logical):
                 path = f"/sys/devices/system/cpu/cpu{cpu}/topology/core_type"
                 try:
-                    with open(path, "r") as f:
+                    with open(path) 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:
@@ -183,8 +179,7 @@ def detect_core_types():
                 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)
+                    p_ids = sorted(p_ids + unknown)  # conservador: desconhecidos como P
                 return sorted(p_ids), sorted(e_ids), {"method": "linux_core_type", "notes": notes}
         except Exception:
             pass
@@ -233,7 +228,6 @@ def get_core_siblings():
             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)
@@ -247,36 +241,27 @@ def get_core_siblings():
                     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
+                        for bit in range(64):
+                            if (mask >> bit) & 1:
+                                core_logicals.append(bit)  # single/multi-grupo: aproximação razoável
                     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
+            return sorted(siblings, key=lambda s: min(s) if s else 1e9)
         except Exception:
             return []
 
     elif platform.system() == "Linux":
-        sibs = []
         try:
+            sibs = []
             for cpu in range(logical):
                 path = f"/sys/devices/system/cpu/cpu{cpu}/topology/thread_siblings_list"
                 try:
-                    with open(path, "r") as f:
+                    with open(path) 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:
@@ -286,172 +271,125 @@ def get_core_siblings():
                         items.append(int(part))
                 sibs.append(sorted(set(items)))
             # Deduplica sublistas iguais
-            uniq = []
             seen = set()
+            uniq = []
             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
+            return sorted(uniq, key=lambda s: min(s))
         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).
+    Reordena 'candidates' para usar primeiro 1 logical por core físico (evita 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)
+    first_pass = [next((x for x in g if x in cand_set), None) for g in siblings_map]
+    first_pass = [x for x in first_pass if x is not None]
+
+    others    = [x for g in siblings_map for x in g if x in cand_set and x not in first_pass]
     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. 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
+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)
-#--------------------------------------------------------------------------------------------------------------------------------------
+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))
+DETECTION_PERFORMANCE   = "auto"   # "auto" | "manual"
+CORES_UTILIZATION       = 1.0
 
+def compute_cores(cpu_count: int, utilization: float) -> int:
+    """Aplica uma utilização fracional a um contagem de CPUs com clamp [1, cpu_count]."""
+    return max(1, min(int(math.floor(cpu_count * utilization)), cpu_count))
 
-EFFECTIVE_LOGICAL_CPUS = compute_effective_cores(LOGICAL_CPUS, CORES_UTILIZATION)
+# NOTA: compute_effective_cores e compute_omp_threads faziam exactamente o mesmo;
+# ambos substituídos por compute_cores acima. Usos em baixo são drop-in equivalentes.
 
-# --------------------
-# --- Detectar núcleos P/E ---
-_DET_P_full, _DET_E_full, _META = detect_core_types()  # Renomeado para indicar que são os full detections
+EFFECTIVE_LOGICAL_CPUS = compute_cores(LOGICAL_CPUS, CORES_UTILIZATION)
 
-# NOVO: Filtrar P/E-cores para estarem dentro do limite de EFFECTIVE_LOGICAL_CPUS
+# --- Detectar núcleos P/E e filtrar para o limite efectivo ---
+_DET_P_full, _DET_E_full, _META = detect_core_types()
 _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)
+# Meta-informação de arranque (modo auto/manual)
 # ===============================================================
-_AUTO_META = "manual"
-OMP_THREADS_PLACEHOLDER = compute_effective_cores(EFFECTIVE_LOGICAL_CPUS, OMP_THREADS_UTILIZATION)
+OMP_THREADS = compute_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:
+    total_det = len(_DET_P) + len(_DET_E)
+    if total_det == 0:
         _AUTO_META = "auto (fallback homogéneo)"
+    elif len(_DET_P) / total_det >= 0.5:
+        _AUTO_META = f"auto (balanceado P/E → OMP={OMP_THREADS})"
     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})"
+        _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()
+# --- 1.2 Alocação de cores para tensores (OMP) e DataLoader ---
+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
+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)
+    take = ordered_P[:min(needed, len(ordered_P))]
+    P_CORE_IDS.extend(take)
+    needed -= len(take)
 
-# 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)
+    take = [i for i in ordered_E if i not in P_CORE_IDS][:needed]
+    P_CORE_IDS.extend(take)
+    needed -= len(take)
 
-# Fallback homogéneo: se nada acima preencheu (ex.: sem deteção ou P/E fora do range), usa os primeiros N
+# Fallback homogéneo
 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
+# Secundários (DataLoader): E sobrantes → P sobrantes → 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
+available = set(range(EFFECTIVE_LOGICAL_CPUS))
+secondary = (
+    [i for i in _DET_E if i not in used and i in available] +
+    [i for i in _DET_P if i not in used and i in available] +
+    [i for i in available if i not in used and i not in _DET_P and i not in _DET_E]
+)
 _seen = set()
 REMAINING_CORE_IDS = [x for x in secondary if not (x in _seen or _seen.add(x))]
 
+DATALOADER_WORKERS = min(len(REMAINING_CORE_IDS), max(0, EFFECTIVE_LOGICAL_CPUS - len(P_CORE_IDS)))
 
-# 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)
+# Variáveis de ambiente
+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":
@@ -462,148 +400,117 @@ def set_affinity(core_ids):
         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]
+final_affinity_cores = sorted(i for i in set(P_CORE_IDS + REMAINING_CORE_IDS) 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 de arranque (apenas uma vez, evita duplicação no reload do Flask)
+# ---------------------------------------------------------------
+if os.environ.get("WERKZEUG_RUN_MAIN") != "true" and not globals().get("_LOGS_PRINTED", False):
     _LOGS_PRINTED = True
+    has_e = bool(_DET_E)
 
-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
+    for note in _META.get("notes", []):
+        print(f"[INFO] [{_ts()}] Nota: {note}")
     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
+    P_from_P = [i for i in P_CORE_IDS if i in _DET_P]
+    P_from_E = [i for i in P_CORE_IDS if i in _DET_E]
     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 "")
-        )
+        e_str = f", +E: {len(P_from_E)} {sorted(P_from_E)}" if P_from_E else ""
+        print(f"[INFO] [{_ts()}] Tensores (OMP={OMP_THREADS}) → P: {len(P_from_P)} {sorted(P_from_P)}{e_str}")
     else:
         print(f"[INFO] [{_ts()}] Tensores (OMP={OMP_THREADS}) [homogéneo] → {len(P_CORE_IDS)} {sorted(P_CORE_IDS)}")
 
-
-    # Secundários (DataLoader)
+    # DataLoader
+    SEC_E     = [i for i in REMAINING_CORE_IDS if i in _DET_E]
+    SEC_P     = [i for i in REMAINING_CORE_IDS if i in _DET_P]
+    SEC_OTHER = [i for i in REMAINING_CORE_IDS if i not in _DET_P and i not in _DET_E]
     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)}")
+        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("-" * 80)
+    print(f"[INFO] [{_ts()}] LOGICAL_CPUS: {LOGICAL_CPUS} | PHYSICAL_CPUS: {PHYSICAL_CPUS} | TOTAL_RAM_GB: {TOTAL_RAM_GB:.2f}")
+    print(f"[INFO] [{_ts()}] Cores Utilization: {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}")
+    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()}] Total alocados (OMP + DataLoader): {total_allocated} (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 = 5                          # Batch size para avaliação (reduzido para CPU)
-BASE_LEARNING_RATE = 1e-4                    # 2e-5
-LR_SCHEDULER_TYPE = "constant_with_warmup"   # (HF: cosine + warmap) cosine
-WARMUP_RATIO = 0.03                          # ~3% dos 4012 steps ≈ 120
-LOGGIN_STEPS = 5
-SAVE_STRATEGY = "steps"
-SAVE_STEPS = 50
-EVAL_STEPS = 5
-#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.75  #0.65
-MAX_LEN_INCREMENT = 256
-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.99     # Target de RAM no callback (não usado diretamente, mas mantido para clareza)
-DYNAMIC_ACCUMULATION_HIGH_RAM_LIMIT = 98.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
+# =========================================================================
+# 1.3 Parâmetros base do treino
+# =========================================================================
+BASE_BATCH_SIZE                  = 1
+INITIAL_ACCUMULATION_MIN_STEPS   = 2
+INITIAL_ACCUMULATION_MAX_STEPS   = 4
+BASE_EVAL_SIZE                   = 5
+BASE_LEARNING_RATE               = 1e-4
+LR_SCHEDULER_TYPE                = "constant_with_warmup"
+WARMUP_RATIO                     = 0.03
+LOGGIN_STEPS                     = 5
+SAVE_STRATEGY                    = "steps"
+SAVE_STEPS                       = 50
+EVAL_STEPS                       = 5
+WEIGHT_DECAY                     = 0.1
+OPTIM                            = "adamw_torch"
+# =========================================================================
+# 1.4 – 1.6  RAM e MAX_LEN
+# =========================================================================
+TARGET_RAM_UTILIZATION           = 0.95   # Limite máximo de uso da RAM total
 
+# Custo empírico de RAM por batch (ajustar conforme modelo)
+ESTIMATED_BATCH_GB               = 0.30   # 0.4 para LLaMA
+
+# NOTA: TARGET_ACCUMULATION_RAM_UTILIZATION foi removido — era um alias de
+#       TARGET_RAM_UTILIZATION e não acrescentava nada. Usa TARGET_RAM_UTILIZATION directamente.
+
+BASE_MAX_LEN                     = 256
+TARGET_MAX_LEN_UTILIZATION       = 0.75
+MAX_LEN_INCREMENT                = 256
+MAX_LEN_CAP                      = 256
+DEFAULT_FALLBACK_CAP             = 8192
+TOKENIZER_SENTINEL_CAP           = 10_000_000
+
+# Custo empírico de RAM para o dataset (ajustar conforme modelo)
+ESTIMATED_BASE_DATASET_RAM_GB    = 1.6
+COST_PER_INCREMENT_GB            = 0.30   # 0.45 para LLaMA
+
+# =========================================================================
+# 1.7  DynamicAccumulationCallback
+# =========================================================================
+DYNAMIC_ACCUMULATION_MAX_STEPS       = 256
+DYNAMIC_ACCUMULATION_TARGET_UTIL     = 0.99   # mantido para referência futura
+DYNAMIC_ACCUMULATION_HIGH_RAM_LIMIT  = 98.5
+DYNAMIC_ACCUMULATION_LOW_RAM_LIMIT   = 40.0
+
+# =========================================================================
+# 1.8  Ganchos opcionais para PyTorch
+# =========================================================================
+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.
+        # 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
+# =========================================================================
+# 1.9  Outros parâmetros
+# =========================================================================
+OPTIMIZER_REFRESH_INTERVAL = 600   # segundos
+
 # =========================================================================
 # 2️.Configuração Inicial e Cálculos
 # =========================================================================
@@ -675,7 +582,6 @@ def ajustar_max_len(
 )
     
     return final_max_len
-
 # ==============================
 # 3.Optimizer Refresh Callback
 # ==============================
@@ -1044,41 +950,41 @@ class DynamicAccumulationCallback(TrainerCallback):
 
         return control
 
-#--------------------------------------------------
+# =========================================================================
 # Variáveis Globais
-model = None  # variável global
-tokenizer = None
+# =========================================================================
+model           = None
+tokenizer       = None
+chat_model      = None
+chat_tokenizer  = None
 
 train_progress = {
-    "current": 0, 
-    "total": 1, 
-    "percent": 0, 
-    "status": "not started", 
-    "message": "Aguardando início do treino."
+    "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
+
+training_logs = []   # linhas de log acumuladas durante o treino
+epoch_losses  = []
+all_data      = []   # dados do último treino (permite continuar)
+
+CURRENT_ACCUM_STEPS     = None   # None = sem override manual activo
+LAST_ACCUM_ORIGIN       = None   # "manual" | "auto" | None
+TOTAL_TRAIN_STEPS       = None   # preenchido após tokenização/Trainer
+BASE_BATCH_SIZE_EFFECTIVE = 4    # usado em /api/train_status para Effective Batch
+
+# =========================================================================
+# Cálculos iniciais de acumulação
+# =========================================================================
+ACCUMULATION_STEPS        = ajustar_accumulation_steps()
+EFFECTIVE_BATCH_SIZE      = BASE_BATCH_SIZE * ACCUMULATION_STEPS
+LAST_ACCUM_ORIGIN         = "auto"
 BASE_BATCH_SIZE_EFFECTIVE = EFFECTIVE_BATCH_SIZE
 
+# Log após o cálculo — agora ACCUMULATION_STEPS tem valor real
+training_logs.append(f"[INFO] accumulation inicial = {ACCUMULATION_STEPS} (auto)")
 #----------------------------
 # Função principal de treino
 #----------------------------
@@ -1088,46 +994,34 @@ def train_model_lora(
     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.
+    Função principal de treino LoRA (Low-Rank Adaptation).
+    CPU-only: XPU/CUDA removidos por decisão de arquitectura.
     """
     # ---------------- VARIÁVEIS GLOBAIS ----------------
-    global training_logs, train_progress, epoch_losses
+    global training_logs, train_progress, epoch_losses, all_data
+
     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")
+    # ---------------- ESTADO INICIAL ----------------
+    initial_status_message = (
+        "Retomando treino a partir de adaptador LoRA salvo..."
+        if lora_adapter_to_load else
+        "Iniciando processo de treino..."
+    )
+    train_progress.update({
+        "current":  0,
+        "total":    1,
+        "percent":  0,
+        "status":   "starting",
+        "message":  initial_status_message,
+    })
+    log_info(initial_status_message)
     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
+    # ---------------- AUXILIAR: detetar camadas LoRA ----------------
     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):
@@ -1141,26 +1035,18 @@ def train_model_lora(
         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
+    # ---------------- 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}")
+        log_info(
+            f"Tokens antes do ajuste: PAD={tokenizer.pad_token}, "
+            f"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:
@@ -1175,53 +1061,26 @@ def train_model_lora(
             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
+        # CPU-only: bf16 é ~2× mais rápido que float32 em CPU moderno
         model = AutoModelForCausalLM.from_pretrained(
             model_path,
-            device_map=model_device_map,
+            device_map="cpu",
             offload_folder="offload",
-            dtype=model_dtype,
-            low_cpu_mem_usage=True
+            dtype=torch.bfloat16,
+            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
-    
-#---------------------------------------------------------------------              
+        model.gradient_checkpointing_enable()
+        log_info("Modelo e tokenizer carregados (CPU / bfloat16).")
+
+        # --- Variáveis de controlo de fluxo (usadas mais abaixo) ---
+        resume_from_trainer_checkpoint     = None
+        lora_adapter_path_final            = os.path.join(output_dir, "lora_model")
+        lora_adapter_to_load_for_training  = None
+        lora_model_loaded_for_initial_eval = False
+        
+#----------------------------------------------------------------------------------            
         # --- Lógica de 4 opções ---
         # Prioridade: 
         #1. Checkpoint do Trainer