Commit b9e8e26d authored by Ibrahim Ahmed's avatar Ibrahim Ahmed
Browse files

controller: settings parsing, feecback ctrl bugs; 

>
> In controller script, the get_settings() function now type casts arrays and floats
> instead of the update_controller() function.
>
> In baseline_control, there was a bug with simpleFeedbackController with signs reversed.
parent 749076a5

src/Baseline-Condenser.ipynb

+70 −19
Changes for src/Baseline-Condenser.ipynb: 70 added lines, 19 removed lines.
Original line number Diff line number Diff line 
%% Cell type:code id: tags:



``` python

%matplotlib inline

%reload_ext autoreload

%autoreload 2



import datetime

import sys

from os import path, environ

import pickle

import warnings



import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

from sklearn.preprocessing import StandardScaler

from sklearn.pipeline import Pipeline

from sklearn.neural_network import MLPRegressor

from tqdm.auto import tqdm, trange



from utils import contiguous_sequences

from plotting import model_surface, plot_surface

from systems import Condenser

from baseline_control import SimpleFeedbackController, FeedbackController



chiller_file_1 = path.join(environ['DATADIR'],

                         'EngineeringScienceBuilding',

                         '2422_ESB_HVAC_1.csv')

chiller_file_2 = path.join(environ['DATADIR'],

                         'EngineeringScienceBuilding',

                         '2841_ESB_HVAC_2.csv')



plot_path = path.join('..', 'docs', 'img')

bin_path = './bin/'

```



%% Cell type:markdown id: tags:



# Controller script functions



%% Cell type:code id: tags:



``` python

# Choosing which chiller to use

chiller_file = chiller_file_2

# Data selection 'all' or 'chiller_on' or 'fan_on'

MODE = 'chiller_on'

# Read pre-processed data:

# Pytorch uses float32 as default type for weights etc,

# so input data points are also read in the same type.

df = pd.read_csv(chiller_file, index_col='time',

                 parse_dates=['time'], dtype=np.float32)

print('Original length: {} Records'.format(len(df)))

# # These fields were not populated until 2020-07-01, so leaving then out of analysis

# df.drop(['PowFanA', 'PowFanB', 'FlowCond', 'PowChiP', 'PerFreqConP', 'PowConP'], axis='columns', inplace=True)

df.drop(['FlowCond', 'PowChiP', 'PerFreqConP'], axis='columns', inplace=True)

from datetime import datetime, timedelta

import pytz

from controller import make_arguments, get_settings, get_controller, update_controller, get_current_state, put_control_action

```



df.dropna(inplace=True)

if MODE == 'chiller_on':

    df = df[df['RunChi'] != 0]

if MODE == 'fan_on':

    df = df[(df['RunFanA'] != 0.) | df['RunFanB'] != 0.]

print('Processed length: {} Records'.format(len(df)))

%% Cell type:code id: tags:



``` python

parser = make_arguments()

args = parser.parse_args(['-s', './local.ini'])

settings = get_settings(args)

settings['target'] = 'temperature'

settings

```



%% Cell type:code id: tags:



``` python

ctrl = get_controller(**settings)

update_controller(ctrl, **settings)

```



%% Cell type:code id: tags:



``` python

end = datetime.now(pytz.utc)

start = end - timedelta(minutes=10)

s = get_current_state(start, end, **settings)

s

```



%% Cell type:code id: tags:



``` python

s['TempCondIn'] = 68

```



%% Cell type:code id: tags:



``` python

action, = ctrl.predict(s)

action

```



%% Cell type:markdown id: tags:



## Environment model



State variables (12):



`'TempCondIn', 'TempCondOut', 'TempEvapOut', 'PowChi', 'PowFanA', 'PowFanB', 'PowConP', 'TempEvapIn', 'TempAmbient', 'TempWetBulb', 'PressDiffEvap', 'PressDiffCond'`



Action variables (1):



`'TempCondInSetpoint'`



Output variables (3):



`'TempCondIn', 'TempCondOut', 'TempEvapOut', 'PowChi', 'PowFanA', 'PowFanB', 'PowConP'`



Model:



`[Action, State] --> [Output]`



%% Cell type:code id: tags:



``` python

# Choosing which chiller to use

chiller_file = chiller_file_2

# Data selection 'all' or 'chiller_on' or 'fan_on'

MODE = 'chiller_on'

# Read pre-processed data:

# Pytorch uses float32 as default type for weights etc,

# so input data points are also read in the same type.

df = pd.read_csv(chiller_file, index_col='time',

                 parse_dates=['time'], dtype=np.float32)

print('Original length: {} Records'.format(len(df)))

# # These fields were not populated until 2020-07-01, so leaving then out of analysis

# df.drop(['PowFanA', 'PowFanB', 'FlowCond', 'PowChiP', 'PerFreqConP', 'PowConP'], axis='columns', inplace=True)

df.drop(['FlowCond', 'PowChiP', 'PerFreqConP'], axis='columns', inplace=True)



df.dropna(inplace=True)

if MODE == 'chiller_on':

    df = df[df['RunChi'] != 0]

if MODE == 'fan_on':

    df = df[(df['RunFanA'] != 0.) | df['RunFanB'] != 0.]

print('Processed length: {} Records'.format(len(df)))

```



%% Cell type:code id: tags:



``` python

# load model

with open(path.join(bin_path, 'v2_condenser'), 'rb') as f:

    save = pickle.load(f, fix_imports=False)

    est_cond = save['estimator']

    std_out_cond = save['output_norm']

    statevars = save['statevars']

    actionvars = save['actionvars']

    inputs = save['inputs']

    outputs = save['outputs']

    lag = save['lag']

```



%% Cell type:markdown id: tags:



### Condenser Data



%% Cell type:code id: tags:



``` python

df_in = pd.DataFrame(columns=inputs, index=df.index)

df_in['TempCondInSetpoint'] = np.clip(df['TempWetBulb'] - 4, a_min=65, a_max=None)  # approach controller

df_in[inputs[1:]] = df[inputs[1:]]



df_out = pd.DataFrame(columns=outputs, index=df.index)

df_out[outputs] = df[outputs]



idx_list = contiguous_sequences(df.index, pd.Timedelta(5, unit='min'), filter_min=10)



# Create dataframes of contiguous sequences with a delay

# of 1 time unit to indicate causality input -> outputs

dfs_in, dfs_out = [], []

for idx in idx_list:

    dfs_in.append(df_in.loc[idx[:-max(lag) if max(lag) > 0 else None]])

    cols = []

    for l, c in zip(lag, outputs):

        window = slice(l, None if l==max(lag) else -(max(lag)-l))

        series = df_out[c].loc[idx[window]]

        cols.append(series.values)

        if l == min(lag): index = series.index

    dfs_out.append(pd.DataFrame(np.asarray(cols).T, index=index, columns=outputs))



df_in = pd.concat(dfs_in, sort=False)

df_out = pd.concat(dfs_out, sort=False)



print('{:6d} time series'.format(len(dfs_in)))

print('{:6d} total rows'.format(len(df_in)))

```



%% Cell type:markdown id: tags:



## RL Environment



%% Cell type:code id: tags:



``` python

# Make wrapper for cooling tower such that outputs are normalized

# i.e. in physical units instead of being 0 mean and 1 variance.



externalvars = ('TempEvapIn', 'TempAmbient', 'TempWetBulb', 'PressDiffEvap', 'PressDiffCond')

externalvals = [df.loc[:, externalvars] for df in dfs_in]



class InvTransformer:



    def __init__(self, estimator, transformer):

        self.estimator = estimator

        self.transformer = transformer



    def predict(self, x):

        return self.transformer.inverse_transform(self.estimator.predict(x))





esb = Condenser(InvTransformer(est_cond, std_out_cond), externalvals)

```



%% Cell type:code id: tags:



``` python

# Visualize environment episode

done = False

states = []

power = []

esb.reset()

while not done:

    state, _, done, info = esb.step(esb.action_space.sample())

    states.append(state)

    power.append(info.get('powchi'))

esb.reset()



states = np.asarray(states)

power = np.asarray(power)

plt.subplot(2,1,1)

plt.plot(power, label='Total Power')

plt.legend()

plt.subplot(2,1,2)

plt.plot(states[:, 0], label='TempCondIn')

plt.plot(states[:, 1], label='TempCondOut')

plt.plot(states[:, 2], label='TempEvapOut')

plt.plot(states[:, 4], label='TempEvapIn')

plt.plot(states[:, 5], label='TempAmbient')

plt.plot(states[:, 6], label='TempWetBulb')

plt.legend()

plt.show()

```



%% Cell type:markdown id: tags:



## Simple Feedback Control



%% Cell type:code id: tags:



``` python

longest_seq_idx = max(range(len(dfs_in)), key= lambda i: len(dfs_in[i]))

```



%% Cell type:code id: tags:



``` python

dfs_in[longest_seq_idx]

```



%% Cell type:code id: tags:



``` python

# seqidx = np.random.randint(len(dfs_in))

seqidx = longest_seq_idx

simulate_hist = True  # Whether to use raw output data, or simulate it through historical actions



# indexing histories after 1st element because simulated trajectories

# are recorded after initial state (> 0), so lengths are equal

act_hist = dfs_in[seqidx].loc[:, ('TempCondInSetpoint')].values[1:, None]

ext = dfs_in[seqidx].loc[:, externalvars]



# Get baseline by running historic actions through environment:

if simulate_hist:

    esb.reset(external=ext, state0=dfs_in[seqidx].iloc[0, 1:].values)

    done = False

    pow_hist_chi, pow_hist_fan, temp_hist = [], [], []

    t = 0

    while not done:

        action = act_hist[t, :1]

        _, _, done, info = esb.step(action)

        # pow_hist_fan.append(info.get('powfans'))

        pow_hist_chi.append(info.get('powchi'))

        temp_hist.append(info.get('tempcondin'))

        t += 1

else:

    pow_hist_chi = dfs_out[seqidx]['PowChi'].values

    pow_hist_fans = dfs_out[seqidx]['PowFans'].values

    temp_hist = dfs_out[seqidx]['TempCondIn'].values

```



%% Cell type:code id: tags:



``` python

# define agent

class Controller1(SimpleFeedbackController):



    def feedback(self, X):

        return -sum(X[3:7])  # PowChi, PowFanA, PowFanB, PowConP

        # return -X[0]



    def starting_action(self, X):

        return np.asarray([X[9] + 4]) # TempWetBulb



    def clip_action(self, u, X):

        u = super().clip_action(u, X)

        return np.clip(u, a_min=X[9], a_max=None)



class Controller2(FeedbackController):



    def feedback(self, X):

        return -X[3]  # PowChi



    def starting_action(self, X):

        return None

        # return X[9] + 4 # TempWetBulb







agent_fn = lambda: Controller1(bounds=((60., 80.),), stepsize=1)

# agent_fn = lambda: Controller2(bounds=((55., 90.),), kp=1., ki=0.2, kd=0.)

```



%% Cell type:code id: tags:



``` python

pfan, pchi, act, rewards, temp = [], [], [], [], []



# run multiple trials over same period for stochastic policy

for trial in trange(1, leave=False):

    state = esb.reset(external=ext, state0=dfs_in[seqidx].iloc[0, 1:].values)

    agent = agent_fn()

    done = False

    pfan.append([])

    pchi.append([])

    act.append([])

    rewards.append([])

    temp.append([])

    while not done:

        action = agent.predict(state)[0]

        state, reward, done, info = esb.step(action)

        act[-1].append(action)

        # pfan[-1].append(info.get('powfans'))

        pchi[-1].append(info.get('powchi'))

        rewards[-1].append(reward)

        temp[-1].append(info.get('tempcondin'))



# get std_dev and mean of metrics

# std_pfan = np.std(pfan, axis=0, keepdims=False)

std_pchi = np.std(pchi, axis=0, keepdims=False)

std_act = np.std(act, axis=0, keepdims=False)

std_rewards = np.std(rewards, axis=0, keepdims=False)

std_temp = np.std(temp, axis=0, keepdims=False)



# pfan = np.mean(pfan, axis=0, keepdims=False)

pchi = np.mean(pchi, axis=0, keepdims=False)

act = np.mean(act, axis=0, keepdims=False)

rewards = np.mean(rewards, axis=0, keepdims=False)

temp = np.mean(temp, axis=0, keepdims=False)

```



%% Cell type:code id: tags:



``` python

plt.figure(figsize=(8,12))

# plt.subplot(4,1,1)

# plt.title('Fan Power (Average RL {:.0f}W vs Historical {:.0f}W)'\

#           .format(np.mean(pfan), np.mean(pow_hist_fan)))

# plt.plot(pfan, 'b:', label='RL.Fan')

# plt.fill_between(np.arange(len(pfan)), pfan+std_pfan, pfan-std_pfan, color='b', alpha=0.3)

# plt.plot(pow_hist_fan, 'r:', label='Historical.Fan')

# plt.ylim(bottom=0)

# plt.legend()



plt.subplot(3,1,1)

plt.title('Chiller Power (Average {:.0f}kW vs Historical {:.0f}kW)'\

          .format(np.mean(pchi), np.mean(pow_hist_chi)))

plt.plot(pchi, 'b:', label='Chiller')

plt.fill_between(np.arange(len(pchi)), pchi+std_pchi, pchi-std_pchi, color='b', alpha=0.3)

plt.plot(pow_hist_chi, 'r:', label='Historical.Chiller')

plt.ylim(bottom=0)

plt.legend()



plt.subplot(3,1,2)

plt.title('Setpoint Control (Average {:.2f} vs Historical {:.2f})'\

          .format(np.mean(act[:, 0]), np.mean(act_hist[:, 0])))

plt.plot(ext['TempAmbient'].values, 'g.', label='TempAmbient')

plt.plot(ext['TempWetBulb'].values, 'c.', label='TempWetBulb')

plt.plot(act[:, 0], 'b:', label='Setpoint')

plt.fill_between(np.arange(len(act[:, 0])), act[:, 0]+std_act[:, 0], act[:, 0]-std_act[:, 0], color='b', alpha=0.3)

plt.plot(act_hist[:, 0], 'r:', label='Historical.Setpoint')

# plt.ylim(top=1.05)

plt.legend()





plt.subplot(3,1,3)

plt.title('Output Temperature (Average {:.1f}F vs Historical {:.1f}F)'\

          .format(np.mean(temp), np.mean(temp_hist)))

plt.plot(temp, 'b:', label='Temp')

plt.fill_between(np.arange(len(temp)), temp+std_temp, temp-std_temp, color='b', alpha=0.3)

plt.plot(temp_hist, 'r:', label='Historical.Temp')

plt.legend()



plt.tight_layout()

```



%% Cell type:code id: tags:



``` python

plt.figure(figsize=(8,3))

plt.plot(dfs_in[seqidx]['TempAmbient'].values, label='Ambient Temp')

plt.plot(dfs_in[seqidx]['TempWetBulb'].values, label='WetBulb Temp')

plt.legend()

plt.ylabel('Temperature /F')

plt.title('Environmental Conditions')

plt.tight_layout()

plt.show()

```

src/baseline_control.py

+12 −4
Changes for src/baseline_control.py: 12 added lines, 4 removed lines.
Original line number Diff line number Diff line
@@ -190,13 +190,21 @@ class SimpleFeedbackController(BaseEstimator): 
            self._actions.append(action)

            step_action = self._actions[-1] - self._actions[-min(2, len(self._actions))]

        else:

            # [a|f]_[1|2] is actions and feedbacks at relative times 1, 2 i.e. first, second

            a_2, a_1 = self._actions[-1], self._actions[-2]

            f_2, f_1 = self._feedbacks[-1], self._feedbacks[-2]

            dir_a = np.random.choice([-1, 1]) if np.sign(a_1-a_2) == 0 else np.sign(a_1-a_2)

            dir_f = np.sign(f_1 - f_2)

            # What was the direction of change in action from the last 2 steps?

            dir_a = np.random.choice([-1, 1]) if np.sign(a_2 - a_1) == 0 else np.sign(a_2 - a_1)

            # What was the direction of change in feedback from the last 2 steps?

            dir_f = np.sign(f_2 - f_1)

            # Feedback dir, action dir, step action

            #       -           -           +

            #       -           +           -

            #       +           -           -

            #       +           +           +

            step_action = self.stepsize * dir_a * dir_f

            a_0 = a_1 + step_action

            action = self.clip_action(a_0, X)

            action = a_2 + step_action

            action = self.clip_action(action, X)

            

            self._actions.append(action)

        # print('err: {:8.2f}, d_err: {:8.2f}, T: {:5.2f}, deltaT: {:5.2f}'\

src/controller.py

+18 −10
Changes for src/controller.py: 18 added lines, 10 removed lines.
Original line number Diff line number Diff line
@@ -71,6 +71,13 @@ def get_settings(parsed_args) -> dict: 
    for setting, value in cfg['DEFAULT'].items():

        # Only update settings which were not specified in the command line

        if (setting not in settings) or (settings.get(setting) is None):

            if setting in ('stepsize', 'window', 'interval'):

                settings[setting] = float(value)

            elif setting=='bounds':

                settings[setting] = np.asarray([tuple(map(float, value.split(',')))])

            elif setting=='target':

                settings[setting] = value.lower()

            else:

                settings[setting] = value

    for setting in ('output', 'logs'):

        if settings.get(setting) is None:
@@ -124,10 +131,10 @@ def get_controller(**settings) -> BaseEstimator: 
            u = super().clip_action(u, X)

            return np.clip(u, a_min=X['TempWetBulb'], a_max=None)



    stepsize, window = float(settings['stepsize']), float(settings['window'])

    setpoint_bounds = map(float, settings['bounds'].split(','))

    ctrl = Controller(bounds=(setpoint_bounds,), stepsize=stepsize, window=window,

                      target=str(settings['target']).lower())

    stepsize, window = settings['stepsize'], settings['window']

    setpoint_bounds = settings['bounds']

    ctrl = Controller(bounds=setpoint_bounds, stepsize=stepsize, window=window,

                      target=settings['target'])

    return ctrl
@@ -137,12 +144,13 @@ def update_controller(ctrl, **settings): 
    # ctrl.kp = kp

    # ctrl.ki = ki

    # ctrl.kd = kd

    stepsize, window = float(settings['stepsize']), float(settings['window'])

    setpoint_bounds = map(float, settings['bounds'].split(','))

    ctrl.stepsize = stepsize

    ctrl.window = window

    ctrl.bounds = np.asarray([setpoint_bounds])

    ctrl.target = str(settings['target']).lower()

    # type conversions now happen in `get_settings()`

    # stepsize, window = float(settings['stepsize']), float(settings['window'])

    # setpoint_bounds = tuple(map(float, settings['bounds'].split(',')))

    ctrl.stepsize = settings['stepsize']

    ctrl.window = settings['window']

    ctrl.bounds = settings['bounds']

    ctrl.target = settings['target']