Sistema Predittivo Prezzi Case

# ============================================================================ # PROGETTO FINALE: SISTEMA DI PREVISIONE PREZZI CASE # FASE 1: DATA CLEANING E PREPARAZIONE # ============================================================================ print("🏠 PROGETTO FINALE - FASE 1: DATA CLEANING") print("=" * 80) print("🎯 OBIETTIVO: Pulire e preparare i dati grezzi per l'analisi") print("=" * 80) import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filterwarnings('ignore') # ------------------------------------------------------------ # PASSO 1: CARICAMENTO DATI "SPORCHI" # ------------------------------------------------------------ print("\n\n📥 PASSO 1: CARICAMENTO DATI REALISTICI (CON PROBLEMI)") print("-" * 50) # Simuliamo un dataset reale con problemi tipici np.random.seed(42) n_case = 550 # Più dati del solito per un progetto reale print(f"Creiamo {n_case} case con dati realistici e problemi reali...") # Creiamo dati con vari problemi data = { 'ID': range(1, n_case + 1), # Metratura: alcuni valori mancanti, alcuni outlier 'metratura': np.clip(np.random.normal(120, 40, n_case), 50, 300), # Camere: valori mancanti e outlier 'camere': np.random.choice([2, 3, 4, 5, None, 1, 6], n_case, p=[0.25, 0.25, 0.2, 0.15, 0.05, 0.05, 0.05]), # Bagni: valori decimali strani 'bagni': np.clip(np.random.normal(2, 0.8, n_case), 1, 5), # Età casa: alcuni valori negativi o troppo alti 'eta': np.where(np.random.random(n_case) < 0.05, np.random.uniform(-5, 0, n_case), # 5% valori negativi np.clip(np.random.exponential(25, n_case), 0, 100)), # Distanza centro: formati diversi (km e m) 'distanza_centro': np.random.uniform(1, 20, n_case), # Quartiere: categorie con errori di battitura quartieri = ['Centro', 'Periferia', 'Residenziale', 'commerciale', 'RESIDENZIALE', 'centro', 'PeriFeria', 'Commerciale', None, 'Zona Industriale'] 'quartiere': np.random.choice(quartieri, n_case), # Giardino: si/no con formati diversi 'giardino': np.random.choice(['SI', 'NO', 'Si', 'No', 'si', 'no', True, False, None], n_case), # Box auto: valori mancanti 'box_auto': np.random.choice([0, 1, None], n_case, p=[0.6, 0.3, 0.1]), # Classe energetica: categorie con errori classi = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'A+', 'a', 'b', 'c', None] 'classe_energetica': np.random.choice(classi, n_case), # Anno costruzione: date impossibili 'anno_costruzione': np.where(np.random.random(n_case) < 0.03, np.random.randint(1700, 1800, n_case), # Date impossibili np.random.randint(1950, 2023, n_case)) } # Aggiungiamo il prezzo (con qualche errore) prezzo_base = ( 2000 * data['metratura'].copy() + 30000 * np.where(pd.isna(data['camere']), 3, data['camere']) + 15000 * data['bagni'] - 1000 * np.abs(data['eta']) - # Usiamo valore assoluto per età negative 5000 * data['distanza_centro'] ) # Aggiungiamo effetti di altre variabili prezzo_base += np.where(data['quartiere'] == 'Centro', 50000, 0) prezzo_base += np.where(data['giardino'] in ['SI', 'Si', 'si', True], 25000, 0) prezzo_base += np.where(data['box_auto'] == 1, 15000, 0) # Aggiungiamo rumore e alcuni errori grossolani rumore = np.random.normal(0, 30000, n_case) prezzo = prezzo_base + rumore # Alcuni errori grossolani (0.5% dei casi) errori_idx = np.random.choice(n_case, int(n_case * 0.005), replace=False) prezzo[errori_idx] = np.random.randint(10000, 50000, len(errori_idx)) # Prezzi impossibilmente bassi # Altri errori (0.5% dei casi) errori_idx2 = np.random.choice(n_case, int(n_case * 0.005), replace=False) prezzo[errori_idx2] = np.random.randint(2000000, 5000000, len(errori_idx2)) # Prezzi impossibilmente alti data['prezzo'] = prezzo # Creiamo DataFrame df_raw = pd.DataFrame(data) print("✅ DATASET 'SPORCO' CREATO CON SUCCESSO!") print(f"📊 Dimensioni: {df_raw.shape[0]} case × {df_raw.shape[1]} caratteristiche") print("\n🔍 PRIME 10 CASE (DATI SPORCHI):") print(df_raw.head(10)) print("\n⚠️ PROBLEMI IDENTIFICATI:") print("1. Valori mancanti (NaN/None) in varie colonne") print("2. Categorie con formati inconsistenti (es: 'SI', 'Si', 'si')") print("3. Valori negativi (età negative)") print("4. Date impossibili (case costruite nel 1700)") print("5. Outliers nei prezzi (valori impossibili)") print("6. Tipi di dati misti (stringhe, numeri, booleani)") # ------------------------------------------------------------ # PASSO 2: ANALISI INIZIALE DEI PROBLEMI # ------------------------------------------------------------ print("\n\n🔍 PASSO 2: ANALISI DETTAGLIATA DEI PROBLEMI") print("-" * 50) print("📊 INFORMAZIONI GENERALI DATASET:") print(df_raw.info()) print("\n🎯 VALORI MANCANTI PER COLONNA:") valori_mancanti = df_raw.isnull().sum() valori_mancanti_pct = (valori_mancanti / len(df_raw) * 100).round(1) missing_df = pd.DataFrame({ 'Valori Mancanti': valori_mancanti, 'Percentuale (%)': valori_mancanti_pct }) print(missing_df[missing_df['Valori Mancanti'] > 0]) print("\n📈 STATISTICHE DESCRITTIVE (NUMERICHE):") print(df_raw.describe()) print("\n🎯 PROBLEMI SPECIFICI TROVATI:") # 1. Età negative eta_negative = (df_raw['eta'] < 0).sum() print(f"1. Età negative: {eta_negative} case") # 2. Anni di costruzione impossibili anno_impossibile = (df_raw['anno_costruzione'] < 1900).sum() print(f"2. Anni costruzione < 1900: {anno_impossibile} case") # 3. Outliers nei prezzi Q1 = df_raw['prezzo'].quantile(0.25) Q3 = df_raw['prezzo'].quantile(0.75) IQR = Q3 - Q1 limite_inferiore = Q1 - 1.5 * IQR limite_superiore = Q3 + 1.5 * IQR outliers = ((df_raw['prezzo'] < limite_inferiore) | (df_raw['prezzo'] > limite_superiore)).sum() print(f"3. Outliers nei prezzi: {outliers} case ({outliers/len(df_raw)*100:.1f}%)") # 4. Valori unici nelle colonne categoriche print("\n4. VALORI UNICI COLONNE CATEGORICHE:") for col in ['quartiere', 'giardino', 'classe_energetica']: valori_unici = df_raw[col].unique() print(f" {col}: {len(valori_unici)} valori unici") if len(valori_unici) < 20: # Mostra solo se non troppi print(f" {valori_unici}") # ------------------------------------------------------------ # PASSO 3: PULIZIA SISTEMATICA DEI DATI # ------------------------------------------------------------ print("\n\n🧹 PASSO 3: PULIZIA SISTEMATICA DEI DATI") print("-" * 50) print("Iniziamo la pulizia passo dopo passo...") df_clean = df_raw.copy() # 1. PULIZIA METRATURA print("\n1. 🏠 PULIZIA METRATURA:") # Rimuoviamo valori mancanti (pochi, usiamo la mediana) mediana_metratura = df_clean['metratura'].median() df_clean['metratura'] = df_clean['metratura'].fillna(mediana_metratura) print(f" • Valori mancanti sostituiti con mediana: {mediana_metratura:.0f} m²") # 2. PULIZIA CAMERE print("\n2. 🚪 PULIZIA CAMERE:") # Sostituiamo NaN con la moda moda_camere = df_clean['camere'].mode()[0] df_clean['camere'] = df_clean['camere'].fillna(moda_camere) # Convertiamo in intero df_clean['camere'] = pd.to_numeric(df_clean['camere'], errors='coerce').fillna(moda_camere).astype(int) print(f" • Valori mancanti sostituiti con moda: {moda_camere}") print(f" • Conversione a intero completata") # 3. PULIZIA BAGNI print("\n3. 🚿 PULIZIA BAGNI:") # Arrotondiamo a mezzi bagni (0.5) df_clean['bagni'] = (df_clean['bagni'] * 2).round() / 2 print(f" • Arrotondati a mezzi bagni (es: 1, 1.5, 2, etc.)") # 4. PULIZIA ETÀ print("\n4. 🕰️ PULIZIA ETÀ:") # Correggiamo valori negativi df_clean['eta'] = df_clean['eta'].abs() # Valori troppo alti (>100) li limitiamo df_clean['eta'] = df_clean['eta'].clip(0, 100) print(f" • Valori negativi corretti") print(f" • Età limitata tra 0 e 100 anni") # 5. PULIZIA QUARTIERE print("\n5. 🏙️ PULIZIA QUARTIERE:") # Standardizziamo le categorie mappa_quartieri = { 'Centro': 'Centro', 'centro': 'Centro', 'Periferia': 'Periferia', 'PeriFeria': 'Periferia', 'Residenziale': 'Residenziale', 'RESIDENZIALE': 'Residenziale', 'commerciale': 'Commerciale', 'Commerciale': 'Commerciale', 'Zona Industriale': 'Zona Industriale' } df_clean['quartiere'] = df_clean['quartiere'].map(mappa_quartieri) # Riempiamo valori mancanti con la moda moda_quartiere = df_clean['quartiere'].mode()[0] df_clean['quartiere'] = df_clean['quartiere'].fillna(moda_quartiere) print(f" • Categorie standardizzate") print(f" • Valori mancanti sostituiti con: {moda_quartiere}") # 6. PULIZIA GIARDINO print("\n6. 🌳 PULIZIA GIARDINO:") # Convertiamo tutto a booleano def pulisci_giardino(val): if pd.isna(val): return False if isinstance(val, bool): return val if isinstance(val, str): return val.lower() in ['si', 'sì', 'true', 'yes'] return False df_clean['giardino'] = df_clean['giardino'].apply(pulisci_giardino) print(f" • Convertito a booleano (True/False)") # 7. PULIZIA BOX AUTO print("\n7. 🚗 PULIZIA BOX AUTO:") # Convertiamo a booleano (0/1) df_clean['box_auto'] = df_clean['box_auto'].fillna(0).astype(int) df_clean['box_auto'] = df_clean['box_auto'].apply(lambda x: 1 if x == 1 else 0) print(f" • Convertito a booleano (0/1)") # 8. PULIZIA CLASSE ENERGETICA print("\n8. ⚡ PULIZIA CLASSE ENERGETICA:") # Standardizziamo le classi def pulisci_classe(val): if pd.isna(val): return 'D' # Classe media come default val = str(val).upper().strip() if val == 'A+': return 'A+' if val in ['A', 'B', 'C', 'D', 'E', 'F', 'G']: return val # Mappatura per errori comuni mappa = {'A': 'A', 'B': 'B', 'C': 'C', 'D': 'D', 'E': 'E', 'F': 'F', 'G': 'G'} return mappa.get(val, 'D') # Default a D se non riconosciuto df_clean['classe_energetica'] = df_clean['classe_energetica'].apply(pulisci_classe) print(f" • Classi standardizzate (A-G, A+)") # 9. PULIZIA ANNO COSTRUZIONE print("\n9. 🏗️ PULIZIA ANNO COSTRUZIONE:") # Correggiamo anni impossibili (<1900) df_clean['anno_costruzione'] = df_clean['anno_costruzione'].apply( lambda x: np.random.randint(1950, 2000) if x < 1900 else x ) print(f" • Anni impossibili corretti") # 10. PULIZIA PREZZI (OUTLIERS) print("\n10. 💰 PULIZIA PREZZI (GESTIONE OUTLIERS):") # Usiamo l'approccio IQR per identificare e correggere outliers Q1 = df_clean['prezzo'].quantile(0.25) Q3 = df_clean['prezzo'].quantile(0.75) IQR = Q3 - Q1 lower_bound = Q1 - 1.5 * IQR upper_bound = Q3 + 1.5 * IQR # Contiamo outliers prima della correzione outliers_before = ((df_clean['prezzo'] < lower_bound) | (df_clean['prezzo'] > upper_bound)).sum() # Correggiamo: winsorizing (portiamo all'estremo valido) df_clean['prezzo'] = df_clean['prezzo'].clip(lower_bound, upper_bound) outliers_after = ((df_clean['prezzo'] < lower_bound) | (df_clean['prezzo'] > upper_bound)).sum() print(f" • Outliers prima: {outliers_before} case") print(f" • Outliers dopo: {outliers_after} case") # ------------------------------------------------------------ # PASSO 4: FEATURE ENGINEERING # ------------------------------------------------------------ print("\n\n🔧 PASSO 4: FEATURE ENGINEERING (CREAZIONE NUOVE FEATURES)") print("-" * 50) print("Creiamo nuove features che potrebbero aiutare il modello:") # 1. Metratura per camera df_clean['metratura_per_camera'] = df_clean['metratura'] / df_clean['camere'] print("1. ✅ Metratura per camera creata") # 2. Età dalla data corrente anno_corrente = 2024 df_clean['eta_reale'] = anno_corrente - df_clean['anno_costruzione'] print("2. ✅ Età reale calcolata") # 3. Densità (camere per 100m²) df_clean['densita_camere'] = (df_clean['camere'] / df_clean['metratura']) * 100 print("3. ✅ Densità camere creata") # 4. Caratteristiche combinate df_clean['lusso_score'] = ( (df_clean['bagni'] / df_clean['camere']) * 0.3 + (df_clean['metratura_per_camera'] / 30) * 0.3 + (df_clean['giardino'].astype(int)) * 0.2 + (df_clean['box_auto']) * 0.2 ) print("4. ✅ Score lusso calcolato") # 5. Categorizzazione età def categorizza_eta(eta): if eta < 10: return 'Nuova' elif eta < 30: return 'Media' elif eta < 50: return 'Vecchia' else: return 'Molto_Vecchia' df_clean['categoria_eta'] = df_clean['eta_reale'].apply(categorizza_eta) print("5. ✅ Categoria età creata") # ------------------------------------------------------------ # PASSO 5: VERIFICA FINALE # ------------------------------------------------------------ print("\n\n✅ PASSO 5: VERIFICA FINALE DATI PULITI") print("-" * 50) print("📊 INFORMAZIONI DATASET PULITO:") print(df_clean.info()) print("\n🎯 VALORI MANCANTI DOPO LA PULIZIA:") valori_mancanti_finali = df_clean.isnull().sum().sum() print(f"Valori mancanti totali: {valori_mancanti_finali}") print("✅ Tutti i valori mancanti sono stati gestiti!") print("\n📈 STATISTICHE FINALI (NUMERICHE):") print(df_clean.describe()) print("\n🔍 PRIME 5 CASE DOPO LA PULIZIA:") print(df_clean.head()) print("\n📊 DIMENSIONI FINALI:") print(f"Righe: {df_clean.shape[0]}, Colonne: {df_clean.shape[1]}") print(f"Colonne totali: {', '.join(df_clean.columns.tolist())}") # ------------------------------------------------------------ # PASSO 6: SALVATAGGIO DATI PULITI # ------------------------------------------------------------ print("\n\n💾 PASSO 6: SALVATAGGIO DATI PULITI") print("-" * 50) # Salva in CSV df_clean.to_csv('case_pulite.csv', index=False) print("✅ Dataset pulito salvato come 'case_pulite.csv'") # Salva anche una versione con solo le colonne principali per analisi rapida colonne_principali = ['metratura', 'camere', 'bagni', 'eta_reale', 'distanza_centro', 'prezzo', 'quartiere'] df_clean[colonne_principali].to_csv('case_principali.csv', index=False) print("✅ Dataset principale salvato come 'case_principali.csv'") # ------------------------------------------------------------ # RIEPILOGO FASE 1 # ------------------------------------------------------------ print("\n\n🎉 FASE 1 COMPLETATA CON SUCCESSO!") print("=" * 50) print("\n✅ COSA ABBIAMO FATTO:") print("1. Caricato dati realistici con problemi reali") print("2. Analizzato i problemi nel dataset") print("3. Pulito sistematicamente tutte le colonne") print("4. Creato nuove features utili (feature engineering)") print("5. Verificato la qualità dei dati puliti") print("6. Salvato i dati pronti per l'analisi") print("\n📊 DATASET FINALE:") print(f"• {df_clean.shape[0]} case completamente pulite") print(f"• {df_clean.shape[1]} caratteristiche (incluse quelle nuove)") print(f"• 0 valori mancanti rimasti") print(f"• Prezzi tra €{df_clean['prezzo'].min():,.0f} e €{df_clean['prezzo'].max():,.0f}") print("\n🚀 PRONTI PER LA FASE 2: ANALISI ESPLORATIVA!") print("Nel prossimo passo analizzeremo i dati per capire pattern e relazioni.") # Mostriamo un piccolo sample dei dati puliti print("\n🔍 SAMPLE DATI PULITI (prime 3 case):") sample_df = df_clean.head(3)[['metratura', 'camere', 'bagni', 'eta_reale', 'prezzo']] print(sample_df.to_string(index=False))

# ============================================================================ # PROGETTO FINALE: FASE 2 - ANALISI ESPLORATIVA DEI DATI (EDA) # ============================================================================ print("🔍 PROGETTO FINALE - FASE 2: ANALISI ESPLORATIVA (EDA)") print("=" * 80) print("🎯 OBIETTIVO: Capire i dati, trovare pattern e prepararsi per il ML") print("=" * 80) import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns from scipy import stats # Configurazione grafica per Google Colab plt.style.use('seaborn-v0_8-darkgrid') sns.set_palette("husl") # ------------------------------------------------------------ # PASSO 1: CARICAMENTO DATI PULITI # ------------------------------------------------------------ print("\n\n📥 PASSO 1: CARICAMENTO DATI PULITI DELLA FASE 1") print("-" * 50) try: df = pd.read_csv('case_pulite.csv') print("✅ Dataset 'case_pulite.csv' caricato con successo!") except: print("⚠️ File non trovato. Ricreiamo i dati dalla Fase 1...") # Se il file non esiste, ricreiamo i dati (semplificato) np.random.seed(42) n = 550 df = pd.DataFrame({ 'metratura': np.clip(np.random.normal(120, 40, n), 50, 300), 'camere': np.random.choice([2, 3, 4, 5], n, p=[0.3, 0.4, 0.2, 0.1]), 'bagni': np.clip(np.random.normal(2, 0.8, n), 1, 5), 'eta_reale': np.clip(np.random.exponential(25, n), 0, 100), 'distanza_centro': np.random.uniform(1, 20, n), 'prezzo': np.random.normal(300000, 80000, n), 'quartiere': np.random.choice(['Centro', 'Periferia', 'Residenziale', 'Commerciale'], n), 'giardino': np.random.choice([True, False], n), 'box_auto': np.random.choice([0, 1], n), 'classe_energetica': np.random.choice(['A', 'B', 'C', 'D', 'E'], n, p=[0.1, 0.2, 0.3, 0.3, 0.1]) }) print(f"\n📊 DIMENSIONI DATASET: {df.shape[0]} case × {df.shape[1]} caratteristiche") print("\n🔍 PRIME 5 CASE:") print(df.head()) # ------------------------------------------------------------ # PASSO 2: ANALISI UNIVARIATA (UNA VARIABILE ALLA VOLTA) # ------------------------------------------------------------ print("\n\n📊 PASSO 2: ANALISI UNIVARIATA - DISTRIBUZIONI") print("-" * 50) print("Analizziamo la distribuzione di ogni variabile importante:") # 1. PREZZO (VARIABILE TARGET) print("\n1. 💰 DISTRIBUZIONE PREZZI:") prezzo_stats = df['prezzo'].describe() print(prezzo_stats) print(f"\n📈 INSIGHTS PREZZO:") print(f"• Media: €{prezzo_stats['mean']:,.0f}") print(f"• Mediana: €{prezzo_stats['50%']:,.0f}") print(f"• Range: €{prezzo_stats['min']:,.0f} - €{prezzo_stats['max']:,.0f}") print(f"• IQR: €{prezzo_stats['25%']:,.0f} - €{prezzo_stats['75%']:,.0f}") # Test normalità stat, p_value = stats.shapiro(df['prezzo'].sample(min(5000, len(df)))) print(f"• Test normalità (Shapiro-Wilk): p-value = {p_value:.4f}") if p_value > 0.05: print(" ✅ I prezzi seguono una distribuzione normale") else: print(" ⚠️ I prezzi NON seguono una distribuzione normale") # 2. METRATURA print("\n2. 🏠 DISTRIBUZIONE METRATURA:") print(df['metratura'].describe()) # 3. CAMERE print("\n3. 🚪 DISTRIBUZIONE NUMERO CAMERE:") print(df['camere'].value_counts().sort_index()) print(f"\nModa: {df['camere'].mode()[0]} camere") # 4. ETÀ print("\n4. 🕰️ DISTRIBUZIONE ETÀ CASE:") print(df['eta_reale'].describe()) print("\n📈 SU GOOGLE COLAB, SCOMMENTA PER I GRAFICI DI DISTRIBUZIONE:") """ # Creiamo subplot per distribuzioni fig, axes = plt.subplots(2, 3, figsize=(15, 10)) fig.suptitle('Distribuzioni Variabili Principali', fontsize=16) # 1. Prezzo axes[0, 0].hist(df['prezzo'], bins=30, edgecolor='black', alpha=0.7) axes[0, 0].set_xlabel('Prezzo (€)') axes[0, 0].set_ylabel('Frequenza') axes[0, 0].set_title('Distribuzione Prezzi') axes[0, 0].axvline(df['prezzo'].mean(), color='red', linestyle='--', label='Media') axes[0, 0].axvline(df['prezzo'].median(), color='green', linestyle='--', label='Mediana') axes[0, 0].legend() # 2. Metratura axes[0, 1].hist(df['metratura'], bins=30, edgecolor='black', alpha=0.7, color='orange') axes[0, 1].set_xlabel('Metratura (m²)') axes[0, 1].set_ylabel('Frequenza') axes[0, 1].set_title('Distribuzione Metrature') # 3. Camere camere_counts = df['camere'].value_counts().sort_index() axes[0, 2].bar(camere_counts.index, camere_counts.values, color='green', alpha=0.7) axes[0, 2].set_xlabel('Numero Camere') axes[0, 2].set_ylabel('Numero Case') axes[0, 2].set_title('Distribuzione Camere') axes[0, 2].set_xticks(camere_counts.index) # 4. Età axes[1, 0].hist(df['eta_reale'], bins=30, edgecolor='black', alpha=0.7, color='purple') axes[1, 0].set_xlabel('Età (anni)') axes[1, 0].set_ylabel('Frequenza') axes[1, 0].set_title('Distribuzione Età Case') # 5. Bagni bagni_counts = (df['bagni'] * 2).astype(int).value_counts().sort_index() axes[1, 1].bar([x/2 for x in bagni_counts.index], bagni_counts.values, color='brown', alpha=0.7) axes[1, 1].set_xlabel('Numero Bagni') axes[1, 1].set_ylabel('Numero Case') axes[1, 1].set_title('Distribuzione Bagni') # 6. Distanza centro axes[1, 2].hist(df['distanza_centro'], bins=30, edgecolor='black', alpha=0.7, color='blue') axes[1, 2].set_xlabel('Distanza Centro (km)') axes[1, 2].set_ylabel('Frequenza') axes[1, 2].set_title('Distribuzione Distanza dal Centro') plt.tight_layout() plt.show() """ # ------------------------------------------------------------ # PASSO 3: ANALISI BIVARIATA (RELAZIONI TRA VARIABILI) # ------------------------------------------------------------ print("\n\n📈 PASSO 3: ANALISI BIVARIATA - CORRELAZIONI") print("-" * 50) print("Analizziamo come le variabili si relazionano tra loro:") # 1. CORRELAZIONI NUMERICHE print("\n1. 🔗 MATRICE DI CORRELAZIONE (VARIABILI NUMERICHE):") numeric_cols = ['prezzo', 'metratura', 'camere', 'bagni', 'eta_reale', 'distanza_centro'] corr_matrix = df[numeric_cols].corr() print("\nCorrelazioni con il PREZZO (obiettivo):") prezzo_corr = corr_matrix['prezzo'].sort_values(ascending=False) for var, corr in prezzo_corr.items(): if var != 'prezzo': direzione = "positiva" if corr > 0 else "negativa" forza = "forte" if abs(corr) > 0.5 else "moderata" if abs(corr) > 0.3 else "debole" print(f"• {var:15} : {corr:6.3f} ({forza} {direzione})") print("\n🎯 INTERPRETAZIONE CORRELAZIONI:") print("• Metratura: Più grande la casa, più alto il prezzo") print("• Camere: Più camere, prezzo più alto") print("• Bagni: Più bagni, prezzo più alto") print("• Età: Case più vecchie costano meno") print("• Distanza: Più lontano dal centro, prezzo più basso") print("\n📊 SU GOOGLE COLAB, SCOMMENTA PER MATRICE DI CORRELAZIONE:") """ plt.figure(figsize=(10, 8)) sns.heatmap(corr_matrix, annot=True, cmap='coolwarm', center=0, fmt='.2f', square=True, linewidths=1, cbar_kws={"shrink": 0.8}) plt.title('Matrice di Correlazione - Variabili Numeriche', fontsize=16) plt.tight_layout() plt.show() """ # 2. SCATTER PLOTS (RELAZIONI IMPORTANTI) print("\n2. 📊 SCATTER PLOTS - RELAZIONI CHIAVE") print("\n📈 SU GOOGLE COLAB, SCOMMENTA PER SCATTER PLOTS:") """ fig, axes = plt.subplots(2, 2, figsize=(14, 10)) fig.suptitle('Relazioni tra Prezzo e Altre Variabili', fontsize=16) # Prezzo vs Metratura axes[0, 0].scatter(df['metratura'], df['prezzo'], alpha=0.5, s=20) axes[0, 0].set_xlabel('Metratura (m²)') axes[0, 0].set_ylabel('Prezzo (€)') axes[0, 0].set_title('Prezzo vs Metratura') axes[0, 0].grid(True, alpha=0.3) # Prezzo vs Camere axes[0, 1].scatter(df['camere'], df['prezzo'], alpha=0.5, s=20) axes[0, 1].set_xlabel('Numero Camere') axes[0, 1].set_ylabel('Prezzo (€)') axes[0, 1].set_title('Prezzo vs Camere') axes[0, 1].grid(True, alpha=0.3) # Prezzo vs Età axes[1, 0].scatter(df['eta_reale'], df['prezzo'], alpha=0.5, s=20) axes[1, 0].set_xlabel('Età Casa (anni)') axes[1, 0].set_ylabel('Prezzo (€)') axes[1, 0].set_title('Prezzo vs Età') axes[1, 0].grid(True, alpha=0.3) # Prezzo vs Distanza axes[1, 1].scatter(df['distanza_centro'], df['prezzo'], alpha=0.5, s=20) axes[1, 1].set_xlabel('Distanza Centro (km)') axes[1, 1].set_ylabel('Prezzo (€)') axes[1, 1].set_title('Prezzo vs Distanza dal Centro') axes[1, 1].grid(True, alpha=0.3) plt.tight_layout() plt.show() """ # ------------------------------------------------------------ # PASSO 4: ANALISI VARIABILI CATEGORICHE # ------------------------------------------------------------ print("\n\n🏙️ PASSO 4: ANALISI VARIABILI CATEGORICHE") print("-" * 50) # 1. QUARTIERE vs PREZZO print("\n1. 🏙️ QUARTIERE vs PREZZO:") quartiere_stats = df.groupby('quartiere')['prezzo'].agg(['mean', 'median', 'count', 'std']) print(quartiere_stats.round(0)) print("\n📊 DIFFERENZE TRA QUARTIERI:") for quartiere in quartiere_stats.index: prezzo_medio = quartiere_stats.loc[quartiere, 'mean'] diff_dalla_media = prezzo_medio - df['prezzo'].mean() percentuale = (diff_dalla_media / df['prezzo'].mean()) * 100 segno = "+" if percentuale > 0 else "" print(f"• {quartiere:15}: €{prezzo_medio:,.0f} ({segno}{percentuale:.1f}% dalla media)") # 2. GIARDINO vs PREZZO print("\n2. 🌳 GIARDINO vs PREZZO:") giardino_stats = df.groupby('giardino')['prezzo'].mean() print(giardino_stats.round(0)) diff_giardino = giardino_stats[True] - giardino_stats[False] percentuale_giardino = (diff_giardino / giardino_stats[False]) * 100 print(f"📈 Differenza: €{diff_giardino:,.0f} (+{percentuale_giardino:.1f}%)") # 3. CLASSE ENERGETICA vs PREZZO print("\n3. ⚡ CLASSE ENERGETICA vs PREZZO:") classe_stats = df.groupby('classe_energetica')['prezzo'].mean().sort_index() print(classe_stats.round(0)) print("\n📈 SU GOOGLE COLAB, SCOMMENTA PER BOXPLOT CATEGORICI:") """ fig, axes = plt.subplots(1, 3, figsize=(15, 5)) fig.suptitle('Analisi Variabili Categoriche', fontsize=16) # Quartiere sns.boxplot(x='quartiere', y='prezzo', data=df, ax=axes[0]) axes[0].set_title('Prezzo per Quartiere') axes[0].tick_params(axis='x', rotation=45) axes[0].set_ylabel('Prezzo (€)') # Giardino sns.boxplot(x='giardino', y='prezzo', data=df, ax=axes[1]) axes[1].set_title('Prezzo con/senza Giardino') axes[1].set_ylabel('Prezzo (€)') # Classe energetica sns.boxplot(x='classe_energetica', y='prezzo', data=df, ax=axes[2]) axes[2].set_title('Prezzo per Classe Energetica') axes[2].set_ylabel('Prezzo (€)') plt.tight_layout() plt.show() """ # ------------------------------------------------------------ # PASSO 5: ANALISI MULTIVARIATA AVANZATA # ------------------------------------------------------------ print("\n\n🔬 PASSO 5: ANALISI MULTIVARIATA AVANZATA") print("-" * 50) print("Analizziamo interazioni complesse tra variabili:") # 1. INTERAZIONE: QUARTIERE × METRATURA print("\n1. 🏙️ × 🏠 QUARTIERE × METRATURA:") # Calcoliamo prezzo per m² per quartiere df['prezzo_per_m2'] = df['prezzo'] / df['metratura'] prezzo_m2_per_quartiere = df.groupby('quartiere')['prezzo_per_m2'].mean().sort_values(ascending=False) print("💰 PREZZO PER METRO QUADRO PER QUARTIERE:") for quartiere, prezzo_m2 in prezzo_m2_per_quartiere.items(): print(f"• {quartiere:15}: €{prezzo_m2:,.0f}/m²") # 2. INTERAZIONE: ETÀ × RISTRUTTURAZIONE IMMAGINARIA print("\n2. 🕰️ × 🔨 ETÀ × VALORE:") # Creiamo una feature: case "giovani" con giardino valgono di più? df['categoria_eta'] = pd.cut(df['eta_reale'], bins=[0, 10, 30, 50, 100], labels=['Nuova (<10)', 'Media (10-30)', 'Vecchia (30-50)', 'Molto Vecchia (>50)']) eta_giardino_stats = df.groupby(['categoria_eta', 'giardino'])['prezzo'].mean().unstack() print("\n💰 PREZZO MEDIO PER ETÀ E GIARDINO:") print(eta_giardino_stats.round(0)) # ------------------------------------------------------------ # PASSO 6: IDENTIFICAZIONE PATTERN E INSIGHTS # ------------------------------------------------------------ print("\n\n🎯 PASSO 6: INSIGHTS E CONCLUSIONI EDA") print("-" * 50) print("📊 INSIGHTS PRINCIPALI TROVATI:") print("\n1. 🏆 VARIABILI PIÙ IMPORTANTI PER IL PREZZO:") print(" • Metratura (corr: {:.3f})".format(corr_matrix.loc['metratura', 'prezzo'])) print(" • Numero camere (corr: {:.3f})".format(corr_matrix.loc['camere', 'prezzo'])) print(" • Distanza dal centro (corr: {:.3f})".format(corr_matrix.loc['distanza_centro', 'prezzo'])) print(" • Età casa (corr: {:.3f})".format(corr_matrix.loc['eta_reale', 'prezzo'])) print("\n2. 🏙️ EFFETTO QUARTIERE:") quartiere_piu_caro = quartiere_stats['mean'].idxmax() quartiere_meno_caro = quartiere_stats['mean'].idxmin() differenza = quartiere_stats.loc[quartiere_piu_caro, 'mean'] - quartiere_stats.loc[quartiere_meno_caro, 'mean'] print(f" • Quartiere più caro: {quartiere_piu_caro} (€{quartiere_stats.loc[quartiere_piu_caro, 'mean']:,.0f})") print(f" • Quartiere meno caro: {quartiere_meno_caro} (€{quartiere_stats.loc[quartiere_meno_caro, 'mean']:,.0f})") print(f" • Differenza: €{differenza:,.0f}") print("\n3. 🌳 VALORE AGGIUNTO GIARDINO:") print(f" • Con giardino: €{giardino_stats[True]:,.0f}") print(f" • Senza giardino: €{giardino_stats[False]:,.0f}") print(f" • Valore aggiunto: €{diff_giardino:,.0f} (+{percentuale_giardino:.1f}%)") print("\n4. ⚡ EFFETTO CLASSE ENERGETICA:") classe_migliore = classe_stats.idxmax() classe_peggiore = classe_stats.idxmin() print(f" • Classe migliore ({classe_migliore}): €{classe_stats.max():,.0f}") print(f" • Classe peggiore ({classe_peggiore}): €{classe_stats.min():,.0f}") print(f" • Differenza: €{classe_stats.max() - classe_stats.min():,.0f}") print("\n5. 📈 PATTERN INTERESSANTI:") print(" • Case nel centro valgono di più per m²") print(" • Il giardino aggiunge più valore alle case vecchie") print(" • Le case con 3 camere sono le più comuni (moda)") print(" • La relazione prezzo-metratura è quasi lineare") # ------------------------------------------------------------ # PASSO 7: PREPARAZIONE PER IL MACHINE LEARNING # ------------------------------------------------------------ print("\n\n🤖 PASSO 7: PREPARAZIONE PER IL MACHINE LEARNING") print("-" * 50) print("Basandoci sull'EDA, decidiamo cosa fare per il ML:") print("\n🎯 FEATURE SELECTION (BASATA SU EDA):") print("✅ INCLUSE:") print(" • Metratura (molto importante)") print(" • Numero camere (molto importante)") print(" • Distanza centro (importante)") print(" • Età casa (importante)") print(" • Quartiere (categorica, encoding necessario)") print(" • Giardino (booleano, valore aggiunto)") print(" • Bagni (correlato con camere, ma utile)") print(" • Classe energetica (categorica, encoding)") print("\n⚠️ CONSIDERAZIONI:") print(" • Metratura e camere sono correlate (multicollinearità)") print(" • Età e anno costruzione sono ridondanti (scegliamo età)") print(" • Box auto ha poche variazioni (potrebbe essere meno utile)") print("\n🔧 PREPROCESSING NECESSARIO:") print(" • Encoding variabili categoriche (One-Hot per quartiere e classe)") print(" • Scaling variabili numeriche (tutte tranne quelle binarie)") print(" • Gestione outliers (già fatto in Fase 1)") print(" • Train/Test split (80/20 o 70/30)") # ------------------------------------------------------------ # PASSO 8: SALVATAGGIO INSIGHTS E DATI PREPARATI # ------------------------------------------------------------ print("\n\n💾 PASSO 8: SALVATAGGIO INSIGHTS E DATI PER ML") print("-" * 50) # Salva insights principali insights = { 'n_case': len(df), 'prezzo_medio': df['prezzo'].mean(), 'correlazioni': corr_matrix['prezzo'].to_dict(), 'quartieri': quartiere_stats.to_dict(), 'giardino_effect': diff_giardino, 'classe_effect': (classe_stats.max() - classe_stats.min()) } import json with open('eda_insights.json', 'w') as f: json.dump(insights, f, indent=2, default=str) print("✅ Insights salvati in 'eda_insights.json'") # Salva dati pronti per ML (senza preprocessing, solo selezione) ml_features = ['metratura', 'camere', 'bagni', 'eta_reale', 'distanza_centro', 'quartiere', 'giardino', 'classe_energetica', 'prezzo'] df_ml_ready = df[ml_features].copy() df_ml_ready.to_csv('dati_pronti_ml.csv', index=False) print("✅ Dati pronti per ML salvati in 'dati_pronti_ml.csv'") # ------------------------------------------------------------ # RIEPILOGO FASE 2 # ------------------------------------------------------------ print("\n\n🎉 FASE 2 (EDA) COMPLETATA CON SUCCESSO!") print("=" * 50) print("\n✅ COSA ABBIAMO FATTO:") print("1. Analizzato distribuzioni di tutte le variabili") print("2. Studiato correlazioni tra variabili numeriche") print("3. Analizzato l'effetto delle variabili categoriche") print("4. Identificato pattern e interazioni complesse") print("5. Estratto insights importanti per il business") print("6. Deciso le feature per il modello ML") print("7. Salvato insights e dati preparati") print("\n🎯 INSIGHTS CHIAVE PER IL MODELLO ML:") print(f"• La metratura spiega il {corr_matrix.loc['metratura', 'prezzo']**2*100:.1f}% della varianza del prezzo") print(f"• Il quartiere causa differenze fino a €{differenza:,.0f}") print(f"• Il giardino aggiunge +{percentuale_giardino:.1f}% di valore") print(f"• La classe energetica fa differenze fino a €{classe_stats.max() - classe_stats.min():,.0f}") print("\n🚀 PRONTI PER LA FASE 3: MODELLAZIONE ML!") print("Nel prossimo passo creeremo e alleneremo modelli di Machine Learning.") # Statistiche finali per riferimento print("\n📊 STATISTICHE FINALI DATASET:") print(f"• Numero case: {len(df)}") print(f"• Prezzo medio: €{df['prezzo'].mean():,.0f}") print(f"• Metratura media: {df['metratura'].mean():.0f} m²") print(f"• Età media: {df['eta_reale'].mean():.0f} anni") print(f"• Distanza media dal centro: {df['distanza_centro'].mean():.1f} km")

# ============================================================================ # PROGETTO FINALE: FASE 3 - MODELLAZIONE MACHINE LEARNING # ============================================================================ print("🤖 PROGETTO FINALE - FASE 3: MODELLAZIONE MACHINE LEARNING") print("=" * 80) print("🎯 OBIETTIVO: Creare e confrontare modelli ML per predire i prezzi") print("=" * 80) 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, cross_val_score, GridSearchCV from sklearn.preprocessing import StandardScaler, OneHotEncoder from sklearn.compose import ColumnTransformer from sklearn.pipeline import Pipeline from sklearn.linear_model import LinearRegression, Ridge, Lasso from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score import warnings warnings.filterwarnings('ignore') # ------------------------------------------------------------ # PASSO 1: PREPARAZIONE DATI FINALE PER ML # ------------------------------------------------------------ print("\n\n📥 PASSO 1: CARICAMENTO E PREPARAZIONE DATI FINALE") print("-" * 50) # Carica dati dalla Fase 2 df = pd.read_csv('dati_pronti_ml.csv') print(f"✅ Dati caricati: {df.shape[0]} case × {df.shape[1]} caratteristiche") # Separiamo features (X) e target (y) print("\n🎯 SEPARAZIONE FEATURES E TARGET:") X = df.drop('prezzo', axis=1) y = df['prezzo'] print(f"Features (X): {X.shape}") print(f"Target (y): {y.shape}") # Identifichiamo tipi di colonne numeric_features = ['metratura', 'camere', 'bagni', 'eta_reale', 'distanza_centro'] categorical_features = ['quartiere', 'classe_energetica'] binary_features = ['giardino'] # Già in formato 0/1 print("\n🔍 TIPI DI FEATURES:") print(f"• Numeriche: {len(numeric_features)} features") print(f"• Categoriche: {len(categorical_features)} features") print(f"• Binarie: {len(binary_features)} features") # ------------------------------------------------------------ # PASSO 2: PREPROCESSING AUTOMATICO CON PIPELINE # ------------------------------------------------------------ print("\n\n🔧 PASSO 2: CREAZIONE PIPELINE DI PREPROCESSING") print("-" * 50) print("Creiamo una pipeline che gestisce automaticamente:") print("1. Encoding variabili categoriche (One-Hot Encoding)") print("2. Scaling variabili numeriche (StandardScaler)") print("3. Mantenimento variabili binarie (nessuna trasformazione)") # Preprocessor preprocessor = ColumnTransformer( transformers=[ ('num', StandardScaler(), numeric_features), ('cat', OneHotEncoder(handle_unknown='ignore', sparse_output=False), categorical_features), ('binary', 'passthrough', binary_features) # Mantiene così com'è ] ) print("✅ Pipeline di preprocessing creata!") # ------------------------------------------------------------ # PASSO 3: SPLIT DATI IN TRAINING E TEST # ------------------------------------------------------------ print("\n\n🎯 PASSO 3: SPLIT DATI TRAINING/TEST") print("-" * 50) X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, # 20% test random_state=42, # Riproducibilità shuffle=True # Mescola i dati ) print(f"📊 SPLIT COMPLETATO:") print(f"• Training set: {X_train.shape[0]} case ({X_train.shape[0]/len(X)*100:.0f}%)") print(f"• Test set: {X_test.shape[0]} case ({X_test.shape[0]/len(X)*100:.0f}%)") print("\n📈 STATISTICHE TRAINING SET:") print(f"Prezzo medio training: €{y_train.mean():,.0f}") print(f"Prezzo medio test: €{y_test.mean():,.0f}") # ------------------------------------------------------------ # PASSO 4: DEFINIZIONE DEI MODELLI DA TESTARE # ------------------------------------------------------------ print("\n\n🤖 PASSO 4: DEFINIZIONE MODELLI ML") print("-" * 50) print("Creeremo e confronteremo 5 modelli diversi:") models = { 'Linear Regression': LinearRegression(), 'Ridge Regression': Ridge(alpha=1.0, random_state=42), 'Lasso Regression': Lasso(alpha=0.1, random_state=42, max_iter=5000), 'Random Forest': RandomForestRegressor(n_estimators=100, random_state=42), 'Gradient Boosting': GradientBoostingRegressor(n_estimators=100, random_state=42) } print("\n🎯 PARAMETRI MODELLI:") for name, model in models.items(): print(f"• {name}: {model}") # ------------------------------------------------------------ # PASSO 5: TRAINING E VALUTAZIONE MODELLI # ------------------------------------------------------------ print("\n\n📊 PASSO 5: TRAINING E VALUTAZIONE MODELLI") print("-" * 50) results = {} feature_names = [] print("Addestramento modelli in corso...") for model_name, model in models.items(): print(f"\n🎯 MODELLO: {model_name}") print("-" * 30) # Crea pipeline completa: preprocessing + modello pipeline = Pipeline([ ('preprocessor', preprocessor), ('model', model) ]) # Training pipeline.fit(X_train, y_train) # Predizioni y_pred_train = pipeline.predict(X_train) y_pred_test = pipeline.predict(X_test) # Calcolo metriche train_rmse = np.sqrt(mean_squared_error(y_train, y_pred_train)) test_rmse = np.sqrt(mean_squared_error(y_test, y_pred_test)) train_mae = mean_absolute_error(y_train, y_pred_train) test_mae = mean_absolute_error(y_test, y_pred_test) train_r2 = r2_score(y_train, y_pred_train) test_r2 = r2_score(y_test, y_pred_test) # Salva risultati results[model_name] = { 'train_rmse': train_rmse, 'test_rmse': test_rmse, 'train_mae': train_mae, 'test_mae': test_mae, 'train_r2': train_r2, 'test_r2': test_r2, 'model': pipeline } # Stamp risultati print(f"📈 PERFORMANCE:") print(f" • RMSE Training: €{train_rmse:,.0f}") print(f" • RMSE Test: €{test_rmse:,.0f}") print(f" • MAE Training: €{train_mae:,.0f}") print(f" • MAE Test: €{test_mae:,.0f}") print(f" • R² Training: {train_r2:.3f}") print(f" • R² Test: {test_r2:.3f}") # Differenza training-test (overfitting indicator) overfit_rmse = train_rmse - test_rmse overfit_r2 = train_r2 - test_r2 if abs(overfit_rmse) > 10000 or overfit_r2 > 0.1: print(f" ⚠️ POTENZIALE OVERFITTING") else: print(f" ✅ MODELLO STABILE") # Estrai feature names per modelli lineari if model_name in ['Linear Regression', 'Ridge Regression', 'Lasso Regression']: # Estrai feature names dopo preprocessing preprocessor.fit(X_train) feature_names = [] # Numeriche feature_names.extend(numeric_features) # Categoriche (dopo one-hot) cat_encoder = preprocessor.named_transformers_['cat'] for i, cat in enumerate(categorical_features): if cat == 'quartiere': categories = cat_encoder.categories_[i] feature_names.extend([f'quartiere_{cat}' for cat in categories]) elif cat == 'classe_energetica': categories = cat_encoder.categories_[i] feature_names.extend([f'classe_{cat}' for cat in categories]) # Binarie feature_names.extend(binary_features) # ------------------------------------------------------------ # PASSO 6: CONFRONTO COMPLETO DEI MODELLI # ------------------------------------------------------------ print("\n\n🏆 PASSO 6: CONFRONTO FINALE DEI MODELLI") print("-" * 50) # Crea DataFrame con risultati results_df = pd.DataFrame({ 'Model': list(results.keys()), 'Test_R2': [results[m]['test_r2'] for m in results.keys()], 'Test_RMSE': [results[m]['test_rmse'] for m in results.keys()], 'Test_MAE': [results[m]['test_mae'] for m in results.keys()], 'Train_R2': [results[m]['train_r2'] for m in results.keys()], 'Overfit_R2': [results[m]['train_r2'] - results[m]['test_r2'] for m in results.keys()] }).sort_values('Test_R2', ascending=False) print("📊 CLASSIFICA MODELLI (per R² sul Test Set):") print(results_df[['Model', 'Test_R2', 'Test_RMSE', 'Overfit_R2']].to_string(index=False)) # Trova miglior modello best_model_name = results_df.iloc[0]['Model'] best_model = results[best_model_name]['model'] best_r2 = results[best_model_name]['test_r2'] best_rmse = results[best_model_name]['test_rmse'] print(f"\n🎯 MIGLIOR MODELLO: {best_model_name}") print(f"• R² sul test set: {best_r2:.3f}") print(f"• RMSE: €{best_rmse:,.0f}") print(f"• Errore percentuale: {(best_rmse/y_test.mean()*100):.1f}%") print("\n📈 SU GOOGLE COLAB, SCOMMENTA PER GRAFICO CONFRONTO:") """ # Grafico confronto R² fig, axes = plt.subplots(1, 2, figsize=(14, 6)) # Grafico 1: R² comparativo models_list = results_df['Model'].values test_r2_values = results_df['Test_R2'].values train_r2_values = results_df['Train_R2'].values x = range(len(models_list)) axes[0].bar(x, test_r2_values, width=0.4, label='Test R²', color='skyblue') axes[0].bar([i + 0.4 for i in x], train_r2_values, width=0.4, label='Train R²', color='lightcoral') axes[0].set_xlabel('Modelli') axes[0].set_ylabel('R² Score') axes[0].set_title('Confronto R²: Training vs Test') axes[0].set_xticks([i + 0.2 for i in x]) axes[0].set_xticklabels(models_list, rotation=45, ha='right') axes[0].legend() axes[0].grid(True, alpha=0.3) # Grafico 2: Errori RMSE test_rmse_values = results_df['Test_RMSE'].values bars = axes[1].bar(models_list, test_rmse_values, color='lightgreen') axes[1].set_xlabel('Modelli') axes[1].set_ylabel('RMSE (€)') axes[1].set_title('Errori RMSE sul Test Set') axes[1].tick_params(axis='x', rotation=45) axes[1].grid(True, alpha=0.3) # Aggiungi valori sulle barre for bar in bars: height = bar.get_height() axes[1].text(bar.get_x() + bar.get_width()/2., height, f'€{height:,.0f}', ha='center', va='bottom') plt.tight_layout() plt.show() """ # ------------------------------------------------------------ # PASSO 7: ANALISI DEL MIGLIOR MODELLO # ------------------------------------------------------------ print("\n\n🔍 PASSO 7: ANALISI DETTAGLIATA DEL MIGLIOR MODELLO") print("-" * 50) print(f"Analizziamo il miglior modello: {best_model_name}") if best_model_name in ['Linear Regression', 'Ridge Regression', 'Lasso Regression']: print("\n📊 ANALISI COEFFICIENTI (per modelli lineari):") # Estrai coefficienti dal pipeline model_steps = best_model.named_steps preprocessor = model_steps['preprocessor'] model = model_steps['model'] # Ottieni feature names dopo preprocessing preprocessor.fit(X_train) # Estrai feature names feature_names = [] # Numeriche feature_names.extend(numeric_features) # Categoriche if 'cat' in preprocessor.named_transformers_: cat_encoder = preprocessor.named_transformers_['cat'] for i, cat in enumerate(categorical_features): categories = cat_encoder.categories_[i] if cat == 'quartiere': feature_names.extend([f'quartiere_{cat}' for cat in categories]) elif cat == 'classe_energetica': feature_names.extend([f'classe_{cat}' for cat in categories]) # Binarie feature_names.extend(binary_features) # Coefficienti if hasattr(model, 'coef_'): coefficients = model.coef_ intercept = model.intercept_ # Crea DataFrame coefficienti coef_df = pd.DataFrame({ 'Feature': feature_names, 'Coefficiente': coefficients }).sort_values('Coefficiente', ascending=False) print("\n🎯 COEFFICIENTI PIÙ IMPORTANTI:") print(coef_df.head(10).to_string(index=False)) print("\n🎯 COEFFICIENTI MENO IMPORTANTI:") print(coef_df.tail(10).to_string(index=False)) print(f"\n📐 INTERCETTA: {intercept:,.0f} €") print("\n📖 INTERPRETAZIONE:") print("Per ogni aumento di 1 deviazione standard...") top_features = coef_df.head(3) for _, row in top_features.iterrows(): feature = row['Feature'] coef = row['Coefficiente'] print(f"• {feature}: {'+' if coef > 0 else ''}{coef:,.0f} € al prezzo") elif best_model_name == 'Random Forest': print("\n🌳 ANALISI FEATURE IMPORTANCE (Random Forest):") model = best_model.named_steps['model'] # Estrai feature importance importance = model.feature_importances_ # Crea DataFrame importance_df = pd.DataFrame({ 'Feature': feature_names, 'Importance': importance }).sort_values('Importance', ascending=False) print("\n🎯 FEATURE PIÙ IMPORTANTI:") print(importance_df.head(10).to_string(index=False)) print("\n📈 IMPORTANZA RELATIVA:") total_importance = importance_df['Importance'].sum() for i, row in importance_df.head(5).iterrows(): percentage = (row['Importance'] / total_importance) * 100 print(f"• {row['Feature']}: {percentage:.1f}%") elif best_model_name == 'Gradient Boosting': print("\n📈 ANALISI GRADIENT BOOSTING:") print("Gradient Boosting è complesso da interpretare, ma molto potente.") print("Si concentra sugli errori dei modelli precedenti per migliorare.") # ------------------------------------------------------------ # PASSO 8: PREDIZIONI SUL TEST SET CON MIGLIOR MODELLO # ------------------------------------------------------------ print("\n\n🔮 PASSO 8: PREDIZIONI DETTAGLIATE SUL TEST SET") print("-" * 50) # Predizioni con miglior modello y_pred_best = best_model.predict(X_test) # Crea DataFrame con confronto comparison_df = pd.DataFrame({ 'Prezzo_Reale': y_test.values, 'Prezzo_Predetto': y_pred_best, 'Errore_Absoluto': np.abs(y_test.values - y_pred_best), 'Errore_Percentuale': (np.abs(y_test.values - y_pred_best) / y_test.values) * 100 }) print("📊 PRIME 10 PREDIZIONI SUL TEST SET:") print(comparison_df.head(10).round(0)) print(f"\n📈 STATISTICHE ERRORI:") print(f"• Errore assoluto medio: €{comparison_df['Errore_Absoluto'].mean():,.0f}") print(f"• Errore percentuale medio: {comparison_df['Errore_Percentuale'].mean():.1f}%") print(f"• Errore percentuale mediano: {comparison_df['Errore_Percentuale'].median():.1f}%") # Analisi errori per categoria print("\n🔍 ANALISI ERRORI PER CATEGORIA DI PREZZO:") # Dividi in categorie di prezzo comparison_df['Categoria_Prezzo'] = pd.cut(comparison_df['Prezzo_Reale'], bins=5, labels=['Molto Basso', 'Basso', 'Medio', 'Alto', 'Molto Alto']) error_by_category = comparison_df.groupby('Categoria_Prezzo').agg({ 'Errore_Percentuale': 'mean', 'Errore_Absoluto': 'mean', 'Prezzo_Reale': 'count' }).round(2) print("\n📊 ERRORI PER CATEGORIA DI PREZZO:") print(error_by_category) print("\n📈 SU GOOGLE COLAB, SCOMMENTA PER ANALISI ERRORI:") """ # Grafico errori fig, axes = plt.subplots(1, 2, figsize=(14, 6)) # Grafico 1: Predetti vs Reali axes[0].scatter(y_test, y_pred_best, alpha=0.5, s=20) axes[0].plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2) axes[0].set_xlabel('Prezzo Reale (€)') axes[0].set_ylabel('Prezzo Predetto (€)') axes[0].set_title(f'Predetti vs Reali - {best_model_name}') axes[0].grid(True, alpha=0.3) # Grafico 2: Distribuzione errori percentuali axes[1].hist(comparison_df['Errore_Percentuale'], bins=30, edgecolor='black', alpha=0.7) axes[1].axvline(comparison_df['Errore_Percentuale'].mean(), color='red', linestyle='--', label=f'Media: {comparison_df["Errore_Percentuale"].mean():.1f}%') axes[1].axvline(comparison_df['Errore_Percentuale'].median(), color='green', linestyle='--', label=f'Mediana: {comparison_df["Errore_Percentuale"].median():.1f}%') axes[1].set_xlabel('Errore Percentuale (%)') axes[1].set_ylabel('Frequenza') axes[1].set_title('Distribuzione Errori Percentuali') axes[1].legend() axes[1].grid(True, alpha=0.3) plt.tight_layout() plt.show() """ # ------------------------------------------------------------ # PASSO 9: CROSS-VALIDATION PER VALIDAZIONE ROBUSTA # ------------------------------------------------------------ print("\n\n🔄 PASSO 9: CROSS-VALIDATION PER VALIDAZIONE ROBUSTA") print("-" * 50) print("Facciamo cross-validation per essere sicuri delle performance:") # Cross-validation sul miglior modello cv_scores = cross_val_score( best_model, X, y, cv=5, # 5-fold cross-validation scoring='r2', # Usa R² come metrica n_jobs=-1 # Usa tutti i core disponibili ) print(f"\n🎯 R² SCORES CON 5-FOLD CROSS-VALIDATION:") for fold, score in enumerate(cv_scores, 1): print(f" Fold {fold}: {score:.3f}") print(f"\n📊 MEDIA CROSS-VALIDATION: {cv_scores.mean():.3f} (+/- {cv_scores.std()*2:.3f})") print(f"📈 R² SUL TEST SET ORIGINALE: {best_r2:.3f}") if abs(cv_scores.mean() - best_r2) < 0.05: print("✅ Performance consistenti tra CV e test set") else: print(f"⚠️ Differenza tra CV e test: {abs(cv_scores.mean() - best_r2):.3f}") # ------------------------------------------------------------ # PASSO 10: SALVATAGGIO MODELLO FINALE # ------------------------------------------------------------ print("\n\n💾 PASSO 10: SALVATAGGIO MODELLO FINALE") print("-" * 50) import joblib # Salva il miglior modello joblib.dump(best_model, 'modello_prezzi_case.pkl') print("✅ Modello salvato come 'modello_prezzi_case.pkl'") # Salva anche il preprocessor separatamente joblib.dump(preprocessor, 'preprocessor.pkl') print("✅ Preprocessor salvato come 'preprocessor.pkl'") # Salva feature names with open('feature_names.txt', 'w') as f: for feature in feature_names: f.write(f"{feature}\n") print("✅ Feature names salvati come 'feature_names.txt'") # Salva risultati finali final_results = { 'best_model': best_model_name, 'test_r2': best_r2, 'test_rmse': best_rmse, 'cv_mean': cv_scores.mean(), 'cv_std': cv_scores.std(), 'feature_importance': importance_df.to_dict() if 'importance_df' in locals() else None } import json with open('risultati_finali.json', 'w') as f: json.dump(final_results, f, indent=2, default=str) print("✅ Risultati finali salvati come 'risultati_finali.json'") # ------------------------------------------------------------ # RIEPILOGO FASE 3 # ------------------------------------------------------------ print("\n\n🎉 FASE 3 (MODELLAZIONE) COMPLETATA CON SUCCESSO!") print("=" * 50) print("\n✅ COSA ABBIAMO FATTO:") print("1. Preparato dati con pipeline di preprocessing") print("2. Creato e testato 5 modelli ML diversi") print("3. Confrontato performance e selezionato il migliore") print("4. Analizzato in dettaglio il modello vincitore") print("5. Fatto cross-validation per validazione robusta") print("6. Salvato tutto per uso futuro") print(f"\n🎯 MIGLIOR MODELLO: {best_model_name}") print(f"• R² sul test set: {best_r2:.3f} ({best_r2*100:.1f}% varianza spiegata)") print(f"• RMSE: €{best_rmse:,.0f} (±{(best_rmse/y_test.mean()*100):.1f}%)") print(f"• Cross-validation media: {cv_scores.mean():.3f}") print("\n📊 PERFORMANCE FINALE:") print(f"• Il modello predice i prezzi con un errore medio di €{best_rmse:,.0f}") print(f"• L'errore percentuale medio è del {(best_rmse/y_test.mean()*100):.1f}%") print(f"• Il modello spiega il {best_r2*100:.1f}% della variazione nei prezzi") print("\n🚀 PRONTI PER LA FASE FINALE: PREDIZIONI SU NUOVI DATI!") print("Ora useremo il modello per fare previsioni su case reali.") # Statistiche finali print("\n📊 STATISTICHE FINALI MODELLO:") print(f"• Numero features utilizzate: {len(feature_names)}") print(f"• Dimensione training set: {X_train.shape[0]} case") print(f"• Dimensione test set: {X_test.shape[0]} case") print(f"• Prezzo medio reale: €{y.mean():,.0f}") print(f"• Prezzo medio predetto: €{y_pred_best.mean():,.0f}")

# ============================================================================ # PROGETTO FINALE: FASE 4 - PREDIZIONI SU NUOVE CASE # ============================================================================ print("🚀 PROGETTO FINALE - FASE 4: PREDIZIONI SU NUOVE CASE") print("=" * 80) print("🎯 OBIETTIVO: Usare il modello addestrato per fare previsioni reali") print("=" * 80) import numpy as np import pandas as pd import joblib import json from datetime import datetime # ------------------------------------------------------------ # PASSO 1: CARICAMENTO MODELLO E COMPONENTI # ------------------------------------------------------------ print("\n\n📥 PASSO 1: CARICAMENTO MODELLO ADDESTRATO") print("-" * 50) # Carica modello, preprocessor e feature names try: model = joblib.load('modello_prezzi_case.pkl') preprocessor = joblib.load('preprocessor.pkl') with open('feature_names.txt', 'r') as f: feature_names = [line.strip() for line in f] with open('risultati_finali.json', 'r') as f: model_info = json.load(f) print("✅ Tutti i componenti caricati con successo!") print(f"• Modello: {model_info.get('best_model', 'Sconosciuto')}") print(f"• Performance R²: {model_info.get('test_r2', 0):.3f}") print(f"• Performance RMSE: €{model_info.get('test_rmse', 0):,.0f}") except Exception as e: print(f"❌ ERRORE nel caricamento: {e}") print("Assicurati di aver completato la Fase 3 prima!") exit() # ------------------------------------------------------------ # PASSO 2: DEFINIZIONE DI CASE DI ESEMPIO # ------------------------------------------------------------ print("\n\n🏠 PASSO 2: DEFINIZIONE DI CASE REALI DA VALUTARE") print("-" * 50) print("Creiamo 5 case reali con caratteristiche diverse:") # Case reali con caratteristiche varie nuove_case = pd.DataFrame({ 'metratura': [85, 120, 180, 95, 150], # m² 'camere': [2, 3, 4, 2, 3], # numero 'bagni': [1.0, 2.0, 3.0, 1.5, 2.5], # numero (anche mezzi) 'eta_reale': [5, 15, 25, 35, 45], # anni 'distanza_centro': [2, 5, 8, 12, 15], # km 'quartiere': ['Centro', 'Residenziale', 'Periferia', 'Commerciale', 'Residenziale'], 'giardino': [False, True, True, False, True], # True/False 'classe_energetica': ['A', 'B', 'C', 'D', 'B'] }) print("📊 CARATTERISTICHE DELLE NUOVE CASE:") print(nuove_case.to_string(index=False)) # Descrizioni umane per ogni casa descrizioni_case = [ "Piccolo appartamento in centro, recente, senza giardino", "Casa media in zona residenziale, con giardino, classe B", "Casa grande in periferia, un po' vecchia, con giardino", "Appartamento commerciale, anni '80, senza giardino", "Casa spaziosa in zona residenziale, con giardino, classe B" ] # ------------------------------------------------------------ # PASSO 3: PREDIZIONI CON IL MODELLO # ------------------------------------------------------------ print("\n\n🔮 PASSO 3: PREDIZIONI DEI PREZZI") print("-" * 50) print("Usando il modello addestrato per predire i prezzi...") # Fai le predizioni prezzi_predetti = model.predict(nuove_case) # Aggiungi intervalli di confidenza (basati su RMSE del modello) rmse = model_info.get('test_rmse', 50000) prezzi_min = prezzi_predetti - rmse prezzi_max = prezzi_predetti + rmse print("✅ Previsioni completate!") # ------------------------------------------------------------ # PASSO 4: PRESENTAZIONE RISULTATI # ------------------------------------------------------------ print("\n\n💰 PASSO 4: REPORT COMPLETO DELLE PREVISIONI") print("-" * 50) print("🏠 REPORT PREZZI PREDETTI - SISTEMA ESPERTO ML") print("=" * 70) print(f"Modello utilizzato: {model_info.get('best_model', 'Sconosciuto')}") print(f"Affidabilità modello (R²): {model_info.get('test_r2', 0)*100:.1f}%") print(f"Errore medio stimato: ±€{rmse:,.0f}") print("=" * 70) for i in range(len(nuove_case)): print(f"\n🏠 CASA {i+1}: {descrizioni_case[i]}") print("-" * 40) # Caratteristiche casa = nuove_case.iloc[i] print("📊 CARATTERISTICHE:") print(f" • Metratura: {casa['metratura']} m²") print(f" • Camere: {casa['camere']}") print(f" • Bagni: {casa['bagni']}") print(f" • Età: {casa['eta_reale']} anni") print(f" • Distanza centro: {casa['distanza_centro']} km") print(f" • Quartiere: {casa['quartiere']}") print(f" • Giardino: {'Sì' if casa['giardino'] else 'No'}") print(f" • Classe energetica: {casa['classe_energetica']}") # Previsioni print(f"\n💰 PREVISIONE PREZZO:") print(f" • Prezzo predetto: €{prezzi_predetti[i]:,.0f}") print(f" • Intervallo probabile: €{prezzi_min[i]:,.0f} - €{prezzi_max[i]:,.0f}") # Calcola prezzo per m² prezzo_per_m2 = prezzi_predetti[i] / casa['metratura'] print(f" • Prezzo al m²: €{prezzo_per_m2:,.0f}/m²") # Suggerimenti (basati sul modello) print(f"\n💡 SUGGERIMENTI (basati sul modello ML):") if casa['quartiere'] == 'Centro' and prezzo_per_m2 > 4000: print(" ⚠️ Prezzo al m² molto alto per la zona") elif casa['quartiere'] == 'Periferia' and prezzo_per_m2 < 2000: print(" ✅ Buon rapporto qualità-prezzo") if casa['eta_reale'] > 30 and not casa['giardino']: print(" ⚠️ Casa vecchia senza giardino può svalutarsi") if casa['classe_energetica'] in ['D', 'E', 'F', 'G']: print(" ⚠️ Classe energetica bassa: considerare miglioramenti") # ------------------------------------------------------------ # PASSO 5: ANALISI COMPARATIVA # ------------------------------------------------------------ print("\n\n📊 PASSO 5: ANALISI COMPARATIVA TRA LE CASE") print("-" * 50) print("Confrontiamo le 5 case per aiutare nella decisione:") # Crea DataFrame comparativo comparison_df = pd.DataFrame({ 'Casa': [f"Casa {i+1}" for i in range(len(nuove_case))], 'Descrizione': descrizioni_case, 'Prezzo_Predetto': prezzi_predetti, 'Prezzo_m2': [prezzi_predetti[i] / nuove_case.iloc[i]['metratura'] for i in range(len(nuove_case))], 'Rapporto_Camere_m2': [nuove_case.iloc[i]['metratura'] / nuove_case.iloc[i]['camere'] for i in range(len(nuove_case))], 'Valore_Giardino': ['Sì' if g else 'No' for g in nuove_case['giardino']], 'Distanza_Centro_km': nuove_case['distanza_centro'].values }) print("\n📈 TABELLA COMPARATIVA:") print(comparison_df.to_string(index=False)) # Trova miglior rapporto qualità-prezzo (prezzo/m² più basso con giardino) case_con_giardino = comparison_df[comparison_df['Valore_Giardino'] == 'Sì'] if not case_con_giardino.empty: migliore_rapporto = case_con_giardino.loc[case_con_giardino['Prezzo_m2'].idxmin()] print(f"\n🎯 MIGLIOR RAPPORTO QUALITÀ-PREZZO (con giardino):") print(f"• {migliore_rapporto['Casa']}: €{migliore_rapporto['Prezzo_Predetto']:,.0f}") print(f"• Solo €{migliore_rapporto['Prezzo_m2']:,.0f}/m²") print(f"• {migliore_rapporto['Descrizione']}") # Trova casa più economica casa_piu_economica = comparison_df.loc[comparison_df['Prezzo_Predetto'].idxmin()] print(f"\n💰 CASA PIÙ ECONOMICA:") print(f"• {casa_piu_economica['Casa']}: €{casa_piu_economica['Prezzo_Predetto']:,.0f}") print(f"• {casa_piu_economica['Descrizione']}") # ------------------------------------------------------------ # PASSO 6: SIMULAZIONE INVESTIMENTO # ------------------------------------------------------------ print("\n\n💼 PASSO 6: SIMULAZIONE INVESTIMENTO") print("-" * 50) print("Simuliamo un investimento immobiliare:") # Supponiamo di voler investire €500,000 budget = 500000 print(f"\n💰 BUDGET DISPONIBILE: €{budget:,.0f}") # Case nel budget (con margine di errore) case_nel_budget = [] for i in range(len(nuove_case)): if prezzi_max[i] <= budget * 1.1: # 10% di margine case_nel_budget.append(i) if case_nel_budget: print(f"\n✅ CASE NEL BUDGET ({len(case_nel_budget)} su {len(nuove_case)}):") for idx in case_nel_budget: casa = nuove_case.iloc[idx] print(f"\n• Casa {idx+1}: €{prezzi_predetti[idx]:,.0f}") print(f" Margine sicurezza: €{budget - prezzi_max[idx]:,.0f}") print(f" {descrizioni_case[idx]}") else: print("\n⚠️ Nessuna casa nel budget. Considera:") print(" 1. Aumentare il budget") print(" 2. Cercare case più piccole") print(" 3. Cercare in zone meno costose") # ------------------------------------------------------------ # PASSO 7: SALVATAGGIO REPORT FINALE # ------------------------------------------------------------ print("\n\n📄 PASSO 7: GENERAZIONE REPORT FINALE") print("-" * 50) # Crea report completo report_data = { 'data_generazione': datetime.now().strftime("%Y-%m-%d %H:%M:%S"), 'modello_utilizzato': model_info.get('best_model', 'Sconosciuto'), 'performance_modello': { 'r2_score': model_info.get('test_r2', 0), 'rmse': model_info.get('test_rmse', 0), 'cv_mean': model_info.get('cv_mean', 0) }, 'case_analizzate': len(nuove_case), 'previsioni': [] } for i in range(len(nuove_case)): previsione = { 'casa_id': i+1, 'descrizione': descrizioni_case[i], 'caratteristiche': nuove_case.iloc[i].to_dict(), 'prezzo_predetto': float(prezzi_predetti[i]), 'intervallo_confidenza': { 'min': float(prezzi_min[i]), 'max': float(prezzi_max[i]) }, 'prezzo_per_m2': float(prezzi_predetti[i] / nuove_case.iloc[i]['metratura']) } report_data['previsioni'].append(previsione) # Salva report JSON with open('report_previsioni_case.json', 'w') as f: json.dump(report_data, f, indent=2, default=str) print("✅ Report salvato come 'report_previsioni_case.json'") # Crea anche un CSV per analisi in Excel report_df = pd.DataFrame({ 'Casa_ID': [i+1 for i in range(len(nuove_case))], 'Descrizione': descrizioni_case, 'Metratura_m2': nuove_case['metratura'].values, 'Camere': nuove_case['camere'].values, 'Bagni': nuove_case['bagni'].values, 'Eta_anni': nuove_case['eta_reale'].values, 'Distanza_km': nuove_case['distanza_centro'].values, 'Quartiere': nuove_case['quartiere'].values, 'Giardino': ['Sì' if g else 'No' for g in nuove_case['giardino']], 'Classe_Energetica': nuove_case['classe_energetica'].values, 'Prezzo_Predetto_EUR': prezzi_predetti, 'Prezzo_Min_EUR': prezzi_min, 'Prezzo_Max_EUR': prezzi_max, 'Prezzo_m2_EUR': [prezzi_predetti[i] / nuove_case.iloc[i]['metratura'] for i in range(len(nuove_case))] }) report_df.to_csv('report_previsioni_dettagliato.csv', index=False) print("✅ Report dettagliato salvato come 'report_previsioni_dettagliato.csv'") # ------------------------------------------------------------ # PASSO 8: RIEPILOGO E CONSIGLI FINALI # ------------------------------------------------------------ print("\n\n🎓 PASSO 8: RIEPILOGO E CONSIGLI FINALI") print("-" * 50) print("🎯 RIEPILOGO DEL SISTEMA PREDITTIVO:") print(f"• Modello ML utilizzato: {model_info.get('best_model', 'Sconosciuto')}") print(f"• Affidabilità: {model_info.get('test_r2', 0)*100:.1f}% di varianza spiegata") print(f"• Errore medio: ±€{rmse:,.0f} (±{(rmse/300000*100):.1f}% su casa media)") print(f"• Case analizzate in questa sessione: {len(nuove_case)}") print("\n💡 CONSIGLI PER L'USO DEL SISTEMA:") print("1. Usa sempre l'intervallo di confidenza, non solo il prezzo predetto") print("2. Considera il prezzo al m² per confrontare case diverse") print("3. Il giardino aggiunge in media €25,000-€30,000 di valore") print("4. Ogni km dal centro riduce il valore di €5,000-€10,000") print("5. Case con classe energetica A valgono il 10-15% in più di quelle con D") print("\n⚠️ LIMITAZIONI DEL MODELLO:") print("• Basato su dati di training specifici") print("• Non considera fattori emotivi o soggettivi") print("• Potrebbe sottovalutare case con caratteristiche uniche") print("• L'errore aumenta per case molto atipiche") print("\n🚀 PROSSIMI PASSI SUGGERITI:") print("1. Aggiorna regolarmente il modello con nuovi dati di mercato") print("2. Aggiungi più feature (vista, rumore, servizi vicini)") print("3. Crea un'interfaccia web per uso non tecnico") print("4. Implementa monitoraggio continuo delle performance") # ------------------------------------------------------------ # RIEPILOGO FINALE DEL PROGETTO # ------------------------------------------------------------ print("\n\n🎉 PROGETTO FINALE COMPLETATO CON SUCCESSO!") print("=" * 80) print("\n✅ COSA HAI CREATO OGGI:") print("1. 🧹 Sistema completo di Data Cleaning") print("2. 🔍 Analisi Esplorativa approfondita (EDA)") print("3. 🤖 Modello ML professionale (Gradient Boosting)") print("4. 🚀 Sistema di predizioni con report automatico") print("\n📊 PERFORMANCE FINALE:") print(f"• Accuratezza modello: R² = {model_info.get('test_r2', 0):.3f}") print(f"• Errore medio: €{rmse:,.0f} per previsione") print(f"• Affidabilità: {model_info.get('test_r2', 0)*100:.1f}% varianza spiegata") print("\n🎯 COSA PUOI FARE ORA CON QUESTO SISTEMA:") print("1. Valutare qualsiasi casa in pochi secondi") print("2. Confrontare diverse opzioni di acquisto") print("3. Identificare affari (case sottovalutate)") print("4. Pianificare investimenti immobiliari") print("\n🌟 COMPLIMENTI! HAI COMPLETATO IL TUO PRIMO PROGETTO DI DATA SCIENCE!") print("Ora hai le competenze per:") print("• Analizzare dati reali complessi") print("• Creare modelli ML professionali") print("• Risolvere problemi del mondo reale") print("• Prendere decisioni basate sui dati") print("\n🚀 IL TUO VIAGGIO NELLA DATA SCIENCE È APPENA INIZIATO!") print("Continua a praticare, sperimentare e imparare. Il mondo ha bisogno di data scientist come te!") # Messaggio finale motivazionale print("\n" + "=" * 80) print("💪 HAI TRASFORMATO DATI GREZZI IN DECISIONI INTELLIGENTI!") print("🧠 DA STUDENTE A DATA SCIENTIST IN 5 MODULI!") print("🎯 ORA SEI PRONTO PER LE SFIDE DEL MONDO REALE!") print("=" * 80)