def main(argv): """ Builds, Trians, and evaluates the model. """ assert len(argv) == 1 # laod data from local disk. (x_train_dev, y_train_dev), (x_train, y_train), (x_dev, y_dev), (x_test, y_test), ( series_mean, series_max, series_min) = load_normalized_data("orig_day_full_imf1.xlsx") # Build the training input_fn def input_train(features=x_train, labels=y_train, batch_size=512): """ An input function for training """ # convert the input to a Dataset dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels)) # Shffling with a buffer larger than the data set ensures # that the examples are will mixed. dataset = dataset.shuffle(4000).batch( batch_size).repeat().make_one_shot_iterator().get_next() return dataset # Build the validation input_fn def input_dev(features=x_dev, labels=y_dev, batch_size=512): # Convert the input to a Dataset dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels)) # Shuffling dataset = dataset.shuffle(2000).batch( batch_size).make_one_shot_iterator().get_next() return dataset feature_columns = [ tf.feature_column.numeric_column("X1"), tf.feature_column.numeric_column("X2"), tf.feature_column.numeric_column("X3"), tf.feature_column.numeric_column("X4"), tf.feature_column.numeric_column("X5"), tf.feature_column.numeric_column("X6"), tf.feature_column.numeric_column("X7"), tf.feature_column.numeric_column("X8"), tf.feature_column.numeric_column("X9"), tf.feature_column.numeric_column("X10"), tf.feature_column.numeric_column("X11"), tf.feature_column.numeric_column("X12"), tf.feature_column.numeric_column("X13"), tf.feature_column.numeric_column("X14"), tf.feature_column.numeric_column("X15"), tf.feature_column.numeric_column("X16"), # tf.feature_column.numeric_column("X17"), # tf.feature_column.numeric_column("X18"), # tf.feature_column.numeric_column("X19"), ] my_check_point_config = tf.estimator.RunConfig( save_checkpoints_steps=50, keep_checkpoint_max=1000 #Retain the 50most recent checkpoints ) for learning_rate in [0.01]: decay_steps = 1000 # Learning rate decay steps decay_rate = 0.98 # Learning rate decay rate hidden_units = [15] batch_size = 512 drop_rates = [0.0] # construct a hyperparameter str hparam_str = 'lr' + str(learning_rate) + '_ds' + str( decay_steps) + '_dr' + str(decay_rate) + '_hu' + str( hidden_units) + '_bs' + str(batch_size) + '_drop' + str( drop_rates) model_dir = model_path + hparam_str # Build a custom Estimator, using the model_fn # 'params' is passed through the 'model_fn' model = tf.estimator.Estimator( model_fn=my_dnn_regression_fn, model_dir=model_dir, params={ 'feature_columns': feature_columns, 'learning_rate': learning_rate, # without learning_rate decay 'decay_steps': decay_steps, 'decay_rate': decay_rate, 'optimizer': tf.train.AdamOptimizer, 'hidden_units': hidden_units, 'drop_rates': drop_rates }, config=my_check_point_config) fig = plt.figure(figsize=(16, 9)) ax221 = plt.subplot(2, 2, 1) ax221.set_title('train predict line') ax221.set_xlabel('Time(day)') ax221.set_ylabel('flow(' + r'$m^3$' + '/s)') ax221.grid() ax222 = plt.subplot(2, 2, 2) ax222.set_title('train predictions and records scatters') ax222.set_xlabel('predictions(' + r'$m^3$' + '/s)') ax222.set_ylabel('records(' + r'$m^3$' + '/s)') ax222.grid() ax223 = plt.subplot(2, 2, 3) ax223.set_title('develop predict line') ax223.set_xlabel('Time(day)') ax223.set_ylabel('flow(' + r'$m^3$' + '/s)') ax223.grid() ax224 = plt.subplot(2, 2, 4) ax224.set_title('develop predictions and records scatters') ax224.set_xlabel('predictions(' + r'$m^3$' + '/s)') ax224.set_ylabel('records(' + r'$m^3$' + '/s)') ax224.grid() for i in range(20): # Train the model model.train(input_fn=input_train, steps=STEPS) # Evaluate how the model performs on a data it has not yet seen. eval_result = model.evaluate(input_fn=input_dev, steps=STEPS) # The evaluation returns a python dictionary. The 'average loss' key is # hold the Mean Square Error (MSE) average_loss = eval_result['mse'] # Convert MSE to root mean square error (RMSE) print("\n" + 80 * "*") print("\nRMS error for the validation set: {:.8f}".format( average_loss)) print() train_pred_input_fn = tf.estimator.inputs.pandas_input_fn( x_train, shuffle=False) dev_pred_input_fn = tf.estimator.inputs.pandas_input_fn( x_dev, shuffle=False) # predict the training set train_pred_results = model.predict(input_fn=train_pred_input_fn) # predict the testing set dev_pred_results = model.predict(input_fn=dev_pred_input_fn) # Convert generator to numpy array train_predictions = np.array( list(p['predictions'] for p in train_pred_results)) dev_predictions = np.array( list(p['predictions'] for p in dev_pred_results)) train_predictions = train_predictions.reshape( np.array(y_train).shape) dev_predictions = dev_predictions.reshape(np.array(y_dev).shape) r2_train = r2_score(y_train, train_predictions) r2_dev = r2_score(y_dev, dev_predictions) print('r2_score_train = {:.10f}'.format(r2_train)) print('r2_score_dev = {:.10f}'.format(r2_dev)) # time series length train_t = np.linspace(1, y_train.size, y_train.size) # plot predict line for training set ax221.cla() ax221.plot(train_t, y_train, label='train records', color='blue') ax221.plot(train_t, train_predictions, label='train predictions', color='red') # plot scatters for training records and predictions ax222.cla() coeff = np.polyfit(train_predictions, y_train, 1) linear_fit = coeff[0] * train_predictions + coeff[1] ideal_fit = 1 * train_predictions ax222.plot(train_predictions, y_train, 'o', color='blue') ax222.plot(train_predictions, linear_fit, '--', color='red', label='Linear fit') ax222.plot(train_predictions, ideal_fit, '-', color='black', label='Ideal fit') # plot predict line for develop set dev_t = np.linspace(1, y_dev.size, y_dev.size) ax223.cla() ax223.plot(dev_t, y_dev, label='develop records', color='blue') ax223.plot(dev_t, dev_predictions, label='develop predictions', color='red') # PLOT scatters for developing records and predictions ax224.cla() coeff = np.polyfit(dev_predictions, y_dev, 1) linear_fit = coeff[0] * dev_predictions + coeff[1] ideal_fit = 1 * dev_predictions ax224.plot(dev_predictions, y_dev, 'o', color='blue') ax224.plot(dev_predictions, linear_fit, '--', color='red', label='Linear fit') ax224.plot(dev_predictions, ideal_fit, '-', color='black', label='Ideal fit') plt.pause(1)
def main(argv): """ Predict based on the trained model and specfic checkpoints. """ assert len(argv) == 1 # laod data from local disk. (x_train_dev, y_train_dev), (x_train, y_train), (x_dev, y_dev), (x_test, y_test), ( series_mean, series_max, series_min) = load_normalized_data("orig_day_full_imf1.xlsx", seed=123) # create feature colums feature_columns = [ tf.feature_column.numeric_column("X1"), tf.feature_column.numeric_column("X2"), tf.feature_column.numeric_column("X3"), tf.feature_column.numeric_column("X4"), tf.feature_column.numeric_column("X5"), tf.feature_column.numeric_column("X6"), tf.feature_column.numeric_column("X7"), tf.feature_column.numeric_column("X8"), tf.feature_column.numeric_column("X9"), tf.feature_column.numeric_column("X10"), tf.feature_column.numeric_column("X11"), tf.feature_column.numeric_column("X12"), tf.feature_column.numeric_column("X13"), tf.feature_column.numeric_column("X14"), tf.feature_column.numeric_column("X15"), tf.feature_column.numeric_column("X16"), # tf.feature_column.numeric_column("X17"), # tf.feature_column.numeric_column("X18"), # tf.feature_column.numeric_column("X19"), ] # recovery the model, and set the dropout rate to 0.0 model_path = 'F:/ml_fp_lytm/tf_projects/imf1_series/models/' current_model = 'lr0.01_ds1000_dr0.98_hu[5]_bs512_drop[0.0]' model_dir = model_path + current_model + '/' model = tf.estimator.Estimator( model_fn=my_dnn_regression_fn, model_dir=model_dir, params={ 'feature_columns': feature_columns, 'hidden_units': [5], 'drop_rates': [0.0] }, ) train_pred_input_fn = tf.estimator.inputs.pandas_input_fn(x_train, shuffle=False) dev_pred_input_fn = tf.estimator.inputs.pandas_input_fn(x_dev, shuffle=False) test_pred_input_fn = tf.estimator.inputs.pandas_input_fn(x_test, shuffle=False) # Use the specific file to predict checkpoint_path = model_dir + 'model.ckpt-23100' # predict the training set train_pred_results = model.predict(input_fn=train_pred_input_fn, checkpoint_path=checkpoint_path) # predict the developing set dev_pred_results = model.predict(input_fn=dev_pred_input_fn, checkpoint_path=checkpoint_path) # predict the testing set. test_pred_results = model.predict(input_fn=test_pred_input_fn, checkpoint_path=checkpoint_path) # Convert generator to numpy array train_predictions = np.array( list(p['predictions'] for p in train_pred_results)) dev_predictions = np.array(list(p['predictions'] for p in dev_pred_results)) test_predictions = np.array( list(p['predictions'] for p in test_pred_results)) # reshape the prediction to y shape. train_predictions = train_predictions.reshape(np.array(y_train).shape) dev_predictions = dev_predictions.reshape(np.array(y_dev).shape) test_predictions = test_predictions.reshape(np.array(y_test).shape) # compute R square r2_train = r2_score(y_train, train_predictions) r2_dev = r2_score(y_dev, dev_predictions) r2_test = r2_score(y_test, test_predictions) # compute MSE mse_train = mean_squared_error(y_train, train_predictions) mse_dev = mean_squared_error(y_dev, dev_predictions) mse_test = mean_squared_error(y_test, test_predictions) # compute MAE mae_train = mean_absolute_error(y_train, train_predictions) mae_dev = mean_absolute_error(y_dev, dev_predictions) mae_test = mean_absolute_error(y_test, test_predictions) # print('r2_score_train = {:.10f}'.format(r2_train)) print('r2_score_dev = {:.10f}'.format(r2_dev)) dump_train_dev_test_to_excel( path='F:/ml_fp_lytm/tf_projects/imf1_series/models/' + current_model + '.xlsx', y_train=y_train, train_pred=train_predictions, r2_train=r2_train, mse_train=mse_train, mae_train=mae_train, y_dev=y_dev, dev_pred=dev_predictions, r2_dev=r2_dev, mse_dev=mse_dev, mae_dev=mae_dev, y_test=y_test, test_pred=test_predictions, r2_test=r2_test, mse_test=mse_test, mae_test=mae_test, ) # print(test_predictions) # plot the predicted line plot_normreconvert_pred(y_train, train_predictions, series_mean, series_max, series_min, fig_savepath=model_path + current_model + '_train_pred.png') plot_normreconvert_relation(y_train, train_predictions, series_mean, series_max, series_min, fig_savepath=model_path + current_model + "_train_rela.png") plot_normreconvert_pred(y_dev, dev_predictions, series_mean, series_max, series_min, fig_savepath=model_path + current_model + "_dev_pred.png") # plot the relationship between the records and predcitions plot_normreconvert_relation(y_dev, dev_predictions, series_mean, series_max, series_min, fig_savepath=model_path + current_model + "_dev_rela.png") plot_normreconvert_pred(y_test, test_predictions, series_mean, series_max, series_min, fig_savepath=model_path + current_model + "_test_pred.png") # plot the relationship between the records and predcitions plot_normreconvert_relation(y_test, test_predictions, series_mean, series_max, series_min, fig_savepath=model_path + current_model + "_test_rela.png")
def main(argv): """ Builds, Trians, and evaluates the model. """ assert len(argv) == 1 # laod data from local disk. (x_train, y_train), (x_dev, y_dev), (x_test, y_test), ( series_mean, series_max, series_min ) = import_tanmiao.load_normalized_data('orig_day_full_X.xlsx') # Build the training input_fn def input_train(features=x_train, labels=y_train, batch_size=128): """ An input function for training """ # convert the input to a Dataset dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels)) # Shffling with a buffer larger than the data set ensures # that the examples are will mixed. dataset = dataset.shuffle(4000).batch( batch_size).repeat().make_one_shot_iterator().get_next() return dataset # Build the validation input_fn def input_dev(features=x_dev, labels=y_dev, batch_size=128): # Convert the input to a Dataset dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels)) # Shuffling dataset = dataset.shuffle(2000).batch( batch_size).make_one_shot_iterator().get_next() return dataset feature_columns = [ tf.feature_column.numeric_column("X1"), tf.feature_column.numeric_column("X2"), tf.feature_column.numeric_column("X3"), tf.feature_column.numeric_column("X4"), tf.feature_column.numeric_column("X5"), tf.feature_column.numeric_column("X6") # tf.feature_column.numeric_column("X7") ] # Build a custom Estimator, using the model_fn # 'params' is passed through the 'model_fn' model = tf.estimator.Estimator(model_fn=my_dnn_regression_fn, model_dir=model_path, params={ 'feature_columns': feature_columns, 'learning_rate': 0.1, 'decay_steps': 500, 'decay_rate': 0.98, 'optimizer': tf.train.AdamOptimizer, 'hidden_units': [20, 20, 20, 20] }) train_pred_input_fn = tf.estimator.inputs.pandas_input_fn(x_train, shuffle=False) space = [ Real(10**-5, 10**0, 'log-uniform', name='learning_rate'), Real(0.1, 0.8, 'log-uniform', name='drop_rates') ] def objective(**paramss): model = tf.estimator.Estimator(model_fn=my_dnn_regression_fn, model_dir=model_path, params={ 'feature_columns': feature_columns, 'learning_rate': paramss.get('learning_rate'), 'decay_steps': 1, 'decay_rate': 1, 'optimizer': tf.train.AdamOptimizer, 'hidden_units': [20, 20, 20, 20], 'drop_rates': paramss.get('drop_rates') }) # Train the model model.train(input_fn=input_train, steps=STEPS) pred = model.predict(input_fn=train_pred_input_fn) train_predictions = np.array(list(p['predictions'] for p in pred)) train_predictions = train_predictions.reshape(np.array(y_train).shape) y_train = np.array(y_train) return np.sum(np.abs(y_train - train_predictions)) res_gp = gp_minimize(objective, space, n_calls=50, random_state=0) print("minmun MAE=%.4f" % res_gp.fun)
def main(argv): """ Builds, Trians, and evaluates the model. """ assert len(argv) == 1 # laod data from local disk. (x_train, y_train), (x_dev, y_dev), (x_test,y_test),(series_mean,series_max,series_min) = import_tanmiao.load_normalized_data("orig_day_full_X.xlsx") # Build the training input_fn def input_train(features=x_train, labels=y_train, batch_size=128): """ An input function for training """ # convert the input to a Dataset dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels)) # Shffling with a buffer larger than the data set ensures # that the examples are will mixed. dataset = dataset.shuffle(4000).batch( batch_size).repeat().make_one_shot_iterator().get_next() return dataset # Build the validation input_fn def input_dev(features=x_dev, labels=y_dev, batch_size=128): # Convert the input to a Dataset dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels)) # Shuffling dataset = dataset.shuffle(2000).batch( batch_size).make_one_shot_iterator().get_next() return dataset feature_columns = [ tf.feature_column.numeric_column("X1"), tf.feature_column.numeric_column("X2"), tf.feature_column.numeric_column("X3"), tf.feature_column.numeric_column("X4"), tf.feature_column.numeric_column("X5"), tf.feature_column.numeric_column("X6"), # tf.feature_column.numeric_column("X7") ] # Build a custom Estimator, using the model_fn # 'params' is passed through the 'model_fn' model = tf.estimator.Estimator( model_fn=my_dnn_regression_fn, model_dir=model_path, params={ 'feature_columns': feature_columns, 'learning_rate': 0.01, 'optimizer': tf.train.AdamOptimizer, 'hidden_units': [20] }) # Train the model model.train(input_fn=input_train, steps=STEPS) # Evaluate how the model performs on a data it has not yet seen. eval_result = model.evaluate(input_fn=input_dev, steps=STEPS) # The evaluation returns a python dictionary. The 'average loss' key is # hold the Mean Square Error (MSE) average_loss = eval_result['rmse'] # train_average_loss = train_eval_result['rmse'] # Convert MSE to root mean square error (RMSE) print("\n" + 80 * "*") print("\nRMS error for the validation set: {:.2f}".format( average_loss)) # print("\nRMS error for the validation set: {:.2f}".format( # train_average_loss)) print() # test the model's performance based on test set test_pred_input_fn = tf.estimator.inputs.pandas_input_fn( x_test, shuffle=False) # The result of 'PREDICT' mode is a python generator test_pred_results = model.predict(input_fn=test_pred_input_fn) # print(list(test_pred_results)) # Convert generator to numpy array test_predictions = np.array(list(p['predictions'] for p in test_pred_results)) test_predictions = test_predictions.reshape(np.array(y_test).shape) # test_predictions_list = [] # for dictionary in list(test_pred_results): # # print(dictionary['predictions']) # test_predictions_list.append(dictionary['predictions']) # test_predictions = np.array(test_predictions_list) r2 = r2_score(y_test,test_predictions) print('r2_score = '+str(r2)) # print(test_predictions) # plot the predicted line plot_util.plot_normreconvert_pred( y_test, test_predictions, series_mean, series_max, series_min, fig_savepath=model_path + "test_pred.png") # plot the relationship between the records and predcitions plot_util.plot_normreconvert_relation( y_test, test_predictions, series_mean, series_max, series_min, fig_savepath=model_path + "test_rela.png")