def createPredictionModel(trainX, trainY, method = 'LR'):
print('Creating base prediction model')
if method == 'LR':
model = LinearRegression(fit_intercept=True)
elif method == 'Ridge':
model = Ridge(5)
elif method == 'keras':
from keras.models import Sequential
from keras.layers import Dense, Dropout
model = Sequential()
model.add(Dense(units=3, activation='relu', input_dim=trainX.shape[1]))
model.add(Dropout(0.01))
model.add(Dense(units=1))
model.compile(loss='mse', optimizer='adam')
else:
print('Unknown model! Implement yourself?')
raise ValueError()
model.fit(trainX, trainY)#, epochs=50, verbose=2) #do not use model = when using keras
res = model.predict(trainX) - trainY # calculate residuals
stdevRes = res.std() # calculate the standard deviation of the residuals
return model, res, stdevRes
def get_classifier(name_of_reg, params):
reg = None
if name_of_reg == 'MultiLinear':
reg = LinearRegression()
reg.fit(X_train, y_train)
elif name_of_reg == 'Support Vector':
reg = SVR(kernel=params['kernel'])
reg.fit(X_train, y_train)
elif name_of_reg == 'DecisionTree':
reg = DecisionTreeRegressor(random_state=0)
reg.fit(X_train, y_train)
elif name_of_reg == 'RandomForest':
reg = RandomForestRegressor(
n_estimators=params['n_estimators'],
random_state=0,
min_samples_leaf=.0001)
reg.fit(X_train, y_train)
elif name_of_reg == 'ExtraTree':
reg = ExtraTreesRegressor(
n_estimators=params['n_estimators'])
reg.fit(X_train, y_train)
elif name_of_reg == 'GradientBoosting':
reg = GradientBoostingRegressor(random_state=0)
reg.fit(X_train, y_train)
elif name_of_reg == 'XGBoost':
reg = XGBRegressor()
reg.fit(X_train, y_train)
elif name_of_reg == 'Artificial Neural Network':
reg = tf.keras.models.Sequential()
reg.add(
tf.keras.layers.Dense(units=60, activation='relu'))
reg.add(
tf.keras.layers.Dense(units=60, activation='relu'))
reg.add(tf.keras.layers.Dense(units=1))
reg.compile(optimizer='adam',
loss='mean_squared_error')
reg.fit(X_train,
y_train,
batch_size=32,
epochs=params['epochs'])
else:
st.warning('Select your choice of algorithm')
return reg
def fitted_q_iteration(self,
four_tuples_set,
stop,
algo="Linear Regression"):
N = 0
print("Computing fitted q iteration ...")
print("{} / 100".format((N / stop) * 100))
while N < stop: # temp stopping condition
N += 1
X = []
y = []
for t in four_tuples_set:
X.append([t[0][0], t[0][1], t[1]])
if N == 1:
y.append(t[2])
else:
y.append(t[2] + self.domain.d_factor * max(
self.qn_approximation[-1].predict(
np.array([t[3][0], t[3][1], -4]).reshape(1, -1))
[0], self.qn_approximation[-1].predict(
np.array([t[3][0], t[3][1], 4]).reshape(1, -1))[0])
)
if algo == "Linear Regression":
model = LinearRegression()
elif algo == "Extremely Randomized Trees":
model = ExtraTreesRegressor(n_estimators=10)
elif algo == "Neural Network":
X = np.array(X)
y = np.array(y)
model = Sequential()
model.add(Dense(8, input_dim=3, activation='relu'))
model.add(Dense(4, activation='relu'))
model.add(Dense(1, activation='linear'))
model.compile(loss='mean_squared_error',
optimizer='adam',
metrics=['mse'])
# model.fit(X, y, epochs=10, batch_size=10, verbose=0)
model.fit(X, y, epochs=100, batch_size=128, verbose=2)
self.qn_approximation.append(model)
if algo != "Neural Network":
self.qn_approximation.append(
model.fit(np.array(X), np.array(y)))
print("{} / 100".format((N / stop) * 100))
return self.qn_approximation[-1]
print("Test Set shape - ", X_test.shape)
# In[ ]:
model = Sequential()
model.add(Dense(64, input_dim=X_train.shape[1], activation='relu'))
#model.add(Dense(1024, activation='relu'))
#model.add(Dense(512, activation='relu'))
#model.add(Dense(1024, activation='relu'))
model.add(Dense(512, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(1)) # Output
opt = keras.optimizers.Adam(learning_rate=0.01)
model.compile(optimizer=opt,loss='mean_squared_error')
estp = EarlyStopping(monitor='val_loss', min_delta=0,patience=5, verbose=1, mode='auto',restore_best_weights=True)
model.fit(X_train,y_train,validation_split=0.15,shuffle='True',verbose=2,epochs=200, callbacks=[estp])
# In[ ]:
model.summary()
# In[ ]:
pred9 = model.predict(X_test)
mse9 = mean_squared_error(y_test, pred9)
X = np.reshape(xs, (-1, 1))
y = np.reshape(ys, (-1, 1))
X_test = np.array([10, 20, -2])
y_test = np.array([19.0, 39, -5])
model.fit(X, y)
prediction = model.predict(np.reshape(X_test, (-1, 1)))
print("MAE:", mean_absolute_error(y_test, prediction))
print("Expected: [[-5.]]", "Got:", model.predict(np.reshape([-2], (-1, 1))))
# Tensorflow
print("\n##### USING TENSORFLOW")
model = Sequential()
model.add(Dense(units=1, input_shape=[1]))
# SGD: Stochastic Gradient Descent
model.compile(optimizer="sgd", loss="mean_squared_error")
model.fit(
xs,
ys,
epochs=500,
)
print("Expected: [[19.]]", "Got:", model.predict([10.0]))
# Adding the input layer and the first hidden layer
regressor.add(
Dense(output_dim=6, init='uniform', activation='relu', input_dim=12))
# Adding the second hidden layer
regressor.add(Dense(output_dim=6, init='uniform', activation='relu'))
# Adding the second hidden layer
regressor.add(Dense(output_dim=6, init='uniform', activation='relu'))
# Adding the output layer
regressor.add(Dense(output_dim=1, init='uniform', activation='linear'))
# Compiling the ANN
regressor.compile(optimizer='adam',
loss='mean_absolute_error',
metrics=['mean_absolute_error'])
# Fitting the ANN to the Training set
regressor.fit(X_train, y_train, batch_size=10, nb_epoch=100)
# Predicting the Test set results
y_pred = regressor.predict(X_test)
y_pred.reshape([
1204,
])
y_pred.shape
#Calculating Score
import numpy as np
# import math
# use neural network
import keras
from keras.layers import Dense
from keras.models import Sequential
from keras import backend
from matplotlib import pyplot
def R2(y_true, y_pred):
return 1- (backend.mean(backend.square(y_pred - y_true), axis=-1)/backend.mean(backend.square(backend.mean(y_true) - y_true), axis=-1))
n_cols = X.shape[1]
input_shape = (n_cols,)
# Specify the model
model = Sequential()
model.add(Dense(350, activation='relu', input_shape = input_shape))
model.add(Dense(200, activation='relu'))
model.add(Dense(150, activation='relu'))
model.add(Dense(1))
# Compile the model
model.compile(optimizer='adam', loss='mean_squared_error', metrics=['mse', 'mae','mape', R2])
# train model
history = model.fit(train_features, train_labels, validation_data=(test_features,test_labels), epochs=1000, batch_size=1200)
# plot metrics
pyplot.plot(history.history['val_mean_squared_error'])
pyplot.plot(history.history['val_mean_absolute_error'])
pyplot.plot(history.history['val_mean_absolute_percentage_error'])
pyplot.plot(history.history['val_R2'])
pyplot.show()
regressor = Sequential()
regressor.add(Dense(units = 500, kernel_initializer = 'uniform', activation = 'relu', input_dim = 1))
regressor.add(Dropout(.2))
regressor.add(Dense(units = 500, kernel_initializer = 'uniform', activation = 'relu'))
regressor.add(Dropout(.2))
regressor.add(Dense(units = 500, kernel_initializer = 'uniform', activation = 'relu'))
regressor.add(Dropout(.2))
regressor.add(Dense(units = 1, kernel_initializer = 'uniform', activation = 'sigmoid'))
regressor.compile(optimizer = 'adam', loss = 'mean_squared_error')
regressor.fit(X_train, y_train, batch_size = 32, epochs = 200)
regressor.save('1.h5')
del regressor
regressor = load_model('1.h5')
real_stock_price = np.array(X_test)
inputs = real_stock_price
predicted_stock_price = regressor.predict(inputs)
def modelling(X_train,
y_train,
X_test,
y_test,
fs='lasso',
method='ols',
select=500):
if method == 'ols':
from sklearn.linear_model import LinearRegression
mod = LinearRegression().fit(X_train, y_train)
if method == 'elasticNet':
from sklearn.linear_model import ElasticNetCV
mod = ElasticNetCV(l1_ratio=[.1, .5, .7, .9, .95, .99, 1],
cv=10,
tol=0.001,
n_jobs=7)
mod.fit(X_train, y_train)
if method == 'xgboost':
import xgboost as xg
max_depth = 3
min_child_weight = 10
subsample = 0.5
colsample_bytree = 0.6
objective = 'reg:linear'
num_estimators = 1000
learning_rate = 0.3
mod = xg.XGBRegressor(max_depth=max_depth,
min_child_weight=min_child_weight,
subsample=subsample,
colsample_bytree=colsample_bytree,
objective=objective,
n_estimators=num_estimators,
learning_rate=learning_rate)
mod.fit(X_train, y_train)
# implement CV
if method == 'nn':
from sklearn.preprocessing import StandardScaler
from keras.models import Sequential
from keras.layers import Dense
from keras.callbacks import EarlyStopping
from keras.callbacks import ModelCheckpoint
from keras.models import load_model
mod = Sequential()
# input layer
mod.add(Dense(50, activation='relu', input_shape=(int(select), )))
# hidden layer
mod.add(Dense(50, activation='relu'))
# output layer
mod.add(Dense(1, activation='linear'))
# mod.summary()
mod.compile(loss='mse', optimizer='adam', metrics=['accuracy'])
# patient early stopping and select best model (not always the last)
es = EarlyStopping(monitor='val_loss',
mode='min',
verbose=1,
patience=200)
mc = ModelCheckpoint('best_model.h5',
monitor='val_acc',
mode='max',
verbose=1,
save_best_only=True)
history = mod.fit(X_train,
y_train,
epochs=1000,
batch_size=25,
verbose=1,
validation_data=(Xt, y_test),
callbacks=[es])
# pickle.dump(mod, open('models/' + fs + '_' + method + '_' +
# select + '.sav', 'wb'))
if method == 'nn':
rmse = (sum((np.concatenate(mod.predict(X_test)) - y_test)**2) /
y_test.size)**(.5)
else:
rmse = (sum((mod.predict(X_test) - y_test)**2) / y_test.size)**(.5)
return mod, rmse
"""
# ANN
import keras
from keras.models import Sequential
from keras.layers import Dense
classifier = Sequential()
classifier.add(
Dense(units=9,
kernel_initializer='uniform',
activation='relu',
input_dim=19))
classifier.add(Dense(units=4, kernel_initializer='uniform', activation='relu'))
classifier.add(Dense(units=1, kernel_initializer='uniform', activation='relu'))
classifier.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
classifier.fit(X, y, batch_size=10, epochs=200)
#Confusion_Matrix
cm = confusion_matrix(y_test, y_pred)
print(cm)
pid = test['PassengerId']
test = test.iloc[:, 1:].drop(['Name', 'Ticket', 'Cabin'], axis=1)
test['Pclass'] = test['Pclass'] / 3
test['Sex'] = test['Sex'].replace('female', 0).replace('male', 1)
test['Age'] = test['Age'].fillna(round(test['Age'].mean()))
test['Age'] = test['Age'] / max(test['Age'])
# 当SibSp不等于0-5中任何一值时，即为8
train_X, test_X, train_label, test_label = train_test_split(X,
Y,
test_size=0.1,
shuffle=False)
train_X = np.array(train_X)
test_X = np.array(test_X)
train_label = np.array(train_label)
test_label = np.array(test_label)
model = Sequential()
#add model layers
model.add((LSTM(128, return_sequences=True)))
model.add((LSTM(64, return_sequences=False)))
model.add(Dense(16, activation='relu'))
model.add(Dense(1, activation='linear'))
model.compile(optimizer='RMSprop', loss='mse')
model.fit(train_X,
train_label,
validation_data=(test_X, test_label),
epochs=50,
shuffle=False)
print(model.evaluate(test_X, test_label))
# model.summary()
predicted = model.predict(test_X)
test_label[:, 0] = y_scaler.inverse_transform(test_label[:, 0])
predicted = np.array(predicted[:, 0]).reshape(-1, 1)
predicted = y_scaler.inverse_transform(predicted)
plt.plot(test_label[:, 0], color='black', label=' Stock Price')
plt.plot(predicted, color='green', label='Predicted Stock Price')
plt.title(' Stock Price Prediction')
plt.xlabel('Time')
test_X = test_X.reshape(test_X.shape[0],7,50,1)
model = Sequential()
#add model layers
model.add(TimeDistributed(Conv1D(128, kernel_size=1, activation='relu', input_shape=(None,50,1))))
model.add(TimeDistributed(MaxPooling1D(2)))
model.add(TimeDistributed(Conv1D(256, kernel_size=1, activation='relu')))
model.add(TimeDistributed(MaxPooling1D(2)))
model.add(TimeDistributed(Conv1D(512, kernel_size=1, activation='relu')))
model.add(TimeDistributed(MaxPooling1D(2)))
model.add(TimeDistributed(Flatten()))
model.add(Bidirectional(LSTM(200,return_sequences=True)))
model.add(Dropout(0.25))
model.add(Bidirectional(LSTM(200,return_sequences=False)))
model.add(Dropout(0.5))
model.add(Dense(1, activation='linear'))
model.compile(optimizer='adam', loss='mse')
model.fit(train_X, train_label, validation_data=(test_X,test_label), epochs=200)
print(model.summary())
print(model.evaluate(test_X,test_label))
# model.summary()
# predicted = model.predict(test_X)
# test_label = (test_label[:,0])
# predicted = np.array(predicted[:,0]).reshape(-1,1)
# for j in range(len_t , len_t + len(test_X)):
# temp =stock.iloc[j,4]
# test_label[j - len_t] = test_label[j - len_t] * temp + temp
# predicted[j - len_t] = predicted[j - len_t] * temp + temp
# plt.plot(test_label, color = 'black', label = ' Stock Price')
# plt.plot(predicted, color = 'green', label = 'Predicted Stock Price')
# plt.title(' Stock Price Prediction')
# plt.xlabel('Time')
# Regression
total_train = np.c_[image_train, desc_train, title_train]
model = LinearRegression(normalize=True)
model.fit(total_train, y_train)
total_test = np.c_[image_outcome, desc_outcome, title_outcome]
total_outcome = model.predict(total_test)
total_outcome[total_outcome >= 0.5] = 1
total_outcome = total_outcome.astype(int)
print("Linear Regression:", sklearn.metrics.f1_score(total_outcome,y_test,average = 'micro')*100)
# Neural Network
input_im = Input(shape=(122,))
input_de = Input(shape=(122,))
input_ti = Input(shape=(122,))
combined = keras.layers.concatenate([input_im, input_de, input_ti])
z = Dense(330, activation = 'sigmoid')(combined)
z = Dense(270, activation = 'tanh')(z)
z = Dense(122, activation = 'sigmoid')(z)
model = Model(inputs=[input_im, input_de, input_ti], outputs=z)
model.summary()
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
model.fit([image_train, desc_train, title_train], y_train, epochs=20, batch_size=256)
y_out = model.predict([image_outcome, desc_outcome, title_outcome])
y_out[y_out > 0.5] = 1
y_out = y_out.astype(int)
print("NN:", f1_score(y_out, y_test, average='micro'))
import keras
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras import optimizers
sgd = optimizers.SGD(lr=0.1, decay=1e-6, momentum=0.9, nesterov=True)
model = Sequential()
model.add(Dense(units=3, activation='relu', input_shape=(3, )))
model.add(Dense(units=300, activation='relu'))
model.add(Dense(units=300, activation='relu'))
model.add(Dense(units=1, activation='sigmoid'))
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
model.fit(X_train, y_train, batch_size=32, epochs=1000)
y_pred = model.predict(X_test)
y_pred_D = sc_y.inverse_transform(y_pred)
score = model.evaluate(X_test, Y_test)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
from sklearn.model_selection import cross_val_score
test = cross_val_score(estimator=model,
X=X_train,
y=Y_train,
def model_predictions(modeloption, x_train, y_train, x_test, y_test):
if modeloption == 'lineareg':
model = LinearRegression()
model.fit(x_train, y_train) # Training
y_predicted = model.predict(x_test) # Test
elif modeloption == 'ridge':
model = RidgeCV(alphas=ALPHAS)
model.fit(x_train, y_train)
print(model.alpha_)
y_predicted = model.predict(x_test)
elif modeloption == 'mlp':
# Build Keras model
model = Sequential()
"""
#model.add(keras.layers.Dropout(0.2, input_shape=(x_train.shape[1],)))
model.add(Dense(NEURONSPERLAYER, input_shape =(x_train.shape[1],)))
model.add(Activation('relu'))
#model.add(keras.layers.Dropout(0.2))
#model.add(Dense(NEURONSPERLAYER))
#model.add(Activation('relu'))
#model.add(keras.layers.Dropout(0.2))
model.add(Dense(NEURONSOUTPUT))
model.add(Activation('linear'))
"""
#trial11
#model.add(keras.layers.Dropout(0.3, input_shape=(x_train.shape[1],)))
model.add(
Dense(NEURONSPERLAYER,
activation='sigmoid',
input_shape=(x_train.shape[1], )))
model.add(Dense(1000, activation=None))
model.compile(loss='mean_squared_error', optimizer=OPTIMIZER)
history = model.fit(x_train,
y_train,
epochs=EPOCHS,
batch_size=BATCH,
verbose=0)
y_predicted = model.predict(x_test,
batch_size=BATCH,
verbose=0,
steps=None)
# show training loss and test loss
print(history.history['loss'])
print(model.evaluate(x_test, y_test, batch_size=BATCH, verbose=0))
elif modeloption == 'knn':
model = KNeighborsRegressor(n_neighbors=NEIGHBORS, weights='distance')
model.fit(x_train, y_train)
y_predicted = model.predict(x_test)
elif modeloption == 'kernelreg':
model = KernelRidge(kernel=KERNEL,
degree=DEGREE,
alpha=0.001,
coef0=10)
model.fit(x_train, y_train)
y_predicted = model.predict(x_test)
return y_predicted
import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.optimizers import SGD
model = Sequential()
model.add(Dense(units=10, input_dim=1))
model.add(Activation('tanh'))
model.add(Dense(units=1))
model.add(Activation('tanh'))
sgd = SGD(lr=0.3)
model.compile(optimizer=sgd, loss='mse')
for step in range(3):
cost = model.train_on_batch(user1.month, user1.grade)
if step % 6 == 0:
print('cost: ', cost)
W, b = model.layers[0].get_weights()
print('W：', W, ' b: ', b)
print(len(model.layers))
y_pred = model.predict(user1.month)
plt.scatter(user1.month, user1.grade)
plt.plot(user1.month, user1.grade, 'r-', lw=2, label="best line")
plt.legend(loc=1)
# implement neural network
model = Sequential([
Dense(9, input_shape=(9, ), activation='relu'),
Dense(20, activation='relu'),
Dense(1, activation='linear'),
])
model.summary(print_fn=lambda line: logger.info(line))
# compile the model
learning_rate = 0.001
logger.info('Compile the model with Learning rate = %f', learning_rate)
model.compile(Adam(lr=learning_rate),
loss='mean_squared_error',
metrics=['mse', 'mae'])
# train the model
history = model.fit(x_train,
y_train,
validation_split=0.2,
batch_size=32,
epochs=6000,
verbose=2)
logger.info(history.history.keys())
# "Loss"
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
def r2_regression(variables,
targets,
num_ensemble=10,
method="linear",
nn_epochs=30,
gb_depth=3,
gb_n_estimators=100,
gb_alpha=0.4,
gb_lambda=0.4):
assert method in valid_methods
r_squared_val = []
r_squared_train = []
num_variables = variables.shape[-1]
iou_predictions = []
print("Aggregating {} regression over {} ensemble members...".format(
method, num_ensemble))
for i in tqdm.tqdm(range(num_ensemble)):
np.random.seed(i)
val_mask = np.random.rand(len(targets)) < 0.2
train_mask = np.logical_not(val_mask)
variables_val, variables_train = variables[val_mask, :], variables[
train_mask, :]
targets_val, targets_train = targets[val_mask], targets[train_mask]
if method == "linear":
model = LinearRegression().fit(variables_train, targets_train)
elif method == "shallow nn":
model = shallow_net_model(num_variables)
model.compile(loss='mean_squared_error',
optimizer='adam',
metrics=[shallow_net_stddev])
model.fit(variables_train,
targets_train,
epochs=nn_epochs,
batch_size=128,
verbose=0)
elif method == "gradient boost":
model = XGBRegressor(verbosity=0,
max_depth=gb_depth,
colsample_bytree=0.5,
n_estimators=gb_n_estimators,
reg_alpha=gb_alpha,
reg_lambda=gb_lambda).fit(
variables_train, targets_train)
prediction = np.clip(model.predict(variables), 0, 1)
if i == 0:
iou_predictions.append(targets[val_mask])
iou_predictions.append(prediction[val_mask])
r_squared_val.append(r2_score(targets_val, prediction[val_mask]))
r_squared_train.append(r2_score(targets_train, prediction[train_mask]))
iou_predictions = np.array(iou_predictions)
r_squared_val, r_squared_train = np.array(r_squared_val), np.array(
r_squared_train)
frame = pd.DataFrame({
"mean R^2 val": [np.mean(r_squared_val)],
"std R^2 val": [np.std(r_squared_val)],
"mean R^2 train": [np.mean(r_squared_train)],
"std R^2 train": [np.std(r_squared_train)]
})
return iou_predictions, frame
plt.title("Simple Linear Regression Model")
plt.plot(x, y, '.',label="Origin")
plt.plot(x, pred_y,'.',label="Model")
plt.legend()
plt.xlabel("Key")
plt.ylabel("Pred_Pos = CDF(Key)")
plt.show()
model = Sequential()
model.add(Dense(8, input_dim=1, activation="relu"))
model.add(Dense(8, activation="relu"))
model.add(Dense(1))
sgd=keras.optimizers.SGD(lr=0.0001) # lr:學習率,可調參數
model.compile(loss="mse", optimizer=sgd, metrics=["mse"])
model.fit(norm_x, y, epochs=1000, batch_size=32, verbose=0) # norm_x:訓練資料, y:訓練目標
pred_y = model.predict(norm_x)
plt.title("Neural Network 8x8 Model")
plt.plot(x, y, '.',label="Origin")
plt.plot(x, pred_y,'.',label="Model")
plt.legend()
plt.xlabel("Key")
plt.ylabel("Pred_Pos = CDF(Key)")
plt.show()
model = Sequential()
model.add(Dense(16, input_dim=1, activation="relu"))
model.add(Dense(16, activation="relu"))
activation='relu'))
# The Hidden Layers :
'''
NN_model.add(Dense(2048, kernel_initializer='normal',activation='relu'))
NN_model.add(Dense(1024, kernel_initializer='normal',activation='relu'))
'''
model.add(Dense(512, kernel_initializer='normal', activation='relu'))
model.add(Dense(256, kernel_initializer='normal', activation='relu'))
# The Output Layer :
model.add(Dense(1, kernel_initializer='normal', activation='linear'))
# Compile the network :
model.compile(loss='mean_absolute_error',
optimizer='adam',
metrics=['mean_absolute_error'])
#NN_model.compile(optimizer='adam', loss='mean_absolute_error', metrics=['accuracy'])
model.summary()
checkpoint_name = 'Weights-{epoch:03d}--{val_loss:.5f}.hdf5'
checkpoint = ModelCheckpoint(checkpoint_name,
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='auto')
callbacks_list = [checkpoint]
model.fit(X_train,
y_train,
for i in range(60,len(train)):
x_train.append(scaled_data[i-60:i,0])
y_train.append(scaled_data[i,0])
x_train, y_train = np.array(x_train), np.array(y_train)
x_train = np.reshape(x_train, (x_train.shape[0],x_train.shape[1],1))
#check for best units
myRMS = []
for p in range (40,60):
model = Sequential()
model.add(LSTM(units=p, return_sequences=True, input_shape=(x_train.shape[1],1)))
model.add(LSTM(units=p))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(x_train, y_train, epochs=10, batch_size=32, verbose=2)
#predicting values, using past 60 from the train data
inputs = new_data[len(new_data) - len(valid) - 60:].values
inputs = inputs.reshape(-1,1)
inputs = scaler.transform(inputs)
X_test = []
for i in range(60,inputs.shape[0]):
X_test.append(inputs[i-60:i,0])
X_test = np.array(X_test)
X_test = np.reshape(X_test, (X_test.shape[0],X_test.shape[1],1))
closing_price = model.predict(X_test)
closing_price = scaler.inverse_transform(closing_price)
atom_state, bond_state = message_block(atom_state, bond_state,
connectivity)
atom_state = Dense(atom_features // 2, activation='softplus')(atom_state)
atom_state = Dense(1)(atom_state)
atom_state = Add()([atom_state, atomwise_energy])
output = ReduceAtomToMol(reducer='sum')([atom_state, snode_graph_indices])
model = GraphModel(
[node_graph_indices, atom_types, distance_rbf, connectivity], [output])
lr = 5E-4
epochs = 500
model.compile(optimizer=keras.optimizers.Adam(lr=lr), loss='mae')
model.summary()
model_name = 'schnet_edgeupdate_fixed'
if not os.path.exists(model_name):
os.makedirs(model_name)
filepath = model_name + "/best_model.hdf5"
checkpoint = ModelCheckpoint(filepath,
save_best_only=True,
period=10,
verbose=1)
csv_logger = CSVLogger(model_name + '/log.csv')
