| """Native visual backbones with 41 pretrained binaural tokens; no LoRA.""" |
| import copy,json,sys |
| from pathlib import Path |
| import torch |
| from evaluation.fourtask_common_v3.new_actors import NewActor |
| from training.stereo_backbones_v1.common import configure |
| TOK='<|havs_stereo_pad|>' |
| class StereoModel(torch.nn.Module): |
| def __init__(self,llm,encoder,token_id): |
| super().__init__();self.llm=llm;self.encoder=encoder;self.token_id=token_id |
| d=llm.get_input_embeddings().weight.shape[1] |
| self.encoder_projector=torch.nn.Sequential(torch.nn.Linear(768,d),torch.nn.GELU(),torch.nn.Linear(d,d),torch.nn.LayerNorm(d)).to(device='cuda',dtype=torch.bfloat16) |
| self.config=llm.config;self._audio=None;self.injections=0 |
| self._hook=llm.get_input_embeddings().register_forward_hook(self.inject) |
| def inject(self,module,args,output): |
| mask=args[0]==self.token_id;n=int(mask.sum()) |
| if not n:return output |
| if self._audio is None:raise RuntimeError('Audio slots without an audio recording') |
| assert n==self._audio.shape[0]*41,(n,self._audio.shape) |
| self.injections+=1 |
| return output.masked_scatter(mask.unsqueeze(-1),self._audio.to(output.dtype)) |
| def encode(self,audio): |
| if audio is None:return None |
| assert audio.ndim==3 and tuple(audio.shape[1:])==(2,320000) |
| if not any(p.requires_grad for p in self.encoder.parameters()):self.encoder.eval() |
| return self.encoder_projector(self.encoder(audio.to(next(self.encoder.parameters()).dtype)).audio_tokens) |
| def forward(self,audio=None,**kwargs): |
| self._audio=self.encode(audio);before=self.injections |
| try: |
| result=self.llm(**kwargs) |
| if audio is not None:assert self.injections>before,'Native backbone bypassed stereo embedding injection' |
| return result |
| finally:self._audio=None |
| def generate(self,audio=None,**kwargs): |
| self._audio=self.encode(audio);before=self.injections |
| try: |
| result=self.llm.generate(**kwargs) |
| if audio is not None:assert self.injections>before |
| return result |
| finally:self._audio=None |
| class StereoActor(NewActor): |
| def __init__(self,parent,out,cfg,checkpoint=None): |
| super().__init__(parent,out,cfg['max_pixels']) |
| sys.path.insert(0,cfg['omini_source']) |
| from omini.models.st_audio_encoder import STAudioEncoder |
| from omini.models.norm_fp32 import patch_norm_fp32 |
| initial=json.loads(Path(cfg['initial_audio_config']).read_text()) |
| enc=STAudioEncoder(audio_frontend='binaural',num_classes=initial['encoder_num_classes'],embed_dim=768,depth=12,num_heads=12,audio_bins=40,temporal_layers=initial['temporal_layers'],drop_path_rate=.1) |
| state=torch.load(cfg['encoder_checkpoint'],map_location='cpu',weights_only=True);enc.load_state_dict(state.get('model',state),strict=True) |
| enc=enc.to(device='cuda',dtype=torch.bfloat16);patch_norm_fp32(enc) |
| |
| |
| tied=self.model.get_input_embeddings().weight is self.model.get_output_embeddings().weight |
| emb_sample=self.model.get_input_embeddings().weight[:4].detach().clone();head_sample=self.model.get_output_embeddings().weight[:4].detach().clone() |
| if not tied: |
| self.model.config.tie_word_embeddings=False |
| if hasattr(self.model.config,'text_config'):self.model.config.text_config.tie_word_embeddings=False |
| tok=self.proc.tokenizer;tok.add_tokens([TOK],special_tokens=True) |
| n=max(len(tok),self.model.get_input_embeddings().weight.shape[0]);self.model.resize_token_embeddings(n,mean_resizing=False) |
| assert torch.equal(emb_sample,self.model.get_input_embeddings().weight[:4]) and torch.equal(head_sample,self.model.get_output_embeddings().weight[:4]),'Token addition changed pretrained rows' |
| assert tied==(self.model.get_input_embeddings().weight is self.model.get_output_embeddings().weight),'Token addition changed embedding binding' |
| self.model=StereoModel(self.model,enc,tok.convert_tokens_to_ids(TOK));self.profile=dict(self.profile,audio=True,native_audio_track='vision_stereo') |
| if checkpoint: |
| from training.stereo_backbones_v1.common import restore |
| restore(self.model,checkpoint) |
| def prepare_inputs(self,msgs,pics,audio=None): |
| msgs=copy.deepcopy(msgs);slots=0 |
| for m in msgs: |
| if isinstance(m['content'],list): |
| for c in m['content']: |
| if c['type']=='audio':c.clear();c.update(type='text',text=TOK*41);slots+=1 |
| assert (slots==1)==(audio is not None),(slots,audio is None) |
| b=super().prepare_inputs(msgs,pics,None) |
| if audio is not None: |
| assert audio.shape==(2,320000);b['audio']=torch.as_tensor(audio).unsqueeze(0) |
| assert int((b['input_ids']==self.model.token_id).sum())==41 |
| return b |
|
|
