# Modified by xypai, 2026-10-29: checkpoint path names only. """LFMComputer subclass: one weight file plus full RAM session persistence.""" from pathlib import Path import hashlib import json import os import shutil import torch try: from lfmputer_runtime.computer.model import LFMComputer as BaseComputer from lfmputer_runtime.computer.circuit import CompiledComputer except ModuleNotFoundError: from lfmcomputer.model import LFMComputer as BaseComputer from lfmcomputer.circuit import CompiledComputer from .ram import FixedRAM,RAMState from .bridge import RAMBridge from .files import RAMFiles class RAMLFMComputer(BaseComputer): def __init__(self,language_model,computer,memory_spec=None,manifest=None,ram_spec=None,bridge=None): super().__init__(language_model,computer,memory_spec,manifest) self.ram=FixedRAM(**(ram_spec or {})) self.ram_bridge=bridge self.files=RAMFiles(**self.files.spec) def forward(self,input_ids=None,*,mode="language",ram_state=None,request=None,**kwargs): if mode=="ram":return self.ram(ram_state,request) if mode=="ram_pipeline":return self.ram.pipeline_forward(ram_state,request) return super().forward(input_ids=input_ids,mode=mode,**kwargs) def new_session(self): session=super().new_session() session.ram=self.ram.empty() session.file_layout=self.files.bind(session.memory,self.ram,session.ram) return session def start_program(self,session,name): super().start_program(session,name) if self.ram_bridge is not None:self.ram_bridge.pull(session.computer,self.ram,session.ram) def continue_program(self,session,**kwargs): if self.ram_bridge is not None: if session.computer is None:raise ValueError("No active program") self.ram_bridge.push(session.ram,session.computer) try: return super().continue_program(session,**kwargs) finally: if self.ram_bridge is not None and session.computer is not None: self.ram_bridge.pull(session.computer,self.ram,session.ram) def fingerprint(self): h=hashlib.sha256(super().fingerprint().encode()) h.update(self.ram.fingerprint().encode()) if self.ram_bridge is not None: h.update(json.dumps(self.ram_bridge.spec,sort_keys=True).encode()) for key,value in sorted(self.ram_bridge.state_dict().items()): h.update(key.encode());h.update(value.detach().cpu().contiguous().numpy().tobytes()) return h.hexdigest() def save_session(self,session,path): from safetensors import safe_open from safetensors.torch import save_file,load_file super().save_session(session,path) with safe_open(str(path),framework="pt") as f:metadata=f.metadata() values=load_file(str(path)) for key,value in vars(session.ram).items():values["ram."+key]=value.detach().cpu().contiguous() metadata["ram_format"]="lfmram-state-1" temporary=str(path)+".ram.tmp" save_file(values,temporary,metadata=metadata);os.replace(temporary,path) def load_session(self,path): from safetensors import safe_open from safetensors.torch import load_file session=super().load_session(path) with safe_open(str(path),framework="pt") as f:metadata=f.metadata() if metadata.get("ram_format")!="lfmram-state-1":raise ValueError("Missing RAM session state") values=load_file(str(path),device=str(self.ram.device)) expected_files={key:value.clone() for key,value in vars(session.memory).items()} session.ram.copy_(RAMState(**{key:values["ram."+key] for key in vars(session.ram)})) for key,value in expected_files.items(): if not torch.equal(value,getattr(session.memory,key)): raise ValueError("File/RAM checkpoint coherence mismatch") return session def save_pretrained(self,path,tokenizer=None): info=super().save_pretrained(path,tokenizer) path=Path(path) info["ram_spec"]=self.ram.spec info["ram_bridge"]=self.ram_bridge.spec if self.ram_bridge is not None else None info["ram_architecture"]="fixed hard-address KV bank, FIFO scratchpad, bit-exact convolution delay" (path/"computer_config.json").write_text(json.dumps(info,indent=2)) shutil.copytree(Path(__file__).parent,path/"lfmputer_runtime/memory",dirs_exist_ok=True, ignore=shutil.ignore_patterns("__pycache__")) return info @classmethod def from_pretrained(cls,path,device="cpu",backend="torch"): from accelerate import init_empty_weights from safetensors.torch import load_file from transformers import AutoConfig,AutoModelForCausalLM,AutoTokenizer path=Path(path);cfg=json.loads((path/"computer_config.json").read_text()) if "ram_spec" not in cfg:raise ValueError("Not a RAM-enabled checkpoint; upgrade first") definition=path/"backbone" base_config=AutoConfig.from_pretrained(definition,trust_remote_code=True,local_files_only=True) base_config._attn_implementation=cfg.get("language_attention","eager") with init_empty_weights():language=AutoModelForCausalLM.from_config(base_config,trust_remote_code=True) bridge=RAMBridge(spec=cfg["ram_bridge"]) if cfg.get("ram_bridge") else None model=cls(language,CompiledComputer(cfg["circuit"]),cfg["memory"],cfg["manifest"],cfg["ram_spec"],bridge) values=load_file(str(path/"model.safetensors")) for alias,original in cfg["aliases"].items():values[alias]=values[original] model.load_state_dict(values,strict=True,assign=True);model.language_model.tie_weights() if model.fingerprint()!=cfg["identity"]:raise ValueError("RAM model identity mismatch") model.definition_path=definition model.to(device).eval();model.computer.prepare(backend) model.tokenizer=AutoTokenizer.from_pretrained(path,trust_remote_code=True,local_files_only=True) return model def upgrade_model(model,upstream=None,ram_bytes=8388608,cache_words=256): if upstream is None: upstream=Path(__file__).parents[1]/"third_party/qwenputer/experimental/riscv" bridge=RAMBridge.compile(upstream) upgraded=RAMLFMComputer(model.language_model,model.computer,model.files.spec, {**model.manifest,"ram":"bounded KV RAM with RAM-backed file data and metadata; custom decoder, not pretrained caches"}, {"ram_bytes":ram_bytes,"cache_words":cache_words,"mmio_bytes":256},bridge) upgraded.definition_path=model.definition_path;upgraded.tokenizer=model.tokenizer upgraded.to(model.computer.device).eval() return upgraded def migrate_session(model,old_session): """Preserve v2 file revisions, conversation and paused CPU state on upgrade.""" import copy session=model.new_session() for name,target in vars(session.memory).items(): source=getattr(old_session.memory,name) if source.shape!=target.shape or source.dtype!=target.dtype: raise ValueError("Filesystem layout differs; explicit migration is required") for name,target in vars(session.memory).items():target.copy_(getattr(old_session.memory,name)) session.messages=copy.deepcopy(old_session.messages);session.audit=copy.deepcopy(old_session.audit) session.program=old_session.program;session.trace=copy.deepcopy(old_session.trace) if old_session.computer is not None: session.computer=old_session.computer.clone() if model.ram_bridge is not None:model.ram_bridge.pull(session.computer,model.ram,session.ram) return session