init

README.md

@@ -0,0 +1,21 @@
+# Driver Placement Optimization System
+
+This Gradio web application analyzes geodata to determine optimal driver placement zones using machine learning.
+
+## Features
+- Upload geodata files for analysis
+- Interactive maps showing priority zones
+- Heatmap visualization of demand-supply imbalance
+- Machine learning-based demand prediction
+
+## How to use
+1. Upload your geodata file (CSV format with lat, lng columns)
+2. The system will process the data and generate two maps:
+   - Priority zones map with top-10 highest demand areas
+   - Heatmap showing demand-supply imbalance
+
+## Technology Stack
+- Gradio for web interface
+- Folium for interactive maps
+- scikit-learn for machine learning predictions
+- Pandas for data processing

app.py

@@ -0,0 +1,245 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import joblib
+import folium
+from folium.plugins import HeatMap
+
+# Загружаем модель
+MODEL_PATH = "model/optimization_model.joblib"
+try:
+    model = joblib.load(MODEL_PATH)
+    print("Модель загружена успешно")
+except:
+    model = None
+    print("Не удалось загрузить модель")
+
+def create_maps(file):
+    """Creating two maps from notebook: markers map and heatmap"""
+    if file is None:
+        return "Please upload geodata file", None, None
+    
+    try:
+        # Read all data without limitations
+        print("Loading data...")
+        df = pd.read_csv(file.name)
+        print(f"Loaded {len(df)} data rows")
+        
+        # Check columns
+        required_cols = ['lat', 'lng', 'spd', 'alt', 'azm', 'randomized_id']
+        if not all(col in df.columns for col in required_cols):
+            return f"Missing columns: {required_cols}", None, None
+        
+        # Calculate distances (simplified)
+        df['distance'] = df.groupby('randomized_id').apply(
+            lambda x: [0] + [100] * (len(x) - 1)  # Simplified, constant distance
+        ).explode().reset_index(drop=True)
+        df['distance'] = pd.to_numeric(df['distance'], errors='coerce')
+        
+        # Create grid WITHOUT categorical data - fix error
+        lat_min, lat_max = df['lat'].min(), df['lat'].max()
+        lng_min, lng_max = df['lng'].min(), df['lng'].max()
+        
+        # Use numeric bins instead of pd.cut
+        df['lat_bin'] = ((df['lat'] - lat_min) // 0.005).astype(int)
+        df['lng_bin'] = ((df['lng'] - lng_min) // 0.005).astype(int)
+        
+        # Create string identifiers for grouping
+        df['lat_grid'] = df['lat_bin'].astype(str)
+        df['lng_grid'] = df['lng_bin'].astype(str)
+        
+        # Aggregate by zones as in notebook
+        df_zone_stats = df.groupby(['lat_grid', 'lng_grid']).agg(
+            zone_avg_spd=('spd', 'mean'),
+            zone_spd_std=('spd', 'std'),
+            zone_min_spd=('spd', 'min'),
+            zone_max_spd=('spd', 'max'),
+            zone_avg_alt=('alt', 'mean'),
+            zone_alt_std=('alt', 'std'),
+            zone_min_alt=('alt', 'min'),
+            zone_max_alt=('alt', 'max'),
+            zone_avg_azm=('azm', 'mean'),
+            zone_azm_std=('azm', 'std'),
+            zone_point_count=('randomized_id', 'count'),
+            zone_total_distance=('distance', 'sum')
+        ).reset_index().fillna(0)
+        
+        # Create target variable
+        zone_counts = df.groupby(['lat_grid', 'lng_grid'])['randomized_id'].nunique().reset_index(name='zone_density')
+        zone_counts['target'] = np.log1p(zone_counts['zone_density'])
+        
+        # Merge data
+        df_ml = pd.merge(df_zone_stats, zone_counts, on=['lat_grid', 'lng_grid'], how='inner')
+        
+        if model is None:
+            return "Model not loaded", None, None
+        
+        # FIX: model expects predicted_demand in data
+        # Add dummy column with value 0
+        df_ml['predicted_demand'] = 0.0
+        
+        # Use all columns except identifiers and target variable
+        X = df_ml.drop(['lat_grid', 'lng_grid', 'zone_density', 'target'], axis=1)
+        
+        # Predict
+        predictions = model.predict(X)
+        
+        # Replace dummy values with real predictions (convert from log-scale)
+        df_ml['predicted_demand'] = np.expm1(predictions)
+        
+        # Create predictions_df as in notebook
+        predictions_df = df_ml[['lat_grid', 'lng_grid', 'zone_avg_alt', 'zone_avg_azm', 
+                               'zone_point_count', 'target', 'predicted_demand']].copy()
+        
+        # Calculate zone center coordinates - use grouping of original data
+        zone_centers = df.groupby(['lat_grid', 'lng_grid']).agg({
+            'lat': 'mean',
+            'lng': 'mean'
+        }).reset_index()
+        
+        # Merge with predictions
+        predictions_df = pd.merge(predictions_df, zone_centers, on=['lat_grid', 'lng_grid'], how='left')
+        
+        # Add calculations as in notebook
+        predictions_df['actual_demand'] = np.expm1(predictions_df['target'])
+        predictions_df['priority_score'] = predictions_df['predicted_demand']  # Already converted
+        predictions_df['supply'] = predictions_df['zone_point_count'] / predictions_df['zone_point_count'].mean()
+        predictions_df['demand_supply_ratio'] = predictions_df['priority_score'] / predictions_df['supply']
+        predictions_df['demand_supply_difference'] = predictions_df['priority_score'] - predictions_df['supply']
+        
+        # Sort by priority
+        predictions_df = predictions_df.sort_values(by='priority_score', ascending=False)
+        
+        # === MAP 1: Top zones with markers (as in notebook) ===
+        top_n = 10
+        top_zones = predictions_df.head(top_n)
+        
+        map_center_lat = top_zones['lat'].mean()
+        map_center_lng = top_zones['lng'].mean()
+        m = folium.Map(location=[map_center_lat, map_center_lng], zoom_start=12)
+        
+        # Add markers for top zones with tooltips
+        for index, row in top_zones.iterrows():
+            tooltip_text = f"Predicted Demand: {row['priority_score']:.2f}<br>" \
+                          f"Actual Demand: {row['actual_demand']:.0f}<br>" \
+                          f"Priority Score: {row['priority_score']:.2f}"
+            folium.Marker(
+                location=[row['lat'], row['lng']],
+                tooltip=tooltip_text,
+                icon=folium.Icon(color='red', icon='info-sign')
+            ).add_to(m)
+        
+        # Save first map and get HTML
+        markers_html = m._repr_html_()
+        
+        # === MAP 2: Heatmap of imbalance (as in notebook) ===
+        # Create data for heatmap
+        heat_data = [[row['lat'], row['lng'], row['demand_supply_difference']] 
+                     for index, row in predictions_df.iterrows()]
+        
+        # Create heatmap
+        map_center_lat = predictions_df['lat'].mean()
+        map_center_lng = predictions_df['lng'].mean()
+        m_heatmap = folium.Map(location=[map_center_lat, map_center_lng], zoom_start=12)
+        
+        # Add heatmap
+        HeatMap(heat_data).add_to(m_heatmap)
+        
+        # Get HTML for second map
+        heatmap_html = m_heatmap._repr_html_()
+        
+        status = f"Processed {len(predictions_df)} zones from {len(df)} data points"
+        
+        return status, markers_html, heatmap_html
+        
+    except Exception as e:
+        return f"Error: {str(e)}", None, None
+
+# Create beautiful Gradio interface
+with gr.Blocks(
+    title="Driver Placement Optimization System",
+    theme=gr.themes.Soft(),
+    css="""
+    .main-container {
+        max-width: 1400px;
+        margin: 0 auto;
+        padding: 20px;
+    }
+    .header {
+        text-align: center;
+        margin-bottom: 30px;
+        color: white;
+        padding: 20px;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        border-radius: 15px;
+        color: white;
+    }
+    .upload-section {
+        background: #f8f9fa;
+        padding: 20px;
+        border-radius: 10px;
+        margin-bottom: 20px;
+    }
+    .maps-container {
+        gap: 20px;
+    }
+    .map-card {
+        background: white;
+        border: 1px solid #e0e0e0;
+        border-radius: 10px;
+        padding: 15px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+    }
+    """
+) as interface:
+    
+    with gr.Column(elem_classes="main-container"):
+        with gr.Row(elem_classes="header"):
+            gr.Markdown(
+                """
+                # Driver Placement Optimization System
+                ### Geodata analysis for optimal placement zones
+                """,
+                elem_classes="header-text"
+            )
+        
+        with gr.Row(elem_classes="upload-section"):
+            with gr.Column():
+                gr.Markdown("### Data Upload")
+                file_input = gr.File(
+                    label="Select file with geodata",
+                    elem_id="file-upload"
+                )
+                status_output = gr.Textbox(
+                    label="Processing Status",
+                    interactive=False,
+                    lines=2
+                )
+        
+        gr.Markdown("### Analysis Results")
+        
+        with gr.Row(elem_classes="maps-container"):
+            with gr.Column(elem_classes="map-card"):
+                gr.Markdown("#### Priority Zones Map")
+                gr.Markdown("*Displays top-10 zones with highest demand*")
+                map1_output = gr.HTML(
+                    label="Top Zones Map for Driver Placement",
+                    elem_id="map1"
+                )
+            
+            with gr.Column(elem_classes="map-card"):
+                gr.Markdown("#### Imbalance Heatmap")
+                gr.Markdown("*Shows difference between demand and supply*")
+                map2_output = gr.HTML(
+                    label="Demand-Supply Imbalance Heatmap",
+                    elem_id="map2"
+                )
+    
+    file_input.change(
+        fn=create_maps,
+        inputs=file_input,
+        outputs=[status_output, map1_output, map2_output]
+    )
+
+if __name__ == "__main__":
+    interface.launch(server_name="127.0.0.1", server_port=7870, share=False)

model/optimization_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab47250d98f86d183ed95f5b6aa8d4017597d0d510be8d4fb43abd623d4ae75c
+size 409969

requirements.txt

@@ -0,0 +1,6 @@
+gradio==3.50.2
+pandas
+numpy
+scikit-learn
+joblib
+folium