Download modeling_lfmputer.py from suayptalha/LFMputer-1.7B: direct link, hf CLI and curl.
- Browser
- Download file 11.5 kB
-
https://huggingface.co/suayptalha/LFMputer-1.7B/resolve/main/modeling_lfmputer.py
- Command line
-
hf download hf://suayptalha/LFMputer-1.7B/modeling_lfmputer.py
-
curl -L -o modeling_lfmputer.py https://huggingface.co/suayptalha/LFMputer-1.7B/resolve/main/modeling_lfmputer.py
11.5 kB
| # LFMputer decoder runtime. Source numerical operations are preserved. | |
| """Single-model conditional LoRA and circuit-internal binary switch. | |
| One request at a time. Routing is an internal frozen, tool-free backbone pass; | |
| this is conditional model execution, not an external classifier service. | |
| """ | |
| from pathlib import Path | |
| import contextlib, json, math, shutil, sys, time | |
| import torch | |
| from torch import nn | |
| import torch.nn.functional as F | |
| from lfmputer_runtime.analytics.model import AnalyticLFMComputer | |
| from lfmputer_runtime.analytics.engine import AnalyticEngine, FEATURES | |
| class BinarySwitch(nn.Module): | |
| def __init__(self, hidden, width=128): | |
| super().__init__() | |
| self.net=nn.Sequential(nn.LayerNorm(hidden),nn.Linear(hidden,width),nn.SiLU(),nn.Linear(width,1)) | |
| nn.init.zeros_(self.net[-1].weight);nn.init.constant_(self.net[-1].bias,-2.) | |
| self.register_buffer('threshold',torch.tensor(.5)) | |
| def forward(self, features):return self.net(features.float()).squeeze(-1) | |
| class GatedAnalyticEngine(AnalyticEngine): | |
| def prepare(self): | |
| # Preserve the circuit precision/frozen-weight contract; the switch alone learns. | |
| torch.set_float32_matmul_precision('highest') | |
| if self.device.type=='cuda':torch.backends.cuda.matmul.allow_tf32=False | |
| for name,p in self.named_parameters(): | |
| if name.startswith('switch.'):continue | |
| double=name.startswith(('layers.polynomial.','layers.units.units.','layers.units.combine.')) | |
| if p.dtype!=(torch.float64 if double else torch.float32) or p.requires_grad: | |
| raise TypeError('Circuit precision/frozen-weight violation: '+name) | |
| class ConditionalLoRA(nn.Module): | |
| def __init__(self, base, rank=8, alpha=16): | |
| super().__init__();self.base=base;self.rank=rank;self.scale=alpha/rank;self.active=False | |
| self.A=nn.Parameter(torch.empty(rank,base.in_features,device=base.weight.device,dtype=torch.float32)) | |
| self.B=nn.Parameter(torch.zeros(base.out_features,rank,device=base.weight.device,dtype=torch.float32)) | |
| nn.init.kaiming_uniform_(self.A,a=math.sqrt(5)) | |
| def weight(self):return self.base.weight | |
| def bias(self):return self.base.bias | |
| def forward(self,x): | |
| y=self.base(x) | |
| if self.active: | |
| # Compute adapter branch in FP32, preserving frozen BF16 base weights. | |
| z=F.linear(F.linear(x.float(),self.A),self.B)*self.scale | |
| y=y+z.to(y.dtype) | |
| return y | |
| def install_lora(lm, rank, alpha, targets): | |
| found=[] | |
| for name,module in list(lm.named_modules()): | |
| if isinstance(module,nn.Linear) and name.rsplit('.',1)[-1] in targets: | |
| parent,key=name.rsplit('.',1);setattr(lm.get_submodule(parent),key,ConditionalLoRA(module,rank,alpha));found.append(name) | |
| if not found:raise RuntimeError('No matching LoRA modules; architecture mismatch') | |
| return found | |
| def torch_conv_training(lm): | |
| # Use the model's differentiable PyTorch convolution, avoiding inference-only kernels. | |
| module=sys.modules[type(lm).__module__] | |
| if hasattr(module,'can_use_lfm3_conv'):module.can_use_lfm3_conv=lambda *a,**k:False | |
| class LFMputer(AnalyticLFMComputer): | |
| def attach(cls, base, rank=8, alpha=16, width=128, | |
| targets=('q_proj','v_proj','o_proj','w1','w2','w3')): | |
| base.__class__=cls | |
| for p in base.parameters():p.requires_grad_(False) | |
| torch_conv_training(base.language_model) | |
| base.switch_spec=dict(rank=rank,alpha=alpha,width=width,targets=list(targets),version=1) | |
| base.lora_names=install_lora(base.language_model,rank,alpha,set(targets)) | |
| base.analytics.__class__=GatedAnalyticEngine | |
| base.analytics.switch=BinarySwitch(base.language_model.config.hidden_size,width).to(next(base.language_model.parameters()).device) | |
| base._route_context=False;base._route_force=None | |
| base.context_limit=8192 | |
| return base | |
| def adapters(self, enabled): | |
| for m in self.language_model.modules(): | |
| if isinstance(m,ConditionalLoRA):m.active=bool(enabled) | |
| def plain_messages(self,prompt):return [{'role':'user','content':prompt}] | |
| def feature_batch(self,prompts,max_length=4096): | |
| tok=self.tokenizer | |
| texts=[tok.apply_chat_template(self.plain_messages(p),tokenize=False,add_generation_prompt=True,enable_thinking=False) for p in prompts] | |
| enc=tok(texts,return_tensors='pt',padding=True,truncation=False,add_special_tokens=False) | |
| if enc.input_ids.shape[1]>max_length:raise ValueError('Gate input exceeds max_length; do not silently truncate') | |
| enc=enc.to(next(self.language_model.parameters()).device) | |
| self.adapters(False) | |
| was=self.language_model.training;self.language_model.eval() | |
| try: | |
| with torch.no_grad(): | |
| h=self.language_model.model(**enc,use_cache=False).last_hidden_state | |
| positions=torch.arange(h.shape[1],device=h.device)[None].expand(h.shape[0],-1) | |
| last=positions.masked_fill(enc.attention_mask==0,-1).max(-1).values | |
| last_features=h[torch.arange(h.shape[0],device=h.device),last].detach().float() | |
| if self.switch_spec.get('feature_pooling','last')=='last_mean': | |
| weights=enc.attention_mask[...,None].float() | |
| mean_features=(h.float()*weights).sum(1)/weights.sum(1).clamp_min(1) | |
| return torch.cat((last_features,mean_features),-1) | |
| return last_features | |
| finally:self.language_model.train(was) | |
| def forward(self,input_ids=None,*,mode='language',prompt=None,force_gate=None,**kwargs): | |
| if mode=='route': | |
| f=self.feature_batch([prompt]);logit=self.analytics.switch(f) | |
| return {'logits':logit,'probability':logit.sigmoid()} | |
| if mode=='chat': | |
| return self._chat_inside(prompt,force_gate=force_gate,**kwargs) | |
| if mode in ('analytic','analytic_tensor') and not self._route_context: | |
| raise RuntimeError('Circuits are disabled outside an open model request') | |
| return super().forward(input_ids=input_ids,mode=mode,**kwargs) | |
| def _chat_inside(self,prompt,force_gate=None,max_new_tokens=512,total_new_tokens=1536,max_calls=3): | |
| started=time.perf_counter() | |
| self.eval();r=self.forward(mode='route',prompt=prompt) | |
| probability=float(r['probability'][0]);opened=probability>=float(self.analytics.switch.threshold) | |
| if force_gate is not None:opened=bool(force_gate) | |
| self.adapters(opened);self._route_context=opened | |
| self.analytics.set_enabled(FEATURES if opened else ()) | |
| self.include_computer_tools=opened;self.external_tools=[];self.external_dispatch={} | |
| before=self.analytics.calls.clone() | |
| try: | |
| if not opened: | |
| # Exactly tool-free input; no circuit schemas or extra system prompt. | |
| enc=self.tokenizer.apply_chat_template(self.plain_messages(prompt),tokenize=True, | |
| add_generation_prompt=True,enable_thinking=False,return_dict=True,return_tensors='pt') | |
| enc=enc.to(next(self.language_model.parameters()).device) | |
| allowance=min(total_new_tokens,self.context_limit-enc.input_ids.shape[1]) | |
| if allowance<=0:raise RuntimeError('Configured context budget exhausted') | |
| out=self.language_model.generate(**enc,max_new_tokens=allowance,do_sample=False,repetition_penalty=1.1,logits_to_keep=1, | |
| pad_token_id=self.tokenizer.pad_token_id,eos_token_id=self.language_model.generation_config.eos_token_id) | |
| answer=self.tokenizer.decode(out[0,enc.input_ids.shape[1]:],skip_special_tokens=True) | |
| suffix=out[0,enc.input_ids.shape[1]:] | |
| eos=self.language_model.generation_config.eos_token_id or self.tokenizer.eos_token_id | |
| eos=[eos] if isinstance(eos,int) else eos | |
| finished=bool(suffix.numel() and int(suffix[-1]) in eos) | |
| result={'answer':answer,'events':[],'generated_tokens':int(suffix.numel()),'prompt_tokens':enc.input_ids.shape[1],'truncated':not finished,'stop_reason':'eos' if finished else 'generation_budget','seconds':time.perf_counter()-started} | |
| else: | |
| result=super().chat(super().new_session(),prompt,max_new_tokens=max_new_tokens, | |
| total_new_tokens=total_new_tokens,max_calls=max_calls,verbose=False) | |
| result.update(gate_open=opened,gate_probability=probability, | |
| circuit_calls={n:int(v) for n,v in zip(FEATURES,(self.analytics.calls-before).tolist())}) | |
| return result | |
| finally: | |
| self.adapters(False);self._route_context=False;self.analytics.set_enabled(()) | |
| def save_pretrained(self,path): | |
| from lfmputer_runtime.checkpoint import save_checkpoint | |
| return save_checkpoint(self,path) | |
| def load(cls,path,device='cuda'): | |
| from accelerate import init_empty_weights | |
| from safetensors.torch import load_file | |
| from transformers import AutoConfig,AutoModelForCausalLM,AutoTokenizer | |
| from lfmputer_runtime.analytics.model import CompiledComputer,RAMBridge | |
| path=Path(path);cfg=json.loads((path/'computer_config.json').read_text());spec=json.loads((path/'routing_config.json').read_text()) | |
| config=AutoConfig.from_pretrained(path/'backbone',trust_remote_code=True,local_files_only=True) | |
| config._attn_implementation='sdpa' | |
| with init_empty_weights(): | |
| lm=AutoModelForCausalLM.from_config(config,trust_remote_code=True) | |
| bridge=RAMBridge(spec=cfg['ram_bridge']) if cfg.get('ram_bridge') else None | |
| base=AnalyticLFMComputer(lm,CompiledComputer(cfg['circuit']),cfg['memory'],cfg['manifest'],cfg['ram_spec'],bridge,cfg['analytic_spec']) | |
| # Attach creates a CPU switch; never try to move a parameter onto a meta device. | |
| for p in base.parameters():p.requires_grad_(False) | |
| base.__class__=cls;base.switch_spec={k:spec[k] for k in ['rank','alpha','width','targets','version']} | |
| base.switch_spec['feature_pooling']=spec.get('feature_pooling','last') | |
| torch_conv_training(lm);base.lora_names=install_lora(lm,spec['rank'],spec['alpha'],set(spec['targets'])) | |
| base.analytics.__class__=GatedAnalyticEngine;base.analytics.switch=BinarySwitch(config.hidden_size*(2 if spec.get('feature_pooling')=='last_mean' else 1),spec['width']) | |
| from lfmputer_runtime.decoder import install_decoder_stack, logical_to_decoder_key | |
| install_decoder_stack(base) | |
| values=load_file(str(path/'model.safetensors')) | |
| for alias,original in spec['aliases'].items():values[alias]=values[original] | |
| values={logical_to_decoder_key(k,base.decoder_layout):v for k,v in values.items()} | |
| base.load_state_dict(values,strict=True,assign=True);base.language_model.tie_weights() | |
| base._route_context=False;base._route_force=None;base.context_limit=8192 | |
| base.tokenizer=AutoTokenizer.from_pretrained(path,config=config,local_files_only=True,trust_remote_code=True,fix_mistral_regex=False) | |
| base.definition_path=path/'backbone';base.source_snapshot=str(path);base.source_revision=spec['source_revision'] | |
| base.to(device).eval();base.computer.prepare('torch');base.analytics.prepare();base.adapters(False) | |
| return base | |