LR.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Load modules\n",
    "import sklearn\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import r2_score\n",
    "from sklearn.metrics import mean_squared_error\n",
    "import numpy as np\n",
    "from numpy import genfromtxt\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "import dataHelp as dh\n",
    "cwd = os.getcwd() # current working directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def splitSignals(signals, bin_size, data_labels, features, forces):\n",
    "    if signals == \"EMG\":\n",
    "        start = forces*bin_size\n",
    "        stop = features*bin_size-1\n",
    "        data_labels = data_labels[forces:]\n",
    "    elif signals == \"forces\":\n",
    "        start = 0\n",
    "        stop = forces*bin_size-1\n",
    "        data_labels = data_labels[0:forces]\n",
    "    elif signals == \"all\":\n",
    "        start = 0\n",
    "        stop = features*bin_size-1\n",
    "    return start, stop, data_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test subjects:  [0]\n",
      "Dev subjects:  [0]\n",
      "Train subjects:  [4, 1, 6, 2, 3, 7, 5]\n",
      "Test subjects:  [1]\n",
      "Dev subjects:  [1]\n",
      "Train subjects:  [2, 3, 6, 7, 0, 4, 5]\n",
      "Test subjects:  [2]\n",
      "Dev subjects:  [2]\n",
      "Train subjects:  [5, 7, 4, 6, 3, 1, 0]\n",
      "Test subjects:  [3]\n",
      "Dev subjects:  [3]\n",
      "Train subjects:  [7, 2, 4, 1, 0, 5, 6]\n",
      "Test subjects:  [4]\n",
      "Dev subjects:  [4]\n",
      "Train subjects:  [3, 0, 1, 5, 7, 2, 6]\n",
      "Test subjects:  [5]\n",
      "Dev subjects:  [5]\n",
      "Train subjects:  [7, 2, 1, 6, 0, 4, 3]\n",
      "Test subjects:  [6]\n",
      "Dev subjects:  [6]\n",
      "Train subjects:  [7, 1, 2, 3, 0, 5, 4]\n",
      "Test subjects:  [7]\n",
      "Dev subjects:  [7]\n",
      "Train subjects:  [2, 5, 0, 6, 3, 1, 4]\n",
      "Train error percent:  1.4288757857635443\n",
      "Test error percent:  8.405465787851279\n",
      "Test MAE:  28.89993838018115\n",
      "Test RMSE:  33.56501348006795\n",
      "R2 for the train sets:  0.9678818809467359\n"
     ]
    }
   ],
   "source": [
    "##### Load data\n",
    "folder_name= \"assisted_subjects_30bins\"#\"incline-load_conditions_30bins\" # dataset name here, use conditions for conditions/subjcond simulations\n",
    "data_type = \"subjects\" # subjects, conditions, or subjcond\n",
    "subject_test = True # set true to iteratively test on all subjects\n",
    "signals = \"all\" # all, EMG, or forces\n",
    "\n",
    "y_ind = 0 # which metabolic predictor to use, 0 is direct measured metabolic\n",
    "norm = True # whether to normalize data\n",
    "seed = 1 # to keep consistent results\n",
    "train_size = 0.8 # percent of data for training set\n",
    "conds_holdout = 2 # number of conditions to holdout and test for subjcond\n",
    "\n",
    "\n",
    "if folder_name[0:8] == \"assisted\":\n",
    "    dataset = \"exo\"\n",
    "    num_conds = 9\n",
    "    features = 22\n",
    "    forces = 6\n",
    "    seed_list = [2,10,3,5,25,1,9,7]\n",
    "    data_labels = np.array([\"Fx_R\", \"Fy_R\", \"Fz_R\", \"Fx_L\", \"Fy_L\", \"Fz_L\", \n",
    "               \"MGAS_R\", \"LGAS_R\", \"MSOL_R\", \"LSOL_R\", \"TA_R\", \"VASM_R\", \"RF_R\", \"BF_R\",\n",
    "               \"MGAS_L\", \"LGAS_L\", \"MSOL_L\", \"LSOL_L\", \"TA_L\", \"VASM_L\", \"RF_L\", \"BF_L\"])\n",
    "\n",
    "elif folder_name[0:12] == \"incline-load\":\n",
    "    dataset = \"incline_load\"\n",
    "    num_conds = 12\n",
    "    features = 14\n",
    "    forces = 6\n",
    "    seed_list = [41,17,13,5,7,1,40,32,2,10,3,12,9]\n",
    "    data_labels = np.array([\"Fx_R\", \"Fy_R\", \"Fz_R\", \"Fx_L\", \"Fy_L\", \"Fz_L\",\n",
    "                            \"SOL\", \"GAS\", \"TA\", \"MH\", \"BF\", \"VM\", \"VL\", \"RF\"])\n",
    "\n",
    "\n",
    "if data_type == \"subjects\" or data_type == \"conditions\" or data_type[0:8] == \"subjcond\":\n",
    "    if subject_test:\n",
    "        test_size = 1\n",
    "        runs = len(seed_list)\n",
    "    else:\n",
    "        test_size = 3\n",
    "        runs = 1\n",
    "else:\n",
    "    test_size = 0.1\n",
    "    runs = 1\n",
    "    \n",
    "if data_type == \"subjcond\":\n",
    "    data_type = data_type + \" \" + str(conds_holdout)\n",
    "\n",
    "training_err = []\n",
    "deving_err = []\n",
    "testing_err = []\n",
    "\n",
    "R2s = []\n",
    "test_rmses = []\n",
    "test_maes = []\n",
    "\n",
    "pred_out = [] # for confusion mat\n",
    "actual_out = [] # for confusion mat\n",
    "\n",
    "for i in range(runs): # number of times iteratively testing for averaged results\n",
    "    \n",
    "    if subject_test:\n",
    "        seed = seed_list[i]\n",
    "    X_train, Y_train, X_dev, Y_dev, X_test, Y_test = dh.loadData(data_type, cwd, seed, y_ind, train_size, test_size, features, norm, folder_name, None, signals)\n",
    "\n",
    "    # Selecting which signals to include:\n",
    "    bin_size = int(X_train.shape[1]/features) # check to compute bin size is 30\n",
    "    start, stop, data_labels = splitSignals(signals, bin_size, data_labels, features, forces)\n",
    "               \n",
    "    signal_rng = np.linspace(start,stop,stop-start+1).astype(int)\n",
    "    X_train = X_train[:,signal_rng]\n",
    "    X_dev = X_dev[:,signal_rng]\n",
    "    X_test = X_test[:,signal_rng]\n",
    "    \n",
    "    lm = LinearRegression() # define linear model\n",
    "    lm.fit(X_train,Y_train) # train on the data\n",
    "    \n",
    "    train_pred = lm.predict(X_train)\n",
    "    test_pred = lm.predict(X_test)\n",
    "    dev_pred = lm.predict(X_dev)\n",
    "    \n",
    "    R2 = r2_score(Y_train, train_pred) # compute R squared on training data\n",
    "    \n",
    "    test_mae = np.mean(abs(test_pred - Y_test))\n",
    "    test_rmse = np.sqrt(mean_squared_error(Y_test, test_pred))\n",
    "\n",
    "    train_err = np.mean(abs((train_pred - Y_train)/Y_train)) # absolute error\n",
    "    dev_err = np.mean(abs((dev_pred - Y_dev)/Y_dev))\n",
    "    test_err = np.mean(abs((test_pred - Y_test)/Y_test))\n",
    "    training_err.append(train_err)\n",
    "    testing_err.append(test_err)\n",
    "    deving_err.append(dev_err)\n",
    "    R2s.append(R2)\n",
    "    test_maes.append(test_mae)\n",
    "    test_rmses.append(test_rmse)\n",
    "    pred_avg, actual_avg = dh.avgSubjectCond(test_pred,Y_test)\n",
    "    pred_out.append(pred_avg)\n",
    "    actual_out.append(actual_avg)\n",
    "\n",
    "print(\"Train error percent: \",np.mean(training_err)*100)\n",
    "#print(\"Dev error percent: \",np.mean(deving_err)*100)\n",
    "print(\"Test error percent: \",np.mean(testing_err)*100)\n",
    "print(\"Test MAE: \",np.mean(test_maes))\n",
    "print(\"Test RMSE: \",np.mean(test_rmses))\n",
    "print(\"R2 for the train sets: \",np.mean(R2s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3108, 660)\n",
      "Fz_L bin 8\n",
      "Fz_L bin 11\n",
      "Fz_L bin 6\n",
      "Fz_R bin 25\n",
      "Fz_R bin 23\n",
      "Fz_L bin 13\n",
      "Fz_R bin 27\n",
      "Fz_R bin 28\n",
      "Fz_R bin 26\n",
      "Fz_L bin 10\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape)\n",
    "# Analayzing coefficients for linear model\n",
    "coef_print = 10 # how many coef to print out\n",
    "coef = lm.coef_ # coefficients for trained model\n",
    "coef_abs = abs(coef)\n",
    "coef_order = np.argsort(-coef_abs) # reverse order --> get largest weighted predictors first\n",
    "for i in range(coef_print):\n",
    "    feature = coef_order[i]//(bin_size) \n",
    "    bin_num = coef_order[i]%bin_size + 1\n",
    "    print(data_labels[feature] + ' bin ' + str(bin_num))"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}