Pose_based_Acitvity_Recognition.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import Dataset\n",
    "from torch.utils.data import DataLoader\n",
    "import torch\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Useful Constants\n",
    "# Output classes to learn how to classify\n",
    "LABELS = [    \n",
    "    \"JUMPING\",\n",
    "    \"JUMPING_JACKS\",\n",
    "    \"BOXING\",\n",
    "    \"WAVING_2HANDS\",\n",
    "    \"WAVING_1HAND\",\n",
    "    \"CLAPPING_HANDS\"\n",
    "\n",
    "] \n",
    "DATASET_PATH = \"data/HAR_pose_activities/database/\"\n",
    "\n",
    "X_train_path = DATASET_PATH + \"X_train.txt\"\n",
    "X_test_path = DATASET_PATH + \"X_test.txt\"\n",
    "\n",
    "y_train_path = DATASET_PATH + \"Y_train.txt\"\n",
    "y_test_path = DATASET_PATH + \"Y_test.txt\"\n",
    "\n",
    "n_steps = 32 # 32 timesteps per series\n",
    "n_categories = len(LABELS)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load the networks inputs\n",
    "\n",
    "def load_X(X_path):\n",
    "    file = open(X_path, 'r')\n",
    "    X_ = np.array(\n",
    "        [elem for elem in [\n",
    "            row.split(',') for row in file\n",
    "        ]], \n",
    "        dtype=np.float32\n",
    "    )\n",
    "    file.close()\n",
    "    blocks = int(len(X_) / n_steps)\n",
    "    \n",
    "    X_ = np.array(np.split(X_,blocks))\n",
    "\n",
    "    return X_ \n",
    "\n",
    "# Load the networks outputs\n",
    "def load_y(y_path):\n",
    "    file = open(y_path, 'r')\n",
    "    y_ = np.array(\n",
    "        [elem for elem in [\n",
    "            row.replace('  ', ' ').strip().split(' ') for row in file\n",
    "        ]], \n",
    "        dtype=np.int32\n",
    "    )\n",
    "    file.close()\n",
    "    \n",
    "    # for 0-based indexing \n",
    "    return y_ - 1\n",
    "\n",
    "X_train = load_X(X_train_path)\n",
    "X_test = load_X(X_test_path)\n",
    "\n",
    "y_train = load_y(y_train_path)\n",
    "y_test = load_y(y_test_path)\n",
    "\n",
    "y_train = np.squeeze(y_train)\n",
    "y_test = np.squeeze(y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 128\n",
    "HIDDEN_DIM = 128\n",
    "NUM_LAYERS = 3\n",
    "\n",
    "NUM_JOINTS = 18*2\n",
    "NUM_CLASSES = 6\n",
    "SEQ_LEN = 32\n",
    "\n",
    "LOG_INTERVAL = 10\n",
    "NUM_EPOCHS = 600"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataset Loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PoseDataset(Dataset):\n",
    "    def __init__(self, data, labels, transform=None):\n",
    "        self.data = torch.from_numpy(data)        \n",
    "        self.labels = torch.LongTensor(labels)\n",
    "        self.transform = transform\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        x = self.data[index, :, :]\n",
    "        y = self.labels[index].long()\n",
    "\n",
    "        if self.transform:\n",
    "            x = self.transform(x)\n",
    "        \n",
    "        return x, y\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = PoseDataset(X_train, y_train, transform=None)\n",
    "train_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)\n",
    "\n",
    "valid_dataset = PoseDataset(X_test, y_test, transform=None)\n",
    "valid_loader = DataLoader(valid_dataset, batch_size=BATCH_SIZE)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Net(nn.Module):\n",
    "    def __init__(self, input_dim, seq_len, hidden_dim, num_classes, layer_num):\n",
    "        super(Net,self).__init__()\n",
    "        self.lstm = torch.nn.LSTM(input_dim, hidden_dim, layer_num, batch_first=True)\n",
    "        self.fc = torch.nn.Linear(hidden_dim, num_classes)\n",
    "        self.bn = nn.BatchNorm1d(seq_len)\n",
    "        \n",
    "    def forward(self,inputs):\n",
    "        x = self.bn(inputs)\n",
    "        lstm_out,(hn,cn) = self.lstm(x)\n",
    "        out = self.fc(lstm_out[:,-1,:])\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Net(\n",
       "  (lstm): LSTM(36, 128, num_layers=3, batch_first=True)\n",
       "  (fc): Linear(in_features=128, out_features=6, bias=True)\n",
       "  (bn): BatchNorm1d(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       ")"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = Net(NUM_JOINTS, SEQ_LEN, HIDDEN_DIM, NUM_CLASSES, NUM_LAYERS).to(device)\n",
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "criterion = nn.CrossEntropyLoss()\n",
    "optimizer = optim.SGD(model.parameters(), lr=0.0005, momentum=0.9)\n",
    "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "losses = {}\n",
    "losses['train'] = []\n",
    "losses['valid'] = []\n",
    "accuracies = {}\n",
    "accuracies['train'] = []\n",
    "accuracies['valid'] = []\n",
    "\n",
    "train_batches = len(train_loader) \n",
    "valid_batches = len(valid_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Training\n",
    "def train(epoch):\n",
    "    model.train()\n",
    "    train_loss = 0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    for batch_idx, (inputs, labels) in enumerate(train_loader):\n",
    "        inputs, labels = inputs.to(device), labels.to(device)        \n",
    "        optimizer.zero_grad()\n",
    "        outputs = model(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        train_loss += loss.item()\n",
    "        _, predicted = outputs.max(1)\n",
    "        total += labels.size(0)\n",
    "        correct += predicted.eq(labels).sum().item()\n",
    "    \n",
    "    train_acc = 100. * correct/total\n",
    "    train_loss /= train_batches\n",
    "    \n",
    "    model.eval()\n",
    "    val_loss = 0\n",
    "    correct = 0\n",
    "    total = 0\n",
    "    with torch.no_grad():\n",
    "        for batch_idx, (inputs, labels) in enumerate(valid_loader):\n",
    "            inputs, labels = inputs.to(device), labels.to(device)\n",
    "            outputs = model(inputs)            \n",
    "            loss = criterion(outputs, labels)\n",
    "            val_loss += loss.item()\n",
    "            _, predicted = outputs.max(1)\n",
    "            total += labels.size(0)\n",
    "            correct += predicted.eq(labels).sum().item()\n",
    "    \n",
    "    val_acc = 100. * correct / total\n",
    "    val_loss /= valid_batches\n",
    "    \n",
    "    if epoch % LOG_INTERVAL == 0:\n",
    "        print('Epoch: %d | Loss: %.3f | Acc: %.3f%% | Valid Loss: %.3f | Valid Acc: %.3f%%' %\n",
    "              (epoch, train_loss, train_acc, val_loss, val_acc))\n",
    "    \n",
    "    losses['train'].append(train_loss)\n",
    "    accuracies['train'].append(train_acc)   \n",
    "    losses['valid'].append(val_loss)\n",
    "    accuracies['valid'].append(val_acc)    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 10 | Loss: 1.741 | Acc: 22.343% | Valid Loss: 1.731 | Valid Acc: 22.831%\n",
      "Epoch: 20 | Loss: 1.738 | Acc: 22.343% | Valid Loss: 1.728 | Valid Acc: 22.831%\n",
      "Epoch: 30 | Loss: 1.736 | Acc: 22.343% | Valid Loss: 1.726 | Valid Acc: 22.831%\n",
      "Epoch: 40 | Loss: 1.731 | Acc: 23.562% | Valid Loss: 1.722 | Valid Acc: 24.152%\n",
      "Epoch: 50 | Loss: 1.719 | Acc: 31.412% | Valid Loss: 1.710 | Valid Acc: 32.134%\n",
      "Epoch: 60 | Loss: 1.512 | Acc: 45.114% | Valid Loss: 1.457 | Valid Acc: 47.905%\n",
      "Epoch: 70 | Loss: 1.096 | Acc: 52.265% | Valid Loss: 1.068 | Valid Acc: 55.121%\n",
      "Epoch: 80 | Loss: 0.704 | Acc: 69.344% | Valid Loss: 0.726 | Valid Acc: 71.431%\n",
      "Epoch: 90 | Loss: 0.553 | Acc: 72.729% | Valid Loss: 0.540 | Valid Acc: 75.969%\n",
      "Epoch: 100 | Loss: 0.492 | Acc: 77.604% | Valid Loss: 0.495 | Valid Acc: 77.673%\n",
      "Epoch: 110 | Loss: 0.404 | Acc: 83.916% | Valid Loss: 0.422 | Valid Acc: 82.473%\n",
      "Epoch: 120 | Loss: 0.340 | Acc: 87.775% | Valid Loss: 0.368 | Valid Acc: 85.585%\n",
      "Epoch: 130 | Loss: 0.271 | Acc: 91.306% | Valid Loss: 0.316 | Valid Acc: 89.237%\n",
      "Epoch: 140 | Loss: 0.226 | Acc: 92.933% | Valid Loss: 0.259 | Valid Acc: 91.045%\n",
      "Epoch: 150 | Loss: 0.195 | Acc: 93.945% | Valid Loss: 0.243 | Valid Acc: 91.584%\n",
      "Epoch: 160 | Loss: 0.176 | Acc: 94.661% | Valid Loss: 0.229 | Valid Acc: 92.297%\n",
      "Epoch: 170 | Loss: 0.163 | Acc: 95.182% | Valid Loss: 0.222 | Valid Acc: 92.314%\n",
      "Epoch: 180 | Loss: 0.158 | Acc: 95.288% | Valid Loss: 0.220 | Valid Acc: 92.766%\n",
      "Epoch: 190 | Loss: 0.154 | Acc: 95.430% | Valid Loss: 0.217 | Valid Acc: 92.540%\n",
      "Epoch: 200 | Loss: 0.153 | Acc: 95.452% | Valid Loss: 0.217 | Valid Acc: 92.645%\n",
      "Epoch: 210 | Loss: 0.153 | Acc: 95.474% | Valid Loss: 0.217 | Valid Acc: 92.610%\n",
      "Epoch: 220 | Loss: 0.154 | Acc: 95.355% | Valid Loss: 0.218 | Valid Acc: 92.766%\n",
      "Epoch: 230 | Loss: 0.155 | Acc: 95.346% | Valid Loss: 0.217 | Valid Acc: 92.714%\n",
      "Epoch: 240 | Loss: 0.152 | Acc: 95.399% | Valid Loss: 0.211 | Valid Acc: 92.993%\n",
      "Epoch: 250 | Loss: 0.147 | Acc: 95.430% | Valid Loss: 0.214 | Valid Acc: 92.940%\n",
      "Epoch: 260 | Loss: 0.142 | Acc: 95.465% | Valid Loss: 0.209 | Valid Acc: 92.923%\n",
      "Epoch: 270 | Loss: 0.149 | Acc: 95.333% | Valid Loss: 0.458 | Valid Acc: 85.863%\n",
      "Epoch: 280 | Loss: 0.125 | Acc: 96.128% | Valid Loss: 0.184 | Valid Acc: 93.740%\n",
      "Epoch: 290 | Loss: 0.132 | Acc: 95.779% | Valid Loss: 0.180 | Valid Acc: 94.001%\n",
      "Epoch: 300 | Loss: 0.092 | Acc: 97.180% | Valid Loss: 0.156 | Valid Acc: 94.766%\n",
      "Epoch: 310 | Loss: 0.073 | Acc: 97.985% | Valid Loss: 0.139 | Valid Acc: 95.131%\n",
      "Epoch: 320 | Loss: 0.093 | Acc: 97.008% | Valid Loss: 0.145 | Valid Acc: 95.253%\n",
      "Epoch: 330 | Loss: 0.074 | Acc: 97.702% | Valid Loss: 0.114 | Valid Acc: 96.609%\n",
      "Epoch: 340 | Loss: 0.055 | Acc: 98.223% | Valid Loss: 0.132 | Valid Acc: 95.879%\n",
      "Epoch: 350 | Loss: 0.050 | Acc: 98.444% | Valid Loss: 0.116 | Valid Acc: 96.575%\n",
      "Epoch: 360 | Loss: 0.038 | Acc: 98.860% | Valid Loss: 0.105 | Valid Acc: 96.418%\n",
      "Epoch: 370 | Loss: 0.041 | Acc: 98.793% | Valid Loss: 0.097 | Valid Acc: 96.679%\n",
      "Epoch: 380 | Loss: 0.036 | Acc: 98.939% | Valid Loss: 0.105 | Valid Acc: 96.696%\n",
      "Epoch: 390 | Loss: 0.025 | Acc: 99.222% | Valid Loss: 0.095 | Valid Acc: 97.322%\n",
      "Epoch: 400 | Loss: 0.025 | Acc: 99.315% | Valid Loss: 0.090 | Valid Acc: 96.957%\n",
      "Epoch: 410 | Loss: 0.028 | Acc: 99.182% | Valid Loss: 0.092 | Valid Acc: 97.200%\n",
      "Epoch: 420 | Loss: 0.019 | Acc: 99.456% | Valid Loss: 0.098 | Valid Acc: 96.853%\n",
      "Epoch: 430 | Loss: 0.018 | Acc: 99.501% | Valid Loss: 0.082 | Valid Acc: 97.618%\n",
      "Epoch: 440 | Loss: 0.019 | Acc: 99.412% | Valid Loss: 0.086 | Valid Acc: 97.740%\n",
      "Epoch: 450 | Loss: 0.011 | Acc: 99.686% | Valid Loss: 0.083 | Valid Acc: 97.705%\n",
      "Epoch: 460 | Loss: 0.008 | Acc: 99.779% | Valid Loss: 0.096 | Valid Acc: 97.374%\n",
      "Epoch: 470 | Loss: 0.006 | Acc: 99.898% | Valid Loss: 0.092 | Valid Acc: 97.740%\n",
      "Epoch: 480 | Loss: 0.008 | Acc: 99.801% | Valid Loss: 0.129 | Valid Acc: 97.131%\n",
      "Epoch: 490 | Loss: 0.004 | Acc: 99.920% | Valid Loss: 0.088 | Valid Acc: 97.931%\n",
      "Epoch: 500 | Loss: 0.004 | Acc: 99.916% | Valid Loss: 0.099 | Valid Acc: 97.670%\n",
      "Epoch: 510 | Loss: 0.003 | Acc: 99.938% | Valid Loss: 0.093 | Valid Acc: 97.774%\n",
      "Epoch: 520 | Loss: 0.003 | Acc: 99.965% | Valid Loss: 0.088 | Valid Acc: 97.879%\n",
      "Epoch: 530 | Loss: 0.003 | Acc: 99.978% | Valid Loss: 0.089 | Valid Acc: 97.757%\n",
      "Epoch: 540 | Loss: 0.002 | Acc: 99.973% | Valid Loss: 0.087 | Valid Acc: 97.844%\n",
      "Epoch: 550 | Loss: 0.002 | Acc: 99.996% | Valid Loss: 0.091 | Valid Acc: 97.861%\n",
      "Epoch: 560 | Loss: 0.002 | Acc: 99.996% | Valid Loss: 0.090 | Valid Acc: 97.879%\n",
      "Epoch: 570 | Loss: 0.002 | Acc: 99.996% | Valid Loss: 0.092 | Valid Acc: 97.792%\n",
      "Epoch: 580 | Loss: 0.002 | Acc: 99.991% | Valid Loss: 0.093 | Valid Acc: 97.792%\n",
      "Epoch: 590 | Loss: 0.002 | Acc: 99.991% | Valid Loss: 0.092 | Valid Acc: 97.774%\n",
      "Epoch: 600 | Loss: 0.002 | Acc: 99.996% | Valid Loss: 0.094 | Valid Acc: 97.774%\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(1, NUM_EPOCHS + 1):\n",
    "    train(epoch)\n",
    "    scheduler.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Results "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 936x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(13,5))\n",
    "plt.subplot(1,2,1)\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.plot(range(NUM_EPOCHS), losses['train'], label=\"train_loss\")\n",
    "plt.plot(range(NUM_EPOCHS), losses['valid'], label=\"valid_loss\")\n",
    "plt.legend()\n",
    "plt.subplot(1,2,2)\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.plot(range(NUM_EPOCHS), accuracies['train'], label=\"train_accuracy\")\n",
    "plt.plot(range(NUM_EPOCHS), accuracies['valid'], label=\"valid_accuracy\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_all_preds(model, loader):\n",
    "    all_preds = torch.tensor([]).to(device)\n",
    "    for inputs, labels in loader:\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "        preds = model(inputs)\n",
    "        all_preds = torch.cat((all_preds, preds), dim=0)\n",
    "    return all_preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/batselem/anaconda3/envs/kaggle/lib/python3.9/site-packages/torch/nn/modules/module.py:1130: UserWarning: RNN module weights are not part of single contiguous chunk of memory. This means they need to be compacted at every call, possibly greatly increasing memory usage. To compact weights again call flatten_parameters(). (Triggered internally at  /opt/conda/conda-bld/pytorch_1656352660876/work/aten/src/ATen/native/cudnn/RNN.cpp:968.)\n",
      "  return forward_call(*input, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    train_preds = get_all_preds(model, valid_loader)\n",
    "\n",
    "train_preds = train_preds.argmax(1)\n",
    "train_preds = train_preds.cpu().detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "\n",
    "cm = metrics.confusion_matrix(y_test, train_preds)\n",
    "cm_display = metrics.ConfusionMatrixDisplay(cm, display_labels = LABELS)\n",
    "cm_display.plot(xticks_rotation='vertical')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export model "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/batselem/anaconda3/envs/kaggle/lib/python3.9/site-packages/torch/onnx/symbolic_opset9.py:3220: UserWarning: Exporting a model to ONNX with a batch_size other than 1, with a variable length with LSTM can cause an error when running the ONNX model with a different batch size. Make sure to save the model with a batch size of 1, or define the initial states (h0/c0) as inputs of the model. \n",
      "  warnings.warn(\n",
      "WARNING: The shape inference of prim::Constant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n",
      "WARNING: The shape inference of prim::Constant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n",
      "WARNING: The shape inference of prim::Constant type is missing, so it may result in wrong shape inference for the exported graph. Please consider adding it in symbolic function.\n"
     ]
    }
   ],
   "source": [
    "sample_input = torch.rand(1, SEQ_LEN, NUM_JOINTS)\n",
    "\n",
    "# Export to ONNX\n",
    "torch.onnx.export(model.to('cpu'), sample_input, \"action_lstm.onnx\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Export to TorchScript\n",
    "model_scripted = torch.jit.script(model.to('cpu')) \n",
    "model_scripted.save('action_lstm.pt') # Save"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load model "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RecursiveScriptModule(\n",
       "  original_name=Net\n",
       "  (lstm): RecursiveScriptModule(original_name=LSTM)\n",
       "  (fc): RecursiveScriptModule(original_name=Linear)\n",
       "  (bn): RecursiveScriptModule(original_name=BatchNorm1d)\n",
       ")"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model = torch.jit.load('action_lstm.pt').to(device)\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}