def forecast(self, ndata, **kwargs):
if self.partitioner is not None:
ordered_sets = self.partitioner.ordered_sets
else:
ordered_sets = FuzzySet.set_ordered(self.partitioner.sets)
l = len(ndata)
npart = len(self.partitioner)
ret = []
for k in np.arange(0, l):
mv = FuzzySet.fuzzyfy_instance(ndata[k], self.partitioner.sets)
r = [max([ min(self.R[i][j], mv[j]) for j in np.arange(0,npart) ]) for i in np.arange(0,npart)]
fs = np.ravel(np.argwhere(r == max(r)))
if len(fs) == 1:
ret.append(self.partitioner.sets[ordered_sets[fs[0]]].centroid)
else:
mp = [self.partitioner.sets[ordered_sets[s]].centroid for s in fs]
ret.append( sum(mp)/len(mp))
return ret
def forecast(self, ndata, **kwargs):
l = 1
if self.partitioner is not None:
ordered_sets = self.partitioner.ordered_sets
else:
ordered_sets = FuzzySet.set_ordered(self.sets)
ndata = np.array(ndata)
l = len(ndata)
ret = []
for k in np.arange(0, l):
actual = FuzzySet.get_maximum_membership_fuzzyset(
ndata[k], self.sets, ordered_sets)
if actual.name not in self.flrgs:
ret.append(actual.centroid)
else:
flrg = self.flrgs[actual.name]
mp = flrg.get_midpoints(self.sets)
ret.append(mp.dot(flrg.weights()))
return ret
def forecast(self, data, **kwargs):
ordered_sets = FuzzySet.set_ordered(self.sets)
ret = []
index = self.indexer.get_season_of_data(data)
ndata = self.indexer.get_data(data)
for k in np.arange(0, len(data)):
if str(index[k]) in self.flrgs:
flrg = self.flrgs[str(index[k])]
d = FuzzySet.get_fuzzysets(ndata[k],
self.sets,
ordered_sets,
alpha_cut=self.alpha_cut)
mp = self.get_midpoints(flrg, d)
ret.append(sum(mp) / len(mp))
else:
ret.append(np.nan)
return ret
def __init__(self, **kwargs):
"""
Even Length Grid Partitioner
:param seasonality: Time granularity, from pyFTS.models.seasonal.common.DateTime
:param data: Training data of which the universe of discourse will be extracted. The universe of discourse is the open interval between the minimum and maximum values of the training data.
:param npart: The number of universe of discourse partitions, i.e., the number of fuzzy sets that will be created
:param func: Fuzzy membership function (pyFTS.common.Membership)
"""
super(TimeGridPartitioner, self).__init__(name="TimeGrid",
preprocess=False,
**kwargs)
self.season = kwargs.get('seasonality', DateTime.day_of_year)
'''Seasonality, a pyFTS.models.seasonal.common.DateTime object'''
self.mask = kwargs.get('mask', '%Y-%m-%d %H:%M:%S')
'''A string with datetime formating mask'''
data = kwargs.get('data', None)
if self.season == DateTime.year:
ndata = [strip_datepart(k, self.season) for k in data]
self.min = min(ndata)
self.max = max(ndata)
else:
tmp = (self.season.value / self.partitions) / 2
self.min = tmp
self.max = self.season.value + tmp
self.type = kwargs.get('type', 'seasonal')
self.sets = self.build(None)
if self.ordered_sets is None and self.setnames is not None:
self.ordered_sets = self.setnames
else:
self.ordered_sets = FS.set_ordered(self.sets)
def __init__(self, **kwargs):
"""
Universe of Discourse partitioner scheme. Split data on several fuzzy sets
:param name: partitioner name
:param data: Training data of which the universe of discourse will be extracted. The universe of discourse is the open interval between the minimum and maximum values of the training data.
:param npart: The number of universe of discourse partitions, i.e., the number of fuzzy sets that will be created
:param func: Fuzzy membership function (pyFTS.common.Membership)
:param names: list of partitions names. If None is given the partitions will be auto named with prefix
:param prefix: prefix of auto generated partition names
:param transformation: data transformation to be applied on data
"""
self.name = kwargs.get('name', "")
self.partitions = kwargs.get('npart', 10)
self.sets = {}
self.membership_function = kwargs.get('func', Membership.trimf)
self.setnames = kwargs.get('names', None)
self.prefix = kwargs.get('prefix', 'A')
self.transformation = kwargs.get('transformation', None)
self.indexer = kwargs.get('indexer', None)
self.variable = kwargs.get('variable', None)
self.type = kwargs.get('type', 'common')
self.ordered_sets = None
if kwargs.get('preprocess', True):
data = kwargs.get('data', [None])
if self.indexer is not None:
ndata = self.indexer.get_data(data)
else:
ndata = data
if self.transformation is not None:
ndata = self.transformation.apply(ndata)
else:
ndata = data
if self.indexer is not None:
ndata = self.indexer.get_data(ndata)
_min = np.nanmin(ndata)
if _min == -np.inf:
ndata[ndata == -np.inf] = 0
_min = np.nanmin(ndata)
self.min = float(_min * 1.1 if _min < 0 else _min * 0.9)
_max = max(ndata)
self.max = float(_max * 1.1 if _max > 0 else _max * 0.9)
self.sets = self.build(ndata)
if self.ordered_sets is None and self.setnames is not None:
self.ordered_sets = self.setnames
else:
self.ordered_sets = FuzzySet.set_ordered(self.sets)
del (ndata)
def flr_membership_matrix(self, flr):
ordered_set = FuzzySet.set_ordered(self.partitioner.sets)
centroids = [self.partitioner.sets[k].centroid for k in ordered_set]
lm = [self.partitioner.sets[flr.LHS].membership(k) for k in centroids]
rm = [self.partitioner.sets[flr.RHS].membership(k) for k in centroids]
l = len(ordered_set)
r = np.zeros((l, l))
for k in range(0,l):
for l in range(0, l):
r[k][l] = min(lm[k], rm[l])
return r
def forecast(self, ndata, **kwargs):
explain = kwargs.get('explain', False)
if self.partitioner is not None:
ordered_sets = self.partitioner.ordered_sets
else:
ordered_sets = FuzzySet.set_ordered(self.sets)
ndata = np.array(ndata)
l = len(ndata) if not explain else 1
ret = []
for k in np.arange(0, l):
actual = FuzzySet.get_maximum_membership_fuzzyset(
ndata[k], self.sets, ordered_sets)
if explain:
print("Fuzzyfication:\n\n {} -> {} \n\n".format(
ndata[k], actual.name))
if actual.name not in self.flrgs:
ret.append(actual.centroid)
if explain:
print("Rules:\n\n {} -> {} (Naïve)\t Midpoint: {} \n\n".
format(actual.name, actual.name, actual.centroid))
else:
flrg = self.flrgs[actual.name]
mp = flrg.get_midpoints(self.sets)
final = mp.dot(flrg.weights(self.sets))
ret.append(final)
if explain:
print("Rules:\n\n {} \n\n ".format(str(flrg)))
print("Midpoints: \n\n {}\n\n".format(mp))
print("Deffuzyfied value: {} \n".format(final))
return ret
def __init__(self, data, part, **kwargs):
""""""
super(SimpleNonStationaryPartitioner,
self).__init__(name=part.name,
data=data,
npart=part.partitions,
func=part.membership_function,
names=part.setnames,
prefix=part.prefix,
transformation=part.transformation,
indexer=part.indexer) #, preprocess=False)
for key in part.sets.keys():
set = part.sets[key]
tmp = common.FuzzySet(set.name, set.mf, set.parameters, **kwargs)
tmp.centroid = set.centroid
self.sets[key] = tmp
self.ordered_sets = stationary_fs.set_ordered(self.sets)
def forecast(self, data, **kwargs):
ordered_sets = FuzzySet.set_ordered(self.sets)
ret = []
index = self.indexer.get_season_of_data(data)
ndata = self.indexer.get_data(data)
for k in np.arange(0, len(data)):
flrg = self.flrgs[str(index[k])]
d = FuzzySet.get_maximum_membership_fuzzyset(
ndata[k], self.sets, ordered_sets)
mp = self.get_midpoints(flrg, d)
ret.append(sum(mp) / len(mp))
return ret
def __init__(self, data, part, **kwargs):
""""""
super(PolynomialNonStationaryPartitioner,
self).__init__(name=part.name,
data=data,
npart=part.partitions,
func=part.membership_function,
names=part.setnames,
prefix=part.prefix,
transformation=part.transformation,
indexer=part.indexer,
preprocess=False)
self.sets = {}
loc_params, wid_params = self.get_polynomial_perturbations(
data, **kwargs)
if self.ordered_sets is None and self.setnames is not None:
self.ordered_sets = part.setnames
else:
self.ordered_sets = stationary_fs.set_ordered(part.sets)
for ct, key in enumerate(self.ordered_sets):
set = part.sets[key]
loc_roots = np.roots(loc_params[ct])[0]
wid_roots = np.roots(wid_params[ct])[0]
tmp = common.FuzzySet(
set.name,
set.mf,
set.parameters,
location=perturbation.polynomial,
location_params=loc_params[ct],
location_roots=loc_roots, #**kwargs)
width=perturbation.polynomial,
width_params=wid_params[ct],
width_roots=wid_roots,
**kwargs)
self.sets[set.name] = tmp
def forecast(self, ndata, **kwargs):
if self.sets == None:
self.sets = self.partitioner.sets
ordered_sets = self.partitioner.ordered_sets
else:
ordered_sets = FuzzySet.set_ordered(self.sets)
l = len(self.sets)
cn = np.array([0.0 for k in range(l)])
ow = np.array([[0.0 for k in range(l)] for z in range(self.order - 1)])
rn = np.array([[0.0 for k in range(l)] for z in range(self.order - 1)])
ft = np.array([0.0 for k in range(l)])
ret = []
for t in np.arange(self.order - 1, len(ndata)):
for ix in range(l):
s = ordered_sets[ix]
cn[ix] = self.sets[s].membership(
FuzzySet.grant_bounds(ndata[t], self.sets, ordered_sets))
for w in range(self.order - 1):
ow[w, ix] = self.sets[s].membership(
FuzzySet.grant_bounds(ndata[t - w], self.sets,
ordered_sets))
rn[w, ix] = ow[w, ix] * cn[ix]
ft[ix] = max(ft[ix], rn[w, ix])
mft = max(ft)
out = 0.0
count = 0.0
for ix in range(l):
s = ordered_sets[ix]
if ft[ix] == mft:
out = out + self.sets[s].centroid
count += 1.0
ret.append(out / count)
return ret
def __init__(self, **kwargs):
"""
Fixed UoD with Even Length Grid Partitioner
"""
kwargs['preprocess'] = False
super(GridPartitioner, self).__init__(name="Grid", **kwargs)
self.max = kwargs.get('max', None)
self.min = kwargs.get('min', None)
if self.max is None or self.min is None:
raise Exception(
"It is mandatory to inform the max and min parameters!")
self.sets = self.build(None)
self.partitions = len(self.sets)
if self.ordered_sets is None and self.setnames is not None:
self.ordered_sets = self.setnames[:len(self.sets)]
else:
self.ordered_sets = FuzzySet.set_ordered(self.sets)
def __init__(self, **kwargs):
"""
Universe of Discourse partitioner scheme. Split data on several fuzzy sets
"""
self.name = kwargs.get('name', "")
"""partitioner name"""
self.partitions = kwargs.get('npart', 10)
"""The number of universe of discourse partitions, i.e., the number of fuzzy sets that will be created"""
self.sets = {}
self.membership_function = kwargs.get('func', Membership.trimf)
"""Fuzzy membership function (pyFTS.common.Membership)"""
self.setnames = kwargs.get('names', None)
"""list of partitions names. If None is given the partitions will be auto named with prefix"""
self.prefix = kwargs.get('prefix', 'A')
"""prefix of auto generated partition names"""
self.transformation = kwargs.get('transformation', None)
"""data transformation to be applied on data"""
self.indexer = kwargs.get('indexer', None)
self.variable = kwargs.get('variable', None)
"""In a multivariate context, the variable that contains this partitioner"""
self.type = kwargs.get('type', 'common')
"""The type of fuzzy sets that are generated by this partitioner"""
self.ordered_sets = None
"""A ordered list of the fuzzy sets names, sorted by their middle point"""
self.kdtree = None
"""A spatial index to help in fuzzyfication"""
self.margin = kwargs.get("margin", 0.1)
"""The upper and lower exceeding margins for the known UoD. The default value is .1"""
self.lower_margin = kwargs.get("lower_margin", self.margin)
"""Specific lower exceeding margins for the known UoD. The default value is the self.margin parameter"""
self.upper_margin = kwargs.get("lower_margin", self.margin)
"""Specific upper exceeding margins for the known UoD. The default value is the self.margin parameter"""
if kwargs.get('preprocess', True):
data = kwargs.get('data', [None])
if self.indexer is not None:
ndata = self.indexer.get_data(data)
else:
ndata = data
if self.transformation is not None:
ndata = self.transformation.apply(ndata)
else:
ndata = data
if self.indexer is not None:
ndata = self.indexer.get_data(ndata)
_min = np.nanmin(ndata)
if _min == -np.inf:
ndata[ndata == -np.inf] = 0
_min = np.nanmin(ndata)
self.min = float(_min *
(1 + self.lower_margin) if _min < 0 else _min *
(1 - self.lower_margin))
_max = np.nanmax(ndata)
self.max = float(_max *
(1 + self.upper_margin) if _max > 0 else _max *
(1 - self.upper_margin))
self.sets = self.build(ndata)
self.partitions = len(self.sets)
if self.ordered_sets is None and self.setnames is not None:
self.ordered_sets = self.setnames[:len(self.sets)]
else:
self.ordered_sets = FuzzySet.set_ordered(self.sets)
del (ndata)
def __init__(self, **kwargs):
"""
Universe of Discourse partitioner scheme. Split data on several fuzzy sets
"""
self.name = kwargs.get('name',"")
"""partitioner name"""
self.partitions = kwargs.get('npart', 10)
"""The number of universe of discourse partitions, i.e., the number of fuzzy sets that will be created"""
self.sets = {}
self.membership_function = kwargs.get('func', Membership.trimf)
"""Fuzzy membership function (pyFTS.common.Membership)"""
self.setnames = kwargs.get('names', None)
"""list of partitions names. If None is given the partitions will be auto named with prefix"""
self.prefix = kwargs.get('prefix', 'A')
"""prefix of auto generated partition names"""
self.transformation = kwargs.get('transformation', None)
"""data transformation to be applied on data"""
self.indexer = kwargs.get('indexer', None)
self.variable = kwargs.get('variable', None)
"""In a multivariate context, the variable that contains this partitioner"""
self.type = kwargs.get('type', 'common')
"""The type of fuzzy sets that are generated by this partitioner"""
self.extractor = kwargs.get('extractor', lambda x: x)
"""Anonymous function used to extract a single primitive type from an object instance"""
self.ordered_sets = None
"""A ordered list of the fuzzy sets names, sorted by their middle point"""
self.kdtree = None
"""A spatial index to help in fuzzyfication"""
if kwargs.get('preprocess',True):
data = kwargs.get('data',[None])
if self.indexer is not None:
ndata = self.indexer.get_data(data)
else:
ndata = data
if self.transformation is not None:
ndata = self.transformation.apply(ndata)
else:
ndata = data
if self.indexer is not None:
ndata = self.indexer.get_data(ndata)
_min = np.nanmin(ndata)
if _min == -np.inf:
ndata[ndata == -np.inf] = 0
_min = np.nanmin(ndata)
self.min = float(_min * 1.1 if _min < 0 else _min * 0.9)
_max = np.nanmax(ndata)
self.max = float(_max * 1.1 if _max > 0 else _max * 0.9)
self.sets = self.build(ndata)
if self.ordered_sets is None and self.setnames is not None:
self.ordered_sets = self.setnames[:len(self.sets)]
else:
self.ordered_sets = FuzzySet.set_ordered(self.sets)
del(ndata)
