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()