File size: 5,368 Bytes
e26f4cc | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 | #!/usr/bin/env python3
"""50_pensamento.py — Tecnologia Pensamento v0.5.0.
Demonstra o ciclo completo (provas r-21):
1. (item a) treino cooperativo das N redes paralelas — perda cai;
2. (item c) consulta OOD (fora do padrão comum) — confiança baixa;
3. (item d) ciclo planejamento → distribuição de competências →
(re-planejamento | resposta) com orçamento — termina (T-P4);
4. ganho de confiança da agregação vs 1 rede isolada (T-P2);
5. escalonamento com N: mais tentativas ⇒ mais confiança (T-P2 empírico).
Também mede a neutralidade no nascimento (T-P5) via confiança da linha de
base e o custo (tempo) por iteração. Saída: resultados/pensamento_v050.json
"""
import json, math, os, time
def main():
import khtst_rust.nucleo_rust as nr
pasta = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
res = {"versao": "0.5.0", "modulo": nr.versao(), "demos": {}}
# -------------------------------------------- demo principal (N=5, ciclo d)
print("=== Pensamento: demo completa (N=5 tentativas) ===", flush=True)
t0 = time.time()
d = nr.demo_pensamento(
d_cond=8, d_saida=4, n_tentativas=5,
passos_treino=220, limiar_conf=0.55, orcamento=6, semente=42,
)
dt = time.time() - t0
print(f" treino cooperativo: perda {d['perda_treino_inicial']:.4f} -> {d['perda_treino_final']:.4f} "
f"(aprendeu: {d['treino_aprendeu']})")
print(f" ciclo d: {d['iteracoes_ciclo_d']} iteracoes | eventos: "
f"{[e['tipo'] for e in d['eventos_ciclo']]}")
print(f" confianca base (1 rede): {d['confianca_base_1_rede']:.4f}")
print(f" confianca Pensamento (N=5): {d['confianca_pensamento']:.4f} "
f"(ganho {d['ganho_confianca']:+.4f})")
res["demos"]["principal"] = {**d, "tempo_s": dt,
"gate_aprendeu": d["treino_aprendeu"],
"gate_terminou": d["iteracoes_ciclo_d"] <= 6,
"gate_ganhou": d["ganho_confianca"] > 0}
# -------------------------------------------- escalonamento com N (T-P2)
print("\n=== Escalonamento com N (T-P2: auto-consistência) ===", flush=True)
escal = []
for n in (1, 2, 3, 5, 8):
t0 = time.time()
r = nr.demo_pensamento(
d_cond=8, d_saida=4, n_tentativas=n,
passos_treino=200, limiar_conf=0.95, orcamento=8, semente=100 + n,
)
dt = time.time() - t0
escal.append({
"n": n,
"conf_base": r["confianca_base_1_rede"],
"conf_pensamento": r["confianca_pensamento"],
"ganho": r["ganho_confianca"],
"iteracoes": r["iteracoes_ciclo_d"],
"tempo_s": dt,
})
print(f" N={n}: base {r['confianca_base_1_rede']:.4f} -> pensamento "
f"{r['confianca_pensamento']:.4f} (ganho {r['ganho_confianca']:+.4f}) | {dt:.1f}s")
# T-P2 empírico: a média das confianças com N grande excede a com N pequeno
confs = [e["conf_pensamento"] for e in escal]
monotona = all(c2 >= c1 - 0.02 for c1, c2 in zip(confs, confs[1:]))
n1, nn = escal[0]["conf_pensamento"], escal[-1]["conf_pensamento"]
res["demos"]["escalonamento_n"] = {
"serie": escal,
"confianca_n1": n1,
"confianca_n_max": nn,
"melhora_com_n": nn > n1,
"monotona_quase": monotona,
"gate_tp2": nn >= n1 - 0.02,
}
print(f" N=1: {n1:.4f} | N=8: {nn:.4f} | melhora: {nn > n1}")
# -------------------------------------------- T-P3: montador algébrico
print("\n=== T-P3: montador algébrico (projeção ridge) ===", flush=True)
rng_w = [[0.3 * ((i * 7 + j * 3) % 11) / 11.0 - 0.15 for j in range(4)] for i in range(8)]
r_alvo = [[float((i + j) % 5) / 5.0 for j in range(3)] for i in range(8)]
r = nr.projetar_ridge(rng_w, r_alvo, 1e-6)
# resíduo mínimo: compara com perturbações
def residuo(rr):
return sum((sum(rng_w[i][k] * rr[k][j] for k in range(4)) - r_alvo[i][j]) ** 2
for i in range(8) for j in range(3))
f0 = residuo(r)
pert_ok = True
for seed in range(20):
pr = [[r[i][j] + 0.1 * math.sin(seed + i + j) for j in range(3)] for i in range(4)]
if residuo(pr) < f0 - 1e-9:
pert_ok = False
print(f" residuo da projecao: {f0:.6f} | nenhuma perturbacao melhora: {pert_ok}")
res["demos"]["projeção_ridge"] = {"residuo": f0, "otimalidade_vs_perturbacoes": pert_ok,
"gate_tp3": pert_ok}
# ------------------------------------------------------------------ resumo
gates = []
for nome, s in res["demos"].items():
gates += [(f"{nome}.{g[5:]}", v) for g, v in s.items() if g.startswith("gate_")]
ok = sum(1 for _, v in gates if v)
res["resumo"] = {"gates_totais": len(gates), "gates_ok": ok, "todos_verdes": ok == len(gates)}
print(f"\n=== RESUMO: {ok}/{len(gates)} gates verdes ===")
os.makedirs(os.path.join(pasta, "resultados"), exist_ok=True)
with open(os.path.join(pasta, "resultados", "pensamento_v050.json"), "w") as f:
json.dump(res, f, indent=1, ensure_ascii=False)
print("salvo: resultados/pensamento_v050.json")
if not res["resumo"]["todos_verdes"]:
raise SystemExit(1)
if __name__ == "__main__":
main()
|