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