# hetu_luoshu_v7_wildfire.py
# 河图洛书 V7.0 - 野火版（纯本地，独立目录，独立记忆）
# 与老登、孢子共用 learning_material 语料库
# 从老登的 masterpieces/ 读取模板（只读，不写入）
# 新作品写入 masterpieces_wildfire/（独立目录，与老登隔离）
# 金池内存上限：10件（只取最新的10个模板）
# 启动时一次性加载全部金池文件到内存（最多10件）
# 每10000轮重新从老登金池加载最新的10个模板
# 野火从第一轮开始训练
# 生成时保留标点符号
import os
import sys
import time
import json
import random
import re
import math
import hashlib
import pickle
import shutil
import threading
from collections import Counter
from typing import List, Dict, Tuple, Optional
from datetime import datetime
# ==================== 目录配置（全部独立） ====================
LEARNING_MATERIAL_DIR = "learning_material"
CACHE_DIR = "cache_wildfire"
RECOVERY_DIR = "recovery_wildfire"
MASTERPIECES_READ_DIR = "masterpieces" # 只读：从老登读取模板
MASTERPIECES_WRITE_DIR = "masterpieces_wildfire" # 只写：野火自己的作品
CHECKPOINT_DIR = "checkpoints_wildfire"
LOGS_DIR = "logs_wildfire"
POOL_LOG_DIR = "pool_log_wildfire"
for d in [CHECKPOINT_DIR, MASTERPIECES_WRITE_DIR, LOGS_DIR, RECOVERY_DIR, CACHE_DIR, POOL_LOG_DIR]:
os.makedirs(d, exist_ok=True)
os.makedirs(LEARNING_MATERIAL_DIR, exist_ok=True)
os.makedirs(MASTERPIECES_READ_DIR, exist_ok=True) # 确保老登目录存在
# ==================== 超时加载检查点 ====================
def load_checkpoint_with_timeout(file_path: str, timeout: int = 600) -> Optional[dict]:
result = [None]
exception = [None]
finished = [False]
def load():
try:
print(f" 📂 开始加载: {os.path.basename(file_path)}")
start_time = time.time()
with open(file_path, 'rb') as f:
result[0] = pickle.load(f)
elapsed = time.time() - start_time
print(f" ✅ 文件读取完成，耗时 {elapsed:.1f} 秒")
except Exception as e:
exception[0] = e
finally:
finished[0] = True
thread = threading.Thread(target=load, daemon=True)
thread.start()
remaining = timeout
while remaining > 0 and not finished[0]:
if remaining % 60 == 0 or remaining <= 10:
print(f" ⏳ 等待加载完成... 剩余 {remaining} 秒")
time.sleep(10)
remaining -= 10
if remaining < 0:
remaining = 0
if not finished[0]:
print(f" ⏰ 加载超时（{timeout}秒），放弃该文件")
return None
if exception[0]:
print(f" ⚠️ 加载失败: {exception[0]}")
return None
return result[0]
# ==================== 本地评分 ====================
def local_evaluate(work: str, dao_novelty: float) -> float:
len_score = min(1.0, len(work) / 50) * 0.4
unique_ratio = len(set(work)) / max(1, len(work)) * 0.3
novelty_score = dao_novelty * 0.3
score = len_score + unique_ratio + novelty_score
return min(1.0, max(0.0, score))
# ==================== 本地生成（保留标点） ====================
def local_generate(morphemes: list, dao_novelty: float, sheng_length: int, jin4_instance=None) -> str:
"""从金池检索模板，插入语素时保留标点符号"""
if jin4_instance and jin4_instance.masterpieces and random.random() < 0.7:
template = random.choice(jin4_instance.masterpieces)
result = template
# 标点符号列表（不插入语素的位置）
punct_chars = {'，', '。', '、', '；', '：', '！', '？', '——', '……', '（', '）', '「', '」', '『', '』', '《', '》', '·'}
# 收集标点位置
punct_positions = set()
for i, ch in enumerate(result):
if ch in punct_chars:
punct_positions.add(i)
# 获取所有可插入位置（非标点位置）
available_positions = [i for i in range(len(result)) if i not in punct_positions]
for m in random.sample(morphemes, min(3, len(morphemes))):
if m and m not in result and len(result) > 0 and available_positions:
pos = random.choice(available_positions)
if pos < len(result) and result[pos] not in punct_chars:
result = result[:pos] + m + result[pos:]
# 更新可用位置
available_positions = [i for i in range(len(result)) if i not in punct_positions]
available_positions = [i for i in available_positions if i > pos]
return result[:sheng_length]
if morphemes:
return "".join(random.sample(morphemes, min(5, len(morphemes))))[:sheng_length]
return "道可道，非常道。"
# ==================== 本地变体生成 ====================
def local_mutate(sentence: str, dao_novelty: float, bian_length: int) -> list:
variants = []
variants.append(sentence[:bian_length])
if len(sentence) >= 5:
prefix = list(sentence[:5])
random.shuffle(prefix)
variants.append(''.join(prefix) + sentence[5:][:bian_length - 5])
return list(dict.fromkeys(variants))[:3]
# ==================== 道：π引擎 ====================
class DaoEngine:
def __init__(self, chunk_size=10000):
self.chunk_size = chunk_size
self.digits = []
self.pointer = 0
self._load_next_chunk()
def _load_next_chunk(self):
try:
import gmpy2
gmpy2.get_context().precision = (self.pointer + self.chunk_size + 100) * 4
pi = gmpy2.const_pi()
pi_str = format(pi, f'.{self.pointer + self.chunk_size + 50}f')
pi_digits = pi_str.replace('.', '')
segment = pi_digits[self.pointer:self.pointer + self.chunk_size]
self.digits.extend([int(ch) for ch in segment])
except ImportError:
from decimal import Decimal, getcontext
getcontext().prec = self.pointer + self.chunk_size + 50
pi = Decimal(0)
for k in range(self.pointer + self.chunk_size + 20):
pi += (Decimal(1) / (16 ** k)) * (
Decimal(4) / (8 * k + 1) - Decimal(2) / (8 * k + 4) -
Decimal(1) / (8 * k + 5) - Decimal(1) / (8 * k + 6)
)
pi_str = str(pi)[2:]
segment = pi_str[self.pointer:self.pointer + self.chunk_size]
self.digits.extend([int(ch) for ch in segment])
def get_novelty(self, length=8) -> float:
while self.pointer + length >= len(self.digits):
self._load_next_chunk()
segment = self.digits[self.pointer:self.pointer + length]
self.pointer += length
value = 0
for i, d in enumerate(segment):
value += d * (0.1 ** (i + 1))
return value
def get_digit(self) -> int:
if self.pointer >= len(self.digits):
self._load_next_chunk()
digit = self.digits[self.pointer]
self.pointer += 1
return digit
def get_digits(self, count: int) -> List[int]:
return [self.get_digit() for _ in range(count)]
def get_pointer(self) -> int:
return self.pointer
def get_state(self) -> dict:
return {"pointer": self.pointer}
def restore_state(self, state: dict):
self.pointer = state.get("pointer", 0)
self.digits = []
self._load_next_chunk()
# ==================== 节奏控制器 ====================
class RhythmController:
def __init__(self):
self.sheng_phase = 0
self.bian_phase = 0
self.sheng_speed = 0.2 * 2 * math.pi / 5
self.bian_speed = 2 * math.pi / 1
def update(self):
self.sheng_phase = (self.sheng_phase + self.sheng_speed) % (2 * math.pi)
self.bian_phase = (self.bian_phase + self.bian_speed) % (2 * math.pi)
def get_sheng_ratio(self):
return 0.55 + 0.25 * math.sin(self.sheng_phase)
def get_bian_ratio(self):
return 0.55 + 0.35 * math.sin(self.bian_phase)
def get_sheng_length(self, sheng_min, sheng_max):
return int(sheng_min + (sheng_max - sheng_min) * self.get_sheng_ratio())
def get_bian_length(self, bian_min, bian_max):
return int(bian_min + (bian_max - bian_min) * self.get_bian_ratio())
def get_state(self) -> dict:
return {"sheng_phase": self.sheng_phase, "bian_phase": self.bian_phase}
def restore_state(self, state: dict):
self.sheng_phase = state.get("sheng_phase", 0)
self.bian_phase = state.get("bian_phase", 0)
# ==================== 河图中央 ====================
class HeTuCenter:
def __init__(self):
self.sheng_info = {"1": 0.0, "2": 0.0, "3": 0.0, "4": 0.0}
self.cheng_info = {"6": 0.0, "7": 0.0, "8": 0.0, "9": 0.0}
self.global_state = {"sheng": 0.0, "cheng": 0.0, "balance": 0.0}
def update_sheng(self, idx: int, value: float):
self.sheng_info[str(idx)] = value
self._update_global_state()
def update_cheng(self, idx: int, value: float):
self.cheng_info[str(idx)] = value
self._update_global_state()
def _update_global_state(self):
self.global_state["sheng"] = sum(self.sheng_info.values()) / 4
self.global_state["cheng"] = sum(self.cheng_info.values()) / 4
self.global_state["balance"] = self.global_state["sheng"] / (self.global_state["cheng"] + 0.01)
def get_full_state(self):
return {"sheng": self.sheng_info.copy(), "cheng": self.cheng_info.copy(), "global": self.global_state.copy()}
def get_save_state(self):
return {"sheng_info": self.sheng_info, "cheng_info": self.cheng_info, "global_state": self.global_state}
def restore_state(self, state: dict):
self.sheng_info = state.get("sheng_info", {"1": 0.0, "2": 0.0, "3": 0.0, "4": 0.0})
self.cheng_info = state.get("cheng_info", {"6": 0.0, "7": 0.0, "8": 0.0, "9": 0.0})
self.global_state = state.get("global_state", {"sheng": 0.0, "cheng": 0.0, "balance": 0.0})
# ==================== 工具函数 ====================
def get_all_txt_files(root_dir: str) -> List[str]:
txt_files = []
if not os.path.exists(root_dir):
return txt_files
for dirpath, dirnames, filenames in os.walk(root_dir):
for filename in filenames:
if filename.endswith('.txt'):
txt_files.append(os.path.join(dirpath, filename))
return txt_files
# ==================== 火2 ====================
class Fire2:
def __init__(self, corpus_paths: List[str]):
self.word_freq = Counter()
self.corpus_paths = corpus_paths
self._load_corpus(corpus_paths)
print(f" 🔥 火2完成，共 {len(self.word_freq)} 个语素")
def _load_corpus(self, paths):
counter = Counter()
all_files = []
for path in paths:
if os.path.isfile(path) and path.endswith('.txt'):
all_files.append(path)
elif os.path.isdir(path):
all_files.extend(get_all_txt_files(path))
if not all_files:
return
for file_path in all_files[:500]:
try:
with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
text = f.read(8000)
for j in range(len(text)):
for l in range(1, 5):
word = text[j:j + l]
if re.match(r'[\u4e00-\u9fff]{1,4}$', word):
counter[word] += 1
except:
pass
self.word_freq = counter
def reload_corpus(self):
old_count = len(self.word_freq)
print(f" 🔄 重新加载语料库（旧语素数:{old_count}）...")
self.word_freq = Counter()
self._load_corpus(self.corpus_paths)
print(f" 🔥 火2重新加载完成，新语素数:{len(self.word_freq)}（新增:{len(self.word_freq) - old_count}）")
def get_morphemes(self, dao_novelty: float, total: int = 50) -> List[str]:
if self.word_freq:
words = list(self.word_freq.keys())
sample_size = min(total, len(words))
if sample_size == 0:
return []
return random.sample(words, sample_size)
seed = int(dao_novelty * 10000)
random.seed(seed)
return [chr(0x4e00 + random.randint(0, 0x5000)) for _ in range(total)]
def get_state(self) -> dict:
return {"word_freq": dict(list(self.word_freq.items())[:5000])}
def restore_state(self, state: dict):
self.word_freq = Counter(state.get("word_freq", {}))
# ==================== 木3 ====================
class Mu3:
def __init__(self):
self.jin4 = None
def set_jin4(self, jin4):
self.jin4 = jin4
def generate(self, morphemes: List[str], dao_novelty: float, sheng_ratio: float, sheng_length: int) -> str:
return local_generate(morphemes, dao_novelty, sheng_length, self.jin4)
def get_state(self) -> dict:
return {}
def restore_state(self, state: dict):
pass
# ==================== 水1 ====================
class Shui1:
def __init__(self):
self.dao = None
def set_dao(self, dao):
self.dao = dao
def mutate(self, sentence: str, dao_novelty: float, bian_ratio: float, bian_length: int) -> List[str]:
return local_mutate(sentence, dao_novelty, bian_length)
def get_state(self) -> dict:
return {}
def restore_state(self, state: dict):
pass
# ==================== 金4 ====================
class Jin4:
def __init__(self, max_size=10): # 只取最新的10个模板
self.masterpieces = []
self.max_size = max_size
def load_from_disk(self, masterpieces_dir: str):
"""从老登的 masterpieces/ 目录读取最新的 max_size 个模板"""
self.masterpieces = []
if not os.path.exists(masterpieces_dir):
print(f" ⚠️ 金池目录不存在: {masterpieces_dir}")
return
print(f"\n 🔍 开始加载金池: {masterpieces_dir}")
all_files = os.listdir(masterpieces_dir)
print(f" 📂 目录下共有 {len(all_files)} 个文件")
files = [f for f in all_files if f.startswith("round_") and f.endswith(".txt")]
print(f" 📄 其中匹配 'round_*.txt' 的文件: {len(files)} 个")
if not files:
print(f" ⚠️ 金池目录为空: {masterpieces_dir}")
return
# 按轮数数值排序，确保加载最新的作品
def extract_round_num(filename):
try:
return int(filename.split('_')[1])
except:
return 0
files.sort(key=extract_round_num, reverse=True)
print(f" 📄 按轮数排序后前5个文件: {files[:5]}")
# 只取最新的 max_size 个
files_to_load = files[:self.max_size]
print(f" 📂 将加载 {len(files_to_load)} 个最新的模板（轮数最大的）")
print(f" 📂 正在加载金池作品...")
loaded_count = 0
for i, f in enumerate(files_to_load):
filepath = os.path.join(masterpieces_dir, f)
try:
with open(filepath, 'r', encoding='utf-8') as file:
content = file.read()
lines = content.split('\n')
work_lines = []
skip_count = 0
for line in lines:
if skip_count < 3:
skip_count += 1
continue
work_lines.append(line.strip())
work = '\n'.join(work_lines).strip()
if work:
self.masterpieces.append(work)
loaded_count += 1
print(f" ✅ 已加载 {loaded_count} 件作品 (轮数: {extract_round_num(f)})")
except Exception as e:
print(f" ❌ 加载 {f} 失败: {e}")
print(f" ✅ 共加载 {len(self.masterpieces)} 件作品到内存金池")
def solidify(self, candidates: List[str], dao_novelty: float) -> Tuple[List[str], List[float]]:
if not candidates:
return [], []
scores = [local_evaluate(work, dao_novelty) for work in candidates]
if not scores:
return [], []
max_score = max(scores)
good_works, good_scores = [], []
for work, score in zip(candidates, scores):
if score == max_score:
good_works.append(work)
good_scores.append(score)
self.masterpieces.append(work)
if len(self.masterpieces) > self.max_size:
self.masterpieces = self.masterpieces[-self.max_size:]
return good_works, good_scores
def get_state(self) -> dict:
return {"masterpieces": self.masterpieces[-100:]}
def restore_state(self, state: dict):
self.masterpieces = state.get("masterpieces", [])
# ==================== 老师 ====================
class Teacher:
def __init__(self, teacher_id: int, student_name: str):
self.id = teacher_id
self.student_name = student_name
self.history = []
def evaluate(self, work: str, dao_novelty: float) -> Tuple[float, str]:
score = local_evaluate(work, dao_novelty)
if self.id == 8:
score = score * 0.95
elif self.id == 9:
score = score * 1.05
elif self.id == 6:
score = score * 0.98
elif self.id == 7:
score = score * 1.02
score = min(1.0, max(0.0, score))
self.history.append((time.time(), work[:30], score))
if len(self.history) > 100:
self.history = self.history[-100:]
return score, f"本地评分{self.id}"
def get_state(self) -> dict:
return {"history": self.history[-50:]}
def restore_state(self, state: dict):
self.history = state.get("history", [])
# ==================== 洛书中心 ====================
class LuoShuCenter:
def __init__(self, dao: DaoEngine):
self.dao = dao
self.hetu_center = HeTuCenter()
self.rhythm = RhythmController()
# 目录配置
self.checkpoint_dir = CHECKPOINT_DIR
self.masterpieces_read_dir = MASTERPIECES_READ_DIR # 从老登读取模板
self.masterpieces_write_dir = MASTERPIECES_WRITE_DIR # 写入野火自己的作品
self.logs_dir = LOGS_DIR
self.recovery_dir = RECOVERY_DIR
self.pool_log_dir = POOL_LOG_DIR
os.makedirs(self.checkpoint_dir, exist_ok=True)
os.makedirs(self.masterpieces_write_dir, exist_ok=True)
os.makedirs(self.logs_dir, exist_ok=True)
os.makedirs(self.recovery_dir, exist_ok=True)
os.makedirs(self.pool_log_dir, exist_ok=True)
print("\n📚 加载语料...")
self.fire2 = Fire2([LEARNING_MATERIAL_DIR])
self.mu3 = Mu3()
self.shui1 = Shui1()
self.shui1.set_dao(dao)
self.jin4 = Jin4() # 内存上限10
self.mu3.set_jin4(self.jin4)
print(f"\n📂 加载野火金池（从老登读取最新的10个模板）...")
self.jin4.load_from_disk(self.masterpieces_read_dir)
self.teacher7 = Teacher(7, "火2")
self.teacher8 = Teacher(8, "木3")
self.teacher6 = Teacher(6, "水1")
self.teacher9 = Teacher(9, "金4")
self.round = 0
self.log_entries = []
self._load_checkpoint()
def _get_checkpoint_path(self) -> str:
return os.path.join(self.checkpoint_dir, "full_checkpoint.pkl")
def _get_tmp_path(self) -> str:
return self._get_checkpoint_path() + ".tmp"
def _get_backup_path(self, round_num: int) -> str:
return os.path.join(self.recovery_dir, f"checkpoint_{round_num}.pkl")
def save_checkpoint(self):
checkpoint = {
"round": self.round,
"dao_state": self.dao.get_state(),
"last_valid_pointer": self.dao.get_pointer(),
"rhythm_state": self.rhythm.get_state(),
"hetu_state": self.hetu_center.get_save_state(),
"fire2_state": self.fire2.get_state(),
"jin4_state": self.jin4.get_state(),
"teacher7_state": self.teacher7.get_state(),
"teacher8_state": self.teacher8.get_state(),
"teacher6_state": self.teacher6.get_state(),
"teacher9_state": self.teacher9.get_state(),
"log_entries": self.log_entries[-100:],
"timestamp": datetime.now().isoformat()
}
tmp_path = self._get_tmp_path()
with open(tmp_path, 'wb') as f:
pickle.dump(checkpoint, f)
main_path = self._get_checkpoint_path()
os.replace(tmp_path, main_path)
if self.round % 100000 == 0 and self.round > 0:
backup_path = self._get_backup_path(self.round)
try:
shutil.copy2(main_path, backup_path)
print(f" 💾 备份检查点已保存: {backup_path}")
except Exception as e:
print(f" ⚠️ 备份保存失败: {e}")
def _restore_pi_pointer(self, checkpoint: dict) -> bool:
pointer_sources = []
dao_state = checkpoint.get("dao_state", {})
if "pointer" in dao_state:
pointer_sources.append(("检查点", dao_state["pointer"]))
if "last_valid_pointer" in checkpoint:
pointer_sources.append(("last_valid_pointer", checkpoint["last_valid_pointer"]))
main_path = self._get_checkpoint_path()
if os.path.exists(main_path):
try:
with open(main_path, 'rb') as f:
main_cp = pickle.load(f)
main_dao = main_cp.get("dao_state", {})
if "pointer" in main_dao:
pointer_sources.append(("主检查点", main_dao["pointer"]))
except:
pass
seen = set()
unique_sources = []
for name, ptr in pointer_sources:
if ptr not in seen:
seen.add(ptr)
unique_sources.append((name, ptr))
for name, ptr in unique_sources:
try:
print(f" 🔄 尝试从 {name} 恢复π指针: {ptr}")
self.dao.pointer = ptr
self.dao.digits = []
self.dao._load_next_chunk()
test_digit = self.dao.get_digit()
self.dao.pointer -= 1
print(f" ✅ π指针恢复成功（来源: {name}）")
return True
except Exception as e:
print(f" ⚠️ 从 {name} 恢复失败: {e}")
continue
print(f" ⚠️ 所有π指针来源均失败，重置为0")
self.dao.pointer = 0
self.dao.digits = []
self.dao._load_next_chunk()
return True
def _load_checkpoint(self):
candidates = []
print("\n 🔍 开始扫描检查点文件...")
print(" ⚠️ 备份文件优先，主文件为最后备选")
tmp_path = self._get_tmp_path()
if os.path.exists(tmp_path):
file_size = os.path.getsize(tmp_path) / 1024
candidates.append(tmp_path)
print(f" 📄 找到临时文件: {os.path.basename(tmp_path)} ({file_size:.1f} KB)")
backup_files = []
if os.path.exists(self.recovery_dir):
for f in os.listdir(self.recovery_dir):
if f.startswith("checkpoint_") and f.endswith(".pkl"):
try:
round_num = int(f.split("_")[1].split(".")[0])
file_size = os.path.getsize(os.path.join(self.recovery_dir, f)) / 1024
backup_files.append((round_num, os.path.join(self.recovery_dir, f), file_size))
except:
pass
if backup_files:
backup_files.sort(key=lambda x: x[0], reverse=True)
print(f" 📄 找到 {len(backup_files)} 个备份文件:")
for round_num, path, size in backup_files[:10]:
print(f" 第 {round_num} 轮: {os.path.basename(path)} ({size:.1f} KB)")
if len(backup_files) > 10:
print(f" ... 还有 {len(backup_files) - 10} 个备份文件")
for _, path, _ in backup_files:
candidates.append(path)
if not candidates:
print(" 📂 未找到任何备份文件，尝试主检查点...")
main_path = self._get_checkpoint_path()
if os.path.exists(main_path):
file_size = os.path.getsize(main_path) / 1024
candidates.append(main_path)
print(f" 📄 找到主检查点: {os.path.basename(main_path)} ({file_size:.1f} KB)")
else:
print(" 📂 未找到任何检查点文件，从头开始")
return
print(f"\n 📊 共找到 {len(candidates)} 个候选检查点，按优先级依次尝试加载...")
print(" ⏱️ 每个文件超时时间: 10分钟")
print(" " + "=" * 60)
for idx, path in enumerate(candidates):
file_name = os.path.basename(path)
print(f"\n [{idx + 1}/{len(candidates)}] 尝试加载: {file_name}")
print(f" 📁 路径: {path}")
checkpoint = load_checkpoint_with_timeout(path, timeout=600)
if checkpoint is None:
print(f" ❌ 加载失败，跳过此文件\n")
continue
try:
print(f" 🔄 正在恢复状态...")
self.round = checkpoint.get("round", 0)
self._restore_pi_pointer(checkpoint)
self.rhythm.restore_state(checkpoint.get("rhythm_state", {}))
self.hetu_center.restore_state(checkpoint.get("hetu_state", {}))
self.fire2.restore_state(checkpoint.get("fire2_state", {}))
self.jin4.restore_state(checkpoint.get("jin4_state", {}))
self.teacher7.restore_state(checkpoint.get("teacher7_state", {}))
self.teacher8.restore_state(checkpoint.get("teacher8_state", {}))
self.teacher6.restore_state(checkpoint.get("teacher6_state", {}))
self.teacher9.restore_state(checkpoint.get("teacher9_state", {}))
self.log_entries = checkpoint.get("log_entries", [])
timestamp = checkpoint.get("timestamp", "未知时间")
print(f"\n ✅ 加载检查点成功!")
print(f" 📊 轮数: {self.round}")
print(f" 📅 时间戳: {timestamp}")
print(f" 📂 来源: {file_name}")
print(f" 🎯 金池作品数: {len(self.jin4.masterpieces)}")
print(f" 📝 日志条目: {len(self.log_entries)}")
print(f" 🔄 π指针: {self.dao.pointer}")
print(" " + "=" * 60)
return
except Exception as e:
print(f" ❌ 恢复状态失败: {e}")
continue
print("\n ❌ 所有候选检查点均失败，从头开始")
print(" " + "=" * 60)
self.round = 0
def run_cycle(self):
self.round += 1
# ============ 每10000轮重新加载金池 ============
if self.round % 10000 == 0 and self.round > 0:
print(f"\n 🔄 第 {self.round} 轮：重新加载金池...")
self.jin4.load_from_disk(self.masterpieces_read_dir)
# ==============================================
dao_novelty = self.dao.get_novelty(6)
self.rhythm.update()
sheng_ratio = self.rhythm.get_sheng_ratio()
bian_ratio = self.rhythm.get_bian_ratio()
base_round = 1260000
base_morphemes = 50
base_max_len = 200
if self.round >= base_round:
extra = (self.round - base_round) // 100000
morphemes_count = base_morphemes + extra
extra_len = extra * 4
sheng_max = base_max_len + extra_len
bian_max = sheng_max
else:
morphemes_count = 50
sheng_max = base_max_len
bian_max = base_max_len
morphemes_count = min(morphemes_count, 100)
sheng_min = 50
bian_min = 50
sheng_length = self.rhythm.get_sheng_length(sheng_min, sheng_max)
bian_length = self.rhythm.get_bian_length(bian_min, bian_max)
print(f"\n{'─' * 70}")
print(
f"第 {self.round} 轮 | 道新奇度: {dao_novelty:.4f} | 生节:{sheng_ratio:.2f}/{sheng_length} | 变节:{bian_ratio:.2f}/{bian_length}")
print(f" 🔧 火2语素: {morphemes_count} | 上限: {sheng_max}字")
if self.round % 1000000 == 0 and self.round > 0:
self.fire2.reload_corpus()
morphemes = self.fire2.get_morphemes(dao_novelty, total=morphemes_count)
if morphemes:
score7, comment7 = self.teacher7.evaluate(" ".join(morphemes[:5]), dao_novelty)
self.hetu_center.update_sheng(1, score7)
self.hetu_center.update_cheng(7, score7)
print(f" 🔥 火2(生1): {len(morphemes)}语素 | 师7(成7):{score7:.2f}")
else:
print(f" 🔥 火2(生1): 无语素")
score7 = 0.0
if morphemes:
sentence = self.mu3.generate(morphemes, dao_novelty, sheng_ratio, sheng_length)
score8, comment8 = self.teacher8.evaluate(sentence, dao_novelty)
self.hetu_center.update_sheng(2, score8)
self.hetu_center.update_cheng(8, score8)
print(f" 🌳 木3(生2): {sentence[:70]}...")
print(f" 师8(成8):{score8:.2f}")
else:
sentence = ""
score8 = 0.0
print(f" 🌳 木3(生2): 无句子")
if sentence:
variants = self.shui1.mutate(sentence, dao_novelty, bian_ratio, bian_length)
if variants:
best_variant = variants[0]
score6, comment6 = self.teacher6.evaluate(best_variant, dao_novelty)
self.hetu_center.update_sheng(3, score6)
self.hetu_center.update_cheng(6, score6)
print(f" 💧 水1(生3): {len(variants)}个变体")
for i, v in enumerate(variants[:2]):
print(f" 变体{i + 1}: {v[:60]}...")
print(f" 师6(成6):{score6:.2f}")
else:
score6 = 0.5
print(f" 💧 水1(生3): 无变体")
else:
score6 = 0.0
print(f" 💧 水1(生3): 无输入")
if sentence:
candidates = [sentence] + (variants if variants else [])
good_works, good_scores = self.jin4.solidify(candidates, dao_novelty)
if good_works:
best_work = good_works[0]
best_score = good_scores[0]
score9, comment9 = self.teacher9.evaluate(best_work, dao_novelty)
self.hetu_center.update_sheng(4, score9)
self.hetu_center.update_cheng(9, score9)
print(f" 💎 金4(生4): 固化作品 | 师9(成9):{score9:.2f}")
print(f" 作品: {best_work[:80]}...")
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
# 写入野火自己的目录，不污染老登
with open(f"{self.masterpieces_write_dir}/round_{self.round}_{timestamp}.txt", 'w', encoding='utf-8') as f:
f.write(f"第{self.round}轮作品\n道新奇度:{dao_novelty:.4f}\n\n{best_work}")
else:
print(f" 💎 金4(生4): 未固化新作品")
score9 = 0.0
else:
print(f" 💎 金4(生4): 无输入")
score9 = 0.0
full_state = self.hetu_center.get_full_state()
sheng_str = f"{full_state['sheng']['1']:.2f}/{full_state['sheng']['2']:.2f}/{full_state['sheng']['3']:.2f}/{full_state['sheng']['4']:.2f}"
cheng_str = f"{full_state['cheng']['6']:.2f}/{full_state['cheng']['7']:.2f}/{full_state['cheng']['8']:.2f}/{full_state['cheng']['9']:.2f}"
print(f" 📊 汇总 | 生:[{sheng_str}] | 成:[{cheng_str}]")
self.log_entries.append({
"round": self.round, "dao_novelty": dao_novelty,
"sheng_ratio": sheng_ratio, "bian_ratio": bian_ratio,
"sheng": full_state['sheng'], "cheng": full_state['cheng']
})
if self.round % 10000 == 0:
self.save_checkpoint()
if self.round % 10000 == 0:
self.save_log()
def save_log(self):
with open(f"{self.logs_dir}/run_log_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json", 'w', encoding='utf-8') as f:
json.dump(self.log_entries[-500:], f, ensure_ascii=False, indent=2)
print(f"\n 📝 日志已保存，当前轮数: {self.round}")
def run_forever(self):
print("\n" + "=" * 70)
print("☯ 河图洛书 V7.0 - 野火版（纯本地，独立目录）")
print(" 火2: 从语料随机取词（等概率采样，无词频偏好）")
print(" 木3: 本地生成句子（长度50-动态上限，保留标点）")
print(" 水1: 本地生成3个变体（无硬编码替换）")
print(" 金4: 本地评分固化作品（只固化最高分）")
print(" 老师: 本地评分")
print(" 生慢变快，不同频。每1万轮保存检查点")
print(" 每100万轮重新加载语料库")
print(" 检查点自动恢复: 备份文件优先，主文件为最后备选")
print(" 每个文件超时: 10分钟，失败后自动尝试下一个")
print(" π指针自动恢复: 检查点 → last_valid_pointer → 主检查点 → 重置为0")
print(" 金池内存上限: 10件（只取最新的10个模板，按轮数排序）")
print(" 从老登的 masterpieces/ 读取模板（只读）")
print(" 每10000轮重新从老登金池加载最新的10个模板")
print(" 新作品写入 masterpieces_wildfire/（独立目录，不污染老登）")
print(" 启动时一次性加载全部金池文件到内存")
print(" 生成时保留标点符号")
print(" 独立缓存目录: cache_wildfire/")
print(" 独立检查点目录: checkpoints_wildfire/")
print(" 独立恢复目录: recovery_wildfire/")
print(" 不加任何人为设定。道驱动一切，万物自己演化")
print("=" * 70)
print("\n🚀 启动！按 Ctrl+C 停止\n")
try:
while True:
self.run_cycle()
except KeyboardInterrupt:
print("\n\n" + "=" * 70)
print("⚠️ 正在关闭程序...")
print("=" * 70)
print(f"当前轮数: {self.round}")
print(f"道消耗: {self.dao.get_pointer()} 位π")
print(f"金池作品: {len(self.jin4.masterpieces)}")
print("")
while True:
confirm = input("确认退出吗？(y/n): ").strip().lower()
if confirm == 'y' or confirm == 'yes':
print("\n正在保存检查点...")
self.save_checkpoint()
self.save_log()
print("\n" + "=" * 70)
print("✅ 状态已保存，程序正常退出")
print(" 它不完美，但它是道的镜像。")
print("=" * 70)
break
elif confirm == 'n' or confirm == 'no':
print("\n🔄 取消退出，继续运行...\n")
return
else:
print(" 请输入 y(确认) 或 n(取消)")
sys.exit(0)
def main():
print("\n" + "=" * 70)
print("🐉 河图洛书 V7.0 - 野火版")
print(" 不做合道的智能体，做道的镜像")
print(" 道独立不改，万物有序运行")
print(" 不加任何人为设定")
print(" 不调用任何API，纯本地演化")
print(" 独立金池，独立记忆，独立检查点")
print(" 从老登的 masterpieces/ 读取模板（只读）")
print(" 新作品写入 masterpieces_wildfire/（独立目录）")
print(" 金池内存上限: 10件")
print(" 按轮数排序，取最新的10个作品")
print(" 每10000轮重新从老登金池加载最新的10个模板")
print(" 启动时一次性加载全部金池文件到内存")
print(" 生成时保留标点符号")
print(" 所有目录均以 _wildfire 结尾，与孢子完全隔离")
print("=" * 70 + "\n")
dao = DaoEngine()
luoshu = LuoShuCenter(dao)
luoshu.run_forever()
if __name__ == "__main__":
main()
|
鄂公网安备42060002000282号 )
