Frame processing - draft.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e084cae2",
   "metadata": {},
   "outputs": [],
   "source": [
    "#I want to put  csv file in form of separate 2d numpy arrays\n",
    "#How?.....\n",
    "#The arduino gets a reading of each sensor every 3 seconds.(Confirm with devs)\n",
    "# there are 8 sensors per arduino(i think)\n",
    "# so..8*3 = 24\n",
    "# so every 24 seconds, separate csv\n",
    "#grid (estimated is 6 by 10)\n",
    "#current total: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a7febd00",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "2aa93385",
   "metadata": {},
   "outputs": [],
   "source": [
    "Sensor_data_df = pd.read_csv(\"SensorData_trial.csv\") # load csv file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8ed58d33",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Location</th>\n",
       "      <th>Date</th>\n",
       "      <th>Time</th>\n",
       "      <th>Sensor Type</th>\n",
       "      <th>Reading</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>I2</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:11:15</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>237</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>I2</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:11:35</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>219</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>I2</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:11:56</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>225</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>I2</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:12:17</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>226</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>I2</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:12:37</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>220</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5315</th>\n",
       "      <td>F2</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:37:21</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>27</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5316</th>\n",
       "      <td>F2</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:37:43</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>28</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5317</th>\n",
       "      <td>F2</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:38:04</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>27</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5318</th>\n",
       "      <td>F2</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:38:25</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>28</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5319</th>\n",
       "      <td>F2</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:38:46</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>22</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5320 rows × 6 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     Location                     Date       Time   Sensor Type   Reading   \n",
       "0          I2   10/21/2021 12:00:00 AM   14:11:15   Water Level       237   \n",
       "1          I2   10/21/2021 12:00:00 AM   14:11:35   Water Level       219   \n",
       "2          I2   10/21/2021 12:00:00 AM   14:11:56   Water Level       225   \n",
       "3          I2   10/21/2021 12:00:00 AM   14:12:17   Water Level       226   \n",
       "4          I2   10/21/2021 12:00:00 AM   14:12:37   Water Level       220   \n",
       "...       ...                      ...        ...           ...       ... ..\n",
       "5315       F2   10/21/2021 12:00:00 AM   14:37:21   Water Level        27   \n",
       "5316       F2   10/21/2021 12:00:00 AM   14:37:43   Water Level        28   \n",
       "5317       F2   10/21/2021 12:00:00 AM   14:38:04   Water Level        27   \n",
       "5318       F2   10/21/2021 12:00:00 AM   14:38:25   Water Level        28   \n",
       "5319       F2   10/21/2021 12:00:00 AM   14:38:46   Water Level        22   \n",
       "\n",
       "[5320 rows x 6 columns]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sensor_data_df # print df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1f3ddce1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of sensors:  64\n",
      "Sensor array:  ['I2' 'J2' 'G1' 'H1' 'I1' 'J1' 'G2' 'H2' 'D9' 'A10' 'B10' 'C10' 'D10' 'A9'\n",
      " 'B9' 'C9' 'C1' 'D1' 'A2' 'B2' 'C2' 'D2' 'A1' 'B1' 'F8' 'F9' 'F10' 'E7'\n",
      " 'E8' 'E9' 'E10' 'F7' 'A5' 'B5' 'C5' 'D5' 'A6' 'B6' 'C6' 'D6' 'B3' 'C3'\n",
      " 'D3' 'A4' 'B4' 'C4' 'D4' 'A3' 'C8' 'D8' 'A7' 'B7' 'C7' 'D7' 'A8' 'B8'\n",
      " 'F3' 'F4' 'E1' 'E2' 'E3' 'E4' 'F1' 'F2']\n"
     ]
    }
   ],
   "source": [
    "Sensor_ids = Sensor_data_df.Location.unique() # get unique values in Location(Sensor IDS)\n",
    "print(\"Number of sensors: \",len(Sensor_ids))\n",
    "print(\"Sensor array: \", Sensor_ids)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "ca43fa3d",
   "metadata": {},
   "outputs": [],
   "source": [
    "Start_row = Sensor_data_df.iloc[0]#get first time value in df\n",
    "End_row = Sensor_data_df.iloc[-1] #get last time value in df\n",
    "Start_time = Start_row[2] # Save start time obj\n",
    "End_time = End_row[2] # Save end time obj"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a30a5518",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start time for curr_csv:   14:11:15\n",
      "End time for curr_csv:   14:38:46\n"
     ]
    }
   ],
   "source": [
    "print(\"Start time for curr_csv: \", Start_time)\n",
    "print(\"End time for curr_csv: \", End_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d1af4564",
   "metadata": {},
   "outputs": [],
   "source": [
    "#convert string to date-time and subtract end -start to get estimate of how many \"frames\" there should be\n",
    "from datetime import datetime, date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "8638051e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#remove space in string first\n",
    "Start_time = Start_time.replace(\" \", \"\")\n",
    "End_time = End_time.replace(\" \", \"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "01cdb01c",
   "metadata": {},
   "outputs": [],
   "source": [
    "time = datetime.strptime(Start_time, '%H:%M:%S').time() #start time converted to date time object\n",
    "time1 = datetime.strptime(End_time, '%H:%M:%S').time()  #end time converted to date time object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ce9b6847",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total time (hrs:mins:secs) for data to be generated:  0:27:31\n"
     ]
    }
   ],
   "source": [
    "datetime_obj = datetime.combine(date.today(), time1) - datetime.combine(date.today(), time)\n",
    "print(\"Total time (hrs:mins:secs) for data to be generated: \",datetime_obj )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a860c403",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 27 mins worth of data. im therefore expecting x frames from data set\n",
    "# first step though is to see if i can split dataframe using date time\n",
    "\n",
    "#current issue: datetime obj is in the form of timedelta while start and end is in the form of datatime\n",
    "#we need to convert both into timedelta for the next step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b726d173",
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_datetime_to_timedelta(datetime_obj):\n",
    "    return datetime.combine(date.min, datetime_obj) - datetime.min"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "4c565c80",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "if convert_datetime_to_timedelta(datetime.strptime(\"0:27:31\", '%H:%M:%S').time()) == datetime_obj:\n",
    "    print(\"True\")#this funtion just tests if string obtained from df can be equated to a start-end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "16413d3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# step 1, convert each string in Time to a datetime object wih format '%H:%M:%S'\n",
    "# issue: space - remove whitespace first(done)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "4a6ba011",
   "metadata": {},
   "outputs": [],
   "source": [
    "#force update on pandas series\n",
    "Time_data = Sensor_data_df[\" Time\"]# using df.time doest work because theres a white space for some reason\n",
    "for x in range(len(Time_data)): \n",
    "    val_ = Time_data[x].replace(\" \", \"\")#remove white space\n",
    "    val_ = datetime.strptime(val_, '%H:%M:%S').time()#change to date time\n",
    "    Time_data.update({x: val_})# update series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8f3f4240",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.time(14, 11, 15)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#series updated. next step, replace current updateed series with old one \n",
    "Time_data[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "af982ccb",
   "metadata": {},
   "outputs": [],
   "source": [
    "Sensor_data_df[\" Time\"] = Time_data# update dataframe from obj to datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "b943bf30",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Location</th>\n",
       "      <th>Date</th>\n",
       "      <th>Time</th>\n",
       "      <th>Sensor Type</th>\n",
       "      <th>Reading</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>I2</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:11:15</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>237</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1524</th>\n",
       "      <td>C1</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:11:15</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>4</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>766</th>\n",
       "      <td>D9</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:11:15</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>76</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2251</th>\n",
       "      <td>F8</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:11:16</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>23</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3375</th>\n",
       "      <td>B3</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:11:16</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>83</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>95</th>\n",
       "      <td>I2</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:44:43</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>225</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>191</th>\n",
       "      <td>J2</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:44:46</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>0</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>287</th>\n",
       "      <td>G1</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:44:48</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>10</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>383</th>\n",
       "      <td>H1</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:44:51</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>2</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>479</th>\n",
       "      <td>I1</td>\n",
       "      <td>10/21/2021 12:00:00 AM</td>\n",
       "      <td>14:44:54</td>\n",
       "      <td>Water Level</td>\n",
       "      <td>0</td>\n",
       "      <td></td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5320 rows × 6 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     Location                     Date      Time   Sensor Type   Reading   \n",
       "0          I2   10/21/2021 12:00:00 AM  14:11:15   Water Level       237   \n",
       "1524       C1   10/21/2021 12:00:00 AM  14:11:15   Water Level         4   \n",
       "766        D9   10/21/2021 12:00:00 AM  14:11:15   Water Level        76   \n",
       "2251       F8   10/21/2021 12:00:00 AM  14:11:16   Water Level        23   \n",
       "3375       B3   10/21/2021 12:00:00 AM  14:11:16   Water Level        83   \n",
       "...       ...                      ...       ...           ...       ... ..\n",
       "95         I2   10/21/2021 12:00:00 AM  14:44:43   Water Level       225   \n",
       "191        J2   10/21/2021 12:00:00 AM  14:44:46   Water Level         0   \n",
       "287        G1   10/21/2021 12:00:00 AM  14:44:48   Water Level        10   \n",
       "383        H1   10/21/2021 12:00:00 AM  14:44:51   Water Level         2   \n",
       "479        I1   10/21/2021 12:00:00 AM  14:44:54   Water Level         0   \n",
       "\n",
       "[5320 rows x 6 columns]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#sort dataframe first\n",
    "Sensor_data_df = Sensor_data_df.sort_values(by=[\" Time\"])#sort by time. if you sort by any other value things will get weird\n",
    "Sensor_data_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c9e15ead",
   "metadata": {},
   "outputs": [],
   "source": [
    "#split dataframe according to \"frames\"\n",
    "# according to devs(see first cell), split df every 24 secs\n",
    "#we need to loop through others while keeping track of time passed.\n",
    "#if enough time has passed(while appending rows), set new start point and continue process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "1ed6fcff",
   "metadata": {},
   "outputs": [],
   "source": [
    "Start = True #set start point\n",
    "End = False\n",
    "temp_array = []\n",
    "temp = []\n",
    "frame = 0\n",
    "for index, row in Sensor_data_df.iterrows():\n",
    "    if Start == True:\n",
    "        temp_array.append(temp)\n",
    "        temp = []\n",
    "        start_time = row[\" Time\"]#get start time\n",
    "        Start = False#set condition to false\n",
    "    #every 24 seconds, set a new start time, if end - start = 24\n",
    "    if datetime.combine(date.today(), row[\" Time\"]) - datetime.combine(date.today(), start_time) > convert_datetime_to_timedelta(datetime.strptime(\"0:00:24\", '%H:%M:%S').time()):\n",
    "        Start = True\n",
    "        frame+=1\n",
    "    temp.append(row)\n",
    "    #print(\"Time passed: \", datetime.combine(date.today(), row[\" Time\"]) - datetime.combine(date.today(), start_time))\n",
    "    #print(frame)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "bfcc090a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number of frames:  79\n"
     ]
    }
   ],
   "source": [
    "print(\"number of frames: \", len(temp_array))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "99cc99e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "#for i in temp_array:\n",
    "    #print(\"Sensors per frame =\", len(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "5b14218f",
   "metadata": {},
   "outputs": [],
   "source": [
    "item_array = []\n",
    "for item in temp_array[1]:\n",
    "    #print(item[0])\n",
    "    item_array.append(item[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "cfbd341e",
   "metadata": {},
   "outputs": [],
   "source": [
    "unique_items = set(item_array)\n",
    "unique_items = list(unique_items)#convert type set to list - difficult to loop through set type for this scenario\n",
    "unique_items.sort()#sort them\n",
    "#unique_items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "b5537158",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re\n",
    ">>> r = re.compile(\"([a-zA-Z]+)([0-9]+)\")\n",
    ">>> m = r.match(unique_items[1])\n",
    ">>> m.group(1)\n",
    ">>> m.group(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "07e66735",
   "metadata": {},
   "outputs": [],
   "source": [
    "letter = []\n",
    "ints = []\n",
    "r = re.compile(\"([a-zA-Z]+)([0-9]+)\")\n",
    "for value in unique_items:\n",
    "    g = r.match(value)\n",
    "    letter.append(g.group(1))\n",
    "    ints.append(int(g.group(2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "4590c4aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "zipped_lists = zip(letter, ints)\n",
    "sorted_pairs = sorted(zipped_lists)\n",
    "\n",
    "tuples = zip(*sorted_pairs)\n",
    "list1, list2 = [ list(tuple) for tuple in  tuples]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "ca5de173",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(list1)):\n",
    "    list1[i] = list1[i]+str(list2[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "78718e69",
   "metadata": {},
   "outputs": [],
   "source": [
    "unique_items = list1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "7a151075",
   "metadata": {},
   "outputs": [],
   "source": [
    "# I need to arrange all these into a single 2d array accounting for:\n",
    "# duplicate values\n",
    "# create blank 10 by 10 array first\n",
    "empty_array = np.zeros((10, 10), int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "2ed30aa0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "empty_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "8895466c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def convert_to_255_range(empty_array):\n",
    "    return ((empty_array - empty_array.min()) * (1/(empty_array.max() - empty_array.min()) * 255)).astype('uint8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "bef229fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\users\\scowt\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\ipykernel_launcher.py:2: RuntimeWarning: divide by zero encountered in long_scalars\n",
      "  \n",
      "c:\\users\\scowt\\appdata\\local\\programs\\python\\python37\\lib\\site-packages\\ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in multiply\n",
      "  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       "       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], dtype=uint8)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#loop through array filling values where necessary\n",
    "convert_to_255_range(empty_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "3dcff52d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['I2', 'C1', 'D9', 'F8', 'B3', 'A5', 'F3', 'J2', 'A10', 'C8', 'F9', 'D1', 'B5', 'C3', 'D8']\n"
     ]
    }
   ],
   "source": [
    "import collections\n",
    "print([item for item, count in collections.Counter(item_array).items() if count > 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "e02065ab",
   "metadata": {},
   "outputs": [],
   "source": [
    "#next step? arrange received data from each temp array into respective section in 2d array\n",
    "#how? First- i need 2d empty array full of zeros to fill (done)\n",
    "#data (done)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "7ec8baa2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temp_array.pop(0)#careful with this should only be done once"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "9c743495",
   "metadata": {},
   "outputs": [],
   "source": [
    "frame_data = []\n",
    "for frame in range(len(temp_array)):\n",
    "    #frame_data = []\n",
    "    sensor_tracker = 0\n",
    "    empty_array = np.zeros((10, 10), int)\n",
    "    #frame = 70\n",
    "    c = 0\n",
    "    for row in range(len(empty_array[0])):\n",
    "        for col in range(len(empty_array[1])):\n",
    "            #access row col index\n",
    "            #fill necessarily\n",
    "            #row:\n",
    "            #0 = A\n",
    "            #1 = B......\n",
    "            #col:\n",
    "            #0 = 1\n",
    "            #1 = 2....\n",
    "            #eg in this instance, search for all cases of A1 in this frame\n",
    "            #then if there are duplicates, either: average values or pick last\n",
    "            #then store in 2d array\n",
    "            #so...when searching for all cases of A1, get unique list str\n",
    "            #loop/get curr index in unique string\n",
    "            #loop through time frame data either for avg or last\n",
    "            #update 2d array and move on to next\n",
    "            if sensor_tracker < len(unique_items):\n",
    "                #print(\"id: \",sensor_tracker)\n",
    "                sensor_id = unique_items[sensor_tracker]\n",
    "                c +=1\n",
    "            for item in temp_array[frame]:\n",
    "                #if item!=[]:\n",
    "                #print(item[0][0])\n",
    "                #Start_time = Start_time.replace(\" \", \"\")\n",
    "                if item[0].replace(\" \",\"\") == sensor_id.replace(\" \",\"\"):\n",
    "                    #print(item[0])\n",
    "                    #update array\n",
    "                    empty_array[row,col] = int(item[4])\n",
    "                    break\n",
    "            sensor_tracker+=1\n",
    "    frame_data.append(convert_to_255_range(empty_array))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "50cf34b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "78"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(frame_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "ff28a9f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(78, 10, 10)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frame_data_numpy = np.array(frame_data)\n",
    "frame_data_numpy.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "be912332",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(78, 1, 10, 10)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.expand_dims(frame_data_numpy, axis=1)\n",
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "3d6eee04",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "78"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "de9df532",
   "metadata": {},
   "outputs": [],
   "source": [
    "#save numpy data in folder as tensors\n",
    "import torch\n",
    "import os\n",
    "import sklearn.preprocessing as scaler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "92e5a9a3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 10, 10)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y[1].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "37d9391f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.04313725, 0.92957746, 1.        , 0.        ,\n",
       "        0.11842105, 1.        , 0.32      , 0.        , 0.57894737],\n",
       "       [0.06122449, 0.38039216, 0.56338028, 0.20895522, 0.02197802,\n",
       "        0.11842105, 0.        , 0.16      , 0.        , 0.68421053],\n",
       "       [0.02040816, 0.08627451, 0.04225352, 0.19402985, 0.        ,\n",
       "        0.        , 0.04878049, 0.        , 0.06451613, 0.05263158],\n",
       "       [0.89795918, 1.        , 1.        , 0.28358209, 0.        ,\n",
       "        1.        , 0.        , 0.01333333, 1.        , 1.        ],\n",
       "       [0.        , 0.        , 0.        , 0.        , 0.62637363,\n",
       "        0.01315789, 0.        , 1.        , 0.        , 0.        ],\n",
       "       [0.        , 0.        , 0.91549296, 0.19402985, 1.        ,\n",
       "        0.01315789, 0.        , 0.10666667, 0.        , 0.42105263],\n",
       "       [0.08163265, 0.39215686, 0.        , 0.        , 0.        ,\n",
       "        0.        , 0.        , 0.        , 0.        , 0.        ],\n",
       "       [0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "        0.        , 0.        , 0.        , 0.        , 0.        ],\n",
       "       [0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "        0.        , 0.        , 0.        , 0.        , 0.        ],\n",
       "       [0.        , 0.        , 0.        , 0.        , 0.        ,\n",
       "        0.        , 0.        , 0.        , 0.        , 0.        ]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scaler.minmax_scale(y[1].squeeze(),feature_range=(0,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "391882b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs_=[]\n",
    "for data in range(len(y)):\n",
    "    #print(y[data].shape)\n",
    "    norm_ = scaler.minmax_scale(y[data].squeeze(),feature_range=(0,1))\n",
    "    #print(norm_.shape)\n",
    "    t = torch.from_numpy(norm_)\n",
    "    t = t.unsqueeze(dim = 0)\n",
    "    #print(t.size())\n",
    "    #break\n",
    "    str_= os.path.join('frame_tensors/' , str(data) + '.pt')\n",
    "    inputs_.append(str(data)+'.pt')\n",
    "    torch.save(t,str_ )\n",
    "    #print(y[data].shape, type(t),t.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "f403cf4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77, 1, 10, 10)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels = y[1:]\n",
    "labels.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "54fcaf7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(78, 10, 10)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels = np.concatenate((labels.squeeze(), y[-2]))\n",
    "labels.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "1ed98d3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(78, 1, 10, 10)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels = np.expand_dims(labels, axis=1)\n",
    "labels.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "507201d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n",
      "torch.Size([1, 10, 10])\n"
     ]
    }
   ],
   "source": [
    "labels_=[]\n",
    "for data in range(len(labels)):\n",
    "    norm_ = scaler.minmax_scale(labels[data].squeeze(),feature_range=(0,1))\n",
    "    t = torch.from_numpy(norm_)\n",
    "    t = t.unsqueeze(dim = 0)\n",
    "    print(t.size())\n",
    "    str_= os.path.join('frame_output_tensors/' , str(data) + '.pt')\n",
    "    labels_.append(str(data)+'.pt')\n",
    "    torch.save(t,str_ )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fb81650",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "d52ece54",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(78, 1, 10, 10)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "labels.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "d7cf0848",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Inputs</th>\n",
       "      <th>Labels</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.pt</td>\n",
       "      <td>0.pt</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1.pt</td>\n",
       "      <td>1.pt</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2.pt</td>\n",
       "      <td>2.pt</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3.pt</td>\n",
       "      <td>3.pt</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4.pt</td>\n",
       "      <td>4.pt</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  Inputs Labels\n",
       "0   0.pt   0.pt\n",
       "1   1.pt   1.pt\n",
       "2   2.pt   2.pt\n",
       "3   3.pt   3.pt\n",
       "4   4.pt   4.pt"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lstm_df = {\n",
    "    'Inputs':inputs_,\n",
    "    'Labels':labels_,\n",
    "    }\n",
    "\n",
    "lstm_df = pd.DataFrame(lstm_df, columns = ['Inputs','Labels'])\n",
    "file_ = 'conv-lstm.csv'\n",
    "lstm_df.to_csv(file_, encoding='utf-8')\n",
    "lstm_df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "dd84ccdb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(78, 10, 10, 1)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#transpose this way for gif purposes\n",
    "np.transpose(y, (0, 2, 3, 1)).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "id": "13a03a23",
   "metadata": {},
   "outputs": [],
   "source": [
    "y = y.transpose(0,2,3,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "id": "a3b9c119",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(77, 10, 10, 1)"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "id": "53220632",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MoviePy - Building file test.gif with imageio.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                       \r"
     ]
    }
   ],
   "source": [
    "from moviepy.editor import ImageSequenceClip\n",
    "clip = ImageSequenceClip(list(y), fps=10)\n",
    "clip.write_gif('test.gif', fps=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d549484c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'frame_data_numpy' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_10116/2399902843.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mframe_data_numpy\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m70\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'frame_data_numpy' is not defined"
     ]
    }
   ],
   "source": [
    "frame_data_numpy[70]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "c71a8728",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(78, 10, 10, 1)"
      ]
     },
     "execution_count": 186,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "frames = np.random.randint(256, size=[78, 10, 10, 1], dtype=np.uint8)\n",
    "frames.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16fd03f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "#save all frames to files as tensors(to work with custom dataloader)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}