1st_order_Process_Identification_with_Tuning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\user\\Anaconda3\\lib\\site-packages\\h5py\\__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "# ProcessIdentification class\n",
    "# Necessary libraries\n",
    "import numpy as np\n",
    "import os\n",
    "import tensorflow as tf\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "from datetime import datetime\n",
    "now = datetime.utcnow().strftime(\"%Y%m%d%H%M%S\")\n",
    "\n",
    "class FirstOrderProcessIdentification:\n",
    "    def __init__(self, n_hidden_layers=2, n_neurons=100, optimizer_class=tf.train.MomentumOptimizer,\n",
    "                 momentum = 0.9, learning_rate=0.01, n_inputs = 11, n_outputs = 1, batch_size=50,\n",
    "                 activation=tf.nn.relu, learning_object=None, loaded_data=None, random_state=None):\n",
    "        self.n_hidden_layers = n_hidden_layers\n",
    "        self.n_neurons = n_neurons\n",
    "        self.optimizer_class = optimizer_class\n",
    "        self.momentum = momentum\n",
    "        self.n_inputs = n_inputs\n",
    "        self.n_outputs = n_outputs\n",
    "        self.learning_rate = learning_rate\n",
    "        self.batch_size = batch_size\n",
    "        self.activation = activation\n",
    "        self.learning_object = learning_object\n",
    "        self.loaded_data = loaded_data\n",
    "        self.random_state = random_state\n",
    "        self._session = None\n",
    "        \n",
    "    def data_preparation(self):\n",
    "        train_set, test_set = train_test_split(self.loaded_data, test_size=0.2, random_state=42)\n",
    "        X_train, y_train = train_set.iloc[:,:11].values, train_set.iloc[:,11:].values\n",
    "        X_test, y_test = test_set.iloc[:,:11].values, test_set.iloc[:,11:].values\n",
    "        X_scale_minmax = X_train\n",
    "        scaler = MinMaxScaler()\n",
    "        scaler.fit(X_train)\n",
    "        X_train = scaler.transform(X_train)\n",
    "        X_test = scaler.transform(X_test)   \n",
    "        return X_train, y_train, X_test, y_test, X_scale_minmax\n",
    "    \n",
    "    def operating_data_preparation(self, X_scale_minmax):\n",
    "        X_op, y_op = self.loaded_data.iloc[:,:11].values, self.loaded_data.iloc[:,11:].values\n",
    "        process_gain = X_op[0,:]        \n",
    "        scaler = MinMaxScaler()\n",
    "        scaler.fit(X_scale_minmax)\n",
    "        X_op = scaler.transform(X_op)\n",
    "        return X_op, y_op, process_gain\n",
    "\n",
    "    def _dnn(self, inputs):\n",
    "        for layer in range(self.n_hidden_layers):\n",
    "            inputs = tf.layers.dense(inputs, self.n_neurons, name=\"hidden%d\" % (layer + 1))\n",
    "            inputs = self.activation(inputs, name=\"hidden%d_out\" % (layer + 1))\n",
    "        return inputs\n",
    "    \n",
    "    def _build_graph(self, n_inputs, n_outputs):\n",
    "        if self.random_state is not None:\n",
    "            tf.set_random_seed(self.random_state)\n",
    "            np.random.seed(self.random_state)\n",
    "            \n",
    "        X = tf.placeholder(tf.float32, shape=(None, n_inputs), name=\"X\")\n",
    "        y = tf.placeholder(tf.float32, shape=(None), name=\"y\")\n",
    "        \n",
    "        dnn_outputs = self._dnn(X)\n",
    "        \n",
    "        y_predict = tf.layers.dense(dnn_outputs, n_outputs, name=\"outputs\")\n",
    "        \n",
    "        RMSE = tf.sqrt(tf.losses.mean_squared_error(y, y_predict), name=\"loss\")\n",
    "        \n",
    "        optimizer = self.optimizer_class(learning_rate=self.learning_rate, momentum=self.momentum, use_nesterov=True)\n",
    "        training_op = optimizer.minimize(RMSE)\n",
    "        \n",
    "        accuracy = tf.reduce_mean(1-(abs(y_predict - y)/y), name=\"accuracy\")\n",
    "        \n",
    "        init = tf.global_variables_initializer()\n",
    "        saver = tf.train.Saver()\n",
    "        \n",
    "        self._X, self._y = X, y\n",
    "        self._y_predict, self._RMSE = y_predict, RMSE\n",
    "        self._training_op, self._accuracy = training_op, accuracy\n",
    "        self._init, self._saver = init, saver\n",
    "\n",
    "    def close_session(self):\n",
    "        if self._session:\n",
    "            self._session.close()\n",
    "\n",
    "    def fit(self, X, y, n_epochs=20):\n",
    "        self.close_session()\n",
    "        \n",
    "        self._graph = tf.Graph()\n",
    "        with self._graph.as_default():\n",
    "            self._build_graph(self.n_inputs, self.n_outputs)        \n",
    "        \n",
    "        self._session = tf.Session(graph=self._graph)\n",
    "        \n",
    "        root_logdir = \"tf_logs_1st_%s_RMSE\" % (self.learning_object)\n",
    "        logdir = \"{}/run-{}/\".format(root_logdir, now)\n",
    "        RMSE_summary = tf.summary.scalar('RMSE', self._RMSE)\n",
    "        file_writer = tf.summary.FileWriter(logdir, self._session.graph)\n",
    "        \n",
    "        with self._session.as_default() as sess:\n",
    "            self._init.run()\n",
    "            for epoch in range(n_epochs):\n",
    "                rnd_idx = np.random.permutation(len(X))\n",
    "                for rnd_indices in np.array_split(rnd_idx, len(X) // self.batch_size):\n",
    "                    X_batch, y_batch = X[rnd_indices], y[rnd_indices]\n",
    "                    feed_dict = {self._X: X_batch, self._y: y_batch}\n",
    "                    sess.run(self._training_op, feed_dict=feed_dict)\n",
    "                acc_batch = self._accuracy.eval(feed_dict=feed_dict)\n",
    "                RMSE_batch = self._RMSE.eval(feed_dict=feed_dict)\n",
    "                summary_str = RMSE_summary.eval(feed_dict=feed_dict)\n",
    "                file_writer.add_summary(summary_str, epoch)\n",
    "                print(\"{}\\tbatch data accuracy: {:.4f}\\tbatch data RMSE: {:.6f}\".format(epoch, acc_batch, RMSE_batch))\n",
    "            \n",
    "            save_path = self._saver.save(sess, \"./1st_order_process_%s_learning.ckpt\" % self.learning_object)\n",
    "            \n",
    "    def predict(self, X, y):\n",
    "        self._graph = tf.Graph()\n",
    "        with self._graph.as_default():\n",
    "            self._build_graph(self.n_inputs, self.n_outputs)\n",
    "            \n",
    "        self._session = tf.Session(graph=self._graph)\n",
    "        with self._session.as_default() as sess:\n",
    "            self._saver.restore(sess, \"./1st_order_process_%s_learning.ckpt\" % self.learning_object)\n",
    "            accuracy_val = self._accuracy.eval(feed_dict={self._X: X, self._y: y})\n",
    "            X_new_scaled = X[:10]\n",
    "            y_pred = self._y_predict.eval(feed_dict={self._X: X_new_scaled})\n",
    "            \n",
    "            print(\"\\n\")\n",
    "            print(\"%s test data accuracy:\" % self.learning_object, accuracy_val)\n",
    "            print(\"\\n\")\n",
    "        \n",
    "        return y_pred\n",
    "    \n",
    "    def operating_predict(self, X, y):\n",
    "        self._graph = tf.Graph()\n",
    "        with self._graph.as_default():\n",
    "            self._build_graph(self.n_inputs, self.n_outputs)\n",
    "            \n",
    "        self._session = tf.Session(graph=self._graph)\n",
    "        with self._session.as_default() as sess:\n",
    "            self._saver.restore(sess, \"./1st_order_process_%s_learning.ckpt\" % self.learning_object)\n",
    "            X_new_scaled = X[:1]\n",
    "            y_pred = self._y_predict.eval(feed_dict={self._X: X_new_scaled})\n",
    "\n",
    "        return y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#PID Tuning class    \n",
    "class PIDTuning:\n",
    "    def __init__(self, tau=None, theta=None, PID_type=None):\n",
    "        self.tau = tau\n",
    "        self.theta = theta\n",
    "        self.PID_type = PID_type         \n",
    "\n",
    "    def IMC_tuning_PIPC(self, process_gain=None):\n",
    "        lamda = 0.25 * self.theta\n",
    "        if self.PID_type == \"PI\":\n",
    "            controller_gain = ((2*self.tau + self.theta)/(2*lamda))/process_gain\n",
    "            integral_time = self.tau + self.theta/2\n",
    "            print(\"PI Controller by IMC Tuning_PIPC: Kc = %f, tau_i = %f\" % (controller_gain, integral_time))\n",
    "        elif self.PID_type == \"PID\":\n",
    "            controller_gain = ((2*self.tau + self.theta)/(2*(lamda + self.theta)))/process_gain\n",
    "            integral_time = self.tau + self.theta/2\n",
    "            derivative_time = self.tau*self.theta/(2*self.tau + self.theta)\n",
    "            print(\"PID Controller by IMC Tuning_PIPC: Kc = %f, tau_i = %f, tau_d = %f\" %\n",
    "                  (controller_gain, integral_time, derivative_time))\n",
    "    \n",
    "    def IMC_tuning_PDCT(self, process_gain=None, Condition=None):\n",
    "        if Condition == \"aggressive control\":\n",
    "            tau_c = 0.5/self.theta\n",
    "        elif Condition == \"default value\":\n",
    "            tau_c = self.theta\n",
    "        elif Condition == \"smooth control\":\n",
    "            tau_c = 1.5*self.theta\n",
    "        elif Condition == \"robust control\":\n",
    "            tau_c = 3*self.theta\n",
    "        if self.PID_type == \"PI\":\n",
    "            controller_gain = self.tau/((tau_c+self.theta)*process_gain)\n",
    "            integral_time = self.tau\n",
    "            print(\"PI Controller by IMC Tuning_PDCT: Kc = %f, tau_i = %f\" % (controller_gain, integral_time))\n",
    "        elif self.PID_type == \"PID\":\n",
    "            controller_gain = (self.tau+(self.theta/2))/((tau_c+(self.theta/2))*process_gain)\n",
    "            integral_time = self.tau+(self.theta/2)\n",
    "            derivative_time = (self.tau*self.theta)/(2*self.tau+self.theta)     \n",
    "            print(\"PID Controller by IMC Tuning_PDCT: Kc = %f, tau_i = %f, tau_d = %f\" %\n",
    "                 (controller_gain, integral_time, derivative_time))  \n",
    "    \n",
    "    def ITAE_1_tuning(self, process_gain=None):\n",
    "        theta_tau_ratio = self.theta/self.tau\n",
    "        if self.PID_type == \"PI\":\n",
    "            controller_gain_set_point = 0.586*(theta_tau_ratio**(-0.916))/process_gain\n",
    "            integral_time_set_point = self.tau/(1.030 - 0.165*theta_tau_ratio)\n",
    "            controller_gain_disturbance = 0.859*(theta_tau_ratio**(-0.977))/process_gain\n",
    "            integral_time_disturbance = self.tau/(0.674*(theta_tau_ratio**(-0.680)))\n",
    "            print(\"PI controller by ITAE-1-setpoint tuning: Kc = %f, tau_i = %f\" % (controller_gain_set_point, integral_time_set_point))\n",
    "            print(\"PI Controller by ITAE-1-disturbance tuning: Kc = %f, tau_i = %f\" % (controller_gain_disturbance, integral_time_disturbance))\n",
    "        elif self.PID_type == \"PID\":\n",
    "            controller_gain_set_point = 0.965*(theta_tau_ratio**(-0.850))/process_gain\n",
    "            integral_time_set_point = self.tau/(0.796 - 0.1465*theta_tau_ratio)\n",
    "            derivative_time_set_point = self.tau*0.308*(theta_tau_ratio**(0.929))\n",
    "            controller_gain_disturbance = 1.357*(theta_tau_ratio**(-0.947))/process_gain\n",
    "            integral_time_disturbance = self.tau/(0.842*(theta_tau_ratio**(-0.738)))\n",
    "            derivative_time_disturbance = self.tau*0.381*(theta_tau_ratio**(0.995))\n",
    "            print(\"PID Controller by ITAE-1-setpoint tuning: Kc = %f, tau_i = %f, tau_d = %f\" %\n",
    "                  (controller_gain_set_point, integral_time_set_point, derivative_time_set_point))\n",
    "            print(\"PID Controller by ITAE-1-disturbance tuning: Kc = %f, tau_i = %f, tau_d = %f\" %\n",
    "                  (controller_gain_disturbance, integral_time_disturbance, derivative_time_disturbance))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#data load for training\n",
    "learning_1st = pd.read_excel('DataFirst_rand_limit.xlsx')\n",
    "pro_iden = FirstOrderProcessIdentification(loaded_data = learning_1st)\n",
    "X_train, y_train, X_test, y_test, X_scale_minmax = pro_iden.data_preparation()\n",
    "y_train_TC, y_train_TD = y_train[:,0:1], y_train[:,1:2]\n",
    "y_test_TC, y_test_TD = y_test[:,0:1], y_test[:,1:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\tbatch data accuracy: -0.8982\tbatch data RMSE: 14.528848\n",
      "1\tbatch data accuracy: 0.6237\tbatch data RMSE: 4.460631\n",
      "2\tbatch data accuracy: 0.9134\tbatch data RMSE: 0.787401\n",
      "3\tbatch data accuracy: 0.9915\tbatch data RMSE: 0.100834\n",
      "4\tbatch data accuracy: 0.9840\tbatch data RMSE: 0.042804\n",
      "5\tbatch data accuracy: 0.9988\tbatch data RMSE: 0.012111\n",
      "6\tbatch data accuracy: 0.9992\tbatch data RMSE: 0.007317\n",
      "7\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.005131\n",
      "8\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.005750\n",
      "9\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.003334\n",
      "10\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.006868\n",
      "11\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.004211\n",
      "12\tbatch data accuracy: 0.9999\tbatch data RMSE: 0.002275\n",
      "13\tbatch data accuracy: 0.9999\tbatch data RMSE: 0.001283\n",
      "14\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.001930\n",
      "15\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.002219\n",
      "16\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.005988\n",
      "17\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.003734\n",
      "18\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.004516\n",
      "19\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.004789\n",
      "20\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.005275\n",
      "21\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.005794\n",
      "22\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.007647\n",
      "23\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.005084\n",
      "24\tbatch data accuracy: 0.9999\tbatch data RMSE: 0.001181\n",
      "25\tbatch data accuracy: 0.9996\tbatch data RMSE: 0.010636\n",
      "26\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.003615\n",
      "27\tbatch data accuracy: 0.9993\tbatch data RMSE: 0.007662\n",
      "28\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.002507\n",
      "29\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.003026\n",
      "30\tbatch data accuracy: 0.9999\tbatch data RMSE: 0.000735\n",
      "INFO:tensorflow:Restoring parameters from ./1st_order_process_tau_learning.ckpt\n",
      "\n",
      "\n",
      "tau test data accuracy: 0.9999205\n",
      "\n",
      "\n",
      "predictive time constant:\n",
      " [[47.41393  ]\n",
      " [ 5.583295 ]\n",
      " [33.43261  ]\n",
      " [34.236786 ]\n",
      " [27.186762 ]\n",
      " [ 2.0278673]\n",
      " [29.245945 ]\n",
      " [19.190521 ]\n",
      " [38.035343 ]\n",
      " [ 4.0135093]]\n",
      "real time constant:\n",
      " [[47.4126849 ]\n",
      " [ 5.5833123 ]\n",
      " [33.43199441]\n",
      " [34.23651574]\n",
      " [27.18671282]\n",
      " [ 2.02896979]\n",
      " [29.24577556]\n",
      " [19.19037046]\n",
      " [38.03488181]\n",
      " [ 4.01143789]]\n"
     ]
    }
   ],
   "source": [
    "#Time Constant training\n",
    "pro_iden_tau = FirstOrderProcessIdentification(learning_rate = 0.00001, momentum = 0.999,\n",
    "                                               learning_object=\"tau\", random_state=42)\n",
    "pro_iden_tau.fit(X=X_train, y=y_train_TC, n_epochs=31)\n",
    "y_pred_TC = pro_iden_tau.predict(X=X_test, y=y_test_TC)\n",
    "print(\"predictive time constant:\\n\", y_pred_TC)\n",
    "print(\"real time constant:\\n\", y_test_TC[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\tbatch data accuracy: 0.9961\tbatch data RMSE: 0.016399\n",
      "1\tbatch data accuracy: 0.9996\tbatch data RMSE: 0.003302\n",
      "2\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.001638\n",
      "3\tbatch data accuracy: 0.9993\tbatch data RMSE: 0.006036\n",
      "4\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.003647\n",
      "5\tbatch data accuracy: 0.9996\tbatch data RMSE: 0.004134\n",
      "6\tbatch data accuracy: 0.9996\tbatch data RMSE: 0.004135\n",
      "7\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.003302\n",
      "8\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.003496\n",
      "9\tbatch data accuracy: 0.9993\tbatch data RMSE: 0.001254\n",
      "10\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.001974\n",
      "11\tbatch data accuracy: 0.9994\tbatch data RMSE: 0.002478\n",
      "12\tbatch data accuracy: 0.9999\tbatch data RMSE: 0.000997\n",
      "13\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.002480\n",
      "14\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.001909\n",
      "15\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.002856\n",
      "16\tbatch data accuracy: 0.9999\tbatch data RMSE: 0.000411\n",
      "17\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.000637\n",
      "18\tbatch data accuracy: 0.9999\tbatch data RMSE: 0.000843\n",
      "19\tbatch data accuracy: 1.0000\tbatch data RMSE: 0.000417\n",
      "20\tbatch data accuracy: 0.9999\tbatch data RMSE: 0.000558\n",
      "21\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.000383\n",
      "22\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.001808\n",
      "23\tbatch data accuracy: 0.9996\tbatch data RMSE: 0.003192\n",
      "24\tbatch data accuracy: 0.9995\tbatch data RMSE: 0.000511\n",
      "25\tbatch data accuracy: 0.9997\tbatch data RMSE: 0.002530\n",
      "26\tbatch data accuracy: 0.9999\tbatch data RMSE: 0.000767\n",
      "27\tbatch data accuracy: 0.9990\tbatch data RMSE: 0.001864\n",
      "28\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.001644\n",
      "29\tbatch data accuracy: 0.9999\tbatch data RMSE: 0.000873\n",
      "30\tbatch data accuracy: 0.9998\tbatch data RMSE: 0.001471\n",
      "31\tbatch data accuracy: 0.9999\tbatch data RMSE: 0.000254\n",
      "INFO:tensorflow:Restoring parameters from ./1st_order_process_theta_learning.ckpt\n",
      "\n",
      "\n",
      "theta test data accuracy: 0.9998541\n",
      "\n",
      "\n",
      "predictive time delay:\n",
      " [[15.096332  ]\n",
      " [ 4.5481796 ]\n",
      " [ 1.6843085 ]\n",
      " [ 9.621013  ]\n",
      " [ 6.9876575 ]\n",
      " [ 3.3588865 ]\n",
      " [ 0.34596208]\n",
      " [14.257213  ]\n",
      " [ 6.1136365 ]\n",
      " [10.017587  ]]\n",
      "real time delay:\n",
      " [[15.09626562]\n",
      " [ 4.54781622]\n",
      " [ 1.68418859]\n",
      " [ 9.62089352]\n",
      " [ 6.98746592]\n",
      " [ 3.35849725]\n",
      " [ 0.3458375 ]\n",
      " [14.25694166]\n",
      " [ 6.113586  ]\n",
      " [10.01724697]]\n"
     ]
    }
   ],
   "source": [
    "#Time Delay training\n",
    "pro_iden_theta = FirstOrderProcessIdentification(n_neurons=70, learning_rate = 0.00001, momentum = 0.999,\n",
    "                                                 batch_size=10, learning_object=\"theta\", random_state=42)\n",
    "pro_iden_theta.fit(X=X_train, y=y_train_TD, n_epochs=32)\n",
    "y_pred_TD = pro_iden_theta.predict(X=X_test, y=y_test_TD)\n",
    "print(\"predictive time delay:\\n\", y_pred_TD)\n",
    "print(\"real time delay:\\n\", y_test_TD[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data load for modeling\n",
    "# The data used here is just data to work. Instead, change to the data you want to model.\n",
    "operating_1st = pd.read_excel('DataFirst_Operating_rand_limit.xlsx')\n",
    "pro_iden = FirstOrderProcessIdentification(loaded_data = operating_1st)\n",
    "X_op, y_op, process_gain = pro_iden.operating_data_preparation(X_scale_minmax=X_scale_minmax)\n",
    "y_op_TC, y_op_TD, = y_op[:,0:1], y_op[:,1:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Restoring parameters from ./1st_order_process_tau_learning.ckpt\n",
      "INFO:tensorflow:Restoring parameters from ./1st_order_process_theta_learning.ckpt\n",
      "\n",
      "\n",
      "predictive time constant: [[33.00825]]\n",
      "\n",
      "\n",
      "predictive time delay: [[1.6332352]]\n"
     ]
    }
   ],
   "source": [
    "tau_pred = pro_iden_tau.operating_predict(X=X_op, y=y_op_TC)\n",
    "theta_pred = pro_iden_theta.operating_predict(X=X_op, y=y_op_TD)\n",
    "\n",
    "print(\"\\n\"); print(\"predictive time constant:\", tau_pred)\n",
    "print(\"\\n\"); print(\"predictive time delay:\", theta_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PID Controller by IMC Tuning_PIPC: Kc = 0.575269, tau_i = 33.824867, tau_d = 0.796902\n",
      "\n",
      "\n",
      "PID Controller by IMC Tuning_PDCT: Kc = 0.479391, tau_i = 33.824867, tau_d = 0.796902\n",
      "\n",
      "\n",
      "PID Controller by ITAE-1-setpoint tuning: Kc = 0.431379, tau_i = 41.848747, tau_d = 0.622723\n",
      "PID Controller by ITAE-1-disturbance tuning: Kc = 0.811992, tau_i = 4.263802, tau_d = 0.631686\n"
     ]
    }
   ],
   "source": [
    "PID_tuning = PIDTuning(tau=tau_pred, theta=theta_pred, PID_type=\"PID\")\n",
    "process_gain = process_gain[:1]\n",
    "\n",
    "PID_tuning.IMC_tuning_PIPC(process_gain=process_gain)\n",
    "print(\"\\n\")\n",
    "PID_tuning.IMC_tuning_PDCT(process_gain=process_gain, Condition=\"default value\")\n",
    "print(\"\\n\")\n",
    "PID_tuning.ITAE_1_tuning(process_gain=process_gain)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}