Add model architecture code

modeling_interfuser.py

@@ -1,5 +1,3 @@
-# modeling_interfuser.py
-
 import torch
 from torch import nn
 import torch.nn.functional as F
@@ -9,74 +7,170 @@ from functools import partial
 import math
 from collections import OrderedDict
 import copy
-from typing import Optional, List, Tuple, Union
+from typing import Optional, List, Tuple
 from torch import Tensor
 from dataclasses import dataclass
-import numpy as np
+import numpy as np # مطلوب لـ SpatialSoftmax
 
 # ==============================================================================
-# ملاحظة: هذا الملف يحتوي على كل التعريفات اللازمة لتشغيل النموذج.
+# ملاحظة: تم نسخ جميع الكلاسات المساعدة من الكود الأصلي هنا
+# لضمان أن يكون الكود قابلاً للتشغيل بشكل مستقل.
 # ==============================================================================
 
-# --- الكلاسات الوهمية للـ Backbones ---
-# في الاستخدام الحقيقي، يجب استبدالها بالشبكات الحقيقية من مكتبة مثل timm.
+# من الأفضل استيرادها من المصدر الأصلي إذا كان ذلك متاحًا
+# لضمان قابلية النقل الكاملة، نعرّفها هنا.
+# from InterFuser.interfuser.timm.models.layers import to_2tuple
+# from InterFuser.interfuser.timm.models.resnet import resnet50d, resnet26d, resnet18d
+# نظرًا لأن هذه الوحدات غير متوفرة مباشرة، سنستخدم كلاسات وهمية (placeholders)
+# للسماح بتشغيل الكود. في الاستخدام الحقيقي، يجب استيرادها بشكل صحيح.
+
+def to_2tuple(x):
+    if isinstance(x, tuple):
+        return x
+    return (x, x)
+
+# DummyResNet المحسّن
 class DummyResNet(nn.Module):
+    """
+    كلاس وهمي محسن لـ ResNet.
+    يقوم بتغيير عدد القنوات المخرجة بناءً على الاسم المعطى له.
+    """
     def __init__(self, name="r26", **kwargs):
         super().__init__()
-        out_channels = 512 if name == "r18" else 2048
+        # تحديد عدد القنوات بناءً على اسم الشبكة
+        if name == "r18":
+            out_channels = 512
+        else: # r26, r50, etc.
+            out_channels = 2048
+
+        print(f"Building DummyResNet '{name}' with {out_channels} output channels.")
+
         self.features = nn.Sequential(
             nn.Conv2d(kwargs.get('in_chans', 3), out_channels, kernel_size=7, stride=2, padding=3),
             nn.AdaptiveAvgPool2d((1, 1))
         )
         self.num_features = out_channels
+
     def forward(self, x):
         return [self.features(x)]
 
-def resnet18d(**kwargs): return DummyResNet(name="r18", **kwargs)
-def resnet26d(**kwargs): return DummyResNet(name="r26", **kwargs)
-def resnet50d(**kwargs): return DummyResNet(name="r50", **kwargs)
-def to_2tuple(x): return (x, x) if not isinstance(x, tuple) else x
+# قم بتحديث كيفية تعريف الشبكات لاستخدام الكلاس الجديد
+def resnet18d(**kwargs):
+    return DummyResNet(name="r18", **kwargs)
 
-# --- جميع الكلاسات المساعدة ---
-# (HybridEmbed, PositionEmbeddingSine, TransformerEncoder, SpatialSoftmax, etc.)
-# تم نسخها بالكامل هنا.
+def resnet26d(**kwargs):
+    return DummyResNet(name="r26", **kwargs)
+
+def resnet50d(**kwargs):
+    return DummyResNet(name="r50", **kwargs)
+# ==============================================================================
+# القسم 1: جميع الكلاسات المساعدة من الكود الأصلي
+# ==============================================================================
+
+# 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
+#         if feature_size is None:
+#             with torch.no_grad():
+#                 training = backbone.training
+#                 if training:
+#                     backbone.eval()
+#                 o = self.backbone(torch.zeros(1, in_chans, img_size[0], img_size[1]))
+#                 if isinstance(o, (list, tuple)):
+#                     o = o[-1]
+#                 feature_size = o.shape[-2:]
+#                 feature_dim = o.shape[1]
+#                 backbone.train(training)
+#         else:
+#             feature_size = to_2tuple(feature_size)
+#             if hasattr(self.backbone, "feature_info"):
+#                 feature_dim = self.backbone.feature_info.channels()[-1]
+#             else:
+#                 feature_dim = self.backbone.num_features
+
+#         self.proj = nn.Conv2d(feature_dim, embed_dim, kernel_size=1, stride=1)
+# هذا هو الكود الجديد الذي يجب أن تستخدمه
 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__()
-        self.img_size = to_2tuple(img_size)
+
+        # --- بداية التعديلات ---
+        # تعديل 1: تأكد من أن img_size هو tuple للوصول الآمن إلى عناصره
+        if isinstance(img_size, int):
+            img_size = (img_size, img_size)
+        # --- نهاية التعديل 1 ---
+
+        self.img_size = img_size
         self.patch_size = to_2tuple(patch_size)
         self.backbone = backbone
+
         if feature_size is None:
             with torch.no_grad():
                 training = backbone.training
-                if training: backbone.eval()
-                o = self.backbone(torch.zeros(1, in_chans, img_size[0], img_size[1]))
-                if isinstance(o, (list, tuple)): o = o[-1]
+                if training:
+                    backbone.eval()
+                
+                # تعديل 2: حاول تمرير المدخلات مع حجم الصورة المحدد
+                try:
+                    o = self.backbone(torch.zeros(1, in_chans, self.img_size[0], self.img_size[1]))
+                except Exception as e:
+                    # إذا فشل، حاول بحجم قياسي كخطة بديلة
+                    print(f"Warning: Failed to infer feature size with img_size {self.img_size}. Retrying with 224x224. Error: {e}")
+                    o = self.backbone(torch.zeros(1, in_chans, 224, 224))
+
+                # تعديل 3: التعامل الآمن مع مخرجات الـ backbone
+                if isinstance(o, (list, tuple)):
+                    o = o[-1]
+                # الآن، من المفترض أن يكون 'o' هو Tensor الذي نريده
+
                 feature_dim = o.shape[1]
                 backbone.train(training)
         else:
             feature_dim = self.backbone.num_features
+        
         self.proj = nn.Conv2d(feature_dim, embed_dim, kernel_size=1, stride=1)
+    # --- نهاية كل التعديلات ---
+
     def forward(self, x):
         x = self.backbone(x)
-        if isinstance(x, (list, tuple)): x = x[-1]
+        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
 
-# ... (يتم لصق بقية الكلاسات المساعدة هنا: PositionEmbeddingSine, Transformer*...)
-# (للاختصار، لن أعرضها كلها مرة أخرى، ولكن يجب أن تكون كلها في هذا الملف)
+
 class PositionEmbeddingSine(nn.Module):
-    def __init__( self, num_pos_feats=64, temperature=10000, normalize=False, scale=None):
+    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
-        if scale is not None and normalize is False: raise ValueError("normalize should be True if scale is passed")
-        if scale is None: scale = 2 * math.pi
+        if scale is not None and normalize is False:
+            raise ValueError("normalize should be True if scale is passed")
+        if scale is None:
+            scale = 2 * math.pi
         self.scale = scale
+
     def forward(self, tensor):
-        x = tensor; bs, _, h, w = x.shape
+        x = tensor
+        bs, _, h, w = x.shape
         not_mask = torch.ones((bs, h, w), device=x.device)
         y_embed = not_mask.cumsum(1, dtype=torch.float32)
         x_embed = not_mask.cumsum(2, dtype=torch.float32)
@@ -84,14 +178,22 @@ class PositionEmbeddingSine(nn.Module):
             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)
+
+        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)
         pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
         return pos
-# (لصق باقي الكلاسات المساعدة هنا)
+
+
 class TransformerEncoder(nn.Module):
     def __init__(self, encoder_layer, num_layers, norm=None):
         super().__init__()
@@ -322,26 +424,80 @@ def build_attn_mask(mask_type, device):
         mask[84:101, 84:101] = False; mask[101:151, :] = False; mask[:, 101:151] = False
     return mask
 
-# --- تعريف فئة الإعدادات (Config) ---
+# ==============================================================================
+# القسم 2: تعريف فئة الإعدادات (Config)
+# ==============================================================================
+
 class InterfuserConfig(PretrainedConfig):
     model_type = "interfuser"
-    def __init__(self, img_size=224, embed_dim=256, enc_depth=6, dec_depth=6, num_heads=8, rgb_backbone_name="r26", lidar_backbone_name="r18", use_different_backbone=True, waypoints_pred_head="gru", **kwargs):
+
+    def __init__(
+        self,
+        img_size=224,
+        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,
+        dropout=0.1,
+        end2end=False,
+        direct_concat=False, # تم تغيير القيمة الافتراضية لتجنب التعقيد
+        separate_view_attention=False,
+        separate_all_attention=False,
+        freeze_num=-1,
+        with_lidar=True,
+        with_right_left_sensors=True,
+        with_center_sensor=True,
+        traffic_pred_head_type="det",
+        waypoints_pred_head="linear-sum",
+        reverse_pos=True,
+        use_different_backbone=False,
+        use_view_embed=True,
+        use_mmad_pretrain=None,
+        **kwargs
+    ):
         super().__init__(**kwargs)
         self.img_size = img_size
+        self.patch_size = patch_size
+        self.in_chans = in_chans
         self.embed_dim = embed_dim
         self.enc_depth = enc_depth
         self.dec_depth = dec_depth
-        self.num_heads = num_heads
+        self.dim_feedforward = dim_feedforward
+        self.normalize_before = normalize_before
         self.rgb_backbone_name = rgb_backbone_name
         self.lidar_backbone_name = lidar_backbone_name
-        self.use_different_backbone = use_different_backbone
+        self.num_heads = num_heads
+        self.dropout = dropout
+        self.end2end = end2end
+        self.direct_concat = direct_concat
+        self.separate_view_attention = separate_view_attention
+        self.separate_all_attention = separate_all_attention
+        self.freeze_num = freeze_num
+        self.with_lidar = with_lidar
+        self.with_right_left_sensors = with_right_left_sensors
+        self.with_center_sensor = with_center_sensor
+        self.traffic_pred_head_type = traffic_pred_head_type
         self.waypoints_pred_head = waypoints_pred_head
-        # أضف أي إعدادات أخرى ضرورية هنا
-        self.patch_size=8; self.in_chans=3; self.dim_feedforward=2048; self.normalize_before=False; self.dropout=0.1; self.end2end=False; self.direct_concat=False; self.separate_view_attention=False; self.separate_all_attention=False; self.freeze_num=-1; self.with_lidar=True; self.with_right_left_sensors=True; self.with_center_sensor=True; self.traffic_pred_head_type="det"; self.reverse_pos=True; self.use_view_embed=True; self.use_mmad_pretrain=None
+        self.reverse_pos = reverse_pos
+        self.use_different_backbone = use_different_backbone
+        self.use_view_embed = use_view_embed
+        self.use_mmad_pretrain = use_mmad_pretrain
+
+# ==============================================================================
+# القسم 3: تعريف فئة مخرجات النموذج (ModelOutput)
+# ==============================================================================
 
-# --- تعريف فئة مخرجات النموذج (ModelOutput) ---
 @dataclass
 class InterfuserOutput(ModelOutput):
+    """
+    كلاس لتخزين مخرجات نموذج Interfuser بطريقة منظمة.
+    """
     waypoints: torch.FloatTensor = None
     traffic_predictions: Optional[torch.FloatTensor] = None
     is_junction: Optional[torch.FloatTensor] = None
@@ -349,13 +505,15 @@ class InterfuserOutput(ModelOutput):
     stop_sign: Optional[torch.FloatTensor] = None
     traffic_features: Optional[torch.FloatTensor] = None
 
-# --- تعريف النموذج الأصلي (Interfuser) ---
-# (يجب لصق كلاس Interfuser بالكامل هنا)
+# ==============================================================================
+# القسم 4: النموذج الأصلي (تم تعديل __init__ ليقبل config)
+# ==============================================================================
+
 class Interfuser(nn.Module):
     def __init__(self, config: InterfuserConfig):
         super().__init__()
         self.config = config
-        
+
         # استخلاص المتغيرات من كائن الـ config
         embed_dim = config.embed_dim
         norm_layer = partial(nn.LayerNorm, eps=1e-6)
@@ -365,7 +523,7 @@ class Interfuser(nn.Module):
         self.traffic_pred_head_type = config.traffic_pred_head_type
         self.waypoints_pred_head = config.waypoints_pred_head
         self.end2end = config.end2end
-        
+
         # ... باقي متغيرات الـ init من الكود الأصلي
         self.direct_concat = config.direct_concat
         self.with_center_sensor = config.with_center_sensor
@@ -374,7 +532,7 @@ class Interfuser(nn.Module):
         self.use_view_embed = config.use_view_embed
         self.separate_view_attention = config.separate_view_attention
         self.separate_all_attention = config.separate_all_attention
-        
+
         if self.direct_concat:
             in_chans = config.in_chans * 4
             self.with_center_sensor = False
@@ -392,11 +550,11 @@ class Interfuser(nn.Module):
         # تعريف الـ backbones (استخدام DummyResNet كمثال)
         # في الاستخدام الحقيقي، استبدل هذا بالتحميل الفعلي للشبكات
         backbone_map = {"r50": resnet50d, "r26": resnet26d, "r18": resnet18d}
-        
+
         # RGB Backbone
         rgb_backbone_class = backbone_map.get(config.rgb_backbone_name, resnet26d)
         self.rgb_backbone = rgb_backbone_class(pretrained=True, in_chans=in_chans, features_only=True, out_indices=[4])
-        
+
         # Lidar Backbone
         if config.use_different_backbone:
             lidar_backbone_class = backbone_map.get(config.lidar_backbone_name, resnet26d)
@@ -435,21 +593,21 @@ class Interfuser(nn.Module):
         elif self.waypoints_pred_head == "gru-command": self.waypoints_generator = GRUWaypointsPredictorWithCommand(embed_dim)
         elif self.waypoints_pred_head == "linear": self.waypoints_generator = LinearWaypointsPredictor(embed_dim, cumsum=False)
         elif self.waypoints_pred_head == "linear-sum": self.waypoints_generator = LinearWaypointsPredictor(embed_dim, cumsum=True)
-        
+
         self.junction_pred_head = nn.Linear(embed_dim, 2)
         self.traffic_light_pred_head = nn.Linear(embed_dim, 2)
         self.stop_sign_head = nn.Linear(embed_dim, 2)
-        
+
         self.traffic_pred_head = nn.Sequential(*[nn.Linear(embed_dim + 32, 64), nn.ReLU(), nn.Linear(64, 7), nn.Sigmoid()])
         self.position_encoding = PositionEmbeddingSine(embed_dim // 2, normalize=True)
-        
+
         encoder_layer = TransformerEncoderLayer(embed_dim, config.num_heads, config.dim_feedforward, config.dropout, act_layer, config.normalize_before)
         self.encoder = TransformerEncoder(encoder_layer, config.enc_depth, None)
-        
+
         decoder_layer = TransformerDecoderLayer(embed_dim, config.num_heads, config.dim_feedforward, config.dropout, act_layer, config.normalize_before)
         decoder_norm = nn.LayerNorm(embed_dim)
         self.decoder = TransformerDecoder(decoder_layer, config.dec_depth, decoder_norm, return_intermediate=False)
-        
+
         self.reset_parameters()
 
     def reset_parameters(self):
@@ -505,7 +663,7 @@ class Interfuser(nn.Module):
             lidar_token_global = lidar_token_global + self.view_embed[:, :, 4, :] + self.global_embed[:, :, 4:5]
             lidar_token_global = lidar_token_global.permute(2, 0, 1)
             features.extend([lidar_token, lidar_token_global])
-        
+
         return torch.cat(features, 0)
 
     def forward(self, x):
@@ -518,7 +676,7 @@ class Interfuser(nn.Module):
             right_image = F.interpolate(right_image, size=(img_size, img_size))
             front_center_image = F.interpolate(front_center_image, size=(img_size, img_size))
             front_image = torch.cat([front_image, left_image, right_image, front_center_image], dim=1)
-        
+
         features = self.forward_features(front_image, left_image, right_image, front_center_image, lidar, measurements)
         bs = front_image.shape[0]
 
@@ -545,7 +703,7 @@ class Interfuser(nn.Module):
         if self.waypoints_pred_head == "heatmap": waypoints = self.waypoints_generator(waypoints_feature, measurements)
         elif self.waypoints_pred_head.startswith("gru"): waypoints = self.waypoints_generator(waypoints_feature, target_point, measurements) if "command" in self.waypoints_pred_head else self.waypoints_generator(waypoints_feature, target_point)
         elif self.waypoints_pred_head.startswith("linear"): waypoints = self.waypoints_generator(waypoints_feature, measurements)
-            
+
         is_junction = self.junction_pred_head(is_junction_feature)
         traffic_light_state = self.traffic_light_pred_head(is_junction_feature) # Original code uses same feature
         stop_sign = self.stop_sign_head(is_junction_feature) # Original code uses same feature
@@ -553,44 +711,134 @@ class Interfuser(nn.Module):
         velocity = measurements[:, 6:7].unsqueeze(-1).repeat(1, 400, 32)
         traffic_feature_with_vel = torch.cat([traffic_feature, velocity], dim=2)
         traffic = self.traffic_pred_head(traffic_feature_with_vel)
-        
+
         return traffic, waypoints, is_junction, traffic_light_state, stop_sign, traffic_feature
 
+# ==============================================================================
+# القسم 5: الغلاف (Wrapper) المتوافق مع Hugging Face
+# ==============================================================================
+from typing import Optional, Tuple, Union
 
-# --- تعريف الغلاف الرئيسي (Wrapper) ---
-# هذا هو الكلاس الذي سيتم استدعاؤه بواسطة AutoModel
 class InterfuserForHuggingFace(PreTrainedModel):
     config_class = InterfuserConfig
+
     def __init__(self, config: InterfuserConfig):
         super().__init__(config)
-        self.model = Interfuser(config) # سيتم بناء النموذج الأصلي هنا
+        self.model = Interfuser(config)
+
     def _init_weights(self, module):
+        """
+        هذه الدالة مطلوبة من PreTrainedModel.
+        بما أن نموذجنا الأصلي لديه دالة reset_parameters، يمكننا الاعتماد عليها.
+        """
         if hasattr(module, 'reset_parameters'):
             module.reset_parameters()
-    def forward(self, rgb: torch.FloatTensor, rgb_left: torch.FloatTensor, rgb_right: torch.FloatTensor, rgb_center: torch.FloatTensor, lidar: torch.FloatTensor, measurements: torch.FloatTensor, target_point: torch.FloatTensor, return_dict: Optional[bool] = None) -> Union[Tuple, InterfuserOutput]:
+
+    def forward(
+        self,
+        rgb: torch.FloatTensor,
+        rgb_left: torch.FloatTensor,
+        rgb_right: torch.FloatTensor,
+        rgb_center: torch.FloatTensor,
+        lidar: torch.FloatTensor,
+        measurements: torch.FloatTensor,
+        target_point: torch.FloatTensor,
+        return_dict: Optional[bool] = None,
+    ) -> Union[Tuple, InterfuserOutput]:
+
+        # --- بداية الكود المصحح ---
         return_dict = return_dict if return_dict is not None else self.config.use_return_dict
-        inputs = {"rgb": rgb, "rgb_left": rgb_left, "rgb_right": rgb_right, "rgb_center": rgb_center, "lidar": lidar, "measurements": measurements, "target_point": target_point}
-        outputs = self.model(inputs)
-        if self.config.end2end:
-            if not return_dict: return (outputs,)
-            return InterfuserOutput(waypoints=outputs)
-        traffic, waypoints, is_junction, traffic_light_state, stop_sign, traffic_feature = outputs
-        if not return_dict: return outputs
-        return InterfuserOutput(waypoints=waypoints, traffic_predictions=traffic, is_junction=is_junction, traffic_light_state=traffic_light_state, stop_sign=stop_sign, traffic_features=traffic_feature)
-# ==============================================================================
-# --- التسجيل الديناميكي للنموذج في مكتبة Transformers ---
-# هذا هو الجزء الحاسم الذي يحل خطأ KeyError
-# ==============================================================================
-from transformers.models.auto.configuration_auto import AutoConfig
-from transformers.models.auto.modeling_auto import AutoModel
 
-print("Registering Interfuser model with AutoModel...")
+        inputs = {
+            "rgb": rgb,
+            "rgb_left": rgb_left,
+            "rgb_right": rgb_right,
+            "rgb_center": rgb_center,
+            "lidar": lidar,
+            "measurements": measurements,
+            "target_point": target_point
+        }
 
-# 1. تسجيل فئة الإعدادات
-AutoConfig.register("interfuser", InterfuserConfig)
+        outputs = self.model(inputs)
 
-# 2. تسجيل فئة النموذج
-# هذا يربط model_type="interfuser" مع الكلاس InterfuserForHuggingFace
-AutoModel.register(InterfuserConfig, InterfuserForHuggingFace)
+        if self.config.end2end:
+            if not return_dict:
+                return (outputs,)
+            return InterfuserOutput(waypoints=outputs)
 
-print("Registration complete.")
+        # تفريغ المخرجات من الـ tuple
+        (
+            traffic,
+            waypoints,
+            is_junction,
+            traffic_light_state,
+            stop_sign,
+            traffic_feature
+        ) = outputs
+
+        if not return_dict:
+            # إرجاع الـ tuple الأصلي إذا لم يتم طلب القاموس
+            return outputs
+
+        # إرجاع كائن المخرجات المنظم
+        return InterfuserOutput(
+            waypoints=waypoints,
+            traffic_predictions=traffic,
+            is_junction=is_junction,
+            traffic_light_state=traffic_light_state,
+            stop_sign=stop_sign,
+            traffic_features=traffic_feature,
+        )
+        # --- نهاية الكود المصحح ---
+# # ==============================================================================
+# # القسم 6: مثال على كيفية الاستخدام
+# # ==============================================================================
+
+# if __name__ == '__main__':
+#     # 1. إنشاء كائن الإعدادات
+#     config = InterfuserConfig(
+#         img_size=224,
+#         embed_dim=256, # تصغير البعد لسهولة التجربة
+#         enc_depth=2,   # تصغير العمق
+#         dec_depth=2,   # تصغير العمق
+#         num_heads=4,   # تصغير عدد الرؤوس
+#         end2end=False, # اختبار الوضع الكامل
+#         waypoints_pred_head="linear-sum"
+#     )
+
+#     # 2. إنشاء النموذج من الإعدادات
+#     model = InterfuserForHuggingFace(config)
+#     model.eval()
+
+#     # 3. إنشاء بيانات وهمية (dummy data) للمدخلات
+#     batch_size = 2
+#     img_size = config.img_size
+
+#     dummy_rgb = torch.randn(batch_size, 3, img_size, img_size)
+#     dummy_lidar = torch.randn(batch_size, 3, img_size, img_size)
+#     # [command, is_junction, traffic_light_state, stop_sign, ...]
+#     dummy_measurements = torch.randn(batch_size, 7)
+#     dummy_target_point = torch.randn(batch_size, 2)
+
+#     # 4. تمرير البيانات للنموذج
+#     with torch.no_grad():
+#         outputs = model(
+#             rgb=dummy_rgb,
+#             rgb_left=dummy_rgb,
+#             rgb_right=dummy_rgb,
+#             rgb_center=dummy_rgb,
+#             lidar=dummy_lidar,
+#             measurements=dummy_measurements,
+#             target_point=dummy_target_point,
+#             return_dict=True  # طلب المخرجات ككائن منظم
+#         )
+
+#     # 5. الوصول إلى المخرجات
+#     print("شكل مخرجات الـ Waypoints:", outputs.waypoints.shape)
+#     print("شكل مخرجات توقعات إشارات المرور:", outputs.traffic_predictions.shape)
+#     print("شكل مخرجات التقاطعات:", outputs.is_junction.shape)
+
+#     # يمكنك الآن حفظ النموذج وتحميله بسهولة
+#     # model.save_pretrained("./my_interfuser_model")
+#     # loaded_model = InterfuserForHuggingFace.from_pretrained("./my_interfuser_model")
+#     # print("\nتم تحميل النموذج بنجاح!")