diff --git a/README.md b/README.md index 00174c3..a788671 100644 --- a/README.md +++ b/README.md @@ -56,6 +56,7 @@ Raw dataset size is 1.9TB (including videos and their annotations). Total datase - [Parsing the AR metadata](https://github.com/google-research-datasets/Objectron/blob/master/notebooks/objectron-geometry-tutorial.ipynb) - [Evaluating the model performance with 3D IoU](https://github.com/google-research-datasets/Objectron/blob/master/notebooks/3D_IOU.ipynb) - [SequenceExample tutorial](https://github.com/google-research-datasets/Objectron/blob/master/notebooks/SequenceExamples.ipynb) +- [Training a NeRF model](https://github.com/google-research-datasets/Objectron/blob/master/notebooks/Objectron_NeRF_Tutorial.ipynb) ## License Objectron is released under [Computational Use of Data Agreement 1.0 (C-UDA-1.0)](https://github.com/microsoft/Computational-Use-of-Data-Agreement). A [copy](https://github.com/google-research-datasets/Objectron/blob/master/LICENSE) of the license is available in this repository. diff --git a/notebooks/Objectron_NeRF_Tutorial.ipynb b/notebooks/Objectron_NeRF_Tutorial.ipynb new file mode 100644 index 0000000..cae6deb --- /dev/null +++ b/notebooks/Objectron_NeRF_Tutorial.ipynb @@ -0,0 +1,596 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7f4a0bfc-83e2-4b76-a7a1-fdfbb6fb51f0", + "metadata": {}, + "source": [ + "# Objectron JaxNeRF Tutorial" + ] + }, + { + "cell_type": "markdown", + "id": "6a2bb4bf-edac-41f1-9891-bc80cf464677", + "metadata": {}, + "source": [ + "This notebook shows how to train a NeRF ([NeRF: Representing Scenes as Neural Radiance Fields for View Synthesis](https://www.matthewtancik.com/nerf)) model using the Objectron dataset and [JaxNeRF](https://github.com/google-research/google-research/tree/master/jaxnerf)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a33dab88-6b13-40b9-a46e-566c3268de7a", + "metadata": {}, + "outputs": [], + "source": [ + "import glob\n", + "import os\n", + "import struct\n", + "import sys\n", + "\n", + "import cv2\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import requests\n", + "from matplotlib import image\n", + "from mpl_toolkits.mplot3d import art3d\n", + "from os import path\n", + "\n", + "module_path = os.path.abspath(os.path.join('..'))\n", + "if module_path not in sys.path:\n", + " sys.path.append(module_path)\n", + " \n", + "# The AR Metadata captured with each frame in the video\n", + "from objectron.schema import a_r_capture_metadata_pb2 as ar_metadata_protocol" + ] + }, + { + "cell_type": "markdown", + "id": "4866be5b-1de2-41d4-bde8-63aceb27664d", + "metadata": {}, + "source": [ + "## Downloading a video sequence" + ] + }, + { + "cell_type": "markdown", + "id": "b159b116-3ea9-4e9c-9c76-fe02ce72ce29", + "metadata": {}, + "source": [ + "To get started, follow the [Download Objectron Data](https://github.com/google-research-datasets/Objectron/blob/master/notebooks/Download%20Data.ipynb) tutorial\n", + "and download a video and AR metadata file (geometry.pbdata) as shown below.\n", + "We use the `chair/batch-24/33` sequence in this tutorial." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d5547557-24fe-4f44-b8df-c195dbdd9237", + "metadata": {}, + "outputs": [], + "source": [ + "video_id = 'chair/batch-24/33'\n", + "download_dir = './nerf_data'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a545e12c-1fc1-471e-8e76-4b7035eed323", + "metadata": {}, + "outputs": [], + "source": [ + "os.makedirs(download_dir, exist_ok=True)\n", + "public_url = \"https://storage.googleapis.com/objectron\"\n", + "urls = [f'{public_url}/videos/{video_id}/video.MOV',\n", + " f'{public_url}/videos/{video_id}/geometry.pbdata']\n", + "for url in urls:\n", + " with open(path.join(download_dir, path.basename(url)), \"wb\") as f:\n", + " f.write(requests.get(url).content)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "acc6c4c7-f09b-4fbe-8ab8-62a11f9aeb90", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 23M\n", + "3.3M geometry.pbdata\n", + " 12K \u001b[0m\u001b[01;34mimages_8\u001b[0m/\n", + " 40K poses_bounds.npy\n", + " 20M video.MOV\n" + ] + } + ], + "source": [ + "ls -sh1 ./nerf_data" + ] + }, + { + "cell_type": "markdown", + "id": "f04830f3-c60d-41b1-a36f-cbb3ef5b94f6", + "metadata": {}, + "source": [ + "## Preparing video frames" + ] + }, + { + "cell_type": "markdown", + "id": "77d6b94a-ca85-4c62-8221-d7d6d8872368", + "metadata": {}, + "source": [ + "Run the following commands to extract RGB frames from the video (FFmpeg required). We downsample the images by a factor of 8 for faster training." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ccd7964e-0787-4c83-902d-dfec92a8b49d", + "metadata": {}, + "outputs": [], + "source": [ + "%%bash\n", + "cd nerf_data/\n", + "mkdir -p \"images_8\"\n", + "ffmpeg -i video.MOV -vsync vfr -vf \"scale=iw/8:ih/8\" -start_number 0 \"images_8/%05d.png\"" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "a5726ac1-ca36-4d9d-834f-6c68722e947a", + "metadata": {}, + "outputs": [], + "source": [ + "sequence_filenames = sorted(glob.glob('nerf_data/images_8/*.png'))\n", + "geometry_filename = 'nerf_data/geometry.pbdata'" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3e14c0f3-f9de-4da1-a0e0-6f02d0595651", + "metadata": {}, + "outputs": [], + "source": [ + "def load_frame_data(geometry_filename):\n", + " # See get_geometry_data in objectron-geometry-tutorial.ipynb\n", + " frame_data = []\n", + " with open(geometry_filename, 'rb') as pb:\n", + " proto_buf = pb.read()\n", + "\n", + " i = 0\n", + " while i < len(proto_buf):\n", + " msg_len = struct.unpack('" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "274 PNG files found\n" + ] + } + ], + "source": [ + "step = 50\n", + "\n", + "plt.figure(figsize=(10,3))\n", + "plt.imshow(np.concatenate([image.imread(filename) for filename in sequence_filenames[::step]], axis=1))\n", + "plt.axis('off')\n", + "plt.show()\n", + "print(f'{len(sequence_filenames)} PNG files found')" + ] + }, + { + "cell_type": "markdown", + "id": "89e7941d-df0f-4774-9aa3-531c1a5121fa", + "metadata": {}, + "source": [ + "## Preparing camera poses" + ] + }, + { + "cell_type": "markdown", + "id": "edd22703-631d-4cba-a50d-7fd71698bd2d", + "metadata": {}, + "source": [ + "Next, process Objectron's camera poses (captured through an AR session; see [ARKit](https://developer.apple.com/documentation/arkit/arcamera/2866108-transform) documentation)\n", + "and convert to the [LLFF](https://github.com/Fyusion/LLFF#using-your-own-poses-without-running-colmap) format accepted by JaxNeRF." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b599441c-6c34-4073-9ad4-75b2979a2308", + "metadata": {}, + "outputs": [], + "source": [ + "def make_poses_bounds_array(frame_data, near=0.2, far=10):\n", + " # See https://github.com/Fyusion/LLFF#using-your-own-poses-without-running-colmap\n", + " # Returns an array of shape (N, 17).\n", + " rows = []\n", + " for frame in frame_data:\n", + " camera = frame.camera\n", + " cam_to_world = np.array(camera.transform).reshape(4,4)[:3]\n", + " w = camera.image_resolution_width\n", + " h = camera.image_resolution_height\n", + " assert w>=h, (w, h) # assume landscape\n", + " # JaxNeRF assumes x,y focal lengths are equal.\n", + " row = llff_pose(cam_to_world, image_hw=[w, h],\n", + " focal=camera.intrinsics[0], near=near, far=far)\n", + " rows.append(row)\n", + " return np.vstack(rows)\n", + "\n", + "def llff_pose(cam_to_world_mat34, image_hw, focal, near, far):\n", + " # Returns an array of shape (17,).\n", + " col = np.concatenate([image_hw, [focal]]).reshape(-1, 1)\n", + " mat35 = np.hstack([cam_to_world_mat34, col])\n", + " return np.concatenate([mat35.ravel(), [near, far]])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "9d3873be-67fe-4c36-8212-ae2b35897dd4", + "metadata": {}, + "outputs": [], + "source": [ + "frame_data = load_frame_data(geometry_filename)\n", + "poses = make_poses_bounds_array(frame_data, near=0.2, far=10)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "e74a5043-0779-4f54-a7b1-c9cd4ce5dded", + "metadata": {}, + "outputs": [], + "source": [ + "np.save('nerf_data/poses_bounds.npy', poses)" + ] + }, + { + "cell_type": "markdown", + "id": "5334b6e5-bbe8-4fe6-90ba-33cf8f03bee7", + "metadata": {}, + "source": [ + "The data directory should now look like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a2b7ffbc-3947-462a-b35b-d0a04f08a87e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total 23M\n", + "3.3M geometry.pbdata\n", + " 12K \u001b[0m\u001b[01;34mimages_8\u001b[0m/\n", + " 40K poses_bounds.npy\n", + " 20M video.MOV\n" + ] + } + ], + "source": [ + "ls -sh1 nerf_data/" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "7a257125-ba14-499b-91fb-ea0feb56130e", + "metadata": {}, + "outputs": [], + "source": [ + "def feature_points_from_frame_data(frames):\n", + " # Returns an array of shape (N, 3).\n", + " points = []\n", + " for frame in frames:\n", + " for v in frame.raw_feature_points.point:\n", + " points.append([v.x, v.y, v.z])\n", + " return np.array(points)\n", + "\n", + "def draw_points(points):\n", + " ax.scatter(points[:,0], points[:,1], points[:,2],\n", + " marker='.', s=0.4)\n", + " ax.set_box_aspect(np.ptp(points, axis=0))\n", + "\n", + "def draw_camera(Rt, ax, scale):\n", + " # Rt: 3x4 cam-to-world matrix\n", + " R, t = Rt[:, :3].T, Rt[:,3]\n", + " start_pts = np.tile(t, [3, 1])\n", + " end_pts = scale * R + t\n", + " lines = np.array([start_pts, end_pts]).transpose(1,0,2)\n", + " colors=['red', 'blue', 'green']\n", + " texts=['-y', 'x', 'z']\n", + " ax.add_collection3d(\n", + " art3d.Line3DCollection(lines, linewidths=1, colors=colors))\n", + " for i, text in enumerate(texts):\n", + " ax.text(lines[i,1,0], lines[i,1,1], lines[i,1,2],\n", + " text, color='black')\n", + " return ax\n", + "\n", + "def draw_scene(ax, points, poses):\n", + " dists = np.linalg.norm(points-points.mean(0), axis=1)\n", + " # Get rid of outliers for visualization.\n", + " points = points[dists" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# There should be 274 image-camera pairs. Plot every 40th camera.\n", + "step = 40\n", + "# To make sure the cameras are oriented correctly, we also plot a point cloud of the object.\n", + "points = feature_points_from_frame_data(frame_data)\n", + "\n", + "fig = plt.figure(figsize=(10,5))\n", + "\n", + "ax = fig.add_subplot(1, 2, 1, projection='3d')\n", + "draw_scene(ax, points[::step], poses[::step])\n", + "ax.view_init(107, -90)\n", + "\n", + "ax = fig.add_subplot(1, 2, 2, projection='3d')\n", + "draw_scene(ax, points[::step], poses[::step])\n", + "ax.view_init(180, -90)\n", + "\n", + "fig.suptitle('LLFF Camera Coordinates')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4476504a-f36c-44ae-86d3-4348d5eccfa6", + "metadata": {}, + "source": [ + "## Training a NeRF model" + ] + }, + { + "cell_type": "markdown", + "id": "06b9cbfa-7fd6-4141-b7e1-e3a2fadd89a2", + "metadata": {}, + "source": [ + "Clone the JaxNeRF repo and follow the installation instructions: https://github.com/google-research/google-research/tree/master/jaxnerf" + ] + }, + { + "cell_type": "markdown", + "id": "f9cd907c-b4c3-4321-b155-849c7188062b", + "metadata": {}, + "source": [ + "Save the configuration below as `configs/objectron_small.yaml` in the cloned `jaxnerf/` directory.\n", + "\n", + "```yaml\n", + "dataset: llff\n", + "batching: all_images\n", + "num_coarse_samples: 64\n", + "num_fine_samples: 128\n", + "use_viewdirs: true\n", + "white_bkgd: false\n", + "batch_size: 256\n", + "randomized: true\n", + "near: 0.2\n", + "far: 10\n", + "factor: 8\n", + "llffhold: 8\n", + "noise_std: 1.\n", + "lr_init: 2.0e-3\n", + "lr_final: 2.0e-5\n", + "lr_delay_steps: 2500\n", + "lr_delay_mult: 0.1\n", + "max_steps: 250000\n", + "save_every: 5000\n", + "render_every: 5000\n", + "gc_every: 7500\n", + "spherify: True\n", + "lindisp: True\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "eafd3764-90b6-4250-a17a-930d8fc3e021", + "metadata": {}, + "source": [ + "Then run the following command in a terminal to train NeRF. `--data_dir` corresponds to the `nerf_data` directory containing the RGB frames (in an `images_8` subdirectory) and camera poses (`poses_bounds.npy`)." + ] + }, + { + "cell_type": "markdown", + "id": "720f4b72-244a-46b6-ad68-340130ffefe9", + "metadata": {}, + "source": [ + "```\n", + "python -m jaxnerf.train \\\n", + " --data_dir=./nerf_data \\\n", + " --train_dir=/PATH/TO/CHECKPOINTS \\\n", + " --config=configs/objectron_small\n", + "```" + ] + }, + { + "cell_type": "markdown", + "id": "5b159536-3116-4e02-9546-777a0ab9cd8f", + "metadata": {}, + "source": [ + "After training is finished (250k steps), we can evaluate on novel views. In the config file above, `llffhold: 8` means 1/8 of the images (every 8th) will be held out for testing." + ] + }, + { + "cell_type": "markdown", + "id": "8a69bfe2-63ec-41a9-9982-307ff41f11d3", + "metadata": {}, + "source": [ + "```\n", + "python -m jaxnerf.eval \\\n", + " --data_dir=./nerf_data \\\n", + " --train_dir=/PATH/TO/CHECKPOINTS \\\n", + " --config=configs/objectron_small\n", + " --chunk=4096\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "aa6101f3-242b-4ae5-a340-07a8e934aa88", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PSNR 29.48\n", + "SSIM 0.89\n" + ] + } + ], + "source": [ + "step = 3 # Visualize every 3th example.\n", + "checkpoint_dir = '/PATH/TO/CHECKPOINTS/'\n", + "\n", + "output_filenames = sorted(glob.glob(path.join(checkpoint_dir, 'test_preds/*.png')))\n", + "plt.figure(figsize=(14,2))\n", + "plt.title('Novel-view RGB Output')\n", + "plt.imshow(np.concatenate([image.imread(filename) for filename in output_filenames[::step] if '/disp_' not in filename], axis=1))\n", + "plt.axis('off')\n", + "\n", + "plt.figure(figsize=(14,2))\n", + "plt.title('Disparity Maps')\n", + "plt.imshow(np.concatenate([image.imread(filename) for filename in output_filenames[::step] if '/disp_' in filename], axis=1), cmap='gray')\n", + "plt.axis('off')\n", + "plt.show()\n", + "\n", + "with open(path.join(checkpoint_dir, 'test_preds/psnr.txt'), 'r') as f:\n", + " print('PSNR {:.2f}'.format(float(f.read())))\n", + "with open(path.join(checkpoint_dir, 'test_preds/ssim.txt'), 'r') as f:\n", + " print('SSIM {:.2f}'.format(float(f.read())))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python [conda env:fast]", + "language": "python", + "name": "conda-env-fast-py" + }, + "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.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}