def uni_baseline(self, steps): pred_values = [] end = steps values = self.uni_data[:-end] actual_values = self.uni_data[len(self.uni_data) - end:] pred_values = [] indexes = self.uni_data[len(self.uni_data) - end:].index for i in range(1, len(actual_values)): pred_values.append(actual_values[i]) pred_values.append(0) """plt.figure(num=None, figsize=(20, 2), dpi=100,facecolor='w', edgecolor='k') plt.xlabel('Time', fontsize=8) plt.ylabel('Adjusted Stock ', fontsize=8) plt.plot(actual_values,marker='.', color='pink') plt.plot(pred_values,marker='.', color='purple') plt.title("Adjusted Stocks ",fontsize=12) plt.show() """ rmse = math.sqrt(rms(actual_values, pred_values)) print("RMSE VALUE : ", rmse) return { "model": "Baseline", "index": list(indexes), "actual": list(actual_values.values), "predicted": list(pred_values), "rmse": rmse }
def gradient_regressor(C, iterations_remaining=10000): changed_w1, changed_w2 = 0., 0. while iterations_remaining: iterations_remaining -= 1 w1, w2 = changed_w1, changed_w2 changed_w1 = w1 + delta_for_w(1, w1, w2, C) changed_w2 = w2 + delta_for_w(2, w1, w2, C) if np.sqrt(rms([w1, w2], [changed_w1, changed_w2])) <= ERROR: break return changed_w1, changed_w2
def sarima(data, steps): model = SARIMAX(endog=data.values, order=(2, 0, 1), seasonal_order=(0, 1, 1, 7), enforce_invertibility=False) sarima_fit = model.fit() print(sarima_fit.summary()) # Rollling Forecast # Number of days to Forecast Parameter end = int(0.2 * len(data)) values = data[:-end] actual_values = data[len(data) - end:] pred_values = [] indexes = data[len(data) - end:].index for i in range(end): model = ARIMA((values), (2, 0, 1)) arima_fit = model.fit() fnext = arima_fit.forecast()[0][0] pred_values.append(fnext) values = data[:-end + i] pred_values = pd.Series(pred_values) pred_values.index = indexes #Doubt #pred_values=pred_values.shift(-1)[:] rmse = rms(actual_values, pred_values) # Needs correction ?? print("RMSE VALUE", rmse) #print(actual_values,pred_values) print(len(pred_values)) return { "model": "Baseline", "index": list(indexes), "actual": list(actual_values.values), "predicted": list(pred_values), "rmse": rmse }
def lstm(data, steps): print(data, steps) indexes = data.index end = int(0.2 * len(data)) train, test = data[0:-end], data[-end:] x, y = transform_supervised(train) df = pd.concat([x, y], axis=1) df.columns = ["x", "y"] df.fillna(0, inplace=True) mx, df = scale_data(df) x, lstm_model = fit_lstm(df, 1, 5, 40) # forecast the entire training dataset to build up state for forecasting #train_reshaped = train_scaled[:, 0].reshape(len(train_scaled), 1, 1) testx, testy = transform_supervised(test) df1 = pd.concat([testx, testy], axis=1) df1.columns = ["x", "y"] df1.fillna(0, inplace=True) mx1, df1 = scale_data(df1) testx, testy = df1.iloc[:, :-1], df1.iloc[:, -1] testx = np.asarray(testx).reshape(testx.shape[0], 1, testx.shape[1]) pred_values = lstm_model.predict(testx, batch_size=1) rmse = rms(testy, pred_values) print("RMSE VALUE : ", rmse) return { "model": "LSTM", "index": list(indexes[-end:]), "actual": list(testy), "predicted": reduce(lambda x, y: x + y, pred_values.tolist()), "rmse": rmse }
def ANM_ordering(data, method='gpr', data_max=1000, data_split=True): start = time.time() if data.shape[0] > data_max: idx = np.random.permutation(data.shape[0])[:data_max] data = data[idx, :] print(data.shape) scaler = MinMaxScaler(feature_range=(-1, 1)) data = scaler.fit_transform(data) if data_split: split = int(data.shape[0] / 2) np.random.shuffle(data) train, test = data[:split, :], data[split:, :] else: train = data.copy() test = data.copy() print(train.shape) print(test.shape) train_backup = train.copy() test_backup = test.copy() hsic_history = [] cost_history = [] n = data.shape[1] j = n S = list(range(n)) sig = np.zeros(n, dtype=int) for k in range(n): print('iteration' + str(k)) pvalues_values = np.array([]) hsic_values = np.array([]) if len(S) == 1: j = j - 1 sig[j] = S[0] else: for i in range(len(S)): hsic = HSIC(method='gamma') if method == 'gpr': model = GPR(normalize_y=False) # model = GPR() elif method == 'lsr': model = LSR(alpha=1.0) else: print('error') exit(0) print(np.delete(train, [i], axis=1).shape) model.fit(np.delete(train, [i], axis=1), train[:, i]) rms_error = rms(train[:, i], model.predict(np.delete(train, [i], axis=1))) # Error of the prediction of variable i without the use of the input weights associated to variable i err = test[:, i] - model.predict(np.delete(test, [i], axis=1)) print('cost: ' + str(rms_error)) cost_history.append(rms_error) # Measure of independence pvalues_values = np.append( pvalues_values, hsic.fit(np.delete(test, [i], axis=1), err)) hsic_values = np.append(hsic_values, hsic.init_hsic) print(hsic_values) # Reset the weights of variable i to its initial values using the backup (BlackIn) j = j - 1 print('pvalues ' + str(pvalues_values)) print('hsics ' + str(hsic_values)) idp = np.argmax(pvalues_values) if len([x for x in pvalues_values if x == np.max(pvalues_values) ]) > 1: # if len(p[p == p[idp]]) > 1: hsic_values[pvalues_values != pvalues_values[idp]] = 1 idp = np.argmin(hsic_values) sig[j] = S[idp] del S[idp] print(sig) hsic_history.append(hsic_values) train = np.delete(train, [idp], axis=1) test = np.delete(test, [idp], axis=1) # sig = np.array([2, 1, 3, 0]) end = time.time() print('time ANM_ordering: ' + str(end - start)) result = { 'order': sig, 'order time': end - start, 'cost_history': cost_history, 'hsic_history': hsic_history, } # def ANM_discovery(data, sig, alpha, method='gpr'): start = time.time() parent = dict() for i in range(len(sig)): parent[sig[i]] = list(sig[:i]) hsic_list_discovery = [] p_list_discovery = [] for i in parent.keys(): print('i: ' + str(i)) pa = list(parent[i]) train_temp = train_backup[:, pa].copy() test_temp = test_backup[:, pa].copy() print('pa: ' + str(pa)) if len(pa) > 1: for k in pa: print(k) hsic = HSIC(method='gamma') if method == 'gpr': model = GPR(normalize_y=False) elif method == 'lsr': model = LSR(alpha=1.0) else: print('error') idk = int(np.argwhere(pa == k).reshape(1)) print(idk) model.fit(np.delete(train_temp, [idk], axis=1), train_backup[:, i]) rms_error = rms( train_backup[:, i], model.predict(np.delete(train_temp, [idk], axis=1))) err = test_backup[:, i] - model.predict( np.delete(test_temp, [idk], axis=1)) print('cost: ' + str(rms_error)) p = hsic.fit(np.delete(test_temp, [idk], axis=1), err) # p = 1 print('p-value: ' + str(p)) print('hsic: ' + str(hsic.init_hsic)) hsic_list_discovery.append(hsic.init_hsic) p_list_discovery.append(p) if (p >= alpha): parent[i].remove(k) # p = hsic.fit(data[:, k], err) # if (p < alpha): # parent_disc[i].remove(k) end = time.time() print('time ANM_discovery: ' + str(end - start)) result['discovery'] = parent result['discovery_time'] = end - start result['hsic_history_discovery'] = hsic_list_discovery result['p_history_discovery'] = p_list_discovery return result