Computer Vision/Human_Activity_Recognition.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Human Activity Recognition.ipynb",
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyNUXpa9XSHvstZh4kvMW9BT",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/hussain0048/Projects-/blob/master/Human_Activity_Recognition.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5k4WRBaseTdn"
      },
      "source": [
        "#**1-Introduction**\n",
        "Human activity recognition is the problem of classifying sequences of data recorded by specialized harnesses or smart phones into known well-defined Human activities.[1]\n",
        "\n",
        "It is a challenging problem as the large number of observations are produced each second, the temporal nature of the observations, and the lack of a clear way to relate data to known movements increase the challenges.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KM1lOZwhe0st"
      },
      "source": [
        "#**2-Importing necessary libraries**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9XtT225Fe7gv",
        "outputId": "d5051e58-4a51-45be-80e0-e381a4be0af6",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        }
      },
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "import warnings\n",
        "warnings.filterwarnings(\"ignore\")"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/statsmodels/tools/_testing.py:19: FutureWarning: pandas.util.testing is deprecated. Use the functions in the public API at pandas.testing instead.\n",
            "  import pandas.util.testing as tm\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xSq-zDRqfWK5"
      },
      "source": [
        "#**3-Reading the data**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VcqUC890fgbS",
        "outputId": "33aa3290-80ea-4fa8-d619-facb65e63e94",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mounted at /content/drive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JHq3cC7Tfeyu"
      },
      "source": [
        "train = pd.read_csv(\"/content/drive/My Drive/Datasets/Human Activity Recognition/train-1.csv\")\n",
        "test = pd.read_csv(\"/content/drive/My Drive/Datasets/Human Activity Recognition/test.csv\")"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_FdoawX66eFB"
      },
      "source": [
        "train.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fHzJ4ecc6m3g"
      },
      "source": [
        "train.shape, test.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wup0Ul0Q6NvB"
      },
      "source": [
        "#**4-To Combine both the  data framemes**\n",
        "To Combine both the  data frames\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b96SHjK-6YiB"
      },
      "source": [
        "train['Data'] = 'Train'\n",
        "test['Data'] = 'Test'\n",
        "both = pd.concat([train, test], axis=0).reset_index(drop=True)\n",
        "both['subject'] = '#' + both['subject'].astype(str)"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nZq3lA6u64ix"
      },
      "source": [
        "both.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "x9v_GQGh6xrh",
        "outputId": "aea302ef-2cd5-42dd-9d3e-c1a9ecefcf2a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "both.dtypes.value_counts()"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float64    561\n",
              "object       3\n",
              "dtype: int64"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YUci-bBi70uP"
      },
      "source": [
        "def basic_details(df):\n",
        "    b = pd.DataFrame()\n",
        "    b['Missing value'] = df.isnull().sum()\n",
        "    b['N unique value'] = df.nunique()\n",
        "    b['dtype'] = df.dtypes\n",
        "    return b\n",
        "basic_details(both)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f5QMFvbS8Bx_"
      },
      "source": [
        "activity = both['Activity']\n",
        "label_counts = activity.value_counts()\n",
        "\n",
        "plt.figure(figsize= (12, 8))\n",
        "plt.bar(label_counts.index, label_counts)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "65IC5kdf8NOq"
      },
      "source": [
        "ata = both['Data']\n",
        "Subject = both['subject']\n",
        "train = both.copy()\n",
        "train = train.drop(['Data','subject','Activity'], axis =1)"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TxHuKZ_Z8XRl"
      },
      "source": [
        "#**4-To Scale the data**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S7Rhv0Li8h0W"
      },
      "source": [
        "# Standard Scaler\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "slc = StandardScaler()\n",
        "train = slc.fit_transform(train)\n",
        "\n",
        "# dimensionality reduction\n",
        "from sklearn.decomposition import PCA\n",
        "pca = PCA(n_components=0.9, random_state=0)\n",
        "train = pca.fit_transform(train)"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9DsuD_fH8pRl"
      },
      "source": [
        "#**5-Splitting the  data into training and testing**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NF59C5YR8vtf"
      },
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "X_train, X_test, y_train, y_test = train_test_split(train, activity, test_size = 0.2, random_state = 0)"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6gcJRPtr84vu"
      },
      "source": [
        "Test options and evaluation metric"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uT4rap_j8_3O"
      },
      "source": [
        "num_folds = 10\n",
        "seed = 0\n",
        "scoring = 'accuracy'\n",
        "results = {}\n",
        "accuracy = {}"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r7YE34nh9GLb"
      },
      "source": [
        "#**6-Activity Recognition Algorithm**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4CkuDXzf9TZ1"
      },
      "source": [
        "# Finalizing the model and comparing the test, predict results\n",
        "from sklearn.neighbors import KNeighborsClassifier\n",
        "from sklearn.metrics import confusion_matrix, accuracy_score, classification_report\n",
        "from sklearn.model_selection import KFold, cross_val_score"
      ],
      "execution_count": 16,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0XKSsQTn9ZLu"
      },
      "source": [
        "model = KNeighborsClassifier(algorithm= 'auto', n_neighbors= 8, p= 1, weights= 'distance')\n",
        "\n",
        "_ = cross_val_score(model, X_train, y_train, cv=10, scoring=scoring)\n",
        "results[\"GScv\"] = (_.mean(), _.std())\n"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "plEb_ooJ9kUO"
      },
      "source": [
        "model.fit(X_train, y_train) \n",
        "y_predict = model.predict(X_test)\n"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MohEpL9L9rCu"
      },
      "source": [
        "accuracy[\"GScv\"] = accuracy_score(y_test, y_predict)"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "65Q1gxZ49w3-"
      },
      "source": [
        "print(classification_report(y_test, y_predict))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z4uAByj695y2"
      },
      "source": [
        "cm= confusion_matrix(y_test, y_predict)\n",
        "sns.heatmap(cm, annot=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1-JTCUE0d-YJ"
      },
      "source": [
        "#**References**\n",
        "[[1]Human Activity Recognition using Smartphone Data with Machine Learning](https://thecleverprogrammer.com/2020/05/27/human-activity-recognition-using-smartphone-data-with-machine-learning/)"
      ]
    }
  ]
}