Source code for pyFTS.common.FuzzySet

import numpy as np
from pyFTS import *
from pyFTS.common import Membership


[docs]class FuzzySet(object): """ Fuzzy Set """ def __init__(self, name, mf, parameters, centroid, alpha=1.0, **kwargs): """ Create a Fuzzy Set """ self.name = name """The fuzzy set name""" self.mf = mf """The membership function""" self.parameters = parameters """The parameters of the membership function""" self.centroid = centroid """The fuzzy set center of mass (or midpoint)""" self.alpha = alpha """The alpha cut value""" self.type = kwargs.get('type', 'common') """The fuzzy set type (common, composite, nonstationary, etc)""" self.variable = kwargs.get('variable',None) """In multivariate time series, indicate for which variable this fuzzy set belogs""" self.Z = None """Partition function in respect to the membership function""" if self.mf == Membership.trimf: self.lower = min(parameters) self.upper = max(parameters) elif self.mf == Membership.gaussmf: self.lower = parameters[0] - parameters[1]*3 self.upper = parameters[0] + parameters[1]*3 self.metadata = {}
[docs] def membership(self, x): """ Calculate the membership value of a given input :param x: input value :return: membership value of x at this fuzzy set """ return self.mf(x, self.parameters) * self.alpha
[docs] def partition_function(self,uod=None, nbins=100): """ Calculate the partition function over the membership function. :param uod: :param nbins: :return: """ if self.Z is None and uod is not None: self.Z = 0.0 for k in np.linspace(uod[0], uod[1], nbins): self.Z += self.membership(k) return self.Z
def __str__(self): return self.name + ": " + str(self.mf.__name__) + "(" + str(self.parameters) + ")"
[docs]def set_ordered(fuzzySets): """Order a fuzzy set list by their centroids""" if len(fuzzySets) > 0: tmp1 = [fuzzySets[k] for k in fuzzySets.keys()] return [k.name for k in sorted(tmp1, key=lambda x: x.centroid)]
[docs]def fuzzyfy_instance(inst, fuzzySets, ordered_sets=None): """ Calculate the membership values for a data point given fuzzy sets :param inst: data point :param fuzzySets: dict of fuzzy sets :return: array of membership values """ if ordered_sets is None: ordered_sets = set_ordered(fuzzySets) mv = [] for key in ordered_sets: mv.append( fuzzySets[key].membership(inst)) return np.array(mv)
[docs]def fuzzyfy_instances(data, fuzzySets, ordered_sets=None): """ Calculate the membership values for a data point given fuzzy sets :param inst: data point :param fuzzySets: dict of fuzzy sets :return: array of membership values """ ret = [] if ordered_sets is None: ordered_sets = set_ordered(fuzzySets) for inst in data: mv = np.array([fuzzySets[key].membership(inst) for key in ordered_sets]) ret.append(mv) return ret
[docs]def get_fuzzysets(inst, fuzzySets, ordered_sets=None, alpha_cut=0.0): """ Return the fuzzy sets which membership value for a inst is greater than the alpha_cut :param inst: data point :param fuzzySets: dict of fuzzy sets :param alpha_cut: Minimal membership to be considered on fuzzyfication process :return: array of membership values """ if ordered_sets is None: ordered_sets = set_ordered(fuzzySets) fs = [key for key in ordered_sets if fuzzySets[key].membership(inst) > alpha_cut] return fs
[docs]def get_maximum_membership_fuzzyset(inst, fuzzySets, ordered_sets=None): """ Fuzzify a data point, returning the fuzzy set with maximum membership value :param inst: data point :param fuzzySets: dict of fuzzy sets :return: fuzzy set with maximum membership """ if ordered_sets is None: ordered_sets = set_ordered(fuzzySets) mv = np.array([fuzzySets[key].membership(inst) for key in ordered_sets]) key = ordered_sets[np.argwhere(mv == max(mv))[0, 0]] return fuzzySets[key]
[docs]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: dict of fuzzy sets :return: fuzzy set with maximum membership """ mv = fuzzyfy_instance(inst, fuzzySets) return np.argwhere(mv == max(mv))[0, 0]
[docs]def fuzzyfy_series_old(data, fuzzySets, method='maximum'): fts = [] for item in data: fts.append(get_maximum_membership_fuzzyset(item, fuzzySets).name) return fts
[docs]def fuzzyfy_series(data, fuzzySets, method='maximum', alpha_cut=0.0): fts = [] ordered_sets = set_ordered(fuzzySets) for t, i in enumerate(data): mv = np.array([fuzzySets[key].membership(i) for key in ordered_sets]) if len(mv) == 0: sets = check_bounds(i, fuzzySets.items(), ordered_sets) else: if method == 'fuzzy': ix = np.ravel(np.argwhere(mv > alpha_cut)) sets = [fuzzySets[ordered_sets[i]].name for i in ix] elif method == 'maximum': mx = max(mv) ix = np.ravel(np.argwhere(mv == mx)) sets = fuzzySets[ordered_sets[ix[0]]].name fts.append(sets) return fts
[docs]def grant_bounds(data, sets, ordered_sets): if data < sets[ordered_sets[0]].lower: return sets[ordered_sets[0]].lower elif data > sets[ordered_sets[-1]].upper: return sets[ordered_sets[-1]].upper else: return data
[docs]def check_bounds(data, sets, ordered_sets): if data < sets[ordered_sets[0]].lower: return sets[ordered_sets[0]] elif data > sets[ordered_sets[-1]].upper: return sets[ordered_sets[-1]]
[docs]def check_bounds_index(data, sets, ordered_sets): if data < sets[ordered_sets[0]].get_lower(): return 0 elif data > sets[ordered_sets[-1]].get_upper(): return len(sets) -1