Update app.py

app.py

@@ -7,6 +7,8 @@ from sklearn.preprocessing import StandardScaler
 from sklearn.linear_model import LinearRegression
 from sklearn.metrics import mean_squared_error, r2_score
 import warnings
+import io
+import json
 warnings.filterwarnings('ignore')
 
 class F1TelemetryAnalyzer:
@@ -16,6 +18,9 @@ class F1TelemetryAnalyzer:
         self.tire_model = LinearRegression()
         self.fuel_model = LinearRegression()
         self.is_trained = False
+        self.current_data = None
+        self.required_columns = ['speed', 'throttle', 'brake_pressure', 'tire_temp', 'engine_temp']
+        self.optional_columns = ['lap_time', 'lap_number', 'tire_degradation', 'fuel_remaining']
         
     def generate_sample_data(self, num_samples=1000):
         """Generate realistic F1 telemetry data"""
@@ -62,6 +67,110 @@ class F1TelemetryAnalyzer:
             'fuel_remaining': fuel_remaining
         })
     
+    def parse_uploaded_file(self, file):
+        """Parse uploaded file and return DataFrame"""
+        try:
+            file_extension = file.name.split('.')[-1].lower()
+            
+            if file_extension == 'csv':
+                df = pd.read_csv(file.name)
+            elif file_extension in ['xlsx', 'xls']:
+                df = pd.read_excel(file.name)
+            elif file_extension == 'json':
+                df = pd.read_json(file.name)
+            else:
+                return None, "Unsupported file format. Please upload CSV, Excel, or JSON files."
+            
+            return df, f"File loaded successfully! Shape: {df.shape}"
+        except Exception as e:
+            return None, f"Error loading file: {str(e)}"
+    
+    def get_column_suggestions(self, df):
+        """Suggest column mappings based on common telemetry column names"""
+        suggestions = {}
+        column_names = df.columns.str.lower()
+        
+        # Common mapping patterns
+        mapping_patterns = {
+            'speed': ['speed', 'velocity', 'spd', 'v'],
+            'throttle': ['throttle', 'thr', 'accelerator', 'gas'],
+            'brake_pressure': ['brake', 'brk', 'brake_pressure', 'brake_force'],
+            'tire_temp': ['tire_temp', 'tyre_temp', 'tire_temperature', 'tyre_temperature', 'temp_tire'],
+            'engine_temp': ['engine_temp', 'engine_temperature', 'water_temp', 'coolant_temp'],
+            'lap_time': ['lap_time', 'laptime', 'time', 'sector_time'],
+            'lap_number': ['lap', 'lap_number', 'lap_num', 'lap_count'],
+            'tire_degradation': ['tire_deg', 'tyre_deg', 'tire_wear', 'tyre_wear'],
+            'fuel_remaining': ['fuel', 'fuel_remaining', 'fuel_level', 'fuel_load']
+        }
+        
+        for telemetry_field, patterns in mapping_patterns.items():
+            for pattern in patterns:
+                matches = column_names[column_names.str.contains(pattern, na=False)]
+                if len(matches) > 0:
+                    suggestions[telemetry_field] = df.columns[matches.index[0]]
+                    break
+        
+        return suggestions
+    
+    def validate_mapped_data(self, df, column_mapping):
+        """Validate that mapped data meets requirements"""
+        missing_required = []
+        for col in self.required_columns:
+            if col not in column_mapping or column_mapping[col] is None:
+                missing_required.append(col)
+        
+        if missing_required:
+            return False, f"Missing required columns: {', '.join(missing_required)}"
+        
+        # Check if mapped columns exist in DataFrame
+        for telemetry_col, df_col in column_mapping.items():
+            if df_col and df_col not in df.columns:
+                return False, f"Column '{df_col}' not found in uploaded data"
+        
+        return True, "Data validation successful"
+    
+    def process_uploaded_data(self, df, column_mapping):
+        """Process uploaded data with column mapping"""
+        processed_df = pd.DataFrame()
+        
+        # Map columns
+        for telemetry_col, df_col in column_mapping.items():
+            if df_col and df_col in df.columns:
+                processed_df[telemetry_col] = df[df_col]
+        
+        # Fill missing optional columns with defaults or calculated values
+        if 'lap_time' not in processed_df.columns:
+            processed_df['lap_time'] = np.random.normal(90, 5, len(processed_df))
+        
+        if 'lap_number' not in processed_df.columns:
+            processed_df['lap_number'] = range(1, len(processed_df) + 1)
+        
+        if 'tire_degradation' not in processed_df.columns:
+            # Estimate tire degradation based on available data
+            if 'lap_number' in processed_df.columns:
+                processed_df['tire_degradation'] = 100 - (processed_df['lap_number'] * 0.8)
+            else:
+                processed_df['tire_degradation'] = np.random.uniform(70, 100, len(processed_df))
+        
+        if 'fuel_remaining' not in processed_df.columns:
+            # Estimate fuel consumption based on available data
+            if 'lap_number' in processed_df.columns:
+                processed_df['fuel_remaining'] = 100 - (processed_df['lap_number'] * 1.5)
+            else:
+                processed_df['fuel_remaining'] = np.random.uniform(50, 100, len(processed_df))
+        
+        # Clean data
+        processed_df = processed_df.dropna()
+        
+        # Clip values to reasonable ranges
+        processed_df['speed'] = np.clip(processed_df['speed'], 0, 400)
+        processed_df['throttle'] = np.clip(processed_df['throttle'], 0, 100)
+        processed_df['brake_pressure'] = np.clip(processed_df['brake_pressure'], 0, 100)
+        processed_df['tire_temp'] = np.clip(processed_df['tire_temp'], 20, 200)
+        processed_df['engine_temp'] = np.clip(processed_df['engine_temp'], 50, 150)
+        
+        return processed_df
+    
     def detect_anomalies(self, data):
         """Detect anomalies in telemetry data"""
         features = ['speed', 'throttle', 'brake_pressure', 'tire_temp', 'engine_temp']
@@ -157,10 +266,98 @@ class F1TelemetryAnalyzer:
 # Initialize the analyzer
 analyzer = F1TelemetryAnalyzer()
 
-def analyze_telemetry():
-    """Main function to run telemetry analysis"""
+def load_file(file):
+    """Load and preview uploaded file"""
+    if file is None:
+        return None, "No file uploaded", {}, ""
+    
+    df, message = analyzer.parse_uploaded_file(file)
+    if df is None:
+        return None, message, {}, ""
+    
+    # Get column suggestions
+    suggestions = analyzer.get_column_suggestions(df)
+    
+    # Create preview
+    preview = df.head(10).to_string()
+    
+    return df, message, suggestions, f"Data Preview (first 10 rows):\n{preview}"
+
+def analyze_uploaded_data(df, speed_col, throttle_col, brake_col, tire_temp_col, engine_temp_col, 
+                         lap_time_col, lap_num_col, tire_deg_col, fuel_col):
+    """Analyze uploaded telemetry data"""
+    if df is None:
+        return None, "No data loaded. Please upload a file first."
+    
+    # Create column mapping
+    column_mapping = {
+        'speed': speed_col,
+        'throttle': throttle_col,
+        'brake_pressure': brake_col,
+        'tire_temp': tire_temp_col,
+        'engine_temp': engine_temp_col,
+        'lap_time': lap_time_col,
+        'lap_number': lap_num_col,
+        'tire_degradation': tire_deg_col,
+        'fuel_remaining': fuel_col
+    }
+    
+    # Validate mapping
+    is_valid, validation_message = analyzer.validate_mapped_data(df, column_mapping)
+    if not is_valid:
+        return None, validation_message
+    
+    # Process data
+    try:
+        processed_data = analyzer.process_uploaded_data(df, column_mapping)
+        analyzer.current_data = processed_data
+        
+        # Detect anomalies
+        processed_data = analyzer.detect_anomalies(processed_data)
+        
+        # Train models
+        tire_r2, fuel_r2 = analyzer.train_predictive_models(processed_data)
+        
+        # Create visualizations
+        fig = analyzer.create_visualizations(processed_data)
+        
+        # Generate report
+        total_samples = len(processed_data)
+        anomalies_detected = len(processed_data[processed_data['anomaly'] == -1])
+        anomaly_percentage = (anomalies_detected / total_samples) * 100
+        
+        report = f"""
+        ## F1 Telemetry Analysis Report (Uploaded Data)
+        
+        **Data Summary:**
+        - Total samples analyzed: {total_samples}
+        - Anomalies detected: {anomalies_detected} ({anomaly_percentage:.1f}%)
+        
+        **Model Performance:**
+        - Tire Degradation Model R²: {tire_r2:.3f}
+        - Fuel Consumption Model R²: {fuel_r2:.3f}
+        
+        **Key Insights:**
+        - Average lap time: {processed_data['lap_time'].mean():.1f} seconds
+        - Average speed: {processed_data['speed'].mean():.1f} km/h
+        - Maximum tire temperature: {processed_data['tire_temp'].max():.1f}°C
+        - Minimum tire performance: {processed_data['tire_degradation'].min():.1f}%
+        
+        **Anomaly Analysis:**
+        - Anomalies primarily detected in: Low speed conditions and high tire temperatures
+        - Recommended action: Investigate cooling systems and potential mechanical issues
+        """
+        
+        return fig, report
+        
+    except Exception as e:
+        return None, f"Error processing data: {str(e)}"
+
+def analyze_sample_data():
+    """Analyze sample telemetry data"""
     # Generate sample data
     data = analyzer.generate_sample_data(1000)
+    analyzer.current_data = data
     
     # Detect anomalies
     data = analyzer.detect_anomalies(data)
@@ -177,7 +374,7 @@ def analyze_telemetry():
     anomaly_percentage = (anomalies_detected / total_samples) * 100
     
     report = f"""
-    ## F1 Telemetry Analysis Report
+    ## F1 Telemetry Analysis Report (Sample Data)
     
     **Data Summary:**
     - Total samples analyzed: {total_samples}
@@ -205,14 +402,95 @@ def predict_telemetry(lap_number, speed, throttle, tire_temp, engine_temp):
     tire_pred, fuel_pred = analyzer.predict_performance(lap_number, speed, throttle, tire_temp, engine_temp)
     return tire_pred, fuel_pred
 
+def update_column_dropdowns(df, suggestions):
+    """Update dropdown options based on loaded data"""
+    if df is None:
+        return [gr.Dropdown(choices=[], value=None)] * 9
+    
+    columns = [""] + list(df.columns)
+    
+    return [
+        gr.Dropdown(choices=columns, value=suggestions.get('speed', ''), label="Speed Column"),
+        gr.Dropdown(choices=columns, value=suggestions.get('throttle', ''), label="Throttle Column"),
+        gr.Dropdown(choices=columns, value=suggestions.get('brake_pressure', ''), label="Brake Pressure Column"),
+        gr.Dropdown(choices=columns, value=suggestions.get('tire_temp', ''), label="Tire Temperature Column"),
+        gr.Dropdown(choices=columns, value=suggestions.get('engine_temp', ''), label="Engine Temperature Column"),
+        gr.Dropdown(choices=columns, value=suggestions.get('lap_time', ''), label="Lap Time Column"),
+        gr.Dropdown(choices=columns, value=suggestions.get('lap_number', ''), label="Lap Number Column"),
+        gr.Dropdown(choices=columns, value=suggestions.get('tire_degradation', ''), label="Tire Degradation Column"),
+        gr.Dropdown(choices=columns, value=suggestions.get('fuel_remaining', ''), label="Fuel Remaining Column")
+    ]
+
 # Create Gradio interface
 with gr.Blocks(title="F1 Telemetry Data Analyzer", theme=gr.themes.Soft()) as demo:
     gr.Markdown("# F1 Telemetry Data Analyzer")
     gr.Markdown("Advanced AI-powered analysis of Formula 1 telemetry data with anomaly detection and predictive modeling.")
     
-    with gr.Tab("Data Analysis"):
-        gr.Markdown("### Generate and analyze telemetry data")
-        analyze_btn = gr.Button("Analyze Telemetry Data", variant="primary")
+    # Store dataframe in state
+    uploaded_df = gr.State(None)
+    
+    with gr.Tab("Upload Data"):
+        gr.Markdown("### Upload your telemetry data files")
+        gr.Markdown("**Supported formats:** CSV, Excel (.xlsx/.xls), JSON")
+        
+        with gr.Row():
+            file_upload = gr.File(
+                label="Upload Telemetry Data",
+                file_types=[".csv", ".xlsx", ".xls", ".json"],
+                type="filepath"
+            )
+        
+        load_status = gr.Textbox(label="Load Status", interactive=False)
+        data_preview = gr.Textbox(label="Data Preview", lines=10, interactive=False)
+        
+        gr.Markdown("### Map Your Data Columns")
+        gr.Markdown("**Required columns** (marked with *): Speed*, Throttle*, Brake Pressure*, Tire Temperature*, Engine Temperature*")
+        
+        with gr.Row():
+            with gr.Column():
+                speed_col = gr.Dropdown(label="Speed Column *", choices=[], value="")
+                throttle_col = gr.Dropdown(label="Throttle Column *", choices=[], value="")
+                brake_col = gr.Dropdown(label="Brake Pressure Column *", choices=[], value="")
+                tire_temp_col = gr.Dropdown(label="Tire Temperature Column *", choices=[], value="")
+                engine_temp_col = gr.Dropdown(label="Engine Temperature Column *", choices=[], value="")
+            
+            with gr.Column():
+                lap_time_col = gr.Dropdown(label="Lap Time Column", choices=[], value="")
+                lap_num_col = gr.Dropdown(label="Lap Number Column", choices=[], value="")
+                tire_deg_col = gr.Dropdown(label="Tire Degradation Column", choices=[], value="")
+                fuel_col = gr.Dropdown(label="Fuel Remaining Column", choices=[], value="")
+        
+        analyze_uploaded_btn = gr.Button("🔍 Analyze Uploaded Data", variant="primary")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                uploaded_plot_output = gr.Plot(label="Telemetry Visualizations")
+            with gr.Column(scale=1):
+                uploaded_report_output = gr.Markdown(label="Analysis Report")
+        
+        # File upload event
+        file_upload.upload(
+            load_file,
+            inputs=[file_upload],
+            outputs=[uploaded_df, load_status, gr.State(), data_preview]
+        ).then(
+            lambda df, suggestions: update_column_dropdowns(df, suggestions),
+            inputs=[uploaded_df, gr.State()],
+            outputs=[speed_col, throttle_col, brake_col, tire_temp_col, engine_temp_col,
+                    lap_time_col, lap_num_col, tire_deg_col, fuel_col]
+        )
+        
+        # Analyze uploaded data
+        analyze_uploaded_btn.click(
+            analyze_uploaded_data,
+            inputs=[uploaded_df, speed_col, throttle_col, brake_col, tire_temp_col, engine_temp_col,
+                   lap_time_col, lap_num_col, tire_deg_col, fuel_col],
+            outputs=[uploaded_plot_output, uploaded_report_output]
+        )
+    
+    with gr.Tab("Sample Data Analysis"):
+        gr.Markdown("### Generate and analyze sample telemetry data")
+        analyze_btn = gr.Button("Analyze Sample Data", variant="primary")
         
         with gr.Row():
             with gr.Column(scale=2):
@@ -221,13 +499,13 @@ with gr.Blocks(title="F1 Telemetry Data Analyzer", theme=gr.themes.Soft()) as de
                 report_output = gr.Markdown(label="Analysis Report")
         
         analyze_btn.click(
-            analyze_telemetry,
+            analyze_sample_data,
             outputs=[plot_output, report_output]
         )
     
     with gr.Tab("Performance Prediction"):
         gr.Markdown("### Predict tire performance and fuel consumption")
-        gr.Markdown("*Note: Run the analysis first to train the models*")
+        gr.Markdown("*Note: Run analysis first to train the models*")
         
         with gr.Row():
             with gr.Column():
@@ -255,6 +533,12 @@ with gr.Blocks(title="F1 Telemetry Data Analyzer", theme=gr.themes.Soft()) as de
         
         This F1 Telemetry Data Analyzer demonstrates advanced AI techniques used in Formula 1 racing:
         
+        **Data Upload Features:**
+        - Support for CSV, Excel, and JSON file formats
+        - Automatic column detection and mapping suggestions
+        - Data validation and cleaning
+        - Flexible data structure handling
+        
         **Anomaly Detection:**
         - Uses Isolation Forest algorithm to detect unusual patterns in telemetry data
         - Identifies potential mechanical issues or performance anomalies
@@ -270,6 +554,7 @@ with gr.Blocks(title="F1 Telemetry Data Analyzer", theme=gr.themes.Soft()) as de
         - Advanced visualization of racing data
         - Performance prediction for race strategy
         - Anomaly detection for preventive maintenance
+        - Upload and analyze your own telemetry data
         
         **Technical Stack:**
         - Python with scikit-learn for ML models
@@ -277,6 +562,11 @@ with gr.Blocks(title="F1 Telemetry Data Analyzer", theme=gr.themes.Soft()) as de
         - Linear regression for performance prediction
         - Matplotlib for advanced visualizations
         - Gradio for interactive web interface
+        
+        **Data Format Requirements:**
+        - **Required columns:** Speed, Throttle, Brake Pressure, Tire Temperature, Engine Temperature
+        - **Optional columns:** Lap Time, Lap Number, Tire Degradation, Fuel Remaining
+        - Missing optional columns will be estimated automatically
         """)
 
 if __name__ == "__main__":