LSTM_Automation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Emulating a controller with an LSTM Network\n",
    "\n",
    "The purpose of this exercise is to automate a temperature control process with an LSTM network. The LSTM network is trained from a PID (Proportional Integral Derivative) controller or a Model Predictive Controller (MPC). LSTM (Long Short Term Memory) networks are a special type of RNN (Recurrent Neural Network) that is structured to remember and predict based on long-term dependencies that are trained with time-series data. An LSTM repeating module has four interacting components.\n",
    "\n",
    "<img align=left width=400px src='https://apmonitor.com/pds/uploads/Main/lstm_automation.png'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The LSTM is trained (parameters adjusted) with an input window of prior data and minimized difference between the predicted and next measured value. Sequential methods predict just one next value based on the window of prior data. In this case, the error between the set point and measured value is the feature and the heater value is the output label.\n",
    "\n",
    "See [Automation with LSTM Network](https://apmonitor.com/pds/index.php/Main/LSTMAutomation) for additional details."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:25:23.638976Z",
     "start_time": "2021-02-17T16:25:20.302787Z"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import random\n",
    "import time\n",
    "from tqdm import tqdm # Progress bar\n",
    "\n",
    "# For scaling, feature selection\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.feature_selection import SelectKBest, f_regression\n",
    "from sklearn.model_selection import train_test_split \n",
    "\n",
    "# For LSTM model\n",
    "from keras.models import Sequential\n",
    "from keras.layers import LSTM, Dropout, Dense\n",
    "from keras.callbacks import EarlyStopping\n",
    "from tqdm.keras import TqdmCallback\n",
    "from keras.models import load_model\n",
    "\n",
    "# For TCLab\n",
    "import tclab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Initialize TCLab Emulator with 100x speedup\n",
    "\n",
    "The [TCLab emulator (digital twin)](https://tclab.readthedocs.io/en/latest/notebooks/04_Emulation_of_TCLab_for_Offline_Use.html) can run faster than real-time. Use 100x speedup with the simulator. Optionally, use the TCLab to generate the training data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:25:23.654241Z",
     "start_time": "2021-02-17T16:25:23.638976Z"
    }
   },
   "outputs": [],
   "source": [
    "speedup = 100\n",
    "TCLab = tclab.setup(connected=False, speedup = speedup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Program PID controller \n",
    "\n",
    "Apply this emulated control on the physical TCLab controller. Use the emulator for training."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:25:23.670215Z",
     "start_time": "2021-02-17T16:25:23.656214Z"
    }
   },
   "outputs": [],
   "source": [
    "# PID Parameters\n",
    "Kc   = 6.0\n",
    "tauI = 75.0 # sec\n",
    "tauD = 0.0  # sec\n",
    "\n",
    "#-----------------------------------------\n",
    "# PID Controller\n",
    "#-----------------------------------------\n",
    "\n",
    "def pid(sp,pv,pv_last,ierr,dt):\n",
    "    # PID coefficients in terms of tuning parameters\n",
    "    KP = Kc\n",
    "    KI = Kc / tauI\n",
    "    KD = Kc * tauD\n",
    "    \n",
    "    # ubias for controller (initial heater)\n",
    "    op0 = 0 \n",
    "    \n",
    "    # upper and lower bounds on heater level\n",
    "    ophi = 100\n",
    "    oplo = 0\n",
    "    \n",
    "    # calculate the error\n",
    "    error = sp - pv\n",
    "    \n",
    "    # calculate the integral error\n",
    "    ierr = ierr + KI * error * dt\n",
    "    \n",
    "    # calculate the measurement derivative\n",
    "    if dt>=1e-8:\n",
    "        dpv = (pv - pv_last) / dt\n",
    "    else:\n",
    "        dpv = 0.0;\n",
    "    \n",
    "    # calculate the PID output\n",
    "    P = KP * error\n",
    "    I = ierr\n",
    "    D = -KD * dpv\n",
    "    op = op0 + P + I + D\n",
    "    \n",
    "    # implement anti-reset windup\n",
    "    if op < oplo or op > ophi:\n",
    "        I = I - KI * error * dt\n",
    "        # clip output\n",
    "        op = max(oplo,min(ophi,op))\n",
    "        \n",
    "    # return the controller output and PID terms\n",
    "    return [op,P,I,D]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Optional: Use MPC (Model Predictive Control)\n",
    "\n",
    "See the last example for [MPC with TCLab](https://apmonitor.com/pds/notebooks/12_time_series.html). This is an optional controller that you can implement instead of PID control."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-18T15:06:22.503795Z",
     "start_time": "2021-02-18T15:06:22.495792Z"
    }
   },
   "outputs": [],
   "source": [
    "#def mpc(input_parameters):    \n",
    "#    return Q1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate data for training LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:25:24.035744Z",
     "start_time": "2021-02-17T16:25:23.687213Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "##### Set up run parameters #####\n",
    "# Run time in minutes\n",
    "run_time = 90.0\n",
    "\n",
    "# Number of cycles\n",
    "loops = int(60.0*run_time)\n",
    "\n",
    "# arrays for storing data\n",
    "T1 = np.zeros(loops) # measured T (degC)\n",
    "Q1 = np.zeros(loops) # Heater values\n",
    "tm = np.zeros(loops) # Time\n",
    "\n",
    "# Temperature set point (degC)\n",
    "with TCLab() as lab:\n",
    "    Tsp1 = np.ones(loops) * lab.T1\n",
    "\n",
    "# vary temperature setpoint\n",
    "end = 30 # leave 1st 30 seconds of temp set point as room temp\n",
    "while end <= loops:\n",
    "    start = end\n",
    "    # keep new temp set point value for anywhere from 4 to 10 min\n",
    "    end += random.randint(240,600) \n",
    "    Tsp1[start:end] = random.randint(30,70)\n",
    "\n",
    "# Plot\n",
    "plt.plot(Tsp1)\n",
    "plt.xlabel('Time',size=14)\n",
    "plt.ylabel(r'Temp SP ($^oC$)',size=14)\n",
    "plt.xticks(size=12)\n",
    "plt.yticks(size=12)\n",
    "plt.savefig('SP_profile.png');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data Collection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:26:54.869018Z",
     "start_time": "2021-02-17T16:25:24.035744Z"
    }
   },
   "outputs": [],
   "source": [
    "# Data collection\n",
    "with TCLab() as lab:\n",
    "    # Find current T1, T2\n",
    "    print('Temperature 1: {0:0.2f} °C'.format(lab.T1))\n",
    "    print('Temperature 2: {0:0.2f} °C'.format(lab.T2))\n",
    "\n",
    "    # Integral error\n",
    "    ierr = 0.0\n",
    "    # Integral absolute error\n",
    "    iae = 0.0\n",
    "    \n",
    "    prev_time = 0\n",
    "    for i,t in enumerate(tclab.clock(loops-1)):\n",
    "        tm[i] = t\n",
    "        dt = t - prev_time\n",
    "        \n",
    "        # Read temperatures in Kelvin \n",
    "        T1[i] = lab.T1\n",
    "\n",
    "        # Integral absolute error\n",
    "        iae += np.abs(Tsp1[i]-T1[i])\n",
    "\n",
    "        # Calculate PID output\n",
    "        [Q1[i],P,ierr,D] = pid(Tsp1[i],T1[i],T1[i-1],ierr,dt)\n",
    "        \n",
    "        # Calculate MPC output (optionally replace PID)\n",
    "\n",
    "        # Write heater output (0-100)\n",
    "        lab.Q1(Q1[i])\n",
    "\n",
    "        # Print line of data\n",
    "        if i%100==0:\n",
    "            print(('{:6.1f} {:6.2f} {:6.2f} ' + \\\n",
    "                  '{:6.2f} {:6.2f} {:6.2f} {:6.2f} {:6.2f}').format( \\\n",
    "                      tm[i],Tsp1[i],T1[i], \\\n",
    "                      Q1[i],P,ierr,D,iae))\n",
    "        prev_time = t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:26:55.171468Z",
     "start_time": "2021-02-17T16:26:54.870445Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Save csv file\n",
    "df = pd.DataFrame()\n",
    "df['Q1'] = Q1[:i]\n",
    "df['Q1'].fillna(0,inplace=True)\n",
    "df['T1'] = T1[:i]\n",
    "df['Tsp'] = Tsp1[:i]\n",
    "df.to_csv('PID_train_data.csv',index=False)\n",
    "\n",
    "# Plot\n",
    "plt.plot(df['Q1'],'b-',label='$Q_1$ (%)')\n",
    "plt.plot(df['T1'],'r-',label='$T_1$ $(^oC)$')\n",
    "plt.plot(df['Tsp'],'k-',label='SP $(^oC)$')\n",
    "plt.legend()\n",
    "plt.savefig('PID_train.png');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feature engineering: create SP error feature and analyze feature importance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:26:55.327215Z",
     "start_time": "2021-02-17T16:26:55.177474Z"
    },
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Create new feature: setpoint error\n",
    "df['err'] = df['Tsp'] - df['T1']\n",
    "\n",
    "# Load possible features\n",
    "X = df[['T1','Tsp','err']]\n",
    "y = np.ravel(df[['Q1']])\n",
    "\n",
    "# SelectKBest feature selection\n",
    "bestfeatures = SelectKBest(score_func=f_regression, k='all')\n",
    "fit = bestfeatures.fit(X,y)\n",
    "plt.bar(x=X.columns,height=fit.scores_);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Feature selection, scaling, and formatting data to LSTM input format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:26:55.373213Z",
     "start_time": "2021-02-17T16:26:55.344216Z"
    }
   },
   "outputs": [],
   "source": [
    "X = df[['Tsp','err']].values\n",
    "y = df[['Q1']].values\n",
    "\n",
    "# Scale data\n",
    "s_x = MinMaxScaler()\n",
    "Xs = s_x.fit_transform(X)\n",
    "\n",
    "s_y = MinMaxScaler()\n",
    "ys = s_y.fit_transform(y)\n",
    "\n",
    "# Each input uses last 'window' number of Tsp and err to predict the next Q1\n",
    "window = 15\n",
    "X_lstm = []\n",
    "y_lstm = []\n",
    "for i in range(window,len(df)):\n",
    "    X_lstm.append(Xs[i-window:i])\n",
    "    y_lstm.append(ys[i])\n",
    "\n",
    "# Reshape data to format accepted by LSTM\n",
    "X_lstm, y_lstm = np.array(X_lstm), np.array(y_lstm)\n",
    "\n",
    "# Split into train and test \n",
    "Xtrain, Xtest, ytrain, ytest = train_test_split(X_lstm,y_lstm,test_size=0.2,shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Keras LSTM "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:40:26.987200Z",
     "start_time": "2021-02-17T16:33:55.613757Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# Keras LSTM model\n",
    "model = Sequential()\n",
    "\n",
    "# First layer specifies input_shape and returns sequences\n",
    "model.add(LSTM(units=100, return_sequences=True, \n",
    "               input_shape=(Xtrain.shape[1],Xtrain.shape[2])))\n",
    "# Dropout layer to prevent overfitting\n",
    "model.add(Dropout(rate=0.1))\n",
    "\n",
    "# Last layer doesn't return sequences (middle layers should return sequences)\n",
    "model.add(LSTM(units=100))\n",
    "model.add(Dropout(rate=0.1))\n",
    "\n",
    "# Dense layer to return prediction\n",
    "model.add(Dense(1))\n",
    "\n",
    "# Compile model; adam optimizer, mse loss\n",
    "model.compile(optimizer='adam', loss='mean_squared_error')\n",
    "\n",
    "es = EarlyStopping(monitor='val_loss',mode='min',verbose=1,patience=25)\n",
    "\n",
    "result = model.fit(Xtrain, ytrain, verbose=0, validation_split=0.2,\n",
    "                   callbacks = [TqdmCallback(verbose=1)],#es\n",
    "                   batch_size=100,\n",
    "                   epochs=300)\n",
    "\n",
    "# Plot loss and save model\n",
    "epochs = es.stopped_epoch\n",
    "plt.semilogy(result.history['loss'],label='loss')\n",
    "plt.semilogy(result.history['val_loss'],label='val_loss')\n",
    "plt.legend()\n",
    "\n",
    "model.save('lstm_control.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preliminary model performance assessment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:40:28.617490Z",
     "start_time": "2021-02-17T16:40:26.990200Z"
    }
   },
   "outputs": [],
   "source": [
    "# Predict using LSTM\n",
    "yp_s = model.predict(Xtest)\n",
    "\n",
    "# Unscale data\n",
    "Xtest_us = s_x.inverse_transform(Xtest[:,-1,:])\n",
    "ytest_us = s_y.inverse_transform(ytest)\n",
    "yp = s_y.inverse_transform(yp_s)\n",
    "\n",
    "# Derive Tsp (sp) and T1 (pv) from X data\n",
    "sp = Xtest_us[:,0]\n",
    "pv = Xtest_us[:,0] + Xtest_us[:,1]\n",
    "\n",
    "# Plot SP, PID response, and LSTM response\n",
    "plt.plot(sp,'k-',label='$SP$ $(^oC)$')\n",
    "plt.plot(pv,'r-',label='$T_1$ $(^oC)$')\n",
    "plt.plot(ytest_us,'b-',label='$Q_{PID}$ (%)')\n",
    "plt.plot(yp,'g-',label='$Q_{LSTM}$ (%)')\n",
    "plt.legend(fontsize=12,loc='lower right')\n",
    "plt.xlabel('Time',size=14)\n",
    "plt.ylabel('Value',size=14)\n",
    "plt.xticks(size=12)\n",
    "plt.yticks(size=12);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generate SP data for test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:40:28.976494Z",
     "start_time": "2021-02-17T16:40:28.622493Z"
    }
   },
   "outputs": [],
   "source": [
    "# Run time in minutes\n",
    "run_time = 45.0\n",
    "\n",
    "# Number of cycles\n",
    "loops = int(60.0*run_time)\n",
    "\n",
    "# arrays for storing data\n",
    "T1 = np.zeros(loops) # measured T (degC)\n",
    "Qpid = np.zeros(loops) # Heater values for PID controller\n",
    "Qlstm = np.zeros(loops) # Heater values for LSTM controller\n",
    "tm = np.zeros(loops) # Time\n",
    "\n",
    "# Temperature set point (degC)\n",
    "with TCLab() as lab:\n",
    "    Tsp = np.ones(loops) * lab.T1\n",
    "\n",
    "# vary temperature setpoint\n",
    "end = window + 15 # leave 1st window + 15 seconds of temp set point as room temp\n",
    "while end <= loops: \n",
    "    start = end\n",
    "    # keep new temp set point value for anywhere from 4 to 10 min\n",
    "    end += random.randint(240,600) \n",
    "    Tsp[start:end] = random.randint(30,70)\n",
    "    \n",
    "# leave last 120 seconds as room temp\n",
    "Tsp[-120:] = Tsp[0]\n",
    "plt.plot(Tsp)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part A: Run the controller with the PID, but also output the LSTM for comparison"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:40:29.006489Z",
     "start_time": "2021-02-17T16:40:28.983493Z"
    }
   },
   "outputs": [],
   "source": [
    "#-----------------------------------------\n",
    "# LSTM Controller\n",
    "#-----------------------------------------\n",
    "\n",
    "def lstm(T1_m, Tsp_m):\n",
    "    # Calculate error (necessary feature for LSTM input)\n",
    "    err = Tsp_m - T1_m\n",
    "    \n",
    "    # Format data for LSTM input\n",
    "    X = np.vstack((Tsp_m,err)).T\n",
    "    Xs = s_x.transform(X)\n",
    "    Xs = np.reshape(Xs, (1, Xs.shape[0], Xs.shape[1]))\n",
    "    \n",
    "    # Predict Q for controller and unscale\n",
    "    Q1c_s = model.predict(Xs)\n",
    "    Q1c = s_y.inverse_transform(Q1c_s)[0][0]\n",
    "    \n",
    "    # Ensure Q1c is between 0 and 100\n",
    "    Q1c = np.clip(Q1c,0.0,100.0)\n",
    "    return Q1c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:45:48.349921Z",
     "start_time": "2021-02-17T16:44:02.026886Z"
    }
   },
   "outputs": [],
   "source": [
    "# Run test\n",
    "with TCLab() as lab:\n",
    "    # Find current T1, T2\n",
    "    print('Temperature 1: {0:0.2f} °C'.format(lab.T1))\n",
    "    print('Temperature 2: {0:0.2f} °C'.format(lab.T2))\n",
    "\n",
    "    # Integral error\n",
    "    ierr = 0.0\n",
    "    # Integral absolute error\n",
    "    iae = 0.0\n",
    "    \n",
    "    start_time = 0\n",
    "    prev_time = 0\n",
    "    for i,t in enumerate(tclab.clock(loops)):\n",
    "        tm[i] = t\n",
    "        dt = t - prev_time\n",
    "\n",
    "        # Read temperature (C)\n",
    "        T1[i] = lab.T1\n",
    "\n",
    "        # Integral absolute error\n",
    "        iae += np.abs(Tsp[i]-T1[i])\n",
    "\n",
    "        # Calculate PID output\n",
    "        [Qpid[i],P,ierr,D] = pid(Tsp[i],T1[i],T1[i-1],ierr,dt)\n",
    "\n",
    "        # Write heater output (0-100)\n",
    "        lab.Q1(Qpid[i])\n",
    "        \n",
    "        # Run LSTM model to get Q1 value for control\n",
    "        if i >= window:\n",
    "            # Load data for model\n",
    "            T1_m = T1[i-window:i]\n",
    "            Tsp_m = Tsp[i-window:i]\n",
    "            # Predict and store LSTM value for comparison\n",
    "            Qlstm[i] = lstm(T1_m,Tsp_m)\n",
    "            \n",
    "        prev_time = t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:45:48.536872Z",
     "start_time": "2021-02-17T16:45:48.352873Z"
    }
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,4))\n",
    "plt.plot(Tsp[:i],'k-',label='SP $(^oC)$')\n",
    "plt.plot(T1[:i],'r-',label='$T_1$ $(^oC)$')\n",
    "plt.plot(Qpid[:i],'b-',label='$Q_{PID}$ (%)')\n",
    "plt.plot(Qlstm[:i],'g-',label='$Q_{LSTM}$ (%)')\n",
    "plt.legend(loc='upper right',fontsize=14)\n",
    "plt.ylim((0,100))\n",
    "plt.xlabel('Time (s)',size=14)\n",
    "plt.xticks(size=12)\n",
    "plt.yticks(size=12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part B: Run the controller with just the LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-17T16:47:32.690137Z",
     "start_time": "2021-02-17T16:45:48.538872Z"
    }
   },
   "outputs": [],
   "source": [
    "# Run test\n",
    "loops = 300\n",
    "with TCLab() as lab:\n",
    "    # Find current T1, T2\n",
    "    print('Temperature 1: {0:0.2f} °C'.format(lab.T1))\n",
    "    print('Temperature 2: {0:0.2f} °C'.format(lab.T2))\n",
    "    \n",
    "    start_time = 0\n",
    "    prev_time = 0\n",
    "    for i,t in enumerate(tclab.clock(loops)):\n",
    "        tm[i] = t\n",
    "        dt = t - prev_time\n",
    "\n",
    "        # Read temperature (C)\n",
    "        T1[i] = lab.T1\n",
    "\n",
    "        # Run LSTM model to get Q1 value for control\n",
    "        if i >= window:\n",
    "            # Load data for model\n",
    "            T1_m = T1[i-window:i]\n",
    "            Tsp_m = Tsp[i-window:i]\n",
    "            # Predict and store LSTM value for comparison\n",
    "            Qlstm[i] = lstm(T1_m,Tsp_m)\n",
    "\n",
    "        # Write heater output (0-100)\n",
    "        lab.Q1(Qlstm[i])\n",
    "        \n",
    "        prev_time = t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-02-18T15:13:49.761601Z",
     "start_time": "2021-02-18T15:13:49.565402Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.figure(figsize=(10,4))\n",
    "plt.plot(Tsp[:i],'k-',label='SP $(^oC)$')\n",
    "plt.plot(T1[:i],'r-',label='$T_1$ $(^oC)$')\n",
    "plt.plot(Qlstm[:i],'g-',label='$Q_{LSTM}$ (%)')\n",
    "plt.legend(fontsize=14)\n",
    "plt.ylim((0,100))\n",
    "plt.xlabel('Time (s)',size=14)\n",
    "plt.xticks(size=12)\n",
    "plt.yticks(size=12)\n",
    "plt.grid()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Part C\n",
    "\n",
    "Use the LSTM controller to control the [TCLab microcontroller](https://apmonitor.com/heat.htm) or [Emulated TCLab](https://tclab.readthedocs.io/en/latest/notebooks/04_Emulation_of_TCLab_for_Offline_Use.html) from a separate program. Demonstrate that you can [package and deploy the LSTM model](https://apmonitor.com/pds/index.php/Main/DeployMachineLearning) so that it could be used on a different computer than the training computer. The application does not necessarily need to run on a separate computer, but show that it is a separate program and independent of this training notebook.\n",
    "\n",
    "<img align=left width=150px src='https://apmonitor.com/pds/uploads/Main/deploy_machine_learning.png'>\n",
    "\n",
    "<img align=left width=400px src='https://apmonitor.com/pdc/uploads/Main/tclab_connect.png'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "# export model name and scaling\n",
    "z = ['lstm_control.h5',s_x,s_y,window]\n",
    "pickle.dump(z,open('lstm_control.pkl','wb'))"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}