def phenotype(individual, train, fts_method, parameters={}, **kwargs):
vars = kwargs.get('variables', None)
tvar = kwargs.get('target_variable', None)
explanatory_vars = []
for ct, vix in enumerate(individual['explanatory_variables']):
var = vars[vix]
params = individual['explanatory_params'][ct]
mf = phenotype_mf(params)
partitioner = phenotype_partitioner(params)
if var['type'] == 'common':
tmp = variable.Variable(var['name'],
data_label=var['data_label'],
alias=var['name'],
partitioner=partitioner,
partitioner_specific={'mf': mf},
npart=params['npart'],
alpha_cut=params['alpha'],
data=train)
elif var['type'] == 'seasonal':
sp = {'seasonality': var['seasonality'], 'mf': mf}
tmp = variable.Variable(var['name'],
data_label=var['data_label'],
alias=var['name'],
partitioner=seasonal.TimeGridPartitioner,
partitioner_specific=sp,
npart=params['npart'],
alpha_cut=params['alpha'],
data=train)
explanatory_vars.append(tmp)
tparams = individual['target_params']
partitioner = phenotype_partitioner(tparams)
mf = phenotype_mf(tparams)
target_var = variable.Variable(tvar['name'],
data_label=tvar['data_label'],
alias=tvar['name'],
partitioner=partitioner,
partitioner_specific={'mf': mf},
npart=tparams['npart'],
alpha_cut=tparams['alpha'],
data=train)
explanatory_vars.append(target_var)
model = fts_method(explanatory_variables=explanatory_vars,
target_variable=target_var,
**parameters)
model.fit(train, **parameters)
return model
def get_variables(**parameters):
"""
From the dictionary of parameters, return a tuple with the list of explanatory and target variables
:param parameters: dictionary of parameters
:return: a tuple with the list of explanatory and target variables
"""
explanatory_variables = []
target_variable = None
for name in parameters['variables'].value:
from pyFTS.models.multivariate import common, variable
var = variable.Variable(
name,
type=parameters['{}_type'.format(name)].value,
data_label=parameters['{}_label'.format(name)].value,
alpha_cut=parameters['{}_alpha'.format(name)].value,
#data_type=parameters['{}_data_type'.format(name)].value,
#mask=parameters['{}_mask'.format(name)].value,
)
var.partitioner = get_partitioner(
parameters['{}_partitioner'.format(name)])
var.partitioner.type = parameters['{}_partitioner_type'.format(
name)].value
explanatory_variables.append(var)
if var.name == parameters['target'].value:
target_variable = var
return (explanatory_variables, target_variable)
def granular_forecast(train_df, test_df, params):
_input = list(params['input'])
_output = params['output']
_npartitions = params['npartitions']
_order = params['order']
_knn = params['knn']
_alpha_cut = params['alpha_cut']
_step = params.get('step', 1)
## create explanatory variables
exp_variables = []
for vc in _input:
exp_variables.append(
variable.Variable(vc,
data_label=vc,
alias=vc,
npart=_npartitions,
func=Membership.trimf,
data=train_df,
alpha_cut=_alpha_cut))
model = granular.GranularWMVFTS(explanatory_variables=exp_variables,
target_variable=exp_variables[0],
order=_order,
knn=_knn)
model.fit(train_df[_input], num_batches=1)
if _step > 1:
forecast = pd.DataFrame(columns=test_df.columns)
length = len(test_df.index)
for k in range(0, (length - (_order + _step - 1))):
fcst = model.predict(test_df[_input],
type='multivariate',
start_at=k,
steps_ahead=_step)
forecast = forecast.append(fcst.tail(1))
else:
forecast = model.predict(test_df[_input], type='multivariate')
return forecast[_output].values
def __init__(self, **kwargs):
mb = kwargs.pop('membership', 'triangular')
_membership = None
if mb == 'triangular':
_membership = trimf
elif mb == 'gaussian':
_membership = gaussmf
_npartitions = kwargs.pop('npartitions', 10)
_alpha_cut = kwargs.pop('alpha_cut', 0.3)
_knn = kwargs.pop('knn', 2)
data = kwargs.pop('data', None)
_order = kwargs.pop('order', 1)
self.columns = data.columns
exp_variables = []
for vc in self.columns:
exp_variables.append(variable.Variable(vc, data_label=vc, alias=vc,
partitioner=GridPartitioner, npart=_npartitions,
func=_membership, data=data, alpha_cut=_alpha_cut))
self.model = granular.GranularWMVFTS(explanatory_variables=exp_variables, target_variable=exp_variables[0], order=_order,
knn=_knn)
import time
from pyFTS.data import Malaysia, SONDA
sonda = SONDA.get_dataframe()[['datahora','glo_avg']].iloc[:600000]
sonda['data'] = pd.to_datetime(sonda["datahora"], format='%Y-%m-%d %H:%M:%S')
sonda = sonda.drop(sonda.index[np.where(sonda["glo_avg"] <= 0.01)])
sonda = sonda.dropna()
print(sonda)
sp = {'seasonality': DateTime.day_of_year , 'names': ['Jan','Fev','Mar','Abr','Mai','Jun','Jul', 'Ago','Set','Out','Nov','Dez']}
vmonth = variable.Variable("Month", data_label="data", partitioner=seasonal.TimeGridPartitioner, npart=12,
data=sonda, partitioner_specific=sp)
sp = {'seasonality': DateTime.minute_of_day, 'names': [str(k)+'hs' for k in range(0,24)]}
vhour = variable.Variable("Hour", data_label="data", partitioner=seasonal.TimeGridPartitioner, npart=24,
data=sonda, partitioner_specific=sp)
vavg = variable.Variable("Radiation", data_label="glo_avg", alias='rad',
partitioner=Grid.GridPartitioner, npart=35,
data=sonda)
model = wmvfts.WeightedMVFTS(explanatory_variables=[vhour, vhour, vavg], target_variable=vavg)
bchmk.distributed_model_train_test_time([model], sonda, 600000, 0.8, inc=1,
num_batches=7, distributed='dispy',nodes=['192.168.0.106','192.168.0.110'],
file='deho.db', tag='speedup', dataset='SONDA')
model = mvfts.MVFTS("")
fig, axes = plt.subplots(nrows=5, ncols=1, figsize=[15, 10])
sp = {
'seasonality':
DateTime.day_of_year,
'names': [
'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct',
'Nov', 'Dec'
]
}
vmonth = variable.Variable("Month",
data_label="datahora",
partitioner=seasonal.TimeGridPartitioner,
npart=12,
data=train,
partitioner_specific=sp)
vmonth.partitioner.plot(axes[0])
sp = {'seasonality': DateTime.minute_of_day}
vhour = variable.Variable("Hour",
data_label="datahora",
partitioner=seasonal.TimeGridPartitioner,
npart=24,
data=train,
partitioner_specific=sp)
vhour.partitioner.plot(axes[1])
df['time'] = pd.to_datetime(df["time"], format='%m/%d/%y %I:%M %p')
train_mv = df.iloc[:1800]
test_mv = df.iloc[1800:2000]
del (df)
sp = {
'seasonality': DateTime.minute_of_day,
'names': [str(k) + 'hs' for k in range(0, 24)]
}
vhour = variable.Variable("Hour",
data_label="time",
partitioner=seasonal.TimeGridPartitioner,
npart=24,
data=train_mv,
partitioner_specific=sp,
alpha_cut=.3)
vtemp = variable.Variable("Temperature",
data_label="temperature",
alias='temp',
partitioner=Grid.GridPartitioner,
npart=15,
func=Membership.gaussmf,
data=train_mv,
alpha_cut=.3)
vload = variable.Variable("Load",
data_label="load",
from pyFTS.models.seasonal.common import DateTime
from pyFTS.partitioners import Grid
sp = {
'seasonality':
DateTime.day_of_year,
'names': [
'Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out',
'Nov', 'Dez'
]
}
vmonth = variable.Variable("Month",
data_label="data",
partitioner=seasonal.TimeGridPartitioner,
npart=12,
data=train,
partitioner_specific=sp,
alpha_cut=.5)
sp = {
'seasonality': DateTime.minute_of_day,
'names': [str(k) for k in range(0, 24)]
}
vhour = variable.Variable("Hour",
data_label="data",
partitioner=seasonal.TimeGridPartitioner,
npart=24,
data=train,
partitioner_specific=sp,
return dates
sp500 = pd.read_csv('/home/petronio/Downloads/sp500.csv', index_col=0)
stock = sp500.iloc[:, :5]
date_grid = gen_dates(index=stock.index, time_is=100, time_os=2)
date_range = date_grid[0]
init_is, end_is, init_os, end_os = date_range
train = stock[init_is:end_is]
test = stock[init_os:end_os]
close = variable.Variable("close",
data_label='Adj Close',
partitioner=Grid.GridPartitioner,
npart=20,
data=train)
polarity = variable.Variable("polarity",
data_label='sentiment_bert',
partitioner=Grid.GridPartitioner,
npart=50,
data=train)
from pyFTS.models import hofts
#mpolarity = mvfts.MVFTS(explanatory_variables=[close, polarity], target_variable=polarity)
mpolarity = hofts.HighOrderFTS(partitioner=polarity.partitioner)
mpolarity.fit(train['sentiment_bert'].values)
mclose = mvfts.MVFTS(explanatory_variables=[close, polarity],
target_variable=close)
