def Computar_solucao_teste(self, dados, lags, enxame):
'''
Este método tem por objetivo computar o fitness de uma particula sentry para um determinado conceito
:param dados: dados que serao usados para definir um conceito
:param lags: quantidade de lags para modelar a entrada da redes
:param enxame: enxame que possui a particula sentry
:return: retorna o fitness para o conjunto de dados passados
'''
# modelando os dados e realizando as previsoes
particao = Particionar_series(dados, [1, 0, 0], lags)
[caracteristicas_entrada, caracteristicas_saida] = particao.Part_train()
previsoes = enxame.Predizer(Entradas=caracteristicas_entrada)
#calculando a estatistica do sensor
acuracias = []
for i in range(len(caracteristicas_entrada)):
erro = mean_absolute_error(caracteristicas_saida[i:i+1], previsoes[i:i+1])
acuracias.append(erro)
estatistica = [0] * 2
estatistica[0] = np.mean(acuracias)
estatistica[1] = np.std(acuracias)
return estatistica
def Computar_Media(self, vetor_caracteristicas, lags, sensor):
'''
Metodo para computar a deteccao de mudanca na serie temporal por meio do comportamento das particulas
:param vetor_caracteristicas: vetor com uma amostra da serie temporal que sera avaliada para verificar a mudanca
:param lags: quantidade de lags para modelar as entradas da RNA
:param modelo: enxame utilizado para computar as estatisticas dos sensores
:param sensor: particula utilizada como sensor
:return: retorna a media e o desvio padrao do sensor para o vetor de caracteristicas: estatistica[media, desvio]
'''
particao = Particionar_series(vetor_caracteristicas, [1, 0, 0], lags)
[caracteristicas_entrada, caracteristicas_saida] = particao.Part_train()
predicao_caracteristica = sensor.Predizer(caracteristicas_entrada)
#calculando a estatistica do sensor
acuracias = []
for i in range(len(caracteristicas_entrada)):
erro = mean_absolute_error(caracteristicas_saida[i:i+1], predicao_caracteristica[i:i+1])
acuracias.append(erro)
estatistica = [0] * 2
estatistica[0] = np.mean(acuracias)
estatistica[1] = np.std(acuracias)
return estatistica
def Atualizar_comportamento_media(self, vetor_caracteristicas, lags, enxame):
'''
Metodo para computar a deteccao de mudanca na serie temporal por meio do comportamento das particulas
:param vetor_caracteristicas: vetor com uma amostra da serie temporal que sera avaliada para verificar a mudanca
:param lags: quantidade de lags para modelar as entradas da RNA
:param enxame: enxame utilizado para verificar a mudanca
:return: retorna a media ou o comportamento do enxame em relacao ao vetor de caracteristicas
'''
#particionando o vetor de caracteristicas para usar para treinar
particao = Particionar_series(vetor_caracteristicas, [1, 0, 0], lags)
[caracteristicas_entrada, caracteristicas_saida] = particao.Part_train()
#variavel para salvar as medias das predicoes
medias = []
#realizando as previsoes e armazenando as acuracias
for i in range(enxame.numero_particulas):
predicao_caracteristica = enxame.sensores[i].Predizer(caracteristicas_entrada)
MAE = mean_absolute_error(caracteristicas_saida, predicao_caracteristica)
medias.append(MAE)
#salvando a media e desvio padrao das acuracias
comportamento = [0] * 2
comportamento[0] = np.mean(medias)
comportamento[1] = np.std(medias)
return comportamento
def main():
data = get_data_without_cols(2)
X_train, y_train, X_test, y_test = data
model = RandomForestRegressor(
n_estimators=100,
n_jobs=-1,
random_state=1,
criterion="mse",
max_features="sqrt",
# min_samples_split=3, max_depth=9,
# min_samples_leaf=1,
# min_weight_fraction_leaf=0,
# min_impurity_decrease=0,
)
model.fit(X_train, y_train.iloc[:, 0])
y_pred = model.predict(X_test).reshape(-1, 1)
r2 = r2_score(y_test, y_pred)
m_e = mean_absolute_error(y_test, y_pred)
mean = y_test.mean(axis=0).mean()
mean_pred = y_pred.mean(axis=0).mean()
print("{} | mean error : {} | mean {} / {}".format(
round(r2, 3),
round(m_e, 3),
round(mean_pred, 3),
round(mean, 3),
))
def evaluate_model(predicted_values, actual_values):
print('---------------------------------\n')
print('R2 Score : %f' %
regression.r2_score(actual_values, predicted_values))
print('Mean Absoulte Error : %f' %
regression.mean_absolute_error(actual_values, predicted_values))
print('Median Absolute Error: %f' %
regression.median_absolute_error(actual_values, predicted_values))
print('----------------------------------\n')
def calc_error_metrics(self):
# Log loss, aka logistic loss or cross-entropy loss.
self.scores['LogLoss'] = log_loss(self.y_true, self.y_pred)
# Mean Squared Error
self.scores['Mean Squared Error'] = mean_squared_error(self.y_true, self.y_pred)
# Mean Absolute Error
self.scores['Mean Absolute Error'] = mean_absolute_error(self.y_true, self.y_pred)
# R^2 (coefficient of determination) regression score function - indicated how well data fits the statistical model
self.scores['R2 Score'] = r2_score(self.y_true, self.y_pred)
"""TBD compute the log-loss to consider boolean"""
return
def get_regression_metrics(y_test, y_score, reg_type='lin', res_rmse=True):
from scipy.stats import linregress, spearmanr
from sklearn.metrics import regression
rmse = np.sqrt(regression.mean_absolute_error(y_test, y_score))
if reg_type == 'lin':
slope, intercept, r, p_value, std_err = linregress(y_test, y_score)
result = "$r$=%0.2f" % (r)
elif reg_type == 'rank':
r, p_value = spearmanr(y_test, y_score)
result = "$\rho$=%0.2f" % (r)
if res_rmse:
result = "%s\nRMSE=%0.2f" % (result, rmse)
return result, r, rmse
def _print_regressionMetrics(_linear, _X, _y, _predict):
metrics = [['Regresión Lineal', 'Datos obtenidos'],
['Coeficiente', _linear.coef_],
['Interceptación', _linear.intercept_],
['Calificación (score)', _linear.score(_X, _y)],
['Variance Score', r2_score(_y, _predict)],
['Explained Variance Score', explained_variance_score(_y, _predict)],
['Mean Squared Error', mean_squared_error(_y, _predict)],
['Mean Absolute Error', mean_absolute_error(_y, _predict)], ]
print('\nMinería de Datos - Regresión Lineal - <VORT>', '\n')
print(_linear, '\n')
print(look(metrics))
def ml_scoring(model, testX, testY):
prediction = model.predict(testX)
mxerr = max_error(testY, prediction)
mabserr = mean_absolute_error(testY, prediction)
r2d2 = r2_score(testY, prediction)
# mlogerr = mean_squared_log_error(testY, prediction)
return {
"max_err": mxerr,
"max_abs_err": mabserr,
"r2": r2d2
# "mlog": mlogerr
}
def main(establishment_number=0, out="results.csv"):
# Get data
cols_to_drop = [
"date_timestamp",
"Vacances_A",
"Vacances_B",
"library",
]
cols_weather = [
'rainfall',
'temperature',
'humidity',
'pressure',
'pressure_variation',
'pressure_variation_3h',
]
data = get_data(
columns_to_drop=cols_to_drop + cols_weather, drop_na=True,
establishment_number=establishment_number,
drop_value_below_threshold=None,
)
X_train, y_train, X_test, y_test = data
# Train model and predict
model = RandomForestRegressor(n_estimators=500, min_samples_split=3, max_features="sqrt", random_state=1)
y_train_array = y_train.iloc[:, 0]
model.fit(X_train, y_train_array)
y_pred = model.predict(X_test).reshape(-1, 1)
# Write results
total = np.concatenate([X_test, y_test, y_pred], axis=1)
df = pd.DataFrame(total, columns=[*list(X_test), "Real visitor number", "Predicted visitor number"])
df.to_csv("data/" + out, sep=";", decimal=",")
# Show scores
r2 = r2_score(y_test, y_pred)
max_visitors = y_test.max(axis=0).max()
mean_visitors = y_test.mean(axis=0).mean()
mean_error = mean_absolute_error(y_test, y_pred)
print(
"""
score R2 : {}
max : {}
mean : {}
mean error : {}
""".format(r2, max_visitors, mean_visitors, mean_error)
)
def Avaliar_particulas(self, enxame_atual, dados, lags):
'''
metodo para avaliar cada particula para um determinado conceito, retorna a melhor particula
:param: enxame_atual: enxame atual que será substituido
:param: dados: dados para avaliar a acuracia dos modelos armazenados
:param: lags: quantidade de lags para modelar os dados de entrada da rede
:return: retorna a melhor particula para o determinado conceito
'''
particao = Particionar_series(dados, [1, 0, 0], lags)
[dados_x, dados_y] = particao.Part_train()
#print("Quantidade de dados para treinamento: ", len(dados_y))
acuracias = []
for i in range(len(enxame_atual.sensores)):
previsao = enxame_atual.Predizer(dados_x, i)
erro = mean_absolute_error(dados_y, previsao)
#print("Sensor [", i, "]:", erro)
acuracias.append(erro)
j = np.argmin(acuracias)
#print("Melhor particula: [",j,"]: ", acuracias[j])
'''
sequencia = range(0, len(acuracias))
colors = ['blue'] * len(acuracias)
colors[0] = 'green'
colors[j] = 'red'
barras = plt.bar(sequencia, acuracias, 0.6, align='center', color = colors)
plt.ylabel('MAE')
plt.xlabel('Particles')
plt.title('Swarm')
plt.xticks(range(len(acuracias)))
limiar = min(acuracias) * 0.06
plt.axis([-1, len(acuracias), min(acuracias) - limiar, max(acuracias) + limiar])
rects = barras.patches
# Now make some labels
height = rects[0].get_height()
plt.text(rects[0].get_x() + rects[0].get_width()/2, height + (limiar/5), 'Current Gbest', ha='center', va='bottom', rotation='vertical')
height = rects[j].get_height()
plt.text(rects[j].get_x() + rects[j].get_width()/2, height+(limiar/2), 'Min error', ha='center', va='bottom', rotation='vertical')
plt.legend()
plt.show()
'''
return enxame_atual.sensores[j]
def evaluate(ytrue, ypred):
"""
:param ytrue: true value of the dependent variable, numpy array
:param ypred: predictions for the dependent variable, numpy array
:return: different evaluation metrics: R squared, mean square error, mean absolute error, and fraction of variance
explained and Spearman ranking correlation coefficient
"""
r2 = r2_score(ytrue, ypred)
mse = mean_squared_error(ytrue, ypred)
mae = mean_absolute_error(ytrue, ypred)
variance_explained = explained_variance_score(ytrue, ypred)
spearman = spearmanr(ytrue, ypred)[0]
return r2, mse, mae, variance_explained, spearman
def Reavaliar_sentry(self, dados, lags, enxame):
'''
Este método tem por objetivo computar o fitness de uma particula sentry para um determinado conceito
:param dados: dados que serao usados para definir um conceito
:param lags: quantidade de lags para modelar a entrada da redes
:param enxame: enxame que possui a particula sentry
:return: retorna o fitness para o conjunto de dados passados
'''
# modelando os dados e realizando as previsoes
particao = Particionar_series(dados, [1, 0, 0], lags)
[caracteristicas_entrada, caracteristicas_saida] = particao.Part_train()
previsoes = enxame.Predizer(Entradas=caracteristicas_entrada)
return mean_absolute_error(caracteristicas_saida, previsoes)
def get_regression_metrics(y_test,y_score,
reg_type='lin',
res_rmse=True):
from scipy.stats import linregress,spearmanr
from sklearn.metrics import regression
rmse=np.sqrt(regression.mean_absolute_error(y_test,y_score))
if reg_type=='lin':
slope, intercept, r, p_value, std_err = linregress(y_test,y_score)
result="$r$=%0.2f" % (r)
elif reg_type=='rank':
r, p_value= spearmanr(y_test,y_score)
result="$\rho$=%0.2f" % (r)
if res_rmse:
result="%s\nRMSE=%0.2f" % (result,rmse)
return result,r,rmse
def test_multi_output_learner_regressor():
stream = RegressionGenerator(n_samples=5500,
n_features=10,
n_informative=20,
n_targets=2,
random_state=1)
stream.prepare_for_use()
estimator = SGDRegressor(random_state=112,
tol=1e-3,
max_iter=10,
loss='squared_loss')
learner = MultiOutputLearner(base_estimator=estimator)
X, y = stream.next_sample(150)
learner.partial_fit(X, y)
cnt = 0
max_samples = 5000
predictions = []
true_targets = []
wait_samples = 100
correct_predictions = 0
while cnt < max_samples:
X, y = stream.next_sample()
# Test every n samples
if (cnt % wait_samples == 0) and (cnt != 0):
predictions.append(learner.predict(X)[0])
true_targets.append(y[0])
if np.array_equal(y[0], predictions[-1]):
correct_predictions += 1
learner.partial_fit(X, y)
cnt += 1
expected_performance = 2.444365309339395
performance = mean_absolute_error(true_targets, predictions)
assert np.isclose(performance, expected_performance)
assert learner._estimator_type == "regressor"
assert type(learner.predict(X)) == np.ndarray
with pytest.raises(AttributeError):
learner.predict_proba(X)
def read_input_data():
X_train, Y_train, X_test, Y_test = normalize_data()
rng = numpy.random.RandomState(123)
# print(normalized_X_train.values, normalized_Y_train)
# print(normalized_X_train.shape, normalized_Y_train.shape)
dbn = DBN(input=X_train,
label=Y_train,
n_ins=X_train.shape[1],
hidden_layer_sizes=[80] * 10,
n_outs=1,
rng=rng)
dbn.pretrain(lr=0.001, k=1, epochs=1000)
dbn.finetune(lr=0.001, epochs=200)
resutls = dbn.predict(X_test)
print("results", resutls, Y_test)
print(Y_test.shape)
print(r2_score(resutls, Y_test), mean_squared_error(resutls, Y_test))
print(mean_absolute_error(resutls, Y_test))
def get_regression_metrics(ground_truth_value, predicted_value):
regression_metric_dict = dict({})
regression_metric_dict['r2_score'] = r2_score(ground_truth_value,
predicted_value)
regression_metric_dict['mean_squared_error'] = mean_squared_error(
ground_truth_value, predicted_value)
#regression_metric_dict['mean_squared_log_error'] = mean_squared_log_error(ground_truth_value, predicted_value)
regression_metric_dict['mean_absolute_error'] = mean_absolute_error(
ground_truth_value, predicted_value)
regression_metric_dict[
'explained_variance_score'] = explained_variance_score(
ground_truth_value, predicted_value)
regression_metric_dict['median_absolute_error'] = median_absolute_error(
ground_truth_value, predicted_value)
regression_metric_dict['max_error'] = max_error(ground_truth_value,
predicted_value)
return regression_metric_dict
def get_resutls_column(model, trainfolds_dfs, testfolds_dfs, train_set,
test_set, feature_set, target_col_name):
MSEs = [None] * len(testfolds_dfs)
MAEs = [None] * len(testfolds_dfs)
SPs = [None] * len(testfolds_dfs)
PNs = [None] * len(testfolds_dfs)
for i in range(len(testfolds_dfs)):
train_X = trainfolds_dfs[i].loc[:, feature_set].values
train_Y = trainfolds_dfs[i].loc[:, target_col_name].values
test_X = testfolds_dfs[i].loc[:, feature_set].values
test_Y = testfolds_dfs[i].loc[:, target_col_name].values
model.fit(train_X, train_Y)
test_pred = model.predict(test_X)
MAEs[i] = MAE(test_pred, test_Y)
MSEs[i] = MSE(test_pred, test_Y)
SPs[i] = SPC(test_pred, test_Y)
PNs[i] = PNC(test_pred, test_Y)
train_cvavg_MAE = numpy.mean(MAEs)
train_cvavg_MSE = numpy.mean(MSEs)
train_cvavg_PN = numpy.mean(PNs)
train_cvavg_SP = numpy.mean(SPs)
test_Y = test_set.loc[:, target_col].values
test_X = test_set.loc[:, feature_set].values
train_X = train_set.loc[:, feature_set].values
train_Y = train_set.loc[:, target_col].values
model.fit(train_X, train_Y)
test_pred = model.predict(test_X)
testset_pn, _ = pearsonr(test_Y, test_pred)
testset_sp, _ = spearmanr(test_Y, test_pred)
testset_mae = mean_absolute_error(test_Y, test_pred)
testset_mse = mean_squared_error(test_Y, test_pred)
column = [
testset_mae, testset_mse, testset_pn, testset_sp, train_cvavg_MAE,
train_cvavg_MSE, train_cvavg_PN, train_cvavg_SP, feature_set,
len(feature_set)
]
column += list(test_pred)
return column
def test_models(library_name, xy_train_test, models=classes_to_test, print_results=False):
X_train, y_train, X_test, y_test = xy_train_test
results = []
for model, name in models:
model.fit(X_train, y_train.iloc[:, 0])
y_pred = model.predict(X_test).reshape(-1, 1)
r2 = r2_score(y_test, y_pred)
n, p = X_test.shape
r_adj = calculate_r2_adjusted_score(r2, n, p)
out = np.concatenate([X_test, y_test, y_pred], axis=1)
# out = pd.concat([pd.DataFrame(X_test), pd.DataFrame(y_test), pd.DataFrame(y_pred)], axis=1)
df = pd.DataFrame(out, columns=[* list(X_test), * list(y_test), "pred"])
m_e = mean_absolute_error(y_test, y_pred)
mean = y_test.mean(axis=0).mean()
mean_pred = y_pred.mean(axis=0).mean()
results += [{
"score": r2,
"score_adjusted": r_adj,
"parameters": list(X_test),
"library_name": library_name,
"model_name": name,
"data": df,
}]
if print_results:
print("{} : {} / {} ||| mean error : {} | mean : {} / {}".format(
name,
round(r2, 3),
round(r_adj, 3),
round(m_e, 3),
round(mean_pred, 3),
round(mean, 3),
))
return results
def score(
# n_estimators,
max_depth,
min_child_weight,
subsample,
gamma,
colsample_bytree):
params['max_depth'] = int(max_depth)
params['min_child_weight'] = min_child_weight
params['subsample'] = subsample
params['gamma'] = gamma
params['colsample_bytree'] = colsample_bytree
scores = []
for (dtrain, dtest) in ttsplits:
model = xgb.train(params, dtrain, 500)
# int(n_estimators))
y_pred = model.predict(dtest)
score = mean_absolute_error(dtest.get_label(), y_pred)
scores.append(score)
return -np.mean(score)
def Computar_estatisticas_ECDD(self, vetor_caracteristicas, lags, ELM):
'''
Metodo para computar a deteccao de mudanca do erro por meio do ECDD
:param vetor_caracteristicas: vetor com uma amostra da serie temporal que sera avaliada para verificar a mudanca
:param lags: quantidade de lags para modelar as entradas da RNA
:param enxame: enxame utilizado para verificar a mudanca
:return: retorna a media ou o comportamento do enxame em relacao ao vetor de caracteristicas
'''
#particionando o vetor de caracteristicas para usar para treinar
particao = Particionar_series(vetor_caracteristicas, divisao_dataset, lags)
[caracteristicas_entrada, caracteristicas_saida] = particao.Part_train()
#realizando as previsoes e armazenando as acuracias
predicao_caracteristica = ELM.Predizer(caracteristicas_entrada)
erros = []
for i in range(len(caracteristicas_saida)):
erro = mean_absolute_error(caracteristicas_saida[i:i+1], predicao_caracteristica[i:i+1])
erros.append(erro)
return np.mean(erros), np.std(erros)
def Computar_comportamento_atual(self, dados, real, enxame):
'''
Metodo para computar o comportamento para os dados atuais
:param dados: dados para realizar a previsao um passo a frente
:param enxame: enxame utilizado para verificar a mudanca
:return: retorna o comportamento para o instante atual
'''
#variavel para salvar as medias das predicoes
medias = []
#realizando as previsoes e armazenando as acuracias
for i in range(enxame.numero_particulas):
predicao_caracteristica = enxame.sensores[i].Predizer(dados)
MAE = mean_absolute_error(real, predicao_caracteristica)
medias.append(MAE)
#salvando a media e desvio padrao das acuracias
comportamento = [0] * 2
comportamento[0] = np.mean(medias)
comportamento[1] = np.std(medias)
return comportamento
def compile_results(self):
# compute the average absolute error and R^2 at each autoencoder dimension
avgAbsErrors = []
r2Values = []
for dim in MLParameterTuner.dims:
actualThenPredicted = np.loadtxt(str(self.get_path(dim) / 'actualThenPredicted.txt'))
avgAbsErrors.append(mean_absolute_error(actualThenPredicted[0], actualThenPredicted[1]))
r2Values.append(r2_score(actualThenPredicted[0], actualThenPredicted[1]))
# make plots with matplotlib
plt.plot(MLParameterTuner.dims, avgAbsErrors)
plt.ylim(0,20)
plt.title('ML pipeline tuning: scan over autoencoder dimension')
plt.xlabel('Latent representation dimension')
plt.ylabel('SVM cross validation avg absolute error')
plt.savefig(str(Path.home() / 'Desktop' / 'AvgAbsErrorVsDim.png'))
plt.gcf().clear()
plt.plot(MLParameterTuner.dims, r2Values)
plt.ylim(0,1)
plt.title('ML pipeline tuning: scan over autoencoder dimension')
plt.xlabel('Latent representation dimension')
plt.ylabel('SVM cross validation R^2')
plt.savefig(str(Path.home() / 'Desktop' / 'R2VsDim.png'))
def Funcao(self, posicao):
'''
Metodo para calcular a funcao objetivo do IDPSO, nesse caso a funcao e a previsao de um ELM
:param posicao: posicao seria os pesos da camada de entrada e os bias da rede ELM
:return: retorna o MSE obtido da previsao de uma ELM
'''
# instanciando um modelo ELM
ELM = ELMRegressor(self.qtd_neuronios)
# modelando a dimensao das particulas para serem usadas
posicao = posicao.reshape(self.linhas, self.qtd_neuronios)
# ELM treinando com a entrada e a saida do conjunto de treinamento e tambem com os pesos da particula
ELM.Treinar(self.dataset[0], self.dataset[1], posicao)
# Realizando a previsao para o conjunto de validacao
prediction_train = ELM.Predizer(self.dataset[2])
# computando o erro do conjunto de validacao
MAE_val = mean_absolute_error(self.dataset[3], prediction_train)
# retornando o erro do conjunto de validacao - forma de evitar o overfitting
return MAE_val
def Predizer(self, Entradas, num_sensor = None, Saidas = None, grafico = None):
'''
Metodo para realizar a previsao com a melhor particula (ELM) do enxame e apresentar o grafico de previsao
:param Entradas: padroes de entrada para realizar a previsao
:param Saidas: padroes de saida para computar o MSE
:param grafico: variavel booleana para ativar ou desativar o grafico de previsao
:return: Retorna a predicao para as entradas apresentadas. Se as entradas e saidas sao apresentadas o MSE e retornado
'''
# se o numero do sensor não é passado então a predição é feita com o gbest
if(num_sensor == None):
#retorna somente a previsao
if(Saidas == None):
prediction = self.best_elm.Predizer(Entradas)
return prediction
else:
prediction = self.best_elm.Predizer(Entradas)
MSE = mean_absolute_error(Saidas, prediction)
print('\n MSE: %s' %MSE)
#apresentar grafico
if(grafico == True):
plt.plot(Saidas, label = 'Real', color = 'Blue')
plt.plot(prediction, label = 'Previsão', color = 'Red')
plt.title('MSE: %s' %MSE)
plt.legend()
plt.tight_layout()
plt.show()
return MSE
else:
# realizando a previsao com o sensor passado
prediction = self.sensores[num_sensor].Predizer(Entradas)
return prediction
def main():
#importando o dataset
dtst = Datasets('dentro')
serie = dtst.Leitura_dados(dtst.bases_linear_graduais(3), csv=True)
particao = Particionar_series(serie, [0.0, 0.0, 0.0], 0)
serie = particao.Normalizar(serie)
# instanciando a memoria
memoria = LTM(1, 0.5)
# criando o primeiro modelo
serie1 = serie[:500]
enxame1 = IDPSO_ELM(serie1, [0.8, 0.2, 0], 5, 10)
enxame1.Treinar()
# criando o primeiro ambiente
ambiente1 = Ambiente(enxame1.particulas, enxame1.best_elm)
memoria.Adicionar_ambiente(ambiente1)
# criando o primeiro modelo
serie1 = serie[:500]
enxame1 = IDPSO_ELM(serie1, [0.8, 0.2, 0], 5, 10)
enxame1.Treinar()
# criando o primeiro ambiente
ambiente1 = Ambiente(enxame1.particulas, enxame1.best_elm)
memoria.Adicionar_ambiente(ambiente1)
# criando o primeiro modelo
serie1 = serie[:500]
enxame1 = IDPSO_ELM(serie1, [0.8, 0.2, 0], 5, 10)
enxame1.Treinar()
# criando o primeiro ambiente
ambiente1 = Ambiente(enxame1.particulas, enxame1.best_elm)
memoria.Adicionar_ambiente(ambiente1)
# criando o primeiro modelo
serie1 = serie[:500]
enxame1 = IDPSO_ELM(serie1, [0.8, 0.2, 0], 5, 10)
enxame1.Treinar()
# criando o primeiro ambiente
ambiente1 = Ambiente(enxame1.particulas, enxame1.best_elm)
memoria.Adicionar_ambiente(ambiente1)
# criando o segundo modelo
serie2 = serie[500:1000]
enxame2 = IDPSO_ELM(serie2, [0.8, 0.2, 0], 5, 10)
enxame2.Treinar()
# criando o segundo ambiente
ambiente2 = Ambiente(enxame2.particulas, enxame2.best_elm)
memoria.Adicionar_ambiente(ambiente2)
# criando o segundo modelo
serie3 = serie[0:500]
enxame3 = IDPSO_ELM(serie3, [0.8, 0.2, 0], 5, 10)
enxame3.Treinar()
# criando o segundo ambiente
ambiente3 = Ambiente(enxame3.particulas, enxame3.best_elm)
memoria.Adicionar_ambiente(ambiente3)
# relembrando um modelo passado
serie4 = serie[1500:2000]
enxame3 = memoria.Relembrar_ambiente(enxame3, serie4, 5)
# criando o segundo modelo
serie5 = serie[2000:2500]
enxame4 = IDPSO_ELM(serie5, [0.8, 0.2, 0], 5, 10)
enxame4.Treinar()
# avaliando as particulas para um determinado conceito, atualiza o gbest se tiver uma particula melhor
serie6 = serie[2500:3000]
particao = Particionar_series(serie6, [1, 0, 0], 5)
[dados_x, dados_y] = particao.Part_train()
memoria.Avaliar_particulas(enxame1, serie6, 5)
previsao = enxame1.Predizer(dados_x)
mae = mean_absolute_error(dados_y, previsao)
print("\ngbest anterior - mae: ", mae)
best_model = memoria.Avaliar_particulas(enxame1, serie6, 5)
enxame1.Atualizar_bestmodel(best_model)
previsao = enxame1.Predizer(dados_x)
mae = mean_absolute_error(dados_y, previsao)
print("gbest posterior - mae: ", mae)
def Relembrar_ambiente(self, enxame_atual, dados, lags):
'''
metodo para relembrar um ambiente, caso o enxame não seja suficiente retreina a partir da melhor solução
:param: enxame_atual: enxame atual que será substituido
:param: dados: dados para avaliar a acuracia dos modelos armazenados
:param: lags: quantidade de lags para modelar os dados de entrada da rede
:return: retorna o melhor enxame para os dados passados
'''
#return enxame_atual.best_elm
particao = Particionar_series(dados, [1, 0, 0], lags)
[dados_x, dados_y] = particao.Part_train()
#print("Quantidade de dados para treinamento: ", len(dados_y))
acuracias = []
if(self.qtd_memoria != 0):
for i in self.vetor_ambientes:
previsao = i.gbest.Predizer(dados_x)
acuracias.append(mean_absolute_error(dados_y, previsao))
#print("Acuracias: ", acuracias)
previsao = enxame_atual.Predizer(dados_x)
erro_atual = mean_absolute_error(dados_y, previsao)
#print("Acuracia do modelo atual: ", erro_atual)
j = np.argmin(acuracias)
#print("Acuracia do melhor modelo da memória: ", acuracias[j])
if(acuracias[j] < erro_atual):
#print("Trocou de solução [", j, "]: ", acuracias[j])
#enxame_atual.particulas = copy.deepcopy(self.vetor_ambientes[j].particulas)
#enxame_atual.Atualizar_bestmodel(self.vetor_ambientes[j].gbest)
#print("Comparacao modelos: ", enxame_atual.best_elm == self.vetor_ambientes[j].gbest)
'''
# plotando erro
j = j+1
acuracias = [erro_atual] + acuracias
colors = ['blue'] * len(acuracias)
colors[0] = 'green'
colors[j] = 'red'
sequencia = range(0, len(acuracias))
barras = plt.bar(sequencia, acuracias, 0.6, align='center', color = colors)
plt.title('Solutions in memory')
plt.ylabel('MAE')
plt.xlabel('Solutions')
plt.xticks(range(len(acuracias)))
limiar = min(acuracias) * 0.6
plt.axis([-1, len(acuracias), min(acuracias) - limiar, max(acuracias) + (2*limiar)])
rects = barras.patches
# Now make some labels
height = rects[0].get_height()
plt.text(rects[0].get_x() + rects[0].get_width()/2, height+(limiar/2), 'Current', ha='center', va='bottom', rotation='vertical')
height = rects[j].get_height()
plt.text(rects[j].get_x() + rects[j].get_width()/2, height+(limiar/2), 'Min error', ha='center', va='bottom', rotation='vertical')
plt.legend()
plt.show()
'''
return self.vetor_ambientes[j].gbest
else:
return enxame_atual.best_elm
def Executar(self, grafico = None):
'''
Metodo para executar o procedimento do algoritmo
:param grafico: variavel booleana para ativar ou desativar o grafico
:return: retorna 5 variaveis: [falsos_alarmes, atrasos, falta_deteccao, MAPE, tempo_execucao]
'''
################################################################################################################################################
################################# CONFIGURACAO DO DATASET ######################################################################################
################################################################################################################################################
#dividindo os dados da dataset dinamica para treinamento_inicial inicial e para uso do stream dinâmico
treinamento_inicial = self.dataset[0:self.n]
stream = self.dataset[self.n:]
################################################################################################################################################
################################# PERIODO ESTATICO #############################################################################################
################################################################################################################################################
#criando e treinando um modelo_vigente para realizar as previsões
enxame = IDPSO_ELM(treinamento_inicial, divisao_dataset, self.lags, self.qtd_neuronios)
enxame.Parametros_IDPSO(it, self.numero_particulas, inercia_inicial, inercia_final, c1, c2, xmax, crit_parada)
enxame.Treinar()
#ajustando com os dados finais do treinamento a janela de predicao
janela_predicao = Janela()
janela_predicao.Ajustar(enxame.dataset[0][(len(enxame.dataset[0])-1):])
predicao = enxame.Predizer(janela_predicao.dados)
#janela com o atual conceito, tambem utilizada para armazenar os dados de retreinamento
janela_caracteristicas = Janela()
janela_caracteristicas.Ajustar(treinamento_inicial)
# instanciando a janela de alerta para quando acontecer
janela_alerta = Janela()
janela_alerta.Ajustar(janela_predicao.dados_mais)
#ativando os sensores de acordo com a primeira janela de caracteristicas
s = S(self.qtd_sensores, self.w, self.c)
s.armazenar_conceito(janela_caracteristicas.dados, self.lags, enxame)
#instanciando a classe LTM
memoria = LTM(0, 0)
#gerar imagem
#memoria.Avaliar_particulas(enxame, janela_caracteristicas.dados, self.lags)
################################################################################################################################################
################################# PERIODO DINAMICO #############################################################################################
################################################################################################################################################
#variavel para armazenar o erro do stream
erro_stream = 0
#variavel para armazenar as deteccoes
deteccoes = []
#variavel para armazenar os alarmes
alarmes = []
#variavel para armazenar o tempo inicial
start_time = time.time()
#vetor para armazenar a predicoes_vetor
if(grafico):
predicoes_vetor = [None] * len(stream)
erro_stream_vetor = [None] * len(stream)
#variavel auxiliar
mudanca_ocorreu = False
alerta_ocorreu = False
#entrando no stream de dados
for i in range(1, len(stream)):
#computando o erro
loss = mean_absolute_error(stream[i:i+1], predicao)
erro_stream += loss
#adicionando o novo dado a janela de predicao
janela_predicao.Add_janela(stream[i])
#realizando a nova predicao com a nova janela de predicao
predicao = enxame.Predizer(janela_predicao.dados)
# salvando o erro e predicao
if(grafico):
#salvando o erro
erro_stream_vetor[i] = loss
#salvando a predicao
predicoes_vetor[i] = predicao
#print("[", i, "]")
# se mudança ocorreu entra aqui
if(mudanca_ocorreu == False):
#verificando os sensores
mudou = s.monitorar(loss, i, True)
# se aconteceu uma mudanca entra
if(mudou):
if(grafico == True):
print("[%d] Mudança" % (i))
deteccoes.append(i)
#zerando a janela de treinamento
janela_caracteristicas.Zerar_Janela()
#atualizando o melhor modelo pela melhor particula do enxame
best_model = memoria.Avaliar_particulas(enxame, janela_alerta.dados, self.lags)
enxame.Atualizar_bestmodel(best_model)
#variavel para alterar o fluxo, ir para o periodo de retreinamento
mudanca_ocorreu = True
alerta_ocorreu = False
# se estiver em estado de alerta começa a guardar dados
if(alerta_ocorreu):
# adicionando os dados a janela
janela_alerta.Increment_Add(stream[i])
# se a jenela de alerta tiver n dadms, entao ja e possivel retreinar
if(len(janela_alerta.dados) > (self.n/2)):
# zerando a janela de alerta
janela_alerta.Ajustar(janela_predicao.dados_mais[0])
# se nao mudou entra
else:
# verificando se está em estado de alerta
alerta = s.monitorar_gbest()
if(alerta):
if(grafico):
print("[%d] Alarme" % (i))
alarmes.append(i)
# ativando o botao de alerta para comecar a armazenar dados
alerta_ocorreu = True
# adicionando a primeira janela aos dados
janela_alerta.Ajustar(janela_predicao.dados_mais[0])
else:
#print("[", i, "] - atualizando gbest, dados: ", len(janela_alerta.dados))
# atualizar a cada time step o gbest
best_model = memoria.Avaliar_particulas(enxame, janela_alerta.dados, self.lags)
enxame.Atualizar_bestmodel(best_model)
# coletando dados ate ter suficiente para retreinar
if(len(janela_caracteristicas.dados) < self.n):
#adicionando a nova instancia na janela de caracteristicas
janela_caracteristicas.Increment_Add(stream[i])
#adicionando a nova instancia na janela de alerta
janela_alerta.Increment_Add(stream[i])
# se a jenela de alerta tiver n dadom, entao ja e possivel retreinar
if(len(janela_alerta.dados) >= self.n):
# atualizando a janela de caracteristicas
janela_caracteristicas.Ajustar(janela_alerta.dados)
# zerando a janela de alerta
janela_alerta.Ajustar(janela_predicao.dados_mais[0])
# dados de retreinamento coletados entao
else:
#atualizando o modelo_vigente preditivo
enxame = IDPSO_ELM(janela_caracteristicas.dados, divisao_dataset, self.lags, self.qtd_neuronios)
enxame.Parametros_IDPSO(it, self.numero_particulas, inercia_inicial, inercia_final, c1, c2, xmax, crit_parada)
enxame.Treinar()
#ajustando com os dados finais do treinamento a janela de predicao
janela_predicao = Janela()
janela_predicao.Ajustar(enxame.dataset[0][(len(enxame.dataset[0])-1):])
predicao = enxame.Predizer(janela_predicao.dados)
#ativando os sensores de acordo com a primeira janela de caracteristicas
s = S(self.qtd_sensores, self.w, self.c)
s.armazenar_conceito(janela_caracteristicas.dados, self.lags, enxame)
#variavel para voltar para o loop principal
mudanca_ocorreu = False
#variavel para armazenar o tempo final
end_time = time.time()
#computando as metricas de deteccao
mt = Metricas_deteccao()
[falsos_alarmes, atrasos] = mt.resultados(stream, deteccoes, self.n)
#computando a acuracia da previsao ao longo do fluxo de dados
MAE = erro_stream/len(stream)
#computando o tempo de execucao
tempo_execucao = (end_time-start_time)
if(grafico == True):
tecnica = "P-IDPSO-ELM-SV"
print(tecnica)
print("Alarmes:")
print(alarmes)
print("Deteccoes:")
print(deteccoes)
print("Falsos Alarmes: ", falsos_alarmes)
print("Atrasos: ", atrasos)
print("MAE: ", MAE)
print("Tempo de execucao: ", tempo_execucao)
#plotando o grafico de erro
if(grafico == True):
g = Grafico()
g.Plotar_graficos(stream, predicoes_vetor, deteccoes, alarmes, erro_stream_vetor, self.n, atrasos, falsos_alarmes, tempo_execucao, MAE, nome=tecnica)
#retorno do metodo
return falsos_alarmes, atrasos, MAE, tempo_execucao
MAE_list = []
for z in range(10):
# instanciando o método IDPSO-ELM
idpso_elm = IDPSO_ELM(serie, divisao_dataset, janela_tempo, qtd_neuronis)
idpso_elm.Parametros_IDPSO(it, particulas, inercia_inicial[j], inercia_final[k], c1, c2, xmax[i], crit)
idpso_elm.Treinar()
# organizando os dados para comparacao #
train_x, train_y = idpso_elm.dataset[0], idpso_elm.dataset[1]
val_x, val_y = idpso_elm.dataset[2], idpso_elm.dataset[3]
test_x, test_y = idpso_elm.dataset[4], idpso_elm.dataset[5]
################################## computando a previsao para o conjunto de validacao ################################
previsao = idpso_elm.Predizer(val_x)
MAE = mean_absolute_error(val_y, previsao)
MAE_list.append(MAE)
cont += 1
media = np.mean(MAE_list)
print(cont, 'Media MAE: ', MAE)
if(erro_best > media):
erro_best = MAE
xmax_best = i
inercia_inicial_best = j
inercia_final_best = k
###################################################################################
print("Erro best: ", erro_best)
def Executar(self, grafico = None):
'''
Metodo para executar o procedimento do algoritmo
:param grafico: variavel booleana para ativar ou desativar o grafico
:return: retorna 5 variaveis: [falsos_alarmes, atrasos, falta_deteccao, MAPE, tempo_execucao]
'''
################################################################################################################################################
################################# CONFIGURACAO DO DATASET ######################################################################################
################################################################################################################################################
#dividindo os dados da dataset dinamica para treinamento_inicial inicial e para uso do stream din�mico
treinamento_inicial = self.dataset[0:self.n]
stream = self.dataset[self.n:]
################################################################################################################################################
################################# PERIODO ESTATICO #############################################################################################
################################################################################################################################################
#criando e treinando um enxame_vigente para realizar as previsoes
ELM = ELMRegressor(self.qtd_neuronios)
ELM.Tratamento_dados(treinamento_inicial, divisao_dataset, self.lags)
ELM.Treinar(ELM.train_entradas, ELM.train_saidas)
#ajustando com os dados finais do treinamento a janela de predicao
janela_predicao = Janela()
janela_predicao.Ajustar(ELM.train_entradas[len(ELM.train_entradas)-1:])
predicao = ELM.Predizer(janela_predicao.dados)
#janela com o atual conceito, tambem utilizada para armazenar os dados de retreinamento
janela_caracteristicas = Janela()
janela_caracteristicas.Ajustar(treinamento_inicial)
################################################################################################################################################
################################# PERIODO DINAMICO #############################################################################################
################################################################################################################################################
#variavel para armazenar o erro do stream
erro_stream = 0
#variavel para armazenar as deteccoes
deteccoes = []
#variavel para armazenar os alarmes
alarmes = []
#variavel para armazenar o tempo inicial
start_time = time.time()
#vetor para armazenar a predicoes_vetor
if(grafico == True):
predicoes_vetor = [None] * len(stream)
erro_stream_vetor = [None] * len(stream)
#entrando no stream de dados
for i in range(1, len(stream)):
#computando o erro
loss = mean_absolute_error(stream[i:i+1], predicao)
erro_stream += loss
#adicionando o novo dado a janela de predicao
janela_predicao.Add_janela(stream[i])
#realizando a nova predicao com a nova janela de predicao
predicao = ELM.Predizer(janela_predicao.dados)
#
if(grafico == True):
#salvando o erro
erro_stream_vetor[i] = loss
#salvando a predicao
predicoes_vetor[i] = predicao
#variavel para armazenar o tempo final
end_time = time.time()
#computando as metricas de deteccao
mt = Metricas_deteccao()
deteccoes.append(-500)
[falsos_alarmes, atrasos] = mt.resultados(stream, deteccoes, self.n)
#computando a acuracia da previsao ao longo do fluxo de dados
MAE = erro_stream/len(stream)
#computando o tempo de execucao
tempo_execucao = (end_time-start_time)
if(grafico == True):
tecnica = "ELM"
print(tecnica)
print("Alarmes:")
print(alarmes)
print("Deteccoes:")
print(deteccoes)
print("Falsos Alarmes: ", falsos_alarmes)
print("Atrasos: ", atrasos)
print("MAE: ", MAE)
print("Tempo de execucao: ", tempo_execucao)
#plotando o grafico de erro
if(grafico == True):
g = Grafico()
deteccoes.append(-500)
g.Plotar_graficos(stream, predicoes_vetor, deteccoes, alarmes, erro_stream_vetor, self.n, atrasos, falsos_alarmes, tempo_execucao, MAE, nome=tecnica)
#retorno do metodo
return falsos_alarmes, atrasos, MAE, tempo_execucao
def Executar(self, grafico = None):
'''
Metodo para executar o procedimento do algoritmo
:param grafico: variavel booleana para ativar ou desativar o grafico
:return: retorna 5 variaveis: [falsos_alarmes, atrasos, falta_deteccao, MAPE, tempo_execucao]
'''
################################################################################################################################################
################################# CONFIGURACAO DO DATASET ######################################################################################
################################################################################################################################################
#dividindo os dados da dataset dinamica para treinamento_inicial inicial e para uso do stream din�mico
treinamento_inicial = self.dataset[0:self.n]
stream = self.dataset[self.n:]
################################################################################################################################################
################################# PERIODO ESTATICO #############################################################################################
################################################################################################################################################
#criando e treinando um enxame_vigente para realizar as previsoes
ELM = ELMRegressor(self.qtd_neuronios)
ELM.Tratamento_dados(treinamento_inicial, divisao_dataset, self.lags)
ELM.Treinar(ELM.train_entradas, ELM.train_saidas)
#ajustando com os dados finais do treinamento a janela de predicao
janela_predicao = Janela()
janela_predicao.Ajustar(ELM.train_entradas[len(ELM.train_entradas)-1:])
predicao = ELM.Predizer(janela_predicao.dados)
#janela com o atual conceito, tambem utilizada para armazenar os dados de retreinamento
janela_caracteristicas = Janela()
janela_caracteristicas.Ajustar(treinamento_inicial)
#atualizar por ECDD
[MI0, SIGMA0] = self.Computar_estatisticas_ECDD(janela_caracteristicas.dados, self.lags, ELM)
ecdd = ECDD(self.Lambda, self.w, self.c)
ecdd.armazenar_conceito(MI0, SIGMA0)
################################################################################################################################################
################################# PERIODO DINAMICO #############################################################################################
################################################################################################################################################
#variavel para armazenar o erro do stream
erro_stream = 0
#variavel para armazenar as deteccoes
deteccoes = []
#variavel para armazenar os alarmes
alarmes = []
#variavel para armazenar o tempo inicial
start_time = time.time()
#vetor para armazenar a predicoes_vetor
if(grafico == True):
predicoes_vetor = [None] * len(stream)
erro_stream_vetor = [None] * len(stream)
#variavel auxiliar
mudanca_ocorreu = False
#entrando no stream de dados
for i in range(1, len(stream)):
#computando o erro
loss = mean_absolute_error(stream[i:i+1], predicao)
erro_stream += loss
#adicionando o novo dado a janela de predicao
janela_predicao.Add_janela(stream[i])
#realizando a nova predicao com a nova janela de predicao
predicao = ELM.Predizer(janela_predicao.dados)
if(grafico == True):
#salvando o erro
erro_stream_vetor[i] = loss
#salvando a predicao
predicoes_vetor[i] = predicao
if(mudanca_ocorreu == False):
#atualizando o media_zt e desvio_zt
ecdd.atualizar_ewma(loss, i)
#monitorando o erro
string_ecdd = ecdd.monitorar()
#verificar se houve mudanca
if(string_ecdd == ecdd.alerta):
if(grafico == True):
print("[%d] Alarme" % (i))
alarmes.append(i)
if(string_ecdd == ecdd.mudanca):
if(grafico == True):
print("[%d] Detectou uma mudanca" % (i))
deteccoes.append(i)
#zerando a janela de treinamento
janela_caracteristicas.Zerar_Janela()
mudanca_ocorreu = True
else:
if(len(janela_caracteristicas.dados) < self.n):
#adicionando a nova instancia na janela de caracteristicas
janela_caracteristicas.Increment_Add(stream[i])
else:
#atualizando o enxame_vigente preditivo
ELM = ELMRegressor(self.qtd_neuronios)
ELM.Tratamento_dados(janela_caracteristicas.dados, divisao_dataset, self.lags)
ELM.Treinar(ELM.train_entradas, ELM.train_saidas)
#ajustando a janela de previsao
janela_predicao = Janela()
janela_predicao.Ajustar(ELM.train_entradas[len(ELM.train_entradas)-1:])
predicao = ELM.Predizer(janela_predicao.dados)
#atualizar por ECDD
[MI0, SIGMA0] = self.Computar_estatisticas_ECDD(janela_caracteristicas.dados, self.lags, ELM)
ecdd = ECDD(self.Lambda, self.w, self.c)
ecdd.armazenar_conceito(MI0, SIGMA0)
#variavel para voltar para o loop principal
mudanca_ocorreu = False
#variavel para armazenar o tempo final
end_time = time.time()
#computando as metricas de deteccao
mt = Metricas_deteccao()
[falsos_alarmes, atrasos] = mt.resultados(stream, deteccoes, self.n)
#computando a acuracia da previsao ao longo do fluxo de dados
MAE = erro_stream/len(stream)
#computando o tempo de execucao
tempo_execucao = (end_time-start_time)
if(grafico == True):
tecnica = "ELM-ECDD"
print(tecnica)
print("Alarmes:")
print(alarmes)
print("Deteccoes:")
print(deteccoes)
print("Falsos Alarmes: ", falsos_alarmes)
print("Atrasos: ", atrasos)
print("MAE: ", MAE)
print("Tempo de execucao: ", tempo_execucao)
#plotando o grafico de erro
if(grafico == True):
g = Grafico()
g.Plotar_graficos(stream, predicoes_vetor, deteccoes, alarmes, erro_stream_vetor, self.n, atrasos, falsos_alarmes, tempo_execucao, MAE, nome=tecnica)
#retorno do metodo
return falsos_alarmes, atrasos, MAE, tempo_execucao
def projectexample_modelling(series, model_name, parameters):
""" Function that performs the following plots
shape of the series
the first items
:params series: univariate time series
:type series: dataframe
:return:
- error (int): variable with error code
"""
# modelling
error = 0
try:
print("{} time series modelling".format('-' * 20))
print("{} {} model".format('-' * 20, model_name))
if model_name=='SARIMAX':
p = parameters[0]
d = parameters[1]
q = parameters[2]
P = parameters[3]
D = parameters[4]
Q = parameters[5]
S = parameters[6]
t = parameters[7]
print("{} fitting model".format('-' * 20))
# fit the model
model = SARIMAX(series.values,
trend = t,
order = (p, d, q),
seasonal_order = (P, D, Q, S),
enforce_stationarity = False,
enforce_invertibility = False).fit()
# Model summary
print("{} Model summary".format('-' * 20))
print(model.summary().tables[1])
# Model diagnostic
print("{} Model diagnostic".format('-' * 20))
fig = model.plot_diagnostics(figsize=(20, 12))
fig.savefig(os.path.join(os.getcwd(), 'figures\\diagnostic_{}.png'.format(model_name)))
fig.show()
except Exception as exception_msg:
print('{} (!) Error in projectexample_modelling: '.format('-' * 20) + str(exception_msg))
error = 1
model = []
return model, error
# Metrics
print("{} Metrics".format('-' * 20))
try:
# Regression metrics
y_fitted = model.predict()
R2 = round(r2_score(series, y_fitted), 3)
MAE = round(mean_absolute_error(series, y_fitted), 3)
RMSE = round(np.sqrt(mean_squared_error(series, y_fitted)), 3)
print("{} R2: {}".format('-' * 20, R2))
print("{} MAE: {}".format('-' * 20, MAE))
print("{} RMSE: {}".format('-' * 20, RMSE))
except Exception as exception_msg:
print('{} (!) Error in projectexample_modelling (metrics): '.format('-' * 20) + str(exception_msg))
error = 2
return model, error
return model, error
def validate(y_true, y_pred):
print 'Kolmogorov-Smirnov test = ', ks_2samp(y_true, y_pred)
print 'mean_squared_error = ', mean_squared_error(y_true, y_pred)
print 'mean_absolute_error = ', mean_absolute_error(y_true, y_pred)
print 'r2_score = ', r2_score(y_true, y_pred)
"""TBD compute the log-loss to consider boolean"""
print "log_loss = " + str(log_loss(y_true, y_pred)) #Log loss, aka logistic loss or cross-entropy loss.
precision, recall, thresholds = precision_recall_curve(y_true, y_pred) #Compute precision-recall pairs for different probability thresholds
#print "precision = " + str(precision)
#print "recall = " + str(recall)
#print "thresholds = " + str(thresholds)
average_precision = average_precision_score(y_true, y_pred) #Compute average precision (AP) from prediction scores
print "average_precision_score = ", average_precision
##############################################################################
# Plot of a ROC curve for a specific class
plt.figure()
plt.plot(precision, recall, label='AUC = %0.2f' % average_precision)
plt.plot([0, 1], [0, 1], 'k--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.title('Precision-Recall Curve')
plt.legend(loc="lower right")
plt.show()
##############################################################################
fpr, tpr, thresholds = roc_curve(y_true, y_pred) #Compute Receiver operating characteristic (ROC)
print "fpr = " + str(fpr)
print "tpr = " + str(tpr)
print "thresholds = " + str(thresholds)
print "roc_auc_score = " + str(roc_auc_score(y_true, y_pred)) #Compute Area Under the Curve (AUC) from prediction scores
roc_auc = auc(fpr, tpr)
##############################################################################
# Plot of a ROC curve for a specific class
plt.figure()
plt.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], 'k--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic ')
plt.legend(loc="lower right")
plt.show()
##############################################################################
##print "pearsonr = " + str(pearsonr(np.array(y_true), np.array(y_pred)))
##print "spearmanr = " + str(spearmanr(np.array(y_true), np.array(y_pred)))
##print matthews_corrcoef(y_true, y_pred) #Compute the Matthews correlation coefficient (MCC) for binary classes
##print confusion_matrix(y_true, y_pred) #Compute confusion matrix to evaluate the accuracy of a classification
##print accuracy_score(y_true, y_pred) #Accuracy classification score.
##print classification_report(y_true, y_pred) #Build a text report showing the main classification metrics
##print f1_score(y_true, y_pred) #Compute the F1 score, also known as balanced F-score or F-measure
##print fbeta_score(y_true, y_pred) #Compute the F-beta score
##print hamming_loss(y_true, y_pred) #Compute the average Hamming loss.
##print jaccard_similarity_score(y_true, y_pred) #Jaccard similarity coefficient score
##print precision_recall_fscore_support(y_true, y_pred) #Compute precision, recall, F-measure and support for each class
##print precision_score(y_true, y_pred) #Compute the precision
##print recall_score(y_true, y_pred) #Compute the recall
##print zero_one_loss(y_true, y_pred) #Zero-one classification loss.
##print "hinge_loss = " + str(hinge_loss(y_true, y_pred)) #Average hinge loss (non-regularized)
return
# Separate output from inputs
y_train = data_df['time_to_failure']
x_train_seg = data_df['segment_id']
x_train = data_df.drop(['time_to_failure', 'segment_id'], axis=1)
svReg = SVR(C=9137.08647605824366,
cache_size=200,
coef0=0.0,
degree=2,
epsilon=0.001,
gamma=0.586414861763494,
kernel='rbf',
max_iter=-1,
shrinking=True,
tol=0.001,
verbose=True)
svReg.fit(x_train, y_train)
# Create an variable to pickle and open it in write mode
mh = ModelHolder(svReg, most_dependent_columns)
mh.save(model_name)
svReg = None
mh_new = load_model(model_name)
svReg, most_dependent_columns = mh_new.get()
y_pred = svReg.predict(x_train)
mas = mean_absolute_error(y_train, y_pred)
print('Mean Absolute Error', mas)
def Executar(self, grafico = None):
'''
Metodo para executar o procedimento do algoritmo
:param grafico: variavel booleana para ativar ou desativar o grafico
:return: retorna 5 variaveis: [falsos_alarmes, atrasos, falta_deteccao, MAPE, tempo_execucao]
'''
################################################################################################################################################
################################# CONFIGURACAO DO DATASET ######################################################################################
################################################################################################################################################
#dividindo os dados da dataset dinamica para treinamento_inicial inicial e para uso do stream dinâmico
treinamento_inicial = self.dataset[0:self.n]
stream = self.dataset[self.n:]
################################################################################################################################################
################################# PERIODO ESTATICO #############################################################################################
################################################################################################################################################
#criando e treinando um enxame_vigente para realizar as previsões
enxame = IDPSO_ELM(treinamento_inicial, divisao_dataset, self.lags, self.qtd_neuronios)
enxame.Parametros_IDPSO(it, self.numero_particulas, inercia_inicial, inercia_final, c1, c2, xmax, crit_parada)
enxame.Treinar()
#ajustando com os dados finais do treinamento a janela de predicao
janela_predicao = Janela()
janela_predicao.Ajustar(enxame.dataset[0][(len(enxame.dataset[0])-1):])
predicao = enxame.Predizer(janela_predicao.dados)
#janela com o atual conceito, tambem utilizada para armazenar os dados de retreinamento
janela_caracteristicas = Janela()
janela_caracteristicas.Ajustar(treinamento_inicial)
#ativando o sensor de comportamento de acordo com a primeira janela de caracteristicas para media e desvio padrão
b = B(self.limite, self.w, self.c)
b.armazenar_conceito(janela_caracteristicas.dados, self.lags, enxame)
################################################################################################################################################
################################# PERIODO DINAMICO #############################################################################################
################################################################################################################################################
#variavel para armazenar o erro do stream
erro_stream = 0
#variavel para armazenar as deteccoes
deteccoes = []
#variavel para armazenar os alarmes
alarmes = []
#variavel para armazenar o tempo inicial
start_time = time.time()
#vetor para armazenar a predicoes_vetor
if(grafico == True):
predicoes_vetor = [None] * len(stream)
erro_stream_vetor = [None] * len(stream)
#variavel auxiliar
mudanca_ocorreu = False
#entrando no stream de dados
for i in range(1, len(stream)):
#computando o erro
loss = mean_absolute_error(stream[i:i+1], predicao)
erro_stream += loss
#adicionando o novo dado a janela de predicao
janela_predicao.Add_janela(stream[i])
#realizando a nova predicao com a nova janela de predicao
predicao = enxame.Predizer(janela_predicao.dados)
if(grafico == True):
#salvando o erro
erro_stream_vetor[i] = loss
#salvando a predicao
predicoes_vetor[i] = predicao
if(mudanca_ocorreu == False):
#computando o comportamento para a janela de predicao, para somente uma instancia - media e desvio padrão
mudou = b.monitorar(janela_predicao.dados, stream[i:i+1], enxame, i)
if(mudou == True):
if(grafico == True):
print("[%d] Detectou uma mudança" % (i))
deteccoes.append(i)
#zerando a janela de treinamento
janela_caracteristicas.Zerar_Janela()
#variavel para alterar o fluxo, ir para o periodo de retreinamento
mudanca_ocorreu = True
else:
if(len(janela_caracteristicas.dados) < self.n):
#adicionando a nova instancia na janela de caracteristicas
janela_caracteristicas.Increment_Add(stream[i])
else:
#atualizando o enxame_vigente preditivo
enxame = IDPSO_ELM(janela_caracteristicas.dados, divisao_dataset, self.lags, self.qtd_neuronios)
enxame.Parametros_IDPSO(it, self.numero_particulas, inercia_inicial, inercia_final, c1, c2, xmax, crit_parada)
enxame.Treinar()
#ajustando com os dados finais do treinamento a janela de predicao
janela_predicao = Janela()
janela_predicao.Ajustar(enxame.dataset[0][(len(enxame.dataset[0])-1):])
predicao = enxame.Predizer(janela_predicao.dados)
# atualizando o conceito para a caracteristica de comportamento
b = B(self.limite, self.w, self.c)
b.armazenar_conceito(janela_caracteristicas.dados, self.lags, enxame)
#variavel para voltar para o loop principal
mudanca_ocorreu = False
#variavel para armazenar o tempo final
end_time = time.time()
#computando as metricas de deteccao
mt = Metricas_deteccao()
[falsos_alarmes, atrasos] = mt.resultados(stream, deteccoes, self.n)
#computando a acuracia da previsao ao longo do fluxo de dados
MAE = erro_stream/len(stream)
#computando o tempo de execucao
tempo_execucao = (end_time-start_time)
if(grafico == True):
tecnica = "IDPSO_ELM_B"
print(tecnica)
print("Alarmes:")
print(alarmes)
print("Deteccoes:")
print(deteccoes)
print("Falsos Alarmes: ", falsos_alarmes)
print("Atrasos: ", atrasos)
print("MAE: ", MAE)
print("Tempo de execucao: ", tempo_execucao)
#plotando o grafico de erro
if(grafico == True):
g = Grafico()
g.Plotar_graficos(stream, predicoes_vetor, deteccoes, alarmes, erro_stream_vetor, self.n, atrasos, falsos_alarmes, tempo_execucao, MAE, nome=tecnica)
#retorno do metodo
y.append(data[i + lag])
return np.array(X), np.array(y)
lag = 3
X_train, y_train = create_sliding_windows(train, lag)
y_train = np.reshape(y_train, (len(y_train), 1))
X_val, y_val = create_sliding_windows(validation, lag)
X_test, y_test = create_sliding_windows(test, lag)
# Training
regressor = SupervisedDBNRegression(hidden_layers_structure=[30, 40],
learning_rate_rbm=0.001,
learning_rate=0.001,
n_epochs_rbm=30,
n_iter_backprop=100,
batch_size=32,
activation_function='relu',
dropout_p=0.2)
regressor.fit(X_train, y_train)
# Save the model
regressor.save('model.pkl')
# Restore it
regressor = SupervisedDBNRegression.load('model.pkl')
# Test
y_pred = regressor.predict(X_test)
print('Done.\nMAE: %f' % mean_absolute_error(y_test, y_pred))
axes=(28, 14),
angle=0,
startAngle=0,
endAngle=360,
color=(255, 255, 255),
thickness=-1)
result = np.bitwise_and(image, mask)
result = result[14:64 - 14, :]
return result
testSamples, testLabels = load_images("eye_left")
model = load_model("model.01-45.01.h5") ### add the correct model name!!!
predictions = model.predict(testSamples)
results = np.zeros((800, 1500, 3))
# create an image with current predictions
for i in range(testSamples.shape[0]):
cv2.circle(results, (int(testLabels[i, 0]), int(testLabels[i, 1])), 10,
(0, 255, 0), 2)
cv2.circle(results, (int(predictions[i, 0]), int(predictions[i, 1])), 10,
(255, 0, 0), 2)
cv2.line(results, (int(predictions[i, 0]), int(predictions[i, 1])),
(int(testLabels[i, 0]), int(testLabels[i, 1])), (255, 0, 0), 2)
cv2.imwrite("test_model.jpg", results)
print("Final MAE: {}".format(mean_absolute_error(testLabels, predictions)))
input("")
from sklearn.ensemble.weight_boosting import AdaBoostRegressor
from sklearn.model_selection._split import train_test_split
tl = TrendLine(data_type='train')
data_df = tl.get()
train_set, test_set = train_test_split(data_df,
test_size=0.2,
random_state=np.random.randint(1, 1000))
y_train = train_set['time_to_failure']
x_train_seg = train_set['segment_id']
x_train = train_set.drop(['time_to_failure', 'segment_id'], axis=1)
y_test = test_set['time_to_failure']
x_test_seg = test_set['segment_id']
x_test = test_set.drop(['time_to_failure', 'segment_id'], axis=1)
adbReg = AdaBoostRegressor(n_estimators=50,
learning_rate=1.0,
loss='linear',
random_state=42)
adbReg.fit(x_train, y_train)
y_pred = adbReg.predict(x_test)
# y_pred = x_train.mean(axis=1)
print('MAE Score for acerage ', mean_absolute_error(y_test, y_pred))
def mae(x, y):
return mean_absolute_error(x, y)
pso_elm.Treinar()
# organizando os dados para comparacao #
train_x, train_y = idpso_elm.dataset[0], idpso_elm.dataset[1]
val_x, val_y = idpso_elm.dataset[2], idpso_elm.dataset[3]
test_x, test_y = idpso_elm.dataset[4], idpso_elm.dataset[5]
################################## computando a previsao para o conjunto de treinamento ################################
plt.plot(train_y, label = "Real")
print("\n------------------------------------------")
previsao = idpso_elm.Predizer(train_x)
MAE = mean_absolute_error(train_y, previsao)
plt.plot(previsao, label = "Previsao IDPSO-ELM: " + str(MAE))
print('IDPSO_ELM - Train MAE: ', MAE)
previsao = elm.Predizer(train_x)
MAE = mean_absolute_error(train_y, previsao)
plt.plot(previsao, label = "Previsao ELM: " + str(MAE))
print('ELM - Train MAE: ', MAE)
previsao = pso_slfn.Predizer(train_x)
MAE = mean_absolute_error(train_y, previsao)
plt.plot(previsao, label = "Previsao PSO_SLFN: " + str(MAE))
print('PSO_SLFN - Train MAE: ', MAE)
def main():
#load da serie
dtst = Datasets()
serie = dtst.Leitura_dados(dtst.bases_reais(3), csv=True)
particao = Particionar_series(serie, [0.0, 0.0, 0.0], 0)
serie = particao.Normalizar(serie)
'''
serie1 = serie[10000:10300]
serie2 = serie[12000:14000]
modelo = IDPSO_ELM(serie1, [1, 0, 0], 5, 10)
modelo.Parametros_IDPSO(100, 30, 0.8, 0.4, 2, 2, 20)
modelo.Treinar()
previsao = modelo.Predizer(modelo.dataset[0])
MAE = mean_absolute_error(modelo.dataset[1], previsao)
print('IDPSO_ELM - MAE: ', MAE)
plt.plot(serie1)
plt.plot(previsao)
plt.show()
serie2_modelada = modelo.Tratamento_Dados(serie2, [1, 0, 0], 5)
previsao = modelo.Predizer(serie2_modelada[0])
MAE = mean_absolute_error(serie2_modelada[1], previsao)
print('IDPSO_ELM - MAE: ', MAE)
plt.plot(serie2)
plt.plot(previsao)
plt.show()
'''
divisao_dataset = [0.8, 0.2, 0]
qtd_neuronis = 10
janela_tempo = 5
modelo = IDPSO_ELM(serie, divisao_dataset, janela_tempo, qtd_neuronis)
modelo.Parametros_IDPSO(100, 30, 0.8, 0.4, 2, 2, 50)
modelo.Treinar()
previsao = modelo.Predizer(modelo.dataset[0])
MAE = mean_absolute_error(modelo.dataset[1], previsao)
print('IDPSO_ELM - Train MAE: ', MAE)
previsao = modelo.Predizer(modelo.dataset[2])
MAE = mean_absolute_error(modelo.dataset[3], previsao)
print('IDPSO_ELM - Val MAE: ', MAE)
###################################################################################
################################### ELM ##########################################
ELM = ELMRegressor(qtd_neuronis)
ELM.Tratamento_dados(serie, divisao_dataset, janela_tempo)
ELM.Treinar(ELM.train_entradas, ELM.train_saidas)
# treinando a rede com o conjunto de treinamento
previsao = ELM.Predizer(ELM.train_entradas)
MAE = mean_absolute_error(ELM.train_saidas, previsao)
print('ELM - Train MAE: ', MAE)
previsao = ELM.Predizer(ELM.val_entradas)
MAE = mean_absolute_error(ELM.val_saidas, previsao)
print('ELM - Val MAE: ', MAE)
subsample=1.0,
subsample_for_bin=200000,
subsample_freq=0,
verbosity=-1)
model.fit(x_train, y_train, verbose=1000)
# Create an variable to pickle and open it in write mode
mh = ModelHolder(model, most_dependent_columns)
mh.save(model_name)
model = None
mh_new = load_model(model_name)
model, most_dependent_columns = mh_new.get()
y_pred = model.predict(x_test)
mas = mean_absolute_error(y_test, y_pred)
print('Mean Absolute Error', mas)
# params = {'num_leaves': 256,
# 'min_data_in_leaf': 50,
# 'objective': 'regression',
# 'max_depth':-1,
# 'learning_rate': 0.001,
# "boosting": "gbdt",
# "feature_fraction": 0.5,
# "bagging_freq": 2,
# "bagging_fraction": 0.5,
# "bagging_seed": 0,
# "metric": 'mae',
# "verbosity":-1,
# 'reg_alpha': 0.25,
X_train, X_test, y_train, y_test = train_test_split(X,
y,
train_size=0.5,
random_state=2016)
print("Linear RT")
t0 = time.time()
lrt = linear_regression_tree(max_depth=3,
max_features="sqrt",
min_samples=20,
kerneltype="poly",
gridsearch=True,
random_state=2016).fit(X_train, y_train)
y_pred = lrt.predict(X_test)
print("Time taken: %0.3f" % (time.time() - t0))
score = mean_absolute_error(y_test, y_pred)
print("Error: %0.3f" % score)
print("")
#printtree(lrt._tree, indent=" ")
print("Linear RF")
t0 = time.time()
lrt = regression_forest(n_estimators=10,
max_depth=4,
max_features="sqrt",
seed=2016,
min_samples=100).fit(X_train, y_train)
y_pred = lrt.predict(X_test)
print("Time taken: %0.3f" % (time.time() - t0))
score = mean_absolute_error(y_test, y_pred)
def MAE(Y1, Y2):
return mean_absolute_error(Y1, Y2)
def Executar(self, grafico = None):
'''
Metodo para executar o procedimento do algoritmo
:param grafico: variavel booleana para ativar ou desativar o grafico
:return: retorna 5 variaveis: [falsos_alarmes, atrasos, falta_deteccao, MAPE, tempo_execucao]
'''
################################################################################################################################################
################################# CONFIGURACAO DO DATASET ######################################################################################
################################################################################################################################################
#dividindo os dados da dataset dinamica para treinamento_inicial inicial e para uso do stream dinâmico
treinamento_inicial = self.dataset[0:self.m]
stream = self.dataset[self.m:]
################################################################################################################################################
################################# PERIODO ESTATICO #############################################################################################
################################################################################################################################################
#criando e treinando um modelo_vigente para realizar as previsões
enxame = PSO_ELM(treinamento_inicial, divisao_dataset, self.lags, self.qtd_neuronios)
enxame.Parametros_PSO(it, self.numero_particulas, inercia, inercia, c1, c2, xmax, crit_parada, self.tx)
enxame.Treinar()
#ajustando com os dados finais do treinamento a janela de predicao
janela_predicao = Janela()
janela_predicao.Ajustar(enxame.dataset[0][(len(enxame.dataset[0])-1):])
predicao = enxame.Predizer(janela_predicao.dados)
#janela com o atual conceito, tambem utilizada para armazenar os dados de retreinamento
janela_caracteristicas = Janela()
janela_caracteristicas.Ajustar(treinamento_inicial)
#ativando os sensores de acordo com a primeira janela de caracteristicas
solucao = self.Computar_solucao_teste(janela_caracteristicas.dados, self.lags, enxame)
self.Sentry(solucao)
################################################################################################################################################
################################# PERIODO DINAMICO #############################################################################################
################################################################################################################################################
#variavel para armazenar o erro do stream
erro_stream = 0
#variavel para armazenar as deteccoes
deteccoes = []
#variavel para armazenar os alarmes
alarmes = []
#variavel para armazenar o tempo inicial
start_time = time.time()
#vetor para armazenar a predicoes_vetor
if(grafico == True):
predicoes_vetor = [None] * len(stream)
erro_stream_vetor = [None] * len(stream)
#variavel auxiliar
mudanca_ocorreu = False
#entrando no stream de dados
for i in range(1, len(stream)):
#computando o erro
loss = mean_absolute_error(stream[i:i+1], predicao)
erro_stream += loss
#adicionando o novo dado a janela de predicao
janela_predicao.Add_janela(stream[i])
#realizando a nova predicao com a nova janela de predicao
predicao = enxame.Predizer(janela_predicao.dados)
# atualizando a janela de caracteristicas
janela_caracteristicas.Add_janela(stream[i])
if(grafico == True):
#salvando o erro
erro_stream_vetor[i] = loss
#salvando a predicao
predicoes_vetor[i] = predicao[0]
#print("[", i, "]")
if(mudanca_ocorreu == False):
if((i % self.S) == 0):
#verificando os sensores
nova_solucao = self.Reavaliar_sentry(janela_caracteristicas.dados[0], self.lags, enxame)
mudou = self.Monitorar_sentry(nova_solucao)
if(mudou):
if(grafico == True):
print("[%d] Mudança" % (i))
deteccoes.append(i)
#variavel para alterar o fluxo, ir para o periodo de retreinamento
mudanca_ocorreu = True
else:
#atualizando o modelo_vigente preditivo
dataset = enxame.Tratamento_Dados(janela_caracteristicas.dados[0], divisao_dataset, self.lags)
enxame.dataset = dataset
enxame.Retreinar()
#ajustando com os dados finais do treinamento a janela de predicao
janela_predicao = Janela()
janela_predicao.Ajustar(enxame.dataset[0][(len(enxame.dataset[0])-1):])
predicao = enxame.Predizer(janela_predicao.dados)
#ativando os sensores de acordo com a primeira janela de caracteristicas
solucao = self.Computar_solucao_teste(janela_caracteristicas.dados[0], self.lags, enxame)
self.Sentry(solucao)
#variavel para voltar para o loop principal
mudanca_ocorreu = False
#variavel para armazenar o tempo final
end_time = time.time()
#computando as metricas de deteccao
mt = Metricas_deteccao()
[falsos_alarmes, atrasos] = mt.resultados(stream, deteccoes, self.m)
#computando a acuracia da previsao ao longo do fluxo de dados
MAE = erro_stream/len(stream)
#computando o tempo de execucao
tempo_execucao = (end_time-start_time)
if(grafico == True):
tecnica = "RPSO-ELM"
print(tecnica)
print("Alarmes:")
print(alarmes)
print("Deteccoes:")
print(deteccoes)
print("Falsos Alarmes: ", falsos_alarmes)
print("Atrasos: ", atrasos)
print("MAE: ", MAE)
print("Tempo de execucao: ", tempo_execucao)
#plotando o grafico de erro
if(grafico == True):
g = Grafico()
g.Plotar_graficos(stream, predicoes_vetor, deteccoes, alarmes, erro_stream_vetor, self.m, atrasos, falsos_alarmes, tempo_execucao, MAE, nome=tecnica)
#retorno do metodo
return falsos_alarmes, atrasos, MAE, tempo_execucao
