def run_code(model,batch_size,syn):
global target,mode,df,X_train,y_train,X_test,y_test
verbose, epochs = 1, 100
history = model.fit(X_train,y_train,epochs=epochs,validation_data=(X_test,y_test),batch_size=batch_size,verbose=verbose,callbacks=callbacks)
def history_plot(history_model,name):
fig, ax = plt.subplots(figsize=(6.4, 4.8))
ax.plot (history_model.history['loss'])
ax.plot (history_model.history['val_loss'])
ax.set_title ('model loss:{}'.format(name))
ax.set_xlabel('epoch')
ax.legend(['train','val'],loc='upper left')
fig.savefig(save_path+'/loss_{}.png'.format(name), dpi=100, bbox_inches='tight')
fig.clear()
plt.close(fig)
history_plot(history,syn)
trainPredict = model.predict(X_train)
testPredict = model.predict(X_test)
#---------- Inverse ------------------#
# y_train = scaler_tar.inverse_transform(y_train)
# trainPredict = scaler_tar.inverse_transform(trainPredict.reshape(y_train.shape))
# y_test = scaler_tar.inverse_transform(y_test)
# testPredict = scaler_tar.inverse_transform(testPredict.reshape(y_test.shape))
record_list_result(syn,df,mode,y_train,y_test,trainPredict,testPredict,target,batch_size,save_path,n_past,n_features,n_future)
def wav_dl_wav_run(model_list, batch, syn):
X, _ = autosplit(data_cA3)
cA3ytrain, cA3ytest = run_code_editv2(model_list, X, yA3_ori, batch)
_, Y = autosplit(data_mar)
y_train, y_test = Y[0], Y[1]
scaler_t = StandardScaler()
y_train = scaler_t.fit_transform(y_train)
y_train = scaler_t.inverse_transform(y_train)
scaler = StandardScaler()
trainPredict = scaler.fit_transform(cA3ytrain)
trainPredict = scaler_t.inverse_transform(trainPredict)
scaler_t = StandardScaler()
y_test = scaler_t.fit_transform(y_test)
y_test = scaler_t.inverse_transform(y_test)
scaler = StandardScaler()
testPredict = scaler.fit_transform(cA3ytest)
testPredict = scaler_t.inverse_transform(testPredict)
record_list_result(syn, df, DLtype, y_train, y_test, trainPredict,
testPredict, target, batch_size, save_path, n_past,
n_features, n_future)
return
def run_code_alone(model, batch_size, syn, cAcD, minmaxscaler, flag_pca):
global target, mode, callbacks
df_scaled = call_data()
##############Wavelet or not############
if cAcD:
X_train, cDX_train, y_train, X_test, cDX_test, y_test = Wavtrain_test_split_xy(
df_scaled, pca=flag_pca)
if flag_pca == True: syn = syn + '_wcA_PCA'
else: syn = syn + '_wcA'
else:
X_train, y_train, X_test, y_test = train_test_split_xy(df_scaled,
pca=flag_pca)
if flag_pca == True: syn = syn + '_PCA'
else: pass
##############Scale or not####################
if minmaxscaler == True:
scaler = MinMaxScaler().fit(flatten(X_train))
X_train = scale(X_train, scaler)
scaler = MinMaxScaler().fit(flatten(X_test))
X_test = scale(X_test, scaler)
syn = syn + '_MinMaxLayer'
else:
pass
#####################################################
print('*' * 20, syn, '*' * 20)
print("shape")
print(X_train.shape, y_train.shape)
print(X_test.shape, y_test.shape)
history = model.fit(X_train,
y_train,
epochs=epochs,
validation_data=(X_test, y_test),
batch_size=batch_size,
verbose=verbose,
callbacks=callbacks)
########### plot loss ########################
history_plot(history, syn)
#################################################
trainPredict = model.predict(X_train).astype('float32')
testPredict = model.predict(X_test).astype('float32')
trainPredict, testPredict = trainPredict.reshape(
y_train.shape), testPredict.reshape(y_test.shape)
# y_train_ori = scaler_tar.inverse_transform(y_train)
# trainPredict = scaler_tar.inverse_transform(trainPredict)
# y_test_ori = scaler_tar.inverse_transform(y_test)
# testPredict = scaler_tar.inverse_transform(testPredict)
y_train_ori, y_test_ori = y_train.astype('float32'), y_test.astype(
'float32')
# model.save(save_path+'/{}.h5'.format(syn))
record_list_result(syn, df_scaled, mode, y_train_ori, y_test_ori,
trainPredict, testPredict, target, batch_size,
save_path, n_past, n_features, n_future)
return
def run_code(model, batch_size, syn, minmaxscaler, flag_pca):
global target, mode
syn = syn + '_wcAcD'
if flag_pca == True: syn = syn + '_PCA'
else: syn = syn + '_NoPCA'
################### Scale #######################
df_mars = call_data()
cAX_train, cDX_train, y_train, cAX_test, cDX_test, y_test = Wavtrain_test_split_xy(
df_mars, pca=flag_pca)
##############Scale or not####################
if minmaxscaler == True:
scaler = MinMaxScaler().fit(flatten(cAX_train))
cAX_train = scale(cAX_train, scaler)
scaler = MinMaxScaler((0, 1)).fit(flatten(cDX_train))
cDX_train = scale(cDX_train, scaler)
scaler = MinMaxScaler().fit(flatten(cAX_test))
cAX_test = scale(cAX_test, scaler)
scaler = MinMaxScaler((0, 1)).fit(flatten(cDX_test))
cDX_test = scale(cDX_test, scaler)
syn = syn + '_MinMaxLayer'
else:
pass
#################################################
print('*' * 20, syn, '*' * 20)
print("shape :")
print(cAX_test.shape, cDX_test.shape, y_test.shape)
print('*' * 20, syn, '*' * 20)
#################################################
validataion = ([cAX_test, cDX_test], y_test)
history = model.fit(x=[cAX_train, cDX_train],
y=y_train,
epochs=epochs,
batch_size=batch_size,
verbose=verbose,
validation_data=validataion,
callbacks=callbacks)
########### plot loss ########################
history_plot(history, syn)
#################################################
trainPredict = model.predict([cAX_train, cDX_train]).astype('float32')
testPredict = model.predict([cAX_test, cDX_test]).astype('float32')
trainPredict, testPredict = trainPredict.reshape(
y_train.shape), testPredict.reshape(y_test.shape)
y_train_ori, y_test_ori = y_train, y_test
# model.save(save_path+'/{}.h5'.format(syn))
record_list_result(syn, df_mars, mode, y_train_ori, y_test_ori,
trainPredict, testPredict, target, batch_size,
save_path, n_past, n_features, n_future)
def run_code(model,batch_size,syn):
global target,mode,df,cX_train,cX_test,cy_train,cy_test
verbose, epochs = 1, 100
history = model.fit(cX_train[0],cy_train[0],epochs=epochs,validation_data=(cX_test[0],cy_test[0]),batch_size=batch_size,verbose=verbose,callbacks=callbacks)
trainPredic_cA = model.predict(cX_train[0])
testPredict_cA = model.predict(cX_test[0])
history = model.fit(cX_train[1],cy_train[1],epochs=epochs,validation_data=(cX_test[1],cy_test[1]),batch_size=batch_size,verbose=verbose,callbacks=callbacks)
trainPredict_cD = model.predict(cX_train[1])
testPredict_cD = model.predict(cX_test[1])
trainPredic_cA = scaler_cA.inverse_transform(trainPredic_cA)
trainPredict_cD = scaler_cD.inverse_transform(trainPredict_cD)
testPredict_cA = scaler_cAt.inverse_transform(testPredict_cA)
testPredict_cD = scaler_cDt.inverse_transform(testPredict_cD)
def iwave(cA,cD):
iwave = list()
for i in range(cA.shape[0]):
# wave = pywt.idwt(cA[i,:],cD[i,:], 'db4')
wave = pywt.iswt((cA[i,:],cD[i,:]), 'db4')
iwave.append(wave)
return np.array(iwave)
trainPredict = iwave(trainPredic_cA,trainPredict_cD)
testPredict = iwave(testPredict_cA,testPredict_cD)
def history_plot(history_model,name):
fig, ax = plt.subplots(figsize=(6.4, 4.8))
ax.plot (history_model.history['loss'])
ax.plot (history_model.history['val_loss'])
ax.set_title ('model loss:{}'.format(name))
ax.set_xlabel('epoch')
ax.legend(['train','val'],loc='upper left')
fig.savefig(save_path+'/loss_{}.png'.format(name), dpi=100, bbox_inches='tight')
fig.clear()
plt.close(fig)
# history_plot(history,syn)
#---------- Inverse ------------------#
# y_train = scaler_tar.inverse_transform(y_train)
# trainPredict = scaler_tar.inverse_transform(trainPredict.reshape(y_train.shape))
# y_test = scaler_tar.inverse_transform(y_test)
# testPredict = scaler_tar.inverse_transform(testPredict.reshape(y_test.shape))
record_list_result(syn,df,mode,y_train,y_test,trainPredict,testPredict,target,batch_size,save_path,n_past,n_features,n_future)
def wav_dl_wav_run(model_list, batch, syn):
X, _ = autosplit(data_cA3)
cA3ytrain, cA3ytest = run_code_editv2(model_list[0], X, yA3_ori, batch)
X, _ = autosplit(data_cD3)
cD3ytrain, cD3ytest = run_code_editv2(model_list[1], X, yD3_ori, batch)
X, _ = autosplit(data_cD2)
cD2ytrain, cD2ytest = run_code_editv2(model_list[2], X, yD2_ori, batch)
# X,_=autosplit(data_cD1)
# cD1ytrain,cD1ytest = run_code_editv2(model_list[3],X,yD1_ori,batch)
trainPredict = inverse_WT([cA3ytrain, cD3ytrain, cD2ytrain]) #,cD1ytrain])
testPredict = inverse_WT([cA3ytest, cD3ytest, cD2ytest]) #,cD1ytest])
_, Y = autosplit(data_mar)
y_train, y_test = Y[0], Y[1]
record_list_result(syn, df, DLtype, y_train, y_test, trainPredict,
testPredict, target, batch_size, save_path, n_past,
n_features, n_future)
def wav_dl_wav_run(model_list, batch, syn):
global n_features
check_PCA = True
n_features = n_pca
X, _ = autosplit(data_cA3, check_PCA)
cA3ytrain, cA3ytest = run_code_editv2(model_list[0], X, yA3_ori, batch)
X, _ = autosplit(data_cA2, check_PCA)
cA2ytrain, cA2ytest = run_code_editv2(model_list[0], X, yA2_ori, batch)
X, _ = autosplit(data_cA1, check_PCA)
cA1ytrain, cA1ytest = run_code_editv2(model_list[0], X, yA1_ori, batch)
X, _ = autosplit(data_cD3, check_PCA)
cD3ytrain, cD3ytest = run_code_editv2(model_list[1], X, yD3_ori, batch)
X, _ = autosplit(data_cD2, check_PCA)
cD2ytrain, cD2ytest = run_code_editv2(model_list[2], X, yD2_ori, batch)
X, _ = autosplit(data_cD1, check_PCA)
cD1ytrain, cD1ytest = run_code_editv2(model_list[3], X, yD1_ori, batch)
trainPredict_3 = inverse_WT([cA3ytrain, cD3ytrain, cD2ytrain, cD1ytrain])
testPredict_3 = inverse_WT([cA3ytest, cD3ytest, cD2ytest, cD1ytest])
trainPredict_2 = inverse_WT([cA2ytrain, cD2ytrain, cD1ytrain])
testPredict_2 = inverse_WT([cA2ytest, cD2ytest, cD1ytest])
trainPredict_1 = inverse_WT([cA1ytrain, cD1ytrain])
testPredict_1 = inverse_WT([cA1ytest, cD1ytest])
#-------------------------------
n_features = len(data_mar.columns)
_, Y = autosplit(data_mar)
y_train, y_test = Y[0], Y[1]
record_list_result('c3' + syn, df, DLtype, y_train, y_test, trainPredict_3,
testPredict_3, target, batch_size, save_path, n_past,
n_features, n_future)
record_list_result('c2' + syn, df, DLtype, y_train, y_test, trainPredict_2,
testPredict_2, target, batch_size, save_path, n_past,
n_features, n_future)
record_list_result('c1' + syn, df, DLtype, y_train, y_test, trainPredict_1,
testPredict_1, target, batch_size, save_path, n_past,
n_features, n_future)
n_features = n_pca
