From 103a83277a3c04ecc86291b8f602caa2197ffadc Mon Sep 17 00:00:00 2001
From: Aayush Rai <156909253+aayushrai1288@users.noreply.github.com>
Date: Tue, 2 Jul 2024 15:21:58 +0530
Subject: [PATCH] Create Training_part.ipynb

The Jupyter notebook for the trianing part of the project
---
 Training_part.ipynb | 906 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 906 insertions(+)
 create mode 100644 Training_part.ipynb

diff --git a/Training_part.ipynb b/Training_part.ipynb
new file mode 100644
index 0000000..ee2ee7d
--- /dev/null
+++ b/Training_part.ipynb
@@ -0,0 +1,906 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-06-21T04:28:58.977554Z",
+     "iopub.status.busy": "2024-06-21T04:28:58.977192Z",
+     "iopub.status.idle": "2024-06-21T04:29:13.186468Z",
+     "shell.execute_reply": "2024-06-21T04:29:13.185664Z",
+     "shell.execute_reply.started": "2024-06-21T04:28:58.977523Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "2024-06-21 04:29:01.304109: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n",
+      "2024-06-21 04:29:01.304202: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n",
+      "2024-06-21 04:29:01.478767: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import glob\n",
+    "\n",
+    "import numpy as np\n",
+    "import tensorflow as tf\n",
+    "from tensorflow import keras\n",
+    "from tensorflow.keras import layers\n",
+    "from matplotlib import pyplot as plt\n",
+    "tf.random.set_seed(1234)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-06-21T04:29:16.466913Z",
+     "iopub.status.busy": "2024-06-21T04:29:16.465874Z",
+     "iopub.status.idle": "2024-06-21T04:34:43.035673Z",
+     "shell.execute_reply": "2024-06-21T04:34:43.034856Z",
+     "shell.execute_reply.started": "2024-06-21T04:29:16.466878Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Downloading data from http://download.cs.stanford.edu/downloads/completion3d/dataset2019.zip\n",
+      "\u001b[1m1585860897/1585860897\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m300s\u001b[0m 0us/step\n"
+     ]
+    }
+   ],
+   "source": [
+    "DATA_DIR = tf.keras.utils.get_file(\n",
+    "    \"dataset2019.zip\",\n",
+    "    \"http://download.cs.stanford.edu/downloads/completion3d/dataset2019.zip\",\n",
+    "    extract=True,\n",
+    ")\n",
+    "DATA_DIR = os.path.join (os.path.dirname(DATA_DIR),\"shapenet\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-06-21T04:34:51.538206Z",
+     "iopub.status.busy": "2024-06-21T04:34:51.537638Z",
+     "iopub.status.idle": "2024-06-21T04:34:51.543451Z",
+     "shell.execute_reply": "2024-06-21T04:34:51.542482Z",
+     "shell.execute_reply.started": "2024-06-21T04:34:51.538175Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import re\n",
+    "import h5py\n",
+    "import numpy as np\n",
+    "\n",
+    "def read_point_cloud_from_h5_file(file_path):\n",
+    "    with h5py.File(file_path, 'r') as file:\n",
+    "        \n",
+    "        point_cloud_data = file['data'][:]\n",
+    "    return point_cloud_data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-06-21T05:20:26.419374Z",
+     "iopub.status.busy": "2024-06-21T05:20:26.418692Z",
+     "iopub.status.idle": "2024-06-21T05:20:54.621883Z",
+     "shell.execute_reply": "2024-06-21T05:20:54.620914Z",
+     "shell.execute_reply.started": "2024-06-21T05:20:26.419344Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Loading 02691156: 100%|██████████| 3795/3795 [00:03<00:00, 1088.31it/s]\n",
+      "Loading 03636649: 100%|██████████| 2068/2068 [00:01<00:00, 1095.93it/s]\n",
+      "Loading 02933112: 100%|██████████| 1322/1322 [00:01<00:00, 1084.20it/s]\n",
+      "Loading 02958343: 100%|██████████| 5677/5677 [00:05<00:00, 1079.16it/s]\n",
+      "Loading 03001627: 100%|██████████| 5750/5750 [00:05<00:00, 1068.83it/s]\n",
+      "Loading 04256520: 100%|██████████| 2923/2923 [00:02<00:00, 1080.93it/s]\n",
+      "Loading 04379243: 100%|██████████| 5750/5750 [00:05<00:00, 1037.04it/s]\n",
+      "Loading 04530566: 100%|██████████| 1689/1689 [00:01<00:00, 983.45it/s] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loaded 28974 partial point clouds and 28974 ground truth point clouds.\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import h5py\n",
+    "import numpy as np\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "def load_h5_file(file_path, dataset_name='data'):\n",
+    "    \"\"\"Load point cloud data from an .h5 file.\"\"\"\n",
+    "    with h5py.File(file_path, 'r') as file:\n",
+    "        data = file[dataset_name][:]\n",
+    "    return data\n",
+    "\n",
+    "def load_dataset(base_dir, categories, dataset_name='data'):\n",
+    "    \"\"\"Load partial and gt datasets from the given base directory.\"\"\"\n",
+    "    partials = []\n",
+    "    gts = []\n",
+    "\n",
+    "    for category in categories:\n",
+    "        partial_dir = os.path.join(base_dir, 'partial', category)\n",
+    "        gt_dir = os.path.join(base_dir, 'gt', category)\n",
+    "\n",
+    "        # Check if the directories exist\n",
+    "        if not os.path.exists(partial_dir):\n",
+    "            print(f\"Partial directory does not exist: {partial_dir}\")\n",
+    "            continue\n",
+    "        if not os.path.exists(gt_dir):\n",
+    "            print(f\"GT directory does not exist: {gt_dir}\")\n",
+    "            continue\n",
+    "\n",
+    "        partial_files = sorted([f for f in os.listdir(partial_dir) if f.endswith('.h5')])\n",
+    "        gt_files = sorted([f for f in os.listdir(gt_dir) if f.endswith('.h5')])\n",
+    "\n",
+    "        for p_file, gt_file in tqdm(zip(partial_files, gt_files), total=len(partial_files), desc=f\"Loading {category}\"):\n",
+    "            partial_path = os.path.join(partial_dir, p_file)\n",
+    "            gt_path = os.path.join(gt_dir, gt_file)\n",
+    "\n",
+    "            partial_data = load_h5_file(partial_path, dataset_name)\n",
+    "            gt_data = load_h5_file(gt_path, dataset_name)\n",
+    "\n",
+    "            partials.append(partial_data)\n",
+    "            gts.append(gt_data)\n",
+    "\n",
+    "    return np.array(partials), np.array(gts)\n",
+    "\n",
+    "# Example usage\n",
+    "base_dir = os.path.join(DATA_DIR , \"train\")\n",
+    "categories = ['02691156', '03636649', '02933112', '02958343', '03001627' , '04256520' , '04379243' , '04530566']  # Replace with your actual category names\n",
+    "partial_dataset, gt_dataset = load_dataset(base_dir, categories)\n",
+    "print(f'Loaded {len(partial_dataset)} partial point clouds and {len(gt_dataset)} ground truth point clouds.')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-06-21T06:09:32.163370Z",
+     "iopub.status.busy": "2024-06-21T06:09:32.163008Z",
+     "iopub.status.idle": "2024-06-21T07:03:28.439211Z",
+     "shell.execute_reply": "2024-06-21T07:03:28.438288Z",
+     "shell.execute_reply.started": "2024-06-21T06:09:32.163342Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/25: 100%|██████████| 906/906 [02:08<00:00,  7.05batch/s, loss=0.0886]\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [1/25], Loss: 0.0886\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2/25: 100%|██████████| 906/906 [02:09<00:00,  7.02batch/s, loss=0.064]  \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [2/25], Loss: 0.0640\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0607] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [3/25], Loss: 0.0607\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0589] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [4/25], Loss: 0.0589\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5/25: 100%|██████████| 906/906 [02:09<00:00,  6.99batch/s, loss=0.0574] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [5/25], Loss: 0.0574\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6/25: 100%|██████████| 906/906 [02:09<00:00,  6.99batch/s, loss=0.0563] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [6/25], Loss: 0.0563\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 7/25: 100%|██████████| 906/906 [02:09<00:00,  6.99batch/s, loss=0.0554] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [7/25], Loss: 0.0554\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8/25: 100%|██████████| 906/906 [02:09<00:00,  6.99batch/s, loss=0.0547] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [8/25], Loss: 0.0547\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0538] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [9/25], Loss: 0.0538\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0533] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [10/25], Loss: 0.0533\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 11/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0528] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [11/25], Loss: 0.0528\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 12/25: 100%|██████████| 906/906 [02:09<00:00,  6.99batch/s, loss=0.0522] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [12/25], Loss: 0.0522\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 13/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.052]  \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [13/25], Loss: 0.0520\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 14/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0516] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [14/25], Loss: 0.0516\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 15/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0513] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [15/25], Loss: 0.0513\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 16/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0509] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [16/25], Loss: 0.0509\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 17/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0506] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [17/25], Loss: 0.0506\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 18/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0504] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [18/25], Loss: 0.0504\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 19/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0502] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [19/25], Loss: 0.0502\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 20/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0499] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [20/25], Loss: 0.0499\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 21/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0497] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [21/25], Loss: 0.0497\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 22/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0495] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [22/25], Loss: 0.0495\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 23/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0494] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [23/25], Loss: 0.0494\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 24/25: 100%|██████████| 906/906 [02:09<00:00,  7.01batch/s, loss=0.0492] \n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [24/25], Loss: 0.0492\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Epoch 25/25: 100%|██████████| 906/906 [02:09<00:00,  7.00batch/s, loss=0.0491] "
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch [25/25], Loss: 0.0491\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "import numpy as np\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "# Encoder definition\n",
+    "class PointNetEncoder(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super(PointNetEncoder, self).__init__()\n",
+    "        self.conv1 = nn.Conv1d(3, 64, 1)\n",
+    "        self.conv2 = nn.Conv1d(64, 128, 1)\n",
+    "        self.conv3 = nn.Conv1d(128, 1024, 1)\n",
+    "        self.fc1 = nn.Linear(1024, 512)\n",
+    "        self.fc2 = nn.Linear(512, 256)\n",
+    "        self.fc3 = nn.Linear(256, 1024)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = F.relu(self.conv1(x))\n",
+    "        x = F.relu(self.conv2(x))\n",
+    "        x = F.relu(self.conv3(x))\n",
+    "        x = torch.max(x, 2)[0]\n",
+    "        x = F.relu(self.fc1(x))\n",
+    "        x = F.relu(self.fc2(x))\n",
+    "        x = self.fc3(x)\n",
+    "        return x\n",
+    "\n",
+    "# Decoder definition\n",
+    "class PointCloudDecoder(nn.Module):\n",
+    "    def __init__(self, num_points):\n",
+    "        super(PointCloudDecoder, self).__init__()\n",
+    "        self.num_points = num_points\n",
+    "        self.fc1 = nn.Linear(1024, 256)\n",
+    "        self.fc2 = nn.Linear(256, 512)\n",
+    "        self.fc3 = nn.Linear(512, num_points * 3)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = F.relu(self.fc1(x))\n",
+    "        x = F.relu(self.fc2(x))\n",
+    "        x = self.fc3(x)\n",
+    "        x = x.view(-1, 3, self.num_points)\n",
+    "        return x\n",
+    "\n",
+    "# Model combining encoder and decoder\n",
+    "class PointCompletionNet(nn.Module):\n",
+    "    def __init__(self, num_points=2048):\n",
+    "        super(PointCompletionNet, self).__init__()\n",
+    "        self.encoder = PointNetEncoder()\n",
+    "        self.decoder = PointCloudDecoder(num_points)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = x.transpose(1, 2)  # Transpose to (batch_size, 3, num_points)\n",
+    "        features = self.encoder(x)\n",
+    "        reconstructed = self.decoder(features)\n",
+    "        return reconstructed.transpose(1, 2)  # Transpose back to (batch_size, num_points, 3)\n",
+    "\n",
+    "# Dataset class\n",
+    "class PointCloudDataset(Dataset):\n",
+    "    def __init__(self, partial_data, gt_data):\n",
+    "        self.partial_data = partial_data.astype(np.float32)\n",
+    "        self.gt_data = gt_data.astype(np.float32)\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.partial_data)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        partial = self.partial_data[idx]\n",
+    "        gt = self.gt_data[idx]\n",
+    "        return partial, gt\n",
+    "\n",
+    "# Chamfer Distance (simplified version)\n",
+    "def chamfer_distance(pred, gt):\n",
+    "    batch_size, num_points, _ = pred.size()\n",
+    "    pred = pred.unsqueeze(1).repeat(1, num_points, 1, 1)\n",
+    "    gt = gt.unsqueeze(2).repeat(1, 1, num_points, 1)\n",
+    "    dist = torch.norm(pred - gt, dim=-1)\n",
+    "    dist1 = dist.min(dim=2)[0]\n",
+    "    dist2 = dist.min(dim=1)[0]\n",
+    "    return dist1.mean(dim=1) + dist2.mean(dim=1)\n",
+    "\n",
+    "# Load your datasets\n",
+    "partial_dataset = partial_dataset\n",
+    "gt_dataset = gt_dataset\n",
+    "\n",
+    "# Create DataLoader\n",
+    "train_dataset = PointCloudDataset(partial_dataset, gt_dataset)\n",
+    "train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)\n",
+    "\n",
+    "# Hyperparameters and model initialization\n",
+    "num_points = 2048\n",
+    "model = PointCompletionNet(num_points).cuda()\n",
+    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
+    "epochs = 25\n",
+    "\n",
+    "# Training loop with progress bar\n",
+    "for epoch in range(epochs):\n",
+    "    model.train()\n",
+    "    running_loss = 0.0\n",
+    "\n",
+    "    # Initialize the progress bar\n",
+    "    with tqdm(total=len(train_loader), desc=f'Epoch {epoch + 1}/{epochs}', unit='batch') as pbar:\n",
+    "        for partial, complete in train_loader:\n",
+    "            partial, complete = partial.cuda(), complete.cuda()\n",
+    "            optimizer.zero_grad()\n",
+    "\n",
+    "            reconstructed = model(partial)\n",
+    "            loss = chamfer_distance(reconstructed, complete).mean()\n",
+    "\n",
+    "            loss.backward()\n",
+    "            optimizer.step()\n",
+    "\n",
+    "            running_loss += loss.item()\n",
+    "            pbar.set_postfix(loss=running_loss/len(train_loader))\n",
+    "            pbar.update(1)\n",
+    "\n",
+    "    print(f'Epoch [{epoch+1}/{epochs}], Loss: {running_loss/len(train_loader):.4f}')\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-06-21T07:03:38.334152Z",
+     "iopub.status.busy": "2024-06-21T07:03:38.333340Z",
+     "iopub.status.idle": "2024-06-21T07:03:38.914949Z",
+     "shell.execute_reply": "2024-06-21T07:03:38.914014Z",
+     "shell.execute_reply.started": "2024-06-21T07:03:38.334115Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test dataset shape: (1184, 2048, 3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Function to load test dataset\n",
+    "def load_test_dataset(base_dir):\n",
+    "    test_data = []\n",
+    "    file_paths = []\n",
+    "\n",
+    "    test_partial_dir = os.path.join(base_dir, 'test', 'partial' , 'all')\n",
+    "\n",
+    "    # Iterate through each file in the test/partial directory\n",
+    "    for file_name in os.listdir(test_partial_dir):\n",
+    "        file_path = os.path.join(test_partial_dir, file_name)\n",
+    "        if os.path.isfile(file_path) and file_name.endswith('.h5'):\n",
+    "            file_paths.append(file_path)\n",
+    "\n",
+    "            # Read point cloud data from .h5 file\n",
+    "            with h5py.File(file_path, 'r') as file:\n",
+    "                data = np.array(file['data'][:])  # Adjust based on your dataset structure\n",
+    "                test_data.append(data)\n",
+    "\n",
+    "    return np.array(test_data), file_paths\n",
+    "\n",
+    "# Example usage\n",
+    "base_dir = DATA_DIR\n",
+    "test_dataset, test_file_paths = load_test_dataset(base_dir)\n",
+    "\n",
+    "# Check the shape of test dataset\n",
+    "print(\"Test dataset shape:\", test_dataset.shape)  # Should be (num_samples, num_points, 3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-06-21T07:03:44.953874Z",
+     "iopub.status.busy": "2024-06-21T07:03:44.953533Z",
+     "iopub.status.idle": "2024-06-21T07:03:45.699614Z",
+     "shell.execute_reply": "2024-06-21T07:03:45.698640Z",
+     "shell.execute_reply.started": "2024-06-21T07:03:44.953847Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from torch.utils.data import Dataset, DataLoader\n",
+    "import numpy as np\n",
+    "\n",
+    "class PointCloudDataset2(Dataset):\n",
+    "    def __init__(self, partial_data, gt_data=None):\n",
+    "        self.partial_data = partial_data.astype(np.float32)\n",
+    "        self.gt_data = gt_data.astype(np.float32) if gt_data is not None else None\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.partial_data)\n",
+    "\n",
+    "    def __getitem__(self, idx):\n",
+    "        partial = self.partial_data[idx]\n",
+    "        if self.gt_data is not None:\n",
+    "            gt = self.gt_data[idx]\n",
+    "            return partial, gt\n",
+    "        else:\n",
+    "            return partial\n",
+    "\n",
+    "# Load the partial point cloud dataset\n",
+    "partial_dataset = PointCloudDataset2(test_dataset)\n",
+    "partial_loader = DataLoader(partial_dataset, batch_size=32, shuffle=False)\n",
+    "# Initialize and load the model (ensure correct architecture and weights)\n",
+    "\n",
+    "  # Replace with your actual model path\n",
+    "model.eval()  # Set the model to evaluation mode\n",
+    "\n",
+    "# Prediction loop\n",
+    "predicted_point_clouds = []\n",
+    "\n",
+    "with torch.no_grad():\n",
+    "    for partial in partial_loader:\n",
+    "        partial = partial.cuda()\n",
+    "        reconstructed = model(partial)\n",
+    "        predicted_point_clouds.append(reconstructed.cpu().numpy())\n",
+    "\n",
+    "# Concatenate all the batches to get the final predictions\n",
+    "predicted_point_clouds = np.concatenate(predicted_point_clouds, axis=0)\n",
+    "\n",
+    "# Save or process the predicted point clouds as needed\n",
+    "np.save('10.npy', predicted_point_clouds)  # Save predictions to a file"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-06-21T07:07:31.931043Z",
+     "iopub.status.busy": "2024-06-21T07:07:31.930671Z",
+     "iopub.status.idle": "2024-06-21T07:07:31.935389Z",
+     "shell.execute_reply": "2024-06-21T07:07:31.934492Z",
+     "shell.execute_reply.started": "2024-06-21T07:07:31.931011Z"
+    }
+   },
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-06-21T07:16:52.225870Z",
+     "iopub.status.busy": "2024-06-21T07:16:52.225249Z",
+     "iopub.status.idle": "2024-06-21T07:16:52.653208Z",
+     "shell.execute_reply": "2024-06-21T07:16:52.652268Z",
+     "shell.execute_reply.started": "2024-06-21T07:16:52.225838Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from mpl_toolkits.mplot3d import Axes3D\n",
+    "\n",
+    "# Example data (replace with your actual data)\n",
+    "partial_cloud = test_dataset[2]  # Example partial point cloud\n",
+    "predicted_cloud =predicted_point_clouds[2]# Example predicted point cloud\n",
+    "\n",
+    "# Create a figure and 3D axis\n",
+    "fig = plt.figure()\n",
+    "ax = fig.add_subplot(111, projection='3d')\n",
+    "\n",
+    "# Plot partial point cloud in blue\n",
+    "ax.scatter(partial_cloud[:, 0], partial_cloud[:, 1], partial_cloud[:, 2], c='b', label='Partial Cloud')\n",
+    "\n",
+    "# Plot predicted point cloud in red\n",
+    "ax.scatter(predicted_cloud[:, 0], predicted_cloud[:, 1], predicted_cloud[:, 2], c='r', label='Predicted Cloud')\n",
+    "\n",
+    "# Set labels and title\n",
+    "ax.set_xlabel('X')\n",
+    "ax.set_ylabel('Y')\n",
+    "ax.set_zlabel('Z')\n",
+    "ax.set_title('Partial and Predicted Point Clouds')\n",
+    "\n",
+    "# Add legend\n",
+    "ax.legend()\n",
+    "\n",
+    "# Show plot\n",
+    "plt.show()\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 58,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-06-21T07:17:38.656277Z",
+     "iopub.status.busy": "2024-06-21T07:17:38.655474Z",
+     "iopub.status.idle": "2024-06-21T07:17:38.701829Z",
+     "shell.execute_reply": "2024-06-21T07:17:38.701018Z",
+     "shell.execute_reply.started": "2024-06-21T07:17:38.656239Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "np.save('test.npy' , test_dataset)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kaggle": {
+   "accelerator": "nvidiaTeslaT4",
+   "dataSources": [],
+   "dockerImageVersionId": 30733,
+   "isGpuEnabled": true,
+   "isInternetEnabled": true,
+   "language": "python",
+   "sourceType": "notebook"
+  },
+  "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}