def test_adam(show=False): problem = tigerforecast.problem('ARMA-v0') x = problem.initialize(p=2,q=0) method = tigerforecast.method('LSTM') method.initialize(n=1, m=1, l=3, h=10, optimizer=Adam) # initialize with class method.predict(1.0) # call methods to verify it works method.update(1.0) optimizer = Adam(learning_rate=0.1) method = tigerforecast.method('LSTM') method.initialize(n=1, m=1, l=3, h=10, optimizer=optimizer) # reinitialize with instance loss = [] for t in range(1000): y_pred = method.predict(x) y_true = problem.step() loss.append(mse(y_pred, y_true)) method.update(y_true) x = y_true if show: plt.plot(loss) plt.show(block=False) plt.pause(3) plt.close() print("test_adam passed")
def test_ons(show=False): #tigerforecast.set_key(0) # consistent randomness problem = tigerforecast.problem('ARMA-v0') x, y_true = problem.initialize() methods = [] labels = ['OGD', 'ONS', 'Adam'] # don't run deprecated ONS method = tigerforecast.method('LSTM') method.initialize(n=1, m=1, optimizer=OGD) # initialize with class methods.append(method) #method = tigerforecast.method('AutoRegressor') #method.initialize(optimizer=Adagrad) # initialize with class #methods.append(method) method = tigerforecast.method('LSTM') method.initialize(n=1, m=1, optimizer=ONS) # initialize with class methods.append(method) #method = tigerforecast.method('AutoRegressor') #method.initialize(optimizer=Adam) # initialize with class #methods.append(method) losses = [[] for i in range(len(methods))] update_time = [0.0 for i in range(len(methods))] for t in tqdm(range(2000)): for i in range(len(methods)): l, method = losses[i], methods[i] y_pred = method.predict(x) l.append(mse(y_pred, y_true)) t = time.time() method.update(y_true) update_time[i] += time.time() - t x, y_true = problem.step() print("time taken:") for t, label in zip(update_time, labels): print(label + ": " + str(t)) if show: plt.yscale('log') for l, label in zip(losses, labels): plt.plot(l, label=label) #plt.plot(avg_regret(l), label = label) plt.legend() plt.title("Autoregressors on ENSO-T6") plt.show(block=False) plt.pause(300) plt.close() print("test_ons passed")
def test_least_squares(steps=1000, show_plot=True): T = steps problem = tigerforecast.problem("ENSO-v0") x, y = problem.initialize(input_signals = ['nino12', 'nino34', 'nino4']) method = tigerforecast.method("LeastSquares") method.initialize(x, y, reg = 10.0 * steps) loss = lambda y_true, y_pred: np.sum((y_true - y_pred)**2) results = [] for i in range(T): x, y_true = problem.step() y_pred = method.step(x, y_true) cur_loss = loss(y_true, y_pred) results.append(cur_loss) if show_plot: plt.plot(results) plt.title("LeastSquares method on ARMA problem") plt.show(block=False) plt.pause(3) plt.close() print("test_least_squares passed") return
def test_autoregressor(steps=100, show_plot=True): T = steps p, q = 3, 3 n = 3 problem = tigerforecast.problem("ARMA-v0") cur_x = problem.initialize(p, q, n=n) method = tigerforecast.method("AutoRegressor") #method.initialize(p, optimizer = ONS) method.initialize(p, optimizer=Adagrad) loss = lambda y_true, y_pred: np.sum((y_true - y_pred)**2) results = [] for i in range(T): cur_y_pred = method.predict(cur_x) #print(cur_y_pred.shape) #method.forecast(cur_x, 3) cur_y_true = problem.step() cur_loss = loss(cur_y_true, cur_y_pred) method.update(cur_y_true) cur_x = cur_y_true results.append(cur_loss) if show_plot: plt.plot(results) plt.title("Autoregressive method on ARMA problem") plt.show(block=False) plt.pause(3) plt.close() print("test_autoregressor passed") return
def test_rnn(steps=100, show_plot=True): T = steps p, q = 3, 3 n = 1 problem = tigerforecast.problem("ARMA-v0") y_true = problem.initialize(p=p, q=q, n=1) method = tigerforecast.method("RNN") method.initialize(n=1, m=1, l=3, h=1) loss = lambda pred, true: np.sum((pred - true)**2) results = [] for i in range(T): u = random.normal(generate_key(), (n, )) y_pred = method.predict(u) y_true = problem.step() results.append(loss(y_true, y_pred)) method.update(y_true) if show_plot: plt.plot(results) plt.title("RNN method on LDS problem") plt.show(block=False) plt.pause(3) plt.close() print("test_rnn passed") return
def test_last_value(steps=1000, show_plot=True): T = steps p, q = 3, 3 problem = tigerforecast.problem("ARMA-v0") cur_x = problem.initialize(p, q) method = tigerforecast.method("LastValue") method.initialize() loss = lambda y_true, y_pred: (y_true - y_pred)**2 results = [] for i in range(T): cur_y_pred = method.predict(cur_x) #print(method.forecast(cur_x, 3)) cur_y_true = problem.step() cur_loss = loss(cur_y_true, cur_y_pred) results.append(cur_loss) method.update(cur_y_true) cur_x = cur_y_true if show_plot: plt.plot(results) plt.title("LastValue method on ARMA problem") plt.show(block=False) plt.pause(1) plt.close() print("test_last_value passed") return
def test_custom_method(steps=1000, show_plot=True): # initial preparation T = steps p, q = 3, 3 loss = lambda y_true, y_pred: (y_true - y_pred)**2 problem = tigerforecast.problem("ARMA-v0") cur_x = problem.initialize(p, q) # simple LastValue custom method implementation class Custom(tigerforecast.CustomMethod): def initialize(self): self.x = 0.0 def predict(self, x): self.x = x return self.x def update(self, y): pass # try registering and calling the custom method tigerforecast.register_custom_method(Custom, "TestCustomMethod") custom_method = tigerforecast.method("TestCustomMethod") custom_method.initialize() # regular LastValue method as sanity check reg_method = tigerforecast.method("LastValue") reg_method.initialize() results = [] for i in range(T): cur_y_pred = custom_method.predict(cur_x) reg_y_pred = reg_method.predict(cur_x) assert cur_y_pred == reg_y_pred # check that CustomMethod outputs the correct thing cur_y_true = problem.step() custom_method.update(cur_y_true) reg_method.update(cur_y_true) results.append(loss(cur_y_true, cur_y_pred)) cur_x = cur_y_true if show_plot: plt.plot(results) plt.title("Custom (last value) method on ARMA problem") plt.show(block=False) plt.pause(1) plt.close() print("test_custom_method passed") return
def test_grid_search_lstm(show=False): problem_id = "SP500-v0" method_id = "LSTM" problem_params = {} # {'p':4, 'q':1} # params for ARMA problem method_params = {'n': 1, 'm': 1} loss = lambda a, b: np.sum((a - b)**2) search_space = { 'l': [3, 4, 5, 6], 'h': [2, 5, 8], 'optimizer': [] } # parameters for ARMA method opts = [Adam, Adagrad, ONS, OGD] lr_start, lr_stop = -1, -3 # search learning rates from 10^start to 10^stop learning_rates = np.logspace(lr_start, lr_stop, 1 + 2 * np.abs(lr_start - lr_stop)) for opt, lr in itertools.product(opts, learning_rates): search_space['optimizer'].append( opt(learning_rate=lr)) # create instance and append trials, min_steps = 10, 100 hpo = GridSearch() # hyperparameter optimizer optimal_params, optimal_loss = hpo.search( method_id, method_params, problem_id, problem_params, loss, search_space, trials=trials, smoothing=10, min_steps=min_steps, verbose=show) # run each model at least 1000 steps if show: print("optimal params: ", optimal_params) print("optimal loss: ", optimal_loss) # test resulting method params method = tigerforecast.method(method_id) method.initialize(**optimal_params) problem = tigerforecast.problem(problem_id) x = problem.initialize(**problem_params) loss = [] if show: print("run final test with optimal parameters") for t in range(5000): y_pred = method.predict(x) y_true = problem.step() loss.append(mse(y_pred, y_true)) method.update(y_true) x = y_true if show: print("plot results") plt.plot(loss) plt.show(block=False) plt.pause(10) plt.close()
def test_rnn_lstm_arma(steps=100, show_plot=True): T = steps p, q = 3, 0 problem = tigerforecast.problem("ARMA-v0") cur_x = problem.initialize(p=p, q=q, n=1) method_RNN = tigerforecast.method("RNN") method_RNN.initialize(1, 1, l=p, h=1) method_LSTM = tigerforecast.method("LSTM") method_LSTM.initialize(1, 1, l=p, h=1) loss = lambda pred, true: np.sum((pred - true)**2) results_RNN = [] results_LSTM = [] for i in range(T): y_pred_RNN = method_RNN.predict(cur_x) y_pred_LSTM = method_LSTM.predict(cur_x) if (i == 0): print(method_RNN.forecast(cur_x, timeline=10)) print(method_LSTM.forecast(cur_x, timeline=10)) y_true = problem.step() results_RNN.append(loss(y_true, y_pred_RNN)) results_LSTM.append(loss(y_true, y_pred_LSTM)) cur_x = y_true method_RNN.update(y_true) method_LSTM.update(y_true) if show_plot: plt.plot(results_RNN, label='RNN') plt.plot(results_LSTM, label='LSTM') plt.legend() plt.title("RNN vs. LSTM on ARMA problem") plt.show(block=False) plt.pause(3) plt.close() print("test_rnn_lstm_arma passed") return
def test_autoregressor(show_plot=True): # TEST ARMA df_site_2231000 = get_site_df() seq_len = 61 rows = df_site_2231000.shape[0] label_series = [] for i in range(int(rows / seq_len)): label_series += ast.literal_eval( df_site_2231000[past_sequence_label_feature_name].iloc[61 * i]) method = tigerforecast.method("AutoRegressor") #method.initialize(p, optimizer = ONS) method.initialize(p=3, n=1) loss = lambda y_true, y_pred: (y_true - y_pred)**2 results = [] running_average_loss = [] for i in range(len(label_series) - 1): cur_y_pred = method.predict(label_series[i]) cur_y_true = label_series[i + 1] cur_loss = loss(cur_y_true, cur_y_pred) method.update(cur_y_true) results.append(cur_loss) total_loss = np.sum(results[-100:]) / 100 running_average_loss.append(total_loss) tigerforecast_dir = get_tigerforecast_dir() data_path = os.path.join(tigerforecast_dir, 'data/loss_site_2231000.csv') try: csv_input = pd.read_csv(data_path) except: csv_input = pd.DataFrame([]) if 'ARMA_100_window_average_loss' not in csv_input: csv_input['ARMA_100_window_average_loss'] = running_average_loss csv_input.to_csv(data_path, index=False) if show_plot: plt.figure() plt.plot(results) plt.title("Autoregressive loss on " + past_sequence_label_feature_name) # plt.close() plt.figure() plt.plot(running_average_loss) plt.title("Autoregressive 100-window average loss on " + past_sequence_label_feature_name) plt.show(block=True)
def initialize(self, method_id, method_params, n = None, m = None, N=3, loss=mse, reg=0.0): """ Description: Initializes autoregressive method parameters Args: method_id (string): id of weak learner method method_params (dict): dict of params to pass method N (int): default 3. Number of weak learners loss (function): loss function for boosting method reg (float): default 1.0. constant for regularization. """ self.initialized = True # initialize proxy loss proxy_loss = lambda y_pred, v: np.dot(y_pred, v) + (reg/2) * np.sum(y_pred**2) # 1. Maintain N copies of the algorithm assert N > 0 self.N = N self.methods = [] method_params['n'] = n method_params['m'] = m for _ in range(N): new_method = tigerforecast.method(method_id) new_method.initialize(**method_params) new_method.optimizer.set_loss(proxy_loss) # proxy loss self.methods.append(new_method) def _prev_predict(x): y = [] cur_y = 0 for i, method_i in enumerate(self.methods): eta_i = 2 / (i + 2) y_pred = method_i.predict(x) cur_y = (1 - eta_i) * cur_y + eta_i * y_pred y.append(cur_y) return [np.zeros(shape=y[0].shape)] + y self._prev_predict = _prev_predict def _get_grads(y_true, prev_predicts): g = jax.grad(loss) v_list = [g(y_prev, y_true) for y_prev in prev_predicts] return v_list self._get_grads = jax.jit(_get_grads)
def _run_test(self, method_params, smoothing, min_steps, verbose=0): """ Run a single test with given method params, using median stopping rule """ # initialize problem and method if verbose: print("Currently testing parameters: " + str(method_params)) method = tigerforecast.method(self.method_id) method.initialize(**method_params) problem = tigerforecast.problem(self.problem_id) if problem.has_regressors: x, y_true = problem.initialize(**self.problem_params) else: x = problem.initialize(**self.problem_params) t = 0 losses = [] # sorted losses, used to get median smooth_losses = np.zeros( smoothing) # store previous losses to get smooth loss while True: # run method until worse than median loss, ignoring first 100 steps t += 1 y_pred = method.predict(x) if problem.has_regressors: method.update(y_true) loss = self.loss(y_pred, y_true) else: x = problem.step() method.update(x) loss = self.loss(y_pred, x) if t == 1: # fill all of smooth_losses with the first loss for i in range(smoothing): smooth_losses = self._update_smoothing(smooth_losses, loss) else: # else replace only the oldest loss smooth_losses = self._update_smoothing(smooth_losses, loss) smooth_loss = np.mean(smooth_losses) if t % smoothing == 0: self._add_to_list(losses, smooth_loss) if self._halting_rule(losses, smooth_loss) and t >= min_steps: break if verbose: print("Time taken: {}, final loss: {}".format(t, smooth_loss)) return smooth_loss
def test_sgd_autoregressor(show=False): problem = tigerforecast.problem('ARMA-v0') x = problem.initialize(p=2, q=0) optimizer = SGD(learning_rate=0.0003) method = tigerforecast.method('AutoRegressor') method.initialize(p=3, optimizer=optimizer) # reinitialize with instance loss = [] for t in range(1000): y_pred = method.predict(x) y_true = problem.step() loss.append(mse(y_pred, y_true)) method.update(y_true) x = y_true if show: plt.title("Test SGD on ARMA(3) with AutoRegressor method") plt.plot(loss) plt.show(block=False) plt.pause(3) plt.close()
def test_custom_problem(steps=1000, show=True): # initial preparation T = steps loss = lambda y_true, y_pred: (y_true - y_pred)**2 method = tigerforecast.method("LastValue") method.initialize() # simple custom Problem that returns alternating +/- 1.0 class Custom(tigerforecast.CustomProblem): def initialize(self): self.T = 0 return -1 def step(self): self.T += 1 return 2 * (self.T % 2) - 1 # try registering and calling the custom problem tigerforecast.register_custom_problem(Custom, "TestCustomProblem") custom_problem = tigerforecast.problem("TestCustomProblem") cur_x = custom_problem.initialize() results = [] for i in range(T): cur_y_pred = method.predict(cur_x) cur_y_true = custom_problem.step() results.append(loss(cur_y_true, cur_y_pred)) cur_x = cur_y_true if show: plt.plot(results) plt.title("LastValue method on custom alternating problem") plt.show(block=False) plt.pause(2) plt.close() print("test_custom_problem passed") return
def test_lstm(show_plot=True): n, m, l, h = 7, 1, 3, 10 method = tigerforecast.method("LSTM") method.initialize(n, m, l, h, optimizer=Adam) loss = lambda pred, true: (pred - true)**2 features = process_features() loss_series = [] for i in range(len(features) - 1): x = features[i] y_pred = method.predict(x)[0] y_true = features[i + 1][-1] # print("y_pred: " + str(y_pred)) # print("y_true: " + str(y_true)) loss_series.append(loss(y_true, y_pred)) method.update(y_true) # print(loss_series[-10:]) # save results tigerforecast_dir = get_tigerforecast_dir() data_path = os.path.join(tigerforecast_dir, 'data/loss_site_2231000.csv') try: csv_input = pd.read_csv(data_path) except: csv_input = pd.DataFrame([]) if 'LSTM_adam_loss' not in csv_input: csv_input['LSTM_adam_loss'] = loss_series csv_input.to_csv(data_path, index=False) if show_plot: plt.plot(loss_series) plt.title("LSTM-Adam loss on site 2231000") plt.show(block=True) plt.close()
def test_simple_boost_arma(steps=500, show=True): # method initialize T = steps method_id = "AutoRegressor" method_params = {'p': 18, 'optimizer': OGD} Ns = [64] timelines = [6, 9, 12] # regular AutoRegressor for comparison autoreg = tigerforecast.method("AutoRegressor") autoreg.initialize(p=18, optimizer=OGD) fig, ax = plt.subplots(nrows=1, ncols=3) cur = 0 # run all boosting method for timeline in timelines: # problem initialize problem = tigerforecast.problem("ENSO-v0") x, y_true = problem.initialize(input_signals=['oni'], timeline=timeline) methods = [] for n in Ns: # number of weak learners method = tigerforecast.method("SimpleBoost") method.initialize(method_id, method_params, n, reg=0.0) # regularization methods.append(method) result_list = [[] for n in Ns] autoreg_loss = [] for i in tqdm(range(T)): # predictions for every boosting method for result_i, method_i in zip(result_list, methods): y_pred = method_i.predict(x) result_i.append(mse(y_true, y_pred)) method_i.update(y_true) # last value and autoregressor predictions autoreg_loss.append(mse(autoreg.predict(x), y_true)) autoreg.update(y_true) x, y_true = problem.step() # plot performance if show: start = T // 2 # plot every boosting method loss for n, results in zip(Ns, result_list): print("Mean loss for n={}: {}".format( n, np.mean(np.array(results)))) ax[cur].plot(avg_regret(results[-start:]), label="SimpleBoost, n={}".format(n)) # plot loss for last value and autoregressor methods print("Mean loss for AutoRegressor: {}".format( np.mean(np.array(autoreg_loss)))) ax[cur].plot(avg_regret(autoreg_loss[-start:]), label="AutoRegressor method") ax[cur].legend(loc="upper right", fontsize=8) cur += 1 fig.tight_layout() plt.show()
def run_experiment(problem, method, metric='mse', lr_tuning=True, key=0, timesteps=None, verbose=0): ''' Description: Initializes the experiment instance. Args: problem (tuple): problem id and parameters to initialize the specific problem instance with method (tuple): method id and parameters to initialize the specific method instance with metric (string): metric we are interesting in computing for current experiment key (int): for reproducibility timesteps(int): number of time steps to run experiment for Returns: loss (list): loss series for the specified metric over the entirety of the experiment time (float): time elapsed memory (float): memory used ''' set_key(key) # extract specifications (problem_id, problem_params) = problem (method_id, method_params) = method loss_fn = metrics[metric] # initialize problem problem = tigerforecast.problem(problem_id) if (problem_params is None): init = problem.initialize() else: init = problem.initialize(**problem_params) # get first few x and y if (problem.has_regressors): x, y = init else: x, y = init, problem.step() # initialize method method = tigerforecast.method(method_id) if (method_params is None): method_params = {} try: method_params['n'] = x.shape[0] except: method_params['n'] = 1 try: method_params['m'] = y.shape[0] except: method_params['m'] = 1 if (lr_tuning): method_params = tune_lr(method_id, method_params, problem_id, problem_params) method.initialize(**method_params) if (timesteps is None): if (problem.max_T == -1): print( "WARNING: On simulated problem, the number of timesteps should be specified. Will default to 5000." ) timesteps = 5000 else: timesteps = problem.max_T - method.p - 2 elif (problem.max_T != -1): timesteps = min(timesteps, problem.max_T - method.p - 2) for i in range(method.p): method.predict(x) new = problem.step() #print('x:{0}, y:{1}'.format(x,y)) if (problem.has_regressors): x, y = new else: x, y = y, new #print('history:{0}'.format(method.past)) if (verbose and key == 0): print("Running %s on %s..." % (method_id, problem_id)) loss = np.zeros(timesteps) time_start = time.time() memory = 0 load_bar = False if (verbose == 2): load_bar = True # get loss series for i in tqdm(range(timesteps), disable=(not load_bar or key != 0)): # get loss and update method try: #this avoids exceptions usually caused by ONS cur_loss = float(loss_fn(y, method.predict(x))) loss = jax.ops.index_update(loss, i, cur_loss) method.update(y) # get new pair of observation and label new = problem.step() if (problem.has_regressors): x, y = new else: x, y = y, new except: loss = jax.ops.index_update(loss, i, float('nan')) return loss, time.time() - time_start, memory
def test_flood_FL(steps=61, show_plot=True): T = steps n, m, l, d = 6, 1, 3, 10 # problem = tigerforecast.problem("LDS-Control-v0") # y_true = problem.initialize(n, m, d) tigerforecast_dir = get_tigerforecast_dir() data_path = os.path.join(tigerforecast_dir, 'data/FL_train.csv') df = pd.read_csv(data_path).head() # print(df['static:drain_area_log2'].head()) # arr_results = onp.load(data_path, encoding='bytes') method = tigerforecast.method("LSTM") method.initialize(n, m, l, d) loss = lambda pred, true: np.sum(((pred - true) / true)**2) # num_batches = len(arr_results) # for i in range(num_batches): # print("num_measurements:" + str(len(arr_results[i][2]))) static_features_to_use = [ ('static:drain_area_log2', False), ('train:site:mean:USGS:discharge_mean', False), ('train:site:std:USGS:discharge_mean', False), ] sequence_features_to_use = [ ('sequence:GSMAP_MERGED:hourlyPrecipRate', False), ('sequence:GLDAS21:Tair_f_inst', True), ('sequence:AQUA_VI:NDVI', True) ] label_feature_name = 'label:USGS:discharge_mean' past_sequence_label_feature_name = 'sequence:USGS:discharge_mean' # print("num_batches: " + str(num_batches)) feature_list = [] # sequence_length = df['sequence:USGS:discharge_mean_shape'] # print("type(sequence_length):" + str(type(sequence_length))) # print("sequence length: " + sequence_length) sequence_length = 61 label_list = [] for i in range(5): for j in range(sequence_length): feature = [] for (seq_feat, b) in sequence_features_to_use: # print("seq_feat: " + seq_feat) # print("df[seq_feat].shape: " + str(df[seq_feat].shape)) # print(df[seq_feat]) # print(type(df[seq_feat].iloc[i])) # print(ast.literal_eval(df[seq_feat].iloc[i])) feature.append(ast.literal_eval(df[seq_feat].iloc[i])[j]) for (stat_feat, c) in static_features_to_use: feature.append(ast.literal_eval(df[stat_feat].iloc[0])[0]) feature_list.append(feature) label_list.append( ast.literal_eval(df[label_feature_name].iloc[0])[0]) print(feature_list[0]) print(len(feature_list[0])) print(len(feature_list)) print(len(label_list)) print(label_list[:10]) results = [] for i in range(len(feature_list)): u = feature_list[i] y_pred = method.predict(u) y_true = label_list[i] print("y_pred: " + str(y_pred)) print("y_true: " + str(y_true)) results.append(loss(y_true, y_pred)) method.update(y_true) print(results[-10:]) if show_plot: plt.plot(results[25:]) plt.title("LSTM method on FL_train data") plt.show(block=True) plt.close() ''' for i in range(1000): print(i) for j in range(61): y_pred = method.predict(arr_results[i][2][j]) y_true = arr_results[i][3][j] results.append(loss(y_true, y_pred)) method.update(y_true)''' ''' if show_plot: plt.plot(results) plt.title("LSTM method on LDS problem") plt.show(block=True) plt.close() print("test_lstm passed")''' return
def test_simple_boost_lstm(steps=500, show=True): # method initialize T = steps method_id = "LSTM" ogd = OGD(learning_rate=0.01) method_params = {'n': 1, 'm': 1, 'l': 5, 'h': 10, 'optimizer': ogd} methods = [] Ns = [1, 3, 6] for n in Ns: # number of weak learners method = tigerforecast.method("SimpleBoost") method.initialize(method_id, method_params, n, reg=1.0) # regularization methods.append(method) # regular AutoRegressor for comparison autoreg = tigerforecast.method("AutoRegressor") autoreg.initialize(p=4) # regularization # problem initialize p, q = 4, 0 problem = tigerforecast.problem("ARMA-v0") y_true = problem.initialize(p, q, noise_magnitude=0.1) # run all boosting method result_list = [[] for n in Ns] last_value = [] autoreg_loss = [] for i in range(T): y_next = problem.step() # predictions for every boosting method for result_i, method_i in zip(result_list, methods): y_pred = method_i.predict(y_true) result_i.append(mse(y_next, y_pred)) method_i.update(y_next) # last value and autoregressor predictions last_value.append(mse(y_true, y_next)) autoreg_loss.append(mse(autoreg.predict(y_true), y_next)) autoreg.update(y_next) y_true = y_next # plot performance if show: start = 100 x = np.arange(start, steps) plt.figure(figsize=(12, 8)) # plot every boosting method loss for n, results in zip(Ns, result_list): print("Mean loss for n={}: {}".format( n, np.mean(np.array(results[start:])))) plt.plot(x, avg_regret(results[start:]), label="SimpleBoost, n={}".format(n)) # plot loss for last value and autoregressor methods print("Mean loss for LastValue: {}".format( np.mean(np.array(last_value[start:])))) plt.plot(x, avg_regret(last_value[start:]), label="Last value method") print("Mean loss for AutoRegressor: {}".format( np.mean(np.array(autoreg_loss[start:])))) plt.plot(x, avg_regret(autoreg_loss[start:]), label="AutoRegressor method") plt.title("SimpleBoost method on ARMA problem") plt.legend() plt.show(block=False) plt.pause(10) plt.close()
def test_wave_filtering(show_plot=False): # state variables T, n, m = 1000, 10, 10 # method variables k, eta = 20, 0.00002 # update_steps is an optional variable recommended by Yi R_Theta = 5 R_M = 2 * R_Theta * R_Theta * k**0.5 # generate random data (columns of Y) hidden_state_dim = 5 h = rand.uniform(generate_key(), minval=-1, maxval=1, shape=(hidden_state_dim, )) # first hidden state h_0 A = rand.normal(generate_key(), shape=(hidden_state_dim, hidden_state_dim)) B = rand.normal(generate_key(), shape=(hidden_state_dim, n)) C = rand.normal(generate_key(), shape=(m, hidden_state_dim)) D = rand.normal(generate_key(), shape=(m, n)) A = (A + A.T) / 2 # make A symmetric A = 0.99 * A / np.linalg.norm(A, ord=2) if (np.linalg.norm(B) > R_Theta): B = B * (R_Theta / np.linalg.norm(B)) if (np.linalg.norm(C) > R_Theta): C = C * (R_Theta / np.linalg.norm(C)) if (np.linalg.norm(D) > R_Theta): D = D * (R_Theta / np.linalg.norm(D)) if (np.linalg.norm(h) > R_Theta): h = h * (R_Theta / np.linalg.norm(h)) # input vectors are random data X = rand.normal(generate_key(), shape=(n, T)) # generate Y according to predetermined matrices Y = [] for t in range(T): Y.append( C.dot(h) + D.dot(X[:, t]) + rand.truncated_normal(generate_key(), 0, 0.1, shape=(m, ))) h = A.dot(h) + B.dot(X[:, t]) + rand.truncated_normal( generate_key(), 0, 0.1, shape=(hidden_state_dim, )) Y = np.array(Y).T # list to numpy matrix method = tigerforecast.method("WaveFiltering") method.initialize(n, m, k, T, eta, R_M) # loss = lambda y_true, y_pred: (y_true - y_pred)**2 loss = lambda y_true, y_pred: (np.linalg.norm(y_true - y_pred))**2 lastvalue_method = tigerforecast.method("LastValue") lastvalue_method.initialize() results = [] lastvalue_results = [] for i in range(T): # print(i) cur_y_pred = method.predict(X[:, i]) #print(method.forecast(cur_x, 3)) cur_y_true = Y[:, i] cur_loss = loss(cur_y_true, cur_y_pred) results.append(cur_loss) method.update(cur_y_true) lastvalue_cur_y_pred = lastvalue_method.predict(X[:, i]) lastvalue_cur_y_true = Y[:, i] lastvalue_cur_loss = loss(lastvalue_cur_y_true, lastvalue_cur_y_pred) lastvalue_results.append(lastvalue_cur_loss) # print("test_wave_filtering passed") print(np.linalg.norm(X[:, -1])) print(np.linalg.norm(Y[:-1])) print(results[-10:-1]) if show_plot: plt.plot(results) plt.title("WaveFiltering method on random data") plt.show(block=True) plt.plot(lastvalue_results) plt.title("LastValue method on random data") plt.show(block=True)