Upload 9 files

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+FM.png filter=lfs diff=lfs merge=lfs -text
+PM.png filter=lfs diff=lfs merge=lfs -text
+PredM.png filter=lfs diff=lfs merge=lfs -text
+RM.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,156 @@
+# Urban Mobility Integrated Neural Dynamics (U-MIND)
+
+## 📖 Model Summary
+
+**Urban Mobility Integrated Neural Dynamics (U-MIND)** constitutes the specialized algorithmic core (Layer 2) of the "Traffic Large Model" architecture. Unlike monolithic Large Language Models (LLMs), **U-MIND** is engineered as a **collaborative cluster of four parallel micro-models**, specifically optimized for the physical constraints of urban transportation. It functions as the high-precision reasoning engine that grounds the L1 model's intent understanding into accurate, mathematically rigorous mobility forecasts by fusing static road semantics with dynamic sensor streams.
+
+The **U-MIND** cluster integrates four specialized engines:
+
+1.  **PM (Perception Engine):** Captures high-frequency dynamics and implicit couplings.
+2.  **RM (Representation Engine):** Encodes static topology and semantic patterns.
+3.  **FM (Fusion Engine):** Aligns heterogeneous multimodal data.
+4.  **PredM (Evolution Engine):** Forecasts future spatio-temporal states.
+
+---
+
+## 🏗️ Model Architecture
+
+The cluster adopts a **Parallel Collaborative Architecture**, where each model specializes in a specific domain of the urban traffic system.
+
+### 1. PM: Perception Model
+* **Role:** **Dynamic State Extractor**
+* **Core Function:** Processes raw, noisy sensor data (Flow, Speed, Occupancy). It utilizes 1D convolution and adaptive pooling to extract short-term trends and denoise signal fluctuations caused by random events.
+* **Key Capability:** Identifies traffic anomalies (e.g., sudden congestion) and compresses high-dimensional time-series into a compact context fingerprint.
+
+![Perception Model](PM.png)
+
+### 2. RM: Representation Model
+* **Role:** **Semantic Pattern Encoder**
+* **Core Function:** Focuses on the static and semi-static attributes of the road network (POI distribution, road geometry). It learns a low-dimensional manifold representation of diverse traffic patterns (e.g., "Residential Area" vs. "Business District").
+* **Key Capability:** Distinguishes between different functional zones based on their daily peak-hour signatures (morning/evening rush).
+
+![Representation Model](RM.png)
+
+### 3. FM: Fusion Model
+* **Role:** **Cross-Modal Aligner**
+* **Core Function:** Acts as the bridge between ground traffic, rail transit, and environmental factors. It employs Multi-Head Attention to dynamically weigh different data sources based on real-time contexts (e.g., increasing rail weight during rainy days).
+* **Key Capability:** Resolves the heterogeneity between static embeddings and dynamic flows, outputting a unified multimodal context vector.
+
+![Fusion Model](FM.png)
+
+### 4. PredM: Prediction Model
+* **Role:** **Future State Estimator**
+* **Core Function:** A specialized graph-based predictor that models the propagation of traffic waves. It combines dilated convolutions for long-range temporal reception with graph structures for spatial dependency.
+* **Key Capability:** Provides high-precision forecasts for both urban ground and rail mobility demands, serving as the calculation engine for the upper-layer applications.
+
+![Prediction Model](PredM.png)
+
+---
+
+## 💻 Usage: Simulation & Loading
+
+This section demonstrates how to generate physics-consistent simulated data and load the pre-trained model weights.
+
+```python
+import torch
+import numpy as np
+# Assuming model definitions (PM, RM, FM, PredM) are imported
+from urban_mobility_models import PerceptionModel, RepresentationModel, FusionModel, SpatioTemporalPredictor
+
+class DataSimulator:
+    """
+    Used to generate synthetic data that reflects the characteristics of urban traffic, covering four tasks: perception, representation, fusion, and prediction.
+    """
+    
+    @staticmethod
+    def sim_perception_data(batch_size=32, seq_len=24, sensors=5):
+        """1. [PM] Simulate Sensor Data: Adds Rush Hour & Random Noise"""
+        data = np.random.normal(50, 15, (batch_size, seq_len, sensors))
+        # Add rush hour patterns (Morning 8am / Evening 6pm)
+        t = np.arange(seq_len)
+        rush = 30 * (np.exp(-0.5*((t-8)/2)**2) + np.exp(-0.5*((t-18)/2)**2))
+        return torch.FloatTensor(data + rush[:, np.newaxis])
+
+    @staticmethod
+    def sim_representation_data(batch_size=32, feat_dim=32):
+        """2. [RM] Simulate Static Patterns: Residential vs Commercial zones"""
+        data = np.zeros((batch_size, feat_dim))
+        for i in range(batch_size):
+            # Residential peaks at 8am/8pm; Commercial peaks at 1pm
+            if np.random.rand() > 0.5:
+                data[i, 8] += 2.0; data[i, 20] += 1.5 # Residential
+            else:
+                data[i, 13] += 2.0 # Commercial
+        return torch.FloatTensor(data + np.random.normal(0, 0.5, data.shape))
+
+    @staticmethod
+    def sim_fusion_data(batch_size=32):
+        """3. [FM] Simulate Multimodal Data: Ground, Rail, Weather"""
+        ground = np.random.normal(0, 1, (batch_size, 32))
+        # Rail correlated with ground + random variance
+        rail = 0.6 * ground[:, :24] + 0.4 * np.random.normal(0, 1, (batch_size, 24))
+        # Weather (Environment)
+        env = np.random.normal(0, 1, (batch_size, 16))
+        return [torch.FloatTensor(d) for d in [ground, rail, env]]
+
+    @staticmethod
+    def sim_prediction_data(batch_size=32, nodes=20, time_steps=12):
+        """4. [PredM] Simulate Graph Inputs: History Flow + Adjacency Matrix"""
+        # Historical flow sequence
+        history = torch.randn(batch_size, nodes, time_steps)
+        # Static Graph Adjacency Matrix (sparse connection)
+        adj = torch.eye(nodes) + (torch.rand(nodes, nodes) > 0.8).float()
+        return history, adj
+
+def load_and_verify_cluster():
+    # 1. Initialize Models
+    pm = PerceptionModel(input_dim=5, hidden_dim=64, output_dim=32)
+    rm = RepresentationModel(input_dim=32, hidden_dim=64, representation_dim=16)
+    fm = FusionModel(input_dims=[32, 24, 16], hidden_dim=512, output_dim=48)
+    pred_m = SpatioTemporalPredictor(num_nodes=20, in_dim=12)
+
+    # 2. Load Pre-trained Weights
+    print("Loading L2 Cluster Weights...")
+    pm.load_state_dict(torch.load('perception_model.pth'))
+    rm.load_state_dict(torch.load('representation_model.pth'))
+    fm.load_state_dict(torch.load('fusion_model.pth'))
+    pred_m.load_state_dict(torch.load('prediction_model.pth')) # Hypothetical check
+    print(">>> All L2 Models Loaded Successfully.")
+
+    # 3. Generate & Forward Simulation Data
+    print("\nRunning Simulation Inference:")
+    
+    # PM
+    pm_out = pm(DataSimulator.sim_perception_data())
+    print(f"PM (Perception) Output: {pm_out.shape} - Dynamic Context Extracted")
+
+    # RM
+    rm_out, _ = rm(DataSimulator.sim_representation_data())
+    print(f"RM (Representation) Output: {rm_out.shape} - Semantic Node Embeddings")
+
+    # FM
+    fm_out, attn = fm(DataSimulator.sim_fusion_data())
+    print(f"FM (Fusion) Output: {fm_out.shape} - Multimodal Aligned Context")
+    
+    # PredM
+    hist, adj = DataSimulator.sim_prediction_data()
+    pred_out = pred_m(hist, adj)
+    print(f"PredM (Prediction) Output: {pred_out.shape} - Future Demand Forecast")
+
+if __name__ == "__main__":
+    load_and_verify_cluster()
+
+```
+
+---
+
+## ⚙️ Intended Use
+
+* **Integrated Mobility Orchestration**
+    * Cooperative scheduling of buses and subways based on fused demand.
+
+* **Resilient Traffic Management**
+    * Rapid response to anomalies (accidents, extreme weather) detected by the Perception engine.
+
+* **Urban Planning Analytics**
+    * Utilizing Representation Model embeddings to analyze the functional evolution of city districts.

fusion_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d56d45eb2ba4d932678ea6665c03663f4ff25d5a77a20789eb02b3e86868d06b
+size 4965348

perception_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f55f106bdc7e504f52404ceaf7d844bf1493efaab132685b624d833edcaee796
+size 3268122

prediction_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:edc1a3d25097b5172972acf6d0dd8f84e368abb04f73e042cea10df8cab62500
+size 1029562

representation_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7d7439669bd41e369b5803919cf88ddc1a043107bec7330d783f7289ee049107
+size 1233076