10b Segment then Attention Errors.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Look at accelerometer data \n",
    "\n",
    "Finding Zero velocity times by rail axis acceleration noise levels, making summary statistics for the noise levels across the whole day files.  Spot check graphs to see what works"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Standard Header used on the projects\n",
    "\n",
    "#first the major packages used for math and graphing\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cycler import cycler\n",
    "import scipy.special as sp\n",
    "\n",
    "#Custome graph format style sheet\n",
    "#plt.style.use('Prospectus.mplstyle')\n",
    "\n",
    "#If being run by a seperate file, use the seperate file's graph format and saving paramaeters\n",
    "#otherwise set what is needed\n",
    "if not 'Saving' in locals():\n",
    "    Saving = False\n",
    "if not 'Titles' in locals():\n",
    "    Titles = True\n",
    "if not 'Ledgends' in locals():\n",
    "    Ledgends = True\n",
    "if not 'FFormat' in locals():\n",
    "    FFormat = '.png'\n",
    "\n",
    "#Standard cycle to make black and white images and dashed and line styles\n",
    "default_cycler = (cycler('color', ['0.00', '0.40', '0.60', '0.70']) + cycler(linestyle=['-', '-', '-', '-']))\n",
    "plt.rc('axes', prop_cycle=default_cycler)\n",
    "my_cmap = plt.get_cmap('gray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Extra Headers:\n",
    "import os as os\n",
    "import pywt as py\n",
    "import statistics as st\n",
    "import os as os\n",
    "import random\n",
    "import multiprocessing\n",
    "from joblib import Parallel, delayed\n",
    "import platform\n",
    "\n",
    "from time import time as ti"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import CoreFunctions as cf\n",
    "from skimage.restoration import denoise_wavelet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Choosing Platform\n",
    "Working is beinging conducted on several computers, and author needs to be able to run code on all without rewriting..  This segment of determines which computer is being used, and sets the directories accordingly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "HostName = platform.node()\n",
    "\n",
    "if HostName == \"Server\":\n",
    "    Computer = \"Desktop\"   \n",
    "elif HostName[-6:] == 'wm.edu':\n",
    "    Computer = \"SciClone\"\n",
    "elif HostName == \"SchoolLaptop\":\n",
    "    Computer = \"LinLap\"\n",
    "elif HostName == \"WTC-TAB-512\":\n",
    "    Computer = \"PortLap\"\n",
    "else:\n",
    "    Computer = \"WinLap\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "if Computer == \"SciClone\":\n",
    "    location = '/sciclone/home20/dchendrickson01/image/'\n",
    "elif Computer == \"WinLap\":\n",
    "    location = 'C:\\\\Data\\\\'\n",
    "elif Computer == \"Desktop\":\n",
    "    location = \"E:\\\\Backups\\\\Dan\\\\CraneData\\\\\"\n",
    "elif Computer == \"LinLap\":\n",
    "    location = '/home/dan/Output/'\n",
    "elif Computer == 'PortLap':\n",
    "    location = 'C:\\\\users\\\\dhendrickson\\\\Desktop\\\\AccelData\\\\'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "if Computer ==  \"SciClone\":\n",
    "    rootfolder = '/sciclone/home20/dchendrickson01/'\n",
    "    folder = '/sciclone/scr10/dchendrickson01/Recordings2/'\n",
    "    imageFolder = '/sciclone/scr10/dchendrickson01/Move3Dprint/'\n",
    "elif Computer == \"Desktop\":\n",
    "    rootfolder = location\n",
    "    folder = rootfolder + \"Recordings2\\\\\"\n",
    "elif Computer ==\"WinLap\":\n",
    "    rootfolder = location\n",
    "    folder = rootfolder + \"Recordings2\\\\\"   \n",
    "elif Computer == \"LinLap\":\n",
    "    rootfolder = '/home/dan/Data/'\n",
    "    folder = rootfolder + 'Recordings2/'\n",
    "elif Computer =='PortLap':\n",
    "    rootfolder = location \n",
    "    folder = rootfolder + 'Recordings2\\\\'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Global Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "Saving = False\n",
    "location = folder\n",
    "Titles = True\n",
    "Ledgends = True\n",
    "\n",
    "f = 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "files = ['230418 recording1.csv','230419 recording1.csv','230420 recording1.csv','230421 recording1.csv',\n",
    "         '230418 recording2.csv','230419 recording2.csv','230420 recording2.csv','230421 recording2.csv']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "BeforeTamping = ['221206 recording1.csv','221207 recording1.csv','221208 recording1.csv','221209 recording1.csv',\n",
    "         '221206 recording2.csv','221207 recording2.csv','221208 recording2.csv','221209 recording2.csv']\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Project Specific Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def RollingStdDev(RawData, SmoothData, RollSize = 25):\n",
    "    StdDevs = []\n",
    "    for i in range(RollSize):\n",
    "        Diffs = RawData[0:i+1]-SmoothData[0:i+1]\n",
    "        Sqs = Diffs * Diffs\n",
    "        Var = sum(Sqs) / (i+1)\n",
    "        StdDev = np.sqrt(Var)\n",
    "        StdDevs.append(StdDev)\n",
    "    for i in range(len(RawData)-RollSize-1):\n",
    "        j = i + RollSize\n",
    "        Diffs = RawData[i:j]-SmoothData[i:j]\n",
    "        Sqs = Diffs * Diffs\n",
    "        Var = sum(Sqs) / RollSize\n",
    "        StdDev = np.sqrt(Var)\n",
    "        StdDevs.append(StdDev)  \n",
    "    \n",
    "    return StdDevs\n",
    "\n",
    "def RollingSum(Data, Length = 100):\n",
    "    RollSumStdDev = []\n",
    "    for i in range(Length):\n",
    "        RollSumStdDev.append(sum(Data[0:i+1]))\n",
    "    for i in range(len(Data) - Length):\n",
    "        RollSumStdDev.append(sum(Data[i:i+Length]))\n",
    "    return RollSumStdDev\n",
    "\n",
    "def SquelchPattern(DataSet, StallRange = 5000, SquelchLevel = 0.02):\n",
    "    SquelchSignal = np.ones(len(DataSet))\n",
    "\n",
    "    for i in range(len(DataSet)-2*StallRange):\n",
    "        if np.average(DataSet[i:i+StallRange]) < SquelchLevel:\n",
    "            SquelchSignal[i+StallRange]=0\n",
    "\n",
    "    return SquelchSignal\n",
    "\n",
    "def getVelocity(Acceleration, Timestamps = 0.003, Squelch = [], corrected = 0):\n",
    "    velocity = np.zeros(len(Acceleration))\n",
    "    \n",
    "    Acceleration -= np.average(Acceleration)\n",
    "    \n",
    "    if len(Timestamps) == 1:\n",
    "        dTime = np.ones(len(Acceleration),dtype=float) * Timestamps\n",
    "    elif len(Timestamps) == len(Acceleration):\n",
    "        dTime = np.zeros(len(Timestamps), dtype=float)\n",
    "        dTime[0]=1\n",
    "        for i in range(len(Timestamps)-1):\n",
    "            j = i+1\n",
    "            if Timestamps[j] > Timestamps[i]:\n",
    "                dTime[j]=Timestamps[j]-Timestamps[i]\n",
    "            else:\n",
    "                dTime[j]=Timestamps[j]-Timestamps[i]+10000.0\n",
    "        dTime /= 10000.0\n",
    "\n",
    "    velocity[0] = Acceleration[0] * (dTime[0])\n",
    "\n",
    "    for i in range(len(Acceleration)-1):\n",
    "        j = i + 1\n",
    "        if corrected ==2:\n",
    "            if Squelch[j]==0:\n",
    "                velocity[j]=0\n",
    "            else:\n",
    "                velocity[j] = velocity[i] + Acceleration[j] * dTime[j]                \n",
    "        else:\n",
    "            velocity[j] = velocity[i] + Acceleration[j] * dTime[j]\n",
    "\n",
    "    if corrected == 1:\n",
    "        PointVairance = velocity[-1:] / len(velocity)\n",
    "        for i in range(len(velocity)):\n",
    "            velocity[i] -=  PointVairance * i\n",
    "    \n",
    "    velocity *= 9.81\n",
    "\n",
    "    return velocity\n",
    "\n",
    "def MakeDTs(Seconds, Miliseconds):\n",
    "    dts = np.zeros(len(Miliseconds), dtype=float)\n",
    "    dts[0]=1\n",
    "    for i in range(len(MiliSeconds)-1):\n",
    "        j = i+1\n",
    "        if Seconds[j]==Seconds[i]:\n",
    "            dts[j]=Miliseconds[j]-Miliseconds[i]\n",
    "        else:\n",
    "            dts[j]=Miliseconds[j]-Miliseconds[i]+1000\n",
    "    dts /= 10000\n",
    "    return dts\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Smooth = cf.Smoothing(ODataSet[:,3],2) #,50)\n",
    "def DeviationVelocity(file):\n",
    "    if file[-3:] =='csv':\n",
    "        ODataSet = np.genfromtxt(open(folder+file,'r'), delimiter=',',skip_header=0,missing_values=0,invalid_raise=False)\n",
    "        SmoothX = denoise_wavelet(ODataSet[:,3], method='VisuShrink', mode='soft', wavelet_levels=3, wavelet='sym2', rescale_sigma='True')\n",
    "        SmoothY = denoise_wavelet(ODataSet[:,4], method='VisuShrink', mode='soft', wavelet_levels=3, wavelet='sym2', rescale_sigma='True')\n",
    "        SmoothZ = denoise_wavelet(ODataSet[:,5], method='VisuShrink', mode='soft', wavelet_levels=3, wavelet='sym2', rescale_sigma='True')\n",
    "        SmoothX -= np.average(SmoothX)\n",
    "        SmoothY -= np.average(SmoothY)\n",
    "        SmoothZ -= np.average(SmoothZ)\n",
    "        StdDevsX = RollingStdDev(ODataSet[:,3],SmoothX)\n",
    "        StdDevsX.append(0)\n",
    "        StdDevsX = np.asarray(StdDevsX)\n",
    "        SmoothDevX = denoise_wavelet(StdDevsX, method='VisuShrink', mode='soft', wavelet_levels=3, wavelet='sym2', rescale_sigma='True')\n",
    "        SquelchSignal = SquelchPattern(SmoothDevX, 2000, 0.03)\n",
    "        #Velocity = getVelocity(ODataSet[:,3], ODataSet[:,2],SquelchSignal, 2)\n",
    "        #Velocity = np.asarray(Velocity)\n",
    "        MoveMatrix = np.matrix([SmoothX, SmoothY, SmoothZ])\n",
    "        return [SquelchSignal,MoveMatrix,file[:-4],SmoothDevX]\n",
    "    else:\n",
    "        pass\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def SepreateMovements(SquelchSignal, RawData, FileName):\n",
    "    Moves= []\n",
    "    MoveNames = []\n",
    "    Move = np.zeros((1,3), dtype=float)\n",
    "    i = 0\n",
    "    for j in range(len(SquelchSignal)-1):\n",
    "        if SquelchSignal[j] == 1:\n",
    "            #try:\n",
    "            Move = np.concatenate((Move, RawData[j,:]), axis=0)\n",
    "            #except:\n",
    "            #    print(j)\n",
    "            if SquelchSignal[j+1] == 0:\n",
    "                #Move = np.matrix(Move)\n",
    "                Moves.append(Move)\n",
    "                MoveNames.append(FileName + str(i).zfill(3))\n",
    "                i+=1\n",
    "                Move = np.zeros((1,3), dtype=float)\n",
    "                #Move[0,2]=0\n",
    "    Moves.append(Move)\n",
    "    MoveNames.append(FileName + str(i).zfill(3))\n",
    "    return Moves, MoveNames\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def splitLong(Moves, maxLength = 4000, minLength = 1000, MoveNames = []):\n",
    "    if len(MoveNames) <=1:\n",
    "        MoveNames = ['null'  for x in range(len(Moves))]\n",
    "    Xmoves = []\n",
    "    Xnames = []\n",
    "    for i in range(len(Moves)):\n",
    "        if np.shape(move)[0] > maxLength: \n",
    "            Xmoves.append(Moves[i][:int(len(Moves[i])/2),:])\n",
    "            Xnames.append(MoveNames[i] + 'a')\n",
    "            Xmoves.append(Moves[i][int(len(Moves[i])/2):,:])\n",
    "            Xnames.append(MoveNames[i] + 'b')\n",
    "        else:\n",
    "            if np.shape(Moves[i])[0] < minLength:\n",
    "                pass\n",
    "            else:\n",
    "                Xmoves.append(Moves[i])\n",
    "                Xnames.append(MoveNames[i])\n",
    "    return Xmoves, Xnames\n",
    "\n",
    "def findMaxLength(Moves):\n",
    "    maxLength = 0\n",
    "    LongMove = 0\n",
    "    for i in range(len(Moves)):\n",
    "        if np.shape(Moves[i])[0] > maxLength: \n",
    "            maxLength =  np.shape(Moves[i])[0]\n",
    "            LongMove = i\n",
    "    return maxLength, LongMove\n",
    "\n",
    "def findMinLength(Moves):\n",
    "    minLength = 9999999\n",
    "    SmallMove = 0\n",
    "    for i in range(len(Moves)):\n",
    "        if np.shape(Moves[i])[0] < minLength: \n",
    "            minLength =  np.shape(Moves[i])[0]\n",
    "            SmallMove = i\n",
    "    return minLength, SmallMove\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Process Files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "LoopFiles = 3\n",
    "loops = int(len(files) / LoopFiles) \n",
    "if len(files)%LoopFiles != 0:\n",
    "    loops += 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "SquelchSignal = []\n",
    "RawData=[]\n",
    "OrderedFileNames=[]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 (3, 4) 7.3383948802948\n",
      "1 (3, 4) 13.23307262659073\n",
      "2 (2, 4) 17.67134563525518\n"
     ]
    }
   ],
   "source": [
    "\n",
    "st = ti()\n",
    "\n",
    "for k in range(loops):\n",
    "    if k == loops -1:\n",
    "        tfiles = files[k*LoopFiles:]\n",
    "    else:\n",
    "        tfiles = files[k*LoopFiles:(k+1)*LoopFiles]\n",
    "    Results = Parallel(n_jobs=LoopFiles)(delayed(DeviationVelocity)(file) for file in tfiles)\n",
    "    #Results =[]\n",
    "    #for file in tfiles:\n",
    "    #    Results.append(DeviationVelocity(file))\n",
    "    #    print(file, (ti()-st)/60.0)\n",
    "        \n",
    "    for i in range(len(Results)):       \n",
    "        SquelchSignal.append(Results[i][0])\n",
    "        RawData.append(Results[i][1])\n",
    "        OrderedFileNames.append(Results[i][2])\n",
    "    print(k, np.shape(Results), (ti()-st)/60.0)\n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0,)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(SquelchSignal[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "#MoveData = Parallel(n_jobs=13)(delayed(SepreateMovements)(SquelchSignal[i], RawData[i].T, OrderedFileNames[i]) for i in range(len(OrderedFileNames)))\n",
    "\n",
    "MoveData = []\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "for i in range(len(RawData)):\n",
    "    MoveData.append(SepreateMovements(SquelchSignal[i], RawData[i].T, OrderedFileNames[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "Movements = []\n",
    "GroupNames = []\n",
    "for move in MoveData:\n",
    "    Movements.append(move[0])\n",
    "    GroupNames.append(move[1])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "Moves=[]\n",
    "for Groups in Movements:\n",
    "    for Move in Groups:\n",
    "        Moves.append(np.asarray(Move).astype('float32'))\n",
    "#Moves = np.asarray(Moves)\n",
    "\n",
    "MoveNames = []\n",
    "for Groups in GroupNames:\n",
    "    for name in Groups:\n",
    "        MoveNames.append(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\ndel SquelchSignal\\ndel RawData\\ndel Movements\\ndel GroupNames\\ndel MoveData\\ndel OrderedFileNames\\n'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''\n",
    "del SquelchSignal\n",
    "del RawData\n",
    "del Movements\n",
    "del GroupNames\n",
    "del MoveData\n",
    "del OrderedFileNames\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "longMove, MoveNumb = findMaxLength(Moves)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "minLength = 750"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "Moves, MoveNames = splitLong(Moves, longMove+1, minLength, MoveNames)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(343,)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.shape(Moves)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#padding moves.  Not needed, need sequences, not moves\n",
    "\n",
    "#Moves2 = []\n",
    "#for move in Moves:\n",
    "#    if np.shape(move)[0] < longMove:\n",
    "#        padding = np.zeros((longMove-np.shape(move)[0], 3))\n",
    "#        tempMove = np.concatenate((move, padding), axis=0)\n",
    "#        Moves2.append(tempMove)\n",
    "#    else:\n",
    "#        Moves2.append(move)\n",
    "#Moves = Moves2\n",
    "\n",
    "#del Moves2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Try LSTM Stuff"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://machinelearningmastery.com/how-to-develop-lstm-models-for-time-series-forecasting/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "TimeSteps = 100\n",
    "Features = np.shape(Moves)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Moves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# split a multivariate sequence into samples\n",
    "def split_sequences(sequences, n_steps):\n",
    "    X, y = list(), list()\n",
    "    for i in range(len(sequences)):\n",
    "        # find the end of this pattern\n",
    "        end_ix = i + n_steps\n",
    "        # check if we are beyond the dataset\n",
    "        if end_ix > len(sequences)-1:\n",
    "            break\n",
    "        # gather input and output parts of the pattern\n",
    "        seq_x, seq_y = sequences[i:end_ix, :], sequences[end_ix, :]\n",
    "        X.append(seq_x)\n",
    "        y.append(seq_y)\n",
    "    return np.array(X), np.array(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Sequences = []\n",
    "Outputs = []\n",
    "for move in Moves:\n",
    "    Seq, Out = split_sequences(move,TimeSteps)\n",
    "    Sequences.append(Seq)\n",
    "    Outputs.append(Out)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "MoveSegments = []\n",
    "for seq in Sequences:\n",
    "    for mv in seq:\n",
    "        MoveSegments.append(mv)\n",
    "NextDataPoint = []\n",
    "for out in Outputs:\n",
    "    for pt in out:\n",
    "        NextDataPoint.append(np.reshape(pt,(1,3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# now the ML bit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import Input\n",
    "from keras.models import load_model, Model\n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.layers import LSTM, Dense, RepeatVector, TimeDistributed, Masking\n",
    "from keras.models import Sequential\n",
    "from attention import Attention\n",
    "import tensorflow as tf\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "BatchSize = 32\n",
    "BatchesPerLoop = 500\n",
    "TestHoldOut = 0.05\n",
    "MinorEpochs = 2\n",
    "MajorEpochs = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq_train, seq_test, out_train, out_test = train_test_split(MoveSegments, NextDataPoint, test_size=TestHoldOut, shuffle=True, random_state=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "model_input = Input(shape=(TimeSteps, Features))\n",
    "x = LSTM(64,return_sequences=True)(model_input)\n",
    "x = Attention(units=32)(x)\n",
    "x = RepeatVector(TimeSteps)(x)\n",
    "\n",
    "x = LSTM(TimeSteps, activation='relu', return_sequences=True)(x)\n",
    "x = Attention(units=32)(x)\n",
    "#x = LSTM(64, activation='relu', return_sequences=True)(x)\n",
    "\n",
    "\n",
    "x = TimeDistributed(Dense(Features))(x)\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_input = Input(shape=(TimeSteps, Features))\n",
    "x = LSTM(32,return_sequences=True, activation = 'relu')(model_input)\n",
    "x = LSTM(6, activation='relu')(x)\n",
    "\n",
    "x =RepeatVector(TimeSteps)(x)\n",
    "\n",
    "x = LSTM(TimeSteps, activation='relu', return_sequences=True)(x)\n",
    "x = LSTM(32, activation='relu', return_sequences=True)(x)\n",
    "\n",
    "x = TimeDistributed(Dense(Features))(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Model(model_input, x)\n",
    "model.compile(loss='mse', optimizer = 'adam')\n",
    "model.summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "InputsPerBatch = BatchSize * BatchesPerLoop \n",
    "LoopsNeeded = int(len(seq_train)/InputsPerBatch)\n",
    "\n",
    "if len(seq_train) % InputsPerBatch != 0:\n",
    "    LoopsNeeded += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for j in range(MajorEpochs):\n",
    "    for i in range(LoopsNeeded):\n",
    "        start = i * InputsPerBatch\n",
    "        data = seq_train[start:start+InputsPerBatch]\n",
    "        model.fit(seq_train[start:start+InputsPerBatch], seq_train[start:start+InputsPerBatch], epochs=MinorEpochs, batch_size=BatchSize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save(\"LSTM_batchedLearning\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_X = model.predict(seq_test)\n",
    "reconstruction = np.squeeze(output_X)\n",
    "scores = np.linalg.norm(seq_test - reconstruction, axis=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "threshold=0.95\n",
    "\n",
    "sorted_scores = sorted(scores)\n",
    "threshold_score = sorted_scores[round(len(scores) * threshold)]\n",
    "\n",
    "plt.title(\"Reconstruction Error\")\n",
    "plt.plot(scores)\n",
    "plt.plot([threshold_score]*len(scores), c='r')\n",
    "plt.show()\n",
    "\n",
    "anomalous = np.where(scores > threshold_score)\n",
    "normal = np.where(scores <= threshold_score)\n",
    "\n",
    "plt.title(\"Anomalies\")\n",
    "plt.scatter(normal, seq_test[normal][:,-1], s=3)\n",
    "plt.scatter(anomalous, seq_test[anomalous][:,-1], s=5, c='r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Simple",
   "language": "python",
   "name": "simple"
  },
  "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": 4
}