Download lfmputer_runtime/memory/integration.py from suayptalha/LFMputer-1.7B: direct link, hf CLI and curl.
- Browser
- Download file 7.73 kB
-
https://huggingface.co/suayptalha/LFMputer-1.7B/resolve/main/lfmputer_runtime/memory/integration.py
- Command line
-
hf download hf://suayptalha/LFMputer-1.7B/lfmputer_runtime/memory/integration.py
-
curl -L -o integration.py https://huggingface.co/suayptalha/LFMputer-1.7B/resolve/main/lfmputer_runtime/memory/integration.py
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 | |
| 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 | |