team_pi.ipynb

{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "wP0AxcKxfQVT"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import random\n",
        "root = \"/content/drive/MyDrive/dataset\"\n",
        "gen = os.walk(root)\n",
        "list_of_folders = next(gen)[1]\n",
        "list_of_folders.sort()\n",
        "\n",
        "train = []\n",
        "valid = []\n",
        "\n",
        "for folder in list_of_folders:\n",
        "  r1 = os.path.join(root, folder)\n",
        "  g = os.walk(r1)\n",
        "  \n",
        "  for subfolder in next(g)[1]:\n",
        "    r2 = (os.path.join(r1, subfolder))\n",
        "\n",
        "    files = [f for f in os.listdir(r2) if os.path.isfile(os.path.join(r2, f))]\n",
        "\n",
        "    for file_name in files:\n",
        "      if random.uniform(0, 1) < 0.8:\n",
        "        train.append([os.path.join(r2, file_name), 1 if subfolder == \"fall\" else 0])\n",
        "      else:\n",
        "        valid.append([os.path.join(r2, file_name), 1 if subfolder == \"fall\" else 0])\n",
        "\n",
        "# 80 - 20 split to traning & validation data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "H7PThPcqmVy6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "71e64262-af20-42db-b68c-8582e7ea1c86"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "                                                 path  fall\n",
            "0   /content/drive/MyDrive/dataset/Anju/notFall/da...     0\n",
            "1   /content/drive/MyDrive/dataset/Anju/notFall/da...     0\n",
            "2   /content/drive/MyDrive/dataset/Anju/notFall/da...     0\n",
            "3   /content/drive/MyDrive/dataset/Anju/notFall/da...     0\n",
            "4   /content/drive/MyDrive/dataset/Anju/notFall/da...     0\n",
            "..                                                ...   ...\n",
            "87  /content/drive/MyDrive/dataset/dhirendraBhai/n...     0\n",
            "88  /content/drive/MyDrive/dataset/dhirendraBhai/n...     0\n",
            "89  /content/drive/MyDrive/dataset/dhirendraBhai/n...     0\n",
            "90  /content/drive/MyDrive/dataset/dhirendraBhai/n...     0\n",
            "91  /content/drive/MyDrive/dataset/dhirendraBhai/n...     0\n",
            "\n",
            "[92 rows x 2 columns]\n"
          ]
        }
      ],
      "source": [
        "import pandas as pd\n",
        "\n",
        "train_df = pd.DataFrame(train, columns=['path', 'fall'])\n",
        "valid_df = pd.DataFrame(valid, columns=['path', 'fall'])\n",
        "print(train_df)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "wbvazqKtnMHE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "81c46a43-448f-4342-a59f-568708596e48"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0    48\n",
              "1    44\n",
              "Name: fall, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "train_df.fall.value_counts()"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "valid_df.fall.value_counts()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gTGj6ffBxRv-",
        "outputId": "bd4384b9-0c54-411b-a3fd-54d79901626b"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1    15\n",
              "0    11\n",
              "Name: fall, dtype: int64"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "shapes = []\n",
        "import torch\n",
        "\n",
        "for i in range(len(train_df)):\n",
        "  csv_path = train_df.iloc[i, 0]\n",
        "  mat = pd.read_csv(csv_path)\n",
        "  mat = [list(mat[x]) for x in ['ax', 'ay', 'az', 'gx', 'gy', 'gz']]\n",
        "  mat = torch.tensor(mat)\n",
        "  if mat.shape[1] < 10:\n",
        "    print(csv_path)\n",
        "  shapes.append(mat.shape[1])\n",
        "\n",
        "print(shapes)\n",
        "mat_min = min(shapes) # csv to tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GCdmH0GlxVlD",
        "outputId": "ae4f417a-dc11-4b81-99d0-10e15b93573d"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[126, 121, 120, 124, 121, 120, 123, 119, 122, 127, 127, 128, 129, 134, 127, 132, 138, 134, 132, 138, 139, 136, 136, 133, 137, 134, 136, 134, 134, 136, 135, 136, 135, 128, 130, 129, 132, 143, 137, 141, 142, 138, 135, 142, 121, 121, 123, 94, 120, 128, 122, 119, 128, 130, 126, 128, 128, 133, 131, 88, 134, 133, 135, 142, 134, 137, 134, 121, 129, 133, 132, 134, 134, 135, 133, 133, 136, 127, 129, 128, 130, 129, 129, 131, 132, 136, 137, 138, 138, 139, 136, 138]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import torch\n",
        "import pandas as pd\n",
        "from torch.utils.data import Dataset, IterableDataset\n",
        "\n",
        "def mat_to_tensor(mat_path):\n",
        "  mat = pd.read_csv(mat_path)\n",
        "  mat = mat.dropna()\n",
        "  mat = [list(mat[x]) for x in ['ax', 'ay', 'az', 'gx', 'gy', 'gz']]\n",
        "  mat = torch.tensor(mat)\n",
        "  return mat\n",
        "\n",
        "class IMUSet(Dataset):\n",
        "    def __init__(self, data_df):\n",
        "        self.data_df = data_df\n",
        "\n",
        "    def __len__(self):\n",
        "        return len(self.data_df)\n",
        "\n",
        "    def __getitem__(self, idx):\n",
        "        mat_path = self.data_df.iloc[idx, 0]\n",
        "        t = mat_to_tensor(mat_path)\n",
        "        label = self.data_df.iloc[idx, 1]\n",
        "        return t, label"
      ],
      "metadata": {
        "id": "hGz5Eltf2Q5w"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from torch.utils.data import DataLoader\n",
        "\n",
        "imuset = IMUSet(train_df) # make dataset\n",
        "\n",
        "train_dataloader = DataLoader(imuset, shuffle=True) "
      ],
      "metadata": {
        "id": "D8UW-U5k298F"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "valid_dataset = IMUSet(valid_df)\n",
        "valid_dataloader = DataLoader(valid_dataset, shuffle=True)\n",
        "\n",
        "valid_features, valid_labels = next(iter(valid_dataloader))\n",
        "\n",
        "valid_features.shape, valid_labels.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JoIVWRr75hWS",
        "outputId": "1c9f20ce-f865-49f4-bbb3-6da956a18b8d"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(torch.Size([1, 6, 133]), torch.Size([1]))"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**LSTM**"
      ],
      "metadata": {
        "id": "AQP6qfIsEFF8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from torch import nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "class FallDetector(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(FallDetector, self).__init__()\n",
        "        self.lstm = nn.LSTM(input_size=6, hidden_size=10, num_layers=1)\n",
        "        self.hidden2tag = nn.Linear(10, 1)\n",
        "\n",
        "    def forward(self, seq):\n",
        "        output, (h_n, c_n) = self.lstm(seq.view(len(seq), 1, -1))\n",
        "        tag_space = self.hidden2tag(c_n.view(1, -1))\n",
        "        # print(tag_space.data)\n",
        "        tag_scores = torch.sigmoid(tag_space)\n",
        "        return tag_scores.view(-1)"
      ],
      "metadata": {
        "id": "67owPWHi5vr7"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.optim as optim\n",
        "\n",
        "model = FallDetector()\n",
        "loss_function = nn.BCELoss() \n",
        "optimizer = optim.Adam(model.parameters())"
      ],
      "metadata": {
        "id": "l2WJyGd47PVH"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "from sklearn.metrics import confusion_matrix, accuracy_score, recall_score\n",
        "\n",
        "def get_statistics(y_true, y_pred):\n",
        "    y_pred = np.concatenate(tuple(y_pred)) > 0.5\n",
        "    y_true = np.concatenate(tuple([[t for t in y] for y in y_true])).reshape(y_pred.shape)\n",
        "\n",
        "    print(\"Accuracy: \", accuracy_score(y_true, y_pred))\n",
        "    print(\"Recall: \", recall_score(y_true, y_pred))\n",
        "    print(len(y_true))\n",
        "\n",
        "    print(\"Confusion Matrix\")\n",
        "    print(confusion_matrix(y_true, y_pred))"
      ],
      "metadata": {
        "id": "TGJVaT0L8CRw"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "for epoch in range(50): \n",
        "    labels = []\n",
        "    preds = []\n",
        "    loss = []\n",
        "\n",
        "    i = 0\n",
        "    for seq, label in train_dataloader:\n",
        "        model.zero_grad()\n",
        "\n",
        "        seq = seq.reshape((-1, 6))\n",
        "        tag_scores = model(seq.to(torch.float))\n",
        "        preds.append(tag_scores.data)\n",
        "        labels.append(label.to(torch.float).data)\n",
        "\n",
        "        loss = loss_function(tag_scores, label.to(torch.float))\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "\n",
        "        i += 1\n",
        "\n",
        "    print(\"Epoch Done\")\n",
        "    get_statistics(labels, preds)\n",
        "\n",
        "    # tag_scores[tag_scores > 0.4] = 1\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NICfurnn8Evo",
        "outputId": "0bee58ab-8fb8-439b-d25e-3aa1a64a4d2d"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch Done\n",
            "Accuracy:  0.6304347826086957\n",
            "Recall:  0.6363636363636364\n",
            "92\n",
            "Confusion Matrix\n",
            "[[30 18]\n",
            " [16 28]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7282608695652174\n",
            "Recall:  0.8181818181818182\n",
            "92\n",
            "Confusion Matrix\n",
            "[[31 17]\n",
            " [ 8 36]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7065217391304348\n",
            "Recall:  0.8636363636363636\n",
            "92\n",
            "Confusion Matrix\n",
            "[[27 21]\n",
            " [ 6 38]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7282608695652174\n",
            "Recall:  0.8409090909090909\n",
            "92\n",
            "Confusion Matrix\n",
            "[[30 18]\n",
            " [ 7 37]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7282608695652174\n",
            "Recall:  0.7272727272727273\n",
            "92\n",
            "Confusion Matrix\n",
            "[[35 13]\n",
            " [12 32]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7608695652173914\n",
            "Recall:  0.8636363636363636\n",
            "92\n",
            "Confusion Matrix\n",
            "[[32 16]\n",
            " [ 6 38]]\n",
            "Epoch Done\n",
            "Accuracy:  0.75\n",
            "Recall:  0.8863636363636364\n",
            "92\n",
            "Confusion Matrix\n",
            "[[30 18]\n",
            " [ 5 39]]\n",
            "Epoch Done\n",
            "Accuracy:  0.6739130434782609\n",
            "Recall:  0.5909090909090909\n",
            "92\n",
            "Confusion Matrix\n",
            "[[36 12]\n",
            " [18 26]]\n",
            "Epoch Done\n",
            "Accuracy:  0.6304347826086957\n",
            "Recall:  0.5454545454545454\n",
            "92\n",
            "Confusion Matrix\n",
            "[[34 14]\n",
            " [20 24]]\n",
            "Epoch Done\n",
            "Accuracy:  0.6413043478260869\n",
            "Recall:  0.6590909090909091\n",
            "92\n",
            "Confusion Matrix\n",
            "[[30 18]\n",
            " [15 29]]\n",
            "Epoch Done\n",
            "Accuracy:  0.6413043478260869\n",
            "Recall:  0.6363636363636364\n",
            "92\n",
            "Confusion Matrix\n",
            "[[31 17]\n",
            " [16 28]]\n",
            "Epoch Done\n",
            "Accuracy:  0.6630434782608695\n",
            "Recall:  0.7272727272727273\n",
            "92\n",
            "Confusion Matrix\n",
            "[[29 19]\n",
            " [12 32]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7282608695652174\n",
            "Recall:  0.75\n",
            "92\n",
            "Confusion Matrix\n",
            "[[34 14]\n",
            " [11 33]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7608695652173914\n",
            "Recall:  0.7727272727272727\n",
            "92\n",
            "Confusion Matrix\n",
            "[[36 12]\n",
            " [10 34]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7608695652173914\n",
            "Recall:  0.7727272727272727\n",
            "92\n",
            "Confusion Matrix\n",
            "[[36 12]\n",
            " [10 34]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7608695652173914\n",
            "Recall:  0.8181818181818182\n",
            "92\n",
            "Confusion Matrix\n",
            "[[34 14]\n",
            " [ 8 36]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7717391304347826\n",
            "Recall:  0.7954545454545454\n",
            "92\n",
            "Confusion Matrix\n",
            "[[36 12]\n",
            " [ 9 35]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7717391304347826\n",
            "Recall:  0.7727272727272727\n",
            "92\n",
            "Confusion Matrix\n",
            "[[37 11]\n",
            " [10 34]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7608695652173914\n",
            "Recall:  0.8409090909090909\n",
            "92\n",
            "Confusion Matrix\n",
            "[[33 15]\n",
            " [ 7 37]]\n",
            "Epoch Done\n",
            "Accuracy:  0.782608695652174\n",
            "Recall:  0.7954545454545454\n",
            "92\n",
            "Confusion Matrix\n",
            "[[37 11]\n",
            " [ 9 35]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7934782608695652\n",
            "Recall:  0.8863636363636364\n",
            "92\n",
            "Confusion Matrix\n",
            "[[34 14]\n",
            " [ 5 39]]\n",
            "Epoch Done\n",
            "Accuracy:  0.782608695652174\n",
            "Recall:  0.7954545454545454\n",
            "92\n",
            "Confusion Matrix\n",
            "[[37 11]\n",
            " [ 9 35]]\n",
            "Epoch Done\n",
            "Accuracy:  0.782608695652174\n",
            "Recall:  0.8409090909090909\n",
            "92\n",
            "Confusion Matrix\n",
            "[[35 13]\n",
            " [ 7 37]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8152173913043478\n",
            "Recall:  0.8863636363636364\n",
            "92\n",
            "Confusion Matrix\n",
            "[[36 12]\n",
            " [ 5 39]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7934782608695652\n",
            "Recall:  0.8181818181818182\n",
            "92\n",
            "Confusion Matrix\n",
            "[[37 11]\n",
            " [ 8 36]]\n",
            "Epoch Done\n",
            "Accuracy:  0.782608695652174\n",
            "Recall:  0.7954545454545454\n",
            "92\n",
            "Confusion Matrix\n",
            "[[37 11]\n",
            " [ 9 35]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7934782608695652\n",
            "Recall:  0.7272727272727273\n",
            "92\n",
            "Confusion Matrix\n",
            "[[41  7]\n",
            " [12 32]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8260869565217391\n",
            "Recall:  0.9318181818181818\n",
            "92\n",
            "Confusion Matrix\n",
            "[[35 13]\n",
            " [ 3 41]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7608695652173914\n",
            "Recall:  0.6818181818181818\n",
            "92\n",
            "Confusion Matrix\n",
            "[[40  8]\n",
            " [14 30]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7717391304347826\n",
            "Recall:  0.7272727272727273\n",
            "92\n",
            "Confusion Matrix\n",
            "[[39  9]\n",
            " [12 32]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8478260869565217\n",
            "Recall:  0.9090909090909091\n",
            "92\n",
            "Confusion Matrix\n",
            "[[38 10]\n",
            " [ 4 40]]\n",
            "Epoch Done\n",
            "Accuracy:  0.7934782608695652\n",
            "Recall:  0.75\n",
            "92\n",
            "Confusion Matrix\n",
            "[[40  8]\n",
            " [11 33]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8369565217391305\n",
            "Recall:  0.8863636363636364\n",
            "92\n",
            "Confusion Matrix\n",
            "[[38 10]\n",
            " [ 5 39]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8043478260869565\n",
            "Recall:  0.8409090909090909\n",
            "92\n",
            "Confusion Matrix\n",
            "[[37 11]\n",
            " [ 7 37]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8260869565217391\n",
            "Recall:  0.8181818181818182\n",
            "92\n",
            "Confusion Matrix\n",
            "[[40  8]\n",
            " [ 8 36]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8043478260869565\n",
            "Recall:  0.75\n",
            "92\n",
            "Confusion Matrix\n",
            "[[41  7]\n",
            " [11 33]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8152173913043478\n",
            "Recall:  0.8636363636363636\n",
            "92\n",
            "Confusion Matrix\n",
            "[[37 11]\n",
            " [ 6 38]]\n",
            "Epoch Done\n",
            "Accuracy:  0.782608695652174\n",
            "Recall:  0.8636363636363636\n",
            "92\n",
            "Confusion Matrix\n",
            "[[34 14]\n",
            " [ 6 38]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8152173913043478\n",
            "Recall:  0.9090909090909091\n",
            "92\n",
            "Confusion Matrix\n",
            "[[35 13]\n",
            " [ 4 40]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8152173913043478\n",
            "Recall:  0.8409090909090909\n",
            "92\n",
            "Confusion Matrix\n",
            "[[38 10]\n",
            " [ 7 37]]\n",
            "Epoch Done\n",
            "Accuracy:  0.782608695652174\n",
            "Recall:  0.8409090909090909\n",
            "92\n",
            "Confusion Matrix\n",
            "[[35 13]\n",
            " [ 7 37]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8369565217391305\n",
            "Recall:  0.8181818181818182\n",
            "92\n",
            "Confusion Matrix\n",
            "[[41  7]\n",
            " [ 8 36]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8152173913043478\n",
            "Recall:  0.8636363636363636\n",
            "92\n",
            "Confusion Matrix\n",
            "[[37 11]\n",
            " [ 6 38]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8043478260869565\n",
            "Recall:  0.7954545454545454\n",
            "92\n",
            "Confusion Matrix\n",
            "[[39  9]\n",
            " [ 9 35]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8260869565217391\n",
            "Recall:  0.9318181818181818\n",
            "92\n",
            "Confusion Matrix\n",
            "[[35 13]\n",
            " [ 3 41]]\n",
            "Epoch Done\n",
            "Accuracy:  0.75\n",
            "Recall:  0.6818181818181818\n",
            "92\n",
            "Confusion Matrix\n",
            "[[39  9]\n",
            " [14 30]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8152173913043478\n",
            "Recall:  0.9090909090909091\n",
            "92\n",
            "Confusion Matrix\n",
            "[[35 13]\n",
            " [ 4 40]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8043478260869565\n",
            "Recall:  0.8409090909090909\n",
            "92\n",
            "Confusion Matrix\n",
            "[[37 11]\n",
            " [ 7 37]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8369565217391305\n",
            "Recall:  0.8409090909090909\n",
            "92\n",
            "Confusion Matrix\n",
            "[[40  8]\n",
            " [ 7 37]]\n",
            "Epoch Done\n",
            "Accuracy:  0.8043478260869565\n",
            "Recall:  0.8863636363636364\n",
            "92\n",
            "Confusion Matrix\n",
            "[[35 13]\n",
            " [ 5 39]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "labels = []\n",
        "preds = []\n",
        "loss = []\n",
        "model.eval()\n",
        "\n",
        "for seq, label in valid_dataloader:\n",
        "\n",
        "    seq = seq.reshape((-1, 6))\n",
        "    tag_scores = model(seq.to(torch.float))\n",
        "    preds.append(tag_scores.data)\n",
        "    labels.append(label.to(torch.float).data)\n",
        "\n",
        "print(\"Epoch Done\")\n",
        "get_statistics(labels, preds)"
      ],
      "metadata": {
        "id": "PgRfl9f4AnAz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8b7e44e2-7803-431e-b275-1e804a337a87"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch Done\n",
            "Accuracy:  0.7307692307692307\n",
            "Recall:  0.6666666666666666\n",
            "26\n",
            "Confusion Matrix\n",
            "[[ 9  2]\n",
            " [ 5 10]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# torch.save(model.state_dict(), 'model_weights.pt')"
      ],
      "metadata": {
        "id": "MIG5VyYmGO47"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# from torch import nn\n",
        "# import torch.nn.functional as F\n",
        "\n",
        "# class FallDetector(nn.Module):\n",
        "#     def __init__(self):\n",
        "#         super(FallDetector, self).__init__()\n",
        "#         self.lstm = nn.LSTM(6, 5, num_layers=1)\n",
        "#         self.hidden2tag = nn.Linear(5, 1)\n",
        "\n",
        "#     def forward(self, seq):\n",
        "#         output, (h_n, c_n) = self.lstm(seq.view(len(seq), 1, -1))\n",
        "#         tag_space = self.hidden2tag(c_n.view(1, -1))\n",
        "#         # print(tag_space.data)\n",
        "#         tag_scores = torch.sigmoid(tag_space)\n",
        "#         return tag_scores.view(-1)\n",
        "\n",
        "# model = FallDetector()\n",
        "# model.load_state_dict(torch.load('model_weights.pt'))\n",
        "# model.eval()"
      ],
      "metadata": {
        "id": "GY_bnvaZGgNM"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "zjsAAvzrInm3"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "AiQbXIaaZ-GI"
      },
      "execution_count": 15,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}