def train(train_params): debug = True data_params = train_params['data_params'] model_params = train_params['model_params'] model_save_path = train_params['model_save_path'] logs_dir_path = train_params['logs_dir_path'] batch_size = model_params['batch_size'] num_epochs = model_params[ 'num_epochs'] # add early stopping, save best model input_num_features = model_params['input_num_features'] # 1 output_num_features = model_params['output_num_features'] look_back = model_params['look_back'] n_hidden = model_params['n_hidden'] learning_rate = model_params['learning_rate'] val_batch_size = batch_size visualize = train_params['visualize'] raw_values, X_train, y_train, X_validation, y_validation, scaler = preprocess_data( data_params) print(raw_values.shape, X_train.shape, y_train.shape, X_validation.shape, y_validation.shape) # print(X_train[0]) # print(X_train[0].shape) # print(X_train[0:2].shape) # gen = batch_generator(X_train, y_train, batch_size) # print(next(gen)[0].shape) # print(next(gen)[1].shape) train_loader = batch_generator(X_train, y_train, batch_size) val_loader = batch_generator(X_validation, y_validation, val_batch_size) train_writer = tf.summary.FileWriter(os.path.join( logs_dir_path, 'train')) #, accuracy.graph) val_writer = tf.summary.FileWriter( os.path.join(logs_dir_path, 'validation')) #, accuracy.graph) num_training_batches = X_train.shape[0] // batch_size num_validation_batches = X_validation.shape[0] // batch_size print("num_training_batches: {}, num_validation_batches: {}".format( num_training_batches, num_validation_batches)) x = tf.placeholder( tf.float32, [None, look_back, input_num_features]) # 1 feature (price) y = tf.placeholder(tf.float32, [None, output_num_features]) init_state_0_c = tf.placeholder(tf.float32, [None, n_hidden]) init_state_0_h = tf.placeholder(tf.float32, [None, n_hidden]) # **** model **** n_hidden = model_params['n_hidden'] learning_rate = model_params['learning_rate'] num_layers = model_params['num_layers'] prediction_num_features = model_params['output_num_features'] batch_size = model_params['batch_size'] weights = { 'out': tf.Variable(tf.random_normal([n_hidden, prediction_num_features])) } biases = {'out': tf.Variable(tf.random_normal([prediction_num_features]))} rnn_cell = tf.nn.rnn_cell.LSTMCell(n_hidden, state_is_tuple=True) rnn_tuple_state = tf.nn.rnn_cell.LSTMStateTuple(init_state_0_c, init_state_0_h) outputs, current_state = tf.nn.dynamic_rnn(rnn_cell, x, initial_state=rnn_tuple_state) # cur_state_0_c = current_state.c # cur_state_0_h = current_state.h tf.summary.histogram('rnn_outputs', outputs) prediction = tf.matmul(outputs[:, -1, :], weights['out']) + biases['out'] with tf.name_scope('Metrices'): # y = tf.reshape(y, [-1]) # necesary? # regular version VS v2 VS sparse # what about the shape of prediction VS shape of y?? # loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=prediction, labels=y)) loss = tf.losses.mean_squared_error( labels=y, predictions=prediction ) # is the loss calculated correctly? are these the params I need to pass? tf.summary.scalar('loss', loss) optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(loss) # in order to calculate rmse we need to transform data back to a price ## prediction_inverse = inverse_transforms(prediction, scaler) ## y_inverse = inverse_transforms(y, scaler) ## prediction_inverse = prediction_inverse.squeeze()[1:] ## y_test_inverse = y_test_inverse.squeeze() ## rmse = sqrt(mean_squared_error(prediction_inverse, y_inverse)) ## tf.summary.scalar('rmse', rmse) merged_summary = tf.summary.merge_all() saver = tf.train.Saver() _cur_state_0_c = np.zeros((batch_size, n_hidden), dtype=np.float32) _cur_state_0_h = np.zeros((batch_size, n_hidden), dtype=np.float32) _current_state = tuple((_cur_state_0_c, _cur_state_0_h)) ## print(_cur_state_0_c.shape) print( "Run 'tensorboard --logdir=./{}' to checkout tensorboard logs.".format( logs_dir_path)) print("==> training") with tf.Session() as sess: sess.run(tf.global_variables_initializer()) # training for epoch in tqdm.tqdm(range(num_epochs)): train_rmse = 0.0 for i, data in tqdm.tqdm(enumerate(train_loader, 0), total=num_training_batches): # print(i) if i == num_training_batches: print("*" * 50) break _x, _y = data _x = _x.reshape((-1, look_back, input_num_features)) _y = _y.reshape((-1, output_num_features)) _pred, _loss, _, _summary, _current_state = sess.run( [ prediction, loss, optimizer, merged_summary, current_state ], feed_dict={ x: _x, y: _y, init_state_0_c: _current_state[0], init_state_0_h: _current_state[1] }) train_writer.add_summary(_summary, i + num_training_batches * epoch) train_writer.close() saver.save(sess, model_save_path) validation_set_size = data_params['validation_set_size'] train_set_size = data_params['training_set_size'] predictions = list() ground_truths = list() print("==> validating") # print(num_validation_batches) for epoch in tqdm.tqdm(range(1)): total_rmse = 0.0 for i, data in tqdm.tqdm(enumerate(val_loader, 0), total=num_validation_batches): if i == 0: history = [] if i == num_validation_batches: break _x, _y = data _x = _x.reshape((-1, look_back, input_num_features)) _y = _y.reshape((-1, output_num_features)) _pred, _summary, _current_state = sess.run( [prediction, merged_summary, current_state], feed_dict={ x: _x, y: _y, init_state_0_c: _current_state[0], init_state_0_h: _current_state[1] }) # print(_pred.shape) # print(type(_pred)) # print(_pred) # _pred = np.squeeze(_pred, axis=0) # print(_pred, _pred.shape) # prediction_inverse = inverse_transforms(_pred, scaler) prediction_inverse = invert_scale(scaler, _x, _pred) # prediction_inverse = prediction_inverse.squeeze(axis=0) prediction_inverse = inverse_difference(raw_values, prediction_inverse, \ validation_set_size + 1 - i) predictions.append(prediction_inverse) ground_truths.append(raw_values[train_set_size + i + 1]) # why +1 ? # rmse = sqrt(mean_squared_error(prediction_inverse, _y)) print("predicted = {}, groud truth = {}".format(prediction_inverse, \ raw_values[train_set_size + i + 1])) # print("rmse: {}".format(rmse)) # print("\n") # total_rmse += rmse val_writer.close() # total_rmse /= num_validation_batches # rmse_2 = sqrt(mean_squared_error(ground_truths, predictions)) predictions = np.array(predictions) print("predictions.shape = {}, y_validation.shape = {}".format( predictions.shape, y_validation.shape)) rmse_2 = sqrt(mean_squared_error(y_validation, predictions)) # print("validation rmse: {}".format(total_rmse)) print("validation rmse 2: {}".format(rmse_2)) if visualize: plt.plot(ground_truths, 'r') plt.plot(predictions, 'b') plt.show()
def train(train_params): debug = True data_params = train_params['data_params'] model_params = train_params['model_params'] model_save_path = train_params['model_save_path'] logs_dir_path = train_params['logs_dir_path'] batch_size = model_params['batch_size'] num_epochs = model_params[ 'num_epochs'] # add early stopping, save best model input_num_features = model_params['input_num_features'] # 1 output_num_features = model_params['output_num_features'] look_back = model_params['look_back'] n_hidden = model_params['n_hidden'] learning_rate = model_params['learning_rate'] val_batch_size = batch_size visualize = train_params['visualize'] validate_only = train_params['validate_only'] trained_model_path = train_params['trained_model_path'] raw_values, X_train, y_train, X_validation, y_validation, scaler = preprocess_data( data_params) print(raw_values.shape, X_train.shape, y_train.shape, X_validation.shape, y_validation.shape) # print(X_train[0]) # print(X_train[0].shape) # print(X_train[0:2].shape) # gen = batch_generator(X_train, y_train, batch_size) # print(next(gen)[0].shape) # print(next(gen)[1].shape) train_loader = batch_generator(X_train, y_train, batch_size) val_loader = batch_generator(X_validation, y_validation, val_batch_size) train_writer = tf.summary.FileWriter(os.path.join( logs_dir_path, 'train')) #, accuracy.graph) val_writer = tf.summary.FileWriter( os.path.join(logs_dir_path, 'validation')) #, accuracy.graph) num_training_batches = X_train.shape[0] // batch_size num_validation_batches = X_validation.shape[0] // batch_size print("num_training_batches: {}, num_validation_batches: {}".format( num_training_batches, num_validation_batches)) x = tf.placeholder( tf.float32, [None, look_back, input_num_features]) # 1 feature (price) y = tf.placeholder(tf.float32, [None, output_num_features]) init_state_0_c = tf.placeholder(tf.float32, [None, n_hidden]) init_state_0_h = tf.placeholder(tf.float32, [None, n_hidden]) # **** model **** n_hidden = model_params['n_hidden'] learning_rate = model_params['learning_rate'] num_layers = model_params['num_layers'] prediction_num_features = model_params['output_num_features'] batch_size = model_params['batch_size'] weights = { 'out': tf.Variable(tf.random_normal([n_hidden, prediction_num_features])) } biases = {'out': tf.Variable(tf.random_normal([prediction_num_features]))} rnn_cell = tf.nn.rnn_cell.LSTMCell(n_hidden, state_is_tuple=True) rnn_tuple_state = tf.nn.rnn_cell.LSTMStateTuple(init_state_0_c, init_state_0_h) outputs, current_state = tf.nn.dynamic_rnn(rnn_cell, x, initial_state=rnn_tuple_state) # cur_state_0_c = current_state.c # cur_state_0_h = current_state.h tf.summary.histogram('rnn_outputs', outputs) prediction = tf.matmul(outputs[:, -1, :], weights['out']) + biases['out'] with tf.name_scope('Metrices'): # y = tf.reshape(y, [-1]) # necesary? # regular version VS v2 VS sparse # what about the shape of prediction VS shape of y?? # loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=prediction, labels=y)) loss = tf.losses.mean_squared_error( labels=y, predictions=prediction ) # is the loss calculated correctly? are these the params I need to pass? tf.summary.scalar('loss', loss) optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(loss) # in order to calculate rmse we need to transform data back to a price ## prediction_inverse = inverse_transforms(prediction, scaler) ## y_inverse = inverse_transforms(y, scaler) ## prediction_inverse = prediction_inverse.squeeze()[1:] ## y_test_inverse = y_test_inverse.squeeze() ## rmse = sqrt(mean_squared_error(prediction_inverse, y_inverse)) ## tf.summary.scalar('rmse', rmse) merged_summary = tf.summary.merge_all() saver = tf.train.Saver() _cur_state_0_c = np.zeros((batch_size, n_hidden), dtype=np.float32) _cur_state_0_h = np.zeros((batch_size, n_hidden), dtype=np.float32) _current_state = tuple((_cur_state_0_c, _cur_state_0_h)) validation_set_size = data_params['validation_set_size'] train_set_size = data_params['training_set_size'] prev_current_state = None best_model_rmse = float("inf") _val_current_state = None ## print(_cur_state_0_c.shape) print( "Run 'tensorboard --logdir=./{}' to checkout tensorboard logs.".format( logs_dir_path)) print("==> training") with tf.Session() as sess: sess.run(tf.global_variables_initializer()) # training for epoch in tqdm.tqdm(range(num_epochs)): # print("_current_state before training:") # print(_current_state) # print("before == previous after? {}".format(cmp_tuples(_current_state, prev_current_state))) if not validate_only: for i, data in tqdm.tqdm(enumerate(train_loader, 0), total=num_training_batches): # print(i) if i == num_training_batches: print("*" * 50) break _x, _y = data _x = _x.reshape((-1, look_back, input_num_features)) _y = _y.reshape((-1, output_num_features)) _pred, _loss, _, _summary, _current_state = sess.run( [ prediction, loss, optimizer, merged_summary, current_state ], feed_dict={ x: _x, y: _y, init_state_0_c: _current_state[0], init_state_0_h: _current_state[1] }) train_writer.add_summary(_summary, i + num_training_batches * epoch) _val_current_state = tuple( (_current_state[0].copy(), _current_state[1].copy())) validation_params = dict() validation_params['sess'] = sess validation_params[ '_current_state'] = _current_state # just for saving it validation_params['_val_current_state'] = _val_current_state validation_params['raw_values'] = raw_values validation_params['y_validation'] = y_validation validation_params['validation_set_size'] = validation_set_size validation_params['val_loader'] = val_loader validation_params['val_writer'] = val_writer validation_params['scaler'] = scaler validation_params[ 'num_validation_batches'] = num_validation_batches validation_params['look_back'] = look_back validation_params['epoch'] = epoch validation_params['input_num_features'] = input_num_features validation_params['output_num_features'] = output_num_features validation_params['placeholders'] = { 'x': x, 'y': y, 'init_state_0_c': init_state_0_c, 'init_state_0_h': init_state_0_h } sess_params = dict() sess_params['prediction'] = prediction sess_params['merged_summary'] = merged_summary sess_params['current_state'] = current_state validation_params['sess_params'] = sess_params validation_params['saver'] = saver validation_params['model_save_path'] = model_save_path validation_params['visualize'] = visualize validation_params['best_model_rmse'] = best_model_rmse validation_params['trained_model_path'] = trained_model_path validate(validation_params) best_model_rmse = validation_params['best_model_rmse'] if validate_only: break val_writer.close() train_writer.close()
def train(train_params): debug = True data_params = train_params['data_params'] model_params = train_params['model_params'] model_save_path = train_params['model_save_path'] logs_dir_path = train_params['logs_dir_path'] batch_size = model_params['batch_size'] num_epochs = model_params[ 'num_epochs'] # add early stopping, save best model input_num_features = model_params['input_num_features'] # 1 output_num_features = model_params['output_num_features'] look_back = model_params['look_back'] n_hidden = model_params['n_hidden'] learning_rate = model_params['learning_rate'] num_layers = model_params['num_layers'] keep_prob = model_params['keep_prob'] val_batch_size = batch_size visualize = train_params['visualize'] validate_only = train_params['validate_only'] trained_model_path = train_params['trained_model_path'] raw_values, X_train, y_train, X_validation, y_validation, scaler = preprocess_data( data_params) print(raw_values.shape, X_train.shape, y_train.shape, X_validation.shape, y_validation.shape) train_loader = batch_generator(X_train, y_train, batch_size) val_loader = batch_generator(X_validation, y_validation, val_batch_size) train_writer = tf.summary.FileWriter(os.path.join( logs_dir_path, 'train')) #, accuracy.graph) val_writer = tf.summary.FileWriter( os.path.join(logs_dir_path, 'validation')) #, accuracy.graph) num_training_batches = X_train.shape[0] // batch_size num_validation_batches = X_validation.shape[0] // batch_size print("num_training_batches: {}, num_validation_batches: {}".format( num_training_batches, num_validation_batches)) # placeholders # 1 feature (price) x = tf.placeholder(tf.float32, [None, look_back, input_num_features]) y = tf.placeholder(tf.float32, [None, output_num_features]) init_state = tf.placeholder(tf.float32, [2, None, n_hidden]) # **** model **** n_hidden = model_params['n_hidden'] learning_rate = model_params['learning_rate'] num_layers = model_params['num_layers'] prediction_num_features = model_params['output_num_features'] batch_size = model_params['batch_size'] weights = { 'out': tf.Variable(tf.random_normal([n_hidden, prediction_num_features])) } biases = {'out': tf.Variable(tf.random_normal([prediction_num_features]))} rnn_cell = tf.nn.rnn_cell.LSTMCell(n_hidden, state_is_tuple=True) rnn_tuple_state = tf.nn.rnn_cell.LSTMStateTuple(init_state[0], init_state[1]) outputs, current_state = tf.nn.dynamic_rnn(rnn_cell, x, initial_state=rnn_tuple_state) tf.summary.histogram('rnn_outputs', outputs) prediction = tf.matmul(outputs[:, -1, :], weights['out']) + biases['out'] with tf.name_scope('Metrices'): loss = tf.losses.mean_squared_error(labels=y, predictions=prediction) tf.summary.scalar('loss', loss) optimizer = tf.train.AdamOptimizer( learning_rate=learning_rate).minimize(loss) merged_summary = tf.summary.merge_all() saver = tf.train.Saver() _current_state = np.zeros((2, batch_size, n_hidden)) validation_set_size = data_params['validation_set_size'] train_set_size = data_params['training_set_size'] prev_current_state = None best_model_rmse = float("inf") _val_current_state = None print( "Run 'tensorboard --logdir=./{}' to checkout tensorboard logs.".format( logs_dir_path)) print("==> training") with tf.Session() as sess: sess.run(tf.global_variables_initializer()) # training for epoch in tqdm.tqdm(range(num_epochs)): if not validate_only: for i, data in tqdm.tqdm(enumerate(train_loader, 0), total=num_training_batches): # print(i) if i == num_training_batches: print("*" * 50) break _x, _y = data _x = _x.reshape((-1, look_back, input_num_features)) _y = _y.reshape((-1, output_num_features)) _pred, _loss, _, _summary, _current_state = sess.run( [ prediction, loss, optimizer, merged_summary, current_state ], feed_dict={ x: _x, y: _y, init_state: _current_state }) train_writer.add_summary(_summary, i + num_training_batches * epoch) _val_current_state = pickle.loads( pickle.dumps(_current_state, -1)) validation_params = dict() validation_params['sess'] = sess validation_params[ '_current_state'] = _current_state # just for saving it validation_params['_val_current_state'] = _val_current_state validation_params['raw_values'] = raw_values validation_params['y_validation'] = y_validation validation_params['validation_set_size'] = validation_set_size validation_params['val_loader'] = val_loader validation_params['val_writer'] = val_writer validation_params['scaler'] = scaler validation_params[ 'num_validation_batches'] = num_validation_batches validation_params['look_back'] = look_back validation_params['epoch'] = epoch validation_params['input_num_features'] = input_num_features validation_params['output_num_features'] = output_num_features validation_params['placeholders'] = { 'x': x, 'y': y, 'init_state': init_state } sess_params = dict() sess_params['prediction'] = prediction sess_params['merged_summary'] = merged_summary sess_params['current_state'] = current_state validation_params['sess_params'] = sess_params validation_params['saver'] = saver validation_params['model_save_path'] = model_save_path validation_params['visualize'] = visualize validation_params['best_model_rmse'] = best_model_rmse validation_params['trained_model_path'] = trained_model_path validate(validation_params) best_model_rmse = validation_params['best_model_rmse'] if validate_only: break val_writer.close() train_writer.close()
def train(train_params): # ************** params ************** debug = True data_params = train_params['data_params'] model_params = train_params['model_params'] model_save_path = train_params['model_save_path'] logs_dir_path = train_params['logs_dir_path'] batch_size = model_params['batch_size'] num_epcohs = model_params['num_epochs'] # add early stopping, save best model input_num_features = model_params['input_num_features'] # 1 output_num_features = model_params['output_num_features'] look_back = model_params['look_back'] n_hidden = model_params['n_hidden'] learning_rate = model_params['learning_rate'] val_batch_size = batch_size X_train, y_train, X_validation, y_validation, scaler = preprocess_data(data_params) # print(X_train[0]) # print(X_train[0].shape) # print(X_train[0:2].shape) # gen = batch_generator(X_train, y_train, batch_size) # print(next(gen)[0].shape) # print(next(gen)[1].shape) train_loader = batch_generator(X_train, y_train, batch_size) val_loader = batch_generator(X_validation, y_validation, val_batch_size) train_writer = tf.summary.FileWriter(os.path.join(logs_dir_path, 'train')) #, accuracy.graph) val_writer = tf.summary.FileWriter(os.path.join(logs_dir_path, 'validation')) #, accuracy.graph) num_training_batches = X_train.shape[0] // batch_size num_validation_batches = X_validation.shape[0] // batch_size # let's say prices are: [1,2,3,4,5,6,7,8,9,10,11,12] # and we use the prices from the past 3 minutes/days (look back = 3) # in order to predict the next # let batch_size = 3 and let num_batches = 3 # input: [[[1, 2, 3], [2, 3, 4], [3, 4, 5]], # [[4,5,6], [5,6,7], [6,7,8]] # [7,8,9], [8,9,10], [9,10,11]]] # labels: [[[4], [5], [6]] # [[7], [8], [9]] # [[10], [11], [12]]] # # Visualizations help! x = tf.placeholder(tf.float32, [None, look_back, input_num_features]) # 1 feature (price) y = tf.placeholder(tf.float32, [None, output_num_features]) # WHAT IS THE SHAPE OF init_state ? ## current_state = tf.placeholder(tf.float32, [model_params['num_layers'], 2, batch_size, n_hidden]) ## current_state = tf.placeholder(tf.float32, [2, batch_size, n_hidden]) state_0_h = tf.placeholder(tf.float32, [None, n_hidden]) state_0_c = tf.placeholder(tf.float32, [None, n_hidden]) # current_state = [] # reset_state = tf.placeholder(tf.int32, shape=[]) ### prediction, current_state = model(x, model_params, current_state, reset_state) # prediction, current_state= model(x, model_params, [], reset_state) # if debug: prediction, current_state = model(x, model_params, (state_0_c, state_0_h)) # debug state_0_c = current_state.c state_0_h = current_state.h # else: # prediction, current_state = model(x, model_params, current_state) # debug # _current_state = np.zeros((model_params['num_layers'], 2, batch_size, n_hidden)) # _current_state = tuple([tuple((el[0], el[1])) for el in _current_state]) # works for LSTMCell ## _current_state = np.zeros((2, batch_size, n_hidden), dtype=np.float32) ## _current_state = tuple((_current_state[0], _current_state[1])) # *** debugging *** if debug: _state_0_c = np.zeros((batch_size, n_hidden), dtype=np.float32) _state_0_h = np.zeros((batch_size, n_hidden), dtype=np.float32) print(_state_0_c.shape) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) # training print("==> debugging") for epoch in tqdm.tqdm(range(num_epcohs)): # _current_state = np.zeros((model_params['num_layers'], 2, batch_size, n_hidden)) # _current_state = tuple([tuple((el[0], el[1])) for el in _current_state]) # print(len(_current_state)) i = 0 train_rmse = 0.0 for i, data in tqdm.tqdm(enumerate(train_loader, 0), total=num_training_batches): if i == num_training_batches: break _x,_y = data _x = _x.reshape((-1, look_back, input_num_features)) _y = _y.reshape((-1, output_num_features)) _state_0_c, _state_0_h, _pred = sess.run([state_0_c, state_0_h, prediction], feed_dict = { x: _x, y: _y, state_0_h: _state_0_h, state_0_c: _state_0_c } ) # current_state: _current_state}) # print(_current_state) # print(np.shape(_current_state[0])) # print(np.shape(_outputs[0])) print(np.shape(_pred[0])) # print(tf.shape(_init_state_debug)) # raise NotImplementedError() # print(_prediction, tf.shape(_prediction[0])) # print(len(_prediction), type(_prediction)) raise NotImplementedError() # *** debugging *** with tf.name_scope('Metrices'): y = tf.reshape(y, [-1]) # necesary? # regular version VS v2 VS sparse # what about the shape of prediction VS shape of y?? loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=prediction, labels=y)) tf.summary.scalar('loss', loss) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(loss) # in order to calculate rmse we need to transform data back to a price prediction_inverse = inverse_transforms(prediction, scaler) y_inverse = inverse_transforms(y, scaler) prediction_inverse = prediction_inverse.squeeze()[1:] y_test_inverse = y_test_inverse.squeeze() rmse = sqrt(mean_squared_error(prediction_inverse, y_inverse)) tf.summary.scalar('rmse', rmse) merged_summary = tf.summary.merge_all() saver = tf.train.Saver() with tf.Session() as sess: sess.run(tf.global_variables_initializer()) # training print("==> training") for epoch in tqdm.tqdm(range(num_epcohs)): # initialize every epoch? # _current_state = np.zeros((model_params['num_layers'], 2, batch_size, n_hidden)) # _current_state = tuple([tuple((el[0], el[1])) for el in _current_state]) _state_0_c = np.zeros((batch_size, n_hidden), dtype=np.float32) _state_0_h = np.zeros((batch_size, n_hidden), dtype=np.float32) i = 0 train_rmse = 0.0 for i, data in tqdm.tqdm(enumerate(train_loader, 0), total=num_training_batches): if i == num_training_batches: break _state_0_c, _state_0_h = sess.run([state_0_c, state_0_h], feed_dict = {x: _x, y: _y, state_0_h: _state_0_h.astype(np.float32), state_0_c: _state_0_c.astype(np.float32)}) _x, _y = data _x = _x.reshape((-1, look_back, input_num_features)) # necesary ? _y = _y.reshape((-1, output_num_features)) # necesary ? _loss, _rmse, _, _summary, _current_state = sess.run([loss, rmse, optimizer, merged_summary, state_0_c, state_0_h], # _init_state = sess.run([init_state_debug], feed_dict = { x: _x, y: _y, state_0_c: _current_state[0], state_0_h: _current_state[1] ##current_state: _current_state, ## reset_state: 1 if i == 0 else 0 ## reset_state: 1 }) ### print("state shape = {}".format(tf.shape(_current_state))) print("state shape = {}".format(tf.shape(_current_state[0]))) raise NotImplementedError() train_rmse += _rmse train_writer.add_summary(_summary, i + num_training_batches * epoch) # validation print("==> validation") for epoch in tqdm.tqdm(range(num_epcohs)): for i, data in tqdm.tqdm(enumerate(val_loader, 0), total=num_training_batches): _x, _y = data _rmse, _summary, _current_state = sess.run([rmse, merged_summary, current_state], feed_dict = { x: _x, y: _y, current_state: _current_state }) val_writer.add_summary(_summary, i + num_validation_batches * epoch) train_writer.close() val_writer.close() saver.save(sess, model_save_path)