1. Carga y limpieza de datos

Se cargaron los datos desde un archivo CSV y se seleccionaron las columnas más relevantes para el modelo:

import pandas as pd

df = pd.read_csv("melb_data.csv")
features = ['Rooms', 'Bathroom', 'Car', 'Landsize', 'BuildingArea', 'Lattitude', 'Longtitude']
df_model = df[features + ['Price']].dropna()
                

2. Separación y escalamiento

Se separaron las variables y se escalaron los datos con StandardScaler:

from sklearn.preprocessing import StandardScaler

X = df_model[features]
y = df_model['Price']

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

2. ¿Qué es StandardScaler y para qué se usa?

StandardScaler es una técnica de escalado de características que transforma los datos para que tengan:

• Media = 0
• Desviación estándar = 1

Esta transformación es crucial para muchos algoritmos de machine learning, especialmente redes neuronales, ya que:

• Evita que las características con valores grandes dominen el entrenamiento.
• Hace que el modelo entrene más rápido y de forma más estable.
• Facilita que los pesos se ajusten correctamente en cada capa.

Ejemplo:

from sklearn.preprocessing import StandardScaler

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

Este paso asegura que todas las características (como área del terreno o número de baños) estén en la misma escala antes de ser procesadas por el modelo.

3. División en entrenamiento y prueba

Se usó train_test_split para dividir el dataset:

from sklearn.model_selection import train_test_split

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

4. Regresión lineal

Modelo tradicional de regresión lineal como base de comparación:

from sklearn.linear_model import LinearRegression

lin_reg = LinearRegression()
lin_reg.fit(X_train, y_train)
y_pred_lr = lin_reg.predict(X_test)
                

5. Red neuronal con TensorFlow

Se construyó una red neuronal secuencial usando Keras (de TensorFlow). La arquitectura incluye capas densas (fully connected) que permiten al modelo aprender relaciones complejas entre variables.

Arquitectura:

• Capa de entrada: 7 entradas (una por cada característica del dataset)
• Primera capa oculta: 64 neuronas con función de activación ReLU. Esta capa transforma los datos linealmente y luego introduce no linealidades para detectar patrones complejos.
• Segunda capa oculta: 32 neuronas con activación ReLU. Reduce la dimensionalidad interna y sigue capturando patrones.
• Capa de salida: 1 neurona sin activación, ya que se trata de un problema de regresión (predicción de un número continuo: el precio).

5. Red neuronal con TensorFlow

Modelo de red neuronal usando Keras con dos capas ocultas:

import tensorflow as tf
from tensorflow.keras import layers, models

model = models.Sequential([
  layers.Dense(64, activation='relu', input_shape=(X_train.shape[1],)),
  layers.Dense(32, activation='relu'),
  layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')
model.fit(X_train, y_train, epochs=100, validation_split=0.2, verbose=0)

y_pred_nn = model.predict(X_test).flatten()
              

Detalles de configuración:

• activation='relu': Función de activación no lineal que acelera el entrenamiento y ayuda a evitar el problema del gradiente desvanecido.
• input_shape=(X_train.shape[1],): Indica que cada entrada tiene 7 características.
• optimizer='adam': Optimizador eficiente y ampliamente usado que ajusta los pesos durante el entrenamiento.
• loss='mse': Pérdida por error cuadrático medio, ideal para problemas de regresión.
• epochs=100: Número de iteraciones sobre el conjunto de entrenamiento.
• validation_split=0.2: Se reserva el 20% del entrenamiento para validación interna.

6. Evaluación de modelos

Se comparan ambos modelos con MSE y R²:

from sklearn.metrics import mean_squared_error, r2_score

mse_lr = mean_squared_error(y_test, y_pred_lr)
r2_lr = r2_score(y_test, y_pred_lr)

mse_nn = mean_squared_error(y_test, y_pred_nn)
r2_nn = r2_score(y_test, y_pred_nn)

print("Regresión Lineal → MSE:", mse_lr, "| R²:", r2_lr)
print("Red Neuronal      → MSE:", mse_nn, "| R²:", r2_nn)
                

7. Resultados

Resultados obtenidos (valores aproximados):

• Regresión Lineal: MSE ≈ 5.34e+10, R² ≈ 0.608
• Red Neuronal: MSE ≈ 4.91e+10, R² ≈ 0.631

La red neuronal superó ligeramente a la regresión lineal en ambas métricas.

8. Conclusión

Aunque la regresión lineal es una buena base, las redes neuronales tienen potencial para modelar relaciones no lineales complejas entre las características y el precio de la vivienda. Incluso con una arquitectura simple, se logra una mejora en la predicción.