Final fix: Upload model with original __init__ and smart wrapper

config.json

@@ -4,24 +4,20 @@
     "InterfuserForHuggingFace"
   ],
   "img_size": 224,
+  "multi_view_img_size": 112,
+  "patch_size": 8,
   "in_chans": 3,
   "embed_dim": 256,
   "enc_depth": 6,
   "dec_depth": 6,
   "dim_feedforward": 2048,
+  "normalize_before": false,
   "rgb_backbone_name": "r50",
   "lidar_backbone_name": "r18",
   "num_heads": 8,
-  "direct_concat": true,
-  "use_different_backbone": true,
-  "waypoints_pred_head": "gru",
-  "traffic_pred_head_type": "det",
-  "use_view_embed": true,
-  "multi_view_img_size": 112,
-  "patch_size": 8,
-  "normalize_before": false,
   "dropout": 0.1,
   "end2end": false,
+  "direct_concat": true,
   "separate_view_attention": false,
   "separate_all_attention": false,
   "act_layer": null,
@@ -30,7 +26,11 @@
   "with_lidar": false,
   "with_right_left_sensors": true,
   "with_center_sensor": false,
+  "traffic_pred_head_type": "det",
+  "waypoints_pred_head": "gru",
   "reverse_pos": true,
+  "use_different_backbone": true,
+  "use_view_embed": true,
   "use_mmad_pretrain": null,
   "auto_map": {
     "AutoModel": "modeling_interfuser.InterfuserForHuggingFace"

modeling_interfuser.py

@@ -1,6 +1,5 @@
 
 # -*- coding: utf-8 -*-
-# This is a self-contained file for the Interfuser model.
 import torch, math, copy
 from torch import nn, Tensor
 from functools import partial
@@ -14,12 +13,18 @@ try:
 except ImportError:
     raise ImportError("This model requires timm. Please install with 'pip install timm==0.4.12' or a compatible version.")
 
+# =========================================================
+# SECTION 1: ALL HELPER CLASSES (COPIED FROM YOUR NOTEBOOK)
+# =========================================================
+
 def _get_clones(module, N): return nn.ModuleList([copy.deepcopy(module) for _ in range(N)])
+
 def build_attn_mask(mask_type):
     mask=torch.ones((151,151),dtype=torch.bool).cuda()
     if mask_type=="seperate_all":mask[:50,:50]=False;mask[50:67,50:67]=False;mask[67:84,67:84]=False;mask[84:101,84:101]=False;mask[101:151,101:151]=False
     elif mask_type=="seperate_view":mask[:50,:50]=False;mask[50:67,50:67]=False;mask[67:84,67:84]=False;mask[84:101,84:101]=False;mask[101:151,:]=False;mask[:,101:151]=False
     return mask
+
 class HybridEmbed(nn.Module):
     def __init__(self,backbone,img_size=224,patch_size=1,feature_size=None,in_chans=3,embed_dim=768):
         super().__init__();assert isinstance(backbone,nn.Module);img_size=to_2tuple(img_size);patch_size=to_2tuple(patch_size);self.img_size=img_size;self.patch_size=patch_size;self.backbone=backbone
@@ -39,6 +44,7 @@ class HybridEmbed(nn.Module):
         x=self.backbone(x)
         if isinstance(x,(list,tuple)):x=x[-1]
         x=self.proj(x);global_x=torch.mean(x,[2,3],keepdim=False)[:,:,None];return x,global_x
+
 class PositionEmbeddingSine(nn.Module):
     def __init__(self,num_pos_feats=64,temperature=10000,normalize=False,scale=None):
         super().__init__();self.num_pos_feats=num_pos_feats;self.temperature=temperature;self.normalize=normalize
@@ -50,6 +56,7 @@ class PositionEmbeddingSine(nn.Module):
         if self.normalize:eps=1e-6;y_embed=y_embed/(y_embed[:,-1:,:]+eps)*self.scale;x_embed=x_embed/(x_embed[:,:,-1:]+eps)*self.scale
         dim_t=torch.arange(self.num_pos_feats,dtype=torch.float32,device=x.device);dim_t=self.temperature**(2*(dim_t//2)/self.num_pos_feats);pos_x=x_embed[:,:,:,None]/dim_t;pos_y=y_embed[:,:,:,None]/dim_t
         pos_x=torch.stack((pos_x[:,:,:,0::2].sin(),pos_x[:,:,:,1::2].cos()),dim=4).flatten(3);pos_y=torch.stack((pos_y[:,:,:,0::2].sin(),pos_y[:,:,:,1::2].cos()),dim=4).flatten(3);return torch.cat((pos_y,pos_x),dim=3).permute(0,3,1,2)
+
 class TransformerEncoder(nn.Module):
     def __init__(self,encoder_layer,num_layers,norm=None):super().__init__();self.layers=_get_clones(encoder_layer,num_layers);self.num_layers=num_layers;self.norm=norm
     def forward(self,src,mask:Optional[Tensor]=None,src_key_padding_mask:Optional[Tensor]=None,pos:Optional[Tensor]=None):
@@ -57,21 +64,25 @@ class TransformerEncoder(nn.Module):
         for layer in self.layers:output=layer(output,src_mask=mask,src_key_padding_mask=src_key_padding_mask,pos=pos)
         if self.norm is not None:output=self.norm(output)
         return output
+
 class GRUWaypointsPredictor(nn.Module):
     def __init__(self,input_dim,waypoints=10,**kwargs):super().__init__();self.gru=torch.nn.GRU(input_size=input_dim,hidden_size=64,batch_first=True);self.encoder=nn.Linear(2,64);self.decoder=nn.Linear(64,2);self.waypoints=waypoints
     def forward(self,x,target_point):bs=x.shape[0];z=self.encoder(target_point).unsqueeze(0);output,_=self.gru(x,z);output=self.decoder(output.reshape(bs*self.waypoints,-1)).reshape(bs,self.waypoints,2);return torch.cumsum(output,1)
+
 class TransformerEncoderLayer(nn.Module):
     def __init__(self,d_model,nhead,dim_feedforward=2048,dropout=0.1,activation=nn.ReLU(),normalize_before=False,**kwargs):
         super().__init__();self.self_attn=nn.MultiheadAttention(d_model,nhead,dropout=dropout);self.linear1=nn.Linear(d_model,dim_feedforward);self.dropout=nn.Dropout(dropout);self.linear2=nn.Linear(dim_feedforward,d_model);self.norm1=nn.LayerNorm(d_model);self.norm2=nn.LayerNorm(d_model);self.dropout1=nn.Dropout(dropout);self.dropout2=nn.Dropout(dropout);self.activation=activation();self.normalize_before=normalize_before
     def with_pos_embed(self,tensor,pos:Optional[Tensor]):return tensor if pos is None else tensor+pos
     def forward(self,src,src_mask:Optional[Tensor]=None,src_key_padding_mask:Optional[Tensor]=None,pos:Optional[Tensor]=None):
         q=k=self.with_pos_embed(src,pos);src2=self.self_attn(q,k,value=src,attn_mask=src_mask,key_padding_mask=src_key_padding_mask)[0];src=src+self.dropout1(src2);src=self.norm1(src);src2=self.linear2(self.dropout(self.activation(self.linear1(src))));src=src+self.dropout2(src2);src=self.norm2(src);return src
+
 class TransformerDecoderLayer(nn.Module):
     def __init__(self,d_model,nhead,dim_feedforward=2048,dropout=0.1,activation=nn.ReLU(),normalize_before=False,**kwargs):
         super().__init__();self.self_attn=nn.MultiheadAttention(d_model,nhead,dropout=dropout);self.multihead_attn=nn.MultiheadAttention(d_model,nhead,dropout=dropout);self.linear1=nn.Linear(d_model,dim_feedforward);self.dropout=nn.Dropout(dropout);self.linear2=nn.Linear(dim_feedforward,d_model);self.norm1=nn.LayerNorm(d_model);self.norm2=nn.LayerNorm(d_model);self.norm3=nn.LayerNorm(d_model);self.dropout1=nn.Dropout(dropout);self.dropout2=nn.Dropout(dropout);self.dropout3=nn.Dropout(dropout);self.activation=activation();self.normalize_before=normalize_before
     def with_pos_embed(self,tensor,pos:Optional[Tensor]):return tensor if pos is None else tensor+pos
     def forward(self,tgt,memory,tgt_mask:Optional[Tensor]=None,memory_mask:Optional[Tensor]=None,tgt_key_padding_mask:Optional[Tensor]=None,memory_key_padding_mask:Optional[Tensor]=None,pos:Optional[Tensor]=None,query_pos:Optional[Tensor]=None):
         q=k=self.with_pos_embed(tgt,query_pos);tgt2=self.self_attn(q,k,value=tgt,attn_mask=tgt_mask,key_padding_mask=tgt_key_padding_mask)[0];tgt=tgt+self.dropout1(tgt2);tgt=self.norm1(tgt);tgt2=self.multihead_attn(query=self.with_pos_embed(tgt,query_pos),key=self.with_pos_embed(memory,pos),value=memory,attn_mask=memory_mask,key_padding_mask=memory_key_padding_mask)[0];tgt=tgt+self.dropout2(tgt2);tgt=self.norm2(tgt);tgt2=self.linear2(self.dropout(self.activation(self.linear1(tgt))));tgt=tgt+self.dropout3(tgt2);tgt=self.norm3(tgt);return tgt
+
 class TransformerDecoder(nn.Module):
     def __init__(self,decoder_layer,num_layers,norm=None,return_intermediate=False,**kwargs):
         super().__init__();self.layers=_get_clones(decoder_layer,num_layers);self.num_layers=num_layers;self.norm=norm;self.return_intermediate=return_intermediate
@@ -80,6 +91,10 @@ class TransformerDecoder(nn.Module):
         for layer in self.layers:output=layer(output,memory,**kwargs)
         if self.norm is not None:output=self.norm(output)
         return output.unsqueeze(0)
+
+# =========================================================
+# SECTION 2: THE ORIGINAL INTERFUSER MODEL (UNMODIFIED)
+# =========================================================
 class Interfuser(nn.Module):
     def __init__(self,img_size=224,multi_view_img_size=112,patch_size=8,in_chans=3,embed_dim=768,enc_depth=6,dec_depth=6,dim_feedforward=2048,normalize_before=False,rgb_backbone_name="r26",lidar_backbone_name="r26",num_heads=8,norm_layer=None,dropout=0.1,end2end=False,direct_concat=True,separate_view_attention=False,separate_all_attention=False,act_layer=None,weight_init="",freeze_num=-1,with_lidar=False,with_right_left_sensors=True,with_center_sensor=False,traffic_pred_head_type="det",waypoints_pred_head="heatmap",reverse_pos=True,use_different_backbone=False,use_view_embed=True,use_mmad_pretrain=None):
         super().__init__();self.traffic_pred_head_type=traffic_pred_head_type;self.num_features=self.embed_dim=embed_dim;norm_layer=norm_layer or partial(nn.LayerNorm,eps=1e-6);act_layer=act_layer or nn.GELU;self.reverse_pos=reverse_pos;self.waypoints_pred_head=waypoints_pred_head;self.with_lidar=with_lidar;self.with_right_left_sensors=with_right_left_sensors;self.with_center_sensor=with_center_sensor;self.direct_concat=direct_concat;self.separate_view_attention=separate_view_attention;self.separate_all_attention=separate_all_attention;self.end2end=end2end;self.use_view_embed=use_view_embed
@@ -101,13 +116,10 @@ class Interfuser(nn.Module):
         else:front_image_token=front_image_token+self.position_encoding(front_image_token)
         front_image_token=front_image_token.flatten(2).permute(2,0,1);front_image_token_global=(front_image_token_global+self.view_embed[:,:,0,:]+self.global_embed[:,:,0:1]).permute(2,0,1);features.extend([front_image_token,front_image_token_global])
         if self.with_right_left_sensors:
-            left_image_token,left_image_token_global=self.rgb_patch_embed(left_image)
-            if self.use_view_embed:left_image_token=left_image_token+self.view_embed[:,:,1:2,:]+self.position_encoding(left_image_token)
-            else:left_image_token=left_image_token+self.position_encoding(left_image_token)
+            left_image_token,left_image_token_global=self.rgb_patch_embed(left_image);right_image_token,right_image_token_global=self.rgb_patch_embed(right_image)
+            if self.use_view_embed:left_image_token=left_image_token+self.view_embed[:,:,1:2,:]+self.position_encoding(left_image_token);right_image_token=right_image_token+self.view_embed[:,:,2:3,:]+self.position_encoding(right_image_token)
+            else:left_image_token=left_image_token+self.position_encoding(left_image_token);right_image_token=right_image_token+self.position_encoding(right_image_token)
             left_image_token=left_image_token.flatten(2).permute(2,0,1);left_image_token_global=(left_image_token_global+self.view_embed[:,:,1,:]+self.global_embed[:,:,1:2]).permute(2,0,1)
-            right_image_token,right_image_token_global=self.rgb_patch_embed(right_image)
-            if self.use_view_embed:right_image_token=right_image_token+self.view_embed[:,:,2:3,:]+self.position_encoding(right_image_token)
-            else:right_image_token=right_image_token+self.position_encoding(right_image_token)
             right_image_token=right_image_token.flatten(2).permute(2,0,1);right_image_token_global=(right_image_token_global+self.view_embed[:,:,2,:]+self.global_embed[:,:,2:3]).permute(2,0,1)
             features.extend([left_image_token,left_image_token_global,right_image_token,right_image_token_global])
         return torch.cat(features,0)
@@ -124,6 +136,9 @@ class Interfuser(nn.Module):
         velocity=measurements[:,6:7].unsqueeze(-1).repeat(1,400,32);traffic_feature_with_vel=torch.cat([hs[:,:400],velocity],dim=2);traffic=self.traffic_pred_head(traffic_feature_with_vel)
         return traffic,waypoints,is_junction,traffic_light_state,stop_sign,hs[:,:400]
 
+# =========================================================
+# SECTION 3: HUGGING FACE WRAPPER CLASSES
+# =========================================================
 class InterfuserConfig(PretrainedConfig):
     model_type="interfuser"
     def __init__(self, **kwargs):
@@ -135,9 +150,11 @@ class InterfuserForHuggingFace(PreTrainedModel):
     config_class = InterfuserConfig
     def __init__(self, config: InterfuserConfig):
         super().__init__(config)
+        # ** الغلاف الذكي: يقرأ كل معامل من config ويمرره إلى Interfuser **
         init_args = config.to_dict()
-        # Remove keys that are not in the original __init__
+        # نزيل المفاتيح التي لا تخص Interfuser.__init__
         for key in ["model_type", "architectures", "auto_map", "transformers_version"]: init_args.pop(key, None)
+        # نستدعي النموذج الأصلي بكل معاملاته
         self.interfuser = Interfuser(**init_args)
     def forward(self, rgb, rgb_left, rgb_right, rgb_center, lidar, measurements, target_point, **kwargs):
         inputs_dict = {'rgb':rgb, 'rgb_left':rgb_left, 'rgb_right':rgb_right, 'rgb_center':rgb_center, 'lidar':lidar, 'measurements':measurements, 'target_point':target_point}