1

Corrección de data defectuosa mediante

regresión lineal múltiple y Redes
Neuronales para aumentar
disponibilidad y confiabilidad en el
análisis de sistemas de distribución de
agua potable
Universidad Tecnologica de Bolivar

Rafael Rincón-T00076683
Data Driven - Decisiones
basadas en Datos
Profesor: Ph.D. Jose Luis Villa
6 de diciembre de 2023

1. Introducción
En las redes de distribución del sistema de acueducto, hay instrumentos para medir
caudal y presión de forma sectorizada, y con esos datos registrados de forma
horaria e indefinidamente, se busca analizar y controlar una eficiente prestación del
servicio. En ocasiones, algunos datos de caudal no se registran correctamente, se
pierden en alguna de las capas del modelo de comunicación, y por diversas causas,
como fallas en el instrumento, en la tubería, en la energía del transmisor, en el
medio del sistema de comunicaciones, en el registro de almacenamiento histórico o
en el procesamiento final. Si no se cuentan con datos certeros de los caudales
presentados en los sectores, se acuden a métodos alternativos para estimar los
caudales y se incurre en riesgo de no hacer una apropiada y oportuna gestión de las
redes. Como propuesta de Solución, se plantea mediante un modelo de regresión
y/o redes neuronales, se puedan obtener valores acertados de caudal, útiles en los
momentos en que no se dispongan de las mediciones o se tengan dudas de ellos
 2

para comprender y manipular el complejo tejido de datos temporales y oscilatorios

que encontramos en la naturaleza y en las aplicaciones prácticas modernas, como la
gestión del sistema de distribución de acueducto.

2. Descripción de la técnicas empleadas

2.1. Regresión Lineal:

La regresión lineal es un modelo estadístico que busca establecer la relación lineal entre
una variable dependiente (objetivo) y una o más variables independientes (predictoras).
Matemáticamente, para un problema de regresión lineal simple con una sola variable
independiente, la fórmula se expresa como:

𝑦 = 𝑚𝑥 + 𝑏

Donde:

● y es la variable dependiente.
● x es la variable independiente.
● m es la pendiente de la línea (coeficiente).
● b es la intersección en el eje
● y (ordenada al origen).

En el caso de regresión lineal múltiple con múltiples variables independientes, la fórmula

se generaliza a:

𝑦 = 𝑏₀ + 𝑏₁𝑥₁ + 𝑏₂𝑥₂ + ... + 𝑏ₙ𝑥ₙ

● "y" es la variable dependiente.

● "x₁, x₂, ..., xₙ" son las variables independientes.
● "b₀" es el término de sesgo o intercepción.
● "b₁, b₂, ..., bₙ" son los coeficientes asociados a cada variable independiente.

El objetivo en la regresión lineal es encontrar los coeficientes "b" que minimicen la suma
de los errores cuadrados entre las predicciones del modelo y los valores reales de la
variable dependiente.
 3
2.2. Redes Neuronales

Las redes neuronales son modelos inspirados en la estructura y funcionamiento del

cerebro humano. Una red neuronal artificial está compuesta por capas de neuronas
interconectadas, cada una de las cuales realiza operaciones matemáticas y aplica una
función de activación.

La arquitectura básica de una red neuronal consta de:

● Capa de entrada: Recibe los datos.

● Capas ocultas: Realizan operaciones y aprendizaje.
● Capa de salida: Produce la predicción.

Cada neurona en una red neuronal tiene pesos y sesgos asociados a las entradas que
recibe. Estos pesos y sesgos se ajustan durante el proceso de entrenamiento para
minimizar una función de pérdida (como el error cuadrático medio o el error absoluto
medio).

La operación en una neurona puede expresarse como:

𝑧 = 𝑤₁𝑥₁ + 𝑤₂𝑥₂ + ... + 𝑤ₙ𝑥ₙ + 𝑏𝑎 = 𝑓(𝑧)

● "z" es la suma ponderada de las entradas más el sesgo.

● "f" es la función de activación (como ReLU, Sigmoide, etc.).
● "w₁, w₂, ..., wₙ" son los pesos de las conexiones.
● "b" es el sesgo.

El proceso de entrenamiento de una red neuronal implica el uso de algoritmos de

optimización, como el descenso de gradiente, para ajustar los pesos y sesgos de la red
con el fin de minimizar la función de pérdida y mejorar su capacidad predictiva.

2.2.1. Función de Activación:

La función de activación introduce no linealidad en la red neuronal, permitiendo que esta

aprenda patrones complejos en los datos. Algunas funciones de activación comunes
son:

ReLU (Rectified Linear Activation): La función ReLU se define como:

𝑓(𝑧) = 𝑚𝑎𝑥(0, 𝑧)
 4

Esta función devuelve cero para valores negativos y el mismo valor para valores
positivos, lo que la hace simple y eficaz.

Sigmoide: La función sigmoide se define como

−𝑧
𝑓(𝑧) = 1/(1 + 𝑒 )

Mapea los valores a un rango entre 0 y 1, y se utiliza comúnmente en la capa de salida

para problemas de clasificación binaria.

Tangente Hiperbólica (Tanh): La función tangente hiperbólica se define como:

𝑧 −𝑧
𝑒 −𝑒
𝑓(𝑧) = 𝑧 −𝑧
𝑒 +𝑒

2.2.2. Función de Pérdida:

La función de pérdida (loss function) evalúa qué tan bien están prediciendo los
resultados del modelo con respecto a los valores reales. En problemas de regresión, el
error cuadrático medio (MSE) o el error absoluto medio (MAE) se utilizan comúnmente
como funciones de pérdida. Para problemas de clasificación, se utilizan funciones como
la entropía cruzada.

2.2.3. Entrenamiento de la Red Neuronal:

Durante el entrenamiento, se utilizan algoritmos de optimización como el descenso de

gradiente estocástico (SGD) o sus variantes (Adam, RMSprop) para ajustar los pesos y
sesgos de la red neuronal. El objetivo es minimizar la función de pérdida, lo que implica
encontrar los pesos y sesgos óptimos que reduzcan al máximo el error entre las
predicciones y los valores reales.

2.2.4. Backpropagation:

El algoritmo de backpropagation es esencial en el entrenamiento de redes neuronales.

Consiste en propagar hacia atrás el error a través de la red para ajustar los pesos y
sesgos en la dirección que minimice la función de pérdida. Esto se hace mediante el
cálculo de gradientes, que indican la dirección y magnitud del ajuste necesario en cada
peso y sesgo para reducir la pérdida.

Entre muchos de estos conceptos que se utilizaron y se profundizaron en la aplicación

del alcance de esta investigación, específicamente se conformó un modelo de regresión
con relaciones de orden superior con variables predictoras múltiples, y regularizadas
 5
para mejorar el desempeño de los modelos obtenidos y su aplicabilidad. Para las redes
neuronales se utilizó TensorFlow 2.0 y su framework insignia Keras, así como las
técnicas profesionales de la inteligencia artificial, empleando cross-validation,
sintonizador Keras Tuner, y las gráficas que evalúan el desempeño del modelo según las
métricas seleccionadas de manera apropiada, que para el caso de una regresión es el
mae o mse (mean absolute error - mean square error)

3. Aplicación
En todo proceso de machine learning de tipo profesional se inicia con la exploración de los datos
para tener una comprensión general del problema a resolver. Para este caso, explicaremos una
señal de caudal enmarcada como una serie de tiempo muestreada de forma horaria durante 2
años.

DateTime
2021-01-01 [Link]
35.203999
2021-01-01 [Link]
36.805000
2021-01-01 [Link]
32.004002
2021-01-01 [Link]
31.205000
2021-01-01 [Link]
39.605000
...
2023-01-01 [Link] 49.206001
2023-01-01 [Link] 42.805000
2023-01-01 [Link] 37.203999
2023-01-01 [Link] 33.202999
2023-01-02 [Link] 22.003000
Name: Caudal, Length: 17545, dtype: float64

Tabla 1. Datos y estadística básica de la serie

Descripción Valor
Conteo 17545
Media 55.39
Desv. Estándar 87.48
Valor min 0.000
Cuartil del 25 por ciento 24.003
Cuartil del 50 por ciento 67.205
Cuartil del 75 por ciento 82.010
Valor max 7748.75

Inmediatamente es apreciable que existen valores de tipo outliers, los cuales serán
tenidos en cuenta en el proceso de limpieza de datos y preprocesamiento.
 6

Figura 1. Exploración de los datos

Estas gráficas son necesarias para aterrizar las bases de la aplicación, al lector o
 7
intervinientes en el proceso y el modelo a implementar. Se observa que esta señal tiene
comportamientos con diferencias marcadas en el tiempo.
Asi mismo, este comportamiento está obedeciendo a otros fenómenos y variables que
influyen sobre la misma, principalmente se deberá incorporar en el análisis la variable de
presión asociada a esta tubería en la cual se está registrando el caudal, y las horas serán
codificadas para facilitar la aproximación de los modelos mediante la técnica de one-hot
coding, binarizado en 24 columnas las 24 horas del día, de esta forma se extraen los
patrones de la señal de una forma directa y la detección de patrones será óptima para
los modelos de machine learning.

3.1. Preprocesamiento y Limpieza de datos

Como se observa en el gráfico, la distribución gaussiana y el boxplot de la serie de
tiempo se ve bastante distorsionada por la presencia de valores de tipo outliers los
cuales deberán ser tratados.
 8
Figura 1. Distribución Gaussiana y Boxplot de los datos

3.2. Aplicando Machine Learning - Regresión Múltiple

En la segunda gráfica es notable el efecto positivo de la corrección de los datos, ahora es

apreciable la forma de la distribución y consistencia de los datos.

Modelo de Regresión Múltiple (Objeto de tipo Pipeline)

La estructura del modelo de regresión lineal se resume en tres componentes y se detalla

así:

Permitiendo aplicar en situaciones como, la descrita en la siguiente gráfica, en la cual se

 9
aprecia que la señal de caudal que abastece un sector permanece estático durante varias
horas, situación muy improbable, al ser el agua un fluido incompresible y cambiante
permanentemente.

En esta gráfica se compara el valor típico obtenido mediante la agrupación de las

mediciones de forma horaria y el cálculo de la mediana, el valor de la predicción y el valor
crudo registrado durante ese día.

3.3. Aplicando Deep Learning - Redes Neuronales

Entrenar el modelo y monitorear la función de pérdida y el parámetro de optimización que

para este caso es el mae - mean absolute error, es importante verificar la efectividad del
aprendizaje en cada época estipulada, así mismo la arquitectura de la red neuronal, con
la cantidad de capas y neuronas, es una tarea de prueba y error, sin embargo con
técnicas adicionales del framework de Keras Tunner es de gran ayuda para estimar los
parametros optimos de la red neuronal. De esta forma se plantea una solución óptima de
arquitectura y parámetros para la red neuronal, consiguiendo los siguientes resultados.
 10

También es fundamental hacer un proceso riguroso de validación del modelo mediante

técnicas como el cross-validation k-fold, con el cual se confirma la robustez del modelo
obtenido con las respectivas métricas de desempeño, calculadas con diferentes
secciones de la data de entrenamiento y validación, consiguiendo los siguientes
resultados:

Las predicciones del modelo de la red neuronal se asemejan muy aproximados a la señal
 11
real, y supone la corrección al momento la pérdida de los datos, presentada a las 10 am
según se aprecia en el gráfico y los datos de ejemplo.

Existen varias maneras de comprobar la calidad del modelo, principalmente el Score o

valor R2.

R-squared (R²) Score: 0.8413692203016634

87/87 [==============================] - 0s 2ms/step
Mean Squared Error (MSE): 87.81237619238425

De forma gráfica se puede apreciar la calidad de las predicciones, sabiendo que estas
métricas suponen una evaluación sobre la totalidad de los datos que también contienen
errores, por lo tanto para efectos prácticos, poder predecir los valores de caudal en esos
momentos de defecto o falla en el dato serán de gran confiabilidad y utilidad para el
proceso de análisis y gestión de las redes.
 12

En el gráfico de residuos, se verifican los errores de las predicciones, también teniendo

en cuenta el componente de aleatoriedad al que responden los datos y posibles ruidos
en las señales.
 13
3.4. Comparativo de Técnicas

Entre la Regresión Múltiple y la implementación de Redes Neuronales, hay gran similitud

en los resultados, para esta investigación el gasto computacional de un modelo de
regresión como el empleado fue notablemente más ahorrativo, en promedio tardando
menos de un segundo en calcularse, mientras que la red neuronal entrenando ha tardado
más de 20 minutos, sin contar el tiempo de prueba y error para establecer la arquitectura
y parámetros óptimos que lograsen resultados más que aceptables.

En este caso, en el cual se presenta un congelamiento de la data real, tanto las

predicciones de la red neuronal como la de la regresión lineal se aproximan entre sí, con
algunas diferencias menores.
 14

En este caso en el cual, la señal real del instrumento y el registro primario del dato marca
un congelamiento total de los datos para ese dia 2022-09-28 se compara entre el valor
típico, la predicción de la red neuronal y la predicción de la regresión, con
particularidades y detalles a profundizar en campo para asegurarse cuál modelo ofrece
mayor confiabilidad en la estimación.

Y finalmente como observaremos a lo largo de la mayoría de los datos, una estrecha

cercanía entre las predicciones y el valor típico conseguido de forma estadística en los
datos para el comportamiento horario de un día del registro de caudal en el servicio de
acueducto.
 15

4. Conclusiones

La utilidad del machine learning es inmensa, sin límites que se puedan imaginar a
simple vista, para esta investigación aplicamos la regresión múltiple mixta
polinomial y un modelo de redes neuronales con tensorflow y Keras, obteniendo
una propuesta para solucionar un gran problema de la industria, como lo son la
falla o defectos en los datos, que requieren ser procesados continuamente y que a
partir de dichos análisis depende la efectividad de la gestión y la sostenibilidad del
proceso.

En términos prácticos, los modelos de regresión lineal, tengan el componente

polinomial y la multivariabilidad, no dejan de ser simples en comparación con las
redes neuronales, pero lo suficientemente robustos para ofrecer predicciones muy
cercanas lo presentado con las predicciones de las redes neuronales.

Cuando el gasto computacional para crear sistemas de apoyo para corregir data
defectuosa, es de relevancia y se requieren modelos rápidos, ligeros y fáciles de
implementar, las técnicas del machine learning serán suficientes, también teniendo
en cuenta que la complejidad de estos sistemas pueden ser soportados por estas
técnicas.

Las redes neuronales tienen un componente de aleatoriedad, muchos parámetros y

aspectos intrínsecos de las redes neuronales son a prueba y error, adaptándose
como una solución de tipo caja negra, sin embargo, son poderosas capaces de
resolver problemas muy complejos para técnicas más livianas como la regresión
múltiple empleada en esta investigación.

En términos generales, se logró proponer un modelo útil para corregir data

defectuosa o con errores en sistemas de distribución de acueducto utilizando
machine learning específicamente regresión polinomial y redes neuronales.
 16

5. Referencias
1. "Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow" por
Aurélien Géron.
2. "Deep Learning with Python" por François Chollet (creador de Keras).
3. "Python Machine Learning" por Sebastian Raschka y Vahid Mirjalili.
4. "A Tutorial on Multivariate Polynomial Fitting" por Xavier Raynaud, Pau Bofill, et
al. (Enfoque en regresión polinómica).
5. "TensorFlow: Large-Scale Machine Learning on Heterogeneous Distributed
Systems" por Martín Abadi, et al. (Detalles sobre la arquitectura y uso de
TensorFlow).
6. "Keras: The Python Deep Learning library" por François Chollet (Artículo original
de Keras).
7. "Journal of Machine Learning Research" - Esta revista contiene una gran
cantidad de artículos sobre Machine Learning, incluyendo implementaciones de
modelos de regresión y redes neuronales.
8. "Neural Networks" - Una revista enfocada en investigaciones y desarrollos
relacionados con redes neuronales artificiales.
9. "IEEE Transactions on Neural Networks and Learning Systems" - Una
publicación de la IEEE que cubre investigaciones en áreas de redes neuronales y
sistemas de aprendizaje
ANEXOS:

import pandas as pd
import numpy as np
import [Link] as plt
import seaborn as sns
data = [Link](hour=[Link],
dayofweek=[Link]) #lunes 0 domingo 6
[Link]("dayofweek").median()
#Análisis Exploratorio:
ylabel = 'CAUDAL'
#[Link]("hour")[ylabel].max().plot(label="max")
#[Link]("hour")[ylabel].min().plot(label="min")
[Link]("hour")[ss].median().plot(label="median")
[Link]("hour")[ss].std().plot(label="std")
[Link](ylabel)
[Link]("Q (m3/hr)")
[Link]()
[Link]()

data[ss].resample("M").mean().plot(label="mean")
[Link]()
[Link]()
[Link]("Q(m3/hr)")
[Link](f"mean daily: {ylabel}")

datos = data[ss]

# Crear la figura con dos subgráficos

fig, axs = [Link](1, 2, figsize=(12, 5))

# Gráfico de campana de Gauss (histograma y distribución normal)

[Link](datos, kde=True, ax=axs[0])
axs[0].set_title('Distribución Gaussiana')
axs[0].set_xlabel('Datos de Nivel')
axs[0].set_ylabel('Ocurrencia')

# Boxplot
[Link](data=datos, ax=axs[1])
axs[1].set_title('Boxplot')
axs[1].set_xlabel('Nivel')

plt.tight_layout()
[Link]()

#REGRESIÓN
from sklearn.linear_model import LinearRegression
from [Link] import PolynomialFeatures, StandardScaler,
OneHotEncoder, MinMaxScaler, RobustScaler
from sklearn.model_selection import train_test_split
import [Link] as metrics
from [Link] import ColumnTransformer
from [Link] import Pipeline

#PREDECIR

def predecir(ss,ff,g=1):
"""
Retorna array con las predicciones según el modelo del sector
especificado
Inputs: ss:Sector,ff:"aaaa-mm-dd"
"""
#g = 0
#ss = ["QHZSO"]
#ff = '2022-12-15'
sspp = ['Presion_Lomas'] if ss=="QHTKL" else addpress(ss)
y_pred = [Link](24).reshape(24,1)
#gotcurv = get_Curv_Tip(ss)
gotcurv = got_curv_df[ss].values
if sspp is not None:

dataaux = addABO(ss, [Link][ff, [ss]+sspp])

try:
month_dummies = pd.get_dummies(dataaux['month'], prefix='month')
except:
print(f"error en: {ss}")
return y_pred
dataaux = [Link]([dataaux, month_dummies], axis=1)
meses_tot = len(month_dummies.[Link]())
dataaux = [Link](columns=["month"])

#regres = [Link](columns=["month"])
#regres = [Link](columns=["year"])

dataaux['hora'] = [Link]
hora_dummies = pd.get_dummies(dataaux['hora'], prefix='hora')
 dataaux = [Link]([dataaux, hora_dummies], axis=1)
dataaux = [Link](columns=["hora"])
colsmodel =
[Link](columns=model_dict[ss].feature_names_in_.tolist())
dataaux = [Link](dataaux,colsmodel,how='outer').fillna(0)
dataaux = [Link](columns=[Link])
y_pred = model_dict[ss].predict(dataaux)
y_pred = [Link](y_pred, a_min=0, a_max=y_pred.max())
if [Link](y_pred.mean()-[Link]())/[Link]() >10:
y_pred = [Link](24)

if g==1:
[Link]()
[Link](y_pred,label='Pred')
[Link](gotcurv,label='Tip')
[Link]([Link][ff, ss].values,label='día')
[Link]()
[Link](f'Predicciones en {ss} del día {ff}')
[Link]('Caudal m3/hr')
[Link]('tiempo (hrs)')
else:
print(f"No se obtuvo predicciones en {ss}")
return y_pred
#REGRESIONAR

def Regres(ss,r=1):
"""
Return DF regresx y model that contain a util way to calculate Q
values throuth
other tags as press, dates and abos,
"""

global score
model = 0
regres = DATAQ[ss].copy()
regres =
regres[(regres>[Link](0.02))&(regres<[Link](0.98))]

sspp = ['Presion_Lomas'] if ss=="QHTKL" else addpress(ss)

if(sspp is not
None)&(DATAQ[DATAQ[ss]<DATAQ[ss].quantile(0.98)].shape[0]!=0):
 regres =
[Link]([regres,DATAQ[DATAQ[ss]<DATAQ[ss].quantile(0.98)][sspp].astyp
e(float)], axis=1, join='inner')
else:
print(f"No se encontraron suficientes datos validos en {ss}")
return 0,0

polynomial_cols = [Link]()[1:]

ss = "QHTKL" if ss=="QHBOMBLOMAS" else ss

if ss in [Link]():
regres = addABO(ss,regres)
month_dummies = pd.get_dummies(regres['month'], prefix='month')
regres = [Link]([regres, month_dummies], axis=1)
meses_tot = len(month_dummies.[Link]())
regres = [Link](columns=["month"])

#regres = [Link](columns=["month"])
#regres = [Link](columns=["year"])

#regres = regres[(regres[ss]>regres[ss].quantile(0.05)) &

(regres[ss]<regres[ss].quantile(0.95))]
regres = [Link](how='any')
regres['hora'] = [Link]
#regres['dayofweek'] = [Link]
hora_dummies = pd.get_dummies(regres['hora'], prefix='hora')
regres = [Link]([regres, hora_dummies], axis=1)
regres = [Link](columns=["hora"])

if (r==1)&([Link][0]>100):

if('ABO' in [Link]()):
if regres['ABO'].isin(['#N/D']).any():
regres['ABO'] = regres['ABO'].replace('#N/D', [Link])
regres = [Link](subset=['ABO'])
print(f"Se han encontrado vacios de Abonados en {ss}")
else:
return print(f"NOO hay valores validos de ABO en {ss}"),0

#REGRESOR
cols = [Link]()
X_cols = cols[1:]
y_col = [cols[0]]
 X = regres[X_cols]
y = regres[y_col]
X_train, X_test, y_train, y_test = train_test_split(X,y)
additional_cols = ['ABO', 'year']
binary_cols = list(set(cols[1:]) - set(polynomial_cols) -
set(additional_cols))

transformer = ColumnTransformer([
('polynomial', PolynomialFeatures(degree=2),
polynomial_cols),
('binary', StandardScaler(), binary_cols),
('linear', MinMaxScaler(), ['ABO','year'])
#...................................
])

model = Pipeline([
('preprocessor', transformer),
('regression', LinearRegression())
])

[Link](X_train, y_train)
y_pred = [Link](X_test)

score = [Link](X_test, y_test)

print(f"Score del modelo: {score} - Sector: {ss}")
elif([Link][0]<=100):
return print(f"No se encontraron suficientes datos validos en
{ss}"),0
else:
print(f"No se encontraron datos de abonados en el TAG: {ss}")

return regres, model, X,y

#MODELADO DINÁMICO
model_dict = {}
model_X = {}
model_y = {}
score_model_dict = {}

for ss in [Link]()[20:24]:
regresx, model,X,y = Regres(ss, 1)
model_dict[ss] = model
model_X[ss] = X
 model_y[ss] = y
score_model_dict[ss] = score

print("Se completo con exito!! La modelación total de los sectores!!

(((examine warnings)))")

#REDES NEURONALES
from sklearn.model_selection import train_test_split
from [Link] import StandardScaler
from [Link] import Sequential
from [Link] import Dense, Dropout
from [Link] import regularizers

ss = "Caudal"
X = model_X[ss].values
y = model_y[ss].values

# Escalado de las características

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# División de los datos en conjunto de entrenamiento y prueba

X_train, X_test, y_train, y_test = train_test_split(X_scaled, y,
test_size=0.2, random_state=42)

model = Sequential()

# Agregando capas ocultas con activación ReLU y regularización

[Link](Dense(96, input_dim=[Link][1], activation='relu',
kernel_regularizer=regularizers.l2(0.01)))
[Link](Dropout(0.2)) # Dropout para reducir el sobreajuste

[Link](Dense(32, activation='relu',
kernel_regularizer=regularizers.l2(0.01)))
[Link](Dropout(0.2))
[Link](Dense(32, activation='relu',
kernel_regularizer=regularizers.l2(0.01)))
[Link](Dropout(0.2))
[Link](Dense(16, activation='relu',
kernel_regularizer=regularizers.l2(0.01)))
[Link](Dropout(0.2))
# Última capa con una neurona para la predicción sin activación
(regresión lineal)
[Link](Dense(1, kernel_regularizer=regularizers.l2(0.01)))

# Compilación del modelo

[Link](optimizer='adam', loss='mean_absolute_error',
metrics=['mae'])

# Entrenamiento del modelo

[Link](X_train, y_train, epochs=500, batch_size=32,
validation_data=(X_test, y_test))

#VALIDACIÓN CRUZADA - CROSS-VALIDATION K-FOLD

from sklearn.model_selection import KFold
import numpy as np

# Tus datos X e y

# Número de divisiones para la validación cruzada

n_splits = 5

# Inicializar el objeto KFold

kf = KFold(n_splits=n_splits, shuffle=True)

# Listas para almacenar las métricas en cada iteración de validación

cruzada
all_losses = []
all_maes = []

# Iterar sobre cada división de la validación cruzada

for train_index, val_index in [Link](X):
X_train_fold, X_val_fold = X[train_index], X[val_index]
y_train_fold, y_val_fold = y[train_index], y[val_index]

# Crear el modelo
model = Sequential()
# Agregando capas ocultas con activación ReLU y regularización
[Link](Dense(96, input_dim=[Link][1], activation='relu',
kernel_regularizer=regularizers.l2(0.01)))
[Link](Dropout(0.2)) # Dropout para reducir el sobreajuste

[Link](Dense(32, activation='relu',
kernel_regularizer=regularizers.l2(0.01)))
 [Link](Dropout(0.2))
[Link](Dense(32, activation='relu',
kernel_regularizer=regularizers.l2(0.01)))
[Link](Dropout(0.2))

# Última capa con una neurona para la predicción sin activación

(regresión lineal)
[Link](Dense(1, kernel_regularizer=regularizers.l2(0.01)))

# Compilar el modelo con métrica MAE

[Link](optimizer='adam', loss='mean_absolute_error',
metrics=['mae'])

# Entrenar el modelo
history = [Link](X_train_fold, y_train_fold, epochs=500,
batch_size=32,
validation_data=(X_val_fold, y_val_fold),
verbose=0)

# Evaluar el modelo en datos de validación

loss, mae = [Link](X_val_fold, y_val_fold)

# Almacenar las métricas

all_losses.append(loss)
all_maes.append(mae)

# Calcular el promedio de las métricas

avg_loss = [Link](all_losses)
avg_mae = [Link](all_maes)

# Resultados promedio de la validación cruzada

print(f"Promedio Loss en validación cruzada: {avg_loss}")
print(f"Promedio Mean Absolute Error en validación cruzada: {avg_mae}")

#MÉTRICAS Y GRÁFICAS PARA EVALUACIÓN DEL MODELO NN

# Evaluación del modelo con los datos de prueba

loss, mse = [Link](X_test, y_test)
# Predicciones del modelo
predictions = [Link](X_test)

#Error Cuadrático Medio (MSE): Mide el promedio de los cuadrados de las

diferencias
#entre las predicciones y los valores reales.
#Cuanto menor sea, mejor será el modelo.

from [Link] import mean_squared_error

# Predicciones del modelo
predictions = [Link](X_test)
# Calcular el MSE
mse = mean_squared_error(y_test, predictions)
print("Mean Squared Error (MSE):", mse)

#Coeficiente de Determinación (R²): Indica cuánta variación de la

variable
#dependiente es explicada por el modelo.
#Un valor cercano a 1 indica un buen ajuste del modelo.
from [Link] import r2_score
# Calcular R²
r2 = r2_score(y_test, predictions)
print("R-squared (R²) Score:", r2)

#Gráfico de Dispersión de Predicciones vs. Valores Reales:

import [Link] as plt
[Link](figsize=(8, 6))
[Link](y_test, predictions)
[Link]("Valores Reales")
[Link]("Predicciones")
[Link]("Gráfico de Dispersión: Valores Reales vs. Predicciones")
[Link]()

#Gráfico de Residuos:
residuals = y_test - predictions
[Link](figsize=(8, 6))
[Link](predictions, residuals)
[Link](y=0, color='r', linestyle='-')
[Link]("Predicciones")
[Link]("Residuos")
[Link]("Gráfico de Residuos")
[Link]()

#Histograma de Residuos:
[Link](figsize=(8, 6))
[Link](residuals, bins=30)
[Link]("Residuos")
[Link]("Frecuencia")
[Link]("Histograma de Residuos")
[Link]()