upload app.py

app.py

@@ -0,0 +1,352 @@
+# 🏠 MiamiHomeAI - Real Estate Price Predictor for Hugging Face Spaces
+# AI-powered Miami real estate price prediction
+
+import gradio as gr
+import pandas as pd
+import numpy as np
+from sklearn.ensemble import RandomForestRegressor
+import joblib
+from pathlib import Path
+import json
+
+print("🏠 MiamiHomeAI iniciando...")
+
+# Configuración
+ZONES = [
+    'Beachfront', 'Coastal', 'Downtown', 'Suburban', 'Waterfront',
+    'Premium', 'Luxury', 'Urban', 'Residential', 'Commercial'
+]
+
+FLOOD_ZONES = ['X', 'AE', 'VE', 'AH', 'AO']
+
+class FeatureEngineer:
+    """Feature engineering para el modelo de precios"""
+    
+    @staticmethod
+    def create_features(data):
+        """Crear las mismas características que en el entrenamiento"""
+        df = data.copy()
+        
+        # Características básicas
+        df['Size_per_Room'] = df['Size'] / (df['Rooms'] + 1e-6)
+        df['Bathroom_Ratio'] = df['Bathrooms'] / (df['Rooms'] + 1e-6)
+        df['Is_New'] = (df['Age'] < 3).astype(int)
+        df['Is_Renovated'] = ((df['Age'] > 20) & (df['Age'] < 25)).astype(int)
+        
+        # Transformaciones no lineales
+        df['Log_Size'] = np.log1p(df['Size'])
+        df['Sqrt_Beach_Distance'] = np.sqrt(df['Beach_Distance'] + 1)
+        df['Inverse_Beach_Distance'] = 1 / (df['Beach_Distance'] + 0.1)
+        
+        # Características geográficas
+        coastal_zones = ['Beachfront', 'Coastal', 'Waterfront']
+        df['Coastal_Zone'] = df['Zone'].apply(
+            lambda x: 1 if any(zone in str(x) for zone in coastal_zones) else 0
+        )
+        df['Premium_Zone'] = df['Zone'].apply(
+            lambda x: 1 if any(term in str(x) for term in ['Premium', 'Luxury']) else 0
+        )
+        
+        # Codificación de flood zone
+        flood_risk_mapping = {'X': 0, 'AE': 1, 'VE': 2, 'AH': 1, 'AO': 1}
+        df['Flood_Risk'] = df['Flood_Zone'].map(flood_risk_mapping).fillna(0)
+        
+        # Interacciones
+        df['Size_Flood_Risk'] = df['Size'] * df['Flood_Risk']
+        df['Coastal_Beach_Interaction'] = df['Coastal_Zone'] * df['Inverse_Beach_Distance']
+        
+        return df
+
+def load_model():
+    """Cargar modelo entrenado o crear modelo demo"""
+    model_files = [
+        "miami_premium_model_v2.joblib",
+        "miami_premium_model.joblib", 
+        "miami_model.joblib",
+        "real_estate_model.joblib"
+    ]
+    
+    for file_name in model_files:
+        if Path(file_name).exists():
+            try:
+                model_data = joblib.load(file_name)
+                if isinstance(model_data, dict) and 'model' in model_data:
+                    print(f"✅ Modelo cargado: {file_name}")
+                    return model_data['model'], True, model_data.get('metadata', {})
+                else:
+                    print(f"✅ Modelo simple cargado: {file_name}")
+                    return model_data, True, {}
+            except Exception as e:
+                print(f"❌ Error cargando {file_name}: {e}")
+                continue
+    
+    print("⚠️ Modelo no encontrado, usando predicciones demo")
+    return None, False, {}
+
+# Cargar modelo
+model, model_loaded, metadata = load_model()
+
+def predict_price(size, rooms, bathrooms, age, zone, school_rating, beach_distance, flood_zone):
+    """Predecir precio de la propiedad"""
+    
+    try:
+        # Crear DataFrame con los inputs
+        input_data = pd.DataFrame({
+            'Size': [size],
+            'Rooms': [rooms], 
+            'Bathrooms': [bathrooms],
+            'Age': [age],
+            'Zone': [zone],
+            'School_Rating': [school_rating],
+            'Beach_Distance': [beach_distance],
+            'Flood_Zone': [flood_zone]
+        })
+        
+        if model_loaded and model is not None:
+            # Aplicar feature engineering
+            features_df = FeatureEngineer.create_features(input_data)
+            
+            # Realizar predicción
+            try:
+                predicted_price = model.predict(features_df)[0]
+                confidence = "Alta" if model_loaded else "Demo"
+                
+                # Formatear precio
+                price_formatted = f"${predicted_price:,.0f}"
+                
+                # Análisis de factores
+                analysis = analyze_property_factors(
+                    size, rooms, bathrooms, age, zone, 
+                    school_rating, beach_distance, flood_zone, predicted_price
+                )
+                
+                result = f"""
+🏠 **PREDICCIÓN DE PRECIO - MIAMIHOMEAI**
+
+💰 **Precio Estimado: {price_formatted}**
+🎯 **Confianza: {confidence}**
+
+{analysis}
+
+📊 **Detalles de la Propiedad:**
+• 📐 Tamaño: {size:,} ft²
+• 🏠 Habitaciones: {rooms}
+• 🚿 Baños: {bathrooms}
+• 📅 Edad: {age} años
+• 🌍 Zona: {zone}
+• 🎓 Rating Escolar: {school_rating}/10
+• 🏖️ Distancia a Playa: {beach_distance} millas
+• 🌊 Zona de Inundación: {flood_zone}
+
+🤖 **Modelo entrenado con técnicas avanzadas de ML**
+"""
+                
+            except Exception as e:
+                result = f"❌ Error en predicción: {str(e)}"
+                
+        else:
+            # Predicción demo
+            base_price = 300000
+            price_per_sqft = 200 + (school_rating * 20)
+            zone_multiplier = get_zone_multiplier(zone)
+            beach_bonus = max(0, (5 - beach_distance) * 50000)
+            age_penalty = age * 2000
+            
+            demo_price = (base_price + 
+                         (size * price_per_sqft * zone_multiplier) + 
+                         beach_bonus - age_penalty)
+            
+            price_formatted = f"${demo_price:,.0f}"
+            
+            result = f"""
+🏠 **PREDICCIÓN DEMO - MIAMIHOMEAI**
+
+💰 **Precio Estimado: {price_formatted}**
+🎯 **Confianza: DEMO**
+
+⚠️ **MODO DEMOSTRACIÓN**
+Esta es una predicción simulada para mostrar la funcionalidad.
+Para predicciones reales, carga el modelo entrenado.
+
+📊 **Factores considerados:**
+• Tamaño de la propiedad
+• Calificación escolar  
+• Proximidad a la playa
+• Zona de ubicación
+• Edad de la propiedad
+
+🤖 **Sube tu modelo entrenado para predicciones reales**
+"""
+        
+        return result
+        
+    except Exception as e:
+        return f"❌ Error procesando datos: {str(e)}"
+
+def get_zone_multiplier(zone):
+    """Obtener multiplicador por zona"""
+    multipliers = {
+        'Luxury': 2.5,
+        'Premium': 2.0, 
+        'Beachfront': 1.8,
+        'Waterfront': 1.6,
+        'Coastal': 1.4,
+        'Downtown': 1.2,
+        'Urban': 1.0,
+        'Suburban': 0.9,
+        'Residential': 0.8,
+        'Commercial': 0.7
+    }
+    return multipliers.get(zone, 1.0)
+
+def analyze_property_factors(size, rooms, bathrooms, age, zone, school_rating, beach_distance, flood_zone, price):
+    """Analizar factores que influyen en el precio"""
+    
+    factors = []
+    
+    # Análisis de tamaño
+    if size > 3000:
+        factors.append("🏰 **Propiedad grande** - Aumenta significativamente el valor")
+    elif size < 1200:
+        factors.append("🏠 **Propiedad compacta** - Precio más accesible")
+    
+    # Análisis de ubicación
+    if any(term in zone for term in ['Beachfront', 'Waterfront']):
+        factors.append("🏖️ **Ubicación premium** - Vista al agua incrementa valor")
+    elif 'Luxury' in zone or 'Premium' in zone:
+        factors.append("💎 **Zona de lujo** - Área exclusiva con precios elevados")
+    
+    # Análisis de proximidad a playa
+    if beach_distance < 1:
+        factors.append("🌊 **Muy cerca de la playa** - Excelente ubicación costera")
+    elif beach_distance > 5:
+        factors.append("🚗 **Lejos de la playa** - Precio más moderado")
+    
+    # Análisis de edad
+    if age < 5:
+        factors.append("✨ **Propiedad nueva** - Sin depreciación por edad")
+    elif age > 30:
+        factors.append("🔧 **Propiedad madura** - Posible necesidad de renovación")
+    
+    # Análisis escolar
+    if school_rating >= 8:
+        factors.append("🎓 **Excelentes escuelas** - Muy atractivo para familias")
+    elif school_rating < 5:
+        factors.append("📚 **Escuelas básicas** - Factor que reduce el valor")
+    
+    if not factors:
+        factors.append("📊 **Propiedad estándar** - Características promedio del mercado")
+    
+    return "\n".join([f"• {factor}" for factor in factors])
+
+print("✅ MiamiHomeAI listo!")
+
+# Crear interfaz Gradio
+interface = gr.Interface(
+    fn=predict_price,
+    inputs=[
+        gr.Slider(
+            minimum=500, maximum=10000, value=2000, step=50,
+            label="🏠 Tamaño (ft²)", 
+            info="Superficie total de la propiedad"
+        ),
+        gr.Slider(
+            minimum=1, maximum=10, value=3, step=1,
+            label="🛏️ Habitaciones",
+            info="Número total de habitaciones"
+        ),
+        gr.Slider(
+            minimum=1, maximum=8, value=2, step=0.5,
+            label="🚿 Baños", 
+            info="Número de baños completos y medios"
+        ),
+        gr.Slider(
+            minimum=0, maximum=50, value=10, step=1,
+            label="📅 Edad (años)",
+            info="Años desde la construcción"
+        ),
+        gr.Dropdown(
+            choices=ZONES, value="Coastal",
+            label="🌍 Zona",
+            info="Ubicación geográfica de la propiedad"
+        ),
+        gr.Slider(
+            minimum=1, maximum=10, value=7, step=0.1,
+            label="🎓 Rating Escolar",
+            info="Calificación promedio de escuelas cercanas (1-10)"
+        ),
+        gr.Slider(
+            minimum=0, maximum=20, value=2, step=0.1,
+            label="🏖️ Distancia a Playa (millas)",
+            info="Distancia a la playa más cercana"
+        ),
+        gr.Dropdown(
+            choices=FLOOD_ZONES, value="X",
+            label="🌊 Zona de Inundación",
+            info="Clasificación FEMA de riesgo de inundación"
+        )
+    ],
+    outputs=gr.Textbox(
+        label="💰 Predicción de Precio",
+        lines=15,
+        show_copy_button=True
+    ),
+    title="🏠 MiamiHomeAI - Predictor de Precios Inmobiliarios",
+    description="""
+    **🎯 Inteligencia Artificial para predicción de precios inmobiliarios en Miami**
+    
+    Obtén estimaciones precisas del valor de propiedades basadas en:
+    📐 Características físicas • 🌍 Ubicación geográfica • 🎓 Calidad educativa • 🏖️ Proximidad costera
+    
+    Desarrollado con técnicas avanzadas de Machine Learning
+    """,
+    article="""
+    ### 🏖️ Sobre el Mercado Inmobiliario de Miami
+    
+    Miami es uno de los mercados inmobiliarios más dinámicos de Estados Unidos, caracterizado por:
+    
+    **🌊 Factores Clave del Precio:**
+    - **Proximidad a la playa**: Las propiedades costeras pueden valer 2-3x más
+    - **Zona de ubicación**: Áreas como South Beach, Brickell, y Coral Gables son premium
+    - **Riesgo de inundación**: Factor crítico en una ciudad costera
+    - **Calidad escolar**: Influye significativamente en el valor residencial
+    
+    **📊 Características del Modelo:**
+    - **Algoritmos**: Random Forest, XGBoost, LightGBM, Stacking Ensemble
+    - **Feature Engineering**: 15+ características derivadas automáticamente
+    - **Validación**: Cross-validation y división estratificada por precio
+    - **Precisión**: Optimizado para el mercado específico de Miami
+    
+    **🎯 Casos de Uso:**
+    - **🏡 Compradores**: Evaluar si un precio es justo
+    - **🏢 Agentes**: Pricing automático de propiedades
+    - **💼 Inversores**: Análisis de oportunidades de inversión
+    - **🏦 Bancos**: Evaluación para préstamos hipotecarios
+    
+    **⚠️ Disclaimers:**
+    - Las predicciones son estimaciones basadas en datos históricos
+    - El mercado inmobiliario puede fluctuar por factores externos
+    - Consulta siempre con profesionales inmobiliarios locales
+    
+    ### 🔧 Tecnología
+    **Framework:** Scikit-learn, XGBoost, LightGBM • **UI:** Gradio • **Deploy:** Hugging Face Spaces
+    
+    ---
+    
+    **🏠 Desarrollado con ❤️ para el mercado inmobiliario de Miami**
+    """,
+    examples=[
+        [2500, 3, 2, 5, "Beachfront", 8.5, 0.5, "X"],
+        [1800, 2, 2, 15, "Downtown", 7.0, 3.0, "AE"], 
+        [4000, 4, 3, 2, "Luxury", 9.0, 0.2, "X"],
+        [1200, 1, 1, 25, "Suburban", 6.0, 8.0, "VE"]
+    ],
+    cache_examples=False,
+    theme="default"
+)
+
+# Lanzar aplicación
+if __name__ == "__main__":
+    print("🌐 Lanzando MiamiHomeAI...")
+    interface.launch()
+    print("🎉 ¡MiamiHomeAI lanzado exitosamente!")