🏠 Regressione Lineare per Previsione Prezzi Immobili

Impara Machine Learning predittivo con Scikit-Learn e dataset reali

Introduzione

Benvenuto nella tua prima esercitazione di Machine Learning! Imparerai a costruire un modello di regressione lineare che predice i prezzi delle case basandosi su caratteristiche come metratura, numero di camere e posizione. Useremo Scikit-Learn, la libreria Python più popolare per il ML.

Scenario Reale:
Lavorerai come Data Scientist per un’agenzia immobiliare che vuole automatizzare la stima dei prezzi delle case. Costruirai un modello ML che impara dai dati storici e fa previsioni accurate.

⚠️ ATTENZIONE: COPIA BLOCCATA

Il codice è protetto da sistema anti-copia. Dovrai SCRIVERE manualmente tutto il codice per imparare veramente! 🚫📋

Parte 1: Setup e Dataset

▶ Importazione Librerie ML

1
Crea una nuova cella su Google Colab e importa le librerie:
PYTHON
# IMPORT LIBRERIE PER MACHINE LEARNING
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

# Configurazione visualizzazione
sns.set_style("whitegrid")
plt.rcParams['figure.figsize'] = (12, 8)

print("✅ Librerie ML importate correttamente!")
print("📊 Librerie disponibili:")
print(f"  • NumPy: {np.__version__}")
print(f"  • Pandas: {pd.__version__}")
print(f"  • Scikit-Learn: importato")

▶ Creazione Dataset Immobiliare

2
Crea il dataset di case per il training:
PYTHON
# 2. CREAZIONE DATASET IMMOBILIARE DI ESEMPIO
np.random.seed(42)  # Per risultati riproducibili

# Genera dati sintetici realistici
n_case = 100

# Caratteristiche (features)
metratura = np.random.randint(50, 300, n_case)  # m²
camere = np.random.randint(1, 6, n_case)        # numero camere
bagni = np.random.randint(1, 4, n_case)         # numero bagni
eta = np.random.randint(0, 50, n_case)          # anni costruzione
zona = np.random.choice([1, 2, 3], n_case, p=[0.3, 0.5, 0.2])  # 1=centro, 2=periferia, 3=suburbano

# Calcola prezzo base (target variable)
# Formula: prezzo = 2000*metratura + 30000*camere + 20000*bagni - 1000*eta + 50000*zona + rumore
prezzo_base = (2000 * metratura + 
               30000 * camere + 
               20000 * bagni - 
               1000 * eta + 
               50000 * zona)

# Aggiungi rumore casuale
rumore = np.random.randn(n_case) * 50000
prezzo = prezzo_base + rumore

# Crea DataFrame Pandas
df_case = pd.DataFrame({
    'metratura': metratura,
    'camere': camere,
    'bagni': bagni,
    'eta': eta,
    'zona': zona,
    'prezzo': prezzo
})

# Converti zona in categorie
df_case['zona_desc'] = df_case['zona'].map({1: 'Centro', 2: 'Periferia', 3: 'Suburbano'})

print("🏠 DATASET IMMOBILIARE CREATO")
print("="*50)
print(f"Numero case nel dataset: {len(df_case)}")
print("\nPrime 5 righe del dataset:")
print(df_case.head())
print("\n📊 Statistiche descrittive:")
print(df_case.describe())

Parte 2: Analisi Esplorativa dei Dati (EDA)

▶ Visualizzazione Relazioni

3
Analizza le relazioni tra variabili:
PYTHON
# 3. ANALISI ESPLORATIVA DEI DATI (EDA)
print("🔍 ANALISI ESPLORATIVA DATI IMMOBILIARI")
print("="*50)

# 3.1 Distribuzione prezzi
print("\n📈 DISTRIBUZIONE PREZZI:")
print(f"Prezzo medio: €{df_case['prezzo'].mean():,.0f}")
print(f"Prezzo mediano: €{df_case['prezzo'].median():,.0f}")
print(f"Prezzo minimo: €{df_case['prezzo'].min():,.0f}")
print(f"Prezzo massimo: €{df_case['prezzo'].max():,.0f}")
print(f"Deviazione standard: €{df_case['prezzo'].std():,.0f}")

# 3.2 Correlazioni tra variabili
print("\n📊 MATRICE DI CORRELAZIONE:")
correlation_matrix = df_case[['metratura', 'camere', 'bagni', 'eta', 'zona', 'prezzo']].corr()
print(correlation_matrix.round(2))

# 3.3 Visualizzazione grafica
print("\n🎨 CREAZIONE GRAFICI DI ANALISI...")

# Configura subplots
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
fig.suptitle('Analisi Dataset Immobiliare', fontsize=16, fontweight='bold')

# 1. Distribuzione prezzi
axes[0, 0].hist(df_case['prezzo'], bins=20, edgecolor='black', alpha=0.7, color='skyblue')
axes[0, 0].set_title('Distribuzione Prezzi Case')
axes[0, 0].set_xlabel('Prezzo (€)')
axes[0, 0].set_ylabel('Frequenza')

# 2. Prezzo vs Metratura
axes[0, 1].scatter(df_case['metratura'], df_case['prezzo'], alpha=0.6, color='green')
axes[0, 1].set_title('Prezzo vs Metratura')
axes[0, 1].set_xlabel('Metratura (m²)')
axes[0, 1].set_ylabel('Prezzo (€)')

# 3. Prezzo vs Numero Camere
box_data = [df_case[df_case['camere'] == i]['prezzo'] for i in sorted(df_case['camere'].unique())]
axes[0, 2].boxplot(box_data, labels=sorted(df_case['camere'].unique()))
axes[0, 2].set_title('Prezzo vs Numero Camere')
axes[0, 2].set_xlabel('Numero Camere')
axes[0, 2].set_ylabel('Prezzo (€)')

# 4. Prezzo vs Zona
zone_prezzi = df_case.groupby('zona_desc')['prezzo'].mean()
colors = ['gold', 'lightcoral', 'lightgreen']
axes[1, 0].bar(zone_prezzi.index, zone_prezzi.values, color=colors)
axes[1, 0].set_title('Prezzo Medio per Zona')
axes[1, 0].set_xlabel('Zona')
axes[1, 0].set_ylabel('Prezzo Medio (€)')
axes[1, 0].tick_params(axis='x', rotation=45)

# 5. Heatmap Correlazioni
im = axes[1, 1].imshow(correlation_matrix.values, cmap='coolwarm', aspect='auto')
axes[1, 1].set_title('Matrice di Correlazione')
axes[1, 1].set_xticks(range(len(correlation_matrix.columns)))
axes[1, 1].set_yticks(range(len(correlation_matrix.columns)))
axes[1, 1].set_xticklabels(correlation_matrix.columns, rotation=45)
axes[1, 1].set_yticklabels(correlation_matrix.columns)
plt.colorbar(im, ax=axes[1, 1])

# 6. Prezzo vs Età Costruzione
axes[1, 2].scatter(df_case['eta'], df_case['prezzo'], alpha=0.6, color='purple')
axes[1, 2].set_title('Prezzo vs Età Costruzione')
axes[1, 2].set_xlabel('Età (anni)')
axes[1, 2].set_ylabel('Prezzo (€)')

plt.tight_layout()
plt.show()

print("✅ Analisi EDA completata con successo!")

Parte 3: Preparazione Dati per Machine Learning

▶ Split Train/Test e Preprocessing

4
Prepara i dati per il modello ML:
PYTHON
# 4. PREPARAZIONE DATI PER MACHINE LEARNING
print("⚙️  PREPARAZIONE DATI PER IL MODELLO")
print("="*50)

# 4.1 Definizione Features (X) e Target (y)
# Selezioniamo le caratteristiche più rilevanti
features = ['metratura', 'camere', 'bagni', 'eta', 'zona']
X = df_case[features]
y = df_case['prezzo']

print(f"\nFeatures selezionate: {features}")
print(f"Dimensione X (features): {X.shape}")
print(f"Dimensione y (target): {y.shape}")

# 4.2 Split in Train e Test set
# Usiamo 80% per training e 20% per testing
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print(f"\n📊 SPLIT DATI COMPLETATO:")
print(f"  Training set: {X_train.shape[0]} case ({X_train.shape[0]/len(df_case)*100:.0f}%)")
print(f"  Test set: {X_test.shape[0]} case ({X_test.shape[0]/len(df_case)*100:.0f}%)")

# 4.3 Mostra esempio dati di training
print("\n📋 ESEMPIO DATI DI TRAINING (prime 3 righe):")
train_sample = pd.concat([X_train.head(3), y_train.head(3)], axis=1)
print(train_sample)

# 4.4 Normalizzazione delle features (opzionale per regressione lineare)
# Per regressione lineare, spesso non serve normalizzazione
# ma la mostriamo per completezza
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

print("\n🔢 NORMALIZZAZIONE COMPLETATA")
print("  Features scalate con media=0 e deviazione=1")

Parte 4: Addestramento Modello di Regressione

▶ Creazione e Training Modello

5
Crea e addestra il modello di regressione:
PYTHON
# 5. ADDESTRAMENTO MODELLO DI REGRESSIONE LINEARE
print("🤖 ADDESTRAMENTO MODELLO ML")
print("="*50)

# 5.1 Creazione modello
model = LinearRegression()
print("✅ Modello LinearRegression creato")

# 5.2 Addestramento con dati di training
print("\n⚡ Addestramento modello in corso...")
model.fit(X_train_scaled, y_train)
print("✅ Modello addestrato con successo!")

# 5.3 Coefficienti del modello (importanza features)
coefficients = pd.DataFrame({
    'feature': features,
    'coefficient': model.coef_
}).sort_values('coefficient', ascending=False)

print("\n📊 COEFFICIENTI DEL MODELLO (importanza features):")
print(coefficients)
print(f"\nIntercetta (bias): €{model.intercept_:,.2f}")

# 5.4 Interpretazione coefficienti
print("\n🔍 INTERPRETAZIONE COEFFICIENTI:")
for idx, row in coefficients.iterrows():
    segno = "+" if row['coefficient'] > 0 else "-"
    effetto = "aumenta" if row['coefficient'] > 0 else "diminuisce"
    print(f"  • {row['feature']}: {segno}€{abs(row['coefficient']):,.0f} per unità → {effetto} il prezzo")

▶ Valutazione Modello

6
Valuta le performance del modello:
PYTHON
# 6. VALUTAZIONE DEL MODELLO
print("\n📈 VALUTAZIONE PERFORMANCE MODELLO")
print("="*50)

# 6.1 Predizioni sui set di training e test
y_pred_train = model.predict(X_train_scaled)
y_pred_test = model.predict(X_test_scaled)

# 6.2 Calcolo metriche di valutazione
def calculate_metrics(y_true, y_pred, dataset_name):
    mae = mean_absolute_error(y_true, y_pred)
    mse = mean_squared_error(y_true, y_pred)
    rmse = np.sqrt(mse)
    r2 = r2_score(y_true, y_pred)
    
    print(f"\n📊 METRICHE {dataset_name.upper()}:")
    print(f"  • MAE (Mean Absolute Error): €{mae:,.0f}")
    print(f"  • MSE (Mean Squared Error): €{mse:,.0f}")
    print(f"  • RMSE (Root Mean Squared Error): €{rmse:,.0f}")
    print(f"  • R² Score: {r2:.3f}")
    
    return mae, rmse, r2

# Calcola metriche per training e test
mae_train, rmse_train, r2_train = calculate_metrics(y_train, y_pred_train, "training")
mae_test, rmse_test, r2_test = calculate_metrics(y_test, y_pred_test, "test")

# 6.3 Visualizzazione predizioni vs valori reali
print("\n🎨 VISUALIZZAZIONE RISULTATI...")

fig, axes = plt.subplots(1, 2, figsize=(15, 6))

# Training set
axes[0].scatter(y_train, y_pred_train, alpha=0.6, color='blue')
axes[0].plot([y_train.min(), y_train.max()], [y_train.min(), y_train.max()], 'r--', lw=2)
axes[0].set_title('Training Set: Valori Reali vs Predetti')
axes[0].set_xlabel('Prezzo Reale (€)')
axes[0].set_ylabel('Prezzo Predetto (€)')
axes[0].grid(True, alpha=0.3)

# Test set
axes[1].scatter(y_test, y_pred_test, alpha=0.6, color='green')
axes[1].plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
axes[1].set_title('Test Set: Valori Reali vs Predetti')
axes[1].set_xlabel('Prezzo Reale (€)')
axes[1].set_ylabel('Prezzo Predetto (€)')
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# 6.4 Analisi residui
print("\n🔍 ANALISI RESIDUI (errori di predizione):")
residui_test = y_test - y_pred_test

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.scatter(y_pred_test, residui_test, alpha=0.6, color='purple')
plt.axhline(y=0, color='r', linestyle='--')
plt.title('Residui vs Predizioni')
plt.xlabel('Prezzo Predetto (€)')
plt.ylabel('Residuo (€)')
plt.grid(True, alpha=0.3)

plt.subplot(1, 2, 2)
plt.hist(residui_test, bins=20, edgecolor='black', alpha=0.7, color='orange')
plt.title('Distribuzione Residui')
plt.xlabel('Residuo (€)')
plt.ylabel('Frequenza')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

print("✅ Valutazione modello completata!")

Parte 5: Utilizzo Pratico del Modello

▶ Previsioni su Nuove Case

7
Usa il modello per fare previsioni:
PYTHON
# 7. UTILIZZO MODELLO PER PREVISIONI
print("🔮 PREVISIONI SU NUOVE CASE")
print("="*50)

# 7.1 Crea nuove case per la previsione
nuove_case = pd.DataFrame({
    'metratura': [120, 85, 200, 150, 90],
    'camere': [3, 2, 4, 3, 2],
    'bagni': [2, 1, 3, 2, 1],
    'eta': [10, 25, 5, 15, 30],
    'zona': [2, 1, 3, 2, 1]  # 1=centro, 2=periferia, 3=suburbano
})

print("🏠 NUOVE CASE DA VALUTARE:")
nuove_case_display = nuove_case.copy()
nuove_case_display['zona_desc'] = nuove_case_display['zona'].map({1: 'Centro', 2: 'Periferia', 3: 'Suburbano'})
print(nuove_case_display[['metratura', 'camere', 'bagni', 'eta', 'zona_desc']])

# 7.2 Preprocessing nuove case (usando lo stesso scaler)
X_nuove_scaled = scaler.transform(nuove_case)

# 7.3 Fai previsioni
previsioni = model.predict(X_nuove_scaled)

# 7.4 Mostra risultati
print("\n💰 PREZZI PREVISTI:")
risultati = nuove_case.copy()
risultati['zona_desc'] = risultati['zona'].map({1: 'Centro', 2: 'Periferia', 3: 'Suburbano'})
risultati['prezzo_previsto'] = previsioni

for idx, row in risultati.iterrows():
    print(f"\nCasa #{idx + 1}:")
    print(f"  • Metratura: {row['metratura']} m²")
    print(f"  • Camere: {row['camere']}")
    print(f"  • Bagni: {row['bagni']}")
    print(f"  • Età: {row['eta']} anni")
    print(f"  • Zona: {row['zona_desc']}")
    print(f"  • 💰 Prezzo stimato: €{row['prezzo_previsto']:,.0f}")

# 7.5 Analisi sensibilità: come cambia il prezzo con le caratteristiche
print("\n📊 ANALISI DI SENSIBILITÀ:")
print("Come cambia il prezzo al variare delle caratteristiche:")

# Casa di riferimento
casa_base = pd.DataFrame({
    'metratura': [100],
    'camere': [3],
    'bagni': [2],
    'eta': [10],
    'zona': [2]
})

prezzo_base = model.predict(scaler.transform(casa_base))[0]
print(f"\nCasa base (100m², 3 camere, 2 bagni, 10 anni, periferia): €{prezzo_base:,.0f}")

# Variazioni
variazioni = [
    ("+20m²", {"metratura": 120}),
    ("+1 camera", {"camere": 4}),
    ("+1 bagno", {"bagni": 3}),
    ("+10 anni", {"eta": 20}),
    ("Centro città", {"zona": 1}),
    ("Suburbano", {"zona": 3})
]

for desc, cambiamenti in variazioni:
    casa_variazione = casa_base.copy()
    for key, value in cambiamenti.items():
        casa_variazione[key] = value
    
    prezzo_variazione = model.predict(scaler.transform(casa_variazione))[0]
    differenza = prezzo_variazione - prezzo_base
    segno = "+" if differenza > 0 else ""
    
    print(f"  {desc}: €{prezzo_variazione:,.0f} ({segno}€{abs(differenza):,.0f})")

print("\n✅ Sistema di previsione prezzi completato con successo!")

Concetti di Machine Learning Appresi

Congratulazioni! Ora conosci:

  • ✓ Regressione Lineare: Modello ML per previsioni numeriche
  • ✓ Scikit-Learn: Libreria Python più usata per ML
  • ✓ EDA (Exploratory Data Analysis): Analisi preliminare dei dati
  • ✓ Train/Test Split: Separazione dati per valutazione modelli
  • ✓ Feature Scaling: Normalizzazione dati per ML
  • ✓ Metriche di Valutazione: MAE, MSE, RMSE, R² Score
  • ✓ Interpretazione Modelli: Coefficienti e loro significato
  • ✓ Pipeline ML Completa: Dati → Preprocessing → Training → Valutazione → Previsioni

Prossimi Passi nel Machine Learning

Nella prossima esercitazione imparerai:

  • 🌺 Classificazione con dataset Iris
  • 📊 Regressione multipla avanzata
  • 🔍 Feature engineering e selezione
  • 🤖 Algoritmi di ensemble (Random Forest)
  • 🧠 Reti neurali per regressione

Hai costruito il tuo primo modello di Machine Learning professionale!

Torna in alto