Hairston_BMI500_WK13HW2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BMI 500 WK 13: \n",
    "## Edge Computing and Human Activity Analysis\n",
    "<b> JaMor Hairston </b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ATTRIBUTION: ChatGPT 3.5 used for explaining functionality and debuggin. Provided references: https://scikit-learn.org/stable/modules/neural_networks_supervised.html#classification; https://scikit-learn.org/stable/modules/generated/sklearn.neural_network.MLPClassifier.html#sklearn.neural_network.MLPClassifier; https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "from collections import defaultdict\n",
    "from itertools import product\n",
    "from pandas import Series\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.metrics import accuracy_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess(data, kernel_size):\n",
    "    proc_data = np.zeros(data.shape)\n",
    "    ''' preprocess '''\n",
    "    for ch in range(data.shape[1]):\n",
    "        kps_seq_ch = data[:, ch]\n",
    "        kps_seq_ch = Series(kps_seq_ch).rolling(kernel_size, min_periods=1, center=True).mean().to_numpy()\n",
    "        proc_data[:, ch] = kps_seq_ch\n",
    "    return proc_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def segmentation(data, win_size):\n",
    "    ''' Sliding window parameters '''\n",
    "    win_len = int(30*win_size) # 1 sec x 30 Hz\n",
    "    win_step = int(30*0.5) # 0.5 sec x 30 Hz\n",
    "    sample_windows = []\n",
    "    for start_time in range(0, data.shape[0], win_step):\n",
    "        end_time = start_time + win_len\n",
    "        if end_time > data.shape[0]:\n",
    "            end_time = data.shape[0]\n",
    "            start_time = end_time - win_len\n",
    "        frame = data[start_time:end_time]\n",
    "        assert frame.shape[0] == win_len, (start_time, end_time, data.shape[0])\n",
    "        sample_windows.append(frame)\n",
    "    sample_windows = np.array(sample_windows)\n",
    "    return sample_windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def feature_extraction(sample_windows):\n",
    "    ''' extract mean and std from each frame'''\n",
    "    N, T, D = sample_windows.shape\n",
    "    feats = []\n",
    "    for i in range(N):\n",
    "        frame = sample_windows[i]\n",
    "        feat = []\n",
    "        for ch in range(D):\n",
    "            frame_ch = frame[:,ch]\n",
    "            # mean feature\n",
    "            mean_ch = np.mean(frame_ch)\n",
    "            feat.append(mean_ch)\n",
    "            # std feature\n",
    "            std_ch = np.std(frame_ch)\n",
    "            feat.append(std_ch)\n",
    "            # min feature\n",
    "            min_ch = np.min(frame_ch)\n",
    "            feat.append(min_ch)\n",
    "            # max feature\n",
    "            max_ch = np.max(frame_ch)\n",
    "            feat.append(max_ch)\n",
    "        feats.append(feat)\n",
    "    feats = np.array(feats)\n",
    "    return feats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "file_names = os.listdir('pose')\n",
    "dict = defaultdict(list)\n",
    "for file_name in file_names:\n",
    "    subject_number = int(file_name[5:7])\n",
    "    # creating file directory\n",
    "    directory = 'pose/' + file_name\n",
    "    label_act = int(file_name[1:3]) - 1\n",
    "    # data load\n",
    "    data3D = np.load(directory)\n",
    "    # 3D to 2D\n",
    "    data = data3D.reshape(data3D.shape[0], -1)\n",
    "    kernel = 15\n",
    "    data_prep = preprocess(data, kernel)\n",
    "    win_len = 1\n",
    "    data_seg = segmentation(data_prep, win_len)\n",
    "    N = data_seg.shape[0]\n",
    "    features = feature_extraction(data_seg)\n",
    "    # storing features\n",
    "    dict[subject_number].append((features, [label_act] * N))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "trainx_list = []\n",
    "train_labels = []\n",
    "\n",
    "for i in range(1, 6):\n",
    "    for j in range(32):\n",
    "        trainx_list.append(dict[i][j][0])\n",
    "        train_labels.append(dict[i][j][1])\n",
    "        \n",
    "trainx = np.vstack(trainx_list)\n",
    "trainy = np.hstack(train_labels)\n",
    "\n",
    "valx_list = []\n",
    "val_labels = []\n",
    "\n",
    "for i in range(6, 8):\n",
    "    for j in range(32):\n",
    "        valx_list.append(dict[i][j][0])\n",
    "        val_labels.append(dict[i][j][1])\n",
    "        \n",
    "valx = np.vstack(valx_list)\n",
    "valy = np.hstack(val_labels)\n",
    "\n",
    "testx_list = []\n",
    "test_labels = []\n",
    "for i in range(8, 11):\n",
    "    for j in range(32):\n",
    "        testx_list.append(dict[i][j][0])\n",
    "        test_labels.append(dict[i][j][1])\n",
    "        \n",
    "testx = np.vstack(testx_list)\n",
    "testy = np.hstack(test_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((100, 50), 0.001, 100, 'adam', 'adaptive')\n",
      "((100, 50), 0.001, 100, 'sgd', 'adaptive')\n",
      "((100, 50), 0.001, 200, 'adam', 'adaptive')\n",
      "((100, 50), 0.001, 200, 'sgd', 'adaptive')\n",
      "((100, 50), 0.01, 100, 'adam', 'adaptive')\n",
      "((100, 50), 0.01, 100, 'sgd', 'adaptive')\n",
      "((100, 50), 0.01, 200, 'adam', 'adaptive')\n",
      "((100, 50), 0.01, 200, 'sgd', 'adaptive')\n",
      "((40, 20), 0.001, 100, 'adam', 'adaptive')\n",
      "((40, 20), 0.001, 100, 'sgd', 'adaptive')\n",
      "((40, 20), 0.001, 200, 'adam', 'adaptive')\n",
      "((40, 20), 0.001, 200, 'sgd', 'adaptive')\n",
      "((40, 20), 0.01, 100, 'adam', 'adaptive')\n",
      "((40, 20), 0.01, 100, 'sgd', 'adaptive')\n",
      "((40, 20), 0.01, 200, 'adam', 'adaptive')\n",
      "((40, 20), 0.01, 200, 'sgd', 'adaptive')\n",
      "((20,), 0.001, 100, 'adam', 'adaptive')\n",
      "((20,), 0.001, 100, 'sgd', 'adaptive')\n",
      "((20,), 0.001, 200, 'adam', 'adaptive')\n",
      "((20,), 0.001, 200, 'sgd', 'adaptive')\n",
      "((20,), 0.01, 100, 'adam', 'adaptive')\n",
      "((20,), 0.01, 100, 'sgd', 'adaptive')\n",
      "((20,), 0.01, 200, 'adam', 'adaptive')\n",
      "((20,), 0.01, 200, 'sgd', 'adaptive')\n",
      "Best Parameters: {'hidden_layer_sizes': (100, 50), 'alpha': 0.001, 'max_iter': 200, 'solver': 'adam', 'learning_rate': 'adaptive'}\n",
      "Validation Set Accuracy with Best Parameters: 0.6416573348264277\n",
      "Test Set Accuracy with Best Parameters: 0.5190311418685121\n"
     ]
    }
   ],
   "source": [
    "# hyperparameter grid\n",
    "param_grid = {\n",
    "    'hidden_layer_sizes': [(100, 50), (40, 20), (20, )],   \n",
    "    'alpha': [0.001, 0.01], \n",
    "    'max_iter': [100, 200], \n",
    "    'solver': ['adam', 'sgd'], \n",
    "    'learning_rate': ['adaptive']\n",
    "}\n",
    "\n",
    "best_score = 0\n",
    "best_params = {}\n",
    "\n",
    "for params in product(*param_grid.values()):\n",
    "    param_dict = {key: value for key, value in zip(param_grid.keys(), params)}\n",
    "    print(params)\n",
    "    \n",
    "    model = MLPClassifier(**param_dict)\n",
    "    model.fit(trainx, trainy)\n",
    "    \n",
    "    val_predictions = model.predict(valx)\n",
    "    val_accuracy = accuracy_score(valy, val_predictions)\n",
    "    if val_accuracy > best_score:\n",
    "        best_score = val_accuracy\n",
    "        best_params = param_dict\n",
    "\n",
    "# reporting\n",
    "best_model = MLPClassifier(**best_params)\n",
    "trainx_all = np.vstack((trainx, valx))\n",
    "trainy_all = np.hstack((trainy, valy))\n",
    "best_model.fit(trainx_all, trainy_all)\n",
    "\n",
    "test_predictions = best_model.predict(testx)\n",
    "test_accuracy = accuracy_score(testy, test_predictions)\n",
    "\n",
    "print(\"Best Parameters:\", best_params)\n",
    "print(\"Validation Set Accuracy with Best Parameters:\", best_score)\n",
    "print(\"Test Set Accuracy with Best Parameters:\", test_accuracy)"
   ]
  }
 ],
 "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.11.5"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}