Second

1095 분 소요

기본 설정

# jupyter notebook 너비 설정
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:90% !important; }</style>"))

import tensorflow as tf
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 그래프 제목 한글 깨짐 해결
import matplotlib

matplotlib.rcParams['font.family'] ='Malgun Gothic'

matplotlib.rcParams['axes.unicode_minus'] =False

# tensorflow에서 GPU 사용하기
import os
from tensorflow.python.client import device_lib

print(device_lib.list_local_devices())
print(tf.test.is_gpu_available())
os.environ["CUDA_VISIBLE_DEVICES"] = "0"

[name: "/device:CPU:0"
device_type: "CPU"
memory_limit: 268435456
locality {
}
incarnation: 5974342890069222965
xla_global_id: -1
, name: "/device:GPU:0"
device_type: "GPU"
memory_limit: 5738397696
locality {
  bus_id: 1
  links {
  }
}
incarnation: 12569557269926017584
physical_device_desc: "device: 0, name: NVIDIA GeForce RTX 3070, pci bus id: 0000:2b:00.0, compute capability: 8.6"
xla_global_id: 416903419
]
True

데이터 불러오기

import os

path = os.getcwd()

file_path = 'C:\\python\\K6\\데이터프레임 생성\\k6_sensor.csv'

raw_df = pd.read_csv(file_path)
raw_df.drop(list(raw_df.columns.values)[0], axis=1, inplace=True)

raw_df['Descr'] = pd.to_datetime(raw_df['Descr'])
raw_df

	Descr	K6 KILN SPEED 1	L6 #2 PAN CONVEYOR	K6 TEMP. INLET	K6 MAIN MOTOR	K6 AUX. COAL FD T/H	K6 MAIN COAL FEED	K6 RDF CFW FEED	K6 MEAL TOTAL T/H	K6 KHD 3CH DAMPER	...	K6 TIRE FEEDING	K6 WDF FLOW	K6 INLET O2	K6 INLET CO	K6 INLET NOX	K6 W.GAS O2	K6 W.GAS CO	K6 NOX	K6 CFW FLOW	K6 H FUEL T/H
0	2022-02-01 00:00:00	3.215802	49.699219	0.000000	438.391724	7.129625	8.081250	21.427252	326.356140	28.847181	...	0.32	-0.026685	NaN	NaN	NaN	NaN	NaN	NaN	0.000000	7.026337
1	2022-02-01 00:01:00	3.217230	52.148438	NaN	439.795532	7.129625	NaN	21.558632	332.204163	NaN	...	NaN	NaN	3.344396	0.684138	549.629944	6.509831	0.120576	257.265625	NaN	7.326008
2	2022-02-01 00:02:00	3.217230	48.574219	NaN	440.558472	7.138170	NaN	21.361029	325.871674	NaN	...	NaN	NaN	3.296712	0.529641	560.158691	6.444874	0.135604	242.265625	NaN	7.172744
3	2022-02-01 00:03:00	3.217230	48.339844	NaN	439.856567	7.129625	NaN	21.122835	328.233002	NaN	...	NaN	NaN	3.183795	0.635157	550.331909	6.265801	0.155056	156.328125	NaN	7.326008
4	2022-02-01 00:04:00	3.219867	51.339844	NaN	439.154663	7.129625	NaN	21.479057	327.489136	NaN	...	NaN	NaN	2.920195	0.752270	555.611511	6.154319	0.196278	64.765625	NaN	7.025762
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
215996	2022-06-30 23:56:00	2.901094	50.320312	31.805904	509.987061	1.121233	NaN	20.080339	282.616150	NaN	...	NaN	-0.011798	5.069047	0.452354	667.185486	6.135885	-0.026334	166.323334	8.010986	NaN
215997	2022-06-30 23:57:00	2.921419	46.945312	32.227055	474.555573	0.148623	NaN	20.225605	282.539856	NaN	...	NaN	-0.014607	4.965667	0.785916	674.692932	6.444874	-0.026334	155.046921	8.006409	NaN
215998	2022-06-30 23:58:00	2.907906	50.003906	NaN	536.324097	1.098955	NaN	20.252308	285.072876	NaN	...	NaN	NaN	4.937438	0.880369	703.349365	6.959270	-0.026334	185.488663	7.957153	NaN
215999	2022-06-30 23:59:00	2.907906	50.085938	33.142597	491.126892	1.113603	NaN	20.080339	285.545898	NaN	...	NaN	NaN	4.088655	1.374228	665.720581	7.287570	-0.021770	224.963760	7.993225	NaN
216000	2022-07-01 00:00:00	2.910707	49.523438	33.142597	487.342651	1.113603	5.546875	20.080339	283.768219	1.039139	...	0.32	-0.014607	4.324788	1.161288	621.957703	6.922402	NaN	239.627686	8.002197	7.827789

216001 rows × 35 columns

import pandas as pd
import datetime
import copy

def datetime_check(data):
    for idx, row in data.iterrows():
        if isinstance(row['Descr'], datetime.date):
            pass
        else:
            print('datetime_check fail !')
            return 
    print('datetime_check success !')

def numeric_check(data):
    '''
    numeric_check: 각 column에 numeric 형태로 변환이 안되는 값이 있으면 실행 중단... 
    '''
    data_columns = list(data.columns)
    data_columns.remove('Descr') 

    for col in data_columns:
        data[col] = pd.to_numeric(data[col], errors = 'raise')
    print('numeric_check success !')	

def fill_missing_value(data):

    data.fillna(method='ffill', inplace=True) 
    data.fillna(method='bfill', inplace=True) 

    return data

def replace_negative_to_zero(data):
    data[data.columns.difference(['Descr'])] = data[data.columns.difference(['Descr'])].clip(lower=0)
    return data

def eliminate_shutdown(data):

    # from 2022-04-12 00:01:00 to 2022-04-14 23:59:00
    shutdown_index = data[(data['Descr'] > datetime.datetime(2022,4,12))&(data['Descr'] < datetime.datetime(2022,4,15))].index
    
    # eliminate shutdown index
    data.drop(shutdown_index, axis=0, inplace=True)
    data.reset_index(drop=True, inplace=True)

    return data



def validation_check(data):
    '''
    data: df, 
    '''
    datetime_check(data)
    numeric_check(data)
    
    data = fill_missing_value(data)
    data = replace_negative_to_zero(data)
    data = eliminate_shutdown(data)
    
    return data

import datetime 

raw_df = validation_check(raw_df) # ********************
print('raw_df has nan',raw_df.isnull().values.any())

datetime_check success !
numeric_check success !
raw_df has nan False

데이터프레임 생성

import copy

n_size = raw_df.shape[0]
# n_size = 20000 # about 2 weeks data

df = raw_df.iloc[:n_size, ~raw_df.columns.isin(['Descr'])].copy()   
date_df = raw_df.loc[:n_size-1, ['Descr']]
date_df['Descr'] = pd.to_datetime(date_df['Descr'])

df['AVERAGE_INLET'] = (df['K6 TEMP.MAT.INLET E'] + df['K6 TEMP.MAT.INLET W']) / 2
# df['AVERAGE_INLET(5min)'] = df['AVERAGE_INLET'].shift(periods=-5)

df['pred'] = ((df['K6 MAIN COAL FEED'] + df['K6 AUX. COAL FD T/H'])*6 + (df['K6 RDF CFW FEED'] + df['K6 CFW FLOW'])*5 + df['K6 TIRE FEEDING']*9 + df['K6 WDF FLOW']*10 - df['K6 H FUEL T/H']*3.43)/2 + 775
# pred = df[['pred']]
# pred = pred.shift(periods=5)
# df['pred(5min)'] = pred['pred']

df['residual'] = df['AVERAGE_INLET'] - df['pred']
# df['RESIDUAL(5min)'] = df['AVERAGE_INLET'] - df['pred(5min)']

prediction = df[[‘pred’]] prediction[‘pred(t-1)’] = prediction[‘pred’].shift(periods=-1) prediction[‘AVERAGE_INLET’] = df[‘AVERAGE_INLET’] prediction[‘residual’] = prediction[‘AVERAGE_INLET’] - prediction[‘pred’] prediction[‘residual(t-1)’] = prediction[‘residual’].shift(periods=1) predictionprediction[‘new_pred’] = prediction[‘pred’] + prediction[‘residual(t-1)’]

s = 0 e = 100000

plt.figure(figsize=(30,5)) plt.plot(prediction[‘AVERAGE_INLET’][s:e]) plt.plot((prediction[‘pred’] + prediction[‘residual(t-1)’]* 0.5)[s:e])prediction[‘new’] = prediction[‘pred’] + prediction[‘residual(t-1)’]* 0.5 (prediction[‘new’] - prediction[‘AVERAGE_INLET’]).min()

모듈

def get_linear_prediction(data):
    w_coal = 6.000  # 유연탄  투입량 계수
    w_rdf = 5.000   # 폐합성수지
    w_tire = 9.000  # 폐타이어
    w_wdf = 10.000  # 폐유
    w_hfuel = -3.430 # 하수슬러지

    MAIN = 'K6 MAIN COAL FEED'        # 메인연료 column
    AUX = 'K6 AUX. COAL FD T/H'
    MRDF = 'K6 CFW FLOW'
    PRDF = 'K6 RDF CFW FEED'
    TIRE = 'K6 TIRE FEEDING'
    WDF = 'K6 WDF FLOW'
    HFUEL = 'K6 H FUEL T/H'
    BIAS = 775

    pred = (w_coal * (data[MAIN] + data[AUX]) + w_rdf * (data[MRDF] + data[PRDF])+ w_tire * data[TIRE] + w_wdf * data[WDF] + w_hfuel * data[HFUEL])/2 + BIAS
    return pred

# def get_linear_prediction_for_control(data):
#     w_coal = 6.000  # 유연탄  투입량 계수
#     w_rdf = 5.000   # 폐합성수지
#     w_tire = 9.000  # 폐타이어
#     w_wdf = 10.000  # 폐유
#     w_hfuel = -3.430 # 하수슬러지

#     MAIN = 'K6 MAIN COAL FEED'        # 메인연료 column
#     AUX = 'K6 AUX. COAL FD T/H'
#     MRDF = 'K6 CFW FLOW'
#     PRDF = 'K6 RDF CFW FEED'
#     TIRE = 'K6 TIRE FEEDING'
#     WDF = 'K6 WDF FLOW'
#     HFUEL = 'K6 H FUEL T/H'
#     BIAS = 775

#     pred = (w_coal * (data[MAIN] + data[AUX]) + w_rdf * (data[MRDF] + data[PRDF])+ w_tire * data[TIRE] + w_wdf * data[WDF] + w_hfuel * data[HFUEL]) + BIAS
#     return pred

df['pred'] = ((df['K6 MAIN COAL FEED'] + df['K6 AUX. COAL FD T/H'])*6 + (df['K6 RDF CFW FEED'] + df['K6 CFW FLOW'])*5 + df['K6 TIRE FEEDING']*9 + df['K6 WDF FLOW']*10 + df['K6 H FUEL T/H']*3.43)/2 + 750
# df['pred_control'] = ((df['K6 MAIN COAL FEED'] + df['K6 AUX. COAL FD T/H'])*6 + (df['K6 RDF CFW FEED'] + df['K6 CFW FLOW'])*5 + df['K6 TIRE FEEDING']*9 + df['K6 WDF FLOW']*10 + df['K6 H FUEL T/H']*3.43) + 625


plt.figure(figsize=(30,5))
plt.plot(df['AVERAGE_INLET'])
plt.plot(df['pred'])

# plt.figure(figsize=(30,5))
# plt.plot(df['AVERAGE_INLET'])
# plt.plot(df['pred_control'])

[<matplotlib.lines.Line2D at 0x2080e516f40>]

png

s = 0
e = s + 1000
plt.figure(figsize=(30,5))
plt.plot(df['AVERAGE_INLET'][s:e])
plt.plot((df['pred'] + df['residual'])[s:e])

[<matplotlib.lines.Line2D at 0x2092aa41280>]

png

PID

idx = 1000

df.loc[idx,'K6 MAIN COAL FEED']

6.04062557220459

import numpy as np
import matplotlib.pyplot as plt

def func(x):
#     return 10 * x # + np.random.randn(1)[0]
    return ((df.loc[idx,'K6 MAIN COAL FEED'] + df.loc[idx,'K6 AUX. COAL FD T/H'])*6 + (x + df.loc[idx,'K6 CFW FLOW'])*5 + df.loc[idx,'K6 TIRE FEEDING']*9 + df.loc[idx,'K6 WDF FLOW']*10 + df.loc[idx,'K6 H FUEL T/H']*3.43)/2 + 750

def P_control(Kp, MV_bar=0):
    """
    Kp     : error coef
    MV_bar : init X
    """
    MV = MV_bar
    
    while True:
        t, PV, SP = yield MV
        e = SP - PV
        P = Kp * e
        MV = MV_bar + P
        
def PI_control(Kp, Ki, MV_bar=0):
    e_prev = 0
    t_prev = 0
    I = 0
    
    MV = MV_bar
    
    while True:
        t, PV, SP = yield MV
        e = SP - PV
        P = Kp * e
        I = I + Ki*e*(t - t_prev)
        MV = MV_bar + P + I
        t_prev = t
        
def PID_control(Kp, Ki, Kd, MV_bar=0):
    e_prev = 0
    t_prev = -100
    I = 0
    
    MV = MV_bar
    
    while True:
        t, PV, SP = yield MV
        e = SP - PV
        P = Kp * e
        I = I + Ki*e*(t - t_prev)
        D = Kd*(e - e_prev)/(t - t_prev)
        MV = MV_bar + P + I + D
        
        e_prev = e
        t_prev = t

P control

controller = P_control(0.2, df.loc[idx, 'K6 RDF CFW FEED'])    # create pid control
print(controller)

print(df.loc[idx, 'K6 RDF CFW FEED'])
controller.send(None)              # initialize

MV = [df.loc[idx, 'K6 RDF CFW FEED']]
PV = []
SP = 875

PV.append(func(MV[-1]))
print((SP - PV[-1])*0.2)
controller.send([idx, PV[-1], SP])

<generator object P_control at 0x00000208BD33B3C0>
0476837158203
0687816348076016

116465350627898

controller = P_control(0.3, df.loc[idx, 'K6 RDF CFW FEED'])    # create pid control
controller.send(None)              # initialize

SP = 875 # 40
MV = [df.loc[idx, 'K6 RDF CFW FEED']]
PV = []

for i in range(100):
    PV.append(func(MV[-1]))
    MV.append(controller.send([i, PV[-1], SP]))
    
plt.figure(figsize=[14,5])
plt.title('P control (Kp = 0.3)')
plt.hlines(SP, 0, 100, label='SP', color='red')
plt.plot(PV, label='PV')
plt.legend()
plt.grid()
plt.show()

plt.figure(figsize=[14,5])
plt.title('MV')
plt.plot(MV, label='MV')
plt.legend()
plt.grid()
plt.show()

png

PI control

controller = PI_control(0.3, 0.01, df.loc[idx, 'K6 RDF CFW FEED'])    # create pid control
controller.send(None)                     # initialize

SP = 875
MV = [df.loc[idx, 'K6 RDF CFW FEED']]
PV = []

for i in range(300):
    PV.append(func(MV[-1]))
    MV.append(controller.send([i, PV[-1], SP]))
    
plt.figure(figsize=[14,5])
plt.title('PI control')
plt.hlines(SP, 0, 300, label='SP', color='red')
plt.plot(PV, label='PV')
plt.legend()
plt.grid()
plt.show()

plt.figure(figsize=[14,5])
plt.title('MV')
plt.plot(MV, label='MV')
plt.legend()
plt.grid()
plt.show()

png

PID control - 1

def PID_control(Kp, Ki, Kd, MV_bar=0):
    e_prev = 0
    t_prev = -100
    I = 0
    
    MV = MV_bar
    
    while True:
        t, PV, SP = yield MV
        e = SP - PV
        P = Kp * e
        I = I + Ki*e*(t - t_prev)
        D = Kd*(e - e_prev)/(t - t_prev)
        MV = MV_bar + P + I + D
        print(MV)
        e_prev = e
        t_prev = t

Kp = 0.3
Ki = 0.01 /2 /2 /2 /2
Kd = 0.001 #*2

controller = PID_control(Kp, Ki, Kd, df.loc[idx, 'K6 RDF CFW FEED'])    # create pid control
controller.send(None)                     # initialize

SP = 875
MV = [df.loc[idx, 'K6 RDF CFW FEED']]
print("real MV ", MV)
# PV = []
PV = 860
for i in range(10):
#     PV.append(func(MV[-1]))
    MV.append(controller.send([i, PV, SP]))
    
plt.figure(figsize=[14,5])
plt.title('PID control')
plt.hlines(SP, 0, 100, label='SP', color='red')
plt.plot(PV, label='PV')
plt.legend()
plt.grid()
plt.show()

real MV  [18.0476837158203]
4853337158203
494558715820297
5039337158203
513308715820298
5226837158203
5320587158203
541433715820297
5508087158203
560183715820298
5695587158203

png

print(len(MV))
print(len(PV))

101
100

MV[-1]

25.437626442624406

func(MV[-2])

878.1760432774804

PV[-1]

878.1760432774804

- rdf

import numpy as np
import matplotlib.pyplot as plt

def func(rdf_x):
    return ((df.loc[idx,'K6 MAIN COAL FEED'] + df.loc[idx,'K6 AUX. COAL FD T/H'])*6 + (rdf_x)*5 + df.loc[idx,'K6 TIRE FEEDING']*9 + df.loc[idx,'K6 WDF FLOW']*10 + df.loc[idx,'K6 H FUEL T/H']*3.43)/2 + 750

idx = 114000  # 114000

Kp = 0.3
Ki = 0.01 #/2 /2 /2 /2
Kd = 0.001 #*2

initial_rdf = df.loc[idx, 'K6 RDF CFW FEED'] + df.loc[idx, 'K6 CFW FLOW']
controller = PID_control(Kp, Ki, Kd, initial_rdf)    # create pid control
controller.send(None)                     # initialize

SP = 875
MV_RDF = [df.loc[idx, 'K6 RDF CFW FEED'] + df.loc[idx, 'K6 CFW FLOW']]
PV = []

res = 5
THRESHOLD = 5

for i in range(100):
    # current X --> predict
    PV.append(func(MV_RDF[-1]) + res)
    
    # residual = PV - SP 
    residual = func(MV_RDF[-1]) + res - SP

    MV_RDF.append(controller.send([i, PV[-1], SP]))

    
plt.figure(figsize=[14,5])
plt.title('PID control')
plt.hlines(SP, 0, 100, label='SP', color='red', linestyle='dashed')
plt.plot(PV, label='PV')
plt.legend()
plt.grid()
# plt.ylim(850,900)
plt.show()


plt.figure(figsize=[14,5])
plt.title('MV RDF')
plt.plot(MV_RDF, label='MV_RDF')
plt.legend()
plt.grid()
plt.show()

-12.092657978489154
124985261464296
-4.062775826111633
520143325043977
7775391069563878
34538303027332
739604820677331
595397841691701
594529630814155
679474630283755
795579910900642
250548980964613
60922672342096
104743905814235
192160751776134
122329778353444
63655331251212
23302712181339
99665589010629
39561545823853
304432497685857
58594969098197
578746732352757
7899175123977
830760984209409
999300603018034
067109562470643
209342359469881
29176357214186
417318531297186
507126943284115
621697256081802
714680614331506
821645476674364
915361168242164
016738922289251
109783407542542
206791720588024
298371212221774
391756314246503
481434494847854
571664693331273
659214476092739
7465939071607
831910341061974
916645843604423
999694951937927
081935391876929
162724127798787
242583530924517
321142142641134
398713311268223
47508499962597
550447536069717
624682397216993
69790743961641
770058925375352
841211950815424
911334808117827
980477299360452
048626378361673
115816822184382
182046394352733
247340886548823
311704261939996
37515688064218
43770620049325
499369242841805
560155374705138
620079512718275
679152005377134
73738639386398
794793466914731
851385822744422
907174376098666
962171040188744
016386674841662
069832663556596
122519708548346
174458758452204
22566030105276
27613490934631
3258928267303
374944288753383
423299280157677
470967724779127
517959343562552
564283766952558
609950452226787
654968750312783
699347857960474
743096857753844
786224690736635
828740180650211
870652018558506
911968777795366
952698905621563
992850732691956
032432468825792
071452209234135

png

idx = 114000  # 114000

initial_rdf = df.loc[idx, 'K6 RDF CFW FEED'] + df.loc[idx, 'K6 CFW FLOW']
controller = PID_control(0.3, 0.01, 0.001, initial_rdf)    # create pid control
controller.send(None)                     # initialize

SP = 875
MV_RDF = [initial_rdf]
PV = []

res = 5
THRESHOLD = 5

for i in range(100):
    # current X --> predict
    PV.append(func(MV_RDF[-1]))
    
    # residual = PV - SP 
    residual = PV[-1]  - SP
    if np.abs(residual) < THRESHOLD:
        break
    MV_RDF.append(controller.send([i, PV[-1], SP]))

    
plt.figure(figsize=[14,5])
plt.title('PID control')
plt.hlines(SP, 0, 100, label='SP', color='red', linestyle='dashed')
plt.plot(PV, label='PV')
plt.legend()
plt.grid()
# plt.ylim(850,900)
plt.show()


plt.figure(figsize=[14,5])
plt.title('MV RDF')
plt.plot(MV_RDF, label='MV_RDF')
plt.hlines(MV_RDF[-1], 0, 100, label='SP', color='white', linestyle='dashed')
plt.legend()
plt.grid()
plt.show()

png

idx = 114000  # 114000


controller = PID_control(0.3, 0.01, 0.001, df.loc[idx, 'K6 RDF CFW FEED'])    # create pid control
controller.send(None)                     # initialize

SP = 875
MV = [df.loc[idx, 'K6 RDF CFW FEED']]
PV = []

for i in range(100):
    PV.append(func(MV[-1]))
    MV.append(controller.send([i, PV[-1], SP]))
    
plt.figure(figsize=[14,5])
plt.title('PID control')
plt.hlines(SP, 0, 100, label='SP', color='red')
plt.plot(PV, label='PV')
plt.legend()
plt.grid()
plt.show()

png

- prdf, mrdf

import numpy as np
import matplotlib.pyplot as plt

def func(prdf_x, mrdf_x):
    return ((df.loc[idx,'K6 MAIN COAL FEED'] + df.loc[idx,'K6 AUX. COAL FD T/H'])*6 + (prdf_x + mrdf_x)*5 + df.loc[idx,'K6 TIRE FEEDING']*9 + df.loc[idx,'K6 WDF FLOW']*10 + df.loc[idx,'K6 H FUEL T/H']*3.43)/2 + 750

import random

idx = random.randint(0,216000) # 114000

initial_rdf = df.loc[idx, 'K6 RDF CFW FEED'] + df.loc[idx, 'K6 CFW FLOW']
controller = PID_control(0.3, 0.01, 0.001, initial_rdf)    # create pid control
controller.send(None)                     # initialize

SP = 875
MV_PRDF = [df.loc[idx, 'K6 RDF CFW FEED']]
MV_MRDF = [df.loc[idx, 'K6 CFW FLOW']]
PV = []

res = 5
THRESHOLD = 5

for i in range(100):
    # current X --> predict
    PV.append(func(MV_PRDF[-1], MV_MRDF[-1]) + res)
    
    # residual = PV - SP 
    residual = func(MV_PRDF[-1], MV_MRDF[-1]) + res - SP

    rate_prdf = MV_PRDF[-1] / (MV_PRDF[-1] + MV_MRDF[-1]) 
    rate_mrdf = MV_MRDF[-1] / (MV_PRDF[-1] + MV_MRDF[-1])
    
    MV_RDF = controller.send([i, PV[-1], SP])

    MV_PRDF.append(MV_RDF * rate_prdf)
    MV_MRDF.append(MV_RDF * rate_mrdf)

    
plt.figure(figsize=[14,5])
plt.title('PID control')
plt.hlines(SP, 0, 100, label='SP', color='red', linestyle='dashed')
plt.plot(PV, label='PV')
plt.legend()
plt.grid()
# plt.ylim(850,900)
plt.show()

plt.figure(figsize=[14,5])
plt.title('MV RDF')
plt.plot(MV_PRDF, label='MV_PRDF')
plt.plot(MV_MRDF, label='MV_MRDF')
plt.legend()
plt.grid()
plt.show()

png

- main, aux

import numpy as np
import matplotlib.pyplot as plt

def func(main_x, aux_x):
    return ((main_x + aux_x)*6 + (df.loc[idx, 'K6 RDF CFW FEED'] + df.loc[idx, 'K6 CFW FLOW'])*5 + df.loc[idx,'K6 TIRE FEEDING']*9 + df.loc[idx,'K6 WDF FLOW']*10 + df.loc[idx,'K6 H FUEL T/H']*3.43)/2 + 750

import random

idx = 189829 # random.randint(0,216000) # 114000

Kp = 0.3
Ki = 0.01 /2 /2 /2
Kd = 0.001 *2


initial_coal = df.loc[idx, 'K6 MAIN COAL FEED'] + df.loc[idx, 'K6 AUX. COAL FD T/H']
controller = PID_control(Kp, Ki, Kd, initial_coal)    # create pid control
controller.send(None)                     # initialize

SP = 875
MV_MAIN = [df.loc[idx, 'K6 MAIN COAL FEED']]
MV_AUX  = [df.loc[idx, 'K6 AUX. COAL FD T/H']]
PV = []

res = 5
THRESHOLD = 5

for i in range(100):
    # current X --> predict
    PV.append(func(MV_MAIN[-1], MV_AUX[-1]) + res)
    
    # residual = PV - SP 
    residual = func(MV_MAIN[-1], MV_AUX[-1]) + res - SP

    rate_main = MV_MAIN[-1] / (MV_MAIN[-1] + MV_AUX[-1]) 
    rate_aux  = MV_AUX[-1]  / (MV_MAIN[-1] + MV_AUX[-1])
    
    MV_COAL = controller.send([i, PV[-1], SP])

    MV_MAIN.append(MV_COAL * rate_main)
    MV_AUX.append(MV_COAL * rate_aux)

    
plt.figure(figsize=[14,5])
plt.title('PID control')
plt.hlines(SP, 0, 100, label='SP', color='red', linestyle='dashed')
plt.plot(PV, label='PV')
plt.legend()
plt.grid()
# plt.ylim(850,900)
plt.show()

plt.figure(figsize=[14,5])
plt.title('MV COAL')
plt.plot(MV_MAIN, label='MV_MAIN')
plt.plot(MV_AUX, label='MV_AUX')
plt.legend()
plt.grid()
plt.show()

png

PID control - 2

def PID_control_2(Kp, Ki, Kd, MV_AUX_bar=0, MV_RDF_bar=0):
    e_prev = 0
    t_prev = -100
    I = 0
    
    MV_AUX = MV_AUX_bar
    MV_RDF = MV_RDF_bar
    
    while True:
        t, PV, SP = yield MV_AUX, MV_RDF
        e = SP - PV
        P = Kp * e
        I = I + Ki*e*(t - t_prev)
        D = Kd*(e - e_prev)/(t - t_prev)
        if e > 0:
            MV_RDF = MV_RDF_bar + P + I + D
#             MV_AUX = MV_AUX
        else:
            MV_AUX = MV_AUX_bar + P + I + D
#             MV_RDF = MV_RDF
        e_prev = e
        t_prev = t

- aux, prdf

import numpy as np
import matplotlib.pyplot as plt

def func(aux_x, prdf_x):
#     return 10 * x # + np.random.randn(1)[0]
    return ((df.loc[idx,'K6 MAIN COAL FEED'] + aux_x)*6 + (prdf_x + df.loc[idx,'K6 CFW FLOW'])*5 + df.loc[idx,'K6 TIRE FEEDING']*9 + df.loc[idx,'K6 WDF FLOW']*10 + df.loc[idx,'K6 H FUEL T/H']*3.43)/2 + 750

print(idx)

import random

idx =  random.randint(0,216000) # 154902  # 114000

Kp = 0.3
Ki = 0.01 /2 /2
Kd = 0.001 

controller = PID_control_2(Kp, Ki, Kd, df.loc[idx, 'K6 AUX. COAL FD T/H'], df.loc[idx, 'K6 RDF CFW FEED'])    # create pid control
controller.send(None)                     # initialize

SP = 875
MV_AUX = [df.loc[idx, 'K6 AUX. COAL FD T/H']]
MV_PRDF = [df.loc[idx, 'K6 RDF CFW FEED']]
PV = []

res = 5
THRESHOLD = 25

for i in range(100):
    PV.append(func(MV_AUX[-1], MV_PRDF[-1]))

    aux,  rdf = controller.send([i, PV[-1], SP])
    MV_AUX.append(aux)
    MV_PRDF.append(rdf)

    
plt.figure(figsize=[14,5])
plt.title('PID control')
plt.hlines(SP, 0, 100, label='SP', color='red', linestyle='dashed')
plt.hlines(SP-THRESHOLD, 0, 100, label='LOW BOUND', color='gray', linestyle='dashed')
plt.hlines(SP+THRESHOLD, 0, 100, label='UPPER BOUND', color='gray', linestyle='dashed')
plt.plot(PV, label='PV')
plt.legend()
plt.grid()
# plt.ylim(850,900)
plt.show()


plt.figure(figsize=[14,5])
plt.title('MV AUX')
plt.plot(MV_AUX, label='MV_AUX')
plt.plot(MV_PRDF, label='MV_RDF')
plt.legend()
plt.grid()
plt.show()

png

- main, aux, prdf, mrdf

def PID_control_4(Kp, Ki, Kd, MV_COAL_bar=0, MV_RDF_bar=0):
    e_prev = 0
    t_prev = -100
    I = 0
    
    MV_COAL = MV_COAL_bar
    MV_RDF  = MV_RDF_bar
    
    while True:
        t, PV, SP = yield MV_COAL, MV_RDF
        e = SP - PV
        P = Kp * e
        I = I + Ki*e*(t - t_prev)
        D = Kd*(e - e_prev)/(t - t_prev)
        if e < 0:
            MV_COAL = MV_COAL_bar + P + I + D
        elif e > 0 and MV_RDF == 0: 
            MV_COAL = MV_COAL_bar + P + I + D
        else:
            MV_RDF = MV_RDF_bar + P + I + D
        e_prev = e
        t_prev = t

import numpy as np
import matplotlib.pyplot as plt

def func(main_x, aux_x, prdf_x, mrdf_x):
#     return 10 * x # + np.random.randn(1)[0]
    return ((main_x + aux_x)*6 + (prdf_x + mrdf_x)*5 + df.loc[idx,'K6 TIRE FEEDING']*9 + df.loc[idx,'K6 WDF FLOW']*10 + df.loc[idx,'K6 H FUEL T/H']*3.43)/2 + 750

print(idx)
print(df.loc[idx, 'K6 MAIN COAL FEED'])
print(df.loc[idx, 'K6 AUX. COAL FD T/H'])
print(df.loc[idx, 'K6 RDF CFW FEED'])
print(df.loc[idx, 'K6 CFW FLOW'])

47243
95937538146973
10658431053162
8003349304199
00640869140625

# main, aux 모두 0인 구간이 존재하는가?
for idx in range(len(df)):
    if (df.loc[idx, 'K6 MAIN COAL FEED'] + df.loc[idx, 'K6 AUX. COAL FD T/H']) == 0:
        print('zero')
# --> 없음 

df.shape[0]

print(idx)

import random

# 운전점
idx = 47243 #40923 #202559 # 55677#26614# random.randint(0,216000)#  172406   # 10001 # 33046 # 189829  #168030 # 154902  # 114000
# idx = random.randint(0,df.shape[0])
print(idx)

# 하이퍼파라미터
Kp = 0.3 
Ki = 0.01 /2 /2 /2 #/2 
Kd = 0.001 

# 초기 설정 
initial_coal = df.loc[idx, 'K6 MAIN COAL FEED'] + df.loc[idx, 'K6 AUX. COAL FD T/H']
initial_rdf  = df.loc[idx, 'K6 RDF CFW FEED']   + df.loc[idx, 'K6 CFW FLOW']
controller = PID_control_4(Kp, Ki, Kd, initial_coal, initial_rdf)    # create pid control
controller.send(None)                     # initialize

# 변하는 투입량 저장할 리스트 
SP = 920 #875
MV_MAIN = [df.loc[idx, 'K6 MAIN COAL FEED']]
MV_AUX  = [df.loc[idx, 'K6 AUX. COAL FD T/H']]
MV_PRDF = [df.loc[idx, 'K6 RDF CFW FEED']]
MV_MRDF = [df.loc[idx, 'K6 CFW FLOW']]
PV = []


THRESHOLD = 5
PV.append(func(MV_MAIN[-1], MV_AUX[-1], MV_PRDF[-1], MV_MRDF[-1]))
# pv = func(MV_MAIN[-1], MV_AUX[-1], MV_PRDF[-1], MV_MRDF[-1])
residual = np.abs(PV[-1] - SP)
print('-------------before control----------------')
# print(MV_MAIN[-1])
# print(MV_AUX[-1])
# print(MV_PRDF[-1])
# print(MV_MRDF[-1])
print(SP-THRESHOLD, '<', PV[-1], '<', SP+THRESHOLD)
# print(PV[-1])
        
if residual < THRESHOLD:
    pass
    # return mv[-1], pv ... 
else:
#     while residual > THRESHOLD:
#         residual -= 1
#         print(residual)

    for i in range(100):
        residual = np.abs(PV[-1] - SP)
        if residual < THRESHOLD:
            break

        # control... 
        MV_COAL, MV_RDF = controller.send([i, PV[-1], SP])
        
        if MV_COAL <0 or MV_RDF < 0 :
            break
        if (MV_MAIN[-1] + MV_AUX[-1]) == 0:
            rate_main = 0
            rate_aux  = 0
        else:
            rate_main = MV_MAIN[-1] / (MV_MAIN[-1] + MV_AUX[-1])
            rate_aux  = MV_AUX[-1]  / (MV_MAIN[-1] + MV_AUX[-1])
        if (MV_PRDF[-1] + MV_MRDF[-1]) == 0: 
            rate_prdf = 0
            rate_mrdf = 0
        else:
            rate_prdf = MV_PRDF[-1] / (MV_PRDF[-1] + MV_MRDF[-1])
            rate_mrdf = MV_MRDF[-1] / (MV_PRDF[-1] + MV_MRDF[-1])

        MV_MAIN.append(MV_COAL * rate_main)
        MV_AUX.append(MV_COAL * rate_aux)
        MV_PRDF.append(MV_RDF * rate_prdf)
        MV_MRDF.append(MV_RDF * rate_mrdf)

        PV.append(func(MV_MAIN[-1], MV_AUX[-1], MV_PRDF[-1], MV_MRDF[-1]))
        residual = np.abs(PV[-1] - SP)
#         print('-------------new mv, pv----------------')

print('-----------after control----------')
print(PV[-1])
print(MV_MAIN[-1])



plt.figure(figsize=[14,5])
plt.title('PID control')
plt.hlines(SP, 0, 100, label='SP', color='red', linestyle='dashed')
plt.hlines(SP-THRESHOLD, 0, 100, label='LOW BOUND', color='gray', linestyle='dashed')
plt.hlines(SP+THRESHOLD, 0, 100, label='UPPER BOUND', color='gray', linestyle='dashed')
plt.plot(PV, label='PV')
plt.legend(loc='upper right')
plt.grid()
# plt.ylim(850,900)
plt.show()


plt.figure(figsize=[14,5])
plt.title('MV_')
plt.plot(MV_MAIN, label='MV_MAIN', color='red')
plt.plot(MV_AUX,  label='MV_AUX', color='orange')
plt.plot(MV_PRDF, label='MV_PRDF')
plt.plot(MV_MRDF, label='MV_MRDF', color='green')
plt.hlines(0, 0, 100, label='LOW BOUND', color='gray', linestyle='dashed')
plt.legend(loc='upper right')
plt.grid()
plt.show()

47243
-------------before control----------------
915 < 882.3637194013595 < 925
-----------after control----------
922.3532084444299
5.95937538146973

png

–> NO WHILE

import random

# 운전점
# idx = 47243 #40923 #202559 # 55677#26614# random.randint(0,216000)#  172406   # 10001 # 33046 # 189829  #168030 # 154902  # 114000
idx = random.randint(0,df.shape[0])
print(idx)

# 하이퍼파라미터
Kp = 0.3 
Ki = 0.01 /2 /2 /2 
Kd = 0.001 

# 초기 설정 
initial_coal = df.loc[idx, 'K6 MAIN COAL FEED'] + df.loc[idx, 'K6 AUX. COAL FD T/H']
initial_rdf  = df.loc[idx, 'K6 RDF CFW FEED']   + df.loc[idx, 'K6 CFW FLOW']
controller = PID_control_4(Kp, Ki, Kd, initial_coal, initial_rdf)    # create pid control
controller.send(None)                     # initialize

# 변하는 투입량 저장할 리스트 
SP = 920 #875
MV_MAIN = [df.loc[idx, 'K6 MAIN COAL FEED']]
MV_AUX  = [df.loc[idx, 'K6 AUX. COAL FD T/H']]
MV_PRDF = [df.loc[idx, 'K6 RDF CFW FEED']]
MV_MRDF = [df.loc[idx, 'K6 CFW FLOW']]
PV = []


THRESHOLD = 5
PV.append(func(MV_MAIN[-1], MV_AUX[-1], MV_PRDF[-1], MV_MRDF[-1]))
# pv = func(MV_MAIN[-1], MV_AUX[-1], MV_PRDF[-1], MV_MRDF[-1])
residual = np.abs(PV[-1] - SP)
print('-------------before control----------------')
# print(MV_MAIN[-1])
# print(MV_AUX[-1])
# print(MV_PRDF[-1])
# print(MV_MRDF[-1])
print(SP-THRESHOLD, '<', PV[-1], '<', SP+THRESHOLD)
# print(PV[-1])
        
if residual < THRESHOLD:
    pass
    # return mv[-1], pv ... 
else:
#     while residual > THRESHOLD:
#         residual -= 1
#         print(residual)

    for i in range(100):
        residual = np.abs(PV[-1] - SP)
#         if residual < THRESHOLD:
#             break

        # control... 
        MV_COAL, MV_RDF = controller.send([i, PV[-1], SP])
        
        if MV_COAL <0 or MV_RDF < 0 :
            break
        if (MV_MAIN[-1] + MV_AUX[-1]) == 0:
            rate_main = 0
            rate_aux  = 0
        else:
            rate_main = MV_MAIN[-1] / (MV_MAIN[-1] + MV_AUX[-1])
            rate_aux  = MV_AUX[-1]  / (MV_MAIN[-1] + MV_AUX[-1])
        if (MV_PRDF[-1] + MV_MRDF[-1]) == 0: 
            rate_prdf = 0
            rate_mrdf = 0
        else:
            rate_prdf = MV_PRDF[-1] / (MV_PRDF[-1] + MV_MRDF[-1])
            rate_mrdf = MV_MRDF[-1] / (MV_PRDF[-1] + MV_MRDF[-1])

        MV_MAIN.append(MV_COAL * rate_main)
        MV_AUX.append(MV_COAL * rate_aux)
        MV_PRDF.append(MV_RDF * rate_prdf)
        MV_MRDF.append(MV_RDF * rate_mrdf)

        PV.append(func(MV_MAIN[-1], MV_AUX[-1], MV_PRDF[-1], MV_MRDF[-1]))
        residual = np.abs(PV[-1] - SP)
#         print('-------------new mv, pv----------------')

print('-----------after control----------')
print(PV[-1])
print(MV_MAIN[-1])



plt.figure(figsize=[14,5])
plt.title('PID control')
plt.hlines(SP, 0, 100, label='SP', color='red', linestyle='dashed')
plt.hlines(SP-THRESHOLD, 0, 100, label='LOW BOUND', color='gray', linestyle='dashed')
plt.hlines(SP+THRESHOLD, 0, 100, label='UPPER BOUND', color='gray', linestyle='dashed')
plt.plot(PV, label='PV')
plt.legend(loc='upper right')
plt.grid()
# plt.ylim(850,900)
plt.show()


plt.figure(figsize=[14,5])
plt.title('MV_')
plt.plot(MV_MAIN, label='MV_MAIN', color='red')
plt.plot(MV_AUX,  label='MV_AUX', color='orange')
plt.plot(MV_PRDF, label='MV_PRDF')
plt.plot(MV_MRDF, label='MV_MRDF', color='green')
plt.hlines(0, 0, 100, label='LOW BOUND', color='gray', linestyle='dashed')
plt.legend(loc='upper right')
plt.grid()
plt.show()

181748
-------------before control----------------
915 < 868.5521341365576 < 925
-----------after control----------
929.7433969621195
10.884957732959272

png

9.922 * 6 + 14.194 * 6 + 5.096 * 5 + 1.02 * 9 + 7.326 * 3.43 + 750

954.4841799999999

print(PV)
print(MV_MAIN)

[]
[5.95937538146973]

(8.882812*6+5.618525*6+22.114595*5+0.52*9+4.60112+8.614501*3.43)/2+750

868.204927715

print(MV_MAIN[0])
print(MV_MAIN[-1])

6.00937557220459
2.209870787897471

(8.1125 * 6 + 5.1249 * 6 + 5.97372 * 5 + 22.194802 * 5 + 0.52 * 9 + 2.98736 * 10 + 8.83652 * 3.43)/2+750 - 890.876932

1.6880047999999306

print(len(MV_AUX))
print(len(MV_PRDF))
print(len(PV))

101
101
100

'''
- - - + linear Prediction
      MCOAL   AUXCOAL  MRDF       PRDF        TEMP      linear   residual
0  8.926562  5.124895   0.0  25.110704  864.158493  875.347403 -11.188910
1  9.252808  5.312198   0.0  29.352726  876.687111  887.493102 -10.805991
2  0.978736  0.561909   0.0  10.605053   12.528617   12.145699   0.382918
'''
result1 = pd.DataFrame()
result1['MCOAL'] = [8.926562, 9.252808, 0.978736]
result1['AUXCOAL'] = [5.124895, 5.312198, 0.561909]
result1['MRDF'] = [0.0, 0.0, 0.0]
result1['PRDF'] = [25.110704, 29.352726, 10.605053]
result1['TEMP'] = [864.158493, 876.687111, 12.528617]
result1['linear'] = [875.347403, 887.493102, 12.145699]
result1['residual'] = [-11.188910, -10.805991, 0.382918]
result1

	MCOAL	AUXCOAL	PRDF	TEMP	linear	residual
0	8.926562	5.124895	25.110704	864.158493	875.347403	-11.188910
1	9.252808	5.312198	29.352726	876.687111	887.493102	-10.805991
2	0.978736	0.561909	10.605053	12.528617	12.145699	0.382918

0.978736/(9.252808-8.926562)

2.9999938696566453

0.561909/(5.312198-5.124895)

3.0

10.605053/(29.352726-25.110704)

2.499999528526725

# rate_list = [5, 5, 6, 6]
fuel_list = ['MCOAL', 'AUXCOAL', 'MRDF', 'PRDF']

rate_list = np.array(result1.loc[result1.shape[0]-1, ['MCOAL', 'AUXCOAL', 'MRDF', 'PRDF']]) * np.array([6, 6, 5, 5])/2
rate_list

array([ 2.936208 ,  1.685727 ,  0.       , 26.5126325])

idx = 0
for i in result1.loc[result1.shape[0]-1]:
    if i == 0 :
        rate_list[idx] = 0
#         del fuel_list[idx]
    idx += 1

    
calculation_of_residual = np.array(rate_list) / sum(rate_list) * result1.loc[result1.shape[0]-1, 'residual']
result1.loc[result1.shape[0]-1, fuel_list] += calculation_of_residual

calculation_of_residual

array([0.03611185, 0.02073243, 0.        , 0.32607372])

result1

	MCOAL	AUXCOAL	PRDF	TEMP	linear	residual
0	8.926562	5.124895	25.110704	864.158493	875.347403	-11.188910
1	9.252808	5.312198	29.352726	876.687111	887.493102	-10.805991
2	1.014848	0.582641	10.931127	12.528617	12.145699	0.382918

1.045705/(9.252808-8.926562)

3.205265351912367

0.621191/(5.312198-5.124895)

3.3165032060351414

11.591266/(29.352726-25.110704)

2.732486064428707

12.528617/(876.687111-864.158493)

0.9999999201827419

calculation_of_residual

array([0.03611185, 0.02073243, 0.        , 0.32607372])

sum(rate_list)

31.1345675

fuel_list

['MCOAL', 'AUXCOAL', 'MRDF', 'PRDF']

전체 구간

221124

df.columns

Index(['K6 KILN SPEED 1', 'L6 #2 PAN CONVEYOR', 'K6 TEMP. INLET',
       'K6 MAIN MOTOR', 'K6 AUX. COAL FD T/H', 'K6 MAIN COAL FEED',
       'K6 RDF CFW FEED', 'K6 MEAL TOTAL T/H', 'K6 KHD 3CH DAMPER',
       'K6 KHD 4CH DAMPER', 'K6 POS.THROTLE FLAP', 'K6 TEMP.GAS PIPE3',
       'K6 TEMP.GAS PIPE2 E', 'K6 TEMP.GAS PIPE2 W', 'K6 TEMP.GAS PIPE1 E',
       'K6 TEMP.GAS PIPE1 W', 'K6 TEMP.MAT.INLET E', 'K6 TEMP.MAT.INLET W',
       'K6 TERTIARY DUCT', 'K6 4CH DUCT', 'K6 TEMP.W.GAS WEST 1',
       'K6 TEMP.W.GAS EAST 2', 'C6 #1 FAN AIR', 'K6 W.VINYL FEEDING',
       'K6 TIRE FEEDING', 'K6 WDF FLOW', 'K6 INLET O2', 'K6 INLET CO',
       'K6 INLET NOX', 'K6 W.GAS O2', 'K6 W.GAS CO', 'K6 NOX', 'K6 CFW FLOW',
       'K6 H FUEL T/H', 'K6 TEMP AVG', 'pred'],
      dtype='object')

# target value
df['K6 TEMP AVG'] = (df['K6 TEMP.MAT.INLET W'] + df['K6 TEMP.MAT.INLET E'])/2 
# print("input data", data_in.shape)  # (14 minutes, 10 columns)

df['pred'] = ((df['K6 MAIN COAL FEED'] + df['K6 AUX. COAL FD T/H'])*6 + (df['K6 RDF CFW FEED'] + df['K6 CFW FLOW'])*5 + df['K6 TIRE FEEDING']*9 + df['K6 WDF FLOW']*10 + df['K6 H FUEL T/H']*3.43)/2 + 750

# real value
real_df = pd.DataFrame()              
real_df['real_y'] = (df['K6 TEMP.MAT.INLET W'] + df['K6 TEMP.MAT.INLET E'])/2 

# real_df = real_df.shift(periods=-1)
real_df = real_df[4:]
real_df.reset_index(drop=True, inplace=True)
print('real_y\n', real_df['real_y'])

real_y
 0         876.163879
1         877.747772
2         880.466919
3         883.195251
4         885.896088
             ...    
211673    925.264343
211674    916.008240
211675    902.668793
211676    895.417725
211677    885.877777
Name: real_y, Length: 211678, dtype: float64

211682 - 211678

# linear pred
linear_pred = get_linear_prediction(df)
# print('linear\n',linear_pred)
# print('Linear has has nan',data_in.isnull().values.any())

linear_df = pd.DataFrame()
linear_df['pred1'] = list(linear_pred[:-4]) # t-13 ~ t-4
linear_df['pred2'] = list(linear_pred[1:-3]) # t-12 ~ t-3
linear_df['pred3'] = list(linear_pred[2:-2]) # t-11 ~ t-2
linear_df['pred4'] = list(linear_pred[3:-1]) # t-10 ~ t-1
linear_df['pred5'] = list(linear_pred[4:]) # t-9 ~ t-0

print('linear dataframe\n', linear_df)

linear dataframe
              pred1       pred2       pred3       pred4       pred5
0       863.590588  863.405103  863.199577  862.315611  863.721089
1       863.405103  863.199577  862.315611  863.721089  862.117862
2       863.199577  862.315611  863.721089  862.117862  863.008380
3       862.315611  863.721089  862.117862  863.008380  863.186302
4       863.721089  862.117862  863.008380  863.186302  863.426017
...            ...         ...         ...         ...         ...
211673  856.606852  854.797739  854.940528  851.934331  853.247981
211674  854.797739  854.940528  851.934331  853.247981  850.681870
211675  854.940528  851.934331  853.247981  850.681870  853.476483
211676  851.934331  853.247981  850.681870  853.476483  853.180689
211677  853.247981  850.681870  853.476483  853.180689  853.203119

[211678 rows x 5 columns]

# residual, mu, std
residual = real_df['real_y'] - linear_df['pred1']
mu = np.mean(residual)
std = np.std(residual)

print('residual\n', residual)
print('mu\n', mu)
print('std\n', std)

residual
 0         12.573291
1         14.342669
2         17.267341
3         20.879640
4         22.174999
            ...    
211673    68.657491
211674    61.210501
211675    47.728264
211676    43.483393
211677    32.629796
Length: 211678, dtype: float64
mu
 0.4422446853999033
std
 33.35816972219655

pred = copy.deepcopy(df[['pred']])
pred = pred[4:]
pred.reset_index(drop=True, inplace=True)
pred

	pred
0	862.819451
1	861.216224
2	862.610891
3	862.286638
4	862.524379
...	...
211673	855.097296
211674	852.531186
211675	855.325799
211676	855.030005
211677	855.052435

211678 rows × 1 columns

import random

s = 150000
e = s + 5000

plt.figure(figsize=(30,5))
plt.plot(df['K6 TEMP AVG'][s:e], label='label')
plt.plot(pred['pred'][s:e], label = 'origin_pred')

# plt.figure(figsize=(30,5))
# plt.plot(df['K6 TEMP AVG'][s:e], label='label')
plt.plot(linear_df['pred1'][s:e] + mu, label='pred', color='green')

[<matplotlib.lines.Line2D at 0x208bd334f70>]

png

# save "prediction" to DB
prediction = pd.DataFrame()
coef = 1
prediction['pred1'] = linear_df.loc[9, 'pred1'] + mu
prediction['pred2'] = linear_df.loc[9, 'pred2'] + mu
prediction['pred3'] = linear_df.loc[9, 'pred3'] + mu
prediction['pred4'] = linear_df.loc[9, 'pred4'] + mu
prediction['pred5'] = linear_df.loc[9, 'pred5'] + mu
prediction.columns = ['pred1', 'pred2', 'pred3', 'pred4', 'pred5']

print('new prediction\n',prediction)

new prediction
 Empty DataFrame
Columns: [pred1, pred2, pred3, pred4, pred5]
Index: []

- prdf

import numpy as np
import matplotlib.pyplot as plt

def func(rdf_x):
    return ((df.loc[idx,'K6 MAIN COAL FEED'] + df.loc[idx,'K6 AUX. COAL FD T/H'])*6 + (rdf_x)*5 + df.loc[idx,'K6 TIRE FEEDING']*9 + df.loc[idx,'K6 WDF FLOW']*10 + df.loc[idx,'K6 H FUEL T/H']*3.43)/2 + 750

# DESIRED_VALUE = 875
# THRESHOLD = 15

pv_list = []

for idx in range(df.shape[0]):
    controller = PID_control(0.3, 0.01, 0.001, df.loc[idx, 'K6 RDF CFW FEED'])    # create pid control
    controller.send(None)                     # initialize

    SP = 875
    MV = [df.loc[idx, 'K6 RDF CFW FEED']]
    PV = []


#     if len(PV) ==0: 
#         residual = 0
#     else:
#         residual = np.abs(DESIRED_VALUE - PV[-1])
    for i in range(100):
#     while residual > THRESHOLD:
        PV.append(func(MV[-1]))
        MV.append(controller.send([i, PV[-1], SP]))
    pv_list.append(PV[-1])
#     plt.figure(figsize=[14,5])
#     plt.title('PID control')
#     plt.hlines(SP, 0, 100, label='SP', color='red')
#     plt.plot(PV, label='PV')
#     plt.legend()
#     plt.grid()
#     plt.show()

plt.figure(figsize=[14,5])
plt.plot(df['AVERAGE_INLET'].rolling(window=100).mean())
plt.ylim(800,)
# plt.twinx()
plt.plot(pd.DataFrame(pv_list).rolling(window=100).mean(), color='orange')

plt.hlines(850, 0, df.shape[0], label='SP', color='gray')
plt.hlines(900, 0, df.shape[0], label='SP', color='gray')

<matplotlib.collections.LineCollection at 0x20814c77f40>

png

plt.figure(figsize=[14,5])
plt.plot(df['AVERAGE_INLET'].rolling(window=100).mean())
plt.ylim(800,)
# plt.twinx()
plt.plot(pd.DataFrame(pv_list).rolling(window=100).mean(), color='orange')

plt.hlines(850, 0, df.shape[0], label='SP', color='gray')
plt.hlines(900, 0, df.shape[0], label='SP', color='gray')

<matplotlib.collections.LineCollection at 0x20814ce6880>

png

plt.figure(figsize=[14,5])
plt.plot(df['AVERAGE_INLET'][:1000])
plt.ylim(825,)
# plt.twinx()
plt.plot(pd.DataFrame(pv_list)[:1000], color='orange')

plt.hlines(875, 0, 1000, label='SP', color='gray')
# plt.hlines(900, 0, 1000, label='SP', color='gray')

<matplotlib.collections.LineCollection at 0x20815a8d550>

png

- main, aux, prdf, mrdf

def PID_control_4(Kp, Ki, Kd, MV_COAL_bar=0, MV_RDF_bar=0):
    e_prev = 0
    t_prev = -100
    I = 0
    
    MV_COAL = MV_COAL_bar
    MV_RDF  = MV_RDF_bar
    
    while True:
        t, PV, SP = yield MV_COAL, MV_RDF
        
        e = SP - PV
        
        P = Kp * e
        I = I + Ki*e*(t - t_prev)
        D = Kd*(e - e_prev)/(t - t_prev)
        
        if e < 0:
            MV_COAL = MV_COAL_bar + P + I + D
        elif e > 0 and MV_RDF == 0: 
            MV_COAL = MV_COAL_bar + P + I + D
        else:
            MV_RDF = MV_RDF_bar + P + I + D
        e_prev = e
        t_prev = t

import numpy as np
import matplotlib.pyplot as plt

def func(main_x, aux_x, prdf_x, mrdf_x):
#     return 10 * x # + np.random.randn(1)[0]
    return ((main_x + aux_x)*6 + (prdf_x + mrdf_x)*5 + df.loc[idx,'K6 TIRE FEEDING']*9 + df.loc[idx,'K6 WDF FLOW']*10 + df.loc[idx,'K6 H FUEL T/H']*3.43)/2 + 750

DESIRED_VALUE = 875
THRESHOLD = 25



Kp = 0.3
Ki = 0.01 /2 /2 /2
Kd = 0.001 #*2

pv_list = []
mv_main_list = []
mv_aux_list  = []
mv_prdf_list = []
mv_mrdf_list = []

for idx, row in df.iterrows():
    
    initial_coal = row['K6 MAIN COAL FEED'] + row['K6 AUX. COAL FD T/H']
    initial_rdf  = row['K6 RDF CFW FEED']   + row['K6 CFW FLOW']
    controller = PID_control_4(Kp, Ki, Kd, initial_coal, initial_rdf)    # create pid control
    controller.send(None)                     # initialize

    SP = DESIRED_VALUE
    MV_MAIN = [row['K6 MAIN COAL FEED']]
    MV_AUX  = [row['K6 AUX. COAL FD T/H']]
    MV_PRDF = [row['K6 RDF CFW FEED']]
    MV_MRDF = [row['K6 CFW FLOW']]
    PV = []

    res = 5

    for i in range(100):
        PV.append(func(MV_MAIN[-1], MV_AUX[-1], MV_PRDF[-1], MV_MRDF[-1]))

        if (MV_MAIN[-1] + MV_AUX[-1]) == 0:
            rate_main = 0
            rate_aux  = 0
        else:
            rate_main = MV_MAIN[-1] / (MV_MAIN[-1] + MV_AUX[-1])
            rate_aux  = MV_AUX[-1]  / (MV_MAIN[-1] + MV_AUX[-1])
        if (MV_PRDF[-1] + MV_MRDF[-1]) == 0: 
            rate_prdf = 0
            rate_mrdf = 0
        else:
            rate_prdf = MV_PRDF[-1] / (MV_PRDF[-1] + MV_MRDF[-1])
            rate_mrdf = MV_MRDF[-1] / (MV_PRDF[-1] + MV_MRDF[-1])

        MV_COAL, MV_RDF = controller.send([i, PV[-1], SP])

        MV_MAIN.append(MV_COAL * rate_main)
        MV_AUX.append(MV_COAL * rate_aux)
        MV_PRDF.append(MV_RDF * rate_prdf)
        MV_MRDF.append(MV_RDF * rate_mrdf)
        
        

    pv_list.append(PV[-1])
    mv_main_list.append(MV_MAIN[-2])
    mv_aux_list.append(MV_AUX[-2])
    mv_prdf_list.append(MV_PRDF[-2])
    mv_mrdf_list.append(MV_MRDF[-2])
    

+ 1분 제어 함수

DESIRED_VALUE = 875
THRESHOLD = 25

def control_1minute(row):
    initial_coal = row['K6 MAIN COAL FEED'] + row['K6 AUX. COAL FD T/H']
    initial_rdf  = row['K6 RDF CFW FEED']   + row['K6 CFW FLOW']
    controller = PID_control_4(Kp, Ki, Kd, initial_coal, initial_rdf)    # create pid control
    controller.send(None)                     # initialize

    SP = DESIRED_VALUE
    MV_MAIN = [row['K6 MAIN COAL FEED']]
    MV_AUX  = [row['K6 AUX. COAL FD T/H']]
    MV_PRDF = [row['K6 RDF CFW FEED']]
    MV_MRDF = [row['K6 CFW FLOW']]
    PV = []

    for i in range(100):
        PV.append(func(MV_MAIN[-1], MV_AUX[-1], MV_PRDF[-1], MV_MRDF[-1]))
        
        residual = PV[-1]  - SP
        if np.abs(residual) < THRESHOLD:
            break
            
        if (MV_MAIN[-1] + MV_AUX[-1]) == 0:
            rate_main = 0
            rate_aux  = 0
        else:
            rate_main = MV_MAIN[-1] / (MV_MAIN[-1] + MV_AUX[-1])
            rate_aux  = MV_AUX[-1]  / (MV_MAIN[-1] + MV_AUX[-1])
        if (MV_PRDF[-1] + MV_MRDF[-1]) == 0: 
            rate_prdf = 0
            rate_mrdf = 0
        else:
            rate_prdf = MV_PRDF[-1] / (MV_PRDF[-1] + MV_MRDF[-1])
            rate_mrdf = MV_MRDF[-1] / (MV_PRDF[-1] + MV_MRDF[-1])

        MV_COAL, MV_RDF = controller.send([i, PV[-1], SP])
        
        MV_MAIN.append(MV_COAL * rate_main)
        MV_AUX.append(MV_COAL * rate_aux)
        MV_PRDF.append(MV_RDF * rate_prdf)
        MV_MRDF.append(MV_RDF * rate_mrdf)
        
#     return PV[-1], MV_MAIN[-2], MV_AUX[-2], MV_PRDF[-2], MV_MRDF[-2]
    return PV[-1], MV_MAIN[-1], MV_AUX[-1], MV_PRDF[-1], MV_MRDF[-1]
        




Kp = 0.3
Ki = 0.01 /2 /2 /2
Kd = 0.001 #*2

pv_list = []
mv_main_list = []
mv_aux_list  = []
mv_prdf_list = []
mv_mrdf_list = []

for idx, row in df.iterrows():
    new_pv, new_main, new_aux, new_prdf, new_mrdf = control_1minute(row)

    pv_list.append(new_pv)
    mv_main_list.append(new_main)
    mv_aux_list.append(new_aux)
    mv_prdf_list.append(new_prdf)
    mv_mrdf_list.append(new_mrdf)
    

메인버너로 들어가는 연료들(메인 콜, MRDF) 거의 그대로 둔다

print(df['K6 MAIN COAL FEED'].mode())
print(df['K6 CFW FLOW'].mode())

0    6.498438
dtype: float64
0    0.0
dtype: float64

df_round = copy.deepcopy(df)
df_round = df_round.round(0)

df_round['K6 MAIN COAL FEED'].value_counts()

0     92301
0     53696
0     30982
0     24996
0     4476
0      2321
0     1157
0     1093
0      441
0        82
0       38
0       36
0       20
0       16
0        14
0        9
0         2
0         2
Name: K6 MAIN COAL FEED, dtype: int64

df_round['K6 AUX. COAL FD T/H'].value_counts()

0     42628
0     32369
0     31065
0     29960
0     19405
0     17422
0     10725
0      5900
0      5533
0      3163
0     3150
0     3030
0     1992
0     1571
0     1480
0     1055
0     1029
0      205
Name: K6 AUX. COAL FD T/H, dtype: int64

df_round['K6 CFW FLOW'].value_counts()

0    84998
0    40374
0    40201
0    17592
0    11607
0     7407
0     3886
0     3673
0     1159
0      785
Name: K6 CFW FLOW, dtype: int64

df_round['K6 RDF CFW FEED'].value_counts()

0    49580
0    45105
0    23291
0    20464
0    16840
0    14749
0     9588
0      8537
0     4887
0     4444
0     3720
0     3384
0     1620
0     1297
0      1111
0      918
0      673
0      469
0      426
0       286
0       170
0       33
0        25
0        21
0       21
0         8
0        5
0         4
0         3
0         2
0        1
Name: K6 RDF CFW FEED, dtype: int64

plt.figure(figsize=(30,5))
plt.plot(df['K6 MAIN COAL FEED'])

plt.figure(figsize=(30,5))
plt.plot(df['K6 AUX. COAL FD T/H'])

plt.figure(figsize=(30,5))
plt.plot(df['K6 CFW FLOW'])
         
plt.figure(figsize=(30,5))
plt.plot(df['K6 RDF CFW FEED'])

[<matplotlib.lines.Line2D at 0x20822818cd0>]

png

import numpy as np
import matplotlib.pyplot as plt

def func(aux_x, prdf_x):
#     return 10 * x # + np.random.randn(1)[0]
    return ((df.loc[idx,'K6 MAIN COAL FEED'] + aux_x)*6 + (prdf_x + df.loc[idx,'K6 CFW FLOW'])*5 + df.loc[idx,'K6 TIRE FEEDING']*9 + df.loc[idx,'K6 WDF FLOW']*10 + df.loc[idx,'K6 H FUEL T/H']*3.43)/2 + 750

def PID_control_2(Kp, Ki, Kd, MV_AUX_bar=0, MV_RDF_bar=0):
    e_prev = 0
    t_prev = -100
    I = 0
    
    MV_AUX = MV_AUX_bar
    MV_RDF = MV_RDF_bar
    
    while True:
        t, PV, SP = yield MV_AUX, MV_RDF
        e = SP - PV
        P = Kp * e
        I = I + Ki*e*(t - t_prev)
        D = Kd*(e - e_prev)/(t - t_prev)
        if e > 0:
            MV_RDF = MV_RDF_bar + P + I + D
#             MV_AUX = MV_AUX
        else:
            MV_AUX = MV_AUX_bar + P + I + D
#             MV_RDF = MV_RDF
        e_prev = e
        t_prev = t

DESIRED_VALUE = 875
THRESHOLD = 25





    
def control_1minute(row):
    initial_coal =  row['K6 AUX. COAL FD T/H']
    initial_rdf  = row['K6 RDF CFW FEED']
    controller = PID_control_2(Kp, Ki, Kd, initial_coal, initial_rdf)    # create pid control
    controller.send(None)                     # initialize

    SP = DESIRED_VALUE
    MV_AUX  = [row['K6 AUX. COAL FD T/H']]
    MV_PRDF = [row['K6 RDF CFW FEED']]
    PV = []
#     PV.append(func(MV_AUX[-1], MV_PRDF[-1]))
    
    for i in range(100):
#         print(MV_AUX[-1], MV_PRDF[-1])
#         pv = (func((MV_AUX[-1]), (MV_PRDF[-1]))).astype('float64')
#         pv = (func((MV_AUX[-1]).astype('float64'), (MV_PRDF[-1]).astype('float64'))).astype('float64')
#         PV.append(pv)
        PV.append(func(MV_AUX[-1], MV_PRDF[-1]))
        
#         residual = PV[-1]  - SP
#         if np.abs(residual) < THRESHOLD:
#             break
            

        aux,  rdf = controller.send([i, PV[-1], SP])
        MV_AUX.append(aux)
        MV_PRDF.append(rdf)
        
        
#     return PV[-1], MV_MAIN[-2], MV_AUX[-2], MV_PRDF[-2], MV_MRDF[-2]
    return PV[-1], MV_AUX[-1], MV_PRDF[-1]
        




Kp = 0.3
Ki = 0.01 /2 /2 /2
Kd = 0.001 #*2

pv_list = []
mv_aux_list  = []
mv_prdf_list = []

for idx, row in df.iterrows():
    new_pv, new_aux, new_prdf = control_1minute(row)

    pv_list.append(new_pv)
    mv_aux_list.append(new_aux)
    mv_prdf_list.append(new_prdf)

    

–> PID

import numpy as np
import matplotlib.pyplot as plt

def func_aux(aux_x):
    return ((df.loc[idx,'K6 MAIN COAL FEED'] + aux_x)*6 + (df.loc[idx, 'K6 RDF CFW FEED'] + df.loc[idx, 'K6 CFW FLOW'])*5 + df.loc[idx,'K6 TIRE FEEDING']*9 + df.loc[idx,'K6 WDF FLOW']*10 + df.loc[idx,'K6 H FUEL T/H']*3.43)/2 + 750


def func_prdf(prdf_x):
    return ((df.loc[idx,'K6 MAIN COAL FEED'] + df.loc[idx,'K6 AUX. COAL FD T/H'])*6 + (prdf_x + df.loc[idx, 'K6 CFW FLOW'])*5 + df.loc[idx,'K6 TIRE FEEDING']*9 + df.loc[idx,'K6 WDF FLOW']*10 + df.loc[idx,'K6 H FUEL T/H']*3.43)/2 + 750

def PID(Kp, Ki, Kd, MV_bar=0):
    e_prev = 0
    t_prev = -100
    I = 0
    
    MV = MV_bar
    
    while True:
        t, PV, SP = yield MV
        e = SP - PV
        
        P = Kp * e
        I = I + Ki*e*(t - t_prev)
        D = Kd*(e - e_prev)/(t - t_prev)
        
        MV = MV_bar + P + I + D
        
        e_prev = e
        t_prev = t

for i in df['K6 MAIN COAL FEED']:
    print(format(i, '.5f'))

# 외부에서 설정할 수 있도록
DESIRED_VALUE = 875
THRESHOLD = 25

# row['K6 AUX. COAL FD T/H']
# row['K6 RDF CFW FEED'] 를 받아오기..
# coal: boolean, True --> coal , False --> prdf
def control_1minute(initial_mv, coal):
    controller = PID(Kp, Ki, Kd, initial_mv)    # create pid control
    controller.send(None)                     # initialize
    
    SP = DESIRED_VALUE
    MV = [initial_mv]
    PV = []
    if coal:
        PV.append(func_aux(MV[-1]))
    else:
        PV.append(func_prdf(MV[-1]))
                  
    residual = np.abs(PV[-1] - SP)
    
    
    for i in range(100):
            
        residual = np.abs(PV[-1]  - SP)
        if residual < THRESHOLD:
            break
            
        MV.append(controller.send([i, PV[-1], SP]))
       
        PV.append(func(MV_AUX[-1], MV_PRDF[-1]))
        residual = np.abs(PV[-1] - SP)
    return PV[-1], MV_AUX[-1]
        

Kp = 0.3
Ki = 0.01 /2 /2 /2
Kd = 0.001 #*2

pv_list = []
mv_aux_list  = []
mv_prdf_list = []

for idx, row in df.iterrows():
    res = (df.loc[idx, 'pred'] - DESIRED_VALUE)
    if res > THRESHOLD:  
        new_pv, new_aux = control_1minute(row['K6 AUX. COAL FD T/H'], True)
    elif res < -THRESHOLD:
        new_pv, new_prdf = control_1minute(row['K6 RDF CFW FEED'], False)
    else:
        new_pv = df.loc[idx, 'pred']
        new_main = df.loc[idx, 'K6 MAIN COAL FEED']
        new_aux = df.loc[idx, 'K6 AUX. COAL FD T/H']
        new_prdf = df.loc[idx, 'K6 RDF CFW FEED']
        new_mrdf = df.loc[idx, 'K6 CFW FLOW']        
    pv_list.append(new_pv)
    mv_main_list.append(new_main)
    mv_aux_list.append(new_aux)
    mv_prdf_list.append(new_prdf)
    mv_mrdf_list.append(new_mrdf)
    

plt.figure(figsize=[14,5])
plt.plot(df['AVERAGE_INLET'].rolling(window=100).mean())
plt.ylim(800,)
# plt.twinx()
plt.plot(pd.DataFrame(pv_list).rolling(window=100).mean(), color='orange')

plt.hlines(850, 0, df.shape[0], label='low bound', color='gray', linestyle='dashed')
plt.hlines(875, 0, df.shape[0], label='desired value', color='red', linestyle='dashed')
plt.hlines(900, 0, df.shape[0], label='upper bound', color='gray', linestyle='dashed')

<matplotlib.collections.LineCollection at 0x20827b50fd0>

png

consider threshold

DESIRED_VALUE = 875
THRESHOLD = 25

def control_1minute(row):
    initial_coal = row['K6 MAIN COAL FEED'] + row['K6 AUX. COAL FD T/H']
    initial_rdf  = row['K6 RDF CFW FEED']   + row['K6 CFW FLOW']
    controller = PID_control_4(Kp, Ki, Kd, initial_coal, initial_rdf)    # create pid control
    controller.send(None)                     # initialize

    SP = DESIRED_VALUE
    MV_MAIN = [row['K6 MAIN COAL FEED']]
    MV_AUX  = [row['K6 AUX. COAL FD T/H']]
    MV_PRDF = [row['K6 RDF CFW FEED']]
    MV_MRDF = [row['K6 CFW FLOW']]
    PV = []
    
    PV.append(func(MV_MAIN[-1], MV_AUX[-1], MV_PRDF[-1], MV_MRDF[-1]))
    residual = np.abs(PV[-1] - SP)
    
    if residual > THRESHOLD:
        for i in range(100):
            residual = np.abs(PV[-1]  - SP)
            if residual < THRESHOLD:
                break
            
            MV_COAL, MV_RDF = controller.send([i, PV[-1], SP])
            
            # 두 연료 합이 0인 경우, 예외처리 
            if (MV_MAIN[-1] + MV_AUX[-1]) == 0:
                rate_main = 0
                rate_aux  = 0
            # 기존 두 연료의 비율로 나눠주기 
            else:
                rate_main = MV_MAIN[-1] / (MV_MAIN[-1] + MV_AUX[-1])
                rate_aux  = MV_AUX[-1]  / (MV_MAIN[-1] + MV_AUX[-1])
            if (MV_PRDF[-1] + MV_MRDF[-1]) == 0: 
                rate_prdf = 0
                rate_mrdf = 0
            else:
                rate_prdf = MV_PRDF[-1] / (MV_PRDF[-1] + MV_MRDF[-1])
                rate_mrdf = MV_MRDF[-1] / (MV_PRDF[-1] + MV_MRDF[-1])

            MV_MAIN.append(MV_COAL * rate_main)
            MV_AUX.append(MV_COAL * rate_aux)
            MV_PRDF.append(MV_RDF * rate_prdf)
            MV_MRDF.append(MV_RDF * rate_mrdf)
            
            PV.append(func(MV_MAIN[-1], MV_AUX[-1], MV_PRDF[-1], MV_MRDF[-1]))
            residual = np.abs(PV[-1] - SP)
    return PV[-1], MV_MAIN[-1], MV_AUX[-1], MV_PRDF[-1], MV_MRDF[-1]
        




Kp = 0.3
Ki = 0.01 /2 /2 /2
Kd = 0.001 #*2

pv_list = []
mv_main_list = []
mv_aux_list  = []
mv_prdf_list = []
mv_mrdf_list = []

for idx, row in df.iterrows():
    new_pv, new_main, new_aux, new_prdf, new_mrdf = control_1minute(row)

    pv_list.append(new_pv)
    mv_main_list.append(new_main)
    mv_aux_list.append(new_aux)
    mv_prdf_list.append(new_prdf)
    mv_mrdf_list.append(new_mrdf)
    

print(len(PV))
print(len(MV_MAIN))
print(len(MV_PRDF))
print(len(pv_list))

# consider threshold
print(len(PV))
print(len(MV_MAIN))
print(len(MV_PRDF))
print(len(pv_list))

pv_list[:100]

[862.6909243816137,
5333098286392,
8020886915921,
4438179844619,
8194510668516,
2162244051696,
6108912962676,
2866379970312,
5243794649838,
1651706379653,
6353276580572,
4694527500869,
1758965986966,
0181628531218,
5403644770383,
9182057064771,
6938245052099,
932591869235,
6338240832091,
1173561424018,
1407727116347,
7243465918303,
7243465918303,
4150980323553,
3136270850896,
8912007564307,
5360493201018,
9545304507018,
8117081850768,
1650979274513,
2063750761748,
8577515810729,
9551542609931,
6491591662169,
4181744784116,
7830207079649,
2312826794387,
2655524128675,
7451729315519,
6476763600112,
3300833386181,
9358527988196,
6257894366978,
0135153645277,
8341110557319,
6929883497954,
9040659779309,
0457017153501,
7484701484441,
6535069674254,
3530947893859,
9231736391783,
4151138943433,
1292047041653,
766003343463,
5202929729222,
9649445742368,
1556028860808,
2933947771788,
3603204101323,
4846180963516,
0738589107989,
5062056207656,
0493833136559,
4901062190534,
3903715980053,
666118147373,
3116294455526,
2324407935146,
8115965950491,
1631881308557,
9340500855449,
656375756264,
9869815421107,
3720957863334,
7916270804407,
6343268060684,
5971312546731,
4138601660729,
7562087309361,
981415282488,
7052407288551,
9710638576745,
4178034991027,
0433051341773,
4574469441175,
2277974003555,
7605246180295,
3060733145476,
5249680393935,
8584974139928,
7244880527257,
9448287814855,
5085257405043,
7594636791945,
0800443118812,
7485578387974,
5943906039,
3736761921643,
9559096831083]

l = ['K6 TEMP.MAT.INLET E','K6 TEMP.MAT.INLET W','K6 AUX. COAL FD T/H','K6 MAIN COAL FEED','K6 CFW FLOW','K6 H FUEL T/H','K6 RDF CFW FEED','K6 WDF FLOW','K6 TIRE FEEDING','K6 W.VINYL FEEDING','C6 #1 FAN AIR','K6 TERTIARY DUCT','K6 KHD 4CH DAMPER','K6 KHD 3CH DAMPER','K6 INLET CO','K6 INLET O2','K6 INLET NOX','K6 MEAL TOTAL T/H','K6 KILN SPEED 1','L6 #2 PAN CONVEYOR','K6 MAIN MOTOR']
len(l)

# --> two temp --> residual 

plt.figure(figsize=[14,5])
plt.plot(df['AVERAGE_INLET'].rolling(window=100).mean())
plt.ylim(800,)
# plt.twinx()
plt.plot(pd.DataFrame(pv_list).rolling(window=100).mean(), color='orange')

plt.hlines(850, 0, df.shape[0], label='low bound', color='gray', linestyle='dashed')
plt.hlines(875, 0, df.shape[0], label='desired value', color='red', linestyle='dashed')
plt.hlines(900, 0, df.shape[0], label='upper bound', color='gray', linestyle='dashed')

<matplotlib.collections.LineCollection at 0x208277d1df0>

png

# after consider threshold
plt.figure(figsize=[14,5])
plt.plot(df['AVERAGE_INLET'].rolling(window=100).mean())
plt.ylim(800,)
# plt.twinx()
plt.plot(pd.DataFrame(pv_list).rolling(window=100).mean(), color='orange')

plt.hlines(850, 0, df.shape[0], label='low bound', color='gray', linestyle='dashed')
plt.hlines(875, 0, df.shape[0], label='desired value', color='red', linestyle='dashed')
plt.hlines(900, 0, df.shape[0], label='upper bound', color='gray', linestyle='dashed')

<matplotlib.collections.LineCollection at 0x208277a05b0>

png

plt.figure(figsize=[14,5])
plt.plot(df['K6 MAIN COAL FEED'].rolling(window=100).mean())
plt.plot(pd.DataFrame(mv_main_list).rolling(window=100).mean())
plt.hlines(df['K6 MAIN COAL FEED'].mean(), 0, df.shape[0], label='average', color='gray', linestyle='dashed')
plt.hlines(0, 0, df.shape[0], label='zero', color='gray', linestyle='dashed')
plt.title('K6 MAIN COAL FEED')
plt.grid()
plt.show()


plt.figure(figsize=[14,5])
plt.plot(df['K6 AUX. COAL FD T/H'].rolling(window=100).mean())
plt.plot(pd.DataFrame(mv_aux_list).rolling(window=100).mean())
plt.hlines(df['K6 AUX. COAL FD T/H'].mean(), 0, df.shape[0], label='average', color='gray', linestyle='dashed')
plt.hlines(0, 0, df.shape[0], label='zero', color='gray', linestyle='dashed')
plt.title('K6 AUX. COAL FD T/H')
plt.grid()
plt.show()


plt.figure(figsize=[14,5])
plt.plot(df['K6 RDF CFW FEED'].rolling(window=100).mean())
plt.plot(pd.DataFrame(mv_prdf_list).rolling(window=100).mean())
plt.hlines(df['K6 RDF CFW FEED'].mean(), 0, df.shape[0], label='average', color='gray', linestyle='dashed')
plt.title('K6 RDF CFW FEED')
plt.grid()
plt.show()


plt.figure(figsize=[14,5])
plt.plot(df['K6 CFW FLOW'].rolling(window=100).mean())
plt.plot(pd.DataFrame(mv_mrdf_list).rolling(window=100).mean())
plt.hlines(df['K6 CFW FLOW'].mean(), 0, df.shape[0], label='average', color='gray', linestyle='dashed')
plt.title('K6 CFW FLOW')
plt.grid()
plt.show()


# # plt.figure(figsize=[14,5])
# # for col in fuel_list:
# #     plt.plot(df[col].rolling(window=100).mean())
# # plt.title('fuel')
# # plt.grid()
# # plt.show()

png

plt.figure(figsize=[14,5])
plt.plot(df['K6 MAIN COAL FEED'].rolling(window=100).mean())
plt.plot(pd.DataFrame(mv_main_list).rolling(window=100).mean())
plt.hlines(df['K6 MAIN COAL FEED'].mean(), 0, df.shape[0], label='average', color='gray', linestyle='dashed')
plt.hlines(0, 0, df.shape[0], label='zero', color='gray', linestyle='dashed')
plt.title('K6 MAIN COAL FEED')
plt.grid()
plt.show()


plt.figure(figsize=[14,5])
plt.plot(df['K6 AUX. COAL FD T/H'].rolling(window=100).mean())
plt.plot(pd.DataFrame(mv_aux_list).rolling(window=100).mean())
plt.hlines(df['K6 AUX. COAL FD T/H'].mean(), 0, df.shape[0], label='average', color='gray', linestyle='dashed')
plt.hlines(0, 0, df.shape[0], label='zero', color='gray', linestyle='dashed')
plt.title('K6 AUX. COAL FD T/H')
plt.grid()
plt.show()


plt.figure(figsize=[14,5])
plt.plot(df['K6 RDF CFW FEED'].rolling(window=100).mean())
plt.plot(pd.DataFrame(mv_prdf_list).rolling(window=100).mean())
plt.hlines(df['K6 RDF CFW FEED'].mean(), 0, df.shape[0], label='average', color='gray', linestyle='dashed')
plt.title('K6 RDF CFW FEED')
plt.grid()
plt.show()


plt.figure(figsize=[14,5])
plt.plot(df['K6 CFW FLOW'].rolling(window=100).mean())
plt.plot(pd.DataFrame(mv_mrdf_list).rolling(window=100).mean())
plt.hlines(df['K6 CFW FLOW'].mean(), 0, df.shape[0], label='average', color='gray', linestyle='dashed')
plt.title('K6 CFW FLOW')
plt.grid()
plt.show()


# # plt.figure(figsize=[14,5])
# # for col in fuel_list:
# #     plt.plot(df[col].rolling(window=100).mean())
# # plt.title('fuel')
# # plt.grid()
# # plt.show()

png

is_over_main = []
for idx, row in df.iterrows():
    if row['K6 MAIN COAL FEED'] < mv_main_list[idx]:
        is_over_main.append(True)
    else:
        is_over_main.append(False)
df['is_over_main'] = is_over_main

is_over_aux = []
for idx, row in df.iterrows():
    if row['K6 AUX. COAL FD T/H'] < mv_aux_list[idx]:
        is_over_aux.append(True)
    else:
        is_over_aux.append(False)
df['is_over_aux'] = is_over_aux

is_under_prdf = []
for idx, row in df.iterrows():
    if row['K6 RDF CFW FEED'] > mv_prdf_list[idx]:
        is_under_prdf.append(True)
    else:
        is_under_prdf.append(False)
df['is_under_prdf'] = is_under_prdf

is_under_mrdf = []
for idx, row in df.iterrows():
    if row['K6 CFW FLOW'] < mv_mrdf_list[idx]:
        is_under_mrdf.append(True)
    else:
        is_under_mrdf.append(False)
df['is_under_mrdf'] = is_under_mrdf

print('is_over_main ', len(df['is_over_main'][is_over_main]))
print('is_over_aux  ', len(df['is_over_aux'][is_over_aux]))
print('is_under_prdf', len(df['is_under_prdf'][is_under_prdf]))
print('is_under_mrdf', len(df['is_under_mrdf'][is_under_mrdf]))

is_over_main  1270
is_over_aux   1261
is_under_prdf 11
is_under_mrdf 5026

for i in range(8):
    s = i * 25000
    e = s + 25000
    
    plt.figure(figsize=(30,5))
    plt.plot(df['K6 MAIN COAL FEED'][s:e])
    plt.plot(pd.DataFrame(mv_main_list)[s:e])
    plt.scatter(df[(df.index>s)&(df.index<e)&(df['is_over_main']) ].index, df[(df.index>s)&(df.index<e)&(df['is_over_main']) ]['K6 MAIN COAL FEED'], color='red', alpha = 0.75, s = 10)
#     plt.twinx()
#     plt.plot(df['K6 RDF CFW FEED'][s:e], color='green')
    # plt.hlines(df['K6 MAIN COAL FEED'].mean(), s, e, label='average', color='gray', linestyle='dashed')
    # plt.hlines(0, s, e, label='zero', color='gray', linestyle='dashed')
    plt.title('K6 MAIN COAL FEED')
    plt.grid()
    plt.show()

png

df_cp = copy.deepcopy(df)
fuel_list = [
    'K6 MAIN COAL FEED',
    'K6 AUX. COAL FD T/H',
    'K6 RDF CFW FEED',
    'K6 CFW FLOW'
]
df_cp.loc[0, fuel_list] = [0,0,0,0]
df_cp

	K6 KILN SPEED 1	L6 #2 PAN CONVEYOR	K6 TEMP. INLET	K6 MAIN MOTOR	K6 AUX. COAL FD T/H	K6 MAIN COAL FEED	K6 RDF CFW FEED	K6 MEAL TOTAL T/H	K6 KHD 3CH DAMPER	K6 KHD 4CH DAMPER	...	AVERAGE_INLET(5min)	pred	pred(5min)	RESIDUAL	RESIDUAL(5min)	pred_control	is_over_main	is_over_aux	is_under_prdf	is_under_mrdf
0	3.215802	49.699219	0.000000	438.391724	0.000000	0.000000	0.000000	326.356140	28.847181	63.903259	...	877.747772	862.690924	NaN	12.362720	NaN	850.381849	False	False	False	False
1	3.217230	52.148438	0.000000	439.795532	7.129625	8.081250	21.558632	332.204163	28.847181	63.903259	...	880.466919	863.533310	NaN	11.870684	NaN	852.066620	False	False	False	False
2	3.217230	48.574219	0.000000	440.558472	7.138170	8.081250	21.361029	325.871674	28.847181	63.903259	...	883.195251	862.802089	NaN	11.362099	NaN	850.604177	False	False	False	False
3	3.217230	48.339844	0.000000	439.856567	7.129625	8.081250	21.122835	328.233002	28.847181	63.903259	...	885.896088	862.443818	NaN	13.189058	NaN	849.887636	False	False	False	False
4	3.219867	51.339844	0.000000	439.154663	7.129625	8.081250	21.479057	327.489136	28.847181	63.903259	...	887.937744	862.819451	NaN	12.442791	NaN	850.638902	False	False	False	False
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
211677	2.901094	50.320312	31.805904	509.987061	1.121233	5.546875	20.080339	282.616150	1.039139	30.395971	...	NaN	855.097296	858.434726	72.016363	66.829617	835.194593	False	False	False	False
211678	2.921419	46.945312	32.227055	474.555573	0.148623	5.546875	20.225605	282.539856	1.039139	30.395971	...	NaN	852.531186	856.606852	65.326370	59.401388	830.062372	False	False	False	False
211679	2.907906	50.003906	32.227055	536.324097	1.098955	5.546875	20.252308	285.072876	1.039139	30.395971	...	NaN	855.325799	854.797739	49.192309	47.871054	835.651598	False	False	False	False
211680	2.907906	50.085938	33.142597	491.126892	1.113603	5.546875	20.080339	285.545898	1.039139	30.395971	...	NaN	855.030005	854.940528	42.237036	40.477196	835.060009	False	False	False	False
211681	2.910707	49.523438	33.142597	487.342651	1.113603	5.546875	20.080339	283.768219	1.039139	30.395971	...	NaN	855.052435	851.934331	32.674658	33.943446	835.104870	False	False	False	False

211682 rows × 45 columns

Twitter Facebook LinkedIn

yerim

Second

기본 설정

데이터 불러오기

데이터프레임 생성

모듈

PID

P control

PI control

PID control - 1

- rdf

- prdf, mrdf

- main, aux

PID control - 2

- aux, prdf

- main, aux, prdf, mrdf

–> NO WHILE

전체 구간

221124

- prdf

- main, aux, prdf, mrdf

+ 1분 제어 함수

메인버너로 들어가는 연료들(메인 콜, MRDF) 거의 그대로 둔다

–> PID

consider threshold

공유하기

참고

Data handling

yerim’s first github.io posting