- Deep refactor on function names for

This commit is contained in:
Petrônio Cândido 2018-02-26 13:11:29 -03:00
parent 09e5415929
commit 6e4df0ce33
39 changed files with 423 additions and 254 deletions

View File

@ -303,7 +303,7 @@ def get_point_statistics(data, model, indexer=None):
def get_interval_statistics(original, model):
"""Condensate all measures for point_to_interval forecasters"""
ret = list()
forecasts = model.forecastInterval(original)
forecasts = model.forecast_interval(original)
ret.append(round(sharpness(forecasts), 2))
ret.append(round(resolution(forecasts), 2))
ret.append(round(coverage(original[model.order:], forecasts[:-1]), 2))
@ -318,7 +318,7 @@ def get_distribution_statistics(original, model, steps, resolution):
ret = list()
try:
_s1 = time.time()
densities1 = model.forecastAheadDistribution(original, steps, parameters=3)
densities1 = model.forecast_ahead_distribution(original, steps, parameters=3)
_e1 = time.time()
ret.append(round(crps(original, densities1), 3))
ret.append(round(_e1 - _s1, 3))
@ -329,7 +329,7 @@ def get_distribution_statistics(original, model, steps, resolution):
try:
_s2 = time.time()
densities2 = model.forecastAheadDistribution(original, steps, parameters=2)
densities2 = model.forecast_ahead_distribution(original, steps, parameters=2)
_e2 = time.time()
ret.append( round(crps(original, densities2), 3))
ret.append(round(_e2 - _s2, 3))

View File

@ -94,7 +94,7 @@ def plotResiduals(targets, models, tam=[8, 8], save=False, file=None):
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)
def plot_residuals(targets, models, tam=[8, 8], save=False, file=None):
@ -127,7 +127,7 @@ def plot_residuals(targets, models, tam=[8, 8], save=False, file=None):
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)
def single_plot_residuals(targets, forecasts, order, tam=[8, 8], save=False, file=None):
@ -153,4 +153,4 @@ def single_plot_residuals(targets, forecasts, order, tam=[8, 8], save=False, fil
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)

View File

@ -317,7 +317,7 @@ def unified_scaled_point(experiments, tam, save=False, file=None,
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)
def plot_dataframe_point(file_synthetic, file_analytic, experiments, tam, save=False, file=None,
@ -372,7 +372,7 @@ def plot_dataframe_point(file_synthetic, file_analytic, experiments, tam, save=F
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)
def check_replace_list(m, replace):
@ -640,7 +640,7 @@ def unified_scaled_interval(experiments, tam, save=False, file=None,
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)
def plot_dataframe_interval(file_synthetic, file_analytic, experiments, tam, save=False, file=None,
@ -695,7 +695,7 @@ def plot_dataframe_interval(file_synthetic, file_analytic, experiments, tam, sav
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)
def unified_scaled_interval_pinball(experiments, tam, save=False, file=None,
@ -793,7 +793,7 @@ def unified_scaled_interval_pinball(experiments, tam, save=False, file=None,
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)
def plot_dataframe_interval_pinball(file_synthetic, file_analytic, experiments, tam, save=False, file=None,
sort_columns=['COVAVG','SHARPAVG','COVSTD','SHARPSTD'],
@ -843,7 +843,7 @@ def plot_dataframe_interval_pinball(file_synthetic, file_analytic, experiments,
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)
def save_dataframe_ahead(experiments, file, objs, crps_interval, crps_distr, times1, times2, save, synthetic):
@ -1067,7 +1067,7 @@ def unified_scaled_ahead(experiments, tam, save=False, file=None,
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)
def plot_dataframe_ahead(file_synthetic, file_analytic, experiments, tam, save=False, file=None,
@ -1110,5 +1110,5 @@ def plot_dataframe_ahead(file_synthetic, file_analytic, experiments, tam, save=F
axes[1].boxplot(crps2, labels=labels, autorange=True, showmeans=True)
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)

View File

@ -43,7 +43,7 @@ class ARIMA(fts.FTS):
if self.indexer is not None:
data = self.indexer.get_data(data)
data = self.doTransformations(data, updateUoD=True)
data = self.apply_transformations(data, updateUoD=True)
old_fit = self.model_fit
try:
@ -66,7 +66,7 @@ class ARIMA(fts.FTS):
if self.indexer is not None and isinstance(data, pd.DataFrame):
data = self.indexer.get_data(data)
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -86,18 +86,18 @@ class ARIMA(fts.FTS):
else:
ret = ar
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret
def forecastInterval(self, data, **kwargs):
def forecast_interval(self, data, **kwargs):
if self.model_fit is None:
return np.nan
sigma = np.sqrt(self.model_fit.sigma2)
#ndata = np.array(self.doTransformations(data))
#ndata = np.array(self.apply_transformations(data))
l = len(data)
@ -118,11 +118,11 @@ class ARIMA(fts.FTS):
ret.append(tmp)
#ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]], point_to_interval=True)
#ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]], point_to_interval=True)
return ret
def forecastAheadInterval(self, data, steps, **kwargs):
def forecast_ahead_interval(self, data, steps, **kwargs):
if self.model_fit is None:
return np.nan
@ -130,11 +130,11 @@ class ARIMA(fts.FTS):
sigma = np.sqrt(self.model_fit.sigma2)
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
nmeans = self.forecastAhead(ndata, steps, **kwargs)
nmeans = self.forecast_ahead(ndata, steps, **kwargs)
ret = []
@ -148,14 +148,14 @@ class ARIMA(fts.FTS):
ret.append(tmp)
ret = self.doInverseTransformations(ret, params=[[data[-1] for a in np.arange(0,steps)]], interval=True)
ret = self.apply_inverse_transformations(ret, params=[[data[-1] for a in np.arange(0, steps)]], interval=True)
return ret
def empty_grid(self, resolution):
return self.get_empty_grid(-(self.original_max*2), self.original_max*2, resolution)
def forecastDistribution(self, data, **kwargs):
def forecast_distribution(self, data, **kwargs):
if self.indexer is not None and isinstance(data, pd.DataFrame):
data = self.indexer.get_data(data)
@ -185,14 +185,14 @@ class ARIMA(fts.FTS):
intervals.append([qt1, qt2])
dist.appendInterval(intervals)
dist.append_interval(intervals)
ret.append(dist)
return ret
def forecastAheadDistribution(self, data, steps, **kwargs):
def forecast_ahead_distribution(self, data, steps, **kwargs):
smoothing = kwargs.get("smoothing", 0.5)
sigma = np.sqrt(self.model_fit.sigma2)
@ -201,7 +201,7 @@ class ARIMA(fts.FTS):
ret = []
nmeans = self.forecastAhead(data, steps, **kwargs)
nmeans = self.forecast_ahead(data, steps, **kwargs)
for k in np.arange(0, steps):
dist = ProbabilityDistribution.ProbabilityDistribution(type="histogram",
@ -217,7 +217,7 @@ class ARIMA(fts.FTS):
intervals.append(tmp)
dist.appendInterval(intervals)
dist.append_interval(intervals)
ret.append(dist)

View File

@ -87,7 +87,7 @@ def run_point(mfts, partitioner, train_data, test_data, window_key=None, transfo
_key = mfts.shortname + " n = " + str(mfts.order) + " " + pttr + " q = " + str(partitioner.partitions)
mfts.partitioner = partitioner
if transformation is not None:
mfts.appendTransformation(transformation)
mfts.append_transformation(transformation)
_start = time.time()
mfts.train(train_data, partitioner.sets, order=mfts.order)
@ -272,7 +272,7 @@ def all_point_forecasters(data_train, data_test, partitions, max_order=3, statis
for count, model in enumerate(models, start=0):
#print(model)
if transformation is not None:
model.appendTransformation(transformation)
model.append_transformation(transformation)
model.train(data_train, data_train_fs.sets, order=model.order)
objs.append(model)
lcolors.append( colors[count % ncol] )
@ -380,7 +380,7 @@ def interval_sliding_window(data, windowsize, train=0.8, models=None, partitione
times[_key] = []
if transformation is not None:
mfts.appendTransformation(transformation)
mfts.append_transformation(transformation)
_start = time.time()
mfts.train(training, data_train_fs.sets)
@ -414,7 +414,7 @@ def interval_sliding_window(data, windowsize, train=0.8, models=None, partitione
times[_key] = []
if transformation is not None:
mfts.appendTransformation(transformation)
mfts.append_transformation(transformation)
_start = time.time()
mfts.train(training, data_train_fs.sets, order=order)
@ -473,7 +473,7 @@ def all_interval_forecasters(data_train, data_test, partitions, max_order=3,save
for count, model in Util.enumerate2(models, start=0, step=2):
if transformation is not None:
model.appendTransformation(transformation)
model.append_transformation(transformation)
model.train(data_train, data_train_fs, order=model.order)
objs.append(model)
lcolors.append( colors[count % ncol] )
@ -552,7 +552,7 @@ def plot_compared_series(original, models, colors, typeonlegend=False, save=Fals
ax.plot(forecasts, color=colors[count], label=lbl, ls="-",linewidth=linewidth)
if fts.has_interval_forecasting and intervals:
forecasts = fts.forecastInterval(original)
forecasts = fts.forecast_interval(original)
lbl = fts.shortname + " " + str(fts.order if fts.is_high_order and not fts.benchmark_only else "")
if not points and intervals:
ls = "-"
@ -573,7 +573,7 @@ def plot_compared_series(original, models, colors, typeonlegend=False, save=Fals
ax.set_xlabel('T')
ax.set_xlim([0, len(original)])
Util.showAndSaveImage(fig, file, save, lgd=legends)
Util.show_and_save_image(fig, file, save, lgd=legends)
def plot_probability_distributions(pmfs, lcolors, tam=[15, 7]):
@ -627,7 +627,7 @@ def ahead_sliding_window(data, windowsize, train, steps, models=None, resolution
times2[_key] = []
if transformation is not None:
mfts.appendTransformation(transformation)
mfts.append_transformation(transformation)
_start = time.time()
mfts.train(train, data_train_fs.sets)
@ -662,7 +662,7 @@ def ahead_sliding_window(data, windowsize, train, steps, models=None, resolution
times2[_key] = []
if transformation is not None:
mfts.appendTransformation(transformation)
mfts.append_transformation(transformation)
_start = time.time()
mfts.train(train, data_train_fs.sets, order=order)
@ -699,7 +699,7 @@ def all_ahead_forecasters(data_train, data_test, partitions, start, steps, resol
mfts = model("")
if not mfts.is_high_order:
if transformation is not None:
mfts.appendTransformation(transformation)
mfts.append_transformation(transformation)
mfts.train(data_train, data_train_fs)
objs.append(mfts)
lcolors.append( colors[count % ncol] )
@ -708,7 +708,7 @@ def all_ahead_forecasters(data_train, data_test, partitions, start, steps, resol
if order >= mfts.min_order:
mfts = model(" n = " + str(order))
if transformation is not None:
mfts.appendTransformation(transformation)
mfts.append_transformation(transformation)
mfts.train(data_train, data_train_fs, order=order)
objs.append(mfts)
lcolors.append(colors[count % ncol])
@ -771,14 +771,14 @@ def plot_compared_intervals_ahead(original, models, colors, distributions, time_
for count, fts in enumerate(models, start=0):
if fts.has_probability_forecasting and distributions[count]:
density = fts.forecastAheadDistribution(original[time_from - fts.order:time_from], time_to,
resolution=resolution)
density = fts.forecast_ahead_distribution(original[time_from - fts.order:time_from], time_to,
resolution=resolution)
#plot_density_scatter(ax, cmap, density, fig, resolution, time_from, time_to)
plot_density_rectange(ax, cm, density, fig, resolution, time_from, time_to)
if fts.has_interval_forecasting and intervals:
forecasts = fts.forecastAheadInterval(original[time_from - fts.order:time_from], time_to)
forecasts = fts.forecast_ahead_interval(original[time_from - fts.order:time_from], time_to)
lower = [kk[0] for kk in forecasts]
upper = [kk[1] for kk in forecasts]
mi.append(min(lower))
@ -811,7 +811,7 @@ def plot_compared_intervals_ahead(original, models, colors, distributions, time_
ax.set_xlabel('T')
ax.set_xlim([0, len(original)])
Util.showAndSaveImage(fig, file, save, lgd=lgd)
Util.show_and_save_image(fig, file, save, lgd=lgd)
def plot_density_rectange(ax, cmap, density, fig, resolution, time_from, time_to):
@ -1043,7 +1043,7 @@ def simpleSearch_RMSE(train, test, model, partitions, orders, save=False, file=N
sets = partitioner(train, p, transformation=transformation).sets
for oc, o in enumerate(orders, start=0):
fts = model("q = " + str(p) + " n = " + str(o))
fts.appendTransformation(transformation)
fts.append_transformation(transformation)
fts.train(train, sets, o, parameters=parameters)
if not intervals:
forecasted = fts.forecast(test)
@ -1055,7 +1055,7 @@ def simpleSearch_RMSE(train, test, model, partitions, orders, save=False, file=N
forecasted.insert(0, None)
if plotforecasts: ax0.plot(forecasted, label=fts.name)
else:
forecasted = fts.forecastInterval(test)
forecasted = fts.forecast_interval(test)
error = 1.0 - Measures.rmse_interval(np.array(test[o:]), np.array(forecasted[:-1]))
errors[oc, pc] = error
if error < min_rmse:
@ -1090,7 +1090,7 @@ def simpleSearch_RMSE(train, test, model, partitions, orders, save=False, file=N
# plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)
return ret
@ -1131,7 +1131,7 @@ def sliding_window_simple_search(data, windowsize, model, partitions, orders, sa
forecasted.insert(0, None)
if plotforecasts: ax0.plot(forecasted, label=fts.name)
else:
forecasted = fts.forecastInterval(test)
forecasted = fts.forecast_interval(test)
_error.append( 1.0 - Measures.rmse_interval(np.array(test[o:]), np.array(forecasted[:-1])) )
error = np.nanmean(_error)
errors[oc, pc] = error
@ -1166,7 +1166,7 @@ def sliding_window_simple_search(data, windowsize, model, partitions, orders, sa
# plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)
return ret
@ -1185,7 +1185,7 @@ def pftsExploreOrderAndPartitions(data,save=False, file=None):
fts.shortname = "n = " + str(order)
fts.train(data, data_fs1, order=order)
point_forecasts = fts.forecast(data)
interval_forecasts = fts.forecastInterval(data)
interval_forecasts = fts.forecast_interval(data)
lower = [kk[0] for kk in interval_forecasts]
upper = [kk[1] for kk in interval_forecasts]
mi.append(min(lower) * 0.95)
@ -1207,7 +1207,7 @@ def pftsExploreOrderAndPartitions(data,save=False, file=None):
fts.shortname = "q = " + str(partitions)
fts.train(data, data_fs, 1)
point_forecasts = fts.forecast(data)
interval_forecasts = fts.forecastInterval(data)
interval_forecasts = fts.forecast_interval(data)
lower = [kk[0] for kk in interval_forecasts]
upper = [kk[1] for kk in interval_forecasts]
mi.append(min(lower) * 0.95)
@ -1230,5 +1230,5 @@ def pftsExploreOrderAndPartitions(data,save=False, file=None):
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)

View File

@ -57,7 +57,7 @@ def run_point(mfts, partitioner, train_data, test_data, window_key=None, transfo
mfts.partitioner = partitioner
if transformation is not None:
mfts.appendTransformation(transformation)
mfts.append_transformation(transformation)
_start = time.time()
mfts.train(train_data, partitioner.sets, order=mfts.order)
@ -243,7 +243,7 @@ def run_interval(mfts, partitioner, train_data, test_data, window_key=None, tran
mfts.partitioner = partitioner
if transformation is not None:
mfts.appendTransformation(transformation)
mfts.append_transformation(transformation)
_start = time.time()
mfts.train(train_data, partitioner.sets, order=mfts.order)
@ -443,7 +443,7 @@ def run_ahead(mfts, partitioner, train_data, test_data, steps, resolution, windo
mfts.partitioner = partitioner
if transformation is not None:
mfts.appendTransformation(transformation)
mfts.append_transformation(transformation)
if mfts.has_seasonality:
mfts.indexer = indexer

View File

@ -31,7 +31,7 @@ def run_point(mfts, partitioner, train_data, test_data, transformation=None, ind
_key = mfts.shortname + " n = " + str(mfts.order) + " " + pttr + " q = " + str(partitioner.partitions)
mfts.partitioner = partitioner
if transformation is not None:
mfts.appendTransformation(transformation)
mfts.append_transformation(transformation)
try:
_start = time.time()
@ -157,7 +157,7 @@ def run_interval(mfts, partitioner, train_data, test_data, transformation=None,
_key = mfts.shortname + " n = " + str(mfts.order) + " " + pttr + " q = " + str(partitioner.partitions)
mfts.partitioner = partitioner
if transformation is not None:
mfts.appendTransformation(transformation)
mfts.append_transformation(transformation)
try:
_start = time.time()
@ -285,7 +285,7 @@ def run_ahead(mfts, partitioner, train_data, test_data, steps, resolution, trans
_key = mfts.shortname + " n = " + str(mfts.order) + " " + pttr + " q = " + str(partitioner.partitions)
mfts.partitioner = partitioner
if transformation is not None:
mfts.appendTransformation(transformation)
mfts.append_transformation(transformation)
try:
_start = time.time()

View File

@ -35,7 +35,7 @@ class QuantileRegression(fts.FTS):
if self.indexer is not None and isinstance(data, pd.DataFrame):
data = self.indexer.get_data(data)
tmp = np.array(self.doTransformations(data, updateUoD=True))
tmp = np.array(self.apply_transformations(data, updateUoD=True))
lagdata, ndata = lagmat(tmp, maxlag=order, trim="both", original='sep')
@ -82,7 +82,7 @@ class QuantileRegression(fts.FTS):
if self.indexer is not None and isinstance(data, pd.DataFrame):
data = self.indexer.get_data(data)
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
ret = []
@ -92,16 +92,16 @@ class QuantileRegression(fts.FTS):
ret.append(self.linearmodel(sample, self.mean_qt))
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret
def forecastInterval(self, data, **kwargs):
def forecast_interval(self, data, **kwargs):
if self.indexer is not None and isinstance(data, pd.DataFrame):
data = self.indexer.get_data(data)
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -111,16 +111,16 @@ class QuantileRegression(fts.FTS):
sample = ndata[k - self.order: k]
ret.append(self.point_to_interval(sample, self.lower_qt, self.upper_qt))
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]], interval=True)
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]], interval=True)
return ret
def forecastAheadInterval(self, data, steps, **kwargs):
def forecast_ahead_interval(self, data, steps, **kwargs):
if self.indexer is not None and isinstance(data, pd.DataFrame):
data = self.indexer.get_data(data)
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
smoothing = kwargs.get("smoothing", 0.9)
@ -128,7 +128,7 @@ class QuantileRegression(fts.FTS):
ret = []
nmeans = self.forecastAhead(ndata, steps, **kwargs)
nmeans = self.forecast_ahead(ndata, steps, **kwargs)
for k in np.arange(0, self.order):
nmeans.insert(k,ndata[-(k+1)])
@ -138,16 +138,16 @@ class QuantileRegression(fts.FTS):
ret.append([intl[0]*(1 + k*smoothing), intl[1]*(1 + k*smoothing)])
ret = self.doInverseTransformations(ret, params=[[data[-1] for a in np.arange(0, steps + self.order)]], interval=True)
ret = self.apply_inverse_transformations(ret, params=[[data[-1] for a in np.arange(0, steps + self.order)]], interval=True)
return ret[-steps:]
def forecastDistribution(self, data, **kwargs):
def forecast_distribution(self, data, **kwargs):
if self.indexer is not None and isinstance(data, pd.DataFrame):
data = self.indexer.get_data(data)
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
ret = []
@ -162,18 +162,18 @@ class QuantileRegression(fts.FTS):
intl = self.point_to_interval(sample, qt[0], qt[1])
intervals.append(intl)
dist.appendInterval(intervals)
dist.append_interval(intervals)
ret.append(dist)
return ret
def forecastAheadDistribution(self, data, steps, **kwargs):
def forecast_ahead_distribution(self, data, steps, **kwargs):
if self.indexer is not None and isinstance(data, pd.DataFrame):
data = self.indexer.get_data(data)
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
ret = []
@ -184,7 +184,7 @@ class QuantileRegression(fts.FTS):
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.appendInterval(intervals)
dist.append_interval(intervals)
ret.append(dist)

View File

@ -49,14 +49,14 @@ class ConventionalFTS(fts.FTS):
def train(self, data, sets,order=1,parameters=None):
self.sets = sets
ndata = self.doTransformations(data)
tmpdata = FuzzySet.fuzzySeries(ndata, sets)
ndata = self.apply_transformations(data)
tmpdata = FuzzySet.fuzzyfy_series_old(ndata, sets)
flrs = FLR.generateNonRecurrentFLRs(tmpdata)
self.flrgs = self.generateFLRG(flrs)
def forecast(self, data, **kwargs):
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -64,7 +64,7 @@ class ConventionalFTS(fts.FTS):
for k in np.arange(0, l):
mv = FuzzySet.fuzzyInstance(ndata[k], self.sets)
mv = FuzzySet.fuzzyfy_instance(ndata[k], self.sets)
actual = self.sets[np.argwhere(mv == max(mv))[0, 0]]
@ -75,6 +75,6 @@ class ConventionalFTS(fts.FTS):
ret.append(_flrg.get_midpoint())
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret

View File

@ -49,7 +49,7 @@ class TrendWeightedFTS(yu.WeightedFTS):
self.detail = "Cheng"
self.is_high_order = False
def generateFLRG(self, flrs):
def generate_FLRG(self, flrs):
flrgs = {}
for flr in flrs:
if flr.LHS.name in flrgs:

View File

@ -111,8 +111,8 @@ def generateIndexedFLRs(sets, indexer, data, transformation=None):
if transformation is not None:
ndata = transformation.apply(ndata)
for k in np.arange(1,len(ndata)):
lhs = FuzzySet.getMaxMembershipFuzzySet(ndata[k-1],sets)
rhs = FuzzySet.getMaxMembershipFuzzySet(ndata[k], sets)
lhs = FuzzySet.get_maximum_membership_fuzzyset(ndata[k - 1], sets)
rhs = FuzzySet.get_maximum_membership_fuzzyset(ndata[k], sets)
season = index[k]
flr = IndexedFLR(season,lhs,rhs)
flrs.append(flr)

View File

@ -55,7 +55,7 @@ class FuzzySet(object):
return self.name + ": " + str(self.mf.__name__) + "(" + str(self.parameters) + ")"
def fuzzyInstance(inst, fuzzySets):
def fuzzyfy_instance(inst, fuzzySets):
"""
Calculate the membership values for a data point given fuzzy sets
:param inst: data point
@ -66,7 +66,7 @@ def fuzzyInstance(inst, fuzzySets):
return mv
def fuzzyInstances(data, fuzzySets):
def fuzzyfy_instances(data, fuzzySets):
"""
Calculate the membership values for a data point given fuzzy sets
:param inst: data point
@ -80,36 +80,36 @@ def fuzzyInstances(data, fuzzySets):
return ret
def getMaxMembershipFuzzySet(inst, fuzzySets):
def get_maximum_membership_fuzzyset(inst, fuzzySets):
"""
Fuzzify a data point, returning the fuzzy set with maximum membership value
:param inst: data point
:param fuzzySets: list of fuzzy sets
:return: fuzzy set with maximum membership
"""
mv = fuzzyInstance(inst, fuzzySets)
mv = fuzzyfy_instance(inst, fuzzySets)
return fuzzySets[np.argwhere(mv == max(mv))[0, 0]]
def getMaxMembershipFuzzySetIndex(inst, fuzzySets):
def get_maximum_membership_fuzzyset_index(inst, fuzzySets):
"""
Fuzzify a data point, returning the fuzzy set with maximum membership value
:param inst: data point
:param fuzzySets: list of fuzzy sets
:return: fuzzy set with maximum membership
"""
mv = fuzzyInstance(inst, fuzzySets)
mv = fuzzyfy_instance(inst, fuzzySets)
return np.argwhere(mv == max(mv))[0, 0]
def fuzzySeries(data, fuzzySets, method='maximum'):
def fuzzyfy_series_old(data, fuzzySets, method='maximum'):
fts = []
for item in data:
fts.append(getMaxMembershipFuzzySet(item, fuzzySets))
fts.append(get_maximum_membership_fuzzyset(item, fuzzySets))
return fts
def fuzzifySeries(data, fuzzySets, method='maximum'):
def fuzzify_series(data, fuzzySets, method='maximum'):
fts = []
for t, i in enumerate(data):
mv = np.array([fs.membership(i) for fs in fuzzySets])

View File

@ -15,7 +15,7 @@ def uniquefilename(name):
return name + str(current_milli_time())
def showAndSaveImage(fig,file,flag,lgd=None):
def show_and_save_image(fig, file, flag, lgd=None):
"""
Show and image and save on file
:param fig: Matplotlib Figure object

View File

@ -117,7 +117,7 @@ class EnsembleFTS(fts.FTS):
return ret
def forecastInterval(self, data, **kwargs):
def forecast_interval(self, data, **kwargs):
if "method" in kwargs:
self.interval_method = kwargs.get('method','quantile')
@ -139,7 +139,7 @@ class EnsembleFTS(fts.FTS):
return ret
def forecastAheadInterval(self, data, steps, **kwargs):
def forecast_ahead_interval(self, data, steps, **kwargs):
if 'method' in kwargs:
self.interval_method = kwargs.get('method','quantile')
@ -180,7 +180,7 @@ class EnsembleFTS(fts.FTS):
def empty_grid(self, resolution):
return self.get_empty_grid(-(self.original_max*2), self.original_max*2, resolution)
def forecastAheadDistribution(self, data, steps, **kwargs):
def forecast_ahead_distribution(self, data, steps, **kwargs):
if 'method' in kwargs:
self.point_method = kwargs.get('method','mean')
@ -232,7 +232,7 @@ class AllMethodEnsembleFTS(EnsembleFTS):
def set_transformations(self, model):
for t in self.transformations:
model.appendTransformation(t)
model.append_transformation(t)
def train(self, data, sets, order=1, parameters=None):
self.original_max = max(data)

View File

@ -26,7 +26,7 @@ def train_individual_model(partitioner, train_data, indexer):
print(_key)
model = cmsfts.ContextualMultiSeasonalFTS(_key, indexer=indexer)
model.appendTransformation(partitioner.transformation)
model.append_transformation(partitioner.transformation)
model.train(train_data, partitioner.sets, order=1)
cUtil.persist_obj(model, "models/"+_key+".pkl")
@ -70,7 +70,7 @@ class SeasonalEnsembleFTS(ensemble.EnsembleFTS):
cUtil.persist_obj(self, "models/"+self.name+".pkl")
def forecastDistribution(self, data, **kwargs):
def forecast_distribution(self, data, **kwargs):
ret = []

View File

@ -54,6 +54,32 @@ class FTS(object):
return best
def predict(self, data, **kwargs):
"""
Forecast using trained model
:param data: time series with minimal length to the order of the model
:param kwargs:
:return:
"""
type = kwargs.get("type", 'point')
steps_ahead = kwargs.get("steps_ahead", None)
if type == 'point' and steps_ahead == None:
return self.forecast(data, **kwargs)
elif type == 'point' and steps_ahead != None:
return self.forecast_ahead(data, steps_ahead, **kwargs)
elif type == 'interval' and steps_ahead == None:
return self.forecast_interval(data, **kwargs)
elif type == 'interval' and steps_ahead != None:
return self.forecast_ahead_interval(data, steps_ahead, **kwargs)
elif type == 'distribution' and steps_ahead == None:
return self.forecast_distribution(data, **kwargs)
elif type == 'distribution' and steps_ahead != None:
return self.forecast_ahead_distribution(data, steps_ahead, **kwargs)
else:
raise ValueError('The argument \'type\' has an unknown value.')
def forecast(self, data, **kwargs):
"""
Point forecast one step ahead
@ -61,27 +87,27 @@ class FTS(object):
:param kwargs:
:return:
"""
pass
raise NotImplementedError('This model do not perform one step ahead point forecasts!')
def forecastInterval(self, data, **kwargs):
def forecast_interval(self, data, **kwargs):
"""
Interval forecast one step ahead
:param data:
:param kwargs:
:return:
"""
pass
raise NotImplementedError('This model do not perform one step ahead interval forecasts!')
def forecastDistribution(self, data, **kwargs):
def forecast_distribution(self, data, **kwargs):
"""
Probabilistic forecast one step ahead
:param data:
:param kwargs:
:return:
"""
pass
raise NotImplementedError('This model do not perform one step ahead distribution forecasts!')
def forecastAhead(self, data, steps, **kwargs):
def forecast_ahead(self, data, steps, **kwargs):
"""
Point forecast n steps ahead
:param data:
@ -101,7 +127,7 @@ class FTS(object):
return ret
def forecastAheadInterval(self, data, steps, **kwargs):
def forecast_ahead_interval(self, data, steps, **kwargs):
"""
Interval forecast n steps ahead
:param data:
@ -109,9 +135,9 @@ class FTS(object):
:param kwargs:
:return:
"""
pass
raise NotImplementedError('This model do not perform multi step ahead interval forecasts!')
def forecastAheadDistribution(self, data, steps, **kwargs):
def forecast_ahead_distribution(self, data, steps, **kwargs):
"""
Probabilistic forecast n steps ahead
:param data:
@ -119,7 +145,7 @@ class FTS(object):
:param kwargs:
:return:
"""
pass
raise NotImplementedError('This model do not perform multi step ahead distribution forecasts!')
def train(self, data, sets, order=1, parameters=None):
"""
@ -132,11 +158,20 @@ class FTS(object):
"""
pass
def appendTransformation(self, transformation):
def fit(self, data, **kwargs):
"""
:param data:
:param kwargs:
:return:
"""
self.train(data, sets=None)
def append_transformation(self, transformation):
if transformation is not None:
self.transformations.append(transformation)
def doTransformations(self,data,params=None,updateUoD=False, **kwargs):
def apply_transformations(self, data, params=None, updateUoD=False, **kwargs):
ndata = data
if updateUoD:
if min(data) < 0:
@ -158,7 +193,7 @@ class FTS(object):
return ndata
def doInverseTransformations(self, data, params=None, **kwargs):
def apply_inverse_transformations(self, data, params=None, **kwargs):
if len(self.transformations) > 0:
if params is None:
params = [None for k in self.transformations]

View File

@ -133,7 +133,7 @@ class HighOrderFTS(fts.FTS):
def train(self, data, sets, order=1,parameters=None):
data = self.doTransformations(data, updateUoD=True)
data = self.apply_transformations(data, updateUoD=True)
self.order = order
self.sets = sets
@ -149,10 +149,10 @@ class HighOrderFTS(fts.FTS):
if l <= self.order:
return data
ndata = self.doTransformations(data)
ndata = self.apply_transformations(data)
for k in np.arange(self.order, l+1):
tmpdata = FuzzySet.fuzzySeries(ndata[k - self.order: k], self.sets)
tmpdata = FuzzySet.fuzzyfy_series_old(ndata[k - self.order: k], self.sets)
tmpflrg = HighOrderFLRG(self.order)
for s in tmpdata: tmpflrg.appendLHS(s)
@ -163,6 +163,6 @@ class HighOrderFTS(fts.FTS):
flrg = self.flrgs[tmpflrg.strLHS()]
ret.append(flrg.get_midpoint())
ret = self.doInverseTransformations(ret, params=[data[self.order-1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret

View File

@ -21,7 +21,7 @@ class HighOrderFTS(fts.FTS):
def forecast(self, data, **kwargs):
ndata = self.doTransformations(data)
ndata = self.apply_transformations(data)
cn = np.array([0.0 for k in range(len(self.sets))])
ow = np.array([[0.0 for k in range(len(self.sets))] for z in range(self.order - 1)])
@ -47,7 +47,7 @@ class HighOrderFTS(fts.FTS):
count += 1.0
ret.append(out / count)
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret

View File

@ -43,9 +43,9 @@ class IntervalFTS(hofts.HighOrderFTS):
mb = [fuzzySets[k].membership(data[k]) for k in np.arange(0, len(data))]
return mb
def forecastInterval(self, data, **kwargs):
def forecast_interval(self, data, **kwargs):
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -66,7 +66,7 @@ class IntervalFTS(hofts.HighOrderFTS):
subset = ndata[k - (self.order - 1): k + 1]
for instance in subset:
mb = FuzzySet.fuzzyInstance(instance, self.sets)
mb = FuzzySet.fuzzyfy_instance(instance, self.sets)
tmp = np.argwhere(mb)
idx = np.ravel(tmp) # flat the array
@ -101,7 +101,7 @@ class IntervalFTS(hofts.HighOrderFTS):
affected_flrgs_memberships.append(min(self.getSequenceMembership(subset, flrg.LHS)))
else:
mv = FuzzySet.fuzzyInstance(ndata[k], self.sets)
mv = FuzzySet.fuzzyfy_instance(ndata[k], self.sets)
tmp = np.argwhere(mv)
idx = np.ravel(tmp)
@ -132,6 +132,6 @@ class IntervalFTS(hofts.HighOrderFTS):
up_ = sum(up) / norm
ret.append([lo_, up_])
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]], interval=True)
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]], interval=True)
return ret

View File

@ -66,9 +66,9 @@ class ImprovedWeightedFTS(fts.FTS):
for s in self.sets: self.setsDict[s.name] = s
ndata = self.doTransformations(data)
ndata = self.apply_transformations(data)
tmpdata = FuzzySet.fuzzySeries(ndata, self.sets)
tmpdata = FuzzySet.fuzzyfy_series_old(ndata, self.sets)
flrs = FLR.generateRecurrentFLRs(tmpdata)
self.flrgs = self.generateFLRG(flrs)
@ -76,7 +76,7 @@ class ImprovedWeightedFTS(fts.FTS):
l = 1
data = np.array(data)
ndata = self.doTransformations(data)
ndata = self.apply_transformations(data)
l = len(ndata)
@ -84,7 +84,7 @@ class ImprovedWeightedFTS(fts.FTS):
for k in np.arange(0, l):
mv = FuzzySet.fuzzyInstance(ndata[k], self.sets)
mv = FuzzySet.fuzzyfy_instance(ndata[k], self.sets)
actual = self.sets[np.argwhere(mv == max(mv))[0, 0]]
@ -96,6 +96,6 @@ class ImprovedWeightedFTS(fts.FTS):
ret.append(mp.dot(flrg.weights()))
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret

View File

@ -10,14 +10,14 @@ class ConditionalVarianceFTS(chen.ConventionalFTS):
self.name = "Conditional Variance FTS"
self.detail = ""
self.flrgs = {}
#self.appendTransformation(Transformations.Differential(1))
#self.append_transformation(Transformations.Differential(1))
if self.partitioner is None:
self.min_tx = None
self.max_tx = None
else:
self.min_tx = self.partitioner.min
self.max_tx = self.partitioner.max
self.appendTransformation(self.partitioner.transformation)
self.append_transformation(self.partitioner.transformation)
self.min_stack = [0,0,0]
self.max_stack = [0,0,0]
@ -28,7 +28,7 @@ class ConditionalVarianceFTS(chen.ConventionalFTS):
else:
self.sets = self.partitioner.sets
ndata = self.doTransformations(data)
ndata = self.apply_transformations(data)
self.min_tx = min(ndata)
self.max_tx = max(ndata)
@ -89,7 +89,7 @@ class ConditionalVarianceFTS(chen.ConventionalFTS):
return affected_sets
def forecast(self, data, **kwargs):
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -127,13 +127,13 @@ class ConditionalVarianceFTS(chen.ConventionalFTS):
ret.append(pto)
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret
def forecastInterval(self, data, **kwargs):
ndata = np.array(self.doTransformations(data))
def forecast_interval(self, data, **kwargs):
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -175,6 +175,6 @@ class ConditionalVarianceFTS(chen.ConventionalFTS):
ret.append(itvl)
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret

View File

@ -104,8 +104,8 @@ class HighOrderNonStationaryFTS(hofts.HighOrderFTS):
else:
self.sets = self.partitioner.sets
ndata = self.doTransformations(data)
#tmpdata = common.fuzzySeries(ndata, self.sets)
ndata = self.apply_transformations(data)
#tmpdata = common.fuzzyfy_series_old(ndata, self.sets)
#flrs = FLR.generateRecurrentFLRs(ndata)
window_size = parameters if parameters is not None else 1
self.flrgs = self.generate_flrg(ndata, window_size=window_size)
@ -175,7 +175,7 @@ class HighOrderNonStationaryFTS(hofts.HighOrderFTS):
window_size = kwargs.get("window_size", 1)
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -215,17 +215,17 @@ class HighOrderNonStationaryFTS(hofts.HighOrderFTS):
ret.append(pto)
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret
def forecastInterval(self, data, **kwargs):
def forecast_interval(self, data, **kwargs):
time_displacement = kwargs.get("time_displacement", 0)
window_size = kwargs.get("window_size", 1)
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -273,6 +273,6 @@ class HighOrderNonStationaryFTS(hofts.HighOrderFTS):
ret.append([sum(lower), sum(upper)])
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret

View File

@ -51,7 +51,7 @@ class NonStationaryFTS(fts.FTS):
else:
self.sets = self.partitioner.sets
ndata = self.doTransformations(data)
ndata = self.apply_transformations(data)
window_size = parameters if parameters is not None else 1
tmpdata = common.fuzzySeries(ndata, self.sets, window_size, method=self.method)
#print([k[0].name for k in tmpdata])
@ -65,7 +65,7 @@ class NonStationaryFTS(fts.FTS):
window_size = kwargs.get("window_size", 1)
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -120,17 +120,17 @@ class NonStationaryFTS(fts.FTS):
ret.append(pto)
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret
def forecastInterval(self, data, **kwargs):
def forecast_interval(self, data, **kwargs):
time_displacement = kwargs.get("time_displacement", 0)
window_size = kwargs.get("window_size", 1)
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -181,6 +181,6 @@ class NonStationaryFTS(fts.FTS):
ret.append([sum(lower), sum(upper)])
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret

View File

@ -50,7 +50,7 @@ def plot_sets(sets, start=0, end=10, step=1, tam=[5, 5], colors=None,
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)
def plot_sets_conditional(model, data, start=0, end=10, step=1, tam=[5, 5], colors=None,
@ -88,4 +88,4 @@ def plot_sets_conditional(model, data, start=0, end=10, step=1, tam=[5, 5], colo
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)

View File

@ -38,7 +38,7 @@ def plot_sets(data, sets, titles, tam=[12, 10], save=False, file=None):
plt.tight_layout()
Util.showAndSaveImage(fig, file, save)
Util.show_and_save_image(fig, file, save)
def plot_partitioners(data, objs, tam=[12, 10], save=False, file=None):

View File

@ -65,7 +65,7 @@ class ProbabilityDistribution(object):
for v,d in enumerate(dens):
self.distribution[self.bins[v]] = d
def appendInterval(self, intervals):
def append_interval(self, intervals):
if self.type == "histogram":
for interval in intervals:
for k in self.bin_index.inside(interval[0], interval[1]):

View File

@ -113,7 +113,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
def train(self, data, sets, order=1,parameters='Fuzzy'):
data = self.doTransformations(data, updateUoD=True)
data = self.apply_transformations(data, updateUoD=True)
self.order = order
if sets is None and self.partitioner is not None:
@ -124,7 +124,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
self.sets = sets
for s in self.sets: self.setsDict[s.name] = s
if parameters == 'Monotonic':
tmpdata = FuzzySet.fuzzySeries(data, sets)
tmpdata = FuzzySet.fuzzyfy_series_old(data, sets)
flrs = FLR.generateRecurrentFLRs(tmpdata)
self.flrgs = self.generateFLRG(flrs)
else:
@ -138,10 +138,10 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
sample = data[k - self.order: k]
mvs = FuzzySet.fuzzyInstances(sample, self.sets)
mvs = FuzzySet.fuzzyfy_instances(sample, self.sets)
lags = {}
mv = FuzzySet.fuzzyInstance(data[k], self.sets)
mv = FuzzySet.fuzzyfy_instance(data[k], self.sets)
tmp = np.argwhere(mv)
idx = np.ravel(tmp) # flatten the array
@ -201,7 +201,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
def update_model(self,data):
fzzy = FuzzySet.fuzzySeries(data, self.sets)
fzzy = FuzzySet.fuzzyfy_series_old(data, self.sets)
flrg = ProbabilisticWeightedFLRG(self.order)
@ -277,7 +277,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
def forecast(self, data, **kwargs):
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -299,7 +299,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
subset = ndata[k - (self.order - 1): k + 1]
for count, instance in enumerate(subset):
mb = FuzzySet.fuzzyInstance(instance, self.sets)
mb = FuzzySet.fuzzyfy_instance(instance, self.sets)
tmp = np.argwhere(mb)
idx = np.ravel(tmp) # flatten the array
@ -332,11 +332,11 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
affected_flrgs.append(flrg)
# Find the general membership of FLRG
affected_flrgs_memberships.append(flrg.get_membership())
affected_flrgs_memberships.append(flrg.get_membership(subset))
else:
mv = FuzzySet.fuzzyInstance(ndata[k], self.sets) # get all membership values
mv = FuzzySet.fuzzyfy_instance(ndata[k], self.sets) # get all membership values
tmp = np.argwhere(mv) # get the indices of values > 0
idx = np.ravel(tmp) # flatten the array
@ -371,11 +371,11 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
if self.auto_update and k > self.order+1: self.update_model(ndata[k - self.order - 1 : k])
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret
def forecastInterval(self, data, **kwargs):
def forecast_interval(self, data, **kwargs):
if 'method' in kwargs:
self.interval_method = kwargs.get('method','quantile')
@ -383,7 +383,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
if 'alpha' in kwargs:
self.alpha = kwargs.get('alpha', 0.05)
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -396,12 +396,12 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
else:
self.interval_quantile(k, ndata, ret)
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]], interval=True)
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]], interval=True)
return ret
def interval_quantile(self, k, ndata, ret):
dist = self.forecastDistribution(ndata)
dist = self.forecast_distribution(ndata)
lo_qt = dist[0].quantile(self.alpha)
up_qt = dist[0].quantile(1.0 - self.alpha)
ret.append([lo_qt, up_qt])
@ -419,7 +419,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
subset = ndata[k - (self.order - 1): k + 1]
for instance in subset:
mb = FuzzySet.fuzzyInstance(instance, self.sets)
mb = FuzzySet.fuzzyfy_instance(instance, self.sets)
tmp = np.argwhere(mb)
idx = np.ravel(tmp) # flatten the array
@ -458,7 +458,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
else:
mv = FuzzySet.fuzzyInstance(ndata[k], self.sets) # get all membership values
mv = FuzzySet.fuzzyfy_instance(ndata[k], self.sets) # get all membership values
tmp = np.argwhere(mv) # get the indices of values > 0
idx = np.ravel(tmp) # flatten the array
@ -494,7 +494,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
up_ = sum(up) / norm
ret.append([lo_, up_])
def forecastDistribution(self, data, **kwargs):
def forecast_distribution(self, data, **kwargs):
if not isinstance(data, (list, set, np.ndarray)):
data = [data]
@ -502,7 +502,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
smooth = kwargs.get("smooth", "none")
nbins = kwargs.get("num_bins", 100)
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -532,7 +532,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
return ret
def forecastAhead(self, data, steps, **kwargs):
def forecast_ahead(self, data, steps, **kwargs):
ret = [data[k] for k in np.arange(len(data) - self.order, len(data))]
for k in np.arange(self.order - 1, steps):
@ -546,7 +546,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
return ret
def forecastAheadInterval(self, data, steps, **kwargs):
def forecast_ahead_interval(self, data, steps, **kwargs):
l = len(data)
@ -559,14 +559,14 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
1] >= self.original_max):
ret.append(ret[-1])
else:
lower = self.forecastInterval([ret[x][0] for x in np.arange(k - self.order, k)])
upper = self.forecastInterval([ret[x][1] for x in np.arange(k - self.order, k)])
lower = self.forecast_interval([ret[x][0] for x in np.arange(k - self.order, k)])
upper = self.forecast_interval([ret[x][1] for x in np.arange(k - self.order, k)])
ret.append([np.min(lower), np.max(upper)])
return ret
def forecastAheadDistribution(self, data, steps, **kwargs):
def forecast_ahead_distribution(self, data, steps, **kwargs):
ret = []
@ -578,7 +578,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
_bins = np.linspace(uod[0], uod[1], nbins).tolist()
if method != 4:
intervals = self.forecastAheadInterval(data, steps)
intervals = self.forecast_ahead_interval(data, steps)
else:
l = len(data)
for k in np.arange(l - self.order, l):
@ -623,7 +623,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
for p in root.paths():
path = list(reversed(list(filter(None.__ne__, p))))
qtle = np.ravel(self.forecastInterval(path))
qtle = np.ravel(self.forecast_interval(path))
data.extend(np.linspace(qtle[0],qtle[1],100).tolist())
@ -631,17 +631,17 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
for qt in np.arange(0, 50, 1):
# print(qt)
qtle_lower = self.forecastInterval(
qtle_lower = self.forecast_interval(
[intervals[x][0] + qt * ((intervals[x][1] - intervals[x][0]) / 100) for x in
np.arange(k - self.order, k)])
qtle_lower = np.ravel(qtle_lower)
data.extend(np.linspace(qtle_lower[0], qtle_lower[1], 100).tolist())
qtle_upper = self.forecastInterval(
qtle_upper = self.forecast_interval(
[intervals[x][1] - qt * ((intervals[x][1] - intervals[x][0]) / 100) for x in
np.arange(k - self.order, k)])
qtle_upper = np.ravel(qtle_upper)
data.extend(np.linspace(qtle_upper[0], qtle_upper[1], 100).tolist())
qtle_mid = self.forecastInterval(
qtle_mid = self.forecast_interval(
[intervals[x][0] + (intervals[x][1] - intervals[x][0]) / 2 for x in np.arange(k - self.order, k)])
qtle_mid = np.ravel(qtle_mid)
data.extend(np.linspace(qtle_mid[0], qtle_mid[1], 100).tolist())
@ -674,7 +674,7 @@ class ProbabilisticWeightedFTS(ifts.IntervalFTS):
pk = np.prod([ret[k - self.order + o].density(path[o])
for o in np.arange(0,self.order)])
d = self.forecastDistribution(path)[0]
d = self.forecast_distribution(path)[0]
for bin in _bins:
dist.set(bin, dist.density(bin) + pk * d.density(bin))

View File

@ -66,8 +66,8 @@ class ExponentialyWeightedFTS(fts.FTS):
def train(self, data, sets,order=1,parameters=1.05):
self.c = parameters
self.sets = sets
ndata = self.doTransformations(data)
tmpdata = FuzzySet.fuzzySeries(ndata, sets)
ndata = self.apply_transformations(data)
tmpdata = FuzzySet.fuzzyfy_series_old(ndata, sets)
flrs = FLR.generateRecurrentFLRs(tmpdata)
self.flrgs = self.generateFLRG(flrs, self.c)
@ -76,7 +76,7 @@ class ExponentialyWeightedFTS(fts.FTS):
data = np.array(data)
ndata = self.doTransformations(data)
ndata = self.apply_transformations(data)
l = len(ndata)
@ -84,7 +84,7 @@ class ExponentialyWeightedFTS(fts.FTS):
for k in np.arange(0, l):
mv = FuzzySet.fuzzyInstance(ndata[k], self.sets)
mv = FuzzySet.fuzzyfy_instance(ndata[k], self.sets)
actual = self.sets[np.argwhere(mv == max(mv))[0, 0]]
@ -96,6 +96,6 @@ class ExponentialyWeightedFTS(fts.FTS):
ret.append(mp.dot(flrg.weights()))
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret

View File

@ -79,7 +79,7 @@ class ContextualMultiSeasonalFTS(sfts.SeasonalFTS):
flrg = self.flrgs[str(index[k])]
d = FuzzySet.getMaxMembershipFuzzySet(ndata[k], self.sets)
d = FuzzySet.get_maximum_membership_fuzzyset(ndata[k], self.sets)
mp = self.getMidpoints(flrg, d)

View File

@ -54,11 +54,11 @@ class MultiSeasonalFTS(sfts.SeasonalFTS):
ret.append(sum(mp) / len(mp))
ret = self.doInverseTransformations(ret, params=[ndata])
ret = self.apply_inverse_transformations(ret, params=[ndata])
return ret
def forecastAhead(self, data, steps, **kwargs):
def forecast_ahead(self, data, steps, **kwargs):
ret = []
for i in steps:
flrg = self.flrgs[str(i)]
@ -67,6 +67,6 @@ class MultiSeasonalFTS(sfts.SeasonalFTS):
ret.append(sum(mp) / len(mp))
ret = self.doInverseTransformations(ret, params=data)
ret = self.apply_inverse_transformations(ret, params=data)
return ret

View File

@ -63,14 +63,14 @@ class SeasonalFTS(fts.FTS):
def train(self, data, sets, order=1, parameters=None):
self.sets = sets
ndata = self.doTransformations(data)
tmpdata = FuzzySet.fuzzySeries(ndata, sets)
ndata = self.apply_transformations(data)
tmpdata = FuzzySet.fuzzyfy_series_old(ndata, sets)
flrs = FLR.generateRecurrentFLRs(tmpdata)
self.flrgs = self.generateFLRG(flrs)
def forecast(self, data, **kwargs):
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
@ -86,6 +86,6 @@ class SeasonalFTS(fts.FTS):
ret.append(np.percentile(mp, 50))
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret

View File

@ -40,14 +40,14 @@ class ConventionalFTS(fts.FTS):
def train(self, data, sets,order=1,parameters=None):
self.sets = sets
ndata = self.doTransformations(data)
tmpdata = FuzzySet.fuzzySeries(ndata, sets)
ndata = self.apply_transformations(data)
tmpdata = FuzzySet.fuzzyfy_series_old(ndata, sets)
flrs = FLR.generateNonRecurrentFLRs(tmpdata)
self.R = self.operation_matrix(flrs)
def forecast(self, data, **kwargs):
ndata = np.array(self.doTransformations(data))
ndata = np.array(self.apply_transformations(data))
l = len(ndata)
npart = len(self.sets)
@ -55,7 +55,7 @@ class ConventionalFTS(fts.FTS):
ret = []
for k in np.arange(0, l):
mv = FuzzySet.fuzzyInstance(ndata[k], self.sets)
mv = FuzzySet.fuzzyfy_instance(ndata[k], self.sets)
r = [max([ min(self.R[i][j], mv[j]) for j in np.arange(0,npart) ]) for i in np.arange(0,npart)]
@ -68,6 +68,6 @@ class ConventionalFTS(fts.FTS):
ret.append( sum(mp)/len(mp))
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret

129
pyFTS/tests/distributed.py Normal file
View File

@ -0,0 +1,129 @@
from pyFTS.partitioners import Grid
from pyFTS import fts, flrg, song, chen, yu, sadaei, ismailefendi, cheng, hofts
from pyFTS.benchmarks import Measures
from pyFTS.common import Util as cUtil
import pandas as pd
import numpy as np
import os
from pyFTS.common import Transformations
from copy import deepcopy
from pyFTS.nonstationary import common, flrg, util, perturbation, nsfts, honsfts, partitioners
bc = Transformations.BoxCox(0)
import dispy
import dispy.httpd
os.chdir("/home/petronio/Dropbox/Doutorado/Codigos/")
def evaluate_individual_model(model, partitioner, train, test, window_size, time_displacement):
import numpy as np
from pyFTS.common import FLR, FuzzySet
from pyFTS.partitioners import Grid
from pyFTS.benchmarks import Measures
from pyFTS.nonstationary import common, flrg, util, perturbation, nsfts, honsfts, partitioners
try:
model.train(train, sets=partitioner.sets, order=model.order, parameters=window_size)
forecasts = model.forecast(test, time_displacement=time_displacement, window_size=window_size)
_rmse = Measures.rmse(test[model.order:], forecasts[:-1])
_mape = Measures.mape(test[model.order:], forecasts[:-1])
_u = Measures.UStatistic(test[model.order:], forecasts[:-1])
except Exception as e:
print(e)
_rmse = np.nan
_mape = np.nan
_u = np.nan
return {'model': model.shortname, 'partitions': partitioner.partitions, 'order': model.order,
'rmse': _rmse, 'mape': _mape, 'u': _u}
data = pd.read_csv("DataSets/synthetic_nonstationary_dataset_A.csv", sep=";")
data = np.array(data["0"][:])
cluster = dispy.JobCluster(evaluate_individual_model, nodes=['192.168.0.108', '192.168.0.110'])
http_server = dispy.httpd.DispyHTTPServer(cluster)
jobs = []
models = []
for order in [1, 2, 3]:
if order == 1:
model = nsfts.NonStationaryFTS("")
else:
model = honsfts.HighOrderNonStationaryFTS("")
model.order = order
models.append(model)
for ct, train, test in cUtil.sliding_window(data, 300):
for partition in np.arange(5, 100, 1):
tmp_partitioner = Grid.GridPartitioner(train, partition)
partitioner = partitioners.PolynomialNonStationaryPartitioner(train, tmp_partitioner,
window_size=35, degree=1)
for model in models:
# print(model.shortname, partition, model.order)
#job = evaluate_individual_model(model, train, test)
job = cluster.submit(deepcopy(model), deepcopy(partitioner), train, test, 35, 240)
job.id = ct + model.order*100
jobs.append(job)
results = {}
for job in jobs:
tmp = job()
# print(tmp)
if job.status == dispy.DispyJob.Finished and tmp is not None:
_m = tmp['model']
_o = tmp['order']
_p = tmp['partitions']
if _m not in results:
results[_m] = {}
if _o not in results[_m]:
results[_m][_o] = {}
if _p not in results[_m][_o]:
results[_m][_o][_p] = {}
results[_m][_o][_p]['rmse'] = []
results[_m][_o][_p]['mape'] = []
results[_m][_o][_p]['u'] = []
results[_m][_o][_p]['rmse'].append(tmp['rmse'])
results[_m][_o][_p]['mape'].append(tmp['mape'])
results[_m][_o][_p]['u'].append(tmp['u'])
cluster.wait() # wait for all jobs to finish
cluster.print_status()
http_server.shutdown() # this waits until browser gets all updates
cluster.close()
dados = []
ncolunas = None
for m in sorted(results.keys()):
for o in sorted(results[m].keys()):
for p in sorted(results[m][o].keys()):
for r in ['rmse', 'mape', 'u']:
tmp = []
tmp.append(m)
tmp.append(o)
tmp.append(p)
tmp.append(r)
tmp.extend(results[m][o][p][r])
dados.append(tmp)
if ncolunas is None:
ncolunas = len(results[m][o][p][r])
colunas = ["model", "order", "partitions", "metric"]
for k in np.arange(0, ncolunas):
colunas.append(str(k))
dat = pd.DataFrame(dados, columns=colunas)
dat.to_csv("experiments/nsfts_partitioning_A.csv", sep=";")

View File

@ -34,7 +34,7 @@ ho_methods = [hofts.HighOrderFTS, hwang.HighOrderFTS]
fs = Grid.GridPartitioner(passengers, 10, transformation=diff)
e.appendTransformation(diff)
e.append_transformation(diff)
e.train(passengers, fs.sets, order=3)
@ -42,7 +42,7 @@ e.train(passengers, fs.sets, order=3)
for method in fo_methods:
model = method("")
model.appendTransformation(diff)
model.append_transformation(diff)
model.train(passengers, fs.sets)
e.appendModel(model)
@ -50,25 +50,25 @@ for method in fo_methods:
for method in ho_methods:
for order in [1,2,3]:
model = method("")
model.appendTransformation(diff)
model.append_transformation(diff)
model.train(passengers, fs.sets, order=order)
e.appendModel(model)
arima100 = arima.ARIMA("", alpha=0.25)
#tmp.appendTransformation(diff)
#tmp.append_transformation(diff)
arima100.train(passengers, None, order=(1,0,0))
arima101 = arima.ARIMA("", alpha=0.25)
#tmp.appendTransformation(diff)
#tmp.append_transformation(diff)
arima101.train(passengers, None, order=(1,0,1))
arima200 = arima.ARIMA("", alpha=0.25)
#tmp.appendTransformation(diff)
#tmp.append_transformation(diff)
arima200.train(passengers, None, order=(2,0,0))
arima201 = arima.ARIMA("", alpha=0.25)
#tmp.appendTransformation(diff)
#tmp.append_transformation(diff)
arima201.train(passengers, None, order=(2,0,1))
@ -87,34 +87,34 @@ _median = e.forecast(passengers, method="median")
print(_median)
"""
"""
_extremum = e.forecastInterval(passengers, method="extremum")
_extremum = e.forecast_interval(passengers, method="extremum")
print(_extremum)
_quantile = e.forecastInterval(passengers, method="quantile", alpha=0.25)
_quantile = e.forecast_interval(passengers, method="quantile", alpha=0.25)
print(_quantile)
_normal = e.forecastInterval(passengers, method="normal", alpha=0.25)
_normal = e.forecast_interval(passengers, method="normal", alpha=0.25)
print(_normal)
"""
#"""
_extremum = e.forecastAheadInterval(passengers, 10, method="extremum")
_extremum = e.forecast_ahead_interval(passengers, 10, method="extremum")
print(_extremum)
_quantile = e.forecastAheadInterval(passengers[:50], 10, method="quantile", alpha=0.05)
_quantile = e.forecast_ahead_interval(passengers[:50], 10, method="quantile", alpha=0.05)
print(_quantile)
_quantile = e.forecastAheadInterval(passengers[:50], 10, method="quantile", alpha=0.25)
_quantile = e.forecast_ahead_interval(passengers[:50], 10, method="quantile", alpha=0.25)
print(_quantile)
_normal = e.forecastAheadInterval(passengers[:50], 10, method="normal", alpha=0.05)
_normal = e.forecast_ahead_interval(passengers[:50], 10, method="normal", alpha=0.05)
print(_normal)
_normal = e.forecastAheadInterval(passengers[:50], 10, method="normal", alpha=0.25)
_normal = e.forecast_ahead_interval(passengers[:50], 10, method="normal", alpha=0.25)
print(_normal)
#"""
#dist = e.forecastAheadDistribution(passengers, 20)
#dist = e.forecast_ahead_distribution(passengers, 20)
#print(dist)

View File

@ -94,7 +94,7 @@ methods = [song.ConventionalFTS, chen.ConventionalFTS, yu.WeightedFTS, sadaei.Ex
for method in methods:
model = method("")
model.appendTransformation(bc)
model.append_transformation(bc)
model.train(train, sets=fs.sets)
forecasts = model.forecast(test)
@ -113,7 +113,7 @@ for method in methods:
#obj = msfts.MultiSeasonalFTS("sonda_msfts_Entropy40_Mhm15", indexer=ix)
#obj.appendTransformation(diff)
#obj.append_transformation(diff)
#obj.train(sonda_treino, fs.sets)
@ -121,7 +121,7 @@ for method in methods:
#ftse = cUtil.load_obj("models/sonda_ensemble_msfts.pkl")
#tmp = ftse.forecastDistribution(sonda_teste[850:860], h=0.5, method="gaussian")
#tmp = ftse.forecast_distribution(sonda_teste[850:860], h=0.5, method="gaussian")
#print(tmp[0])
@ -168,7 +168,7 @@ fts.train(sonda_treino, sets=None)
#ftse.update_uod(sonda_treino)
#tmp = ftse.forecastDistribution(sonda_teste,h=1)
#tmp = ftse.forecast_distribution(sonda_teste,h=1)
#tmp = ftse.forecast(sonda_teste,h=1)
@ -187,27 +187,27 @@ from pyFTS.benchmarks import arima, quantreg, Measures
#Util.plot_dataframe_point("experiments/taiex_point_sintetic.csv","experiments/taiex_point_analitic.csv",11)
"""
arima100 = arima.ARIMA("", alpha=0.25)
#tmp.appendTransformation(diff)
#tmp.append_transformation(diff)
arima100.train(passengers, None, order=(1,0,0))
arima101 = arima.ARIMA("", alpha=0.25)
#tmp.appendTransformation(diff)
#tmp.append_transformation(diff)
arima101.train(passengers, None, order=(1,0,1))
arima200 = arima.ARIMA("", alpha=0.25)
#tmp.appendTransformation(diff)
#tmp.append_transformation(diff)
arima200.train(passengers, None, order=(2,0,0))
arima201 = arima.ARIMA("", alpha=0.25)
#tmp.appendTransformation(diff)
#tmp.append_transformation(diff)
arima201.train(passengers, None, order=(2,0,1))
#tmp = quantreg.QuantileRegression("", alpha=0.25, dist=True)
#tmp.appendTransformation(diff)
#tmp.append_transformation(diff)
#tmp.train(sunspots[:150], None, order=1)
#teste = tmp.forecastAheadInterval(sunspots[150:155], 5)
#teste = tmp.forecastAheadDistribution(nasdaq[1600:1604], steps=5, resolution=50)
#teste = tmp.forecast_ahead_interval(sunspots[150:155], 5)
#teste = tmp.forecast_ahead_distribution(nasdaq[1600:1604], steps=5, resolution=50)
bchmk.plot_compared_series(enrollments,[tmp], ['blue','red'], points=False, intervals=True)
@ -282,7 +282,7 @@ from pyFTS.partitioners import Grid
#model = pwfts.ProbabilisticWeightedFTS("FTS 1")
#model.appendTransformation(diff)
#model.append_transformation(diff)
#model.train(best[0:1600],fs.sets, order=3)
#bchmk.plot_compared_intervals_ahead(best[1600:1700],[model], ['blue','red'],
@ -370,11 +370,11 @@ fs = Grid.GridPartitioner(sonda[:9000], 10, transformation=diff)
tmp = sfts.SeasonalFTS("")
tmp.indexer = ix
tmp.appendTransformation(diff)
tmp.append_transformation(diff)
#tmp = pwfts.ProbabilisticWeightedFTS("")
#tmp.appendTransformation(diff)
#tmp.append_transformation(diff)
tmp.train(sonda[:9000], fs.sets, order=1)

View File

@ -109,7 +109,7 @@ nsftsp.train(trainp, order=2, parameters=ws)
#print(nsftsp)
tmpp = nsftsp.forecast(passengers[101:104], time_displacement=101, window_size=ws)
tmpi = nsftsp.forecastInterval(passengers[101:104], time_displacement=101, window_size=ws)
tmpi = nsftsp.forecast_interval(passengers[101:104], time_displacement=101, window_size=ws)
#print(passengers[101:104])
print([k[0] for k in tmpi])

View File

@ -56,9 +56,9 @@ pfts1.shortname = "1st Order"
#tmp = pfts1.forecast(data[3000:3020])
#tmp = pfts1.forecastInterval(data[3000:3020])
#tmp = pfts1.forecast_interval(data[3000:3020])
tmp = pfts1.forecastDistribution(data[3500])
tmp = pfts1.forecast_distribution(data[3500])
p = 0
for b in tmp[0].bins:
@ -66,9 +66,9 @@ for b in tmp[0].bins:
print(p)
#tmp = pfts1.forecastAheadInterval(data[3000:3020],20)
#tmp = pfts1.forecast_ahead_interval(data[3000:3020],20)
#tmp = pfts1.forecastAheadDistribution(data[3000:3020],20, method=3, h=0.45, kernel="gaussian")
#tmp = pfts1.forecast_ahead_distribution(data[3000:3020],20, method=3, h=0.45, kernel="gaussian")
#print(tmp[0])
#print(tmp[0].quantile([0.05, 0.95]))

View File

@ -46,7 +46,7 @@ class WeightedFTS(fts.FTS):
self.name = "Weighted FTS"
self.detail = "Yu"
def generateFLRG(self, flrs):
def generate_FLRG(self, flrs):
flrgs = {}
for flr in flrs:
if flr.LHS.name in flrgs:
@ -58,17 +58,17 @@ class WeightedFTS(fts.FTS):
def train(self, data, sets,order=1,parameters=None):
self.sets = sets
ndata = self.doTransformations(data)
tmpdata = FuzzySet.fuzzySeries(ndata, sets)
ndata = self.apply_transformations(data)
tmpdata = FuzzySet.fuzzyfy_series_old(ndata, sets)
flrs = FLR.generateRecurrentFLRs(tmpdata)
self.flrgs = self.generateFLRG(flrs)
self.flrgs = self.generate_FLRG(flrs)
def forecast(self, data, **kwargs):
l = 1
data = np.array(data)
ndata = self.doTransformations(data)
ndata = self.apply_transformations(data)
l = len(ndata)
@ -76,7 +76,7 @@ class WeightedFTS(fts.FTS):
for k in np.arange(0, l):
mv = FuzzySet.fuzzyInstance(ndata[k], self.sets)
mv = FuzzySet.fuzzyfy_instance(ndata[k], self.sets)
actual = self.sets[np.argwhere(mv == max(mv))[0, 0]]
@ -88,6 +88,6 @@ class WeightedFTS(fts.FTS):
ret.append(mp.dot(flrg.weights()))
ret = self.doInverseTransformations(ret, params=[data[self.order - 1:]])
ret = self.apply_inverse_transformations(ret, params=[data[self.order - 1:]])
return ret

View File

@ -1,16 +1,21 @@
from distutils.core import setup
setup(
name = 'pyFTS',
packages = ['pyFTS','pyFTS.benchmarks','pyFTS.common','pyFTS.data', 'pyFTS.ensemble',
'pyFTS.models','pyFTS.seasonal','pyFTS.partitioners','pyFTS.probabilistic',
'pyFTS.tests','pyFTS.nonstationary'],
package_data = {'benchmarks':['*'], 'common':['*'], 'data':['*'], 'ensemble':['*'], 'models':['*'], 'seasonal':['*'], 'partitioners':['*'], 'probabilistic':['*'], 'tests':['*']},
version = '1.1.1',
description = 'Fuzzy Time Series for Python',
author = 'Petronio Candido L. e Silva',
author_email = 'petronio.candido@gmail.com',
url = 'https://github.com/petroniocandido/pyFTS',
download_url = 'https://github.com/petroniocandido/pyFTS/archive/pkg1.1.1.tar.gz',
keywords = ['forecasting', 'fuzzy time series', 'fuzzy', 'time series forecasting'],
classifiers = [],
name='pyFTS',
packages=['pyFTS', 'pyFTS.benchmarks', 'pyFTS.common', 'pyFTS.data', 'pyFTS.ensemble',
'pyFTS.models', 'pyFTS.seasonal', 'pyFTS.partitioners', 'pyFTS.probabilistic',
'pyFTS.tests', 'pyFTS.nonstationary'],
package_data={'benchmarks': ['*'], 'common': ['*'], 'data': ['*'], 'ensemble': ['*'], 'models': ['*'],
'seasonal': ['*'], 'partitioners': ['*'], 'probabilistic': ['*'], 'tests': ['*']},
version='1.1.1',
description='Fuzzy Time Series for Python',
author='Petronio Candido L. e Silva',
author_email='petronio.candido@gmail.com',
url='https://github.com/petroniocandido/pyFTS',
download_url='https://github.com/petroniocandido/pyFTS/archive/pkg1.1.1.tar.gz',
keywords=['forecasting', 'fuzzy time series', 'fuzzy', 'time series forecasting'],
classifiers=[],
install_requires=[
'numpy','pandas','matplotlib','dill','copy','dispy','multiprocessing','joblib'
],
)