Added Radar

Individual-Contest/Radar/.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

Individual-Contest/Radar/.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

Individual-Contest/Radar/.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

Individual-Contest/Radar/.pytest_cache/v/cache/lastfailed

@@ -0,0 +1,3 @@
+{
+  "Radar.ipynb::Radar.ipynb": true
+}

Individual-Contest/Radar/.pytest_cache/v/cache/nodeids

@@ -0,0 +1,3 @@
+[
+  "Radar.ipynb::Radar.ipynb"
+]

Individual-Contest/Radar/Radar.ipynb

@@ -0,0 +1,564 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<img src=\"./figs/IOAI-Logo.png\" alt=\"IOAI Logo\" width=\"200\" height=\"auto\">\n",
+    "\n",
+    "[IOAI 2025 (Beijing, China), Individual Contest](https://ioai-official.org/china-2025)\n",
+    "\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/IOAI-official/IOAI-2025/blob/main/Individual-Contest/Radar/Radar.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Radar\n",
+    "\n",
+    "## 1. Problem Description \n",
+    "\n",
+    "Radar is a key technology in wireless communication, with widespread applications such as self-driving cars. It typically involves an antenna that transmits specific signals and receives their reflections from objects in the environment. By processing these signals, the system determines the angular direction, distance, and velocity of target objects.\n",
+    "\n",
+    "In real-world applications, radar signal processing is challenging due to noise and reflections from non-target objects in the surroundings. For example, when attempting to detect pedestrians, the radar may also receive reflections from trees or other background objects, which can degrade accuracy. Your task is to use AI to analyze the signals received by the radar and identify the presence of a human at each position.\n",
+    "\n",
+    "In this task, we provide an **indoor radar experiment dataset**, and your objective is to develop a model that performs **radar semantic segmentation**. \n",
+    "\n",
+    "\n",
+    "## 2. Dataset\n",
+    "\n",
+    "To measure objects surrounding a radar, the following key parameters are used:\n",
+    "\n",
+    "- **Range**: The straight-line distance between the radar and an object.\n",
+    "- **Azimuth**: The horizontal angle (left to right) between the radar and the object.\n",
+    "- **Elevation**: The vertical angle (up or down) of the object relative to the radar.\n",
+    "- **Velocity**: The speed at which the object is moving toward or away from the radar.\n",
+    "\n",
+    "<img src=\"./figs/Radar Fig 1.png\" width=\"300\">\n",
+    "\n",
+    "\n",
+    "The radar data is processed into multiple **heatmaps**, each encoding the **received signal strength** at various positions and directions.\n",
+    "\n",
+    "- **Static heatmaps** emphasize reflections from **stationary** objects.\n",
+    "- **Dynamic heatmaps** highlight changes caused by **moving** objects.\n",
+    "\n",
+    "When no object is present at a specific location, the signal consists mostly of background noise and appears weak. In contrast, reflections from an object increase signal intensity, enabling detection of the object.\n",
+    "\n",
+    "For example, the **static range-azimuth heatmap** represents signal strength across different distances (**range**) and horizontal angles (**azimuth**), mainly reflected by stationary objects.\n",
+    "\n",
+    "Each sample in the dataset is stored in a `.mat.pt` file as a tensor of shape $7 \\times 50 \\times 181$, where:\n",
+    "\n",
+    "- 7 is the number of maps (6 heatmaps + 1 semantic label map),\n",
+    "- 50 represents range bins (distance),\n",
+    "- 181 represents angular or velocity bins, covering angles from \\-90° to \\+90° in either the horizontal or vertical plane. You can assume that the velocity bins are also remapped from \\-90° to \\+90° for visualization consistency.\n",
+    "- each heatmap intensity value is normalized to [0, 1], representing received signal strength.\n",
+    "\n",
+    "The 6 heatmaps are structured as follows:\n",
+    "\n",
+    "- **Index 0**: Static range-azimuth heatmap\n",
+    "- **Index 1**: Dynamic range-azimuth heatmap\n",
+    "- **Index 2**: Static range-elevation heatmap\n",
+    "- **Index 3**: Dynamic range-elevation heatmap\n",
+    "- **Index 4**: Static range-velocity heatmap\n",
+    "- **Index 5**: Dynamic range-velocity heatmap\n",
+    "\n",
+    "All values in heatmaps are **normalized**, so no unit conversion is required.\n",
+    "\n",
+    "The **map at Index 6** is the semantic label map, stored in range-azimuth format. \n",
+    "\n",
+    "- **-1**: Background (no target)\n",
+    "- **0**: Suitcase\n",
+    "- **1**: Chair\n",
+    "- **2**: Human\n",
+    "- **3**: Wall\n",
+    "\n",
+    "This is the visualization of 1.mat.pt in training_set:\n",
+    "\n",
+    "<img src=\"./figs/Radar Fig 2.png\" width=\"675\">\n",
+    "\n",
+    "Here is part of a sample from the dataset:\n",
+    "\n",
+    "<img src=\"./figs/Radar Fig 3.png\" width=\"675\">\n",
+    "\n",
+    "\n",
+    "Data scale: 1800 samples in the training set, 500 samples in the validation set, and 500 samples in the test set.\n",
+    "\n",
+    "## 3\\. Task\n",
+    "\n",
+    "Your task is to develop a model that takes the **first six heatmaps** (indices 0 to 5) as input, and predicts the **semantic label map** (index 6) as the output. The goal is to accurately identify what the target is(-1 to 3) at each location in the radar’s field of view.\n",
+    "\n",
+    "1. **Input**: A tensor of shape $6 \\times 50 \\times 181$, representing six radar heatmaps.\n",
+    "2. **Output**: A tensor of shape $50 \\times 181$, representing the target semantic label map.\n",
+    "\n",
+    "\n",
+    "## 4\\. Submission \n",
+    "\n",
+    "Please submit a file named `submission.ipynb`. The output is a zip file named \"submission.zip\", which contains two tables `submission_val.csv` and `submission_test.csv` corresponding to the prediction results of the validation set and the test set respectively.\n",
+    "\n",
+    "**Note:** The output table should have a header, the data in the table is not the actual solved data, it is only used as an example of the submission format.\n",
+    "\n",
+    "| filename | pixel_0 | pixel_1 | ... | pixel_9049 |\n",
+    "| :------: | :-----: | ------- | --- | ---------- |\n",
+    "| 1.mat.pt |   -1    | -1      | ... | -1         |\n",
+    "|   ...    |   ...   | ...     | ... | ...        |\n",
+    "\n",
+    "## 5\\. Score\n",
+    "\n",
+    "The score is based on the **accuracy of label recognition**. Correctly identifying target points is weighted more heavily than correctly identifying background points. \n",
+    "\n",
+    "### Scoring Criteria: \n",
+    "\n",
+    "* Each correctly identified **background pixel** earns **1 point**. \n",
+    "\n",
+    "* Each correctly identified **non-background pixel** earns **50 points**. \n",
+    "\n",
+    "* The final score is normalized to a **0-1 point** by comparing it to the maximum possible score. \n",
+    "\n",
+    "### Formula：\n",
+    "$$\n",
+    "Score = \\frac{|C_{0,correct}| \\times 1 + |C_{1,correct}| \\times bonus}{|C_0| \\times 1 + |C_1| \\times bonus}\n",
+    "$$\n",
+    "where:\n",
+    "\n",
+    "$$\n",
+    "\\begin{aligned}\n",
+    "I &= \\{1, 2, \\dots, 50\\times 181\\}\\\\\n",
+    "C_0 &= \\{i \\in I \\mid y_i = -1\\}\\\\\n",
+    "C_1 &= \\{i \\in I \\mid y_i \\neq -1\\}\\\\\n",
+    "C_{0,correct} &= \\{i \\in C_0 \\mid p_i = y_i\\}\\\\\n",
+    "C_{1,correct} &= \\{i \\in C_1 \\mid p_i = y_i\\}\\\\\n",
+    "\\end{aligned}\n",
+    "$$\n",
+    "\n",
+    "\n",
+    "### Example\n",
+    "\n",
+    "For a $3\\times3$ heatmap, assume the Ground Truth is:\n",
+    "\n",
+    "$$\n",
+    "\\begin{bmatrix}\n",
+    "-1 & -1 & -1 \\\\\n",
+    "1 & 2 & 3 \\\\\n",
+    "-1 & -1 & -1\n",
+    "\\end{bmatrix}\n",
+    "$$\n",
+    "\n",
+    "The intenteded result is:\n",
+    "\n",
+    "$$\n",
+    "\\begin{bmatrix}\n",
+    "-1 & 1 & -1 \\\\\n",
+    "-1 & 2 & -1 \\\\\n",
+    "-1 & 3 & -1\n",
+    "\\end{bmatrix}\n",
+    "$$\n",
+    "\n",
+    "Then there are four correctly identified `-1` and one correctly identified `2`. Your score is 4 + 50 = 54 points. The maximum possible score is 6 + 50 * 3 = 156, that is, the score for six background pixels and three non-background pixels. Your normalized score is 54 / 156 = 0.346.\n",
+    "\n",
+    "$$\n",
+    "Score = \\frac{4 \\times 1 + 1 \\times 50}{6 \\times 1 + 3 \\times 50}=0.346\n",
+    "$$\n",
+    "\n",
+    "## 6. Baseline and Training Set\n",
+    "\n",
+    "- Below you can find the baseline solution.\n",
+    "- The dataset is in `training_set` folder.\n",
+    "- The highest score by the Scientific Committee for this task is 0.90 in Leaderboard B, this score is used for score unification.\n",
+    "- The baseline score by the Scientific Committee for this task is 0.67 in Leaderboard B, this score is used for score unification."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Data Loading"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import random\n",
+    "import numpy as np\n",
+    "import torch\n",
+    "\n",
+    "seed = 42\n",
+    "\n",
+    "random.seed(seed)                  # Python built-in random\n",
+    "np.random.seed(seed)               # NumPy\n",
+    "torch.manual_seed(seed)            # PyTorch (CPU)\n",
+    "torch.cuda.manual_seed(seed)       # PyTorch (single GPU)\n",
+    "torch.cuda.manual_seed_all(seed)   # PyTorch (all GPUs)\n",
+    "\n",
+    "# Ensures deterministic behavior\n",
+    "torch.backends.cudnn.deterministic = True\n",
+    "torch.backends.cudnn.benchmark = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import torch\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "class CustomDataset(Dataset):\n",
+    "    def __init__(self, file_paths, transform=None):\n",
+    "        self.file_paths = file_paths\n",
+    "        self.transform = transform\n",
+    "        self.file_names = [os.path.basename(path) for path in file_paths]\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.file_paths)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        data = torch.load(self.file_paths[idx], weights_only=True)\n",
+    "        \n",
+    "        images = data[:6]  \n",
+    "        labels = data[6]           \n",
+    "        \n",
+    "        images = images.float()  \n",
+    "        labels = labels.long()   \n",
+    "        labels = labels + 1\n",
+    "\n",
+    "        if self.transform:\n",
+    "            images = self.transform(images)\n",
+    "            labels = self.transform(labels)\n",
+    "        \n",
+    "        return images, labels, self.file_names[idx]\n",
+    "\n",
+    "class CustomDataset_test(Dataset):\n",
+    "    def __init__(self, file_paths, transform=None):\n",
+    "        self.file_paths = file_paths\n",
+    "        self.transform = transform\n",
+    "        self.file_names = [os.path.basename(path) for path in file_paths]\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.file_paths)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        data = torch.load(self.file_paths[idx], weights_only=True)\n",
+    "        \n",
+    "        images = data[:6]        \n",
+    "        \n",
+    "        images = images.float()  \n",
+    "\n",
+    "        if self.transform:\n",
+    "            images = self.transform(images)\n",
+    "        \n",
+    "        return images, self.file_names[idx]\n",
+    "\n",
+    "def generate_file_paths(base_path):\n",
+    "    file_paths = []\n",
+    "    for frame in os.listdir(base_path):\n",
+    "        frame_path = os.path.join(base_path, frame)\n",
+    "        if frame_path.endswith('.mat.pt'):\n",
+    "            file_paths.append(frame_path)\n",
+    "    return [path for path in file_paths if os.path.exists(path)]\n",
+    "\n",
+    "def load_data(base_path, batch_size=4, num_workers=2, test_size=0.2):\n",
+    "    file_paths = generate_file_paths(base_path)\n",
+    "    \n",
+    "    train_paths, test_paths = train_test_split(file_paths, test_size=test_size, random_state=42)\n",
+    "    \n",
+    "    train_dataset = CustomDataset(file_paths=train_paths)\n",
+    "    test_dataset = CustomDataset(file_paths=test_paths)\n",
+    "    \n",
+    "    train_loader = DataLoader(\n",
+    "        train_dataset, \n",
+    "        batch_size=batch_size, \n",
+    "        shuffle=True, \n",
+    "        num_workers=num_workers, \n",
+    "        drop_last=True\n",
+    "    )\n",
+    "    \n",
+    "    test_loader = DataLoader(\n",
+    "        test_dataset, \n",
+    "        batch_size=batch_size, \n",
+    "        shuffle=False, \n",
+    "        num_workers=num_workers, \n",
+    "        drop_last=True\n",
+    "    )\n",
+    "    \n",
+    "    return train_loader, test_loader"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Model Definition and Training"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.optim as optim\n",
+    "\n",
+    "class MyModel(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(MyModel, self).__init__()\n",
+    "        self.conv1 = nn.Conv2d(in_channels=6, out_channels=16, kernel_size=3, padding=1)  \n",
+    "        self.conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, padding=1)  \n",
+    "        self.conv3 = nn.Conv2d(in_channels=32, out_channels=5, kernel_size=3, padding=1)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.conv1(x))\n",
+    "        x = self.relu(self.conv2(x))\n",
+    "        x = self.conv3(x)  \n",
+    "        return x\n",
+    "\n",
+    "def train(model, train_loader, test_loader, optimizer, criterion, num_epochs=100):\n",
+    "    train_losses = []\n",
+    "    val_losses = []\n",
+    "    \n",
+    "    for epoch in range(num_epochs):\n",
+    "        model.train()\n",
+    "        epoch_loss = 0.0\n",
+    "        batch_count = 0\n",
+    "        \n",
+    "        for images, labels, _ in train_loader:\n",
+    "            images = images.cuda() if torch.cuda.is_available() else images\n",
+    "            labels = labels.cuda() if torch.cuda.is_available() else labels\n",
+    "            \n",
+    "            outputs = model(images)\n",
+    "            outputs = outputs.view(outputs.size(0), outputs.size(1), -1)  # [B, C, H*W]\n",
+    "            labels = labels.view(labels.size(0), -1)  # [B, H*W]\n",
+    "            loss = criterion(outputs, labels)\n",
+    "            \n",
+    "            optimizer.zero_grad()\n",
+    "            loss.backward()\n",
+    "            optimizer.step()\n",
+    "            \n",
+    "            epoch_loss += loss.item()\n",
+    "            batch_count += 1\n",
+    "        \n",
+    "        avg_train_loss = epoch_loss / batch_count\n",
+    "        train_losses.append(avg_train_loss)\n",
+    "        \n",
+    "        model.eval()\n",
+    "        val_loss = 0.0\n",
+    "        val_batch_count = 0\n",
+    "        \n",
+    "        with torch.no_grad():\n",
+    "            for images, labels, _ in test_loader:\n",
+    "                images = images.cuda() if torch.cuda.is_available() else images\n",
+    "                labels = labels.cuda() if torch.cuda.is_available() else labels\n",
+    "                \n",
+    "                outputs = model(images)\n",
+    "                outputs = outputs.view(outputs.size(0), outputs.size(1), -1)\n",
+    "                labels = labels.view(labels.size(0), -1)\n",
+    "                loss = criterion(outputs, labels)\n",
+    "                \n",
+    "                val_loss += loss.item()\n",
+    "                val_batch_count += 1\n",
+    "        \n",
+    "        avg_val_loss = val_loss / val_batch_count\n",
+    "        val_losses.append(avg_val_loss)\n",
+    "        \n",
+    "        if (epoch+1) % 2 == 0:\n",
+    "            print(f'Epoch [{epoch+1}/{num_epochs}], '\n",
+    "                  f'Train Loss: {avg_train_loss:.4f}, '\n",
+    "                  f'Val Loss: {avg_val_loss:.4f}')\n",
+    "    \n",
+    "    return train_losses, val_losses\n",
+    "TRAIN_PATH = \"./\"\n",
+    "# The training set is deployed automatically in the testing machine. \n",
+    "# You notebook can access the TRAIN_PATH even if you do not mount it along with notebook.\n",
+    "data_path = TRAIN_PATH + 'training_set'\n",
+    "\n",
+    "train_loader, test_loader = load_data(\n",
+    "    base_path=data_path,\n",
+    "    batch_size=4,  \n",
+    "    num_workers=2,\n",
+    "    test_size=0.2\n",
+    ")\n",
+    "\n",
+    "model = MyModel()\n",
+    "if torch.cuda.is_available():\n",
+    "    model = model.cuda()\n",
+    "\n",
+    "criterion = nn.CrossEntropyLoss()\n",
+    "optimizer = optim.Adam(model.parameters(), lr=0.001) \n",
+    "\n",
+    "train_losses, val_losses = train(\n",
+    "    model=model,\n",
+    "    train_loader=train_loader,\n",
+    "    test_loader=test_loader,\n",
+    "    optimizer=optimizer,\n",
+    "    criterion=criterion,\n",
+    "    num_epochs=40\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Generate CSV for Submission"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run inference on validation set and testing set\n",
+    "from torch.utils.data import DataLoader\n",
+    "import pandas as pd\n",
+    "\n",
+    "def run_inference(model, data_loader):\n",
+    "    \"\"\"Run inference and return predictions with filenames\"\"\"\n",
+    "    model.eval()\n",
+    "    predictions = []\n",
+    "    filenames = []\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        for images, file_names in data_loader:\n",
+    "            images = images.cuda() if torch.cuda.is_available() else images\n",
+    "            \n",
+    "            outputs = model(images)\n",
+    "            preds = torch.argmax(outputs, dim=1)\n",
+    "            \n",
+    "            # Convert predictions back to original label range [-1, 3]\n",
+    "            preds = preds - 1\n",
+    "            \n",
+    "            # Flatten predictions for each sample\n",
+    "            for i, pred in enumerate(preds):\n",
+    "                predictions.append(pred.cpu().numpy().flatten())\n",
+    "                filenames.append(file_names[i])\n",
+    "    \n",
+    "    return predictions, filenames\n",
+    "\n",
+    "#DATA_PATH is the secret environment variable to point the address of the validation set and test set on the testing machine. \n",
+    "#You cannot access this address locally.\n",
+    "if os.environ.get('DATA_PATH'):\n",
+    "    DATA_PATH = os.environ.get(\"DATA_PATH\") + \"/\" \n",
+    "else:\n",
+    "    DATA_PATH = \"\"  # Fallback for local testing\n",
+    "# Load validation set\n",
+    "val_paths = generate_file_paths(DATA_PATH + 'validation_set')\n",
+    "val_dataset = CustomDataset_test(file_paths=val_paths)\n",
+    "val_loader = DataLoader(\n",
+    "    val_dataset,\n",
+    "    batch_size=1,\n",
+    "    shuffle=False,\n",
+    "    num_workers=2\n",
+    ")\n",
+    "\n",
+    "# Load testing set\n",
+    "test_paths = generate_file_paths(DATA_PATH + 'testing_set')\n",
+    "test_dataset = CustomDataset_test(file_paths=test_paths)\n",
+    "test_loader = DataLoader(\n",
+    "    test_dataset,\n",
+    "    batch_size=1,\n",
+    "    shuffle=False,\n",
+    "    num_workers=2\n",
+    ")\n",
+    "\n",
+    "# Run inference on validation set\n",
+    "print(\"Running inference on validation set...\")\n",
+    "val_predictions, val_filenames = run_inference(model, val_loader)\n",
+    "\n",
+    "# Save validation results to CSV\n",
+    "val_results = []\n",
+    "for filename, pred in zip(val_filenames, val_predictions):\n",
+    "    # Create a row with filename and flattened predictions\n",
+    "    row = {'filename': filename}\n",
+    "    for i, p in enumerate(pred):\n",
+    "        row[f'pixel_{i}'] = p\n",
+    "    val_results.append(row)\n",
+    "\n",
+    "val_df = pd.DataFrame(val_results)\n",
+    "val_df.to_csv('submission_val.csv', index=False)\n",
+    "print(f\"Validation results saved to output_validation.csv with shape: {val_df.shape}\")\n",
+    "\n",
+    "# Run inference on testing set\n",
+    "print(\"Running inference on testing set...\")\n",
+    "test_predictions, test_filenames = run_inference(model, test_loader)\n",
+    "\n",
+    "# Save testing results to CSV\n",
+    "test_results = []\n",
+    "for filename, pred in zip(test_filenames, test_predictions):\n",
+    "    # Create a row with filename and flattened predictions\n",
+    "    row = {'filename': filename}\n",
+    "    for i, p in enumerate(pred):\n",
+    "        row[f'pixel_{i}'] = p\n",
+    "    test_results.append(row)\n",
+    "\n",
+    "test_df = pd.DataFrame(test_results)\n",
+    "test_df.to_csv('submission_test.csv', index=False)\n",
+    "print(f\"Testing results saved to output_testing.csv with shape: {test_df.shape}\")\n",
+    "\n",
+    "print(\"\\nInference completed! Results saved to:\")\n",
+    "print(\"- submission_val.csv (for validation set leaderboard)\")\n",
+    "print(\"- submission_test.csv (for testing set leaderboard)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Create .zip File"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import zipfile\n",
+    "import os\n",
+    "\n",
+    "# Define the files to zip and the zip file name.\n",
+    "files_to_zip = ['submission_val.csv', 'submission_test.csv']\n",
+    "zip_filename = 'submission.zip'\n",
+    "\n",
+    "# Create a zip file\n",
+    "with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
+    "    for file in files_to_zip:\n",
+    "        # Add the file to the zip fil\n",
+    "        zipf.write(file, os.path.basename(file))\n",
+    "\n",
+    "print(f'{zip_filename} Created successfully!')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}

Individual-Contest/Radar/Solution/Radar_Solution.ipynb

@@ -0,0 +1,1056 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ab23242e-3c5e-4ba6-9cb9-dfc4d8c22321",
+   "metadata": {},
+   "source": [
+    "<img src=\"./figs/IOAI-Logo.png\" alt=\"IOAI Logo\" width=\"200\" height=\"auto\">\n",
+    "\n",
+    "[IOAI 2025 (Beijing, China), Individual Contest](https://ioai-official.org/china-2025)\n",
+    "\n",
+    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/IOAI-official/IOAI-2025/blob/main/Individual-Contest/Radar/Solution/Radar_Solution.ipynb)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f2ea67c2-ec81-4ced-b8a4-a19b591376bb",
+   "metadata": {},
+   "source": [
+    "# Radar: Reference Solution"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "97ae6685",
+   "metadata": {},
+   "source": [
+    "## Configs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4243ca5d",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "radar_configs = {\n",
+    "    'c': 3e8, \n",
+    "    'startFreq': 77e9, \n",
+    "    'Tr': 60e-6,                    # Sweeping frequency time\n",
+    "    'Idle_time': 100e-6,            # free time\n",
+    "    'Fs': 10e6,                     # Sampling frequency\n",
+    "    'Slope': 29.982e12,             # chirp slope\n",
+    "    'Bandwidth': 60e-6 * 29.982e12, # Transmission signal bandwidth\n",
+    "    'BandwidthValid': 0.767539200e9,# Effective bandwidth of the transmitted signal\n",
+    "    'range_size': 256,              # range size\n",
+    "    'azimuth_size': 181,            # azimuth size\n",
+    "    'elevation_size': 181,          # elevation size\n",
+    "    'crop_num': 3,                  # crop some indices in range domain\n",
+    "    'n_chirps': 128,                # number of chirps in one frame\n",
+    "    'min_azimuth': -90,             # min radar azimuth\n",
+    "    'max_azimuth': 90,              # max radar azimuth\n",
+    "    'min_elevation': -90,           # min radar elevation\n",
+    "    'max_elevation': 90,            # max radar elevation    \n",
+    "    'min_range': 1.0,               # min radar range\n",
+    "    'max_range': 25.0,              # max radar range\n",
+    "    'range_res': 3e8/(2*0.767539200e9), \n",
+    "    'angle_res': 1\n",
+    "}\n",
+    "\n",
+    "dimssnet_configs = {\n",
+    "    'n_epoch': 10,\n",
+    "    'batch_size': 2,\n",
+    "    'learning_rate': 1e-5,\n",
+    "    'range_size': 50,\n",
+    "    'azimuth_size': 181,\n",
+    "    'elevation_size': 181,\n",
+    "    'doppler_size': 181, \n",
+    "    'min_azimuth': -90,             # min radar azimuth\n",
+    "    'max_azimuth': 90,              # max radar azimuth\n",
+    "    'min_elevation': -90,           # min radar elevation\n",
+    "    'max_elevation': 90,            # max radar elevation    \n",
+    "    'min_range': 1.0,               # min radar range\n",
+    "    'max_range': 25.0,              # max radar range\n",
+    "}\n",
+    "\n",
+    "n_class = 5\n",
+    "class_table = {\n",
+    "    -1: 'background', \n",
+    "    0: 'suicase', \n",
+    "    1: 'chair', \n",
+    "    2: 'person',\n",
+    "    3: 'wall'\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c39a54f5",
+   "metadata": {},
+   "source": [
+    "## Models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "10817ce8",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "\n",
+    "class SRA_Encode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(SRA_Encode, self).__init__()\n",
+    "        self.conv1a = nn.Conv2d(in_channels=1, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv1b = nn.Conv2d(in_channels=64, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv2a = nn.Conv2d(in_channels=64, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv2b = nn.Conv2d(in_channels=128, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv3a = nn.Conv2d(in_channels=128, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv3b = nn.Conv2d(in_channels=256, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "\n",
+    "        self.bn1a = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn1b = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn2a = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn2b = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn3a = nn.BatchNorm2d(num_features=256)\n",
+    "        self.bn3b = nn.BatchNorm2d(num_features=256)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.bn1a(self.conv1a(x)))\n",
+    "        x = self.relu(self.bn1b(self.conv1b(x)))\n",
+    "        x = self.relu(self.bn2a(self.conv2a(x)))\n",
+    "        x = self.relu(self.bn2b(self.conv2b(x)))\n",
+    "        x = self.relu(self.bn3a(self.conv3a(x)))\n",
+    "        x = self.relu(self.bn3b(self.conv3b(x)))\n",
+    "        \n",
+    "        return x\n",
+    "\n",
+    "class SRA_Decode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(SRA_Decode, self).__init__()\n",
+    "        self.convt1 = nn.ConvTranspose2d(in_channels=256, out_channels=128,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt2 = nn.ConvTranspose2d(in_channels=128, out_channels=64,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt3 = nn.ConvTranspose2d(in_channels=64, out_channels=32,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.prelu = nn.PReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "        self.upsample = nn.Upsample(size=(dimssnet_configs['range_size'],\n",
+    "                                          dimssnet_configs['azimuth_size']), mode='nearest')\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.prelu(self.convt1(x))\n",
+    "        x = self.prelu(self.convt2(x))\n",
+    "        x = self.prelu(self.convt3(x))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class DRA_Encode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DRA_Encode, self).__init__()\n",
+    "        self.conv1a = nn.Conv2d(in_channels=1, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) # (1 50 181)->(64 50 181)\n",
+    "        self.conv1b = nn.Conv2d(in_channels=64, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) # (64 50 181)->(64 25 91)\n",
+    "        self.conv2a = nn.Conv2d(in_channels=64, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) # (64 25 91)->(128 25 91)\n",
+    "        self.conv2b = nn.Conv2d(in_channels=128, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) # (128 25 91)->(128 13 46)\n",
+    "        self.conv3a = nn.Conv2d(in_channels=128, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) # (128 13 46)->(256 13 46)\n",
+    "        self.conv3b = nn.Conv2d(in_channels=256, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) # (256 13 46)->(256 7 23)\n",
+    "\n",
+    "        self.bn1a = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn1b = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn2a = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn2b = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn3a = nn.BatchNorm2d(num_features=256)\n",
+    "        self.bn3b = nn.BatchNorm2d(num_features=256)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.bn1a(self.conv1a(x)))\n",
+    "        x = self.relu(self.bn1b(self.conv1b(x)))\n",
+    "        x = self.relu(self.bn2a(self.conv2a(x)))\n",
+    "        x = self.relu(self.bn2b(self.conv2b(x)))\n",
+    "        x = self.relu(self.bn3a(self.conv3a(x)))\n",
+    "        x = self.relu(self.bn3b(self.conv3b(x)))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class DRA_Decode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DRA_Decode, self).__init__()\n",
+    "        self.convt1 = nn.ConvTranspose2d(in_channels=256, out_channels=128,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) # (256 7 23)->(128 13 45)\n",
+    "        self.convt2 = nn.ConvTranspose2d(in_channels=128, out_channels=64,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) # (128 13 45)->(64 25 89)\n",
+    "        self.convt3 = nn.ConvTranspose2d(in_channels=64, out_channels=32,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1)) # (64 25 89)->(32 49 177)\n",
+    "        self.prelu = nn.PReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "        self.upsample = nn.Upsample(size=(dimssnet_configs['range_size'],\n",
+    "                                          dimssnet_configs['elevation_size']), mode='nearest')\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.prelu(self.convt1(x))\n",
+    "        x = self.prelu(self.convt2(x))\n",
+    "        x = self.prelu(self.convt3(x))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class SRE_Encode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(SRE_Encode, self).__init__()\n",
+    "        self.conv1a = nn.Conv2d(in_channels=1, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv1b = nn.Conv2d(in_channels=64, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv2a = nn.Conv2d(in_channels=64, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv2b = nn.Conv2d(in_channels=128, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv3a = nn.Conv2d(in_channels=128, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv3b = nn.Conv2d(in_channels=256, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "\n",
+    "        self.bn1a = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn1b = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn2a = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn2b = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn3a = nn.BatchNorm2d(num_features=256)\n",
+    "        self.bn3b = nn.BatchNorm2d(num_features=256)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.bn1a(self.conv1a(x)))\n",
+    "        x = self.relu(self.bn1b(self.conv1b(x)))\n",
+    "        x = self.relu(self.bn2a(self.conv2a(x)))\n",
+    "        x = self.relu(self.bn2b(self.conv2b(x)))\n",
+    "        x = self.relu(self.bn3a(self.conv3a(x)))\n",
+    "        x = self.relu(self.bn3b(self.conv3b(x)))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class SRE_Decode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(SRE_Decode, self).__init__()\n",
+    "        self.convt1 = nn.ConvTranspose2d(in_channels=256, out_channels=128,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt2 = nn.ConvTranspose2d(in_channels=128, out_channels=64,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt3 = nn.ConvTranspose2d(in_channels=64, out_channels=32,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.prelu = nn.PReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "        self.upsample = nn.Upsample(size=(dimssnet_configs['range_size'],\n",
+    "                                          dimssnet_configs['elevation_size']), mode='nearest')\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.prelu(self.convt1(x))\n",
+    "        x = self.prelu(self.convt2(x))\n",
+    "        x = self.prelu(self.convt3(x))\n",
+    "\n",
+    "        return x\n",
+    "    \n",
+    "class DRE_Encode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DRE_Encode, self).__init__()\n",
+    "        self.conv1a = nn.Conv2d(in_channels=1, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv1b = nn.Conv2d(in_channels=64, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv2a = nn.Conv2d(in_channels=64, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv2b = nn.Conv2d(in_channels=128, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv3a = nn.Conv2d(in_channels=128, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv3b = nn.Conv2d(in_channels=256, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "\n",
+    "        self.bn1a = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn1b = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn2a = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn2b = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn3a = nn.BatchNorm2d(num_features=256)\n",
+    "        self.bn3b = nn.BatchNorm2d(num_features=256)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.bn1a(self.conv1a(x)))\n",
+    "        x = self.relu(self.bn1b(self.conv1b(x)))\n",
+    "        x = self.relu(self.bn2a(self.conv2a(x)))\n",
+    "        x = self.relu(self.bn2b(self.conv2b(x)))\n",
+    "        x = self.relu(self.bn3a(self.conv3a(x)))\n",
+    "        x = self.relu(self.bn3b(self.conv3b(x)))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class DRE_Decode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DRE_Decode, self).__init__()\n",
+    "        self.convt1 = nn.ConvTranspose2d(in_channels=256, out_channels=128,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt2 = nn.ConvTranspose2d(in_channels=128, out_channels=64,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt3 = nn.ConvTranspose2d(in_channels=64, out_channels=32,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.prelu = nn.PReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "        self.upsample = nn.Upsample(size=(dimssnet_configs['range_size'],\n",
+    "                                          dimssnet_configs['elevation_size']), mode='nearest')\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.prelu(self.convt1(x))\n",
+    "        x = self.prelu(self.convt2(x))\n",
+    "        x = self.prelu(self.convt3(x))\n",
+    "\n",
+    "        return x\n",
+    "    \n",
+    "class SRD_Encode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(SRD_Encode, self).__init__()\n",
+    "        self.conv1a = nn.Conv2d(in_channels=1, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv1b = nn.Conv2d(in_channels=64, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv2a = nn.Conv2d(in_channels=64, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv2b = nn.Conv2d(in_channels=128, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv3a = nn.Conv2d(in_channels=128, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv3b = nn.Conv2d(in_channels=256, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "\n",
+    "        self.bn1a = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn1b = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn2a = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn2b = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn3a = nn.BatchNorm2d(num_features=256)\n",
+    "        self.bn3b = nn.BatchNorm2d(num_features=256)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.bn1a(self.conv1a(x)))\n",
+    "        x = self.relu(self.bn1b(self.conv1b(x)))\n",
+    "        x = self.relu(self.bn2a(self.conv2a(x)))\n",
+    "        x = self.relu(self.bn2b(self.conv2b(x)))\n",
+    "        x = self.relu(self.bn3a(self.conv3a(x)))\n",
+    "        x = self.relu(self.bn3b(self.conv3b(x)))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class SRD_Decode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(SRD_Decode, self).__init__()\n",
+    "        self.convt1 = nn.ConvTranspose2d(in_channels=256, out_channels=128,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt2 = nn.ConvTranspose2d(in_channels=128, out_channels=64,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt3 = nn.ConvTranspose2d(in_channels=64, out_channels=32,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.prelu = nn.PReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "        self.upsample = nn.Upsample(size=(dimssnet_configs['range_size'],\n",
+    "                                          dimssnet_configs['doppler_size']), mode='nearest')\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.prelu(self.convt1(x))\n",
+    "        x = self.prelu(self.convt2(x))\n",
+    "        x = self.prelu(self.convt3(x))\n",
+    "\n",
+    "        return x\n",
+    "    \n",
+    "class DRD_Encode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DRD_Encode, self).__init__()\n",
+    "        self.conv1a = nn.Conv2d(in_channels=1, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv1b = nn.Conv2d(in_channels=64, out_channels=64, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv2a = nn.Conv2d(in_channels=64, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv2b = nn.Conv2d(in_channels=128, out_channels=128, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.conv3a = nn.Conv2d(in_channels=128, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.conv3b = nn.Conv2d(in_channels=256, out_channels=256, \n",
+    "                                kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "\n",
+    "        self.bn1a = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn1b = nn.BatchNorm2d(num_features=64)\n",
+    "        self.bn2a = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn2b = nn.BatchNorm2d(num_features=128)\n",
+    "        self.bn3a = nn.BatchNorm2d(num_features=256)\n",
+    "        self.bn3b = nn.BatchNorm2d(num_features=256)\n",
+    "\n",
+    "        self.relu = nn.ReLU()\n",
+    "        \n",
+    "    def forward(self, x):\n",
+    "        x = self.relu(self.bn1a(self.conv1a(x)))\n",
+    "        x = self.relu(self.bn1b(self.conv1b(x)))\n",
+    "        x = self.relu(self.bn2a(self.conv2a(x)))\n",
+    "        x = self.relu(self.bn2b(self.conv2b(x)))\n",
+    "        x = self.relu(self.bn3a(self.conv3a(x)))\n",
+    "        x = self.relu(self.bn3b(self.conv3b(x)))\n",
+    "\n",
+    "        return x\n",
+    "\n",
+    "class DRD_Decode(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DRD_Decode, self).__init__()\n",
+    "        self.convt1 = nn.ConvTranspose2d(in_channels=256, out_channels=128,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt2 = nn.ConvTranspose2d(in_channels=128, out_channels=64,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.convt3 = nn.ConvTranspose2d(in_channels=64, out_channels=32,\n",
+    "                                         kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
+    "        self.prelu = nn.PReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "        self.upsample = nn.Upsample(size=(dimssnet_configs['range_size'],\n",
+    "                                          dimssnet_configs['doppler_size']), mode='nearest')\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.prelu(self.convt1(x))\n",
+    "        x = self.prelu(self.convt2(x))\n",
+    "        x = self.prelu(self.convt3(x))\n",
+    "\n",
+    "        return x"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "483a5ba6",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class DIMSSNet(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(DIMSSNet, self).__init__()\n",
+    "        self.encode_sra = SRA_Encode()\n",
+    "        self.decode_sra = SRA_Decode()\n",
+    "        self.encode_dra = DRA_Encode()\n",
+    "        self.decode_dra = DRA_Decode()\n",
+    "        self.encode_sre = SRE_Encode()\n",
+    "        self.decode_sre = SRE_Decode()\n",
+    "        self.encode_dre = DRE_Encode()\n",
+    "        self.decode_dre = DRE_Decode()\n",
+    "        self.encode_srd = SRD_Encode()\n",
+    "        self.decode_srd = SRD_Decode()\n",
+    "        self.encode_drd = DRD_Encode()\n",
+    "        self.decode_drd = DRD_Decode()\n",
+    "        self.fuse_fea = Fuse_fea()\n",
+    "        # self.fuse_fea = Fuse_fea_2D()\n",
+    "        \n",
+    "    def forward(self, x_sra, x_dra, x_sre, x_dre, x_srd, x_drd):\n",
+    "        x_sra = self.encode_sra(x_sra)\n",
+    "        feas_sra = self.decode_sra(x_sra)  # (B, 32, 50, 181)\n",
+    "        \n",
+    "        x_dra = self.encode_dra(x_dra)\n",
+    "        feas_dra = self.decode_dra(x_dra)  # (B, 32, 50, 181)\n",
+    "        \n",
+    "        x_sre = self.encode_sre(x_sre)\n",
+    "        feas_sre = self.decode_sre(x_sre)  # (B, 32, 50, 181)\n",
+    "        \n",
+    "        x_dre = self.encode_dre(x_dre)\n",
+    "        feas_dre = self.decode_dre(x_dre)  # (B, 32, 50, 181)\n",
+    "\n",
+    "        x_srd = self.encode_sre(x_srd)\n",
+    "        feas_srd = self.decode_sre(x_srd)  # (B, 32, 50, 181)\n",
+    "        \n",
+    "        x_drd = self.encode_dre(x_drd)\n",
+    "        feas_drd = self.decode_dre(x_drd)  # (B, 32, 50, 181)        \n",
+    "        \n",
+    "        feas = self.fuse_fea(feas_sra, feas_dra, feas_sre, feas_dre, feas_srd, feas_drd) # (B, 32, 50, 181)\n",
+    "\n",
+    "        return feas"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ddb913e6",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "range_size=radar_configs['range_size']\n",
+    "azimuth_size=radar_configs['azimuth_size']\n",
+    "elevation_size=radar_configs['elevation_size']\n",
+    "\n",
+    "class Fuse_fea(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(Fuse_fea, self).__init__()\n",
+    "        self.convt1 = nn.Conv2d(in_channels=192, out_channels=96,\n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.convt2 = nn.Conv2d(in_channels=96, out_channels=48,\n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.convt3 = nn.Conv2d(in_channels=48, out_channels=24,\n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
+    "        self.convt4 = nn.Conv2d(in_channels=24, out_channels=n_class,\n",
+    "                                kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))        \n",
+    "        self.relu = nn.ReLU()\n",
+    "        self.sigmoid = nn.Sigmoid()\n",
+    "\n",
+    "    def forward(self, feas_sra, feas_dra, feas_sre, feas_dre, feas_srd, feas_drd):\n",
+    "        feas_sre = torch.sum(feas_sre, 3, keepdim=True) # (B, 32, 50, 181) -> (B, 32, 50, 1)\n",
+    "        feas_sre = feas_sre.expand(-1, -1, -1, azimuth_size)\n",
+    "        \n",
+    "        feas_dre = torch.sum(feas_dre, 3, keepdim=True)  # (B, 32, 50, 181) -> (B, 32, 50, 1)\n",
+    "        feas_dre = feas_dre.expand(-1, -1, -1, azimuth_size)\n",
+    "\n",
+    "        feas_srd = torch.sum(feas_srd, 3, keepdim=True)  # (B, 32, 50, 181) -> (B, 32, 50, 1)\n",
+    "        feas_srd = feas_srd.expand(-1, -1, -1, azimuth_size)\n",
+    "\n",
+    "        feas_drd = torch.sum(feas_drd, 3, keepdim=True)  # (B, 32, 50, 181) -> (B, 32, 50, 1)\n",
+    "        feas_drd = feas_drd.expand(-1, -1, -1, azimuth_size)\n",
+    "\n",
+    "        # Resize using bilinear interpolation\n",
+    "        feas_sra = F.interpolate(feas_sra, size=(range_size, azimuth_size), mode='bilinear', align_corners=False)\n",
+    "        feas_dra = F.interpolate(feas_dra, size=(range_size, azimuth_size), mode='bilinear', align_corners=False)\n",
+    "        feas_sre = F.interpolate(feas_sre, size=(range_size, azimuth_size), mode='bilinear', align_corners=False)\n",
+    "        feas_dre = F.interpolate(feas_dre, size=(range_size, azimuth_size), mode='bilinear', align_corners=False)\n",
+    "        feas_srd = F.interpolate(feas_srd, size=(range_size, azimuth_size), mode='bilinear', align_corners=False)\n",
+    "        feas_drd = F.interpolate(feas_drd, size=(range_size, azimuth_size), mode='bilinear', align_corners=False)\n",
+    "        \n",
+    "        feas_ra = torch.cat((feas_sra, feas_dra, feas_sre, feas_dre, feas_srd, feas_drd), 1) # 6*(B, 32, 50, 181) -> (B, 192, 50, 181)\n",
+    "\n",
+    "        x = self.relu(self.convt1(feas_ra))  # (B, 192, 50, 181) -> (B, 96, 50, 181)\n",
+    "        x = self.relu(self.convt2(x))  # (B, 96, 50, 181) -> (B, 48, 50, 181)\n",
+    "        x = self.relu(self.convt3(x))  # (B, 48, 50, 181) -> (B, 24, 50, 181)        \n",
+    "        x = self.sigmoid(self.convt4(x))  # (B, 24, 50, 181) -> (B, 5, 50, 181)\n",
+    "        \n",
+    "        return x\n",
+    "    "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8d86ece",
+   "metadata": {},
+   "source": [
+    "## Utils"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "49705a8f",
+   "metadata": {
+    "jupyter": {
+     "source_hidden": false
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import scipy.io\n",
+    "import numpy as np\n",
+    "\n",
+    "# Define the target size\n",
+    "TARGET_HEIGHT = 50\n",
+    "TARGET_WIDTH = 181\n",
+    "\n",
+    "def load_raw_data(file_path):\n",
+    "    data = scipy.io.loadmat(file_path)\n",
+    "\n",
+    "    # Range-Azimuth Static\n",
+    "    range_az_static = data['range_az_static']\n",
+    "    range_az_static_prob = data['range_az_music_average_static_probability']\n",
+    "    range_az_static_class2_prob = range_az_static_prob[:, :, 1]  # 椅子的概率\n",
+    "\n",
+    "    # Range-Elevation Static\n",
+    "    range_ele_static = data['range_ele_static_all']\n",
+    "\n",
+    "    # Range-Azimuth Dynamic\n",
+    "    range_az_dynamic = data['range_az_dynamic']\n",
+    "    range_az_dynamic_prob = data['range_az_music_average_dynamic_probability']\n",
+    "    range_az_dynamic_class1_prob = range_az_dynamic_prob[:, :, 0]  # 人的概率\n",
+    "\n",
+    "    # Range-Elevation Dynamic\n",
+    "    range_ele_dynamic = data['range_ele_dynamic_all'] \n",
+    "\n",
+    "    return [range_az_static, range_az_dynamic, range_ele_static,\n",
+    "            range_ele_dynamic, range_az_dynamic_class1_prob, range_az_static_class2_prob]\n",
+    "\n",
+    "def generate_parameter():\n",
+    "    parameter = {\n",
+    "        'c': 3e8,  # the speed of light\n",
+    "        'start_freq': 77e9,  # starting frequency\n",
+    "        'tr': 60e-6,  # Sweeping time, that is, the cycle\n",
+    "        'samples': 256,  # sampling point\n",
+    "        'fs': 10e6,  # Sampling rate\n",
+    "        'tframe_set': 80e-3,  # Frame period\n",
+    "        'range_bin': 256,  # range bin\n",
+    "        'chirps': 128,  # chirp number\n",
+    "        'doppler_bin': 128,  # doppler bin\n",
+    "        'slope': 29.982e12,  # chirp slope\n",
+    "        'bandwidth': 29.982e12 * 60e-6,  # Effective bandwidth of the transmitted signal\n",
+    "        'bandwidth_valid': 256 / 10e6 * 29.982e12,  # Transmission signal bandwidth\n",
+    "        'center_freq': 77e9 + (29.982e12 * 60e-6) / 2,  # center frequency\n",
+    "        'lambda': 3e8 / (77e9 + (29.982e12 * 60e-6) / 2),  # wavelength\n",
+    "        'tx_antenna': [1, 1, 1],  # The number of transmitting antennas\n",
+    "        'rx_antenna': [1, 1, 1, 1],  # Number of receiving antennas\n",
+    "        'tx_num': 3,  # The number of transmitting antennas\n",
+    "        'rx_num': 4,  # The number of receiving antennas\n",
+    "        'virtual_antenna': 12,  # Number of virtual antennas\n",
+    "        'dz': (3e8 / (77e9 + (29.982e12 * 60e-6) / 2)) / 2,  # Pitch spacing of the receiving antenna\n",
+    "        'dx': (3e8 / (77e9 + (29.982e12 * 60e-6) / 2)) / 2,  # Horizontal spacing of receiving antennas\n",
+    "        'num_cpi': 50,  # 帧数\n",
+    "    }\n",
+    "    return parameter\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c266f24b",
+   "metadata": {},
+   "source": [
+    "## Dataloaders"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "892cfb3a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "class CustomDataset(Dataset):\n",
+    "    def __init__(self, file_paths, transform=None):\n",
+    "        self.file_paths = file_paths\n",
+    "        self.transform = transform\n",
+    "        self.file_names = [os.path.basename(path) for path in file_paths]\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.file_paths)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        data = torch.load(self.file_paths[idx], weights_only=True)\n",
+    "        \n",
+    "        images = data[:6]  #first 6 channels are the heatmaps\n",
+    "        labels = data[6]   #last channel is the label\n",
+    "        \n",
+    "        images = images.float()  \n",
+    "        labels = labels.long()   \n",
+    "        labels = labels + 1     #labels are -1 to 3, add 1 to make them 0 to 4\n",
+    "\n",
+    "        if self.transform:\n",
+    "            images = self.transform(images)\n",
+    "            labels = self.transform(labels)\n",
+    "        \n",
+    "        return images, labels, self.file_names[idx]\n",
+    "\n",
+    "class CustomDataset_test(Dataset):\n",
+    "    def __init__(self, file_paths, transform=None):\n",
+    "        self.file_paths = file_paths\n",
+    "        self.transform = transform\n",
+    "        self.file_names = [os.path.basename(path) for path in file_paths]\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.file_paths)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        data = torch.load(self.file_paths[idx], weights_only=True)\n",
+    "        \n",
+    "        images = data[:6] #only load first 6 channels, labels are not in val_set and test_set\n",
+    "        \n",
+    "        images = images.float()  \n",
+    "\n",
+    "        if self.transform:\n",
+    "            images = self.transform(images)\n",
+    "        \n",
+    "        return images, self.file_names[idx]\n",
+    "\n",
+    "# extend base_path to file_path\n",
+    "def generate_file_paths(base_path):\n",
+    "    file_paths = []\n",
+    "    for frame in os.listdir(base_path):\n",
+    "        frame_path = os.path.join(base_path, frame)\n",
+    "        if frame_path.endswith('.mat.pt'):\n",
+    "            file_paths.append(frame_path)\n",
+    "    return [path for path in file_paths if os.path.exists(path)]\n",
+    "\n",
+    "def load_data(base_path, batch_size=4, num_workers=2, test_size=0.2):\n",
+    "    file_paths = generate_file_paths(base_path)\n",
+    "    \n",
+    "    train_paths, test_paths = train_test_split(file_paths, test_size=test_size, random_state=42)\n",
+    "    \n",
+    "    train_dataset = CustomDataset(file_paths=train_paths)\n",
+    "    test_dataset = CustomDataset(file_paths=test_paths)\n",
+    "    \n",
+    "    train_loader = DataLoader(\n",
+    "        train_dataset, \n",
+    "        batch_size=batch_size, \n",
+    "        shuffle=True, \n",
+    "        num_workers=num_workers, \n",
+    "        drop_last=True\n",
+    "    )\n",
+    "    \n",
+    "    test_loader = DataLoader(\n",
+    "        test_dataset, \n",
+    "        batch_size=batch_size, \n",
+    "        shuffle=False, \n",
+    "        num_workers=num_workers, \n",
+    "        drop_last=True\n",
+    "    )\n",
+    "    \n",
+    "    return train_loader, test_loader\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "67cd6c15",
+   "metadata": {},
+   "source": [
+    "## Loss Function"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4c573803",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#Used to handle the problem of class imbalance\n",
+    "\n",
+    "def to_one_hot(tensor, nClasses):\n",
+    "    n, h, w = tensor.size()\n",
+    "    one_hot = torch.zeros(n, nClasses, h, w, device=tensor.device)\n",
+    "    index_tensor = tensor.long().view(n, 1, h, w)\n",
+    "    one_hot = one_hot.scatter_(1, index_tensor, 1)\n",
+    "    return one_hot\n",
+    "\n",
+    "def _neg_loss(pred, gt):\n",
+    "    pred = torch.clamp(pred, 1e-5, 1-1e-5)\n",
+    "\n",
+    "    pos_inds = gt.eq(1).float()\n",
+    "    neg_inds = gt.eq(0).float()\n",
+    "\n",
+    "    balance_cof = 1.0\n",
+    "    pos_loss = torch.log(pred) * torch.pow(1 - pred, 2) * pos_inds * balance_cof\n",
+    "    neg_loss = torch.log(1 - pred) * torch.pow(pred, 2) * neg_inds\n",
+    "    num_pos = pos_inds.float().sum()\n",
+    "    pos_loss_sum = pos_loss.sum()\n",
+    "    neg_loss_sum = neg_loss.sum()\n",
+    "    if num_pos == 0:\n",
+    "        loss = -neg_loss_sum\n",
+    "    else:\n",
+    "        loss = -(pos_loss_sum + neg_loss_sum) / num_pos\n",
+    "    return loss\n",
+    "\n",
+    "class FocalLoss(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(FocalLoss, self).__init__()\n",
+    "        self.neg_loss = _neg_loss\n",
+    "\n",
+    "    def forward(self, out, target):\n",
+    "        return self.neg_loss(out, target)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dec2b582",
+   "metadata": {},
+   "source": [
+    "## Train"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c2f0301",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch.optim as optim\n",
+    "import matplotlib.pyplot as plt\n",
+    "import time\n",
+    "\n",
+    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
+    "\n",
+    "num_epochs = 20\n",
+    "\n",
+    "base_path = '/bohr/train-22pn/v2/training_set'\n",
+    "train_loader, test_loader = load_data(\n",
+    "    base_path=base_path,\n",
+    "    batch_size=4,\n",
+    "    num_workers=2,\n",
+    "    test_size=0.2\n",
+    ")\n",
+    "\n",
+    "dimssnet = DIMSSNet().to(device)\n",
+    "criterion = FocalLoss()\n",
+    "optimizer = optim.Adam(dimssnet.parameters(), lr=0.001)\n",
+    "start_time = time.time()\n",
+    "test_loss_record = []\n",
+    "train_loss_record = []\n",
+    "\n",
+    "for epoch in range(num_epochs):\n",
+    "    dimssnet.train()\n",
+    "    running_loss = 0.0\n",
+    "    for images, labels, _ in train_loader:\n",
+    "        images = images.to(device)\n",
+    "        labels = labels.to(device)\n",
+    "        \n",
+    "        images = [image.unsqueeze(1) for image in images]\n",
+    "        images = torch.stack(images, dim=0)\n",
+    "        images = images.float()\n",
+    "        \n",
+    "        outputs = dimssnet(images[:, 0, :, :], images[:, 1, :, :], images[:, 2, :, :],\n",
+    "                            images[:, 3, :, :], images[:, 4, :, :], images[:, 5, :, :])\n",
+    "\n",
+    "        outputs_resized = F.interpolate(outputs, size=(TARGET_HEIGHT, TARGET_WIDTH), mode='bilinear', align_corners=False)\n",
+    "        labels = to_one_hot(labels, n_class)\n",
+    "        \n",
+    "        loss = criterion(outputs_resized, labels.long())\n",
+    "        optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        \n",
+    "        running_loss += loss.item()\n",
+    "\n",
+    "    test_loss = 0.0\n",
+    "    dimssnet.eval()\n",
+    "    with torch.no_grad():\n",
+    "        for images, labels, _ in test_loader:\n",
+    "            images = images.to(device)\n",
+    "            labels = labels.to(device)\n",
+    "            \n",
+    "            images = [image.unsqueeze(1) for image in images]\n",
+    "            images = torch.stack(images, dim=0)\n",
+    "            images = images.float()\n",
+    "            \n",
+    "            outputs = dimssnet(images[:, 0, :, :], images[:, 1, :, :], images[:, 2, :, :],\n",
+    "                                images[:, 3, :, :], images[:, 4, :, :], images[:, 5, :, :])\n",
+    "            \n",
+    "            outputs_resized = F.interpolate(outputs, size=(TARGET_HEIGHT, TARGET_WIDTH), mode='bilinear', align_corners=False)\n",
+    "            labels = to_one_hot(labels, n_class)\n",
+    "            \n",
+    "            loss = criterion(outputs_resized, labels.long())\n",
+    "            test_loss += loss.item()\n",
+    "    \n",
+    "    test_loss_record.append(test_loss/len(test_loader))\n",
+    "    train_loss_record.append(running_loss/len(train_loader))\n",
+    "    print(f\"Epoch {epoch+1}/{num_epochs}, Training Loss: {running_loss/len(train_loader):.4f}, Test Loss: {test_loss/len(test_loader):.4f}\")\n",
+    "\n",
+    "# Create a new state_dict and add the \"model\" prefix, in order to match the loading method in metrics\n",
+    "new_state_dict = {}\n",
+    "for k, v in dimssnet.state_dict().items():\n",
+    "    new_key = f\"model.{k}\" \n",
+    "    new_state_dict[new_key] = v\n",
+    "\n",
+    "print(\"dimssnet successfully saved!\")    \n",
+    "print(\"Training finished.\")\n",
+    "end_time = time.time()\n",
+    "total_time = end_time - start_time\n",
+    "print(f\"Training completed in {total_time} seconds\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f001aee8",
+   "metadata": {},
+   "source": [
+    "## Inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8b330819",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Run inference on validation set and testing set\n",
+    "import pandas as pd\n",
+    "\n",
+    "def run_inference(model, data_loader):\n",
+    "    model.eval()\n",
+    "    predictions = []\n",
+    "    filenames = []\n",
+    "    \n",
+    "    with torch.no_grad():\n",
+    "        for images, file_names in data_loader:\n",
+    "            images = images.cuda() if torch.cuda.is_available() else images\n",
+    "            \n",
+    "            x = [image.unsqueeze(1) for image in images]\n",
+    "            x = torch.stack(x, dim=0)\n",
+    "            x = x.float()\n",
+    "            \n",
+    "            # Forward propagation\n",
+    "            outputs = model(x[:, 0, :, :], x[:, 1, :, :], x[:, 2, :, :],\n",
+    "                            x[:, 3, :, :], x[:, 4, :, :], x[:, 5, :, :])\n",
+    "            \n",
+    "            # Adjust the output size\n",
+    "            outputs = F.interpolate(outputs, size=(50, 181), mode='bilinear', align_corners=False)\n",
+    "\n",
+    "            preds = torch.argmax(outputs, dim=1)\n",
+    "            \n",
+    "            preds = preds - 1\n",
+    "            \n",
+    "            for i, pred in enumerate(preds):\n",
+    "                predictions.append(pred.cpu().numpy().flatten())\n",
+    "                filenames.append(file_names[i])\n",
+    "    \n",
+    "    return predictions, filenames\n",
+    "\n",
+    "# Load validation set\n",
+    "if os.environ.get('DATA_PATH'):\n",
+    "    DATA_PATH = os.environ.get(\"DATA_PATH\") + \"/\" \n",
+    "else:\n",
+    "    DATA_PATH = \"\"  # Fallback for local testing\n",
+    "# Load validation set\n",
+    "val_paths = generate_file_paths(DATA_PATH + 'validation_set')\n",
+    "val_dataset = CustomDataset_test(file_paths=val_paths)\n",
+    "val_loader = DataLoader(\n",
+    "    val_dataset,\n",
+    "    batch_size=1,\n",
+    "    shuffle=False,\n",
+    "    num_workers=0\n",
+    ")\n",
+    "\n",
+    "# Load testing set\n",
+    "if os.environ.get('DATA_PATH'):\n",
+    "    DATA_PATH = os.environ.get(\"DATA_PATH\") + \"/\" \n",
+    "else:\n",
+    "    DATA_PATH = \"\"  # Fallback for local testing\n",
+    "# Load testing set\n",
+    "test_paths = generate_file_paths(DATA_PATH + 'testing_set')\n",
+    "test_dataset = CustomDataset_test(file_paths=test_paths)\n",
+    "test_loader = DataLoader(\n",
+    "    test_dataset,\n",
+    "    batch_size=1,\n",
+    "    shuffle=False,\n",
+    "    num_workers=0\n",
+    ")\n",
+    "\n",
+    "# Run inference on validation set\n",
+    "print(\"Running inference on validation set...\")\n",
+    "val_predictions, val_filenames = run_inference(dimssnet, val_loader)\n",
+    "\n",
+    "# Save validation results to CSV\n",
+    "val_results = []\n",
+    "for filename, pred in zip(val_filenames, val_predictions):\n",
+    "    # Create a row with filename and flattened predictions\n",
+    "    row = {'filename': filename}\n",
+    "    for i, p in enumerate(pred):\n",
+    "        row[f'pixel_{i}'] = p\n",
+    "    val_results.append(row)\n",
+    "\n",
+    "val_df = pd.DataFrame(val_results)\n",
+    "val_df.to_csv('submission_val.csv', index=False)\n",
+    "print(f\"Validation results saved to output_validation.csv with shape: {val_df.shape}\")\n",
+    "\n",
+    "# Run inference on testing set\n",
+    "print(\"Running inference on testing set...\")\n",
+    "test_predictions, test_filenames = run_inference(dimssnet, test_loader)\n",
+    "\n",
+    "# Save testing results to CSV\n",
+    "test_results = []\n",
+    "for filename, pred in zip(test_filenames, test_predictions):\n",
+    "    # Create a row with filename and flattened predictions\n",
+    "    row = {'filename': filename}\n",
+    "    for i, p in enumerate(pred):\n",
+    "        row[f'pixel_{i}'] = p\n",
+    "    test_results.append(row)\n",
+    "\n",
+    "test_df = pd.DataFrame(test_results)\n",
+    "test_df.to_csv('submission_test.csv', index=False)\n",
+    "print(f\"Testing results saved to output_testing.csv with shape: {test_df.shape}\")\n",
+    "\n",
+    "print(\"\\nInference completed! Results saved to:\")\n",
+    "print(\"- submission_val_ref.csv (for validation set leaderboard)\")\n",
+    "print(\"- submission_test_ref.csv (for testing set leaderboard)\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "72fde72d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import zipfile\n",
+    "import os\n",
+    "\n",
+    "# Define the files to zip and the zip file name.\n",
+    "files_to_zip = ['submission_val.csv', 'submission_test.csv']\n",
+    "zip_filename = 'submission.zip'\n",
+    "\n",
+    "# Create a zip file\n",
+    "with zipfile.ZipFile(zip_filename, 'w') as zipf:\n",
+    "    for file in files_to_zip:\n",
+    "        # Add the file to the zip fil\n",
+    "        zipf.write(file, os.path.basename(file))\n",
+    "\n",
+    "print(f'{zip_filename} Created successfully!')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Individual-Contest/Radar/Solution/Scoring/metrics.py

@@ -0,0 +1,117 @@
+import json
+import pandas as pd
+import numpy as np
+import os
+
+def load_ground_truth_from_csv(csv_path):
+    """Load ground truth labels from CSV file"""
+    df = pd.read_csv(csv_path)
+    
+    ground_truth = {}
+    for _, row in df.iterrows():
+        filename = row['filename']
+        
+        # Extract ground truth labels (all columns except filename)
+        gt_cols = [col for col in df.columns if col.startswith('pixel_')]
+        gt_labels = row[gt_cols].values.astype(int)
+        
+        ground_truth[filename] = gt_labels
+    
+    print(f"Loaded {len(ground_truth)} samples from CSV")
+    return ground_truth
+
+def calculate_score_from_csv(csv_path, ground_truth, bonus=50):
+    df = pd.read_csv(csv_path)
+
+    total_score = 0
+    total_theo = 0
+
+    for _, row in df.iterrows():
+        filename = row['filename']
+        if filename not in ground_truth:
+            raise ValueError(f"Missing ground truth for file: {filename}")
+        
+        pred_cols = [col for col in df.columns if col.startswith('pixel_')]
+        if len(pred_cols) == 0:
+            raise ValueError("No prediction columns found (e.g., pixel_0, pixel_1, ...)")
+
+        predictions = row[pred_cols].values.astype(int)
+        gt_labels = ground_truth[filename]
+
+        if len(predictions) != len(gt_labels):
+            raise ValueError(f"Length mismatch for {filename}: prediction({len(predictions)}), ground truth({len(gt_labels)})")
+
+        equal_mask = predictions == gt_labels
+        neg_one_mask = gt_labels == -1
+
+        score_neg_one = np.sum(equal_mask & neg_one_mask) * 1
+        score_other = np.sum(equal_mask & ~neg_one_mask) * bonus
+        score_theo = np.sum(neg_one_mask) * 1 + np.sum(~neg_one_mask) * bonus
+
+        total_score += score_neg_one + score_other
+        total_theo += score_theo
+
+    if total_theo == 0:
+        print("Warning: Theoretical total score is zero. Returning score 0.0")
+        return 0.0
+
+    score = total_score / total_theo
+
+    if not np.isfinite(score) or score < 0 or score > 1:
+        print(f"Warning: Score {score} is invalid. Returning 0.0")
+        return 0.0
+
+    return score
+
+def main():
+    """Main function to calculate scores for both validation and testing sets"""
+    bonus = 50  # Score weights for non-background categories
+    if os.environ.get('METRIC_PATH'):
+        METRIC_PATH = os.environ.get("METRIC_PATH")+"/" 
+    else:
+        METRIC_PATH =""
+    # Paths for predictions
+    val_csv_path = 'submission_val.csv'
+    test_csv_path = 'submission_test.csv'
+    
+    # Paths for ground truth CSV files
+    val_gt_csv_path = METRIC_PATH + 'ground_truth_val.csv'
+    test_gt_csv_path = METRIC_PATH + 'ground_truth_test.csv'
+    
+    # Load ground truth for validation set from CSV
+    val_ground_truth = load_ground_truth_from_csv(val_gt_csv_path)
+    
+    # Load ground truth for testing set from CSV
+    test_ground_truth = load_ground_truth_from_csv(test_gt_csv_path)
+    
+    # Calculate scores
+    print("\nCalculating scores...")
+    
+    # Validation set score
+    val_score = calculate_score_from_csv(val_csv_path, val_ground_truth, bonus)
+    print(f"Validation set score: {val_score:.4f}")
+    if val_score > 1:
+        val_score = 0
+
+    # Testing set score
+    test_score = calculate_score_from_csv(test_csv_path, test_ground_truth, bonus)
+    print(f"Testing set score: {test_score:.4f}")
+    if test_score > 1:
+        test_score = 0
+        
+    # Save results
+    score = {
+        "public_a": val_score,
+        "private_b": test_score,
+    }
+    ret_json = {
+        "status": True,
+        "score": score,
+        "msg": "Success!",
+    }
+    
+    with open('score.json', 'w') as f:
+        json.dump(ret_json, f, indent=2)
+    
+if __name__ == '__main__':
+    main()