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