def train(net: DaRnnNet, train_data: TrainData, t_cfg: TrainConfig, scaler, n_epochs=10, save_plots=False): iter_per_epoch = int(np.ceil(t_cfg.train_size * 1. / t_cfg.batch_size)) iter_losses = np.zeros(n_epochs * iter_per_epoch) epoch_losses = np.zeros(n_epochs) logger.info(f"Iterations per epoch: {t_cfg.train_size * 1. / t_cfg.batch_size:3.3f} ~ {iter_per_epoch:d}.") n_iter = 0 for e_i in range(n_epochs): perm_idx = np.random.permutation(t_cfg.train_size - t_cfg.T) for t_i in range(0, t_cfg.train_size, t_cfg.batch_size): batch_idx = perm_idx[t_i:(t_i + t_cfg.batch_size)] feats, y_history, y_target = prep_train_data(batch_idx, t_cfg, train_data) loss = train_iteration(net, t_cfg.loss_func, feats, y_history, y_target) iter_losses[e_i * iter_per_epoch + t_i // t_cfg.batch_size] = loss # if (j / t_cfg.batch_size) % 50 == 0: # self.logger.info("Epoch %d, Batch %d: loss = %3.3f.", i, j / t_cfg.batch_size, loss) n_iter += 1 adjust_learning_rate(net, n_iter) epoch_losses[e_i] = np.mean(iter_losses[range(e_i * iter_per_epoch, (e_i + 1) * iter_per_epoch)]) if e_i % 10 == 0: y_test_pred = scaler.inverse_transform(np.concatenate([train_data.feats[t_cfg.train_size:],predict(net, train_data, t_cfg.train_size, t_cfg.batch_size, t_cfg.T, on_train=False)],axis=1))[:,-1] y_test_true = scaler.inverse_transform(np.concatenate([train_data.feats[t_cfg.train_size:],train_data.targs[t_cfg.train_size:]],axis=1))[:,-1] # TODO: make this MSE and make it work for multiple inputs val_loss = y_test_pred - y_test_true rmse = np.sqrt(np.mean(np.square(y_test_true - y_test_pred))) logger.info(f"Epoch {e_i:d}, train loss: {epoch_losses[e_i]:3.3f}, val loss: {np.mean(np.abs(val_loss))}, rmse: {rmse}.") logger.info(f"PRED: {y_test_pred[-10:]}") logger.info(f"TRUE: {y_test_true[-10:]}") plt.figure() plt.plot(y_test_true, label="True") plt.plot(y_test_pred, label='Predicted - Test') plt.legend(loc='upper left') utils.save_or_show_plot(f"pred_{e_i}_{rmse}.png", save_plots) return iter_losses, epoch_losses
def train(net: DaRnnNet, train_data: TrainData, t_cfg: TrainConfig, n_epochs=10, save_plots=False): iter_per_epoch = int(np.ceil(t_cfg.train_size * 1. / t_cfg.batch_size)) iter_losses = np.zeros(n_epochs * iter_per_epoch) epoch_losses = np.zeros(n_epochs) logger.info(f"Iterations per epoch: {t_cfg.train_size * 1. / t_cfg.batch_size:3.3f} ~ {iter_per_epoch:d}.") n_iter = 0 for e_i in range(n_epochs): perm_idx = np.random.permutation(t_cfg.train_size - t_cfg.T) for t_i in range(0, t_cfg.train_size, t_cfg.batch_size): batch_idx = perm_idx[t_i:(t_i + t_cfg.batch_size)] feats, y_history, y_target = prep_train_data(batch_idx, t_cfg, train_data) loss = train_iteration(net, t_cfg.loss_func, feats, y_history, y_target) iter_losses[e_i * iter_per_epoch + t_i // t_cfg.batch_size] = loss # if (j / t_cfg.batch_size) % 50 == 0: # self.logger.info("Epoch %d, Batch %d: loss = %3.3f.", i, j / t_cfg.batch_size, loss) n_iter += 1 adjust_learning_rate(net, n_iter) epoch_losses[e_i] = np.mean(iter_losses[range(e_i * iter_per_epoch, (e_i + 1) * iter_per_epoch)]) if e_i % 10 == 0: y_test_pred = predict(net, train_data, t_cfg.train_size, t_cfg.batch_size, t_cfg.T, on_train=False) # TODO: make this MSE and make it work for multiple inputs val_loss = y_test_pred - train_data.targs[t_cfg.train_size:] logger.info(f"Epoch {e_i:d}, train loss: {epoch_losses[e_i]:3.3f}, val loss: {np.mean(np.abs(val_loss))}.") y_train_pred = predict(net, train_data, t_cfg.train_size, t_cfg.batch_size, t_cfg.T, on_train=True) plt.figure() plt.plot(range(1, 1 + len(train_data.targs)), train_data.targs, label="True") plt.plot(range(t_cfg.T, len(y_train_pred) + t_cfg.T), y_train_pred, label='Predicted - Train') plt.plot(range(t_cfg.T + len(y_train_pred), len(train_data.targs) + 1), y_test_pred, label='Predicted - Test') plt.legend(loc='upper left') utils.save_or_show_plot(f"pred_{e_i}.png", save_plots) return iter_losses, epoch_losses
def main(): save_plots = True debug = False raw_data = pd.read_csv(os.path.join("data", "nasdaq100_padding.csv"), nrows=100 if debug else None) logger.info(f"Shape of data: {raw_data.shape}.\nMissing in data: {raw_data.isnull().sum().sum()}.") targ_cols = ("NDX",) data, scaler = preprocess_data(raw_data, targ_cols) da_rnn_kwargs = {"batch_size": 128, "T": 10} config, model = da_rnn(data, n_targs=len(targ_cols), learning_rate=.001, **da_rnn_kwargs) iter_loss, epoch_loss = train(model, data, config, n_epochs=10, save_plots=save_plots) final_y_pred = predict(model, data, config.train_size, config.batch_size, config.T) plt.figure() plt.semilogy(range(len(iter_loss)), iter_loss) utils.save_or_show_plot("iter_loss.png", save_plots) plt.figure() plt.semilogy(range(len(epoch_loss)), epoch_loss) utils.save_or_show_plot("epoch_loss.png", save_plots) plt.figure() plt.plot(final_y_pred, label='Predicted') plt.plot(data.targs[config.train_size:], label="True") plt.legend(loc='upper left') utils.save_or_show_plot("final_predicted.png", save_plots) with open(os.path.join("data", "da_rnn_kwargs.json"), "w") as fi: json.dump(da_rnn_kwargs, fi, indent=4) joblib.dump(scaler, os.path.join("data", "scaler.pkl")) torch.save(model.encoder.state_dict(), os.path.join("data", "encoder.torch")) torch.save(model.decoder.state_dict(), os.path.join("data", "decoder.torch"))
def train(net: DaRnnNet, train_data: TrainData, t_cfg: TrainConfig, n_epochs=10, save_plots=False): iter_per_epoch = int(np.ceil(t_cfg.train_size * 1. / t_cfg.batch_size)) iter_losses = np.zeros(n_epochs * iter_per_epoch) epoch_losses = np.zeros(n_epochs) logger.info( f"Iterations per epoch: {t_cfg.train_size * 1. / t_cfg.batch_size:3.3f} ~ {iter_per_epoch:d}." ) n_iter = 0 for e_i in range(n_epochs): print(e_i, end='\r') # ANDREA --> The training set is now chosen at random #print(len(train_data), t_cfg.train_size, train_data[0][0][:2]) perm_idx = np.random.permutation(t_cfg.train_size - t_cfg.T) perm_idx = np.random.choice(perm_idx, size=TRAIN_SIZE) #print(perm_idx) #for t_i in range(0, t_cfg.train_size, t_cfg.batch_size): for t_i in range(0, TRAIN_SIZE, t_cfg.batch_size): batch_idx = perm_idx[t_i:(t_i + t_cfg.batch_size)] ################################################################ feats, y_history, y_target = prep_train_data( batch_idx, t_cfg, train_data) ################################################################ loss = train_iteration(net, t_cfg.loss_func, feats, y_history, y_target) iter_losses[e_i * iter_per_epoch + t_i // t_cfg.batch_size] = loss # if (j / t_cfg.batch_size) % 50 == 0: # self.logger.info("Epoch %d, Batch %d: loss = %3.3f.", i, j / t_cfg.batch_size, loss) n_iter += 1 adjust_learning_rate(net, n_iter) epoch_losses[e_i] = np.mean(iter_losses[range( e_i * iter_per_epoch, (e_i + 1) * iter_per_epoch)]) if e_i % 5 == 0: y_test_pred = predict(net, train_data, t_cfg.train_size, t_cfg.batch_size, t_cfg.T, on_train=False, eval=True) # ANDREA --> Temporary fix # y_test_pred = np.maximum(np.minimum(1, y_test_pred), -1) val_loss = y_test_pred - train_data.targs[ t_cfg.train_size:t_cfg.train_size + len(y_test_pred)] val_loss = np.mean(np.square(val_loss)) y_train_pred = predict(net, train_data, t_cfg.train_size, t_cfg.batch_size, t_cfg.T, on_train=True) tra_loss = y_train_pred - train_data.targs[:len(y_train_pred)] tra_loss = np.mean(np.square(tra_loss)) # TODO: make this MSE and make it work for multiple inputs #val_loss = y_test_pred - train_data.targs[t_cfg.train_size:] #logger.info(f"Epoch {e_i:d}, train loss: {epoch_losses[e_i]:3.3f}, val loss: {val_loss}.") logger.info( f"Epoch {e_i:d}, train loss: {tra_loss:3.3f}, val loss: {val_loss:3.3f}." ) # ANDREA --> Temporary fix # y_train_pred = np.maximum(np.minimum(1, y_train_pred), -1) plt.figure() plt.plot(range(1, 1 + len(train_data.targs)), train_data.targs, label="True") plt.plot(range(t_cfg.T, len(y_train_pred) + t_cfg.T), y_train_pred, label='Predicted - Train') #plt.plot(range(t_cfg.T + len(y_train_pred), len(train_data.targs) + 1), y_test_pred, label='Predicted - Test') t0 = t_cfg.T + len(y_train_pred) plt.plot(range(t0, t0 + VALI_SIZE), y_test_pred, label='Predicted - Test') plt.legend(loc='upper left') utils.save_or_show_plot(f"pred_{e_i}.png", save_plots) return iter_losses, epoch_losses
#raw_data = pd.read_csv(os.path.join("data", "iex_nasdaq100_dataset.csv"), nrows=100 if debug else None) raw_data = pd.read_csv(os.path.join("data", "nasdaq100_padding.csv"), nrows=100 if debug else None) logger.info(f"Shape of data: {raw_data.shape}.\nMissing in data: {raw_data.isnull().sum().sum()}.") targ_cols = ("NDX",) #targ_cols = ("AAPL",) data, scaler = preprocess_data(raw_data, targ_cols) da_rnn_kwargs = {"batch_size": 128, "T": 10} config, model = da_rnn(data, n_targs=len(targ_cols), learning_rate=.001, **da_rnn_kwargs) iter_loss, epoch_loss = train(model, data, config, n_epochs=10, save_plots=save_plots) final_y_pred = predict(model, data, config.train_size, config.batch_size, config.T) plt.figure() plt.semilogy(range(len(iter_loss)), iter_loss) utils.save_or_show_plot("iter_loss.png", save_plots) plt.figure() plt.plot(final_y_pred, label="Predicted") plt.plot(data.targs[config.train_size:], label="True") plt.legend(loc="upper left") #plt.show() utils.save_or_show_plot("final_predicted.png", save_plots) if interactive_plot == True: pred_plot = go.Scatter(x = np.arange(0, len(final_y_pred)), y = final_y_pred, name='Predicted', mode= 'lines+markers') true_plot = go.Scatter(x = np.arange(0, len(data.targs[config.train_size:])), y = data.targs[config.train_size:],
def train(net: TCHA, train_data: TrainData, t_cfg: TrainConfig, tarRoad, scaler, n_epochs=10, save_plots=False): # 每epoch中含有批次数 iter_per_epoch = int(np.ceil(t_cfg.train_size * 1. / t_cfg.batch_size)) # 批次总数 iter_losses = np.zeros(n_epochs * iter_per_epoch) epoch_losses = np.zeros(n_epochs) logger.info(f"Iterations per epoch: {t_cfg.train_size * 1. / t_cfg.batch_size:3.6f} ~ {iter_per_epoch:d}.") n_iter = 0 enschedual = ReduceLROnPlateau(net.enc_opt, 'min', patience=5, factor=0.5) deschedual = ReduceLROnPlateau(net.dec_opt, 'min', patience=5, factor=0.5) # vis = visdom.Visdom() # winstr = 'HC train loss B: ' + str(t_cfg.batch_size) + 'I: ' + str(t_cfg.interval) # vis.line([0.], [0.], win=winstr, opts=dict(title=winstr)) # global_step = 0 for e_i in range(n_epochs): st = datetime.datetime.now() perm_idx = np.random.permutation(t_cfg.train_size - t_cfg.T - t_cfg.interval) # perm_idx = np.arange(0, t_cfg.train_size - t_cfg.T - t_cfg.interval) for t_i in range(0, t_cfg.train_size - t_cfg.T - t_cfg.interval, t_cfg.batch_size): # 每一混乱批次 # if t_i == 5632: # print(t_i) endidx = min(t_i + t_cfg.batch_size, t_cfg.train_size) batch_idx = perm_idx[t_i:endidx] feats, y_history, y_target, speed = prep_train_data(batch_idx, t_cfg, train_data) loss = train_iteration(net, t_cfg.loss_func, feats, y_history, y_target, speed) # 第t_i批次的loss放入 iter_losses[e_i * iter_per_epoch + t_i // t_cfg.batch_size] = loss # if (j / t_cfg.batch_size) % 50 == 0: # self.logger.info("Epoch %d, Batch %d: loss = %3.3f.", i, j / t_cfg.batch_size, loss) n_iter += 1 # adjust_learning_rate(net, n_iter) # 当前epoch平均loss epoch_losses[e_i] = np.mean(iter_losses[range(e_i * iter_per_epoch, (e_i + 1) * iter_per_epoch)]) # vis.line([epoch_losses[e_i]], [global_step], win=winstr, update='append') # global_step += 1 enschedual.step(epoch_losses[e_i]) deschedual.step(epoch_losses[e_i]) # if e_i % 20 == 0: weights, y_test_pred, _ = predict(net, train_data, t_cfg.train_size, t_cfg.batch_size, t_cfg.T, t_cfg.interval, on_train=False) # TODO: make this MSE and make it work for multiple inputs # val_loss = y_test_pred - train_data.targs[t_cfg.train_size:] val_loss = myMSE(y_test_pred, train_data.targs[t_cfg.train_size:], t_cfg.isMean) save_final(t_cfg.isMean, y_test_pred, train_data.targs[t_cfg.train_size:], tarRoad, config.timestep, config.interval, scaler) weights, y_train_pred, _ = predict(net, train_data, t_cfg.train_size, t_cfg.batch_size, t_cfg.T, t_cfg.interval, on_train=True) save_final(t_cfg.isMean, y_train_pred, train_data.targs[:t_cfg.train_size], tarRoad, config.timestep, config.interval, scaler,filename="hhh") train_loss = myMSE(y_train_pred, train_data.targs[:t_cfg.train_size], t_cfg.isMean) logger.info(f"Epoch {e_i:d}, train loss: {np.mean(np.abs(epoch_losses[e_i]))}, val loss: {np.mean(np.abs(val_loss))}.") torch.save(net.encoder.state_dict(), 'models/' + tarRoad + '/' + str(t_cfg.interval) + '/HCAdam_encoder' + str(t_cfg.batch_size) + str(e_i) + '-norm' + '.model') torch.save(net.decoder.state_dict(), 'models/' + tarRoad + '/' + str(t_cfg.interval) + '/HCAdam_decoder' + str(t_cfg.batch_size) + str(e_i) + '-norm' + '.model') plt.figure() plt.plot(range(1, 1 + len(train_data.targs)), train_data.targs, label="True") plt.plot(range(t_cfg.T, len(y_train_pred) + t_cfg.T), y_train_pred, label='Predicted - Train') plt.plot(range(t_cfg.T + len(y_train_pred) + t_cfg.interval, len(train_data.targs)), y_test_pred, label='Predicted - Test') plt.legend(loc='upper left') savename = "pred_epoch" + str(e_i) + "interval" + str(t_cfg.interval) + 'batchsize' + str( t_cfg.batch_size) + '.png' utils.save_or_show_plot(savename, save_plots, t_cfg.interval, tarRoad) pd_iterloss = pd.DataFrame(iter_losses) pd_epoloss = pd.DataFrame(epoch_losses) pd_iterloss.to_csv('result/' + tarRoad + '/iterloss iterval' + str(t_cfg.interval) + '.csv') pd_epoloss.to_csv('result/' + tarRoad + '/epochloss iterval' + str(t_cfg.interval) + '.csv') plt.close() ed = datetime.datetime.now() print('epoch:{}, time cost:{}\n\n'.format(e_i, (ed - st).seconds)) return iter_losses, epoch_losses
pd_sptial = pd.DataFrame(embeded_weights[0]) pd_time = pd.DataFrame(embeded_weights[1]) pd_sptial.to_csv('result/' + 'att_sptial'+'.csv') pd_time.to_csv('result/' + 'att_time' + '.csv') else: iter_loss, epoch_loss = train(model, data, config, tarRoad, scaler, n_epochs=num_epochs, save_plots=save_plots) weightss, final_y_pred, y_true = predict(model, data, config.train_size, config.batch_size, config.T, config.interval) pd_sptial = pd.DataFrame(weightss[0]) pd_time = pd.DataFrame(weightss[1]) pd_sptial.to_csv('result/' + 'att_sptial'+'.csv') pd_time.to_csv('result/' + 'att_time' + '.csv') try: plt.figure() plt.semilogy(range(len(iter_loss)), iter_loss) utils.save_or_show_plot("train iter_loss interval" + str(interval) + ".png", save_plots, interval=interval, tarRoad=tarRoad) plt.figure() plt.semilogy(range(len(epoch_loss)), epoch_loss) utils.save_or_show_plot("train epoch epoch_loss interval" + str(interval) + ".png", save_plots, interval, tarRoad) except Exception as e: print(e) plt.figure() plt.plot(data.targs[config.train_size:], label="True") plt.plot(final_y_pred, label='Predicted') plt.legend(loc='upper left') # y1 = pd.DataFrame(y_true) # y2 = pd.DataFrame(data.targs[config.train_size:]) # print(y1) # print(y2)
debug = False save_plots = False with open(os.path.join("data", "enc_kwargs.json"), "r") as fi: enc_kwargs = json.load(fi) enc = Encoder(**enc_kwargs) enc.load_state_dict( torch.load(os.path.join("data", "encoder.torch"), map_location=device)) with open(os.path.join("data", "dec_kwargs.json"), "r") as fi: dec_kwargs = json.load(fi) dec = Decoder(**dec_kwargs) dec.load_state_dict( torch.load(os.path.join("data", "decoder.torch"), map_location=device)) scaler = joblib.load(os.path.join("data", "scaler.pkl")) raw_data = pd.read_csv(os.path.join("data", "nasdaq100_padding.csv"), nrows=100 if debug else None) targ_cols = ("NDX", ) data = preprocess_data(raw_data, targ_cols, scaler) with open(os.path.join("data", "da_rnn_kwargs.json"), "r") as fi: da_rnn_kwargs = json.load(fi) final_y_pred = predict(enc, dec, data, **da_rnn_kwargs) plt.figure() plt.plot(final_y_pred, label='Predicted') plt.plot(data.targs[(da_rnn_kwargs["T"] - 1):], label="True") plt.legend(loc='upper left') utils.save_or_show_plot("final_predicted_reloaded.png", save_plots)
def train(net: DaRnnNet, train_data: TrainData, training_configuration: TrainConfig, n_epochs=10, save_plots=True): iter_per_epoch = int( np.ceil(training_configuration.train_size * 1. / training_configuration.batch_size) ) #calculating how many iterations there will be in each epoch iter_losses = np.zeros(n_epochs * iter_per_epoch) epoch_losses = np.zeros(n_epochs) logger.info( f"Iterations per epoch: {training_configuration.train_size * 1. / training_configuration.batch_size:3.3f} ~ {iter_per_epoch:d}." ) n_iter = 0 #while j < self.train_size - self.T: epoch_counter = 0 for e_i in range(n_epochs): print("Epoch no: ", epoch_counter) epoch_counter += 1 randomly_permuted_index = np.random.permutation( training_configuration.train_size - training_configuration.T ) #If x is an integer, randomly permute np.arange(x). # If x is an array, make a copy and shuffle the elements randomly. for t_i in range(0, training_configuration.train_size, training_configuration.batch_size): batch_idx = randomly_permuted_index[t_i:( t_i + training_configuration.batch_size)] feats, y_history, y_target = prep_train_data( batch_idx, training_configuration, train_data) loss = train_iteration(net, training_configuration.loss_func, feats, y_history, y_target) iter_losses[e_i * iter_per_epoch + t_i // training_configuration.batch_size] = loss # if (j / t_cfg.batch_size) % 50 == 0: # self.logger.info("Epoch %d, Batch %d: loss = %3.3f.", i, j / t_cfg.batch_size, loss) n_iter += 1 adjust_learning_rate(net, n_iter) epoch_losses[e_i] = np.mean(iter_losses[range( e_i * iter_per_epoch, (e_i + 1) * iter_per_epoch)]) if e_i % 10 == 0: y_test_pred = predict(net, train_data, training_configuration.train_size, training_configuration.batch_size, training_configuration.T, on_train=False) # TODO: make this MSE and make it work for multiple inputs val_loss = y_test_pred - train_data.targs[training_configuration. train_size:] logger.info( f"Epoch {e_i:d}, train loss: {epoch_losses[e_i]:3.3f}, val loss: {np.mean(np.abs(val_loss))}." ) y_train_pred = predict(net, train_data, training_configuration.train_size, training_configuration.batch_size, training_configuration.T, on_train=True) plt.figure() plt.plot(range(1, 1 + len(train_data.targs)), train_data.targs, label="True") plt.plot(range(training_configuration.T, len(y_train_pred) + training_configuration.T), y_train_pred, label='Predicted - Train') plt.plot(range(training_configuration.T + len(y_train_pred), len(train_data.targs) + 1), y_test_pred, label='Predicted - Test') plt.legend(loc='upper left') utils.save_or_show_plot(f"pred_{e_i}.png", save_plots) return iter_losses, epoch_losses
def main(raw_args=None): """ Call like this: ['--tasks', 'smartrain', '-epochs', '500'] """ save_plots = True debug = False arguments = parse_args(raw_args) """ handle different datasets""" if arguments.task == "nasdaq": raw_data = pd.read_csv(os.path.join("data", "nasdaq100_padding.csv"), nrows=100 if debug else None) targ_cols = ("NDX", ) # "RH" elif arguments.task == "pump": print("pump") targ_cols = ("sensor_00", "sensor_04") elif arguments.task == "smartrain": #path = "/content/data/pump/labeled/sensor.csv.pkl" path = "/content/data/smart-rain/All_Data_No0.csv" #raw_data = pd.read_pickle(path) raw_data = pd.read_csv(path) raw_data['time'] = pd.to_datetime(raw_data['time'], ) raw_data.drop(['time', "Rain"], axis=1, inplace=True) print(raw_data.head()) #raw_data = raw_data.set_index("time") #raw_data.index = pd.to_datetime(raw_data.index) #raw_data = sm.datasets.rwm.load_pandas().data #raw_data = sm.datasets.get_rdataset("datasets", "treering") print(raw_data.head()) print(raw_data.columns) print(raw_data.tail()) targ_cols = ("temperature", ) # "RH" else: raise ValueError('Invalid task.') logger.info( f"Shape of data: {raw_data.shape}.\nMissing in data: {raw_data.isnull().sum().sum()}." ) data, scaler = preprocess_data(raw_data, targ_cols) da_rnn_kwargs = { "batch_size": arguments.batchsize, "T": arguments.ntimestep } config, model = da_rnn(data, n_targs=len(targ_cols), learning_rate=arguments.lr, **da_rnn_kwargs) iter_loss, epoch_loss = train(model, data, config, n_epochs=arguments.epochs, save_plots=save_plots) final_y_pred = predict(model, data, config.train_size, config.batch_size, config.T) plt.figure() plt.semilogy(range(len(iter_loss)), iter_loss) utils.save_or_show_plot("iter_loss.png", save_plots) plt.figure() plt.semilogy(range(len(epoch_loss)), epoch_loss) utils.save_or_show_plot("epoch_loss.png", save_plots) plt.figure() plt.plot(final_y_pred, label='Predicted') plt.plot(data.targs[config.train_size:], label="True") plt.legend(loc='upper left') utils.save_or_show_plot("final_predicted.png", save_plots) with open(os.path.join("data", "da_rnn_kwargs.json"), "w") as fi: json.dump(da_rnn_kwargs, fi, indent=4) joblib.dump(scaler, os.path.join("data", "scaler.pkl")) torch.save(model.encoder.state_dict(), os.path.join("data", "encoder.torch")) torch.save(model.decoder.state_dict(), os.path.join("data", "decoder.torch"))
def train(net: DaRnnNet, train_data: TrainData, t_cfg: TrainConfig, n_epochs=10, save_plots=False): iter_per_epoch = int(np.ceil(t_cfg.train_size * 1. / t_cfg.batch_size)) iter_losses = np.zeros(n_epochs * iter_per_epoch) epoch_losses = np.zeros(n_epochs) logger.info( f"[{time_since(start)}] Iterations per epoch:{t_cfg.train_size * 1. / t_cfg.batch_size:3.3f}~{iter_per_epoch:d}" ) n_iter = 0 # 总训练次数 for e_i in range(n_epochs): # perm_idx 长度为T的时间段的起始下标 perm_idx = np.random.permutation( t_cfg.train_size - t_cfg.T) # permutation打乱数据 范围:0~train_size-T-1 for t_i in range(0, t_cfg.train_size, t_cfg.batch_size): # 0~train_size 步长为 batch_size # 返回每一个 batch_size 的 起始下标 构成的数组 batch_idx = perm_idx[t_i:(t_i + t_cfg.batch_size)] feats, y_history, y_target = prepare_train_data( batch_idx, t_cfg, train_data) loss = train_iteration(net, t_cfg.loss_func, feats, y_history, y_target) # 第e_i个循环(每个循环iter_per_epoch个)的第 t_i // t_cfg.batch_size个 iter_losses[e_i * iter_per_epoch + t_i // t_cfg.batch_size] = loss n_iter += 1 adjust_learning_rate(net, n_iter) epoch_losses[e_i] = np.mean(iter_losses[range( e_i * iter_per_epoch, (e_i + 1) * iter_per_epoch)]) """ 一轮训练完打印一次结果 """ if e_i % 1 == 0: y_test_pred = predict(net, train_data, t_cfg.train_size, t_cfg.batch_size, t_cfg.T, on_train=False) # TODO: make this mse and make it work for multiple inputs val_loss = y_test_pred - train_data.targs[t_cfg.train_size:] logger.info( f"[{time_since(start)}] Epoch{e_i:d} - train loss:{epoch_losses[e_i]} val loss:{np.mean(np.abs(val_loss))}." ) y_train_pred = predict(net, train_data, t_cfg.train_size, t_cfg.batch_size, t_cfg.T, on_train=True) plt.figure() plt.title(f"pred_{e_i}") plt.plot(range(1, 1 + len(train_data.targs)), train_data.targs, label="True") plt.plot(range(t_cfg.T, len(y_train_pred) + t_cfg.T), y_train_pred, label="Predicted -Train") plt.plot(range(t_cfg.T + len(y_train_pred), len(train_data.targs) + 1), y_test_pred, label='Predicted - Test') plt.legend(loc="upper left") utils.save_or_show_plot(f"pred_{e_i}.png", save_plots) return iter_losses, epoch_losses