Opciones para ejecutar cuadernos Jupyter Notebook en la nube


Un cuaderno de Jupyter (Jupyter Notebook en inglés) es una aplicación web interactiva que permite crear y compartir documentos que contienen código en vivo, ecuaciones, visualizaciones y texto explicativo. Estos cuadernos son especialmente populares en la comunidad de programadores, científicos de datos, ingenieros y académicos debido a su capacidad para integrar código ejecutable y resultados en un mismo lugar, lo que facilita la exploración, análisis y presentación de datos.

Algunas de las razones por las que los cuadernos de Jupyter se han vuelto tan famosos son:

  • Interactividad: Los cuadernos permiten ejecutar código en bloques individuales, lo que significa que se puede ejecutar un fragmento de código y ver los resultados inmediatamente debajo. Esto facilita la depuración y la iteración rápida.
  • Documentación enriquecida: Además de código, los cuadernos permiten incluir texto enriquecido usando el formato Markdown, lo que facilita la creación de documentación, explicaciones y anotaciones en el mismo entorno donde se ejecuta el código.
  • Visualización integrada: Los cuadernos de Jupyter admiten la generación y visualización de gráficos, diagramas y visualizaciones interactivas directamente en el documento, lo que facilita la comprensión de los datos y los resultados.
  • Reproducibilidad: Los cuadernos permiten documentar el proceso de análisis y los pasos de manera detallada, lo que ayuda a otros a reproducir los resultados y entender el flujo de trabajo.
  • Compartir y colaborar: Los cuadernos se pueden compartir fácilmente a través de plataformas en línea, lo que facilita la colaboración y la presentación de resultados a colegas y público en general.
  • Soporte para múltiples lenguajes de programación: Aunque su nombre está asociado originalmente con Python, los cuadernos de Jupyter también admiten otros lenguajes de programación como R, Julia y más, lo que los hace versátiles para diferentes necesidades y comunidades.
  • Educación y aprendizaje interactivo: Los cuadernos son herramientas efectivas para la enseñanza y el aprendizaje, ya que permiten a los estudiantes interactuar con el contenido, modificar el código y ver los resultados en tiempo real.

Existen varias opciones para ejecutar Jupyter Notebook en la nube sin necesidad de instalar nada en nuestros equipos y aprovechando la poten cia computacional y los recursos tanto de CPU como de GPU de maquinas mas potentes.

Aquí presentamos algunas de las mas populares:

Google Colab

Estamos con la plataforma gratuita de Google que permite ejecutar Jupyter Notebooks en la nube. Se puede acceder a ella desde cualquier navegador web y tiene integración con Google Drive para guardar y compartir tus notebooks. Simplemente estando validado con nuestra cuenta de Google, nos vamos a la url de Collab (https://colab.research.google.com/ ) y ya podemos ejecutar cualquier cuaderno bien desde nuestro repositorio de Google Drive como desde el repositorio de Github o por supuesto crear uno nuevo.

Colab, también conocido como «Colaboratory», nos permite programar y ejecutar Python en un navegador ( NO necesariamente Chrome) con las ventajas de que no requiere configuración, el acceso a GPUs es sin coste adicional y permite compartir contenido fácilmente.

Microsoft Azure Notebooks

Fue un servicio en la nube que permitía a los usuarios crear, ejecutar y compartir cuadernos de Jupyter en un entorno en línea. Ofrecía capacidades similares a otros entornos de cuadernos, como Google Colab y Jupyter Notebook en sí. Sin embargo, en septiembre de 2021, Microsoft anunció la descontinuación de Azure Notebooks y se detuvo la creación de nuevos cuadernos y la capacidad de compartirlos.

Aunque Azure Notebooks ya no está disponible, los usuarios aún pueden trabajar con cuadernos de Jupyter en otras plataformas, como Jupyter Notebook localmente en sus máquinas, en servicios de nube alternativos como Google Colab o en entornos de desarrollo integrados (IDE) como VISUAL STUDIO que admitan cuadernos interactivos.

Amazon SageMaker:

Es una plataforma de aprendizaje automático de Amazon que permite crear, entrenar y desplegar modelos de aprendizaje automático en la nube. También incluye la opción de ejecutar Jupyter Notebooks en la nube proporcionando una forma integrada de trabajar con cuadernos Jupyter para el desarrollo y entrenamiento de modelos de machine learning. Puede utilizar cuadernos Jupyter en SageMaker de manera similar a como lo haría en otros entornos, pero con la ventaja de tener acceso directo a las capacidades de SageMaker y a la infraestructura de AWS. Aquí hay una descripción de cómo puede utilizar cuadernos Jupyter en Amazon SageMaker:

  • Creación de un cuaderno: En la consola de Amazon SageMaker, puede crear un cuaderno directamente desde la interfaz. Esto generará una instancia de cuaderno Jupyter alojada en la nube de AWS.
  • Elegir una instancia de cuaderno: Puede seleccionar la configuración de la instancia de cuaderno que mejor se adapte a sus necesidades en términos de capacidad de cómputo y memoria.
  • Selección de imagen del cuaderno: Puede elegir una imagen del cuaderno que contenga las bibliotecas y marcos de trabajo que necesita, como TensorFlow, PyTorch o scikit-learn.
  • Acceso a datos y recursos de SageMaker: Dentro del cuaderno, puede acceder a sus conjuntos de datos almacenados en Amazon S3 y utilizar las capacidades de SageMaker para preprocesamiento y manipulación de datos.
  • Entrenamiento de modelos: Puede utilizar el cuaderno para definir y entrenar tus modelos de machine learning utilizando las capacidades de SageMaker, como el escalado distribuido para entrenar en grandes conjuntos de datos.
  • Visualización y análisis de resultados: Los cuadernos Jupyter en SageMaker le permiten generar visualizaciones y analizar los resultados del entrenamiento en tiempo real.
  • Despliegue de modelos: Puede utilizar el cuaderno para implementar modelos entrenados en servicios de producción de SageMaker, como endpoints en línea, lotes de inferencia y más.
  • Colaboración y compartición: Puede compartir sus cuadernos con otros colaboradores, lo que facilita la colaboración en proyectos de machine learning.
  • Integración con otros servicios de AWS: Puede acceder y utilizar otros servicios de AWS dentro de su cuaderno, lo que le puede brindar un amplio conjunto de herramientas para trabajar con datos y modelos.

Binder

Binder es una plataforma en línea gratuita que permite ejecutar Jupyter Notebooks desde un repositorio de GitHub sin necesidad de instalar nada en tu ordenador. Es una buena opción si quiere compartir su notebook con otros usuarios. Para acceder a la plataforma Binder y ejecutar un Jupyter Notebook en línea, siga los siguientes pasos:

  • Abra un navegador web y diríjase a la página web de Binder: https://mybinder.org/
  • En la sección «GitHub repository name or URL», ingrese el nombre de usuario de GitHub y el nombre del repositorio que contiene el notebook que desea ejecutar. Por ejemplo, si el usuario de GitHub es «myuser» y el nombre del repositorio es «myrepo», ingrese «myuser/myrepo». En la sección «Git ref», ingrese la rama o el hash del commit que contiene el notebook que deseas ejecutar. Si no está seguro, déjelo en blanco para ejecutar la última versión del notebook en la rama principal. Haga clic en el botón «Launch» para iniciar Binder.
  • Espere unos minutos mientras Binder crea un ambiente virtual con todas las dependencias necesarias para ejecutar el notebook en línea. Una vez que el ambiente virtual esté listo, verá una página de Jupyter Notebook en su navegador web, donde puede explorar y ejecutar el notebook.

Tenga en cuenta que Binder es una plataforma gratuita y compartida, por lo que la velocidad y la capacidad de procesamiento pueden ser limitadas. Además, tenga en cuenta que cualquier persona puede acceder a su notebook si compartes la URL.

Como ejemplo ,para instalar nilmtk en Binder, siga los siguientes pasos:

  1. Abra su notebook en Binder.
  2. Cree un nuevo archivo llamado requirements.txt en la raíz de su directorio de trabajo. Para ello, haga clic en New en la parte superior derecha de la página y selecciona Text File. Cambie el nombre del archivo a requirements.txt. Abra el archivo requirements.txt y agrega la siguiente línea: nilmtk Esto le indica a Binder que instale la librería nilmtk y todas sus dependencias. Guarde el archivo requirements.txt. Cierre todos los notebooks y pestañas de Jupyter abiertos.
  3. En la página principal de Binder, haga clic en Build en la parte superior derecha de la página. Esto iniciará la construcción de un nuevo ambiente virtual con nilmtk y sus dependencias instaladas.
  4. Espere a que Binder termine de construir el ambiente virtual. Esto puede tomar varios minutos.
  5. Una vez que la construcción esté completa, abra un nuevo notebook y verifique que nilmtk está instalado correctamente. Para ello, ingrese el siguiente código en una celda de su notebook y ejecútelo como python code :import nilmtk Si no hay errores, significa que nilmtk se ha instalado correctamente y está listo para empezar a trabajar con la famosa librería.

Estas son solo algunas opciones, pero existen muchas más plataformas en la nube que te permiten ejecutar Jupyter Notebooks. La elección depende de sus necesidades y preferencias personales.

Evaluar modelos ingenuos para pronosticar el consumo de electricidad de los hogares


El conjunto de datos de ‘ Consumo de energía del hogar ‘ es un conjunto de datos de series de tiempo multivariable que describe el consumo de electricidad de un solo hogar durante cuatro años.

Los datos se recopilaron entre diciembre de 2006 y noviembre de 2010 y cada minuto se recopilaron observaciones del consumo de energía dentro del hogar.

Es una serie multivariada compuesta por siete variables (además de la fecha y la hora). Las variables son las siguientes:

  • global_active_power : la potencia activa total consumida por el hogar (kilovatios).
  • global_reactive_power : La potencia reactiva total consumida por el hogar (kilovatios).
  • voltaje : Voltaje promedio (voltios).
  • global_intensity : Intensidad de corriente promedio (amperios).
  • sub_metering_1 : Energía activa para cocina (vatios-hora de energía activa).
  • sub_metering_2 : Energía activa para lavandería (vatios-hora de energía activa).
  • sub_metering_3 : Energía activa para sistemas de control climático (vatios-hora de energía activa).

La potencia aparente  o potencia total se subdividen en dos componentes, que son la potencia activa y la potencia reactiva, la primera de ellas es la que nos encontraremos en la factura de la luz de nuestra vivienda, (en la industria es diferente), cobrándonos unos bonitos €/kWh y por tanto será el que realmente importa si lo que queremos es ver cuanto nos cuesta hacer funcionar un aparato eléctrico. Por otro lado si la tensión y la corriente se desfasan porque la carga que tengo conectada así lo requiere (aparatos con bobinas en su interior), entonces aparece la famosa energía reactivaque hace que la potencia aparente se diferencie bastante de la activa (la que nos cobran).

Para conocer el valor de la potencia reactiva (Q) es necesario conocer el desfase (phi) entre estas dos señales (voltaje y corriente) y aplicar la fórmula Q=V*I*sen(phi). Con la potencia activa sucede algo similar pero sustituyendo seno por coseno en la expresión.

Existen formas de compensar la energía reactiva (disminuirla), normalmente se basan en instalar condensadores que compensan las cargas inductivas (bobinas) con cargas capacitivas (condensadores), pero esto sólo se hace a nivel industrial ya que en el ámbito doméstico todavía (TODAVÍA) no pagamos por la reactiva consumida.

En nuestros cálculos se puede crear una cuarta variable de submedición restando la suma de tres variables de sub-medición definidas de la energía activa total de la siguiente manera:

sub_metering_remainder = (global_active_power * 1000 / 60) - (sub_metering_1 + sub_metering_2 + sub_metering_3)

Cargar y preparar conjunto de datos

El conjunto de datos se puede descargar desde el repositorio de UCI Machine Learning como un solo archivo .zip de unos 20 megabytes:consumo_electricidad_hogar.zip

Si descargamos el conjunto de datos y descomprimimos en su directorio de trabajo actual tendremos el archivo “ home_power_consumption.txt ” que tiene un tamaño de aproximadamente 127 megabytes y contiene todas las medidas.

Podemos usar la función read_csv() para cargar los datos y combinar las dos primeras columnas en una única columna de fecha y hora que podemos usar como índice.

# load all datadataset = read_csv('household_power_consumption.txt', sep=';', header=0, low_memory=False, infer_datetime_format=True, parse_dates={'datetime':[0,1]}, index_col=['datetime'])

A continuación, podemos marcar todos los valores faltantes indicados con un ‘ ‘ carácter con un valor NaN , que es un flotante.

Esto nos permitirá trabajar con los datos como una matriz de valores de punto flotante en lugar de tipos mixtos (menos eficientes).

# mark all missing valuesdataset.replace('?', nan, inplace=True)# make dataset numericdataset = dataset.astype('float32')

También necesitamos completar los valores faltantes ahora que han sido marcados.

Un enfoque muy simple sería copiar la observación a la misma hora del día anterior. Podemos implementar esto en una función llamada fill_missing() que tomará la matriz NumPy de los datos y copiará los valores de hace exactamente 24 horas.

# fill missing values with a value at the same time one day agodef fill_missing(values): one_day = 60 * 24 for row in range(values.shape[0]): for col in range(values.shape[1]): if isnan(values[row, col]): values[row, col] = values[row - one_day, col]

Podemos aplicar esta función directamente a los datos dentro del DataFrame.

# fill missingfill_missing(dataset.values)

Ahora podemos crear una nueva columna que contenga el resto de la submedición, utilizando el cálculo de la sección anterior.

# add a column for for the remainder of sub meteringvalues = dataset.valuesdataset['sub_metering_4'] = (values[:,0] * 1000 / 60) - (values[:,4] + values[:,5] + values[:,6])

Ahora podemos guardar la versión limpia del conjunto de datos en un nuevo archivo; en este caso, simplemente cambiaremos la extensión del archivo a .csv y guardaremos el conjunto de datos como ‘ home_power_consumption.csv ‘.

# save updated datasetdataset.to_csv('household_power_consumption.csv')

Uniendo todo esto, el ejemplo completo de cargar, limpiar y guardar el conjunto de datos se enumera a continuación.

# load and clean-up data
from numpy import nan
from numpy import isnan
from pandas import read_csv
from pandas import to_numeric
 
# fill missing values with a value at the same time one day ago
def fill_missing(values):
 one_day = 60 * 24
 for row in range(values.shape[0]):
 for col in range(values.shape[1]):
 if isnan(values[row, col]):
 values[row, col] = values[row - one_day, col]
 
# load all data
dataset = read_csv('household_power_consumption.txt', sep=';', header=0, low_memory=False, infer_datetime_format=True, parse_dates={'datetime':[0,1]}, index_col=['datetime'])
# mark all missing values
dataset.replace('?', nan, inplace=True)
# make dataset numeric
dataset = dataset.astype('float32')
# fill missing
fill_missing(dataset.values)
# add a column for for the remainder of sub metering
values = dataset.values
dataset['sub_metering_4'] = (values[:,0] * 1000 / 60) - (values[:,4] + values[:,5] + values[:,6])
# save updated dataset
dataset.to_csv('household_power_consumption.csv')

Al ejecutar el ejemplo, se crea el nuevo archivo » home_power_consumption.csv » que podemos usar como punto de partida para nuestro proyecto de modelado.

Photo by Benjamin Farren on Pexels.com

Evaluación del modelo

Ahora consideraremos cómo podemos desarrollar y evaluar modelos predictivos para el conjunto de datos de energía doméstica que ya hemos preparadio. Para ello estudiaremos cuatro aspectos:

  1. Encuadre del problema.
  2. Métrica de evaluación.
  3. Conjuntos de entrenamiento y prueba.
  4. Validación Walk-Forward.

Encuadre del problema

Hay muchas maneras de aprovechar y explorar el conjunto de datos de consumo de energía del hogar. En este estudio, usaremos los datos para explorar una pregunta muy específica; esto es: Dado el consumo de energía reciente, ¿Cuál es el consumo de energía esperado para la próxima semana?

Esto requiere que un modelo predictivo pronostique la potencia activa total para cada día durante los próximos siete días. Técnicamente, este encuadre del problema se conoce como un problema de pronóstico de serie de tiempo de múltiples pasos, dados los múltiples pasos de pronóstico. Un modelo que hace uso de múltiples variables de entrada puede denominarse modelo de pronóstico de serie de tiempo multivariante de múltiples pasos.

Un modelo de este tipo podría ser útil dentro del hogar en la planificación de gastos. También podría ser útil desde el punto de vista de la oferta para planificar la demanda de electricidad de un hogar específico.

Este marco del conjunto de datos también sugiere que sería útil reducir la muestra de las observaciones por minuto del consumo de energía a los totales diarios. Esto no es obligatorio, pero tiene sentido, dado que estamos interesados ​​en la potencia total por día.

Podemos lograr esto fácilmente usando la función resample() en pandas DataFrame. Llamar a esta función con el argumento ‘ D ‘ permite que los datos cargados indexados por fecha y hora se agrupen por día . Luego podemos calcular la suma de todas las observaciones para cada día y crear un nuevo conjunto de datos de consumo de energía diario para cada una de las ocho variables.

El ejemplo completo se muestra a continuación.


# resample minute data to total for each day
from pandas import read_csv
# load the new file
dataset = read_csv('household_power_consumption.csv', header=0, infer_datetime_format=True, parse_dates=['datetime'], index_col=['datetime'])
# resample data to daily
daily_groups = dataset.resample('D')
daily_data = daily_groups.sum()
# summarize
print(daily_data.shape)
print(daily_data.head())
# save
daily_data.to_csv('household_power_consumption_days.csv')

Al ejecutar el ejemplo, se crea un nuevo conjunto de datos de consumo de energía total diario y se guarda el resultado en un archivo separado llamado » home_power_conquisition_days.csv «.

Podemos usar esto como el conjunto de datos para ajustar y evaluar modelos predictivos para el marco elegido del problema.

Métrica de evaluación

Un pronóstico estará compuesto por siete valores, uno para cada día de la semana siguiente. Es común con los problemas de pronóstico de varios pasos evaluar cada paso de tiempo pronosticado por separado. Esto es útil por varias razones:

  • Para comentar sobre la aptitud en un plazo de entrega específico (p. ej., +1 día frente a +3 días).
  • Para contrastar modelos en función de sus habilidades en diferentes plazos de entrega (por ejemplo, modelos buenos en +1 día frente a modelos buenos en días +5).

Las unidades de la potencia total son los kilovatios y sería útil tener una métrica de error que también estuviera en las mismas unidades. Tanto el error cuadrático medio (RMSE) como el error absoluto medio (MAE) se ajustan a esta factura, aunque RMSE se usa más comúnmente y se adoptará en esta visión. A diferencia de MAE, RMSE castiga más los errores de pronóstico.

La métrica de rendimiento para este problema será el RMSE para cada tiempo de entrega desde el día 1 hasta el día 7.

Como atajo, puede ser útil resumir el rendimiento de un modelo utilizando una puntuación única para ayudar en la selección del modelo.

Una puntuación posible que podría usarse sería el RMSE en todos los días de pronóstico.

La función Evaluation_forecasts() a continuación implementará este comportamiento y devolverá el rendimiento de un modelo basado en múltiples pronósticos de siete días.


# evaluate one or more weekly forecasts against expected values
def evaluate_forecasts(actual, predicted):
 scores = list()
 # calculate an RMSE score for each day
 for i in range(actual.shape[1]):
 # calculate mse
 mse = mean_squared_error(actual[:, i], predicted[:, i])
 # calculate rmse
 rmse = sqrt(mse)
 # store
 scores.append(rmse)
 # calculate overall RMSE
 s = 0
 for row in range(actual.shape[0]):
 for col in range(actual.shape[1]):
 s += (actual[row, col] - predicted[row, col])**2
 score = sqrt(s / (actual.shape[0] * actual.shape[1]))
 return score, scores

Ejecutar la función primero devolverá el RMSE general independientemente del día, luego una matriz de puntajes de RMSE para cada día.

Conjuntos de entrenamiento y prueba

Usaremos los primeros tres años de datos para entrenar modelos predictivos y el último año para evaluar modelos.

Los datos de un conjunto de datos determinado se dividirán en semanas estándar (son semanas que comienzan en domingo y terminan en sábado).

Esta es una forma realista y útil de usar el encuadre elegido del modelo, donde se puede predecir el consumo de energía para la próxima semana. También es útil con el modelado, donde los modelos se pueden usar para predecir un día específico (por ejemplo, el miércoles) o la secuencia completa.

Dividiremos los datos en semanas estándar, trabajando hacia atrás desde el conjunto de datos de prueba.

El último año de los datos es 2010 y el primer domingo de 2010 fue el 3 de enero. Los datos terminan a mediados de noviembre de 2010 y el último sábado más cercano en los datos es el 20 de noviembre. Esto da 46 semanas de datos de prueba.

La primera y la última fila de datos diarios para el conjunto de datos de prueba se proporcionan a continuación para su confirmación.


2010-01-03,2083.4539999999984,191.61000000000055,350992.12000000034,8703.600000000033,3842.0,4920.0,10074.0,15888.233355799992
...
2010-11-20,2197.006000000004,153.76800000000028,346475.9999999998,9320.20000000002,4367.0,2947.0,11433.0,17869.76663959999

Los datos diarios comienzan a finales de 2006.

El primer domingo en el conjunto de datos es el 17 de diciembre, que es la segunda fila de datos.

La organización de los datos en semanas estándar proporciona 159 semanas estándar completas para entrenar un modelo predictivo.

2006-12-17,3390.46,226.0059999999994,345725.32000000024,14398.59999999998,2033.0,4187.0,13341.0,36946.66673200004
...
2010-01-02,1309.2679999999998,199.54600000000016,352332.8399999997,5489.7999999999865,801.0,298.0,6425.0,14297.133406600002

La función split_dataset() a continuación divide los datos diarios en conjuntos de entrenamiento y prueba y organiza cada uno en semanas estándar.

Se utilizan compensaciones de fila específicas para dividir los datos utilizando el conocimiento del conjunto de datos. Luego, los conjuntos de datos divididos se organizan en datos semanales mediante la función NumPy split() .


# split a univariate dataset into train/test sets
def split_dataset(data):
 # split into standard weeks
 train, test = data[1:-328], data[-328:-6]
 # restructure into windows of weekly data
 train = array(split(train, len(train)/7))
 test = array(split(test, len(test)/7))
 return train, test

Podemos probar esta función cargando el conjunto de datos diario e imprimiendo la primera y la última fila de datos tanto del tren como de los conjuntos de prueba para confirmar que cumplen con las expectativas anteriores.

El ejemplo de código completo se muestra a continuación.


# split into standard weeks
from numpy import split
from numpy import array
from pandas import read_csv
 
# split a univariate dataset into train/test sets
def split_dataset(data):
 # split into standard weeks
 train, test = data[1:-328], data[-328:-6]
 # restructure into windows of weekly data
 train = array(split(train, len(train)/7))
 test = array(split(test, len(test)/7))
 return train, test
 
# load the new file
dataset = read_csv('household_power_consumption_days.csv', header=0, infer_datetime_format=True, parse_dates=['datetime'], index_col=['datetime'])
train, test = split_dataset(dataset.values)
# validate train data
print(train.shape)
print(train[0, 0, 0], train[-1, -1, 0])
# validate test
print(test.shape)
print(test[0, 0, 0], test[-1, -1, 0])

Ejecutar el ejemplo muestra que, de hecho, el conjunto de datos del tren tiene 159 semanas de datos, mientras que el conjunto de datos de prueba tiene 46 semanas.

Podemos ver que la potencia activa total para el tren y el conjunto de datos de prueba para la primera y la última fila coinciden con los datos de las fechas específicas que definimos como los límites de las semanas estándar para cada conjunto.


(159, 7, 8)
3390.46 1309.2679999999998
(46, 7, 8)
2083.4539999999984 2197.006000000004

Validación Walk-Forward

Los modelos se evaluarán utilizando un esquema llamado validación de avance . Aquí es donde se requiere que un modelo haga una predicción de una semana, luego los datos reales de esa semana se ponen a disposición del modelo para que pueda usarse como base para hacer una predicción en la semana siguiente. Esto es tanto realista en cuanto a cómo se puede usar el modelo en la práctica como beneficioso para los modelos, permitiéndoles hacer uso de los mejores datos disponibles.

Podemos demostrar esto a continuación con la separación de los datos de entrada y los datos de salida/predichos.

Input, Predict
[Week1] Week2
[Week1 + Week2] Week3
[Week1 + Week2 + Week3] Week4
...

El enfoque de validación de avance para evaluar modelos predictivos en este conjunto de datos se implementa a continuación y se llama evaluar_modelo() .

El nombre de una función se proporciona para el modelo como el argumento » model_func «. Esta función es responsable de definir el modelo, ajustar el modelo a los datos de entrenamiento y hacer un pronóstico de una semana.

Los pronósticos hechos por el modelo luego se evalúan contra el conjunto de datos de prueba utilizando la función de evaluación_previsiones() previamente definida .


# evaluate a single model
def evaluate_model(model_func, train, test):
 # history is a list of weekly data
 history = [x for x in train]
 # walk-forward validation over each week
 predictions = list()
 for i in range(len(test)):
 # predict the week
 yhat_sequence = model_func(history)
 # store the predictions
 predictions.append(yhat_sequence)
 # get real observation and add to history for predicting the next week
 history.append(test[i, :])
 predictions = array(predictions)
 # evaluate predictions days for each week
 score, scores = evaluate_forecasts(test[:, :, 0], predictions)
 return score, scores

Una vez que tenemos la evaluación de un modelo, podemos resumir el rendimiento.

La función a continuación denominada resume_scores() mostrará el rendimiento de un modelo en una sola línea para facilitar la comparación con otros modelos.


# summarize scores
def summarize_scores(name, score, scores):
 s_scores = ', '.join(['%.1f' % s for s in scores])
 print('%s: [%.3f] %s' % (name, score, s_scores))

Ahora tenemos todos los elementos para comenzar a evaluar modelos predictivos en el conjunto de datos.

Modelos de pronóstico ingenuos

Es importante probar modelos de pronóstico ingenuos en cualquier problema de predicción nuevo. Los resultados de los modelos ingenuos brindan una idea cuantitativa de cuán difícil es el problema de pronóstico y brindan un rendimiento de línea de base mediante el cual se pueden evaluar métodos de pronóstico más sofisticados.

Ahora desarrollaremos y compararemos tres métodos de pronóstico ingenuos para el problema de predicción de energía doméstica; ellos son:

  • Pronóstico de Persistencia Diaria.
  • Pronóstico persistente semanal.
  • Pronóstico persistente semanal de hace un año.

Previsión de persistencia diaria

El primer pronóstico ingenuo que desarrollaremos es un modelo de persistencia diaria. Este modelo toma la potencia activa del último día anterior al período de pronóstico (por ejemplo, el sábado) y la utiliza como el valor de la potencia para cada día del período de pronóstico (de domingo a sábado).

La función daily_persistence() a continuación implementa la estrategia de pronóstico de persistencia diaria.


# daily persistence model
def daily_persistence(history):
 # get the data for the prior week
 last_week = history[-1]
 # get the total active power for the last day
 value = last_week[-1, 0]
 # prepare 7 day forecast
 forecast = [value for _ in range(7)]
 return forecast

Pronóstico persistente semanal

Otro buen pronóstico ingenuo al pronosticar una semana estándar es usar toda la semana anterior como pronóstico para la próxima semana. Se basa en la idea de que la próxima semana será muy similar a esta semana.

La funciónweekly_persistence() a continuación implementa la estrategia de pronóstico de persistencia semanal.


# weekly persistence model
def weekly_persistence(history):
 # get the data for the prior week
 last_week = history[-1]
 return last_week[:, 0]

Pronóstico persistente semanal de hace un año

Similar a la idea de usar la semana pasada para pronosticar la próxima semana es la idea de usar la misma semana del año pasado para predecir la próxima semana. Es decir, utilizar la semana de observaciones de hace 52 semanas como pronóstico, basándose en la idea de que la próxima semana será similar a la misma semana de hace un año.

La siguiente función week_one_year_ago_persistence() implementa la estrategia de pronóstico de la semana de hace un año.


# week one year ago persistence model
def week_one_year_ago_persistence(history):
 # get the data for the prior week
 last_week = history[-52]
 return last_week[:, 0]

Comparación de modelos ingenuos

Podemos comparar cada una de las estrategias de pronóstico utilizando el arnés de prueba desarrollado en la sección anterior.

En primer lugar, el conjunto de datos se puede cargar y dividir en conjuntos de entrenamiento y de prueba.

# load the new filedataset = read_csv('household_power_consumption_days.csv', header=0, infer_datetime_format=True, parse_dates=['datetime'], index_col=['datetime'])# split into train and testtrain, test = split_dataset(dataset.values)

Cada una de las estrategias se puede almacenar en un diccionario con un nombre único. Este nombre se puede utilizar en la impresión y en la creación de un gráfico de las partituras.

# define the names and functions for the models we wish to evaluatemodels = dict()models['daily'] = daily_persistencemodels['weekly'] = weekly_persistencemodels['week-oya'] = week_one_year_ago_persistence

Luego, podemos enumerar cada una de las estrategias, evaluarlas mediante la validación de avance, imprimir los puntajes y agregar los puntajes a un gráfico de líneas para una comparación visual.

# evaluate each modeldays = ['sun', 'mon', 'tue', 'wed', 'thr', 'fri', 'sat']for name, func in models.items(): # evaluate and get scores score, scores = evaluate_model(func, train, test) # summarize scores summarize_scores('daily persistence', score, scores) # plot scores pyplot.plot(days, scores, marker='o', label=name)

Uniendo todo esto, el ejemplo completo que evalúa las tres estrategias de pronóstico ingenuo se enumera a continuación.


# naive forecast strategies
from math import sqrt
from numpy import split
from numpy import array
from pandas import read_csv
from sklearn.metrics import mean_squared_error
from matplotlib import pyplot
 
# split a univariate dataset into train/test sets
def split_dataset(data):
 # split into standard weeks
 train, test = data[1:-328], data[-328:-6]
 # restructure into windows of weekly data
 train = array(split(train, len(train)/7))
 test = array(split(test, len(test)/7))
 return train, test
 
# evaluate one or more weekly forecasts against expected values
def evaluate_forecasts(actual, predicted):
 scores = list()
 # calculate an RMSE score for each day
 for i in range(actual.shape[1]):
 # calculate mse
 mse = mean_squared_error(actual[:, i], predicted[:, i])
 # calculate rmse
 rmse = sqrt(mse)
 # store
 scores.append(rmse)
 # calculate overall RMSE
 s = 0
 for row in range(actual.shape[0]):
 for col in range(actual.shape[1]):
 s += (actual[row, col] - predicted[row, col])**2
 score = sqrt(s / (actual.shape[0] * actual.shape[1]))
 return score, scores
 
# summarize scores
def summarize_scores(name, score, scores):
 s_scores = ', '.join(['%.1f' % s for s in scores])
 print('%s: [%.3f] %s' % (name, score, s_scores))
 
# evaluate a single model
def evaluate_model(model_func, train, test):
 # history is a list of weekly data
 history = [x for x in train]
 # walk-forward validation over each week
 predictions = list()
 for i in range(len(test)):
 # predict the week
 yhat_sequence = model_func(history)
 # store the predictions
 predictions.append(yhat_sequence)
 # get real observation and add to history for predicting the next week
 history.append(test[i, :])
 predictions = array(predictions)
 # evaluate predictions days for each week
 score, scores = evaluate_forecasts(test[:, :, 0], predictions)
 return score, scores
 
# daily persistence model
def daily_persistence(history):
 # get the data for the prior week
 last_week = history[-1]
 # get the total active power for the last day
 value = last_week[-1, 0]
 # prepare 7 day forecast
 forecast = [value for _ in range(7)]
 return forecast
 
# weekly persistence model
def weekly_persistence(history):
 # get the data for the prior week
 last_week = history[-1]
 return last_week[:, 0]
 
# week one year ago persistence model
def week_one_year_ago_persistence(history):
 # get the data for the prior week
 last_week = history[-52]
 return last_week[:, 0]
 
# load the new file
dataset = read_csv('household_power_consumption_days.csv', header=0, infer_datetime_format=True, parse_dates=['datetime'], index_col=['datetime'])
# split into train and test
train, test = split_dataset(dataset.values)
# define the names and functions for the models we wish to evaluate
models = dict()
models['daily'] = daily_persistence
models['weekly'] = weekly_persistence
models['week-oya'] = week_one_year_ago_persistence
# evaluate each model
days = ['sun', 'mon', 'tue', 'wed', 'thr', 'fri', 'sat']
for name, func in models.items():
 # evaluate and get scores
 score, scores = evaluate_model(func, train, test)
 # summarize scores
 summarize_scores(name, score, scores)
 # plot scores
 pyplot.plot(days, scores, marker='o', label=name)
# show plot
pyplot.legend()
pyplot.show()

Al ejecutar el ejemplo, primero se imprimen las puntuaciones totales y diarias de cada modelo. Podemos ver que la estrategia semanal funciona mejor que la estrategia diaria y que la semana de hace un año ( week-oya ) vuelve a funcionar ligeramente mejor.

Nota : Sus resultados pueden variar dada la naturaleza estocástica del algoritmo o procedimiento de evaluación, o diferencias en la precisión numérica. Considere ejecutar el ejemplo varias veces y compare el resultado promedio.

Podemos ver esto tanto en los puntajes generales de RMSE para cada modelo como en los puntajes diarios para cada día de pronóstico. Una excepción es el error de pronóstico del primer día (domingo), donde parece que el modelo de persistencia diaria funciona mejor que las estrategias de dos semanas.

Podemos usar la estrategia semana-oya con un RMSE general de 465,294 kilovatios como referencia de rendimiento para que los modelos más sofisticados se consideren hábiles en este marco específico del problema.


daily: [511.886] 452.9, 596.4, 532.1, 490.5, 534.3, 481.5, 482.0
weekly: [469.389] 567.6, 500.3, 411.2, 466.1, 471.9, 358.3, 482.0
week-oya: [465.294] 550.0, 446.7, 398.6, 487.0, 459.3, 313.5, 555.1

También se crea un diagrama de líneas del error de pronóstico diario.

Podemos ver el mismo patrón observado de las estrategias semanales que funcionan mejor que la estrategia diaria en general, excepto en el caso del primer día.

Es sorprendente que la semana de hace un año funcione mejor que la semana anterior porque parece mas lógico esperar que el consumo de energía de la semana pasada fuera más relevante.

La revisión de todas las estrategias en el mismo gráfico sugiere posibles combinaciones de estrategias que pueden dar como resultado un rendimiento aún mejor.

Gráfica de líneas que compara estrategias de pronóstico ingenuo para el pronóstico de energía doméstica

Gráfica de líneas que compara estrategias de pronóstico ingenuo para el pronóstico de energía doméstica

Extensiones

Hay algunas ideas para ampliar el contenido que hemos visto que tal vez desee explorar.

  • Estrategia ingenua adicional . Proponer, desarrollar y evaluar una estrategia ingenua más para pronosticar el consumo de energía de la próxima semana.
  • Estrategia de conjunto ingenua . Desarrollar una estrategia de conjunto que combine las predicciones de los tres métodos de pronóstico ingenuo propuestos.
  • Modelos optimizados de persistencia directa . Probar y encontrar el día anterior relativo óptimo (por ejemplo, -1 o -7) para usar para cada día de pronóstico en un modelo de persistencia directa.

Fuente: https://machinelearningmastery.com/naive-methods-for-forecasting-household-electricity-consumption/