Upload app.py with huggingface_hub

app.py

@@ -10,8 +10,10 @@ from PIL import Image
 import cv2
 import math
 
-# --- استيراد من الملفات التي أنشأناها ---
-from model import interfuser_baseline
+# --- استيراد من الملفات المنظمة في مشروعك ---
+# نفترض أن بنية النموذج موجودة في model/architecture.py
+from model import build_interfuser_model 
+# نفترض أن بقية المنطق موجود في logic.py
 from logic import (
     transform, lidar_transform, InterfuserController, ControllerConfig,
     Tracker, DisplayInterface, render, render_waypoints, render_self_car,
@@ -19,97 +21,158 @@ from logic import (
 )
 
 # ==============================================================================
-#           1. تحميل النموذج (يتم مرة واحدة)
+#           1. إعدادات ومسارات النماذج
 # ==============================================================================
-print("Loading the Interfuser model...")
+WEIGHTS_DIR = "model"
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-model = interfuser_baseline()
-model_path = "model/interfuser_best_model.pth"
-if not os.path.exists(model_path):
-    raise FileNotFoundError(f"Model file not found at {model_path}. Please upload it.")
-
-# استخدام weights_only=True لزيادة الأمان عند تحميل الملفات من مصادر غير موثوقة
-try:
-    state_dic = torch.load(model_path, map_location=device, weights_only=True)
-except:
-    state_dic = torch.load(model_path, map_location=device)
+
+# متغير عام لتخزين النموذج المحمّل حاليًا
+current_model = None
+
+# قاموس لتحديد الإعدادات الخاصة بكل نموذج.
+# اسم المفتاح يجب أن يطابق اسم ملف الأوزان (بدون .pth).
+# إذا لم يتم تحديد إعدادات لنموذج ما، سيتم استخدام الإعدادات الافتراضية في دالة البناء.
+MODELS_SPECIFIC_CONFIGS = {
+    "interfuser_baseline": {
+        "rgb_backbone_name": "r50",
+        "embed_dim": 256,
+        "direct_concat": True, # هذا النموذج يتوقع دمج الصور
+    },
+    "interfuser_lightweight": {
+        "rgb_backbone_name": "r26",
+        "embed_dim": 128,
+        "enc_depth": 4,
+        "dec_depth": 4,
+        "direct_concat": True, # هذا النموذج يتوقع دمج الصور
+    }
+    # أضف هنا أي إعدادات لنماذج أخرى لديك
+    # "my_other_model": { "direct_concat": False, ... }
+}
+
+def find_available_models():
+    """
+    تبحث في مجلد الأوزان وتعيد قائمة بأسماء النماذج المتاحة.
+    """
+    if not os.path.isdir(WEIGHTS_DIR):
+        print(f"تحذير: مجلد الأوزان '{WEIGHTS_DIR}' غير موجود.")
+        return []
+    
+    models = [f.replace(".pth", "") for f in os.listdir(WEIGHTS_DIR) if f.endswith(".pth")]
+    return models
+
+# ==============================================================================
+#           2. دالة تحميل النموذج الديناميكية
+# ==============================================================================
+def load_model(model_name: str):
+    """
+    تحمل النموذج المحدد من القائمة المنسدلة وتضعه في المتغير العام current_model.
+    """
+    global current_model
     
-model.load_state_dict(state_dic)
-model.to(device)
-model.eval()
-print("Model loaded successfully.")
+    if not model_name:
+        return "الرجاء اختيار نموذج من القائمة."
 
+    weights_path = os.path.join(WEIGHTS_DIR, f"{model_name}.pth")
+    print(f"Attempting to load model: '{model_name}' from '{weights_path}'")
+    
+    # الحصول على الإعدادات المخصصة للنموذج، أو قاموس فارغ إذا لم توجد
+    model_config = MODELS_SPECIFIC_CONFIGS.get(model_name, {})
+    
+    # بناء النموذج باستخدام الإعدادات المحددة
+    model = build_interfuser_model(model_config)
+    
+    if not os.path.exists(weights_path):
+        gr.Warning(f"ملف الأوزان '{weights_path}' غير موجود. سيتم استخدام النموذج بأوزان عشوائية.")
+    else:
+        try:
+            # استخدام weights_only=True للأمان
+            state_dic = torch.load(weights_path, map_location=device, weights_only=True)
+            model.load_state_dict(state_dic)
+            print(f"تم تحميل أوزان النموذج '{model_name}' بنجاح.")
+        except Exception as e:
+            gr.Warning(f"فشل تحميل الأوزان للنموذج '{model_name}': {e}. تأكد من تطابق الإعدادات في 'MODELS_SPECIFIC_CONFIGS' مع الملف المحفوظ. سيتم استخدام أوزان عشوائية.")
+            
+    model.to(device)
+    model.eval()
+    
+    current_model = model # تحديث النموذج العام
+    
+    return f"تم تحميل نموذج: {model_name}"
 
 # ==============================================================================
-#           2. دالة التشغيل الرئيسية لـ Gradio
+#           3. دالة التشغيل الرئيسية لـ Gradio
 # ==============================================================================
 def run_single_frame(
-    rgb_image_path: str,
-    rgb_left_image_path: str,
-    rgb_right_image_path: str,
-    rgb_center_image_path: str,
-    lidar_image_path: str,
-    measurements_path: str,
-    target_point_list: list
+    rgb_image_path,
+    rgb_left_image_path,
+    rgb_right_image_path,
+    rgb_center_image_path,
+    lidar_image_path,
+    measurements_path,
+    target_point_list
 ):
-    """
-    تعالج إطارًا واحدًا من البيانات، وتُنشئ لوحة تحكم مرئية كاملة،
-    وتُرجع كلاً من الصورة والبيانات المهيكلة.
-    """
+    global current_model
+    
+    if current_model is None:
+        raise gr.Error("الرجاء اختيار وتحميل نموذج أولاً من القائمة المنسدلة.")
+    
     try:
-        # ==========================================================
-        #           1. قراءة ومعالجة المدخلات من المسارات
-        # ==========================================================
+        # --- 1. قراءة ومعالجة المدخلات ---
         if not rgb_image_path:
           raise gr.Error("الرجاء توفير مسار الصورة الأمامية (RGB).")
-
+        
         rgb_image_pil = Image.open(rgb_image_path.name).convert("RGB")
         rgb_left_pil = Image.open(rgb_left_image_path.name).convert("RGB") if rgb_left_image_path else rgb_image_pil
         rgb_right_pil = Image.open(rgb_right_image_path.name).convert("RGB") if rgb_right_image_path else rgb_image_pil
         rgb_center_pil = Image.open(rgb_center_image_path.name).convert("RGB") if rgb_center_image_path else rgb_image_pil
 
+        # تطبيق التحويلات لتحويل الصور إلى تنسورات
+        front_tensor = transform(rgb_image_pil).unsqueeze(0).to(device)
+        left_tensor = transform(rgb_left_pil).unsqueeze(0).to(device)
+        right_tensor = transform(rgb_right_pil).unsqueeze(0).to(device)
+        center_tensor = transform(rgb_center_pil).unsqueeze(0).to(device)
+        
         if lidar_image_path:
             lidar_array = np.load(lidar_image_path.name)
             if lidar_array.max() > 0:
                 lidar_array = (lidar_array / lidar_array.max()) * 255.0
-            lidar_pil = Image.fromarray(lidar_array.astype(np.uint8))
-            lidar_image_pil = lidar_pil.convert('RGB')
+            lidar_pil = Image.fromarray(lidar_array.astype(np.uint8)).convert('RGB')
         else:
-            lidar_image_pil = Image.fromarray(np.zeros((112, 112, 3), dtype=np.uint8))
-
-        rgb_tensor = transform(rgb_image_pil).unsqueeze(0).to(device)
-        rgb_left_tensor = transform(rgb_left_pil).unsqueeze(0).to(device)
-        rgb_right_tensor = transform(rgb_right_pil).unsqueeze(0).to(device)
-        rgb_center_tensor = transform(rgb_center_pil).unsqueeze(0).to(device)
-        lidar_tensor = lidar_transform(lidar_image_pil).unsqueeze(0).to(device)
+            lidar_pil = Image.fromarray(np.zeros((112, 112, 3), dtype=np.uint8))
+        lidar_tensor = lidar_transform(lidar_pil).unsqueeze(0).to(device)
 
         with open(measurements_path.name, 'r') as f:
-            measurements_dict = json.load(f)
-
-        measurements_values = [
-            measurements_dict.get('command', 2.0), measurements_dict.get('command', 2.0),
-            measurements_dict.get('command', 2.0), measurements_dict.get('command', 2.0),
-            measurements_dict.get('command', 2.0), measurements_dict.get('command', 2.0),
-            measurements_dict.get('speed', 5.0)
-        ]
-        measurements_tensor = torch.tensor([measurements_values], dtype=torch.float32).to(device)
-        target_point_tensor = torch.tensor([target_point_list], dtype=torch.float32).to(device)
+            m_dict = json.load(f)
 
+        # إنشاء تنسور القياسات الصحيح (10 عناصر)
+        measurements_tensor = torch.tensor([[
+            m_dict.get('x', 0.0), m_dict.get('y', 0.0), m_dict.get('theta', 0.0),
+            m_dict.get('speed', 5.0), m_dict.get('steer', 0.0), m_dict.get('throttle', 0.0),
+            float(m_dict.get('brake', 0.0)), m_dict.get('command', 2.0),
+            float(m_dict.get('is_junction', 0.0)), float(m_dict.get('should_brake', 0.0))
+        ]], dtype=torch.float32).to(device)
+        
+        target_point_tensor = torch.tensor([target_point_list], dtype=torch.float32).to(device)
+        
+        # تجميع المدخلات للنموذج
         inputs = {
-            'rgb': rgb_tensor, 'rgb_left': rgb_left_tensor, 'rgb_right': rgb_right_tensor,
-            'rgb_center': rgb_center_tensor, 'lidar': lidar_tensor,
-            'measurements': measurements_tensor, 'target_point': target_point_tensor
+            'rgb': front_tensor, # للنماذج التي لا تدمج
+            'rgb_left': left_tensor,
+            'rgb_right': right_tensor,
+            'rgb_center': center_tensor,
+            'lidar': lidar_tensor,
+            'measurements': measurements_tensor,
+            'target_point': target_point_tensor
         }
 
-        # ==========================================================
-        #           2. تشغيل النموذج والمعالجات اللاحقة
-        # ==========================================================
+        # --- 2. تشغيل النموذج ---
         with torch.no_grad():
-            outputs = model(inputs)
+            outputs = current_model(inputs)
             traffic, waypoints, is_junction, traffic_light, stop_sign, _ = outputs
 
-        measurements_np = measurements_tensor[0].cpu().numpy()
-        pos, theta, speed = [0,0], 0, measurements_np[6]
+        # --- 3. المعالجة اللاحقة والتصوّر ---
+        speed = m_dict.get('speed', 5.0)
+        pos, theta = [m_dict.get('x', 0.0), m_dict.get('y', 0.0)], m_dict.get('theta', 0.0)
         
         traffic_np = traffic[0].detach().cpu().numpy().reshape(20, 20, -1)
         waypoints_np = waypoints[0].detach().cpu().numpy() * WAYPOINT_SCALE_FACTOR
@@ -118,15 +181,13 @@ def run_single_frame(
         updated_traffic = tracker.update_and_predict(traffic_np.copy(), pos, theta, frame_num=0)
         
         controller = InterfuserController(ControllerConfig())
-        steer, throttle, brake, metadata_tuple = controller.run_step(
+        steer, throttle, brake, metadata = controller.run_step(
             speed=speed, waypoints=waypoints_np, junction=is_junction.sigmoid()[0, 1].item(),
             traffic_light_state=traffic_light.sigmoid()[0, 0].item(),
             stop_sign=stop_sign.sigmoid()[0, 1].item(), meta_data=updated_traffic
         )
 
-        # ==========================================================
-        #           3. إنشاء التصور المرئي (Dashboard)
-        # ==========================================================
+        # إنشاء لوحة التحكم المرئية
         map_t0, counts_t0 = render(updated_traffic, t=0)
         map_t1, counts_t1 = render(updated_traffic, t=T1_FUTURE_TIME)
         map_t2, counts_t2 = render(updated_traffic, t=T2_FUTURE_TIME)
@@ -144,8 +205,7 @@ def run_single_frame(
         stop_sign_state = "Yes" if stop_sign.sigmoid()[0,1].item() > 0.5 else "No"
         
         interface_data = {
-            'camera_view': np.array(rgb_image_pil),
-            'map_t0': map_t0, 'map_t1': map_t1, 'map_t2': map_t2,
+            'camera_view': np.array(rgb_image_pil), 'map_t0': map_t0, 'map_t1': map_t1, 'map_t2': map_t2,
             'text_info': { 
                 'Frame': 'API Frame', 'Control': f"S:{steer:.2f} T:{throttle:.2f} B:{int(brake)}", 
                 'Light': f"L: {light_state}", 'Stop': f"St: {stop_sign_state}" 
@@ -155,37 +215,52 @@ def run_single_frame(
         
         dashboard_image = display.run_interface(interface_data)
 
-        # ==========================================================
-        #           4. تجهيز وإرجاع المخرجات النهائية
-        # ==========================================================
+        # --- 4. تجهيز المخرجات ---
         result_dict = {
             "predicted_waypoints": waypoints_np.tolist(),
             "control_commands": {"steer": steer, "throttle": throttle, "brake": bool(brake)},
             "perception": {"traffic_light_status": light_state, "stop_sign_detected": (stop_sign_state == "Yes"), "is_at_junction_prob": round(is_junction.sigmoid()[0,1].item(), 3)},
-            "metadata": {"speed_info": metadata_tuple[0], "perception_info": metadata_tuple[1], "stop_info": metadata_tuple[2], "safe_distance": metadata_tuple[3]}
+            "metadata": {"speed_info": metadata[0], "perception_info": metadata[1], "stop_info": metadata[2], "safe_distance": metadata[3]}
         }
         
         return Image.fromarray(dashboard_image), result_dict
 
     except Exception as e:
         print(traceback.format_exc())
-        raise gr.Error(f"Error processing single frame: {e}")
-
+        raise gr.Error(f"حدث خطأ أثناء معالجة الإطار: {e}")
 
 # ==============================================================================
 #           4. تعريف واجهة Gradio
 # ==============================================================================
+
+# البحث عن النماذج المتاحة عند بدء تشغيل الواجهة
+available_models = find_available_models()
+
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 🚗 محاكاة القيادة الذاتية باستخدام Interfuser")
     
+    with gr.Row():
+        model_selector = gr.Dropdown(
+            label="اختر النموذج من مجلد 'model/weights'",
+            choices=available_models,
+            value=available_models[0] if available_models else "لم يتم العثور على نماذج"
+        )
+        status_textbox = gr.Textbox(label="حالة تحميل النموذج", interactive=False)
+
+    # التحميل الأولي والتحميل عند التغيير
+    if available_models:
+        demo.load(fn=load_model, inputs=model_selector, outputs=status_textbox)
+    model_selector.change(fn=load_model, inputs=model_selector, outputs=status_textbox)
+
+    gr.Markdown("---")
+    
     with gr.Tabs():
         with gr.TabItem("نقطة نهاية API (إطار واحد)", id=1):
             gr.Markdown("### اختبار النموذج بإدخال مباشر (Single Frame Inference)")
-            gr.Markdown("هذه الواجهة مخصصة للمطورين. قم برفع الملفات المطلوبة لتشغيل النموذج على إطار واحد.")
             
             with gr.Row():
                 with gr.Column(scale=1):
-                    gr.Markdown("#### ملفات الصور والبيانات")
+                    gr.Markdown("#### المدخلات")
                     api_rgb_image_path = gr.File(label="RGB (Front) File (.jpg, .png)")
                     api_rgb_left_image_path = gr.File(label="RGB (Left) File (Optional)")
                     api_rgb_right_image_path = gr.File(label="RGB (Right) File (Optional)")
@@ -203,13 +278,9 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
             api_run_button.click(
                 fn=run_single_frame,
                 inputs=[
-                    api_rgb_image_path, 
-                    api_rgb_left_image_path, 
-                    api_rgb_right_image_path, 
-                    api_rgb_center_image_path, 
-                    api_lidar_image_path,
-                    api_measurements_path, 
-                    api_target_point_list
+                    api_rgb_image_path, api_rgb_left_image_path, api_rgb_right_image_path, 
+                    api_rgb_center_image_path, api_lidar_image_path,
+                    api_measurements_path, api_target_point_list
                 ],
                 outputs=[api_output_image, api_output_json],
                 api_name="run_single_frame"
@@ -219,4 +290,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
 #           5. تشغيل التطبيق
 # ==============================================================================
 if __name__ == "__main__":
+    if not available_models:
+        print("تحذير: لم يتم العثور على أي ملفات نماذج (.pth) في مجلد 'model/weights'.")
+        print("سيتم تشغيل الواجهة ولكن لن تتمكن من تحميل أي نموذج.")
     demo.queue().launch(debug=True)