{ "cells": [ { "cell_type": "markdown", "id": "given-quilt", "metadata": {}, "source": [ "# PilotNet Sigma-Delta Neural Network (SDNN) Training\n", "\n", "\n", "\n", "\n", "\n", "
\"Drawing\" \"Drawing\"
\n", "\n", "\n", "\n", "\n", "\n", "\n", "
PilotNet: Predict the car's steering angle from the dashboard view.
PilotNet dataset is available freely here. © MIT License.\n", "
\n", "\n", "## What are SDNNs?\n", "\n", "\n", "\n", "
\"Drawing\" \"Drawing\"
\n", "\n", "__Sigma-delta neural networks__ consists of two main units: _sigma_ decoder in the dendrite and _delta_ encoder in the axon. Delta encoder uses differential encoding on the output activation of a regular ANN activation, for e.g. ReLU. In addition it only sends activation to the next layer when the encoded message magnitude is larger than its threshold. The sigma unit accumulates the sparse event messages and accumulates it to restore the original value.\n", "\n", "\n", "\n", "\n", "
\n", "\n", "A sigma-delta neuron is simply a regular activation wrapped around by a sigma unit at it's input and a delta unit at its output.\n", "\n", "When the input to the network is a temporal sequence, the activations do not change much. Therefore, the message between the layers are reduced which in turn reduces the synaptic computation in the next layer. In addition, the graded event values can encode the change in magnitude in one time-step. Therefore there is no increase in latency at the cost of time-steps unlike the rate coded Spiking Neural Networks.\n", "\n", "\n", "\n", "\n", "\n", "\n", "
\"Drawing\" \"Drawing\"
Credit Eadweard Muybridge © Public Domain
\n", "\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 1, "id": "mature-massage", "metadata": {}, "outputs": [], "source": [ "import sys, os\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import h5py\n", "\n", "import torch\n", "from torch.utils.data import DataLoader\n", "from torchvision import transforms\n", "import torch.nn.functional as F\n", "\n", "import lava.lib.dl.slayer as slayer\n", "\n", "from pilotnet_dataset import PilotNetDataset\n", "import utils" ] }, { "cell_type": "code", "execution_count": 2, "id": "expressed-juice", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "torch.manual_seed(4205)" ] }, { "cell_type": "markdown", "id": "dying-strength", "metadata": {}, "source": [ "# Event sparsity loss\n", "\n", "Sparsity loss to penalize the network for high event-rate." ] }, { "cell_type": "code", "execution_count": 3, "id": "nonprofit-charger", "metadata": {}, "outputs": [], "source": [ "def event_rate_loss(x, max_rate=0.01):\n", " mean_event_rate = torch.mean(torch.abs(x))\n", " return F.mse_loss(F.relu(mean_event_rate - max_rate), torch.zeros_like(mean_event_rate))" ] }, { "cell_type": "markdown", "id": "comfortable-corrections", "metadata": {}, "source": [ "# Network description\n", "\n", "__SLAYER 2.0__ (__`lava.dl.slayer`__) provides a variety of learnable _neuron models_ , _synapses_ _axons_ and _dendrites_ that support quantized training. \n", "For easier use, it also provides __`block`__ interface which packages the associated neurons, synapses, axons and dendrite features into a single module. \n", "\n", "__Sigma-delta blocks__ are available as `slayer.blocks.sigma_delta.{Dense, Conv, Pool, Input, Output, Flatten, ...}` which can be easily composed to create a variety of sequential network descriptions as shown below. The blocks can easily enable _synaptic weight normalization_, _neuron normalization_ as well as provide useful _gradient monitoring_ utility and _hdf5 network export_ utility.\n", "\n", "\n", "\n", "These blocks can be used to create a network using standard PyTorch procedure." ] }, { "cell_type": "code", "execution_count": 4, "id": "mature-doubt", "metadata": {}, "outputs": [], "source": [ "class Network(torch.nn.Module):\n", " def __init__(self):\n", " super(Network, self).__init__()\n", " \n", " sdnn_params = { # sigma-delta neuron parameters\n", " 'threshold' : 0.1, # delta unit threshold\n", " 'tau_grad' : 0.5, # delta unit surrogate gradient relaxation parameter\n", " 'scale_grad' : 1, # delta unit surrogate gradient scale parameter\n", " 'requires_grad' : True, # trainable threshold\n", " 'shared_param' : True, # layer wise threshold\n", " 'activation' : F.relu, # activation function\n", " }\n", " sdnn_cnn_params = { # conv layer has additional mean only batch norm\n", " **sdnn_params, # copy all sdnn_params\n", " 'norm' : slayer.neuron.norm.MeanOnlyBatchNorm, # mean only quantized batch normalizaton\n", " }\n", " sdnn_dense_params = { # dense layers have additional dropout units enabled\n", " **sdnn_cnn_params, # copy all sdnn_cnn_params\n", " 'dropout' : slayer.neuron.Dropout(p=0.2), # neuron dropout\n", " }\n", " \n", " self.blocks = torch.nn.ModuleList([# sequential network blocks \n", " # delta encoding of the input\n", " slayer.block.sigma_delta.Input(sdnn_params), \n", " # convolution layers\n", " slayer.block.sigma_delta.Conv(sdnn_cnn_params, 3, 24, 3, padding=0, stride=2, weight_scale=2, weight_norm=True),\n", " slayer.block.sigma_delta.Conv(sdnn_cnn_params, 24, 36, 3, padding=0, stride=2, weight_scale=2, weight_norm=True),\n", " slayer.block.sigma_delta.Conv(sdnn_cnn_params, 36, 64, 3, padding=(1, 0), stride=(2, 1), weight_scale=2, weight_norm=True),\n", " slayer.block.sigma_delta.Conv(sdnn_cnn_params, 64, 64, 3, padding=0, stride=1, weight_scale=2, weight_norm=True),\n", " # flatten layer\n", " slayer.block.sigma_delta.Flatten(),\n", " # dense layers\n", " slayer.block.sigma_delta.Dense(sdnn_dense_params, 64*40, 100, weight_scale=2, weight_norm=True),\n", " slayer.block.sigma_delta.Dense(sdnn_dense_params, 100, 50, weight_scale=2, weight_norm=True),\n", " slayer.block.sigma_delta.Dense(sdnn_dense_params, 50, 10, weight_scale=2, weight_norm=True),\n", " # linear readout with sigma decoding of output\n", " slayer.block.sigma_delta.Output(sdnn_dense_params, 10, 1, weight_scale=2, weight_norm=True)\n", " ])\n", " \n", " \n", " def forward(self, x):\n", " count = []\n", " event_cost = 0\n", "\n", " for block in self.blocks: \n", " # forward computation is as simple as calling the blocks in a loop\n", " x = block(x)\n", " if hasattr(block, 'neuron'):\n", " event_cost += event_rate_loss(x)\n", " count.append(torch.sum(torch.abs((x[..., 1:]) > 0).to(x.dtype)).item())\n", "\n", " return x, event_cost, torch.FloatTensor(count).reshape((1, -1)).to(x.device)\n", "\n", " def grad_flow(self, path):\n", " # helps monitor the gradient flow\n", " grad = [b.synapse.grad_norm for b in self.blocks if hasattr(b, 'synapse')]\n", "\n", " plt.figure()\n", " plt.semilogy(grad)\n", " plt.savefig(path + 'gradFlow.png')\n", " plt.close()\n", "\n", " return grad\n", " \n", " def export_hdf5(self, filename):\n", " # network export to hdf5 format\n", " h = h5py.File(filename, 'w')\n", " layer = h.create_group('layer')\n", " for i, b in enumerate(self.blocks):\n", " b.export_hdf5(layer.create_group(f'{i}'))\n", " \n", " " ] }, { "cell_type": "markdown", "id": "closed-willow", "metadata": {}, "source": [ "# Training parameters" ] }, { "cell_type": "code", "execution_count": 5, "id": "brown-twins", "metadata": {}, "outputs": [], "source": [ "batch = 8 # batch size\n", "lr = 0.001 # leaerning rate\n", "lam = 0.01 # lagrangian for event rate loss\n", "epochs = 200 # training epochs\n", "steps = [60, 120, 160] # learning rate reduction milestones\n", "\n", "trained_folder = 'Trained'\n", "logs_folder = 'Logs'\n", "\n", "os.makedirs(trained_folder, exist_ok=True)\n", "os.makedirs(logs_folder , exist_ok=True)\n", "\n", "device = torch.device('cuda')" ] }, { "cell_type": "markdown", "id": "hidden-spring", "metadata": {}, "source": [ "# Instantiate Network, Optimizer, Dataset and Dataloader" ] }, { "cell_type": "code", "execution_count": 6, "id": "exposed-claim", "metadata": {}, "outputs": [], "source": [ "net = Network().to(device)\n", "\n", "optimizer = torch.optim.RAdam(net.parameters(), lr=lr, weight_decay=1e-5)\n", "\n", "# Datasets\n", "training_set = PilotNetDataset(\n", " train=True, \n", " transform=transforms.Compose([\n", " transforms.Resize([33, 100]),\n", " transforms.ToTensor(),\n", " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n", " ]), \n", ")\n", "testing_set = PilotNetDataset(\n", " train=False, \n", " transform=transforms.Compose([\n", " transforms.Resize([33, 100]),\n", " transforms.ToTensor(),\n", " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),\n", " ]),\n", ")\n", "\n", "train_loader = DataLoader(dataset=training_set, batch_size=batch, shuffle=True, num_workers=8)\n", "test_loader = DataLoader(dataset=testing_set , batch_size=batch, shuffle=True, num_workers=8)\n", "\n", "stats = slayer.utils.LearningStats()\n", "assistant = slayer.utils.Assistant(\n", " net=net,\n", " error=lambda output, target: F.mse_loss(output.flatten(), target.flatten()),\n", " optimizer=optimizer,\n", " stats=stats,\n", " count_log=True,\n", " lam=lam\n", " )" ] }, { "cell_type": "markdown", "id": "fifty-comfort", "metadata": {}, "source": [ "# Training loop\n", "\n", "Training loop mainly consists of looping over epochs and calling `assistant.train` and `assistant.test` utilities over training and testing dataset. The `assistant` utility takes care of statndard backpropagation procedure internally.\n", "\n", "* `stats` can be used in print statement to get formatted stats printout.\n", "* `stats.testing.best_loss` can be used to find out if the current iteration has the best testing loss. Here, we use it to save the best model.\n", "* `stats.update()` updates the stats collected for the epoch.\n", "* `stats.save` saves the stats in files." ] }, { "cell_type": "code", "execution_count": 7, "id": "antique-combining", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[Epoch 49/200] Train loss = 0.08724 (min = 0.06125) | Test loss = 0.07638 (min = 0.07048)\n", "[Epoch 59/200] Train loss = 0.05042 (min = 0.06125) | Test loss = 0.06043 (min = 0.05631)\n", "Learning rate reduction from 0.001\n", "[Epoch 99/200] Train loss = 0.03670 (min = 0.03420) | Test loss = 0.04726 (min = 0.04006)\n", "[Epoch 119/200] Train loss = 0.03588 (min = 0.03177) | Test loss = 0.04133 (min = 0.03812)\n", "Learning rate reduction from 0.0003\n", "[Epoch 149/200] Train loss = 0.03995 (min = 0.02701) | Test loss = 0.04514 (min = 0.03812)\n", "[Epoch 159/200] Train loss = 0.03351 (min = 0.02701) | Test loss = 0.04028 (min = 0.03812)\n", "Learning rate reduction from 8.999999999999999e-05\n", "[Epoch 199/200] Train loss = 0.03122 (min = 0.02523) | Test loss = 0.04434 (min = 0.03812)\n" ] } ], "source": [ "for epoch in range(epochs):\n", " if epoch in steps:\n", " for param_group in optimizer.param_groups: \n", " print('\\nLearning rate reduction from', param_group['lr'])\n", " param_group['lr'] /= 10/3\n", " \n", " for i, (input, ground_truth) in enumerate(train_loader): # training loop\n", " assistant.train(input, ground_truth)\n", " print(f'\\r[Epoch {epoch:3d}/{epochs}] {stats}', end='')\n", " \n", " for i, (input, ground_truth) in enumerate(test_loader): # testing loop\n", " assistant.test(input, ground_truth)\n", " print(f'\\r[Epoch {epoch:3d}/{epochs}] {stats}', end='')\n", " \n", " if epoch%50==49: print() \n", " if stats.testing.best_loss: \n", " torch.save(net.state_dict(), trained_folder + '/network.pt')\n", " stats.update()\n", " stats.save(trained_folder + '/')\n", " \n", " # gradient flow monitoring\n", " net.grad_flow(trained_folder + '/')\n", " \n", " # checkpoint saves\n", " if epoch%10 == 0:\n", " torch.save({'net': net.state_dict(), 'optimizer': optimizer.state_dict()}, logs_folder + f'/checkpoint{epoch}.pt') " ] }, { "cell_type": "markdown", "id": "favorite-float", "metadata": {}, "source": [ "# Learning plots.\n", "\n", "Plotting the learning curves is as easy as calling `stats.plot()`." ] }, { "cell_type": "code", "execution_count": 8, "id": "boolean-command", "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "stats.plot(figsize=(15, 5))" ] }, { "cell_type": "markdown", "id": "fleet-monday", "metadata": {}, "source": [ "# Export the best trained model\n", "\n", "Load the best model during training and export it as hdf5 network. It is supported by `lava.lib.dl.netx` to automatically load the network as a lava process." ] }, { "cell_type": "code", "execution_count": 9, "id": "maritime-manchester", "metadata": {}, "outputs": [], "source": [ "net.load_state_dict(torch.load(trained_folder + '/network.pt'))\n", "net.export_hdf5(trained_folder + '/network.net')" ] }, { "cell_type": "markdown", "id": "reserved-quilt", "metadata": {}, "source": [ "# Operation count of trained model\n", "\n", "Here, we compare the synaptic operation and neuron activity of the trained SDNN and an ANN of iso-architecture." ] }, { "cell_type": "markdown", "id": "quarterly-technical", "metadata": {}, "source": [ "## Event statistics on testing dataset" ] }, { "cell_type": "code", "execution_count": 10, "id": "southeast-character", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Event count : 2170.5430, 224.2953, 372.4000, 507.9524, 28.2095, 4.7143, 1.0000, 0.1333, 0.4286 | loss = 0.04975 (min = 0.03812)" ] } ], "source": [ "counts = []\n", "for i, (input, ground_truth) in enumerate(test_loader):\n", " _, count = assistant.test(input, ground_truth)\n", " count = (count.flatten()/(input.shape[-1]-1)/input.shape[0]).tolist() # count skips first events\n", " counts.append(count) \n", " print('\\rEvent count : ' + ', '.join([f'{c:.4f}' for c in count]), f'| {stats.testing}', end='') \n", " \n", "counts = np.mean(counts, axis=0)" ] }, { "cell_type": "markdown", "id": "frequent-sight", "metadata": {}, "source": [ "# Event and Synops comparion with ANN" ] }, { "cell_type": "code", "execution_count": 11, "id": "reasonable-volleyball", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "|-----------------------------------------------------------------------------|\n", "| | SDNN | ANN |\n", "|-----------------------------------------------------------------------------|\n", "| | Shape | Events | Synops | Activations| MACs |\n", "|-----------------------------------------------------------------------------|\n", "| layer-0 | (100, 33, 3) | 2475.93 | | 9900 | |\n", "| layer-1 | ( 49, 16, 24) | 239.46 | 133700.12 | 18816 | 534600 |\n", "| layer-2 | ( 24, 7, 36) | 422.39 | 19395.86 | 6048 | 1524096 |\n", "| layer-3 | ( 22, 4, 64) | 558.71 | 121649.28 | 5632 | 1741824 |\n", "| layer-4 | ( 20, 2, 64) | 29.90 | 321818.47 | 2560 | 3244032 |\n", "| layer-5 | ( 1, 1,100) | 4.80 | 2989.97 | 100 | 256000 |\n", "| layer-6 | ( 1, 1, 50) | 1.35 | 240.00 | 50 | 5000 |\n", "| layer-7 | ( 1, 1, 10) | 0.16 | 13.46 | 10 | 500 |\n", "| layer-8 | ( 1, 1, 1) | 0.44 | 0.16 | 1 | 10 |\n", "|-----------------------------------------------------------------------------|\n", "| Total | | 3733.14 | 599807.33 | 43117 | 7306062 |\n", "|-----------------------------------------------------------------------------|\n", "\n", "\n", "MSE : 0.038123 sq. radians\n", "Total neurons : 43117\n", "Events sparsity: 11.55x\n", "Synops sparsity: 12.18x\n" ] } ], "source": [ "utils.compare_ops(net, counts, mse=stats.testing.min_loss)" ] } ], "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.8.10" } }, "nbformat": 4, "nbformat_minor": 5 }