Update app.py

app.py

@@ -14,6 +14,8 @@ class F1AerodynamicPredictor:
         self.model = RandomForestRegressor(n_estimators=100, random_state=42)
         self.scaler = StandardScaler()
         self.is_trained = False
+        self.current_data = None
+        self.data_source = "None"
         self.feature_names = ['front_wing_angle', 'rear_wing_angle', 'ride_height', 
                              'suspension_stiffness', 'downforce', 'drag_coefficient',
                              'track_temp', 'wind_speed', 'track_grip']
@@ -68,6 +70,65 @@ class F1AerodynamicPredictor:
             'lap_time': lap_time
         })
     
+    def validate_uploaded_data(self, df):
+        """Validate uploaded data format and content"""
+        required_columns = self.feature_names + ['lap_time']
+        missing_columns = [col for col in required_columns if col not in df.columns]
+        
+        if missing_columns:
+            return False, f"Missing required columns: {missing_columns}"
+        
+        # Check for reasonable value ranges
+        validation_ranges = {
+            'front_wing_angle': (0, 50),
+            'rear_wing_angle': (0, 50),
+            'ride_height': (10, 150),
+            'suspension_stiffness': (10, 300),
+            'downforce': (200, 2000),
+            'drag_coefficient': (0.3, 3.0),
+            'track_temp': (5, 60),
+            'wind_speed': (0, 30),
+            'track_grip': (0.3, 1.2),
+            'lap_time': (60, 180)
+        }
+        
+        validation_issues = []
+        for col, (min_val, max_val) in validation_ranges.items():
+            if col in df.columns:
+                out_of_range = df[(df[col] < min_val) | (df[col] > max_val)]
+                if len(out_of_range) > 0:
+                    validation_issues.append(f"{col}: {len(out_of_range)} values out of range ({min_val}-{max_val})")
+        
+        if validation_issues:
+            return False, f"Data validation issues: {'; '.join(validation_issues)}"
+        
+        return True, "Data validation successful"
+    
+    def load_user_data(self, file_path):
+        """Load and validate user-uploaded data"""
+        try:
+            # Try to read the file
+            if file_path.name.endswith('.csv'):
+                df = pd.read_csv(file_path.name)
+            elif file_path.name.endswith(('.xlsx', '.xls')):
+                df = pd.read_excel(file_path.name)
+            else:
+                return None, "Unsupported file format. Please upload CSV or Excel files."
+            
+            # Validate data
+            is_valid, message = self.validate_uploaded_data(df)
+            if not is_valid:
+                return None, message
+            
+            # Store the data
+            self.current_data = df
+            self.data_source = "User uploaded"
+            
+            return df, f"Successfully loaded {len(df)} records from uploaded file."
+            
+        except Exception as e:
+            return None, f"Error loading file: {str(e)}"
+    
     def train_model(self, data):
         """Train the aerodynamic performance model"""
         X = data[self.feature_names]
@@ -130,40 +191,6 @@ class F1AerodynamicPredictor:
         
         return optimal_setup, optimal_lap_time
     
-    def analyze_sensitivity(self, base_setup, track_conditions):
-        """Analyze sensitivity of lap time to setup changes"""
-        if not self.is_trained:
-            return None, None
-        
-        # Base lap time
-        base_params = list(base_setup) + list(track_conditions)
-        base_lap_time = self.predict_lap_time(base_params)
-        
-        # Analyze each parameter
-        sensitivity_data = []
-        param_names = ['Front Wing', 'Rear Wing', 'Ride Height', 'Suspension', 'Downforce', 'Drag Coeff']
-        
-        for i, param_name in enumerate(param_names):
-            # Test parameter variations
-            variations = np.linspace(0.8, 1.2, 21)  # ±20% variation
-            lap_times = []
-            
-            for var in variations:
-                test_setup = base_setup.copy()
-                test_setup[i] *= var
-                test_params = list(test_setup) + list(track_conditions)
-                lap_time = self.predict_lap_time(test_params)
-                lap_times.append(lap_time)
-            
-            sensitivity_data.append({
-                'parameter': param_name,
-                'variations': variations,
-                'lap_times': lap_times,
-                'sensitivity': np.std(lap_times)
-            })
-        
-        return sensitivity_data, base_lap_time
-    
     def create_visualizations(self, data):
         """Create aerodynamic analysis visualizations"""
         fig, axes = plt.subplots(2, 2, figsize=(15, 12))
@@ -202,6 +229,60 @@ class F1AerodynamicPredictor:
         
         plt.tight_layout()
         return fig
+    
+    def compare_datasets(self, synthetic_data, user_data):
+        """Compare user data with synthetic baseline"""
+        fig, axes = plt.subplots(2, 2, figsize=(15, 12))
+        
+        # Lap time distributions
+        axes[0, 0].hist(synthetic_data['lap_time'], bins=30, alpha=0.7, 
+                       label='Synthetic', color='blue', edgecolor='black')
+        axes[0, 0].hist(user_data['lap_time'], bins=30, alpha=0.7, 
+                       label='User Data', color='red', edgecolor='black')
+        axes[0, 0].set_xlabel('Lap Time (s)')
+        axes[0, 0].set_ylabel('Frequency')
+        axes[0, 0].set_title('Lap Time Distribution Comparison')
+        axes[0, 0].legend()
+        axes[0, 0].grid(True, alpha=0.3)
+        
+        # Aerodynamic efficiency comparison
+        synthetic_eff = synthetic_data['downforce'] / synthetic_data['drag_coefficient']
+        user_eff = user_data['downforce'] / user_data['drag_coefficient']
+        
+        axes[0, 1].scatter(synthetic_data['drag_coefficient'], synthetic_data['downforce'], 
+                          alpha=0.5, label='Synthetic', color='blue')
+        axes[0, 1].scatter(user_data['drag_coefficient'], user_data['downforce'], 
+                          alpha=0.5, label='User Data', color='red')
+        axes[0, 1].set_xlabel('Drag Coefficient')
+        axes[0, 1].set_ylabel('Downforce (N)')
+        axes[0, 1].set_title('Aerodynamic Trade-off Comparison')
+        axes[0, 1].legend()
+        axes[0, 1].grid(True, alpha=0.3)
+        
+        # Wing angle comparison
+        axes[1, 0].scatter(synthetic_data['front_wing_angle'], synthetic_data['rear_wing_angle'], 
+                          alpha=0.5, label='Synthetic', color='blue')
+        axes[1, 0].scatter(user_data['front_wing_angle'], user_data['rear_wing_angle'], 
+                          alpha=0.5, label='User Data', color='red')
+        axes[1, 0].set_xlabel('Front Wing Angle (°)')
+        axes[1, 0].set_ylabel('Rear Wing Angle (°)')
+        axes[1, 0].set_title('Wing Configuration Comparison')
+        axes[1, 0].legend()
+        axes[1, 0].grid(True, alpha=0.3)
+        
+        # Performance correlation
+        axes[1, 1].scatter(synthetic_eff, synthetic_data['lap_time'], 
+                          alpha=0.5, label='Synthetic', color='blue')
+        axes[1, 1].scatter(user_eff, user_data['lap_time'], 
+                          alpha=0.5, label='User Data', color='red')
+        axes[1, 1].set_xlabel('Aerodynamic Efficiency')
+        axes[1, 1].set_ylabel('Lap Time (s)')
+        axes[1, 1].set_title('Efficiency vs Performance')
+        axes[1, 1].legend()
+        axes[1, 1].grid(True, alpha=0.3)
+        
+        plt.tight_layout()
+        return fig
 
 # Initialize the predictor
 predictor = F1AerodynamicPredictor()
@@ -219,7 +300,7 @@ def analyze_aerodynamics():
     
     # Generate report
     report = f"""
-    ## F1 Aerodynamic Performance Analysis
+    ## F1 Aerodynamic Performance Analysis (Synthetic Data)
     
     **Model Performance:**
     - R² Score: {r2:.3f}
@@ -244,6 +325,87 @@ def analyze_aerodynamics():
     
     return fig, report
 
+def upload_and_analyze_data(file):
+    """Handle file upload and analysis"""
+    if file is None:
+        return None, "Please upload a data file.", None
+    
+    # Load user data
+    user_data, message = predictor.load_user_data(file)
+    if user_data is None:
+        return None, message, None
+    
+    # Train model on user data
+    r2, rmse = predictor.train_model(user_data)
+    
+    # Create visualizations
+    fig = predictor.create_visualizations(user_data)
+    
+    # Generate report
+    report = f"""
+    ## F1 Aerodynamic Performance Analysis (User Data)
+    
+    **Data Load Status:** {message}
+    
+    **Model Performance:**
+    - R² Score: {r2:.3f}
+    - RMSE: {rmse:.3f} seconds
+    
+    **Dataset Statistics:**
+    - Total configurations analyzed: {len(user_data)}
+    - Fastest lap time: {user_data['lap_time'].min():.2f}s
+    - Slowest lap time: {user_data['lap_time'].max():.2f}s
+    - Average lap time: {user_data['lap_time'].mean():.2f}s
+    
+    **Aerodynamic Insights:**
+    - Average downforce: {user_data['downforce'].mean():.0f}N
+    - Average drag coefficient: {user_data['drag_coefficient'].mean():.3f}
+    - Best aero efficiency: {(user_data['downforce'] / user_data['drag_coefficient']).max():.1f}
+    
+    **Data Quality Assessment:**
+    - Missing values: {user_data.isnull().sum().sum()}
+    - Duplicate records: {user_data.duplicated().sum()}
+    - Data range validation: Passed
+    """
+    
+    return fig, report, user_data
+
+def compare_data_sources():
+    """Compare user data with synthetic baseline"""
+    if predictor.current_data is None:
+        return None, "Please upload data first to enable comparison."
+    
+    # Generate synthetic data for comparison
+    synthetic_data = predictor.generate_aero_data(len(predictor.current_data))
+    
+    # Create comparison visualization
+    fig = predictor.compare_datasets(synthetic_data, predictor.current_data)
+    
+    # Generate comparison report
+    synthetic_avg = synthetic_data['lap_time'].mean()
+    user_avg = predictor.current_data['lap_time'].mean()
+    
+    report = f"""
+    ## Data Comparison Report
+    
+    **Performance Comparison:**
+    - Synthetic Data Average Lap Time: {synthetic_avg:.2f}s
+    - User Data Average Lap Time: {user_avg:.2f}s
+    - Difference: {user_avg - synthetic_avg:.2f}s
+    
+    **Setup Characteristics:**
+    - Synthetic wing angles are more conservative
+    - User data shows {'more aggressive' if user_avg < synthetic_avg else 'more conservative'} setup approach
+    - Aerodynamic efficiency patterns {'align well' if abs(user_avg - synthetic_avg) < 2 else 'show significant differences'}
+    
+    **Recommendations:**
+    - {'Your data suggests more aggressive setups than baseline' if user_avg < synthetic_avg else 'Consider more aggressive aerodynamic configurations'}
+    - Validate setup ranges against your specific track conditions
+    - Use comparison insights to refine optimization parameters
+    """
+    
+    return fig, report
+
 def predict_performance(front_wing, rear_wing, ride_height, suspension, downforce, drag_coeff, track_temp, wind_speed, track_grip):
     """Predict lap time for given setup"""
     if not predictor.is_trained:
@@ -252,7 +414,9 @@ def predict_performance(front_wing, rear_wing, ride_height, suspension, downforc
     setup_params = [front_wing, rear_wing, ride_height, suspension, downforce, drag_coeff, track_temp, wind_speed, track_grip]
     lap_time = predictor.predict_lap_time(setup_params)
     
-    return f"🏁 Predicted Lap Time: {lap_time:.3f} seconds"
+    data_source_note = f"(Model trained on: {predictor.data_source})"
+    
+    return f"Predicted Lap Time: {lap_time:.3f} seconds {data_source_note}"
 
 def optimize_car_setup(track_temp, wind_speed, track_grip):
     """Optimize car setup for given conditions"""
@@ -271,6 +435,7 @@ def optimize_car_setup(track_temp, wind_speed, track_grip):
     ## Optimal Car Setup
     
     **Predicted Lap Time: {optimal_lap_time:.3f} seconds**
+    *(Model trained on: {predictor.data_source})*
     
     **Optimal Configuration:**
     - Front Wing Angle: {optimal_setup[0]:.1f}°
@@ -288,14 +453,19 @@ def optimize_car_setup(track_temp, wind_speed, track_grip):
     
     return setup_report
 
+def create_sample_data():
+    """Create sample data file for download"""
+    sample_data = predictor.generate_aero_data(100)
+    return sample_data.to_csv(index=False)
+
 # Create Gradio interface
 with gr.Blocks(title="F1 Aerodynamic Performance Predictor", theme=gr.themes.Soft()) as demo:
     gr.Markdown("# F1 Aerodynamic Performance Predictor")
     gr.Markdown("AI-powered aerodynamic analysis and setup optimization for Formula 1 racing.")
     
-    with gr.Tab("Aerodynamic Analysis"):
-        gr.Markdown("### Analyze aerodynamic performance data")
-        analyze_btn = gr.Button("🔍 Analyze Aerodynamics", variant="primary")
+    with gr.Tab("Synthetic Data Analysis"):
+        gr.Markdown("### Analyze synthetic aerodynamic performance data")
+        analyze_btn = gr.Button("🔍 Analyze Synthetic Data", variant="primary")
         
         with gr.Row():
             with gr.Column(scale=2):
@@ -308,9 +478,61 @@ with gr.Blocks(title="F1 Aerodynamic Performance Predictor", theme=gr.themes.Sof
             outputs=[aero_plot, aero_report]
         )
     
+    with gr.Tab("Upload & Analyze Data"):
+        gr.Markdown("### Upload your own F1 data for analysis")
+        gr.Markdown("**Required columns:** front_wing_angle, rear_wing_angle, ride_height, suspension_stiffness, downforce, drag_coefficient, track_temp, wind_speed, track_grip, lap_time")
+        
+        with gr.Row():
+            with gr.Column():
+                file_upload = gr.File(
+                    label="Upload CSV or Excel file",
+                    file_types=[".csv", ".xlsx", ".xls"]
+                )
+                
+                sample_btn = gr.Button("Download Sample Data Format", variant="secondary")
+                sample_file = gr.File(label="Sample Data", visible=False)
+                
+                upload_btn = gr.Button("Analyze Uploaded Data", variant="primary")
+                
+            with gr.Column():
+                upload_status = gr.Markdown("No file uploaded yet.")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                upload_plot = gr.Plot(label="Data Analysis")
+            with gr.Column(scale=1):
+                upload_report = gr.Markdown(label="Analysis Report")
+        
+        # Comparison section
+        gr.Markdown("### Compare with Synthetic Baseline")
+        compare_btn = gr.Button("Compare Data Sources", variant="secondary")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                comparison_plot = gr.Plot(label="Data Comparison")
+            with gr.Column(scale=1):
+                comparison_report = gr.Markdown(label="Comparison Report")
+        
+        # Event handlers
+        sample_btn.click(
+            create_sample_data,
+            outputs=[sample_file]
+        )
+        
+        upload_btn.click(
+            upload_and_analyze_data,
+            inputs=[file_upload],
+            outputs=[upload_plot, upload_report, upload_status]
+        )
+        
+        compare_btn.click(
+            compare_data_sources,
+            outputs=[comparison_plot, comparison_report]
+        )
+    
     with gr.Tab("Performance Prediction"):
         gr.Markdown("### Predict lap time for specific setup")
-        gr.Markdown("*Note: Run the analysis first to train the model*")
+        gr.Markdown("*Note: Train the model first using synthetic or uploaded data*")
         
         with gr.Row():
             with gr.Column():
@@ -363,37 +585,42 @@ with gr.Blocks(title="F1 Aerodynamic Performance Predictor", theme=gr.themes.Sof
     
     with gr.Tab("About"):
         gr.Markdown("""
-        ## About This Tool
-        
-        This F1 Aerodynamic Performance Predictor uses advanced machine learning and optimization techniques:
-        
-        **Performance Prediction:**
-        - Random Forest model predicts lap times based on car setup and track conditions
-        - Considers aerodynamic efficiency, wing configurations, and environmental factors
-        - Trained on realistic F1 aerodynamic data
-        
-        **🔧 Setup Optimization:**
-        - Uses Differential Evolution algorithm to find optimal car configurations
-        - Balances downforce vs drag for maximum performance
-        - Considers track-specific conditions for tailored setups
-        
-        **Key Features:**
-        - Aerodynamic efficiency analysis (downforce/drag ratio)
-        - Wing angle optimization for different track types
-        - Environmental impact assessment (temperature, wind, grip)
-        - Sensitivity analysis for setup parameters
-        
-        **Technical Implementation:**
-        - Random Forest Regressor for non-linear relationships
-        - Differential Evolution for global optimization
-        - StandardScaler for feature normalization
-        - Advanced visualization of aerodynamic trade-offs
-        
-        **Racing Applications:**
-        - Pre-race setup optimization
-        - Strategy planning for different track conditions
-        - Understanding aerodynamic trade-offs
-        - Performance prediction for qualifying and race scenarios
+        ## About This Enhanced Tool
+        
+        This F1 Aerodynamic Performance Predictor now supports both synthetic and real data analysis:
+        
+        **Dual Data Sources:**
+        - **Synthetic Data**: Realistic simulated F1 aerodynamic data for learning and experimentation
+        - **User Data**: Upload your own telemetry, test results, or historical performance data
+        
+        **Data Upload Features:**
+        - CSV and Excel file support
+        - Automatic data validation and quality checks
+        - Sample data template download
+        - Comparison analysis between your data and synthetic baseline
+        
+        **Enhanced Analysis:**
+        - Model training on real or synthetic data
+        - Data quality assessment and validation
+        - Performance comparison between different datasets
+        - Track which data source was used for predictions
+        
+        **Setup Optimization:**
+        - Uses Differential Evolution algorithm for global optimization
+        - Adapts to patterns in your specific data
+        - Provides data-source-aware recommendations
+        
+        **Required Data Format:**
+        Your uploaded data should include these columns:
+        - front_wing_angle, rear_wing_angle, ride_height
+        - suspension_stiffness, downforce, drag_coefficient
+        - track_temp, wind_speed, track_grip, lap_time
+        
+        **Professional Applications:**
+        - Validate simulation models against real telemetry
+        - Identify setup trends and patterns in your data
+        - Optimize configurations for specific track conditions
+        - Compare your team's approach with industry baselines
         """)
 
 if __name__ == "__main__":