Skeleton_movement_prediction.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "id": "6cf32895",
      "metadata": {
        "id": "6cf32895"
      },
      "source": [
        "#### Learning of Structured Data"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "yqgxHc8qutto",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yqgxHc8qutto",
        "outputId": "08e175f5-27b3-4c1a-fa1e-620668762b7a"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: kaggle in /usr/local/lib/python3.10/dist-packages (1.5.16)\n",
            "Requirement already satisfied: six>=1.10 in /usr/local/lib/python3.10/dist-packages (from kaggle) (1.16.0)\n",
            "Requirement already satisfied: certifi in /usr/local/lib/python3.10/dist-packages (from kaggle) (2023.11.17)\n",
            "Requirement already satisfied: python-dateutil in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.8.2)\n",
            "Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.31.0)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from kaggle) (4.66.1)\n",
            "Requirement already satisfied: python-slugify in /usr/local/lib/python3.10/dist-packages (from kaggle) (8.0.1)\n",
            "Requirement already satisfied: urllib3 in /usr/local/lib/python3.10/dist-packages (from kaggle) (2.0.7)\n",
            "Requirement already satisfied: bleach in /usr/local/lib/python3.10/dist-packages (from kaggle) (6.1.0)\n",
            "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from bleach->kaggle) (0.5.1)\n",
            "Requirement already satisfied: text-unidecode>=1.3 in /usr/local/lib/python3.10/dist-packages (from python-slugify->kaggle) (1.3)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->kaggle) (3.6)\n",
            "Mounted at /content/drive\n",
            "Warning: Your Kaggle API key is readable by other users on this system! To fix this, you can run 'chmod 600 /root/.kaggle/kaggle.json'\n",
            "Downloading learning-of-structured-data-fhws-ws2324.zip to /content\n",
            " 91% 89.0M/98.3M [00:00<00:00, 161MB/s]\n",
            "100% 98.3M/98.3M [00:00<00:00, 140MB/s]\n"
          ]
        }
      ],
      "source": [
        "# @title Imported and extracted the Data\n",
        "\n",
        "# Install Kaggle library\n",
        "!pip install kaggle\n",
        "\n",
        "# Install colab and mount Google Drive\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "\n",
        "# Kaggle API key to the appropriate directory\n",
        "!mkdir -p ~/.kaggle\n",
        "!cp /content/kaggle.json  ~/.kaggle/\n",
        "# !chmod 600 ~/.kaggle/kaggle.json\n",
        "\n",
        "# Download the dataset\n",
        "!kaggle competitions download -c learning-of-structured-data-fhws-ws2324\n",
        "\n",
        "# Unzip the dataset\n",
        "!unzip -q learning-of-structured-data-fhws-ws2324.zip"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "219cfe94",
      "metadata": {
        "id": "219cfe94"
      },
      "outputs": [],
      "source": [
        "# @title Added  Necessary libraries\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import os\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bRGKgris_1nw",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bRGKgris_1nw",
        "outputId": "93e996c7-ad4a-46d1-828e-66e8098b0543"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ],
      "source": [
        "# @title Loading the dataset\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "84d2eac9",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "84d2eac9",
        "outputId": "dcd0559f-747c-4dea-8c42-0a4a34a38fae"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(1167, 1167)"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# @title Data preprocessing\n",
        "\n",
        "to_use = [] # columns to be used. skip the confidence score. and angles\n",
        "for i in range(0,75,3):\n",
        "    to_use.append(i)\n",
        "    to_use.append(i+1)\n",
        "\n",
        "data_list = []\n",
        "\n",
        "mapping = {\"boxing\" :0,\n",
        "\"drums\" : 1,\n",
        "\"guitar\" : 2,\n",
        "\"rowing\" : 3,\n",
        "\"violin\" :4}\n",
        "\n",
        "training_files =  os.listdir('/content/train/train/')\n",
        "\n",
        "for file in training_files:\n",
        "    d = pd.read_csv(f'/content/train/train/{file}',usecols=to_use)\n",
        "    d = d.fillna(0)\n",
        "    data_list.append(d.to_numpy()[:int(len(d)/2)]) # remove half of datasets, 'cause they are repeating, but additionally they have angles and confidience score\n",
        "\n",
        "# labels\n",
        "labels = []\n",
        "for name in training_files:\n",
        "    lab = mapping[name[9:-4]]\n",
        "    labels.append(lab)\n",
        "\n",
        "len(data_list),len(labels)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "de49f747",
      "metadata": {
        "id": "de49f747"
      },
      "outputs": [],
      "source": [
        "# @title Train test split\n",
        "from sklearn.model_selection import train_test_split\n",
        "X_train, X_test, y_train, y_test = train_test_split(data_list, labels, test_size=0.33, random_state=42)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "792dc5cc",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "792dc5cc",
        "outputId": "bf870a19-568d-4fc3-b261-e19e2c858a04"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(179037, 179037, 88157, 88157)"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# @title Creating Windows\n",
        "window_size = 50\n",
        "stride = 1\n",
        "\n",
        "#training\n",
        "tr_windows = []\n",
        "tr_window_labels = []\n",
        "\n",
        "\n",
        "for f,l in zip(X_train,y_train):\n",
        "    #print(f.shape)\n",
        "    for j in range(f.shape[0]-window_size):\n",
        "        tr_windows.append(f[j:j+50,:])\n",
        "        tr_window_labels.append(l)\n",
        "\n",
        "\n",
        "#validation\n",
        "te_windows = []\n",
        "te_window_labels = []\n",
        "\n",
        "\n",
        "for f,l in zip(X_test,y_test):\n",
        "    #print(f.shape)\n",
        "    for j in range(f.shape[0]-window_size):\n",
        "        te_windows.append(f[j:j+50,:])\n",
        "        te_window_labels.append(l)\n",
        "\n",
        "\n",
        "len(tr_windows),len(tr_window_labels),len(te_windows),len(te_window_labels)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "bfa33504",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bfa33504",
        "outputId": "dae313c0-7b0f-491d-dd12-43b645c6573e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(torch.Size([179037, 50, 50]),\n",
              " torch.Size([179037]),\n",
              " torch.Size([88157, 50, 50]),\n",
              " torch.Size([88157]))"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# @title Converted windows  into the  Tensors\n",
        "tr_windows = torch.tensor(np.array(tr_windows)).permute(0,2,1)\n",
        "tr_window_labels = torch.tensor(np.array(tr_window_labels))\n",
        "\n",
        "te_windows = torch.tensor(np.array(te_windows)).permute(0,2,1)\n",
        "te_window_labels = torch.tensor(np.array(te_window_labels))\n",
        "\n",
        "tr_windows.shape,tr_window_labels.shape,te_windows.shape,te_window_labels.shape"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "Uk3NEoPK698I",
      "metadata": {
        "id": "Uk3NEoPK698I"
      },
      "outputs": [],
      "source": [
        "# @title Selected avalible device\n",
        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "PjRLOgQgHwra",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PjRLOgQgHwra",
        "outputId": "62988e90-1a7d-4086-d912-e0b835ca5b3d"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "ImprovedCNN1DModel(\n",
            "  (cnn_layers): Sequential(\n",
            "    (0): Conv1d(50, 16, kernel_size=(3,), stride=(1,), padding=(1,))\n",
            "    (1): ReLU()\n",
            "    (2): MaxPool1d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "    (3): Conv1d(16, 32, kernel_size=(3,), stride=(1,), padding=(1,))\n",
            "    (4): ReLU()\n",
            "    (5): MaxPool1d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "    (6): Conv1d(32, 64, kernel_size=(3,), stride=(1,), padding=(1,))\n",
            "    (7): ReLU()\n",
            "    (8): MaxPool1d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
            "  )\n",
            "  (fc_layers): Sequential(\n",
            "    (0): Linear(in_features=384, out_features=128, bias=True)\n",
            "    (1): ReLU()\n",
            "    (2): Linear(in_features=128, out_features=64, bias=True)\n",
            "    (3): ReLU()\n",
            "    (4): Linear(in_features=64, out_features=5, bias=True)\n",
            "  )\n",
            ")\n"
          ]
        }
      ],
      "source": [
        "# @title CNN One  Dimensional Architecture\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "class ImprovedCNN1DModel(nn.Module):\n",
        "    def __init__(self, num_channels, window_size):\n",
        "        super(ImprovedCNN1DModel, self).__init__()\n",
        "\n",
        "        self.cnn_layers = nn.Sequential(\n",
        "            nn.Conv1d(num_channels, 16, kernel_size=3, stride=1, padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.MaxPool1d(kernel_size=2, stride=2),\n",
        "            nn.Conv1d(16, 32, kernel_size=3, stride=1, padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.MaxPool1d(kernel_size=2, stride=2),\n",
        "            nn.Conv1d(32, 64, kernel_size=3, stride=1, padding=1),\n",
        "            nn.ReLU(),\n",
        "            nn.MaxPool1d(kernel_size=2, stride=2)\n",
        "        )\n",
        "\n",
        "        # Calculate the final size after three CNN layers and pooling\n",
        "        final_size = window_size // 2 // 2 // 2\n",
        "\n",
        "        self.fc_layers = nn.Sequential(\n",
        "            nn.Linear(64 * final_size, 128),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(128, 64),\n",
        "            nn.ReLU(),\n",
        "            nn.Linear(64, 5)  # Assuming a regression task, change as needed\n",
        "        )\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.cnn_layers(x)\n",
        "\n",
        "        # Reshape for fully connected layer\n",
        "        x = x.view(x.size(0), -1)\n",
        "\n",
        "        x = self.fc_layers(x)\n",
        "        return x\n",
        "\n",
        "# Example instantiation with 50 channels and window size of 50\n",
        "num_channels = 50\n",
        "window_size = 50\n",
        "model = ImprovedCNN1DModel(num_channels=num_channels, window_size=window_size).to(device)\n",
        "\n",
        "# Print the improved model architecture\n",
        "print(model)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "af3e4cc8",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "af3e4cc8",
        "outputId": "59ae3aae-10d6-424b-90ba-f7db85d31a12"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "0.2047954325811393\n",
            "0.1369316673727676\n"
          ]
        }
      ],
      "source": [
        "# @title Training the  Model\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
        "\n",
        "l = []\n",
        "num_epochs = 2\n",
        "batch_size = 32\n",
        "for epoch in range(num_epochs):\n",
        "    model.train()\n",
        "    indexes = np.random.permutation(tr_windows.shape[0])\n",
        "    for i in range(0,indexes.shape[0],batch_size):\n",
        "        #print(i,indexes[i:i+batch_size])\n",
        "        inputs, lab = tr_windows[[indexes[i:i+batch_size]]].to(device), tr_window_labels[[indexes[i:i+batch_size]]].to(device)\n",
        "        #print(inputs.shape,labels)\n",
        "        optimizer.zero_grad()\n",
        "        outputs = model(inputs.float())\n",
        "        loss = criterion(outputs, lab.long())\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        l.append(loss.item())\n",
        "    print(sum(l)/len(l))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "cfafca93",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cfafca93",
        "outputId": "62f3673c-5e75-48b0-db1a-2f3192118a4c"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            " Validation Accuracy: 0.9537\n"
          ]
        }
      ],
      "source": [
        "# @title Validation of a Model\n",
        "model.eval()\n",
        "with torch.no_grad():\n",
        "    correct = 0\n",
        "    total = 0\n",
        "    for inputs, lab in zip(te_windows,te_window_labels):\n",
        "        inputs, lab = inputs.to(device), lab.to(device)\n",
        "        #print(lab)\n",
        "        outputs = model(inputs.reshape((1,50,50)).float())\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        total +=   1\n",
        "        correct += (predicted == lab).sum().item()\n",
        "\n",
        "    accuracy = correct / total\n",
        "    print(f\" Validation Accuracy: {accuracy:.4f}\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "9932e42c",
      "metadata": {
        "id": "9932e42c"
      },
      "outputs": [],
      "source": [
        "# @title Kaggle predictions\n",
        "n = 305\n",
        "stride=window_size\n",
        "predictions = []\n",
        "for i in range(n):\n",
        "    clab = []\n",
        "    file = pd.read_csv(f'/content/test/test/{i}.csv',usecols=to_use).fillna(0).to_numpy()\n",
        "    for j in range(0,file.shape[0]-window_size,stride):\n",
        "        inp = torch.tensor(file[j:j+50]).unsqueeze(0).permute(0,2,1).to(device)\n",
        "        #print(inp.shape)\n",
        "        out = torch.argmax(model(inp.float()))\n",
        "        clab.append(out.item())\n",
        "    unique, counts = np.unique(clab, return_counts=True)\n",
        "    fpred = unique[counts.argmax()]\n",
        "    predictions.append(fpred)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "id": "a27fee73",
      "metadata": {
        "id": "a27fee73"
      },
      "outputs": [],
      "source": [
        "# @title Writing the Solution in **Sumbission file**.\n",
        "sheet = {'id':range(305),'action':predictions}\n",
        "df = pd.DataFrame(sheet)\n",
        "df.to_csv('Submission_file.csv',index=False)"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "gpuType": "T4",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "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.10.9"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 5
}