Create app.py

app.py

@@ -0,0 +1,283 @@
+import gradio as gr
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from sklearn.ensemble import IsolationForest
+from sklearn.preprocessing import StandardScaler
+from sklearn.linear_model import LinearRegression
+from sklearn.metrics import mean_squared_error, r2_score
+import warnings
+warnings.filterwarnings('ignore')
+
+class F1TelemetryAnalyzer:
+    def __init__(self):
+        self.scaler = StandardScaler()
+        self.anomaly_detector = IsolationForest(contamination=0.1, random_state=42)
+        self.tire_model = LinearRegression()
+        self.fuel_model = LinearRegression()
+        self.is_trained = False
+        
+    def generate_sample_data(self, num_samples=1000):
+        """Generate realistic F1 telemetry data"""
+        np.random.seed(42)
+        
+        # Base parameters
+        lap_time = np.random.normal(90, 5, num_samples)  # seconds
+        speed = np.random.normal(200, 30, num_samples)  # km/h
+        throttle = np.random.uniform(0, 100, num_samples)  # %
+        brake_pressure = np.random.uniform(0, 100, num_samples)  # %
+        tire_temp = np.random.normal(80, 15, num_samples)  # °C
+        engine_temp = np.random.normal(95, 10, num_samples)  # °C
+        
+        # Introduce some realistic correlations
+        speed = np.clip(speed + throttle * 0.5 - brake_pressure * 0.3, 50, 300)
+        tire_temp = np.clip(tire_temp + speed * 0.1 + throttle * 0.2, 40, 120)
+        engine_temp = np.clip(engine_temp + throttle * 0.15 + speed * 0.05, 70, 130)
+        
+        # Lap number for degradation modeling
+        lap_number = np.random.randint(1, 60, num_samples)
+        
+        # Tire degradation (performance decreases over laps)
+        tire_degradation = 100 - (lap_number * 0.8 + np.random.normal(0, 2, num_samples))
+        tire_degradation = np.clip(tire_degradation, 60, 100)
+        
+        # Fuel consumption (decreases with laps)
+        fuel_remaining = 100 - (lap_number * 1.5 + np.random.normal(0, 3, num_samples))
+        fuel_remaining = np.clip(fuel_remaining, 0, 100)
+        
+        # Add some anomalies
+        anomaly_indices = np.random.choice(num_samples, size=int(num_samples * 0.05), replace=False)
+        speed[anomaly_indices] = np.random.uniform(20, 50, len(anomaly_indices))  # Very slow speeds
+        tire_temp[anomaly_indices] = np.random.uniform(130, 150, len(anomaly_indices))  # Overheating
+        
+        return pd.DataFrame({
+            'lap_time': lap_time,
+            'speed': speed,
+            'throttle': throttle,
+            'brake_pressure': brake_pressure,
+            'tire_temp': tire_temp,
+            'engine_temp': engine_temp,
+            'lap_number': lap_number,
+            'tire_degradation': tire_degradation,
+            'fuel_remaining': fuel_remaining
+        })
+    
+    def detect_anomalies(self, data):
+        """Detect anomalies in telemetry data"""
+        features = ['speed', 'throttle', 'brake_pressure', 'tire_temp', 'engine_temp']
+        X = data[features]
+        
+        # Fit and predict anomalies
+        anomalies = self.anomaly_detector.fit_predict(X)
+        data['anomaly'] = anomalies
+        
+        return data
+    
+    def train_predictive_models(self, data):
+        """Train tire degradation and fuel consumption models"""
+        # Prepare features for prediction
+        features = ['lap_number', 'speed', 'throttle', 'tire_temp', 'engine_temp']
+        X = data[features]
+        
+        # Train tire degradation model
+        y_tire = data['tire_degradation']
+        self.tire_model.fit(X, y_tire)
+        
+        # Train fuel consumption model
+        y_fuel = data['fuel_remaining']
+        self.fuel_model.fit(X, y_fuel)
+        
+        self.is_trained = True
+        
+        # Calculate model performance
+        tire_pred = self.tire_model.predict(X)
+        fuel_pred = self.fuel_model.predict(X)
+        
+        tire_r2 = r2_score(y_tire, tire_pred)
+        fuel_r2 = r2_score(y_fuel, fuel_pred)
+        
+        return tire_r2, fuel_r2
+    
+    def predict_performance(self, lap_number, speed, throttle, tire_temp, engine_temp):
+        """Predict tire degradation and fuel consumption"""
+        if not self.is_trained:
+            return "Model not trained yet!", ""
+        
+        features = np.array([[lap_number, speed, throttle, tire_temp, engine_temp]])
+        
+        tire_pred = self.tire_model.predict(features)[0]
+        fuel_pred = self.fuel_model.predict(features)[0]
+        
+        return f"Predicted Tire Performance: {tire_pred:.1f}%", f"Predicted Fuel Remaining: {fuel_pred:.1f}%"
+    
+    def create_visualizations(self, data):
+        """Create telemetry visualizations"""
+        fig, axes = plt.subplots(2, 2, figsize=(15, 12))
+        
+        # Speed vs Lap Time
+        normal_data = data[data['anomaly'] == 1]
+        anomaly_data = data[data['anomaly'] == -1]
+        
+        axes[0, 0].scatter(normal_data['speed'], normal_data['lap_time'], 
+                          alpha=0.6, label='Normal', color='blue')
+        axes[0, 0].scatter(anomaly_data['speed'], anomaly_data['lap_time'], 
+                          alpha=0.8, label='Anomaly', color='red')
+        axes[0, 0].set_xlabel('Speed (km/h)')
+        axes[0, 0].set_ylabel('Lap Time (s)')
+        axes[0, 0].set_title('Speed vs Lap Time (Anomaly Detection)')
+        axes[0, 0].legend()
+        axes[0, 0].grid(True, alpha=0.3)
+        
+        # Tire Temperature Distribution
+        axes[0, 1].hist(normal_data['tire_temp'], bins=30, alpha=0.7, label='Normal', color='blue')
+        axes[0, 1].hist(anomaly_data['tire_temp'], bins=30, alpha=0.7, label='Anomaly', color='red')
+        axes[0, 1].set_xlabel('Tire Temperature (°C)')
+        axes[0, 1].set_ylabel('Frequency')
+        axes[0, 1].set_title('Tire Temperature Distribution')
+        axes[0, 1].legend()
+        axes[0, 1].grid(True, alpha=0.3)
+        
+        # Tire Degradation over Laps
+        axes[1, 0].scatter(data['lap_number'], data['tire_degradation'], alpha=0.6, color='green')
+        axes[1, 0].set_xlabel('Lap Number')
+        axes[1, 0].set_ylabel('Tire Performance (%)')
+        axes[1, 0].set_title('Tire Degradation Over Race')
+        axes[1, 0].grid(True, alpha=0.3)
+        
+        # Fuel Consumption
+        axes[1, 1].scatter(data['lap_number'], data['fuel_remaining'], alpha=0.6, color='orange')
+        axes[1, 1].set_xlabel('Lap Number')
+        axes[1, 1].set_ylabel('Fuel Remaining (%)')
+        axes[1, 1].set_title('Fuel Consumption Over Race')
+        axes[1, 1].grid(True, alpha=0.3)
+        
+        plt.tight_layout()
+        return fig
+
+# Initialize the analyzer
+analyzer = F1TelemetryAnalyzer()
+
+def analyze_telemetry():
+    """Main function to run telemetry analysis"""
+    # Generate sample data
+    data = analyzer.generate_sample_data(1000)
+    
+    # Detect anomalies
+    data = analyzer.detect_anomalies(data)
+    
+    # Train predictive models
+    tire_r2, fuel_r2 = analyzer.train_predictive_models(data)
+    
+    # Create visualizations
+    fig = analyzer.create_visualizations(data)
+    
+    # Generate summary report
+    total_samples = len(data)
+    anomalies_detected = len(data[data['anomaly'] == -1])
+    anomaly_percentage = (anomalies_detected / total_samples) * 100
+    
+    report = f"""
+    ## F1 Telemetry Analysis Report
+    
+    **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: {data['lap_time'].mean():.1f} seconds
+    - Average speed: {data['speed'].mean():.1f} km/h
+    - Maximum tire temperature: {data['tire_temp'].max():.1f}°C
+    - Minimum tire performance: {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
+
+def predict_telemetry(lap_number, speed, throttle, tire_temp, engine_temp):
+    """Predict tire and fuel performance"""
+    tire_pred, fuel_pred = analyzer.predict_performance(lap_number, speed, throttle, tire_temp, engine_temp)
+    return tire_pred, fuel_pred
+
+# 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")
+        
+        with gr.Row():
+            with gr.Column(scale=2):
+                plot_output = gr.Plot(label="Telemetry Visualizations")
+            with gr.Column(scale=1):
+                report_output = gr.Markdown(label="Analysis Report")
+        
+        analyze_btn.click(
+            analyze_telemetry,
+            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*")
+        
+        with gr.Row():
+            with gr.Column():
+                lap_input = gr.Slider(1, 60, value=10, label="Lap Number")
+                speed_input = gr.Slider(50, 300, value=200, label="Speed (km/h)")
+                throttle_input = gr.Slider(0, 100, value=75, label="Throttle (%)")
+                tire_temp_input = gr.Slider(40, 120, value=80, label="Tire Temperature (°C)")
+                engine_temp_input = gr.Slider(70, 130, value=95, label="Engine Temperature (°C)")
+                
+                predict_btn = gr.Button("🎯 Predict Performance", variant="secondary")
+            
+            with gr.Column():
+                tire_pred_output = gr.Textbox(label="Tire Performance Prediction")
+                fuel_pred_output = gr.Textbox(label="Fuel Consumption Prediction")
+        
+        predict_btn.click(
+            predict_telemetry,
+            inputs=[lap_input, speed_input, throttle_input, tire_temp_input, engine_temp_input],
+            outputs=[tire_pred_output, fuel_pred_output]
+        )
+    
+    with gr.Tab("ℹ️ About"):
+        gr.Markdown("""
+        ## About This Tool
+        
+        This F1 Telemetry Data Analyzer demonstrates advanced AI techniques used in Formula 1 racing:
+        
+        **🔍 Anomaly Detection:**
+        - Uses Isolation Forest algorithm to detect unusual patterns in telemetry data
+        - Identifies potential mechanical issues or performance anomalies
+        - Helps engineers spot problems before they become critical
+        
+        **📈 Predictive Modeling:**
+        - Machine learning models predict tire degradation and fuel consumption
+        - Based on real-time telemetry inputs (speed, throttle, temperatures)
+        - Enables strategic decision-making during races
+        
+        **🎯 Key Features:**
+        - Real-time telemetry processing simulation
+        - Advanced visualization of racing data
+        - Performance prediction for race strategy
+        - Anomaly detection for preventive maintenance
+        
+        **🏗️ Technical Stack:**
+        - Python with scikit-learn for ML models
+        - Isolation Forest for anomaly detection
+        - Linear regression for performance prediction
+        - Matplotlib for advanced visualizations
+        - Gradio for interactive web interface
+        """)
+
+if __name__ == "__main__":
+    demo.launch()