demo.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CAD-Recode Demonstration\n",
    "In this demonstration, we load a point cloud and process it using a pre-trained CAD-Recode model, which generates Python CadQuery code. Finally, we interpret the code to create a CAD model, visualize it, and evaluate its quality metrics. This notebook works on both CPU and GPU."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Define CAD-Recode model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import open3d\n",
    "import trimesh\n",
    "import skimage.io\n",
    "import numpy as np\n",
    "import cadquery as cq\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.spatial import cKDTree\n",
    "\n",
    "import torch\n",
    "from torch import nn\n",
    "from transformers import (\n",
    "    AutoTokenizer, Qwen2ForCausalLM, Qwen2Model, PreTrainedModel)\n",
    "from transformers.modeling_outputs import CausalLMOutputWithPast\n",
    "\n",
    "\n",
    "class FourierPointEncoder(nn.Module):\n",
    "    def __init__(self, hidden_size):\n",
    "        super().__init__()\n",
    "        frequencies = 2.0 ** torch.arange(8, dtype=torch.float32)\n",
    "        self.register_buffer('frequencies', frequencies, persistent=False)\n",
    "        self.projection = nn.Linear(54, hidden_size)\n",
    "\n",
    "    def forward(self, points):\n",
    "        x = points[..., :3]\n",
    "        x = (x.unsqueeze(-1) * self.frequencies).view(*x.shape[:-1], -1)\n",
    "        x = torch.cat((points[..., :3], x.sin(), x.cos()), dim=-1)\n",
    "        x = self.projection(torch.cat((x, points[..., 3:]), dim=-1))\n",
    "        return x\n",
    "\n",
    "\n",
    "class CADRecode(Qwen2ForCausalLM):\n",
    "    def __init__(self, config):\n",
    "        PreTrainedModel.__init__(self, config)\n",
    "        self.model = Qwen2Model(config)\n",
    "        self.vocab_size = config.vocab_size\n",
    "        self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)\n",
    "        \n",
    "        torch.set_default_dtype(torch.float32)\n",
    "        self.point_encoder = FourierPointEncoder(config.hidden_size)\n",
    "        torch.set_default_dtype(torch.bfloat16)\n",
    "\n",
    "    def forward(self,\n",
    "                input_ids=None,\n",
    "                attention_mask=None,\n",
    "                point_cloud=None,\n",
    "                position_ids=None,\n",
    "                past_key_values=None,\n",
    "                inputs_embeds=None,\n",
    "                labels=None,\n",
    "                use_cache=None,\n",
    "                output_attentions=None,\n",
    "                output_hidden_states=None,\n",
    "                return_dict=None,\n",
    "                cache_position=None):\n",
    "        output_attentions = output_attentions if output_attentions is not None else self.config.output_attentions\n",
    "        output_hidden_states = output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states\n",
    "        return_dict = return_dict if return_dict is not None else self.config.use_return_dict\n",
    "\n",
    "        # concatenate point and text embeddings\n",
    "        if past_key_values is None or past_key_values.get_seq_length() == 0:\n",
    "            assert inputs_embeds is None\n",
    "            inputs_embeds = self.model.embed_tokens(input_ids)\n",
    "            point_embeds = self.point_encoder(point_cloud).bfloat16()\n",
    "            inputs_embeds[attention_mask == -1] = point_embeds.reshape(-1, point_embeds.shape[2])\n",
    "            attention_mask[attention_mask == -1] = 1\n",
    "            input_ids = None\n",
    "            position_ids = None\n",
    "\n",
    "        # decoder outputs consists of (dec_features, layer_state, dec_hidden, dec_attn)\n",
    "        outputs = self.model(\n",
    "            input_ids=input_ids,\n",
    "            attention_mask=attention_mask,\n",
    "            position_ids=position_ids,\n",
    "            past_key_values=past_key_values,\n",
    "            inputs_embeds=inputs_embeds,\n",
    "            use_cache=use_cache,\n",
    "            output_attentions=output_attentions,\n",
    "            output_hidden_states=output_hidden_states,\n",
    "            return_dict=return_dict,\n",
    "            cache_position=cache_position)\n",
    "\n",
    "        hidden_states = outputs[0]\n",
    "        logits = self.lm_head(hidden_states)\n",
    "        logits = logits.float()\n",
    "\n",
    "        loss = None\n",
    "        if labels is not None:\n",
    "            # Shift so that tokens < n predict n\n",
    "            shift_logits = logits[..., :-1, :].contiguous()\n",
    "            shift_labels = labels[..., 1:].contiguous()\n",
    "            # Flatten the tokens\n",
    "            loss_fct = nn.CrossEntropyLoss()\n",
    "            shift_logits = shift_logits.view(-1, self.config.vocab_size)\n",
    "            shift_labels = shift_labels.view(-1)\n",
    "            # Enable model parallelism\n",
    "            shift_labels = shift_labels.to(shift_logits.device)\n",
    "            loss = loss_fct(shift_logits, shift_labels)\n",
    "\n",
    "        if not return_dict:\n",
    "            output = (logits,) + outputs[1:]\n",
    "            return (loss,) + output if loss is not None else output\n",
    "\n",
    "        return CausalLMOutputWithPast(\n",
    "            loss=loss,\n",
    "            logits=logits,\n",
    "            past_key_values=outputs.past_key_values,\n",
    "            hidden_states=outputs.hidden_states,\n",
    "            attentions=outputs.attentions)\n",
    "\n",
    "    def prepare_inputs_for_generation(self, *args, **kwargs):\n",
    "        model_inputs = super().prepare_inputs_for_generation(*args, **kwargs)\n",
    "        model_inputs['point_cloud'] = kwargs['point_cloud']\n",
    "        return model_inputs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load CAD-Recode checkpoint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "attn_implementation = 'flash_attention_2' if torch.cuda.is_available() else None\n",
    "tokenizer = AutoTokenizer.from_pretrained(\n",
    "    'Qwen/Qwen2-1.5B',\n",
    "    pad_token='<|im_end|>',\n",
    "    padding_side='left')\n",
    "model = CADRecode.from_pretrained(\n",
    "    'filapro/cad-recode',\n",
    "    torch_dtype='auto',\n",
    "    attn_implementation=attn_implementation).eval().to(device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load input point cloud\n",
    "Load the mesh of one of the examples from the Fusion360 test set and sample 256 points from it. Then input mesh is normalized to fit within a cube of size 2, centered at the origin. Both the mesh and point cloud can be visualized interactively in this notebook using `open3d` or `trimesh`; however, for non-interactive environments, we render them as static images."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!wget https://github.com/filaPro/cad-recode/releases/download/v1.0/49215_5368e45e_0000.stl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mesh_to_point_cloud(mesh, n_points=256):\n",
    "    vertices, faces = trimesh.sample.sample_surface(mesh, n_points)\n",
    "    point_cloud = np.concatenate((\n",
    "        np.asarray(vertices),\n",
    "        mesh.face_normals[faces]\n",
    "    ), axis=1)\n",
    "    ids = np.lexsort((point_cloud[:, 0], point_cloud[:, 1], point_cloud[:, 2]))\n",
    "    point_cloud = point_cloud[ids]\n",
    "    return point_cloud\n",
    "\n",
    "\n",
    "gt_mesh = trimesh.load_mesh('./49215_5368e45e_0000.stl')\n",
    "gt_mesh.apply_translation(-(gt_mesh.bounds[0] + gt_mesh.bounds[1]) / 2.0)\n",
    "gt_mesh.apply_scale(2.0 / max(gt_mesh.extents))\n",
    "np.random.seed(42)\n",
    "point_cloud = mesh_to_point_cloud(gt_mesh)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's have a look at input point cloud\n",
    "It looks like a table with four legs!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def render(geometry, image_size=128, camera_distance=-1.8, image_path='/tmp/tmp.png'):\n",
    "    visualizer = open3d.visualization.Visualizer()\n",
    "    visualizer.create_window(width=image_size * 4, height=image_size * 4)\n",
    "    visualizer.add_geometry(geometry)\n",
    "\n",
    "    lookat = np.array([0, 0, 0], dtype=np.float32)\n",
    "    front = np.array([1, 1, 1], dtype=np.float32)\n",
    "    up = np.array([0, 1, 0], dtype=np.float32)\n",
    "    eye = lookat + front * camera_distance\n",
    "    right = np.cross(up, front)\n",
    "    right /= np.linalg.norm(right)\n",
    "    true_up = np.cross(front, right)\n",
    "    rotation_matrix = np.column_stack((right, true_up, front)).T\n",
    "    extrinsic = np.eye(4)\n",
    "    extrinsic[:3, :3] = rotation_matrix\n",
    "    extrinsic[:3, 3] = -rotation_matrix @ eye\n",
    "\n",
    "    view_control = visualizer.get_view_control()\n",
    "    camera_params = view_control.convert_to_pinhole_camera_parameters()\n",
    "    camera_params.extrinsic = extrinsic\n",
    "    view_control.convert_from_pinhole_camera_parameters(camera_params)\n",
    "\n",
    "    visualizer.poll_events()\n",
    "    visualizer.update_renderer()\n",
    "    visualizer.capture_screen_image(image_path)\n",
    "    visualizer.destroy_window()\n",
    "\n",
    "    image = skimage.io.imread(image_path)\n",
    "    image = skimage.transform.resize(\n",
    "        image,\n",
    "        output_shape=(image_size, image_size),\n",
    "        order=2,\n",
    "        anti_aliasing=True,\n",
    "        preserve_range=True).astype(np.uint8)\n",
    "    return image\n",
    "\n",
    "pcd = open3d.geometry.PointCloud()\n",
    "pcd.points = open3d.utility.Vector3dVector(point_cloud[:, :3])\n",
    "pcd.normals = open3d.utility.Vector3dVector(point_cloud[:, 3:])\n",
    "pcd.paint_uniform_color(np.array([0, 80, 239]) / 255)\n",
    "plt.figure(figsize=(3, 3))\n",
    "_ = plt.imshow(render(pcd))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run CAD-Recode on the input point cloud"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "import cadquery as cq\n",
      "w0=cq.Workplane('XY',origin=(0,0,14))\n",
      "r=w0.sketch().push([(-37,-33)]).circle(5).push([(-37,36)]).circle(5).push([(40,-34)]).circle(6).push([(39,36)]).circle(5).finalize().extrude(-38).union(w0.workplane(offset=10/2).box(100,84,10))\n"
     ]
    }
   ],
   "source": [
    "input_ids = [tokenizer.pad_token_id] * len(point_cloud) + [tokenizer('<|im_start|>')['input_ids'][0]]\n",
    "attention_mask = [-1] * len(point_cloud) + [1]\n",
    "with torch.no_grad():\n",
    "    batch_ids = model.generate(\n",
    "        input_ids=torch.tensor(input_ids).unsqueeze(0).to(model.device),\n",
    "        attention_mask=torch.tensor(attention_mask).unsqueeze(0).to(model.device),\n",
    "        point_cloud=torch.tensor(point_cloud.astype(np.float32)).unsqueeze(0).to(model.device),\n",
    "        max_new_tokens=768,\n",
    "        pad_token_id=tokenizer.pad_token_id)\n",
    "py_string = tokenizer.batch_decode(batch_ids)[0]\n",
    "begin = py_string.find('<|im_start|>') + 12\n",
    "end = py_string.find('<|endoftext|>')\n",
    "py_string = py_string[begin: end]\n",
    "print(py_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Execute predicted python code to raise a CAD model\n",
    "The predicted code might be invalid or could potentially cause memory leaks in CadQuery, as described in this [issue](https://github.com/CadQuery/cadquery/issues/1665).  Therefore, it is recommended to run the next cell in a separate process with a timeout of, for example, 3 seconds.:\n",
    "```\n",
    "process = Process(target=..., args=...)\n",
    "process.start()\n",
    "process.join(3)\n",
    "\n",
    "if process.is_alive():\n",
    "    process.terminate()\n",
    "    process.join()\n",
    "```\n",
    "But in this demo safety is omitted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "exec(py_string, globals())\n",
    "compound = globals()['r'].val()\n",
    "vertices, faces = compound.tessellate(0.001, 0.1)\n",
    "mesh = trimesh.Trimesh([(v.x, v.y, v.z) for v in vertices], faces)\n",
    "mesh.export('/tmp/1.stl')\n",
    "cq.exporters.export(compound, '/tmp/1.step')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 300x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "mesh = open3d.io.read_triangle_mesh('/tmp/1.stl')\n",
    "mesh.vertices = open3d.utility.Vector3dVector(np.asarray(mesh.vertices) / 50.)\n",
    "mesh.paint_uniform_color(np.array([255, 255, 136]) / 255)\n",
    "mesh.compute_vertex_normals()\n",
    "plt.figure(figsize=(3, 3))\n",
    "_ = plt.imshow(render(mesh))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Compute IoU and Chamfer distance metrics\n",
    "The predicted model resembles a table, but let's calculate how closely it matches the ground truth mesh."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CD: 0.232, IoU: 0.922\n"
     ]
    }
   ],
   "source": [
    "pred_mesh = trimesh.load_mesh('/tmp/1.stl')\n",
    "pred_mesh.apply_transform(trimesh.transformations.scale_matrix(1 / 50 / 2))\n",
    "pred_mesh.apply_transform(trimesh.transformations.translation_matrix([0.5, 0.5, 0.5]))\n",
    "gt_mesh.apply_transform(trimesh.transformations.scale_matrix(1 / 2))\n",
    "gt_mesh.apply_transform(trimesh.transformations.translation_matrix([0.5, 0.5, 0.5]))\n",
    "\n",
    "n_points = 8192\n",
    "gt_points, _ = trimesh.sample.sample_surface(gt_mesh, n_points)\n",
    "pred_points, _ = trimesh.sample.sample_surface(pred_mesh, n_points)\n",
    "gt_distance, _ = cKDTree(gt_points).query(pred_points, k=1)\n",
    "pred_distance, _ = cKDTree(pred_points).query(gt_points, k=1)\n",
    "cd = np.mean(np.square(gt_distance)) + np.mean(np.square(pred_distance))\n",
    "\n",
    "intersection_volume = 0\n",
    "for gt_mesh_i in gt_mesh.split():\n",
    "    for pred_mesh_i in pred_mesh.split():\n",
    "        intersection = gt_mesh_i.intersection(pred_mesh_i)\n",
    "        volume = intersection.volume if intersection is not None else 0\n",
    "        intersection_volume += volume\n",
    "\n",
    "gt_volume = sum(m.volume for m in gt_mesh.split())\n",
    "pred_volume = sum(m.volume for m in pred_mesh.split())\n",
    "union_volume = gt_volume + pred_volume - intersection_volume\n",
    "iou = intersection_volume / union_volume\n",
    "\n",
    "print(f'CD: {cd * 1000:.3f}, IoU: {iou:.3f}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}