Introducción

Una red neuronal consiste en simular las propiedades observadas en los sistemas
neuronales biológicos a través de modelos matemáticos recreados mediante mecanismos
artificiales. Una red neuronal, son algoritmos y estructuras inspirados en las funciones
biológicas de las redes neuronales.
Es común utilizar redes neuronales para problemas de clasificación y regresión, pero
realmente tienen un gran potencial para resolver multitud de problemáticas. Son muy
buenas para detectar patrones. En este documento utilizaremos las redes neuronales para
un pronóstico de series temporales utilizando Python como herramienta para crear y
enseñar el comportamiento de la serie de datos, para realizar un pronóstico. Una serie
temporal es un conjunto de muestras tomadas a intervalos de tiempo regulares, estas
dependen del tiempo y suele tener tendencias a crecer o decrecer. Analizar el
comportamiento para el pronóstico es muy útil para conocer el comportamiento de sistema
en este caso eléctrico, y realizar correcciones en base a los resultados esperados.
Para crear la red neuronal se utilizó la biblioteca Keras que es una biblioteca de Python que
proporciona, de manera simple. La creación de una amplia gama de modelos de Deep
Learning utilizando como backend otras bibliotecas como TensorFlow, Theano o CNTK.

Objetivos
 Desarrollar de una red neuronal en el entorno de Python que permita predecir el
comportamiento del consumo eléctrico.
 Aprender el funcionamiento de una red neuronal
 Utilizar herramientas de programación que permitan la creación de redes
neuronales

Alcance
Se limitará predecir el comportamiento de 7 días de consumo de energía en base a la data
de energía que tiene 2 meses de consumo de energía, el mismo mostrara gráfica del
pronóstico del consumo y se compara con valores reales en el tiempo. Se utilizará una red
neuronal creada con Python a través de las librerías TensorFlow y Keras y se explicara el
procedimiento para realizar la red neuronal y todas las adecuaciones tomadas para este
fin.
Desarrollo del proyecto
Cargar la serie de datos a través de las librerías de numpy y pandas.

La data contiene la energía consumida de un edificio corporativo.

Aquí se carga la data y se almacena en la variable df.

En este paso se altera el flujo de entrada del archivo csv que contiene una columna con
consumo, y lo convertiremos en varias columnas. Tomamos nuestra serie temporal y la
convertiremos en un “problema de tipo supervisado “para poder alimentar nuestra red
neuronal y poder entrenarla con backpropagation.
Entradas: serán “7 columnas” que representan el consumo de los 7 días anteriores.
Salida: El valor del “8vo día”. Es decir, el consumo de ese día.
Para hacer esta transformación se usa una función llamada series_to_supervised() y
MinMaxScaler para transformar el rango de nuestros valores entre -1 y 1.

Resultado de los datos de entrada transformados.

Aquí creamos la red neuronal haremos una subdivisión de los primeros 15 días
consecutivos para entrenamiento de la red y los siguientes 15 para su validación.
La arquitectura de la red neuronal será:
7 entradas, 1 capa Oculta con 7 neuronas y 1 sola neurona de salida.

Como la predicción será un valor continuo y no discreto, para calcular la exactitud

utilizaremos Mean Squared Error (MSE) y para saber si mejora con el entrenamiento se
debería ir reduciendo con las EPOCHS. Yo utilice 70 épocas para reducir el error lo mas
posible.
Resultados del entrenamiento

Nos muestra un error de 0.2926

Se grafico los resultados mediante el entrenamiento vs los valores reales y vemos como se
aproximan los valores (Rojo) por entrenamiento a los valores reales(verde) si se aumenta
EPOCHS mejora cada vez más.

Para el pronóstico futuro se utilizó los últimos 15 días del mes de julio para pronosticar los
7 primeros días del mes de agosto.
En este paso se hace lo mismo que cuando se estaba procesando la data para el
entrenamiento de la neurona pero sin la salida Y o var1(t) porque es la que vamos a
predecir.

aquí tomamos la última fila que corresponde a los últimos días del mes de julio.
Se utiliza la función “rellenando” el desplazamiento que hacemos por cada predicción. Esto
es porque queremos predecir los 7 primeros días de agosto. Entonces para el 1 de agosto,
ya tenemos el set con los últimos 7 días de Julio. Pero para pronosticar el 2 de agosto
necesitamos los 7 días anteriores que INCLUYEN al 1 Julio y ese valor, lo obtenemos en
nuestra predicción anterior. Y así hasta el 7 de agosto.
Transformamos los valores de 0 y 1 a valores den kWh para la matriz de salida y poder
graficar la misma.
Resultados

Cosumo Primera semana Agosto

1000
900
800
Consumo (kWh)

700
600
500
400
300
200
100
0

Aquí vemos como resultado la gráfica de pronóstico de consumo. Esta grafica se comparó
con los valores reales medidos del mes de agosto y su comportamiento es el mismo al
pronosticado. Lo que valida la salida de red neuronal.

.
Conclusiones
Aprovechamos la capacidad de las redes neuronales de generalizar y lograr predecir
consumos futuros, Se logró entrenar una red neuronal a partir de datos reales de consumo
pueda predecir el consumo de sistema eléctrico, con variaciones reales.
Anexo
import pandas as pd
import numpy as np
import matplotlib.pylab as plt
%matplotlib inline
plt.rcParams['figure.figsize'] = (16, 9)
plt.style.use('fast')

from keras.models import Sequential

from keras.layers import Input,Dense,Activation,Flatten
from sklearn.preprocessing import MinMaxScaler

df = pd.read_csv('Documents\consumo_SB.csv', parse_dates=[0], header=None,i

ndex_col=0, squeeze=True,names=['fecha','k'])
df.head()

PASOS=7

def series_to_supervised(data, n_in=1, n_out=1, dropnan=True):

n_vars = 1 if type(data) is list else data.shape[1]
df = pd.DataFrame(data)
cols, names = list(), list()

for i in range(n_in, 0, -1):

cols.append(df.shift(i))
names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]
for i in range(0, n_out):
cols.append(df.shift(-i))
if i == 0:
names += [('var%d(t)' % (j+1)) for j in range(n_vars)]
else:
names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]

agg = pd.concat(cols, axis=1)

agg.columns = names
if dropnan:
agg.dropna(inplace=True)
return agg

values = df.values
values = values.astype('float32')
scaler = MinMaxScaler(feature_range=(-1, 1))
values=values.reshape(-1, 1)
scaled = scaler.fit_transform(values)
reframed = series_to_supervised(scaled, PASOS, 1)
reframed.head()

values = reframed.values
n_train_days = 30+31 - (15+PASOS)
train = values[:n_train_days, :]
test = values[n_train_days:, :]
x_train, y_train = train[:, :-1], train[:, -1]
x_val, y_val = test[:, :-1], test[:, -1]

x_train = x_train.reshape((x_train.shape[0], 1, x_train.shape[1]))

x_val = x_val.reshape((x_val.shape[0], 1, x_val.shape[1]))
print(x_train.shape, y_train.shape, x_val.shape, y_val.shape)
def crear_modeloFF():
model = Sequential()
model.add(Dense(PASOS, input_shape=(1,PASOS),activation='tanh'))
model.add(Flatten())
model.add(Dense(1, activation='tanh'))
model.compile(loss='mean_absolute_error',optimizer='Adam',metrics=["mse"
])
model.summary()
return model
EPOCHS=70

model = crear_modeloFF()

history=model.fit(x_train,y_train,epochs=EPOCHS,validation_data=(x_val,y_val
),batch_size=PASOS)
ultimosDias = df['17/07/2020':'31/07/2020']
ultimosDias
values = ultimosDias.values
values = values.astype('float32')
values=values.reshape(-1, 1)
scaled = scaler.fit_transform(values)
reframed = series_to_supervised(scaled, PASOS, 1)
reframed.drop(reframed.columns[[7]], axis=1, inplace=True)
reframed.head(7)
values = reframed.values
x_test = values[2:, :]
x_test = x_test.reshape((x_test.shape[0], 1, x_test.shape[1]))
x_test
def agregarNuevoValor(x_test,nuevoValor):
for i in range(x_test.shape[2]-1):
 x_test[0][0][i] = x_test[0][0][i+1]
x_test[0][0][x_test.shape[2]-1]=nuevoValor
return x_test

results=[]
for i in range(7):
parcial=model.predict(x_test)
results.append(parcial[0])
print(x_test)
x_test=agregarNuevoValor(x_test,parcial[0])
adimen = [x for x in results]
inverted = scaler.inverse_transform(adimen)
inverted
prediccion1SemanaDiciembre = pd.DataFrame(inverted)
prediccion1SemanaDiciembre.columns = ['pronostico']
prediccion1SemanaDiciembre.plot()
prediccion1SemanaDiciembre.to_csv('pronostico.csv')