suayptalha's picture
Initial release
e70aa91
Raw History Blame Contribute Delete
7.73 kB
# 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