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 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 Tratamento_Dados(self, serie, divisao, janela):
'''
Metodo para dividir a serie temporal em treinamento e validacao
:param serie: vetor, com a serie temporal utilizada para treinamento
:param divisao: lista com porcentagens, da seguinte forma [pct_treinamento_entrada, pct_treinamento_saida, pct_validacao_entrada, pct_validacao_saida]
:param janela: quantidade de lags usados para modelar os padroes de entrada da ELM
:return: retorna uma lista com os seguintes dados [treinamento_entrada, treinamento_saida, validacao_entrada, validacao_saida]
'''
#tratamento dos dados
particao = Particionar_series(serie, divisao, janela)
[train_entrada, train_saida] = particao.Part_train()
[val_entrada, val_saida] = particao.Part_val()
[test_entrada, test_saida] = particao.Part_test()
#inserindo os dados em uma lista
lista_dados = []
lista_dados.append(train_entrada)
lista_dados.append(train_saida)
lista_dados.append(val_entrada)
lista_dados.append(val_saida)
lista_dados.append(test_entrada)
lista_dados.append(test_saida)
#retornando o valor
return lista_dados
def Computar_estatisticas_DDM_desvio(self, vetor_caracteristicas, lags,
ELM):
'''
Metodo para computar a deteccao de mudanca do erro por meio do DDM com desvio padrão tradicional
: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.min(erros), np.std(erros), erros
def main():
high = 2
low = 3
dataset = pd.read_csv(
"../series/WIN$N_Daily_201601040000_201905300000.csv",
header=None,
sep='\t')[low][1:].values
dataset = np.array(dataset, dtype=float)
#dataset = np.append(dataset, 98225)
dataset = np.append(dataset, 96870)
particao = Particionar_series(dataset, [0.0, 0.0, 0.0], 0)
serie = particao.Normalizar(dataset)
divisao_dataset = [0.6, 0.3, 0.1]
qtd_neuronios = 10
janela_tempo = 4
previsoes = []
for i in range(30):
print(i)
################################### IDPSO-ELM ##########################################
modelo = IDPSO_ELM(serie, divisao_dataset, janela_tempo, qtd_neuronios)
modelo.Parametros_IDPSO(100, 15, 0.8, 0.4, 2, 2, 0.3, 20)
modelo.Treinar()
##### previsao de amanha #####
ultimo_padrao = modelo.dataset[4][-1]
ultimo_padrao = np.append(ultimo_padrao, modelo.dataset[5][-1])
ultimo_padrao = ultimo_padrao[1:]
ultimo_padrao = ultimo_padrao.reshape((1, janela_tempo))
previsao_amanha = modelo.Predizer(ultimo_padrao)
previsoes.append(previsao_amanha)
########################################################################################
media = [np.mean(previsoes)]
mediana = [np.median(previsoes)]
print("IDPSO-ELM: (media) ", particao.Desnormalizar(media))
print("IDPSO-ELM: (mediana) ", particao.Desnormalizar(mediana))
#plt.plot(particao.Desnormalizar(modelo.Predizer(modelo.dataset[4])), label='Predicted')
#plt.plot(particao.Desnormalizar(modelo.dataset[5]), label='Ground Truth')
#plt.legend()
#plt.show()
'''
def Tratamento_dados(self, serie, divisao, lags):
#dividindo a serie para particionar
particao = Particionar_series(serie, divisao, lags)
#tratamento dos dados
[train_entrada, train_saida] = particao.Part_train()
[val_entrada, val_saida] = particao.Part_val()
[teste_entrada, teste_saida] = particao.Part_test()
#transformação das listas em arrays
self.train_entradas = np.asarray(train_entrada)
self.train_saidas = np.asarray(train_saida)
self.val_entradas = np.asarray(val_entrada)
self.val_saidas = np.asarray(val_saida)
self.teste_entradas = np.asarray(teste_entrada)
self.teste_saidas = np.asarray(teste_saida)
def main():
#instanciando o dataset
dtst = Datasets('dentro')
dataset = dtst.Leitura_dados(dtst.bases_reais(3), csv=True)
particao = Particionar_series(dataset, [0.0, 0.0, 0.0], 0)
dataset = particao.Normalizar(dataset)
#instanciando o algoritmo com sensores
n = 300
lags = 5
qtd_neuronios = 10
w = 0.25
c = 0.25
alg = ELM_FEDD(dataset, n, lags, qtd_neuronios, 0.2, w, c)
#colhendo os resultados
def main():
#instanciando o dataset
dtst = Datasets('dentro')
#dataset = dtst.Leitura_dados(dtst.bases_linear_graduais(1), csv=True)
dataset = dtst.Leitura_dados(dtst.bases_reais(3), csv=True)
particao = Particionar_series(dataset, [0.0, 0.0, 0.0], 0)
dataset = particao.Normalizar(dataset)
#instanciando o algoritmo com sensores
n = 300
lags = 5
qtd_neuronios = 10
numero_particulas = 30
limite = 10
w = 0.75
c = 1
alg = IDPSO_ELM_B(dataset, n, lags, qtd_neuronios, numero_particulas,
limite, w, c)
#colhendo os resultados
alg.Executar(grafico=True)
def main():
#load da serie
import pandas as pd
dataset = pd.read_csv("../series/WINJ19_M5_201903061300_201904051750.csv",
header=None,
sep='\t')[5][1:].values
dataset = np.array(dataset, dtype=float)
particao = Particionar_series(dataset, [0.0, 0.0, 0.0], 4, norm=True)
# dividindo os dados entre treinamento e teste
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
particao.matriz_entrada,
particao.vetor_saida,
test_size=0.1,
shuffle=False,
stratify=None)
# treinando da forma convencional
ELM = ELMRegressor(10)
ELM.Treinar(X_train, y_train)
# realizando a previsao no teste da forma convencional
previsao_teste = ELM.Predizer(X_test)
MAE = mean_absolute_error(y_test, previsao_teste)
print('ELM Prediction - Test MAE: ', MAE)
plt.plot(previsao_teste, label="Prediction")
# realizando a previsao no teste da forma convencional
previsao_teste = ELM.PredizerPhaseAdjustment(X_test)
MAE = mean_absolute_error(y_test, previsao_teste)
print('ELM Prediction Adjusted - Test MAE: ', MAE)
plt.plot(previsao_teste, label="Prediction Adjusted")
# plotando os valores reais
plt.plot(y_test, label="Real")
plt.legend()
plt.show()
from algoritmos_online.IDPSO_ELM_B import IDPSO_ELM_B from algoritmos_online.IDPSO_ELM_S import IDPSO_ELM_S # importing libs to help in the methods execution from ferramentas.Importar_dataset import Datasets from ferramentas.Particionar_series import Particionar_series #1. importing the datasets dtst = Datasets() #1.1 REAL DATASETS ################################################### # 1 = Dow 30 # 2 = Nasdaq # 3 = S&P 500 dataset = dtst.Leitura_dados(dtst.bases_reais(1), csv=True) dataset = Particionar_series().Normalizar(dataset) #1.1 ################################################################# #1.2 SYNTHETIC DATASETS ############################################### # dtst.bases_lineares(1) # dtst.bases_nlineares(1) # dtst.bases_sazonais() # dtst.bases_hibridas() #dataset = dtst.Leitura_dados(dtst.bases_hibridas(1), csv=True) #dataset = Particionar_series().Normalizar(dataset) #1.2 ################################################################## #2. IMPORTING AND RUNNING ALGORITHMS ################################ # IDPSO-ELM-S idpso_elm_s = IDPSO_ELM_S(dataset) idpso_elm_s.Executar(grafico=True)