def forecast_ahead_distribution(self, ndata, steps, **kwargs):
ret = []
smooth = kwargs.get("smooth", "none")
uod = self.get_UoD()
if 'bins' in kwargs:
_bins = kwargs.pop('bins')
nbins = len(_bins)
else:
nbins = kwargs.get("num_bins", 100)
_bins = np.linspace(uod[0], uod[1], nbins)
start = kwargs.get('start_at', 0)
sample = ndata[start: start + self.max_lag]
for dat in sample:
if 'type' in kwargs:
kwargs.pop('type')
tmp = ProbabilityDistribution.ProbabilityDistribution(smooth, uod=uod, bins=_bins, **kwargs)
tmp.set(dat, 1.0)
ret.append(tmp)
dist = self.forecast_distribution(sample, bins=_bins)[0]
ret.append(dist)
for k in np.arange(self.max_lag+1, steps+self.max_lag+1):
dist = ProbabilityDistribution.ProbabilityDistribution(smooth, uod=uod, bins=_bins, **kwargs)
lags = []
# Find all bins of past distributions with probability greater than zero
for ct, lag in enumerate(self.lags):
dd = ret[k - lag]
vals = [float(v) for v in dd.bins if np.round(dd.density(v), 4) > 0.0]
lags.append( sorted(vals) )
# Trace all possible combinations between the bins of past distributions
for path in product(*lags):
# get the combined probabilities for this path
pk = np.prod([ret[k - (self.max_lag + lag)].density(path[ct])
for ct, lag in enumerate(self.lags)])
d = self.forecast_distribution(path)[0]
for bin in _bins:
dist.set(bin, dist.density(bin) + pk * d.density(bin))
ret.append(dist)
return ret[-steps:]
def forecast_distribution_from_distribution(self, previous_dist, smooth,
uod, bins, **kwargs):
dist = ProbabilityDistribution.ProbabilityDistribution(smooth,
uod=uod,
bins=bins,
**kwargs)
lags = []
# Find all bins of past distributions with probability greater than zero
for ct, lag in enumerate(self.lags):
dd = previous_dist[-lag]
vals = [
float(v) for v in dd.bins if np.round(dd.density(v), 4) > 0.0
]
lags.append(sorted(vals))
# Trace all possible combinations between the bins of past distributions
for path in product(*lags):
# get the combined probabilities for this path
pk = np.prod([
previous_dist[-lag].density(path[ct])
for ct, lag in enumerate(self.lags)
])
d = self.forecast_distribution(path)[0]
for bin in bins:
dist.set(bin, dist.density(bin) + pk * d.density(bin))
return dist
def forecast_ahead_distribution(self, data, steps, **kwargs):
smooth = kwargs.get("smooth", "histogram")
ret = []
start = kwargs.get('start', self.order)
uod = self.get_UoD()
sample = [[k] for k in data[start - self.order:start]]
for k in np.arange(self.order, steps + self.order):
forecasts = []
lags = [sample[k - i - 1] for i in np.arange(0, self.order)]
# Trace the possible paths
for path in product(*lags):
forecasts.extend(self.knn(path))
dist = ProbabilityDistribution.ProbabilityDistribution(
smooth, uod=uod, data=forecasts, name="", **kwargs)
ret.append(dist)
sample.append(
sampler(forecasts, np.arange(.1, 1, 0.1), bounds=True))
return ret
def forecast_distribution(self, data, **kwargs):
ret = []
X = []
l = len(data)
for t in np.arange(self.order, l):
X.append([data[t - k - 1] for k in np.arange(self.order)])
Y, sigma = self.model.predict(X, return_std=True)
for k in len(Y):
dist = ProbabilityDistribution.ProbabilityDistribution(
type="histogram", uod=[self.original_min, self.original_max])
intervals = []
for alpha in np.arange(0.05, 0.5, 0.05):
qt1 = Y[k] + st.norm.ppf(alpha) * sigma[k]
qt2 = Y[k] + st.norm.ppf(1 - alpha) * sigma[k]
intervals.append([qt1, qt2])
dist.append_interval(intervals)
ret.append(dist)
return ret
def forecast_distribution(self, data, **kwargs):
ret = []
smooth = kwargs.get("smooth", "KDE")
alpha = kwargs.get("alpha", None)
uod = self.get_UoD()
for k in data.index:
tmp = self.get_models_forecasts(data.ix[k])
if alpha is None:
tmp = np.ravel(tmp).tolist()
else:
tmp = self.get_distribution_interquantile(
np.ravel(tmp).tolist(), alpha)
name = str(self.indexer.get_index(data.ix[k]))
dist = ProbabilityDistribution.ProbabilityDistribution(smooth,
uod=uod,
data=tmp,
name=name,
**kwargs)
ret.append(dist)
return ret
def forecast_ahead_distribution(self, data, steps, **kwargs):
smoothing = kwargs.get("smoothing", 0.5)
sigma = np.sqrt(self.model_fit.sigma2)
l = len(data)
ret = []
nmeans = self.forecast_ahead(data, steps, **kwargs)
for k in np.arange(0, steps):
dist = ProbabilityDistribution.ProbabilityDistribution(
type="histogram", uod=[self.original_min, self.original_max])
intervals = []
for alpha in np.arange(0.05, 0.5, 0.05):
tmp = []
hsigma = (1 + k * smoothing) * sigma
tmp.append(nmeans[k] + st.norm.ppf(alpha) * hsigma)
tmp.append(nmeans[k] + st.norm.ppf(1 - alpha) * hsigma)
intervals.append(tmp)
dist.append_interval(intervals)
ret.append(dist)
return ret
def forecast_distribution(self, data, **kwargs):
sigma = np.sqrt(self.model_fit.sigma2)
l = len(data)
ret = []
for k in np.arange(self.order, l + 1):
sample = [data[i] for i in np.arange(k - self.order, k)]
mean = self.forecast(sample)
if isinstance(mean, (list, np.ndarray)):
mean = mean[0]
dist = ProbabilityDistribution.ProbabilityDistribution(
type="histogram", uod=[self.original_min, self.original_max])
intervals = []
for alpha in np.arange(0.05, 0.5, 0.05):
qt1 = mean + st.norm.ppf(alpha) * sigma
qt2 = mean + st.norm.ppf(1 - alpha) * sigma
intervals.append([qt1, qt2])
dist.append_interval(intervals)
ret.append(dist)
return ret
def forecast_distribution(self, data, **kwargs):
ret = []
smooth = kwargs.get("smooth", "KDE")
alpha = kwargs.get("alpha", None)
uod = self.get_UoD()
for k in np.arange(self.order, len(data)):
sample = data[k - self.order:k]
forecasts = self.get_models_forecasts(sample)
if alpha is None:
forecasts = np.ravel(forecasts).tolist()
else:
forecasts = self.get_distribution_interquantile(
np.ravel(forecasts).tolist(), alpha)
dist = ProbabilityDistribution.ProbabilityDistribution(
smooth, uod=uod, data=forecasts, name="", **kwargs)
ret.append(dist)
return ret
def forecast_ahead_distribution(self, ndata, steps, **kwargs):
smoothing = kwargs.get("smoothing", 0.01)
l = len(ndata)
ret = []
nmeans = self.forecast_ahead(ndata, steps, **kwargs)
for k in np.arange(0, self.order):
nmeans.insert(k, ndata[k])
for k in np.arange(self.order, steps + self.order):
dist = ProbabilityDistribution.ProbabilityDistribution(
type="histogram", uod=[self.original_min, self.original_max])
intervals = [[nmeans[self.order], nmeans[self.order]]]
for qt in self.dist_qt:
intl1 = self.point_to_interval(nmeans[k - self.order:k], qt[0],
qt[1])
tmpk = k - self.order
intl2 = [
intl1[0] * (1 - (tmpk * smoothing)),
intl1[1] * (1 + (tmpk * smoothing))
]
intervals.append(intl2)
dist.append_interval(intervals)
ret.append(dist)
return ret
def forecast_ahead_distribution(self, data, steps, **kwargs):
smoothing = kwargs.get("smoothing", 0.5)
X = [data[t] for t in np.arange(self.order)]
S = []
for k in np.arange(self.order, steps + self.order):
sample = [X[k - t - 1] for t in np.arange(self.order)]
Y, sigma = self.model.predict([sample], return_std=True)
X.append(Y[0])
S.append(sigma[0])
X = X[-steps:]
#uncertainty = st.norm.ppf(alpha) * np.sqrt(np.diag(sigma))
ret = []
for k in range(steps):
dist = ProbabilityDistribution.ProbabilityDistribution(
type="histogram", uod=[self.original_min, self.original_max])
intervals = []
for alpha in np.arange(0.05, 0.5, 0.05):
qt1 = X[k] - st.norm.ppf(alpha) * (
1 + k * smoothing) * np.sqrt(S[k])
qt2 = X[k] - st.norm.ppf(1 - alpha) * (
1 + k * smoothing) * np.sqrt(S[k])
intervals.append([qt1, qt2])
dist.append_interval(intervals)
ret.append(dist)
return ret
def forecast_ahead_distribution(self, ndata, steps, **kwargs):
ret = []
if 'type' in kwargs:
kwargs.pop('type')
smooth = kwargs.get("smooth", "none")
uod = self.get_UoD()
if 'bins' in kwargs:
_bins = kwargs.pop('bins')
nbins = len(_bins)
else:
nbins = kwargs.get("num_bins", 100)
_bins = np.linspace(uod[0], uod[1], nbins)
start = kwargs.get('start_at', 0)
if 'fuzzyfied' in kwargs:
fuzzyfied = kwargs.pop('fuzzyfied')
else:
fuzzyfied = False
if not fuzzyfied:
sample = ndata[start:start + self.max_lag]
else:
sample = []
for k in ndata[start:start + self.max_lag]:
kv = self.partitioner.defuzzyfy(k, mode='both')
sample.append(kv)
for dat in sample:
if not isinstance(dat,
ProbabilityDistribution.ProbabilityDistribution):
tmp = ProbabilityDistribution.ProbabilityDistribution(
smooth, uod=uod, bins=_bins, **kwargs)
tmp.set(dat, 1.0)
ret.append(tmp)
else:
ret.append(dat)
dist = self.forecast_distribution_from_distribution(
ret, smooth, uod, _bins, **kwargs)
ret.append(dist)
for k in np.arange(start + self.max_lag, steps + start + self.max_lag):
dist = self.forecast_distribution_from_distribution(
ret[k - self.max_lag:], smooth, uod, _bins, **kwargs)
ret.append(dist)
return ret[-steps:]
def forecast_distribution(self, data, **kwargs):
sim_vector = self.inference(steps)
ret = []
for ct, sample in enumerate(sim_vector):
pd = ProbabilityDistribution.ProbabilityDistribution(type='histogram', data=sample, nbins=500)
ret.append(pd)
return ret
def forecast_distribution(self, ndata, **kwargs):
smooth = kwargs.get("smooth", "none")
l = len(ndata)
uod = self.get_UoD()
if 'bins' in kwargs:
_bins = kwargs.pop('bins')
nbins = len(_bins)
else:
nbins = kwargs.get("num_bins", 100)
_bins = np.linspace(uod[0], uod[1], nbins)
ret = []
for k in np.arange(self.order - 1, l):
sample = ndata[k - (self.order - 1):k + 1]
flrgs = self.generate_lhs_flrg(sample)
if 'type' in kwargs:
kwargs.pop('type')
dist = ProbabilityDistribution.ProbabilityDistribution(smooth,
uod=uod,
bins=_bins,
**kwargs)
for bin in _bins:
num = []
den = []
for s in flrgs:
if s.get_key() in self.flrgs:
flrg = self.flrgs[s.get_key()]
pk = flrg.lhs_conditional_probability(
sample, self.sets, self.global_frequency_count,
uod, nbins)
wi = flrg.rhs_conditional_probability(
bin, self.sets, uod, nbins)
num.append(wi * pk)
den.append(pk)
else:
num.append(0.0)
den.append(0.000000001)
pf = sum(num) / sum(den)
dist.set(bin, pf)
ret.append(dist)
return ret
def forecast_ahead_distribution(self, ndata, steps, **kwargs):
ret = []
for k in np.arange(self.order, steps + self.order):
dist = ProbabilityDistribution.ProbabilityDistribution(type="histogram",
uod=[self.original_min, self.original_max])
intervals = [[k, k] for k in ndata[-self.order:]]
for qt in self.dist_qt:
intl = self.interval_to_interval([intervals[x] for x in np.arange(k - self.order, k)], qt[0], qt[1])
intervals.append(intl)
dist.append_interval(intervals)
ret.append(dist)
return ret
def forecast_ahead_distribution(self, data, steps, **kwargs):
if 'method' in kwargs:
self.point_method = kwargs.get('method', 'mean')
smooth = kwargs.get("smooth", "KDE")
alpha = kwargs.get("alpha", None)
ret = []
start = kwargs.get('start', self.order)
uod = self.get_UoD()
sample = data[start - self.order:start]
for k in np.arange(self.order, steps + self.order):
forecasts = []
lags = {}
for i in np.arange(0, self.order):
lags[i] = sample[k - self.order]
# Build the tree with all possible paths
root = tree.FLRGTreeNode(None)
tree.build_tree_without_order(root, lags, 0)
for p in root.paths():
path = list(reversed(list(filter(None.__ne__, p))))
forecasts.extend(self.get_models_forecasts(path))
sample.append(sampler(forecasts, np.arange(0.1, 1, 0.1)))
if alpha is None:
forecasts = np.ravel(forecasts).tolist()
else:
forecasts = self.get_distribution_interquantile(
np.ravel(forecasts).tolist(), alpha)
dist = ProbabilityDistribution.ProbabilityDistribution(
smooth, uod=uod, data=forecasts, name="", **kwargs)
ret.append(dist)
return ret
def forecast_distribution(self, data, **kwargs):
ret = []
smooth = kwargs.get("smooth", "histogram")
uod = self.get_UoD()
for k in np.arange(self.order, len(data)):
sample = data[k - self.order:k]
forecasts = self.knn(sample)
dist = ProbabilityDistribution.ProbabilityDistribution(
smooth, uod=uod, data=forecasts, name="", **kwargs)
ret.append(dist)
return ret
def forecast_distribution(self, ndata, **kwargs):
ret = []
l = len(ndata)
for k in np.arange(self.order, l + 1):
dist = ProbabilityDistribution.ProbabilityDistribution(type="histogram",
uod=[self.original_min, self.original_max])
intervals = []
for qt in self.dist_qt:
sample = ndata[k - self.order: k]
intl = self.point_to_interval(sample, qt[0], qt[1])
intervals.append(intl)
dist.append_interval(intervals)
ret.append(dist)
return ret
def forecast_ahead_distribution(self, data, steps, **kwargs):
if 'method' in kwargs:
self.point_method = kwargs.get('method', 'mean')
smooth = kwargs.get("smooth", "histogram")
alpha = kwargs.get("alpha", None)
ret = []
start = kwargs.get('start_at', self.order)
uod = self.get_UoD()
sample = [[k] for k in data[start:start + self.order]]
for k in np.arange(self.order, steps + self.order):
forecasts = []
lags = []
for i in np.arange(0, self.order):
lags.append(sample[i - self.order])
# Trace the possible paths
for path in product(*lags):
forecasts.extend(self.get_models_forecasts(path))
sample.append(
sampler(forecasts, np.arange(.1, 1, 0.1), bounds=True))
if alpha is None:
forecasts = np.ravel(forecasts).tolist()
else:
forecasts = self.get_distribution_interquantile(
np.ravel(forecasts).tolist(), alpha)
dist = ProbabilityDistribution.ProbabilityDistribution(
smooth, uod=uod, data=forecasts, name="", **kwargs)
ret.append(dist)
return ret[-steps:]
def forecast_ahead_distribution(self, ndata, steps, **kwargs):
ret = []
smooth = kwargs.get("smooth", "none")
uod = self.get_UoD()
if 'bins' in kwargs:
_bins = kwargs.pop('bins')
nbins = len(_bins)
else:
nbins = kwargs.get("num_bins", 100)
_bins = np.linspace(uod[0], uod[1], nbins)
start = kwargs.get('start', self.order)
sample = ndata[start - self.order:start]
for dat in sample:
if 'type' in kwargs:
kwargs.pop('type')
tmp = ProbabilityDistribution.ProbabilityDistribution(smooth,
uod=uod,
bins=_bins,
**kwargs)
tmp.set(dat, 1.0)
ret.append(tmp)
dist = self.forecast_distribution(sample, bins=_bins)[0]
ret.append(dist)
for k in np.arange(self.order + 1, steps + self.order + 1):
dist = ProbabilityDistribution.ProbabilityDistribution(smooth,
uod=uod,
bins=_bins,
**kwargs)
lags = {}
# Find all bins of past distributions with probability greater than zero
for ct, dd in enumerate(ret[k - self.order:k]):
vals = [
float(v) for v in dd.bins if round(dd.density(v), 4) > 0
]
lags[ct] = sorted(vals)
root = tree.FLRGTreeNode(None)
tree.build_tree_without_order(root, lags, 0)
# Trace all possible combinations between the bins of past distributions
for p in root.paths():
path = list(reversed(list(filter(None.__ne__, p))))
# get the combined probabilities for this path
pk = np.prod([
ret[k - self.order + o].density(path[o])
for o in np.arange(0, self.order)
])
d = self.forecast_distribution(path)[0]
for bin in _bins:
dist.set(bin, dist.density(bin) + pk * d.density(bin))
ret.append(dist)
return ret[self.order:]
def forecast_distribution(self, ndata, **kwargs):
smooth = kwargs.get("smooth", "none")
from_distribution = kwargs.get('from_distribution', False)
fuzzyfied = kwargs.get('fuzzyfied', False)
l = len(ndata)
uod = self.get_UoD()
if 'bins' in kwargs:
_bins = kwargs.pop('bins')
nbins = len(_bins)
else:
nbins = kwargs.get("num_bins", 100)
_bins = np.linspace(uod[0], uod[1], nbins)
ret = []
for k in np.arange(self.max_lag - 1, l):
sample = ndata[k - (self.max_lag - 1):k + 1]
if from_distribution:
dist = self.forecast_distribution_from_distribution(
sample, smooth, uod, _bins)
else:
if not fuzzyfied:
flrgs = self.generate_lhs_flrg(sample)
else:
fsets = self.get_sets_from_both_fuzzyfication(sample)
flrgs = self.generate_lhs_flrg_fuzzyfied(fsets)
if 'type' in kwargs:
kwargs.pop('type')
dist = ProbabilityDistribution.ProbabilityDistribution(
smooth, uod=uod, bins=_bins, **kwargs)
for bin in _bins:
num = []
den = []
for s in flrgs:
if s.get_key() in self.flrgs:
flrg = self.flrgs[s.get_key()]
wi = flrg.rhs_conditional_probability(
bin, self.partitioner.sets, uod, nbins)
if not fuzzyfied:
pk = flrg.lhs_conditional_probability(
sample, self.partitioner.sets,
self.global_frequency_count, uod, nbins)
else:
lhs_mv = self.pwflrg_lhs_memberhip_fuzzyfied(
flrg, sample)
pk = flrg.lhs_conditional_probability_fuzzyfied(
lhs_mv, self.partitioner.sets,
self.global_frequency_count, uod, nbins)
num.append(wi * pk)
den.append(pk)
else:
num.append(0.0)
den.append(0.000000001)
pf = np.nansum(num) / np.nansum(den)
dist.set(bin, pf)
ret.append(dist)
return ret
