plt.ylabel('MSE [USRetailPrice]')
# In[43]:
plt.figure(figsize=(10,7))
plotter.plot({'Basic': history}, metric = "mae")
plt.ylim([0, 30])
plt.ylabel('MAE [USRetailPrice]')
# In[44]:
loss, mae, mse = model.evaluate(normed_test_data, test_labels, verbose=2)
mae
# Issues:
# - MAE is \\$8.30 after one run, which is pretty high
# - Normalizing doesn't seem to work (?)
# In[ ]:
# In[ ]:
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')
plt.ylabel(' Stock Price')
plt.legend()
plt.show()
model = tf.contrib.learn.DNNClassifier(hidden_units=3 * [500],
n_classes=len(bins) + 1,
feature_columns=fc)
def input_fn():
fc = {'lags': tf.constant(data[cols_bin].values)}
la = tf.constant(
data['direction'].apply(lambda x: 0 if x < 0 else 1).values,
shape=[data['direction'].size, 1])
return fc, la
model.fit(input_fn=input_fn, steps=250) # %time 29.7s
model.evaluate(input_fn=input_fn, steps=1) # Binary predictions (0,1)...
pred = np.array(list(
model.predict(input_fn=input_fn))) # Binary predictions (0,1)...
data['pos_dnn_tf'] = np.where(
pred > 0, 1, -1) #...need to be transformed to market positions (-1, +1)
data['strat_dnn_tf'] = data['pos_dnn_tf'] * data['returns']
data[['returns', 'strat_dnn_tf']].sum().apply(np.exp)
#returns 1.110278
#strat_dnn_tf 2.114755
#dtype: float64
data[['returns', 'strat_dnn_tf']].cumsum().apply(np.exp).plot(figsize=(10, 6))
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,
cv=10,
scoring=None)
print(test.mean())
print(test.std())
model.summary()
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
def regression(asset, d, test_size):
# Report
fields = [
'label', 'n_train', 'n_test', 'model', 'train_loss',
'feature_importance', 'rmse'
]
results = []
# Data
feature_index = d.shape[1] - n_label
feature_names = d.columns[:feature_index]
n_feature = len(feature_names)
xs = d.iloc[:, :feature_index]
# Evaluate labels
for label_index in range(1, n_label + 1, 1):
label_name = d.columns[-label_index]
ys = list(d.iloc[:, -label_index])
train_xs, test_xs, train_ys, test_ys = train_test_split(
xs, ys, shuffle=False, test_size=test_size)
attributes = [label_name, len(train_ys), len(test_ys)]
# Evaluate models
for model_name in ['gbdt', 'lr', 'rnn']:
if model_name == 'gbdt':
# Model - xgboost
params = get_xgb_regression_params()
d_train = xgb.DMatrix(train_xs,
label=train_ys,
feature_names=feature_names)
d_test = xgb.DMatrix(test_xs,
label=test_ys,
feature_names=feature_names)
best_param, best_round = xgb_param_selection(
params, d_train, target='test-rmse-mean')
model = xgb.train(best_param,
d_train,
num_boost_round=best_round,
verbose_eval=False)
train_result = model.eval(d_train)
train_loss = float(train_result.split(':')[-1])
predictions = model.predict(d_test)
feature_importance = sorted(model.get_fscore().items(),
key=lambda x: x[1],
reverse=True)
elif model_name == 'lr':
model = LinearRegression()
model.fit(train_xs, train_ys)
train_predictions = model.predict(train_xs)
train_loss = math.sqrt(
mean_squared_error(train_ys, train_predictions))
predictions = model.predict(test_xs)
feature_importance = None
elif model_name == 'rnn':
# Normalized by training data
scaler = StandardScaler().fit(train_xs)
norm_xs = scaler.transform(xs)
sequnce_xs, sequence_ys = get_rnn_data(norm_xs, ys, rnn_length)
# Data
train_xs, test_xs, train_ys, test_ys = train_test_split(
sequnce_xs,
sequence_ys,
shuffle=False,
test_size=test_size)
model = get_rnn_model(rnn_length,
n_feature,
target='regression')
early_stopping = EarlyStopping(patience=30, monitor='val_loss')
history = model.fit(train_xs,
train_ys,
batch_size=batch_size,
epochs=1000,
validation_split=1.0 / 5,
callbacks=[early_stopping],
shuffle=False)
best_epoch = np.argmin(history.history['val_loss'])
model = get_rnn_model(rnn_length,
n_feature,
target='regression')
model.fit(train_xs,
train_ys,
batch_size=batch_size,
epochs=best_epoch)
train_loss = model.evaluate(train_xs, train_ys)[0]
predictions = model.predict(test_xs)
feature_importance = None
# print('RNN training history', history.history)
# Evaluation
mse = mean_squared_error(test_ys, predictions)
rmse = math.pow(mse, 0.5)
performance = [model_name, train_loss, feature_importance, rmse]
result = attributes + performance
results.append(result)
report = pd.DataFrame(results, columns=fields)
report.to_csv(get_regression_file_path(asset), index=False)
print(report)
checkpoint_path = "/content/gdrive/My Drive/Trained_Models/wine_binary_quality/wine_binary_quality.ckpt"
checkpoint_dir = os.path.dirname(checkpoint_path)
cp_callback = tf.keras.callbacks.ModelCheckpoint(filepath=checkpoint_path,
save_weights_only=True,
verbose=1)
history = model.fit(
normed_train_data, train_labels,
epochs=EPOCHS,
validation_split = 0.2,
# callbacks=[cp_callback],
)
test_loss, test_acc = model.evaluate(
normed_test_data,
test_labels,
verbose=2,
)
print('Test accuracy:', test_acc)
"""# Evaluate the model"""
probability_model = tf.keras.Sequential([model, tf.keras.layers.Softmax()])
predictions = probability_model.predict(normed_test_data)
"""# Export model to GDrive"""
#Graph to look at the full set of 3 class predictions
def plot_value_array(i, predictions_array, true_label):
predictions_array, true_label = predictions_array, true_label[i]
model.add(Dense(5, activation='sigmoid', use_bias=10))
model.add(Dense(3, activation='softmax'))
model.compile(optimizer='adam',loss='binary_crossentropy',metrics=['accuracy'])
early_stopping = EarlyStopping(monitor='loss', patience=1.99, mode='min')
history = model.fit(X_train, y_train, batch_size=64, epochs=100, verbose=1, validation_data= None,callbacks=[early_stopping])
from keras.models import model_from_json
model_json = model.to_json()
with open("model.json", "w") as json_file:
json_file.write(model_json)
model.save_weights("weights4.h5")
#Validating on the validation set
loss, acc = model.evaluate(X_valid, y_valid)
y_pred = model.predict(X_valid)
print(X_valid.shape)
list_of_vector = list()
for ele in y_pred:
vector = convert_pred_to_one_and_zeros(ele)
list_of_vector.append(vector)
y_pred = np.array(list_of_vector)
print('Validation Loss:', loss)
print('Validation Accuracy:',acc*100,'%')
print(model.summary())
#Confusion Matrix Validation
import sklearn.metrics as skm
import seaborn as sn
