From eab40ff5ba0cface0e0dc72de232e3a3bb784cb4 Mon Sep 17 00:00:00 2001 From: ShahVishrut <53956360+ShahVishrut@users.noreply.github.com> Date: Fri, 14 Jun 2024 01:18:47 -0700 Subject: [PATCH] Created using Colab --- docs/tutorials/DAVIS_Direction.ipynb | 724 +++++++++++++++++++++++++++ 1 file changed, 724 insertions(+) create mode 100644 docs/tutorials/DAVIS_Direction.ipynb diff --git a/docs/tutorials/DAVIS_Direction.ipynb b/docs/tutorials/DAVIS_Direction.ipynb new file mode 100644 index 00000000..74e73e18 --- /dev/null +++ b/docs/tutorials/DAVIS_Direction.ipynb @@ -0,0 +1,724 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Training an SNN Model Using DAVISDATA\n", + "#### By Vishrut Shah (vsshah@ucsc.edu)" + ], + "metadata": { + "id": "eQQM61WutIG2" + } + }, + { + "cell_type": "markdown", + "source": [ + "This tutorial shows how to work with the DAVIS camera dataset using Tonic as well as set up and train a spiking neural network model (snn) using snnTorch to output basic odometry data based on event camera data.\n", + "Runtime: 45-60 minutes (on GPU)" + ], + "metadata": { + "id": "2EAuNA5-N2BB" + } + }, + { + "cell_type": "markdown", + "source": [ + "# 1. Background" + ], + "metadata": { + "id": "dnktWEZCJ4se" + } + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fBN6SwtC_K4Y" + }, + "source": [ + "https://tonic.readthedocs.io/en/latest/generated/tonic.datasets.DAVISDATA.html#\n", + "\n", + "http://rpg.ifi.uzh.ch/davis_data.html" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 1.1 Event Cameras\n", + "An event camera consists of a set of pixels that record changes in brightness independently and asynchronously. In other words, each pixel stays inactive unless a change in brightness occurs at the location of the pixel, in which case said pixel logs its location, timestamp, and whether the brightness increased or decreased at that point. Due to the nature of this data, with specific pixels activating at specific times, this is well-suited for a Spiking Neural Network, which relies on neurons \"spiking\" or outputting at specific times.\n", + "\n", + "### 1.1.1 Frames\n", + "Throughout this tutorial, I will be using the word \"frames\" a lot. In the context of an event-based camera, a frame groups events into constant time intervals. Each frame is essentially a 2D-array, representing the grid of camera pixels. The number at each pixel in the 2D-array represents the number of events (changes in brightness) at that pixel in that time interval. Oftentimes, such as in this tutorial, there are 2 2D-arrays (channels) for each frame, one for events registering an increase in brightness, and one for events registering a decrease." + ], + "metadata": { + "id": "qCg-OSqFIkbG" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 1.2 DAVISDATA\n", + "The DAVIS (Dynamic and Active-pixel Vision Sensor) event camera dataset consists of several recordings of different scenes. Each recording provides the following data across several timestamps:\n", + "* event camera logs\n", + "* grayscale images\n", + "* inertial measurements\n", + "* position and orientation of camera (ground truth)" + ], + "metadata": { + "id": "qxaTrkyJQk1E" + } + }, + { + "cell_type": "markdown", + "source": [ + "# 2. Installation and Preliminary Setup" + ], + "metadata": { + "id": "bIE6RkQyiKi5" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 2.1 Python Libraries\n", + "Install and import the necessary libraries." + ], + "metadata": { + "id": "j9cDVRfuja1Z" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "VY48601qjjXi" + }, + "outputs": [], + "source": [ + "!pip install snntorch --quiet\n", + "!pip install tonic --quiet" + ] + }, + { + "cell_type": "code", + "source": [ + "import snntorch as snn\n", + "from snntorch import surrogate\n", + "from snntorch import functional as SF\n", + "from snntorch import spikeplot as splt\n", + "from snntorch import utils\n", + "\n", + "import tonic\n", + "from tonic.datasets import DAVISDATA\n", + "\n", + "import torch\n", + "import torchvision\n", + "import torch.nn as nn\n", + "from torch.utils.data import DataLoader, random_split\n", + "\n", + "import numpy\n", + "from IPython.display import HTML\n", + "import statistics\n", + "import matplotlib.pyplot as plt" + ], + "metadata": { + "id": "dLU6pIRgsJor" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "##2.2 Dataset Download\n", + "Next, we download the desired recordings using Tonic. The Tonic library greatly simplifies downloading and working with event-based datasets. For this task, we download the main recordings involving translational motion of the camera. This may take several minutes." + ], + "metadata": { + "id": "LTkuvNRGUQtI" + } + }, + { + "cell_type": "code", + "source": [ + "dataset = DAVISDATA(save_to='./data', recording=['shapes_translation', 'poster_translation', 'boxes_translation', 'dynamic_translation'])" + ], + "metadata": { + "id": "HTvyebTTO2eE" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 2.3 Visualization\n", + "Interested in seeing what you just downloaded? The code below allows for visualization of the recordings. Increase the time_window value if you would like to consume less memory. Running this snippet may cause a lot of warnings. Don't worry, this is expected." + ], + "metadata": { + "id": "MNUAsckOUPEv" + } + }, + { + "cell_type": "code", + "source": [ + "which_recording = 0 # Replace with index of recording you want to visualize\n", + "\n", + "transform = tonic.transforms.ToFrame(\n", + " sensor_size = dataset.sensor_size,\n", + " time_window = 50000,\n", + ")\n", + "\n", + "frames = transform(dataset[which_recording][0][0])\n", + "\n", + "animation = tonic.utils.plot_animation(frames);\n", + "HTML(animation.to_jshtml())" + ], + "metadata": { + "id": "napNb-Hc7w72", + "collapsed": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Here's an image of a single frame of the shapes_translation recording.\n", + "\n", + "\n", + "![download (1).png](data:image/png;base64,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)" + ], + "metadata": { + "id": "0MNrwGr7zFwS" + } + }, + { + "cell_type": "markdown", + "source": [ + "# 3. Formatting the Data" + ], + "metadata": { + "id": "KXuoyuSKycwQ" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 3.1 The Issue\n", + "The DAVIS dataset contains a LOT of data. Using each raw recording as a single data point would get highly complex and computationally expensive quite fast, both in terms of the high amount of data in the input, and also the requirement for the model to produce a complex output. For example, consider the target/label of the \"shapes_translation\" recording. We might expect a single number, or a vector of numbers. Let's try printing it out." + ], + "metadata": { + "id": "oPdQQRfAUh7N" + } + }, + { + "cell_type": "code", + "source": [ + "print(dataset[0][1])" + ], + "metadata": { + "id": "56P8RaO3lwxh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "As we can see, we get a whole dictionary containing the positions and orientations of the camera across thousands of timestamps. Trying to get the model to output all this information from a recording would take a lot of computational resources and time." + ], + "metadata": { + "id": "dOsY0TVuSwvb" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 3.2 Proposed Solution\n", + "\n", + "Instead, let's train our model on something more understandable. To do this, we rearrange the dataset in a custom format that preserves the relevant information, and allows us to have inputs and desired outputs of a much smaller dimension. In this case, the proposed setup is as follows:\n", + "\n", + "From each recording, create several datapoints of the form (frames, direction).\n", + "\n", + "* frames = set of n consecutive frames taken from the recording\n", + "* direction = whether the camera was moving left or right while recording those n frames. Note: other directions are excluded becuase they are not mutually exclusive from left-right\n", + "\n", + "In other words, we have simplified this to a binary classification task.\n", + "\n", + "The input frames come from the event recordings. Where does the actual value for the direction come from (to compare to the model's output and perform gradient descent)? This will come from the dictionary we printed out earlier. We can find the x position of the camera at the timestamp of the first frame and compare that to the x position of the camera at the timestamp of the last frame." + ], + "metadata": { + "id": "t7MYQPhCZSC-" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 3.3 Implementation of Solution\n", + "This first function below is optional, if you would like to compress your frames to save memory." + ], + "metadata": { + "id": "kycuFcFFGOS5" + } + }, + { + "cell_type": "code", + "source": [ + "# This function will only get called if the downsample flag is set to true\n", + "def downsample(frames, factor):\n", + " num_frames, channels, height, width = frames.shape\n", + "\n", + " # Calculate new dimensions\n", + " new_height = height // factor\n", + " new_width = width // factor\n", + "\n", + " # Initialize the downsampled array\n", + " downsampled_frames = numpy.zeros((num_frames, channels, new_height, new_width))\n", + "\n", + " for frame_idx in range(num_frames): # for each frame / channel, divide the array into blocks and sum the values in each block, creating a new array reducing each block into a single value corresponding to the sum\n", + " for channel in range(channels):\n", + " for i in range(new_height):\n", + " for j in range(new_width):\n", + " block = frames[frame_idx, channel, i*factor:(i+1)*factor, j*factor:(j+1)*factor]\n", + " block_sum = numpy.sum(block)\n", + " downsampled_frames[frame_idx, channel, i, j] = block_sum\n", + "\n", + " return downsampled_frames.astype(numpy.int16)" + ], + "metadata": { + "collapsed": true, + "id": "MzmJ7XOax508" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "The code below iterates through each recording, creates frames, and computes the target values for each set of n frames." + ], + "metadata": { + "id": "5oNhTOc0dX8F" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vr0EZpDSj8SU" + }, + "outputs": [], + "source": [ + "downsample = False # Modify if you would like to compress the frames to have a smaller dimension\n", + "downsample_factor = 7 # How much to compress each dimension by\n", + "frames = list()\n", + "velocities = list()\n", + "\n", + "for i in range(len(dataset)): # Iterate through each recording\n", + " groundtruth = dataset[i][1]\n", + "\n", + " mean_diff = numpy.diff(list(zip(groundtruth[\"ts\"], groundtruth[\"ts\"][1:]))).mean() # Calculates the average time between each measurement of the groundtruth\n", + " time_window = 10 * mean_diff # Modify this based on how much time you want each frame to bin events into\n", + " intervalLength = 25 # Modify this based on how many frames you want in each data point\n", + "\n", + " transform = tonic.transforms.ToFrame(\n", + " sensor_size = dataset.sensor_size,\n", + " time_window = time_window,\n", + " )\n", + "\n", + " if downsample:\n", + " frames.append(downsample(transform(dataset[i][0][0]), downsample_factor))\n", + " else:\n", + " frames.append(transform(dataset[i][0][0]))\n", + "\n", + " velocities.append(list())\n", + "\n", + " offset = time_window * intervalLength / mean_diff # How many measurements apart of the motion capture system are the first and last frame\n", + " start = 0\n", + " increment = time_window / mean_diff\n", + "\n", + "\n", + " while int(offset + start * increment) < len(groundtruth[\"point\"]):\n", + " dx = groundtruth[\"point\"][int(offset + start * increment)][0] - groundtruth[\"point\"][int(start * increment)][0] # How much the camera moved across the batch of n frames\n", + " velocities[i].append(0 if dx > 0 else 1) # If the change in x was positive, the camera moved right, otherwise it moved left\n", + " start += 1" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 3.4 Custom Dataset\n", + "The drawback of the ToFrame() function used above is that it puts all the frames in one list. We do not yet have sets of n consecutive frames. We only have their directions. We need to create several datapoints taking n consecutive frames from this list. One approach we could take is to create a new list that contains all these intervals. The problem with this is that copying this array takes a lot of memory, and we are limited on RAM usage. Instead, we create a CustomDataset class. This formats and creates the data point only when it is needed, significantly saving memory." + ], + "metadata": { + "id": "_PI_g4hcI0-9" + } + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from torch.utils.data import Dataset, DataLoader\n", + "\n", + "class CustomDataset(Dataset):\n", + " def __init__(self, frames, velocities, interval_length):\n", + " self.frames = frames\n", + " self.velocities = velocities\n", + " self.interval_length = interval_length\n", + "\n", + " def __len__(self):\n", + " length = 0\n", + " for i in range(len(velocities)):\n", + " length += len(self.velocities[i])\n", + " return length\n", + "\n", + " def __getitem__(self, idx): # Loads and formats each datapoint when necessary\n", + " recording_num = 0\n", + " while idx >= len(self.velocities[recording_num]):\n", + " idx -= len(self.velocities[recording_num])\n", + " recording_num += 1\n", + " start_idx = idx\n", + " end_idx = start_idx + self.interval_length\n", + " frame_batch = self.frames[recording_num][start_idx:end_idx] # creates an interval of n frames\n", + " velocity = self.velocities[recording_num][idx] # pairs the frames with the corresponding displacement across those frames\n", + " return frame_batch, velocity\n", + "\n", + "# Assuming 'frames' and 'velocities' are your data and targets respectively\n", + "dataset = CustomDataset(frames, velocities, interval_length=intervalLength)" + ], + "metadata": { + "id": "nzQwGi8LQsBC" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 3.5 Dataloaders\n", + "Below, we randomly split the dataset into datapoints that will be used to train the model, and datapoints that will be used to test its accuracy." + ], + "metadata": { + "id": "awCLMc_Xfkch" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Se7vJByLUvS9" + }, + "outputs": [], + "source": [ + "# DataLoader parameters\n", + "batch_size = 32\n", + "shuffle = True\n", + "\n", + "train_size = int(0.7 * len(dataset))\n", + "test_size = len(dataset) - train_size\n", + "\n", + "\n", + "train_dataset, test_dataset = random_split(dataset, [train_size, test_size]) # splits the dataset into data used to train the model and data used to test its accuracy\n", + "\n", + "# Create DataLoader\n", + "trainloader = DataLoader(train_dataset, batch_size=batch_size, collate_fn=tonic.collation.PadTensors(batch_first=False), shuffle=shuffle)\n", + "testloader = DataLoader(test_dataset, batch_size=batch_size, collate_fn=tonic.collation.PadTensors(batch_first=False), shuffle=shuffle)" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# 4. Training the Model\n", + "The following code initializes the model and the functions that will be used to train it. This structure is adapted from the snnTorch Tutorials. Some things to note: The linear layer of the network has a high input count, due to the large dimensions of the DAVIS Camera frame. This value will have to be modified if you choose to compress the frames. The 2 outputs are for left and right." + ], + "metadata": { + "id": "Q1q-39VjssOv" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 4.1 Model Structure" + ], + "metadata": { + "id": "NpuQRh16f-r4" + } + }, + { + "cell_type": "code", + "source": [ + "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"mps\") if torch.backends.mps.is_available() else torch.device(\"cpu\")\n", + "\n", + "# neuron and simulation parameters\n", + "spike_grad = surrogate.atan()\n", + "beta = 0.95\n", + "\n", + "# Initialize Network\n", + "net = nn.Sequential(nn.Conv2d(2, 12, 5),\n", + " nn.MaxPool2d(2),\n", + " snn.Leaky(beta=beta, spike_grad=spike_grad, init_hidden=True),\n", + " nn.Conv2d(12, 32, 5),\n", + " nn.MaxPool2d(2),\n", + " snn.Leaky(beta=beta, spike_grad=spike_grad, init_hidden=True),\n", + " nn.Flatten(),\n", + " nn.Linear(76608, 2),\n", + " snn.Leaky(beta=beta, spike_grad=spike_grad, init_hidden=True, output=True)\n", + " ).to(device)" + ], + "metadata": { + "id": "sxEd_Z2TeLGz" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def forward_pass(net, data):\n", + " spk_rec = []\n", + " utils.reset(net)\n", + "\n", + " for step in range(data.size(0)):\n", + " spk_out, mem_out = net(data[step])\n", + " spk_rec.append(spk_out)\n", + "\n", + " return torch.stack(spk_rec)" + ], + "metadata": { + "id": "4DBMfs8w9v_i" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "optimizer = torch.optim.Adam(net.parameters(), lr=1e-3, betas=(0.9, 0.999))\n", + "loss_fn = SF.mse_count_loss(correct_rate=0.7, incorrect_rate=0.3)" + ], + "metadata": { + "id": "WqBsUYyV90m1" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 4.2 Model Train\n", + "Buckle up, this is going to take a long time. Took about 30 minutes for me." + ], + "metadata": { + "id": "bwAlFzMitcB6" + } + }, + { + "cell_type": "code", + "source": [ + "num_epochs = 25\n", + "\n", + "loss_hist = []\n", + "acc_hist = []\n", + "\n", + "for epoch in range(num_epochs):\n", + " for i, (data, targets) in enumerate(iter(trainloader)):\n", + " data = data.to(device)\n", + " targets = targets.to(device)\n", + "\n", + " net.train()\n", + " spk_rec = forward_pass(net, data)\n", + " loss_val = loss_fn(spk_rec, targets)\n", + "\n", + " optimizer.zero_grad()\n", + " loss_val.backward()\n", + " optimizer.step()\n", + "\n", + " loss_hist.append(loss_val.item())\n", + "\n", + " print(f\"Epoch {epoch}, Iteration {i} \\nTrain Loss: {loss_val.item():.2f}\")\n", + "\n", + " acc = SF.accuracy_rate(spk_rec, targets)\n", + " acc_hist.append(acc)\n", + " print(f\"Accuracy: {acc * 100:.2f}%\\n\")" + ], + "metadata": { + "id": "zVYrw5nF94Js", + "collapsed": true + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Graph the results of the training by running the code below." + ], + "metadata": { + "id": "acsjICA3gFsC" + } + }, + { + "cell_type": "code", + "source": [ + "fig = plt.figure(facecolor=\"w\")\n", + "plt.plot(acc_hist)\n", + "plt.title(\"Train Set Accuracy\")\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"Accuracy\")\n", + "plt.show()" + ], + "metadata": { + "id": "le5xnYnRGeYu" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Hopefully, your graph is increasing over time and looks something like this. It may be better or worse than this depending on how the batches are randomly chosen. If it doesn't look like the accuracy got much better over the iterations, you can try re-randomizing the batches by re-running the code cell with the batch size and DataLoaders.\n", + "\n", + "![download.png](data:image/png;base64,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)" + ], + "metadata": { + "id": "xHAphjNYtqre" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 4.3 Model Test\n", + "Next let's try inputting some points that we didn't use for training into the neural network." + ], + "metadata": { + "id": "ejlR1j0laCLl" + } + }, + { + "cell_type": "code", + "source": [ + "net.eval()\n", + "\n", + "batch_accuracy = []\n", + "\n", + "with torch.no_grad():\n", + " for data, targets in testloader:\n", + "\n", + " data = data.to(device)\n", + " targets = targets.to(device)\n", + "\n", + " spk_rec = forward_pass(net, data)\n", + "\n", + " acc = SF.accuracy_rate(spk_rec, targets)\n", + " batch_accuracy.append(acc)\n", + "\n", + " print(f\"Accuracy: {acc * 100:.2f}%\\n\")\n", + "\n", + "print(\"The average accuracy across the testloader is:\", 100 * statistics.mean(batch_accuracy), \"%\")" + ], + "metadata": { + "id": "M0gdp_O7ihtu" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Graph the results of the testing by running the code below." + ], + "metadata": { + "id": "o72Gf_wrgQsS" + } + }, + { + "cell_type": "code", + "source": [ + "fig = plt.figure(facecolor=\"w\")\n", + "plt.plot(batch_accuracy)\n", + "plt.title(\"Test Set Accuracy\")\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"Accuracy\")\n", + "plt.show()\n", + "print(\"The average accuracy across the testloader is:\", 100 * statistics.mean(batch_accuracy), \"%\")" + ], + "metadata": { + "id": "CG3SNH-tvzk_" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "![Screen Shot 2024-06-12 at 6.42.02 PM.png](data:image/png;base64,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)" + ], + "metadata": { + "id": "bWsn8aG9vHLF" + } + }, + { + "cell_type": "markdown", + "source": [ + "# 5. Results\n", + "That wraps up the tutorial! This was an example of how to use the DAVIS dataset to perform a binary classification task. Some final remarks..." + ], + "metadata": { + "id": "0RByuTn1zhs8" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 5.1 Improving on This Setup\n", + "\n", + "\n", + "\n", + "1. Currently, each set of frames is mapped to a single value of left or right. However, it is completely possible that there is an even split of left and right movement across some sets of frames. It's also possible that the camera moved up and down and barely moved left or right at all in certain intervals. One possible solution is to remove these datapoints.\n", + "2. For the purposes of this tutorial, the model is trained on 4 recordings. It is unclear if the accuracy of the model can be generalized to other recordings, or if the model has overfitted parameters to these specific recordings.\n", + "3. There was overlap over the datapoints, as the set of all possible intervals of n recordings consist of overlapping intervals.\n", + "\n", + "\n" + ], + "metadata": { + "id": "Bplaw540h3mG" + } + }, + { + "cell_type": "markdown", + "source": [ + "## 5.2 Implications\n", + "\n", + "Hooray! We successfully trained a Spiking Neural Network to output direction using event camera data! This type of task has applications in Simultaneous Localization and Mapping (SLAM) algorithms, which track an agent's position and motion within an evironment. With traditional image data being large and computationally expensive, using event cameras and spiking neural networks could be more energy efficient on the large scale." + ], + "metadata": { + "id": "Lp-RwJnYmuCY" + } + } + ], + "metadata": { + "colab": { + "provenance": [], + "private_outputs": true, + "include_colab_link": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file