Neural network demo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fill_by_average(prev_data):\n",
    "    final_data=[]\n",
    "    for i,item in enumerate(prev_data):\n",
    "        final_data.append(item)\n",
    "        if i<len(prev_data)-1:\n",
    "            final_data.append((item+prev_data[i+1])/2)\n",
    "    return final_data\n",
    "from sklearn import preprocessing\n",
    "\n",
    "def fft_from_data_frame(data_frame,fs=1e6):\n",
    "    signal_set = []\n",
    "    for index, row in data_frame.iterrows():\n",
    "        fft_data = fft(row, n=row.size)/row.size\n",
    "        freq = fftfreq(row.size, d=1/fs)\n",
    "        cut_high_signal = np.abs(fft_data).copy()\n",
    "        cut_high_signal[(freq > 50000)] = 0\n",
    "        cut_high_signal[(freq < 30000)] = 0\n",
    "        d = np.abs(cut_high_signal)\n",
    "#         d  = list(filter(lambda a: a != 0, d))\n",
    "        while len(d) < 80:\n",
    "            d = fill_by_average(d) \n",
    "        if len(d) == 81:\n",
    "            d.insert(41,(d[0]+d[len(d)-1])/2)\n",
    "        signal_set.append(d)\n",
    "    return signal_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4095\n",
      "ee\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from scipy.signal import hilbert, chirp\n",
    "def hilbert_transform(data_frame,fs=1e6):\n",
    "    signal_set = []\n",
    "    for index, signal in data_frame.iterrows():\n",
    "        analytic_signal = hilbert(signal)\n",
    "        amplitude_envelope = np.abs(analytic_signal)\n",
    "        instantaneous_phase = np.unwrap(np.angle(analytic_signal))\n",
    "        instantaneous_frequency = (np.diff(instantaneous_phase)/((2.0*np.pi) * fs))\n",
    "        print(len(instantaneous_frequency))\n",
    "        signal_set.append(analytic_signal)\n",
    "        t = np.arange(4096) / 1e6\n",
    "        fig = plt.figure()\n",
    "        ax0 = fig.add_subplot(211)\n",
    "        ax0.plot(t, signal, label='signal')\n",
    "        ax0.plot(t, amplitude_envelope, label='envelope')\n",
    "        ax0.set_xlabel(\"time in seconds\")\n",
    "        ax0.legend()\n",
    "        ax1 = fig.add_subplot(212)\n",
    "        ax1.plot(t[1:], instantaneous_frequency)\n",
    "        ax1.set_xlabel(\"time in seconds\")\n",
    "        ax1.set_ylim(0.0, 120.0)\n",
    "        return\n",
    "    return signal_set\n",
    "hilbert_transform(stopper_data)\n",
    "print('ee')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import plotly\n",
    "from numpy.fft import fft, fftfreq, ifft, rfft\n",
    "\n",
    "stopper_data = pd.read_csv('./data/train/Stopper/_80cm_AS_00008.csv', header=None)\n",
    "stopper_data_2 = pd.read_csv('./data/train/Stopper/100cm_AS_00003.csv', header=None)\n",
    "wall_data = pd.read_csv('./data/train/Wall_Collection/_80cm_AS_00002.csv', header=None)\n",
    "wall_data_2 = pd.read_csv('./data/train/Wall_Collection/100cm_AS_00005.csv', header=None)\n",
    "\n",
    "predict_stopper_data = pd.read_csv('./data/predict/Stopper/100cm_AS_00003.csv', header=None)\n",
    "predict_wall_data = pd.read_csv('./data/predict/Wall_Collection/_80cm_AS_00002.csv', header=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "stopper_fft = fft_from_data_frame(stopper_data) + fft_from_data_frame(stopper_data_2)\n",
    "wall_fft = fft_from_data_frame(wall_data)+ fft_from_data_frame(wall_data_2)\n",
    "predict_stopper_fft = fft_from_data_frame(predict_stopper_data)\n",
    "predict_wall_fft = fft_from_data_frame(predict_wall_data)\n",
    "X = stopper_fft + wall_fft\n",
    "y = [0]*len(stopper_fft) + [1]*len(wall_fft)\n",
    "predict_X = predict_stopper_fft + predict_wall_fft\n",
    "y_true = [0]*len(predict_stopper_fft) + [1]*len(predict_wall_fft)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "metadata": {},
   "outputs": [],
   "source": [
    "#all files\n",
    "# stopper_data = pd.read_csv('./data/all/Stopper_train_80_to_180.csv', header=None)\n",
    "# wall_data = pd.read_csv('./data/all/Wall_Collection_train_80_to_180.csv', header=None)\n",
    "# predict_stopper_data = pd.read_csv('./data/all/Stopper_predict_80_to_180.csv', header=None)\n",
    "# predict_wall_data = pd.read_csv('./data/all/Wall_Collection_predict_80_to_180.csv', header=None)\n",
    "\n",
    "\n",
    "stopper_data = pd.read_csv('./final_data/Step_train_aggregate.csv', header=None)\n",
    "wall_data = pd.read_csv('./final_data/Wall_train_aggregate.csv', header=None)\n",
    "predict_stopper_data = pd.read_csv('./final_data/Step_predict_aggregate.csv', header=None)\n",
    "predict_wall_data = pd.read_csv('./final_data/Wall_predict_aggregate.csv', header=None)\n",
    "\n",
    "#get fft\n",
    "stopper_fft = fft_from_data_frame(stopper_data)\n",
    "wall_fft = fft_from_data_frame(wall_data)\n",
    "X = stopper_fft + wall_fft\n",
    "y = [11]*len(stopper_fft) + [2]*len(wall_fft)\n",
    "\n",
    "#predictions\n",
    "predict_stopper_fft = fft_from_data_frame(predict_stopper_data)\n",
    "predict_wall_fft = fft_from_data_frame(predict_wall_data)\n",
    "predict_X = predict_stopper_fft + predict_wall_fft\n",
    "y_true = [0]*len(predict_stopper_fft) + [1]*len(predict_wall_fft)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'predict_wall_fft' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-d1e2a7795588>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mclf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMLPClassifier\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msolver\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'lbfgs'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0malpha\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1e-5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mhidden_layer_sizes\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrandom_state\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mclf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpredict_wall_fft\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mclf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpredict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpredict_wall_fft\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mresult\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'predict_wall_fft' is not defined"
     ]
    }
   ],
   "source": [
    "from sklearn.neural_network import MLPClassifier\n",
    "clf = MLPClassifier(solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(7,), random_state=1)\n",
    "clf.fit(X, y)\n",
    "print(len(predict_wall_fft[0]))\n",
    "result = clf.predict(predict_wall_fft)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEKCAYAAAD9xUlFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xt8VNW5//HPw10UFAV/RwkSkEtJSEAMt2MFFJAUFSp6uNS7AtUWtVq1VC1ytP1phVqrpVhUiloFFUVS5RSUi8VWEJCLEgURUIOeAgGFomgCz/ljT3aHkMsEsjMkfN+vV17MXnvN3s+ekHlmrbVnLXN3REREAGolOwARETlyKCmIiEhISUFEREJKCiIiElJSEBGRkJKCiIiElBRERCSkpCAiIiElBRERCdVJdgAV1bRpU09NTU12GCIi1cqKFSu2u3uz8upVu6SQmprK8uXLkx2GiEi1YmYfJ1JP3UciIhJSUhARkZCSgoiIhJQUREQkpKQgIiKhyJKCmU01s61m9l4p+83MHjazDWa2xsy6RBWLiIgkJsqWwjQgu4z93wPaxn5GA5MjjEVERBIQ2fcU3P1vZpZaRpXBwFMerAe6xMxOMLNT3P3zqGI6Ejy79BNmr9qS7DBEpBpKO7Uxd1+YHuk5kjmm0Bz4NG47L1Z2EDMbbWbLzWz5tm3bqiS4KDy79BPumPUuSzftSHYoIiIlSuY3mq2EMi+portPAaYAZGVllVinskT5Sb4oGfz/izL4QffTIjmHiMjhSGZSyANaxG2nAJ8lKZbQ7FVbyP18F2mnNK70Y3dvdSKDOzdXQhCRI1Yyk0IOMMbMZgDdgS+TMZ5QvGVQlBCe+2HPqg5FRCTpIksKZjYd6AM0NbM84G6gLoC7PwrMAQYCG4CvgKujiqUsxVsGaac0ZnDnEoc2RERqvCjvPhpRzn4HfhzV+RPx7NJPWLppB91bnaiWgYgIR/k3mou6jdQyEBEJHNVJAYLBXw38iogEqt0iO5WhaHA5qruMRESqq6OypRCfENR1JCLyb0dlSwHQbaciIiU4KlsKIiJSMiUFEREJHXVJoei7CSIicrCjLinouwkiIqU76pIC6LsJIiKlOSqTgoiIlExJQUREQkoKIiISUlIQEZGQkoKIiISUFEREJKSkICIiISUFEREJKSmIiEhISUFEREJKCiIiElJSEBGRkJKCiIiElBRERCSkpCAiIiElBRERCSkpiIhISElBRERCSgoiIhJSUhARkVCkScHMss1snZltMLOxJew/zcwWmtlKM1tjZgOjjEdERMoWWVIws9rAJOB7QBowwszSilW7C3je3c8AhgN/iCoeEREpX5QthW7ABnff6O7fAjOAwcXqONA49vh44LMI4xERkXLUifDYzYFP47bzgO7F6owH5pnZDcCxQL8I4xERkXJE2VKwEsq82PYIYJq7pwADgafN7KCYzGy0mS03s+Xbtm2LIFQREYFok0Ie0CJuO4WDu4euBZ4HcPe3gAZA0+IHcvcp7p7l7lnNmjWLKFwREYkyKSwD2ppZKzOrRzCQnFOszidAXwAz60CQFNQUEBFJksiSgrsXAmOAucD7BHcZrTWze8xsUKzaT4FRZrYamA5c5e7Fu5hERKSKRDnQjLvPAeYUKxsX9zgXOCvKGEREJHH6RrOIiISUFEREJKSkICIiISUFEREJKSmIiEhISUFEREJKCiIiElJSEBGRkJKCiIiElBRERCSUUFIws3pm1ibqYEREJLnKTQpmdj7wLvBabLuzmc2KOjAREal6ibQU7iFYMe0LAHdfBajVICJSAyUyS2qBu39hdsBCatVueutnl37C7FVbyP18F2mnNC7/CSIiR6FEksL7ZjYUqGVmrYCbgCXRhlX54hPC4M7Nkx2OiMgRKZGkMAYYB+wHXiJYNOfnUQYVlbRTGvPcD3smOwwRkSNWIklhgLv/DPhZUYGZDSFIECIiUoMkMtB8Vwlld1Z2ICIiknylthTMbACQDTQ3swfjdjUm6EoSEZEapqzuo63Ae8BeYG1c+W5gbJRBiYhIcpSaFNx9JbDSzJ5x971VGJOIiCRJIgPNzc3sV0Aa0KCo0N3bRRaViIgkRSIDzdOAPwEGfA94HpgRYUwiIpIkiSSFhu4+F8DdP3L3u4Bzog1LRESSIZHuo28smOPiIzO7DtgCnBxtWCIikgyJJIWbgeOAG4FfAccD10QZlIiIJEe5ScHdl8Ye7gYuBzCzlCiDEhGR5ChzTMHMuprZ982saWw73cyeohpOiCciIuUrNSmY2X3AM8ClwF/N7E5gIbAa0O2oIiI1UFndR4OBTu7+tZmdCHwW215XNaGJiEhVK6v7aK+7fw3g7juAD5QQRERqtrJaCq3NrGh6bANS47Zx9yHlHdzMsoHfAbWBx939/hLqDAXGE6zmttrdf5B4+CIiUpnKSgoXF9v+fUUObGa1gUlAfyAPWGZmOe6eG1enLcGCPWe5+04z0/cfRESSqKwJ8eYf5rG7ARvcfSOAmc0gGKfIjaszCpjk7jtj59x6mOcUEZHDkMg0F4eqOfBp3HZerCxeO6Cdmf3dzJbEupsOYmajzWy5mS3ftm1bROGKiEiUScFKKPNi23WAtkAfYATwuJmdcNCT3Ke4e5a7ZzVr1qzSAxURkUDCScHM6lfw2HlAi7jtFILbWovXme3uBe6+CVhHkCRERCQJyk0KZtbNzN4FPoxtdzKzRxI49jKgrZm1MrN6wHAgp1idl4nNuBr71nQ7YGMF4hcRkUqUSEvhYeACIB/A3VeTwNTZ7l4IjAHmAu8Dz7v7WjO7x8wGxarNBfLNLJfg29K3uXt+xS9DREQqQyKzpNZy94+D2bND+xI5uLvPAeYUKxsX99iBW2I/IiKSZIkkhU/NrBvgse8e3ACsjzYsERFJhkS6j64n+CR/GvBPoEesTEREaphEWgqF7j488khERCTpEmkpLDOzOWZ2pZk1ijwiERFJmnKTgrufDvwSOBN418xeNjO1HEREaqCEvrzm7v9w9xuBLsAugsV3RESkhknky2vHmdmlZvYX4G1gG/CfkUcmIiJVLpGB5veAvwAPuPviiOMREZEkSiQptHb3/ZFHIiIiSVdqUjCz37j7T4EXzaz47KYJrbwmIiLVS1kthedi/1ZoxTUREam+ylp57e3Yww7ufkBiMLMxwOGuzCYiIkeYRG5JvaaEsmsrOxAREUm+ssYUhhGsgdDKzF6K29UI+CLqwEREpOqVNabwNsEaCinApLjy3cDKKIMSEZHkKGtMYROwCXi96sIREZFkKqv76A13721mO4H4W1KNYH2cEyOPTkREqlRZ3UdFS242rYpAREQk+Uq9+yjuW8wtgNruvg/oCfwQOLYKYhMRkSqWyC2pLxMsxXk68BTQAXg20qhERCQpEkkK+929ABgCPOTuNwDNow1LRESSIZGkUGhm/wVcDrwSK6sbXUgiIpIsiX6j+RyCqbM3mlkrYHq0YYmISDKUO3W2u79nZjcCbczsO8AGd/9V9KGJiEhVKzcpmNnZwNPAFoLvKPyHmV3u7n+POjgREalaiSyy81tgoLvnAphZB4IkkRVlYCIiUvUSGVOoV5QQANz9faBedCGJiEiyJNJSeMfM/kjQOgC4FE2IJyJSIyWSFK4DbgRuJxhT+BvwSJRBiYhIcpSZFMwsAzgdmOXuD1RNSCIikiyljimY2R0EU1xcCrxmZiWtwFYmM8s2s3VmtsHMxpZR7xIzczPT4LWISBKV1VK4FMh09z1m1gyYA0xN9MBmVptgcZ7+QB6wzMxy4getY/UaEXRPLa1o8CIiUrnKuvvoG3ffA+Du28qpW5JuBF902+ju3wIzgMEl1LsXeADYW8Hji4hIJSurpdA6bm1mA06PX6vZ3YeUc+zmwKdx23lA9/gKZnYG0MLdXzGzWxMPW0REolBWUri42PbvK3hsK6EsXMHNzGoRfDHuqnIPZDYaGA1w2mmnVTAMERFJVFlrNM8/zGPnESzQUyQF+CxuuxHQEVhkZgD/AeSY2SB3X14slinAFICsrKz4pUFFRKQSVXScoCKWAW3NrJWZ1QOGAzlFO939S3dv6u6p7p4KLAEOSggiIlJ1IksK7l4IjAHmAu8Dz7v7WjO7x8wGRXVeERE5dIl8oxkAM6vv7t9U5ODuPofgVtb4snGl1O1TkWOLiEjlK7elYGbdzOxd4MPYdicz0zQXIiI1UCLdRw8DFwD5AO6+mmAlNhERqWESSQq13P3jYmX7oghGRESSK5ExhU/NrBvgsakrbgDWRxuWiIgkQyItheuBW4DTgH8CPWJlIiJSw5TbUnD3rQTfMRARkRqu3KRgZo8RNz1FEXcfHUlEIiKSNImMKbwe97gBcBEHTnQnIiI1RCLdR8/Fb5vZ08BrkUUkIiJJcyjTXLQCWlZ2ICIiknyJjCns5N9jCrWAHUCpS2uKiEj1VWZSsGBO607AlljRfnfX1NUiIjVUmd1HsQQwy933xX6UEEREarBExhTeNrMukUciIiJJV2r3kZnVia2J8F1glJl9BOwhWGbT3V2JQkSkhilrTOFtoAvw/SqKRUREkqyspGAA7v5RFcUiIiJJVlZSaGZmt5S2090fjCAeERFJorKSQm3gOGItBhERqfnKSgqfu/s9VRaJiIgkXVm3pKqFICJylCkrKfStsihEROSIUGpScPcdVRmIiIgk36HMkioiIjWUkoKIiISUFEREJKSkICIiISUFEREJKSmIiEhISUFEREJKCiIiEoo0KZhZtpmtM7MNZja2hP23mFmuma0xs/lm1jLKeEREpGyRJQUzqw1MAr4HpAEjzCytWLWVQJa7ZwIzgQeiikdERMoXZUuhG7DB3Te6+7fADGBwfAV3X+juX8U2lwApEcYjIiLliDIpNAc+jdvOi5WV5lrgf0raYWajzWy5mS3ftm1bJYYoIiLxokwKJU297SVWNLsMyAImlLTf3ae4e5a7ZzVr1qwSQxQRkXhlLbJzuPKAFnHbKcBnxSuZWT/gTqC3u38TYTwiIlKOKFsKy4C2ZtbKzOoBw4Gc+ApmdgbwR2CQu2+NMBYREUlAZEnB3QuBMcBc4H3geXdfa2b3mNmgWLUJBOtAv2Bmq8wsp5TDiYhIFYiy+wh3nwPMKVY2Lu5xvyjPLyIiFaNvNIuISEhJQUREQkoKIiISUlIQEZGQkoKIiISUFEREJKSkICIiISUFEREJKSmIiEhISUFEREJKCiIiElJSEBGRkJKCiIiElBRERCSkpCAiIiElBRERCSkpiIhISElBRERCSgoiIhJSUhARkZCSgoiIhOokOwCRIgUFBeTl5bF3795khyJSbTVo0ICUlBTq1q17SM9XUpAjRl5eHo0aNSI1NRUzS3Y4ItWOu5Ofn09eXh6tWrU6pGOo+0iOGHv37uWkk05SQhA5RGbGSSeddFitbSUFOaIoIYgcnsP9G1JSECnB+PHjmThxYpl1Xn75ZXJzcyt03A8++ICePXtSv379co9f1dydG2+8kTZt2pCZmck777xTYr3nnnuOzMxM0tPTuf3228Pyjz/+mL59+5KZmUmfPn3Iy8sL933yySecd955dOjQgbS0NDZv3gzA/Pnz6dKlC507d+a73/0uGzZsCJ/z/PPPk5aWRnp6Oj/4wQ/C8ieffJK2bdvStm1bnnzyyYPiGzRoEB07dgy3V69eTc+ePcnIyODCCy9k165d4b41a9bQs2dP0tPTycjICD9hT58+nYyMDDIzM8nOzmb79u3hcx555BHat29/0PXfd999tGnThvbt2zN37twDYtq3bx9nnHEGF1xwQVi2YMECunTpQseOHbnyyispLCwM9y1atIjOnTuTnp5O7969w/Lf/e53dOzYkfT0dB566KGSfj2Hz92r1c+ZZ57ph2Loo//woY/+45CeK1UjNzc32SGE7r77bp8wYUKZda688kp/4YUXKnTcf/7zn/7222/7HXfcUe7xq9qrr77q2dnZvn//fn/rrbe8W7duB9XZvn27t2jRwrdu3eru7ldccYW//vrr7u5+ySWX+LRp09zdff78+X7ZZZeFz+vdu7fPmzfP3d13797te/bscXf3tm3bhr/3SZMm+ZVXXunu7uvXr/fOnTv7jh073D143dzd8/PzvVWrVp6fn+87duzwVq1ahXXc3V988UUfMWKEp6enh2VZWVm+aNEid3d/4okn/K677nJ394KCAs/IyPBVq1aF11ZYWOgFBQXerFkz37Ztm7u733bbbX733Xe7u/uCBQu8b9++vnfv3gPiWrt2rWdmZvrevXt948aN3rp1ay8sLAxj+M1vfuMjRozw888/393d9+3b5ykpKb5u3Tp3d//FL37hjz/+uLu779y50zt06OAff/zxAed49913PT093ffs2eMFBQXet29fX79+fYm/y5L+loDlnsB7rFoKIjG/+tWvaN++Pf369WPdunVh+WOPPUbXrl3p1KkTF198MV999RX/+Mc/yMnJ4bbbbqNz58589NFHJdYr7uSTT6Zr164VujPknnvuoWvXrnTs2JHRo0cT/H1Dnz59WL58OQDbt28nNTUVCD6V3nrrreEn3UceeSSh88yePZsrrrgCM6NHjx588cUXfP755wfU2bhxI+3ataNZs2YA9OvXjxdffBGA3Nxc+vbtC8A555zD7Nmzw/LCwkL69+8PwHHHHUfDhg2BoKuj6JP7l19+yamnngoEr/mPf/xjmjRpEr5uAHPnzqV///6ceOKJNGnShP79+/PXv/4VgH/96188+OCD3HXXXQfEvG7dOnr16gVA//79w3jnzZtHZmYmnTp1AuCkk06idu3a4Zvjnj17cHd27doVxjV58mTGjh1L/fr1D4hr9uzZDB8+nPr169OqVSvatGnD22+/DQQ3ULz66quMHDkyjCk/P5/69evTrl27g+J69tlnGTJkCKeddtoB53j//ffp0aMHDRs2pE6dOvTu3ZtZs2Yl8JutGN19JEek//7LWnI/21V+xQpIO7Uxd1+YXuK+FStWMGPGDFauXElhYSFdunThzDPPBGDIkCGMGjUKgLvuuosnnniCG264gUGDBnHBBRdwySWXAHDCCSeUWO9wjRkzhnHjxgFw+eWX88orr3DhhReWWn/KlCls2rSJlStXUqdOHXbs2AHAzTffzMKFCw+qP3z4cMaOHcuWLVto0aJFWJ6SksKWLVs45ZRTwrI2bdrwwQcfsHnzZlJSUnj55Zf59ttvAejUqRMvvvgiN910E7NmzWL37t3k5+ezfv16TjjhBIYMGcKmTZvo168f999/P7Vr1+bxxx9n4MCBHHPMMTRu3JglS5YAsH79egDOOuss9u3bx/jx48nOzi41RoBf/OIX/PSnPw0TTpGOHTuSk5PD4MGDeeGFF/j000/Dc5gZAwYMYNu2bQwfPpzbb7+dunXrMnnyZDIyMjj22GNp27YtkyZNCp+zePFi7rzzTho0aMDEiRPp2rUrW7ZsoUePHiXG9ZOf/IQHHniA3bt3h/ubNm1KQUEBy5cvJysri5kzZx4QV0FBAX369GH37t3cdNNNXHHFFXTs2JE777yT/Px8jjnmGObMmUNWVlap/w8OlVoKIsDixYu56KKLaNiwIY0bN2bQoEHhvvfee4+zzz6bjIwMnnnmGdauXVviMRKtV1ELFy6ke/fuZGRksGDBgnKP+/rrr3PddddRp07wme/EE08E4Le//S2rVq066Gfs2LEAYQskXvFByyZNmjB58mSGDRvG2WefTWpqanieiRMn8sYbb3DGGWfwxhtv0Lx5c+rUqUNhYSGLFy9m4sSJLFu2jI0bNzJt2rQwpjlz5pCXl8fVV1/NLbfcAkBhYSEffvghixYtYvr06YwcOZIvvvii1BhXrVrFhg0buOiiiw7aP3XqVCZNmsSZZ57J7t27qVevXniON998k2eeeYY333yTWbNmMX/+fAoKCpg8eTIrV67ks88+IzMzk/vuuy98zs6dO1myZAkTJkxg6NChYcuipLheeeUVTj755PADRvy+GTNmcPPNN9OtWzcaNWoUvo6FhYWsWLGCV199lblz53Lvvfeyfv16OnTowM9+9jP69+9PdnY2nTp1Cp9TmSJtKZhZNvA7oDbwuLvfX2x/feAp4EwgHxjm7pujjEmqh9I+0UeptLs2rrrqKl5++WU6derEtGnTWLRo0WHVq4i9e/fyox/9iOXLl9OiRQvGjx8fDobWqVOH/fv3h/WKuHuJ11JeSyElJSX8tApBt0dRt0m8Cy+8MGypTJkyhdq1awNw6qmn8tJLLwFBV86LL77I8ccfT0pKCmeccQatW7cG4Pvf/z5Llixh0KBBrF69mu7duwMwbNgwsrOzgeCTdo8ePahbty6tWrWiffv2fPjhh6SkpBzwuubl5dGnTx/eeustVqxYQWpqKoWFhWzdupU+ffqwaNEivvOd7zBv3jwg+BT+6quvhufo3bs3TZs2BWDgwIG88847NG7cGIDTTz8dgKFDh3L//feHzxkyZAhmRrdu3ahVqxbbt28v9bXLyckhJyeHOXPmsHfvXnbt2sVll13Gn//8Z3r27MnixYuBoCurqHWUkpJC06ZNOfbYYzn22GPp1asXq1evpl27dlx77bVce+21ANxxxx2kpKQc9Ps5XJG1FMysNjAJ+B6QBowws7Ri1a4Fdrp7G+C3wK+jikekLL169WLWrFl8/fXX7N69m7/85S/hvt27d3PKKadQUFDAM888E5Y3atTogC6B0uolqm/fvmGXQ5GiN/umTZvyr3/9i5kzZ4b7UlNTWbFiBcAB5eeddx6PPvpoeDdLUfdReS2FQYMG8dRTT+HuLFmyhOOPP/6ArqMiW7duBWDnzp384Q9/CPvKt2/fHiap++67j2uuuQaArl27snPnTrZt2wYEd92kpaXRpEkTvvzyy/DN8LXXXqNDhw5AkDiKEtj27dtZv349rVu3ZsCAAcybN4+dO3eyc+dO5s2bx4ABA7j++uv57LPP2Lx5M2+++Sbt2rULk0dRvPv37+eXv/wl1113HQADBgxgzZo1fPXVVxQWFvLGG2+QlpZG8+bNyc3NDeMtHteCBQuAIMF8++23NG3alEGDBjFjxgy++eYbNm3axIcffki3bt247777yMvLY/PmzcyYMYNzzz2XP//5zwfE9c033/DrX/86jGvw4MEsXryYwsJCvvrqK5YuXRqev+g5n3zyCS+99BIjRow46PdzuKJsKXQDNrj7RgAzmwEMBuLv4RsMjI89ngn83szMS2qLiUSoS5cuDBs2jM6dO9OyZUvOPvvscN+9995L9+7dadmyJRkZGWEiGD58OKNGjeLhhx9m5syZpdaL97//+79kZWWxa9cuatWqxUMPPURubi7HHXccGzZsCLt6ihSNU2RkZJCamkrXrl3DfbfeeitDhw7l6aef5txzzw3LR44cyfr168nMzKRu3bqMGjWKMWPGlPsaDBw4kDlz5tCmTRsaNmzIn/70p3Bf586dWbVqFQA33XQTq1evBmDcuHHhYOmiRYv4+c9/jpnRq1evsB++du3aTJw4kb59+xbdQcioUaOoU6cOjz32GBdffDG1atWiSZMmTJ06FSB8809LS6N27dpMmDCBk046CQjGDopeh3Hjxh30mhU3ffr0MJYhQ4Zw9dVXA0FX2C233ELXrl0xMwYOHMj5558PwN13302vXr2oW7cuLVu2DLu7rrnmGq655ho6duxIvXr1ePLJJzEz0tPTGTp0KGlpadSpU4dJkyaFLajSTJgwgVdeeYX9+/dz/fXXh7/DDh06kJ2dTWZmJrVq1WLkyJHhLbYXX3wx+fn51K1bl0mTJoUD8ZXJonr/NbNLgGx3Hxnbvhzo7u5j4uq8F6uTF9v+KFZne0nHBMjKyvKiOy4qYtgf3wLguR/2rPBzpWq8//774Seio817773H1KlTefDBB5MditQAJf0tmdkKdy93ZDrKlkJJHbTFM1AidTCz0cBoILxNq6LSTm18SM8TqQodO3ZUQpAjQpRJIQ9oEbedAnxWSp08M6sDHA/sKH4gd58CTIGgpXAowSRj4FJEpLqJ8pbUZUBbM2tlZvWA4UBOsTo5wJWxx5cACzSeICKSPJG1FNy90MzGAHMJbkmd6u5rzewegq9b5wBPAE+b2QaCFsLwqOKR6qG02ylFJDGH+7k60u8puPscYE6xsnFxj/cC/xVlDFJ9NGjQgPz8fE2fLXKIPLaeQoMGDQ75GJrmQo4YKSkp5OXlhfeHi0jFFa28dqiUFOSIUfTtVRFJHs19JCIiISUFEREJKSmIiEgosmkuomJm24CPD/HpTYFSp9CooXTNRwdd89HhcK65pbs3K69StUsKh8PMlicy90dNoms+Ouiajw5Vcc3qPhIRkZCSgoiIhI62pDAl2QEkga756KBrPjpEfs1H1ZiCiIiU7WhrKYiISBlqZFIws2wzW2dmG8xsbAn765vZc7H9S80steqjrFwJXPMtZpZrZmvMbL6ZtUxGnJWpvGuOq3eJmbmZVfs7VRK5ZjMbGvtdrzWzZ6s6xsqWwP/t08xsoZmtjP3/HpiMOCuLmU01s62xlSlL2m9m9nDs9VhjZl0qNQB3r1E/BNN0fwS0BuoBq4G0YnV+BDwaezwceC7ZcVfBNZ8DNIw9vv5ouOZYvUbA34AlQFay466C33NbYCXQJLZ9crLjroJrngJcH3ucBmxOdtyHec29gC7Ae6XsHwj8D8HKlT2ApZV5/prYUugGbHD3je7+LTADGFyszmDgydjjmUBfq95zNZd7ze6+0N2/im0uIVgJrzpL5PcMcC/wALC3KoOLSCLXPAqY5O47Adx9axXHWNkSuWYHitbbPZ6DV3isVtz9b5SwAmWcwcBTHlgCnGBmp1TW+WtiUmgOfBq3nRcrK7GOuxcCXwInVUl00UjkmuNdS/BJozor95rN7Ayghbu/UpWBRSiR33M7oJ2Z/d3MlphZdpVFF41Ernk8cJmZ5RGs33JD1YSWNBX9e6+Qmjh1dkmf+IvfYpVIneok4esxs8uALKB3pBFFr8xrNrNawG+Bq6oqoCqQyO+5DkEXUh+C1uBiM+vo7l9EHFtUErnmEcA0d/+NmfW5VUuzAAAFTUlEQVQkWM2xo7vvjz68pIj0/asmthTygBZx2ykc3JwM65hZHYImZ1nNtSNdIteMmfUD7gQGufs3VRRbVMq75kZAR2CRmW0m6HvNqeaDzYn+357t7gXuvglYR5AkqqtErvla4HkAd38LaEAwR1BNldDf+6GqiUlhGdDWzFqZWT2CgeScYnVygCtjjy8BFnhsBKeaKveaY10pfyRICNW9nxnKuWZ3/9Ldm7p7qrunEoyjDHL35ckJt1Ik8n/7ZYKbCjCzpgTdSRurNMrKlcg1fwL0BTCzDgRJoSYv35cDXBG7C6kH8KW7f15ZB69x3UfuXmhmY4C5BHcuTHX3tWZ2D7Dc3XOAJwiamBsIWgjDkxfx4UvwmicAxwEvxMbUP3H3QUkL+jAleM01SoLXPBc4z8xygX3Abe6en7yoD0+C1/xT4DEzu5mgG+Wq6vwhz8ymE3T/NY2Nk9wN1AVw90cJxk0GAhuAr4CrK/X81fi1ExGRSlYTu49EROQQKSmIiEhISUFEREJKCiIiElJSEBGRkJKCHHHMbJ+ZrYr7SS2jbmpps0lW8JyLYjNxro5NEdH+EI5xnZldEXt8lZmdGrfvcTNLq+Q4l5lZ5wSe8xMza3i455ajg5KCHIm+dvfOcT+bq+i8l7p7J4LJEidU9Mnu/qi7PxXbvAo4NW7fSHfPrZQo/x3nH0gszp8ASgqSECUFqRZiLYLFZvZO7Oc/S6iTbmZvx1oXa8ysbaz8srjyP5pZ7XJO9zegTey5fWPz9L8bm+e+fqz8fvv3+hQTY2XjzexWM7uEYH6pZ2LnPCb2CT/LzK43swfiYr7KzB45xDjfIm4iNDObbGbLLVhH4b9jZTcSJKeFZrYwVnaemb0Vex1fMLPjyjmPHEWUFORIdExc19GsWNlWoL+7dwGGAQ+X8LzrgN+5e2eCN+W82LQHw4CzYuX7gEvLOf+FwLtm1gCYBgxz9wyCGQCuN7MTgYuAdHfPBH4Z/2R3nwksJ/hE39ndv47bPRMYErc9DHjuEOPMJpjWosid7p4FZAK9zSzT3R8mmBfnHHc/Jzb1xV1Av9hruRy4pZzzyFGkxk1zITXC17E3xnh1gd/H+tD3EczpU9xbwJ1mlgK85O4fmllf4ExgWWx6j2MIEkxJnjGzr4HNBNMvtwc2ufv62P4ngR8DvydYn+FxM3sVSHhqbnffZmYbY3PWfBg7x99jx61InMcSTPsQv+rWUDMbTfB3fQrBgjNrij23R6z877Hz1CN43UQAJQWpPm4G/gl0ImjhHrRojrs/a2ZLgfOBuWY2kmCa4Sfd/ecJnOPS+AnzzKzENTZi8/F0I5iEbTgwBji3AtfyHDAU+ACY5e5uwTt0wnESrEB2PzAJGGJmrYBbga7uvtPMphFMDFecAa+5+4gKxCtHEXUfSXVxPPB5bI78ywk+JR/AzFoDG2NdJjkE3SjzgUvM7ORYnRMt8fWpPwBSzaxNbPty4I1YH/zx7j6HYBC3pDuAdhNM312Sl4DvE6wD8FysrEJxunsBQTdQj1jXU2NgD/Clmf0/4HulxLIEOKvomsysoZmV1OqSo5SSglQXfwCuNLMlBF1He0qoMwx4z8xWAd8hWLIwl+DNc56ZrQFeI+haKZe77yWYgfIFM3sX2A88SvAG+0rseG8QtGKKmwY8WjTQXOy4O4FcoKW7vx0rq3CcsbGK3wC3uvtqgrWZ1wJTCbqkikwB/sfMFrr7NoI7o6bHzrOE4LUSATRLqoiIxFFLQUREQkoKIiISUlIQEZGQkoKIiISUFEREJKSkICIiISUFEREJKSmIiEjo/wCTpi9wQ6alCwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "pred = clf.predict_proba(predict_X)[::,1]\n",
    "fpr, tpr, _ = metrics.roc_curve(y_true, pred)\n",
    "auc = metrics.roc_auc_score(y_true, pred)\n",
    "plt.plot(fpr,tpr,label=\"data 1, auc=\"+str(auc))\n",
    "plt.legend(loc=4)\n",
    "plt.ylabel('True Positive Rate')\n",
    "plt.xlabel('False Positive Rate')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[190   8]\n",
      " [  4 218]]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 288x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_pred = clf.predict(predict_X)\n",
    "\n",
    "# confusion metrics\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from matplotlib.colors import ListedColormap\n",
    "cmap = ListedColormap(['g', 'w'])\n",
    "\n",
    "cm = confusion_matrix(y_true, y_pred)\n",
    "\n",
    "plt.matshow(cm, cmap=cmap)\n",
    "for i in range(len(cm)):\n",
    "    for j in range(len(cm[0])):\n",
    "        c = cm[j,i]\n",
    "        plt.text(i, j, str(c), va='center', ha='center')\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 354,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,10):\n",
    "    clf = MLPClassifier(solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(i,), random_state=1)\n",
    "    clf.fit(X, y)\n",
    "    result = clf.predict(predict_X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 hidden layer: 15 2 hidden layer: 6 and max accuracy score:  0.8954282263372098\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn import preprocessing\n",
    "# stopper_data = pd.read_csv('./final_data/Step_Overall.csv', header=None)\n",
    "# wall_data = pd.read_csv('./final_data/Wall_Overall.csv', header=None)\n",
    "stopper_data = pd.read_csv('./final_data/Stopper_overall_80to270.csv', header=None)\n",
    "wall_data = pd.read_csv('./final_data/Wall_Collection_overall_80to270.csv', header=None)\n",
    "\n",
    "#get fft\n",
    "stopper_fft = fft_from_data_frame(stopper_data, fs=1e6)\n",
    "wall_fft = fft_from_data_frame(wall_data, fs=1e6)\n",
    "\n",
    "X = stopper_fft + wall_fft\n",
    "X = preprocessing.normalize(X)\n",
    "y = [0]*len(stopper_fft) + [1]*len(wall_fft)\n",
    "max_average = 0 \n",
    "index = 0\n",
    "index_2 = 0\n",
    "\n",
    "for j in range(1, 10):\n",
    "    for i in range(1,50):\n",
    "        clf = MLPClassifier(solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(i,j,), random_state=1)\n",
    "        scores = cross_val_score(clf, X, y, cv=8, scoring=\"accuracy\")\n",
    "    #     print(\"hidden layer\", i, \"score average\", scores.mean())\n",
    "        if max_average < scores.mean():\n",
    "            max_average = scores.mean()\n",
    "            index = i\n",
    "            index_2 = j\n",
    "print(\"1 hidden layer:\",index, \"2 hidden layer:\", index_2, \"and max accuracy score: \",max_average)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 hidden layer: 15 2 hidden layer: 3 and max accuracy score:  0.9285714285714286\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import KFold\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn import metrics\n",
    "\n",
    "# kf = KFold(n_splits=8)\n",
    "kf = KFold(n_splits=10, shuffle=True)\n",
    "from sklearn import metrics\n",
    "max_average = 0 \n",
    "index = 0\n",
    "index_2 = 0\n",
    "y = np.array(y)\n",
    "for j in range(1, 10):\n",
    "    for i in range(1,50):\n",
    "        clf = MLPClassifier(solver='lbfgs', alpha=1e-5,hidden_layer_sizes=(i,j,), random_state=1)\n",
    "        score = np.array([])\n",
    "        for train_index, test_index in kf.split(X):\n",
    "            X_train, X_test = X[train_index], X[test_index]\n",
    "            y_train, y_test = y[train_index], y[test_index]\n",
    "            clf.fit(X_train,y_train)\n",
    "            y_clf_result = clf.predict(X_test)\n",
    "            score = np.append(score, [accuracy_score(y_clf_result, y_test)])\n",
    "        if max_average < np.average(score):\n",
    "            max_average = np.average(score)\n",
    "            index = i\n",
    "            index_2 = j\n",
    "print(\"1 hidden layer:\",index, \"2 hidden layer:\", index_2, \"and max accuracy score: \",max_average)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.5 0.5 0.5 0.5]\n",
      "[0.18257419 0.36514837 0.54772256 0.73029674]\n"
     ]
    }
   ],
   "source": [
    "\n",
    "for n in normalized_X:\n",
    "    print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "104\n",
      "(104, 4096)\n"
     ]
    }
   ],
   "source": [
    "from sklearn import preprocessing\n",
    "a = preprocessing.normalize(stopper_fft)\n",
    "print(a.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,2]"
   ]
  }
 ],
 "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.7.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}