open3d_pointnet_inference.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import random\n",
    "from random import randrange\n",
    "from IPython.display import clear_output\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.parallel\n",
    "import torch.optim as optim\n",
    "import torch.utils.data\n",
    "import torchvision.datasets as dset\n",
    "import torchvision.transforms as transforms\n",
    "import torchvision.utils as vutils\n",
    "from torch.autograd import Variable\n",
    "from datasets import PartDataset\n",
    "from pointnet import PointNetCls\n",
    "import torch.nn.functional as F\n",
    "import matplotlib.pyplot as plt\n",
    "import open3d as o3\n",
    "import download\n",
    "from open3d import JVisualizer\n",
    "if torch.cuda.is_available():\n",
    "    import torch.backends.cudnn as cudnn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model file already downloaded in ./cls_model.pth\n",
      "Dataset file already downloaded in ./shapenetcore_partanno_segmentation_benchmark_v0.zip\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# General parameters\n",
    "NUM_POINTS = 10000\n",
    "MODEL_PATH = './cls_model.pth'\n",
    "DATA_FOLDER = './shapenetcore_partanno_segmentation_benchmark_v0'\n",
    "\n",
    "# download dataset and pre-trained model\n",
    "download.download_contents()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Airplane': 0, 'Bag': 1, 'Cap': 2, 'Car': 3, 'Chair': 4, 'Earphone': 5, 'Guitar': 6, 'Knife': 7, 'Lamp': 8, 'Laptop': 9, 'Motorbike': 10, 'Mug': 11, 'Pistol': 12, 'Rocket': 13, 'Skateboard': 14, 'Table': 15}\n"
     ]
    }
   ],
   "source": [
    "# Create dataset object\n",
    "test_dataset_seg = PartDataset(\n",
    "    root=DATA_FOLDER,\n",
    "    train=False,\n",
    "    classification=False,\n",
    "    npoints=NUM_POINTS)\n",
    "\n",
    "# Problem ontology\n",
    "classes_dict = {'Airplane': 0, 'Bag': 1, 'Cap': 2, 'Car': 3, 'Chair': 4, \n",
    "                'Earphone': 5, 'Guitar': 6, 'Knife': 7, 'Lamp': 8, 'Laptop': 9,\n",
    "                'Motorbike': 10, 'Mug': 11, 'Pistol': 12, 'Rocket': 13, \n",
    "                'Skateboard': 14, 'Table': 15}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "PointNetCls(\n",
       "  (feat): PointNetfeat(\n",
       "    (stn): STN3d(\n",
       "      (conv1): Conv1d(3, 64, kernel_size=(1,), stride=(1,))\n",
       "      (conv2): Conv1d(64, 128, kernel_size=(1,), stride=(1,))\n",
       "      (conv3): Conv1d(128, 1024, kernel_size=(1,), stride=(1,))\n",
       "      (mp1): MaxPool1d(kernel_size=10000, stride=10000, padding=0, dilation=1, ceil_mode=False)\n",
       "      (fc1): Linear(in_features=1024, out_features=512, bias=True)\n",
       "      (fc2): Linear(in_features=512, out_features=256, bias=True)\n",
       "      (fc3): Linear(in_features=256, out_features=9, bias=True)\n",
       "      (relu): ReLU()\n",
       "      (bn1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (bn2): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (bn3): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (bn4): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (bn5): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    )\n",
       "    (conv1): Conv1d(3, 64, kernel_size=(1,), stride=(1,))\n",
       "    (conv2): Conv1d(64, 128, kernel_size=(1,), stride=(1,))\n",
       "    (conv3): Conv1d(128, 1024, kernel_size=(1,), stride=(1,))\n",
       "    (bn1): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (bn2): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (bn3): BatchNorm1d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "    (mp1): MaxPool1d(kernel_size=10000, stride=10000, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (fc1): Linear(in_features=1024, out_features=512, bias=True)\n",
       "  (fc2): Linear(in_features=512, out_features=256, bias=True)\n",
       "  (fc3): Linear(in_features=256, out_features=16, bias=True)\n",
       "  (bn1): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (bn2): BatchNorm1d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "  (relu): ReLU()\n",
       ")"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create the classification network from pre-trained model\n",
    "classifier = PointNetCls(k=len(classes_dict.items()), num_points=NUM_POINTS)\n",
    "if torch.cuda.is_available():\n",
    "    classifier.cuda()\n",
    "    classifier.load_state_dict(torch.load(MODEL_PATH))\n",
    "else:\n",
    "    classifier.load_state_dict(torch.load(MODEL_PATH, map_location='cpu'))\n",
    "classifier.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Simple point cloud coloring mapping\n",
    "def read_pointnet_colors(seg_labels):\n",
    "    map_label_to_rgb = {\n",
    "        1: [0, 255, 0],\n",
    "        2: [0, 0, 255],\n",
    "        3: [255, 0, 0],\n",
    "        4: [255, 0, 255],  # purple\n",
    "        5: [0, 255, 255],  # cyan\n",
    "        6: [255, 255, 0],  # yellow\n",
    "    }\n",
    "    colors = np.array([map_label_to_rgb[label] for label in seg_labels])\n",
    "    return colors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4975d0c4c9fd4d159efddd9204b8672b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "JVisualizer with 1 geometries"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your object is a [Table] with probability 0.999. Press enter to continue!\n"
     ]
    }
   ],
   "source": [
    "# Three.js based visualizer\n",
    "visualizer = JVisualizer()\n",
    "\n",
    "# Basic inference and visualization loop\n",
    "MAX_SAMPLES = 15\n",
    "for samples in range(MAX_SAMPLES):\n",
    "    random_index = randrange(len(test_dataset_seg))\n",
    "    print('[Sample {} / {}]'.format(random_index, len(test_dataset_seg)))\n",
    "    \n",
    "    # clean visualization\n",
    "    visualizer.clear()\n",
    "    clear_output()\n",
    "\n",
    "    # get next sample\n",
    "    point_set, seg = test_dataset_seg.__getitem__(random_index)\n",
    "\n",
    "    # create cloud for visualization\n",
    "    cloud = o3.geometry.PointCloud()\n",
    "    cloud.points = o3.utility.Vector3dVector(point_set)\n",
    "    cloud.colors = o3.utility.Vector3dVector(read_pointnet_colors(seg.numpy()))\n",
    "\n",
    "    # perform inference in GPU\n",
    "    points = Variable(point_set.unsqueeze(0))\n",
    "    points = points.transpose(2, 1)\n",
    "    if torch.cuda.is_available():\n",
    "        points = points.cuda()\n",
    "    pred_logsoft, _ = classifier(points)\n",
    "\n",
    "    # move data back to cpu for visualization\n",
    "    pred_logsoft_cpu = pred_logsoft.data.cpu().numpy().squeeze()\n",
    "    pred_soft_cpu = np.exp(pred_logsoft_cpu)\n",
    "    pred_class = np.argmax(pred_soft_cpu)\n",
    "\n",
    "    # let's visualize the input sample\n",
    "    visualizer.add_geometry(cloud)\n",
    "    visualizer.show()\n",
    "    \n",
    "    # Visualize probabilities\n",
    "    plt.xticks(list(classes_dict.values()), list(classes_dict.keys()),rotation=90)\n",
    "    plt.xlabel('Classes')\n",
    "    plt.ylabel('Probabilities')\n",
    "    plt.plot(list(classes_dict.values()), pred_soft_cpu)\n",
    "    plt.show()\n",
    "\n",
    "    input('Your object is a [{}] with probability {:0.3}. Press enter to continue!'\n",
    "          .format(list(classes_dict.keys())[pred_class], pred_soft_cpu[pred_class]))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}