Vous avez envie d’explorer un nouvel ensemble de données ? Hé bien, pourquoi pas tenter une analyse de données de Formule 1 avec Python. Si vous ne savez pas comment vous y prendre, alors ce guide est fait exactement pour vous !
Ce tutoriel vous fournira tout ce dont vous avez besoin pour extraire en temps réel les données de la Formule 1 de 2018 jusqu’à aujourd’hui. À partir de là, on verra 5 astuces rapides d’analyse de données.
Ce tutoriel vous fournira également des ressources, des explications et des conseils tout au long du processus ! Prêt à commencer ?!!
Mise en place de l’environnement pour l’analyser de données de Formule 1 avec Python
Démarrer avec fastf1 – les données
fastf1 est un paquet Python permettant d’accéder en direct aux données historiques de chronométrage et de télémétrie de la F1. Alors laissez-moi maintenant expliquer en détail comment la bibliothèque fastf1 fonctionne. Fastf1 a également sa propre documentation, mais si vous êtes débutant vous risquez de ne pas vous y retrouver.
Commençons par les bases : installer la bibliothèque fastf1 et importer les bibliothèques dont nous avons besoin.
Installation de fastf1
Il est recommandé d’installer FastF1 en utilisant pip :
pip install fastf1
Notez que Python 3.8 ou plus est requis.
Importation des bibliothèques
Pour l’instant, il s’agit uniquement de la bibliothèque fastf1 et de Pandas :
import fastf1 as ff1 import pandas as pd
Mettre en cache les données
Chaque week-end, une énorme quantité de données est générée, ce qui prend du temps à charger. Fastf1 a donc fourni une fonctionnalité de cache qui stocke les données d’un week-end de course dans un certain dossier, de sorte que la prochaine fois que les données sont chargées, il va beaucoup plus vite. Pour ce faire, nous créons un dossier appelé ‘cache’, puis nous activons la mise en cache avec :
# Activer la mémoire cache
ff1.Cache.enable_cache('cache') Chargement d’une session de données
Pour charger les données d’une certaine course, nous devons spécifier trois paramètres :
- year : année de la course
- gp : nom ou numéro du weekend. Exemple de type string : « 1 » pour Australie, … « 21 » pour Abu Dhabi. Ou encore on peut passer le nom du circuit, ex : « monza »
- event (optionnel) : type de course, exemple les qualifs avec « Q »
Disons que nous sommes intéressés par les qualifications du Grand Prix de Turquie 2021. Nous passerions ces arguments :
quali = ff1.get_session(2021, 'Turkey', 'Q')
La bibliothèque fastf1 peut identifier correctement le Grand Prix en fonction de différents types d’entrées. Au lieu de « Turquie », nous aurions par exemple pu dire « Istanbul », « Istanbul Park » ou « 16 » (c’était la 16ème course de la saison).
Maintenant que nous avons défini la session, nous pouvons charger les tours. Cela va fonctionner pendant quelques secondes (la prochaine fois sera plus rapide puisqu’elle collectera les données depuis le cache).
laps = quali.load_laps(with_telemetry=True)
Je vous recommande vivement d’inspecter la variable laps pour voir de quoi il s’agit. Ce sera le sujet de la seconde partie de ce tuto !
5 astuces rapides pour une analyse de données de Formule 1 avec Python
Si tout est prêt, nous chargeons les bibliothèques, activons le cache fastf1, sélectionnons une course (cela peut être n’importe quelle course évidemment, pour cet exemple nous allons travailler avec Abu Dhabi 2021), et chargeons ses tours.
import fastf1 as ff1
import pandas as pd
# Activer la mémoire cache
ff1.Cache.enable_cache('cache')
# Charger les données d'une course F1
race = ff1.get_session(2021, 'Abu Dhabi', 'R')
# Obtenir les tours
laps = race.load_laps(with_telemetry=True)Vous trouverez l’ensemble du code des 5 astuces suivantes sur un notebook disponible sur Google Colab en cliquant ici.
Astuce 1 : explorer les données
Lorsque vous avez devant vous un nouvel ensemble de données, vous souhaitez probablement commencer par vous faire une première idée de ces données. Cela signifie avoir une idée des variables/features contenues dans l’ensemble de données, de la façon dont elles se comportent, etc. Heureusement, Pandas offre de nombreux outils pour cela.
Commençons par .head(), une fonction qui vous montre simplement les 5 premières lignes (la tête) d’un DataFrame. Si vous lui passez un argument, par exemple .head(10), cela vous donnera les 10 premières lignes de l’ensemble de données. Pour les 5 dernières lignes du DataFrame, vous pouvez utiliser .tail().
laps.head()
Une autre fonction que je trouve vraiment utile pour explorer rapidement les données est .T. Elle est très basique et très simple, mais elle remplit une fonction intéressante. Le « T » signifie « Transformer » et permet d’intervertir les colonnes et les lignes. Je travaille souvent avec des ensembles de données qui ont beaucoup de colonnes, et souvent je ne peux pas facilement les explorer toutes car les colonnes du milieu sont omises sur l’axe horizontal sur Jupyter Notebook. L’exécution de .T vous montre toutes les colonnes d’un ensemble de données, y compris les données contenues dans ces colonnes. Vous pouvez également combiner cette fonction avec .head(), en exécutant par exemple laps.head().T.
laps.T
La méthode rapide d’exploration des données que je vais présenter ensuite est .describe(), qui vous fournira des statistiques sommaires de toutes les variables quantitatives de l’ensemble de données.
laps.describe()
Encore, une fois vous trouverez les sorties (outputs) obtenues en vous référant au notebook suivant.
Astuce 2 : Trouver le tour le plus rapide
Si vous souhaitez localiser des données spécifiques dans un DataFrame, vous pouvez utiliser DataFrame.loc[] pour trouver ces données en fonction des critères que vous avez saisis. Ainsi, disons que nous voulons trouver le tour le plus rapide. Ce que nous pouvons faire, c’est trouver le temps le plus rapide en utilisant .min(), et obtenir la ligne qui appartient à ce temps le plus rapide en utilisant loc[]. Laissez-moi vous montrer !
laps.loc[laps['LapTime'] == min(laps['LapTime'].dropna())]
Ce que nous demandons à Python c’est : « donne-nous la ligne où la feature ‘LapTime’ est égal au LapTime (temps de tour du circuit) le plus bas que tu puisses trouver ». Le critère que nous donnons pour sélectionner les données dont nous avons besoin est laps['LapTime'] == min(laps['LapTime']), donc en fait Pandas va nous retourner la ligne où le LapTime est égal au LapTime le plus bas qui existe (donc, le tour le plus rapide). Nous devons également y ajouter .dropna(), car il y a quelques laptimes manquants (NaN – Not A Number) qui ne doivent pas être pris en compte.
Astuce 3 : Compter l’utilisation des pneus
Une autre astuce très simple et extrêmement pertinente à appliquer en utilisant Pandas est .value_counts(). Imaginons que vous souhaitiez savoir quel pneu a été le plus utilisé pendant une course. Vous pourriez le mesurer en comptant le nombre total de tours effectués avec chaque pneu. Pour ce faire, il suffit d’une simple ligne de commande :
laps['Compound'].value_counts()
Ce que nous demandons à notre programme est en fait très simple : « nous donner le nombre d’occurrences (counts) de chaque valeur unique dans la ligne ‘Compound' ». Cela nous renvoie ensuite le nombre de tours utilisés par chaque valeur pendant la course.
Astuce 4 : Cadence de la course au sein des équipes
Et si nous voulons connaître le temps moyen par tour de chaque pilote dans chaque équipe ?
Pandas dispose d’une méthode extrêmement utile appelée .groupby(). En gros, elle vous permet de regrouper des données en fonction des colonnes que vous spécifiez, et vous permet de résumer ces données. Nous allons utiliser cette fonction à plusieurs reprises dans cet article, car elle est très utile. Pour analyser la cadence moyenne par tour de chaque pilote dans chaque équipe, nous procédons comme suit :
laps[['Team', 'Driver', 'LapTime']].groupby(['Team', 'Driver']).mean().sort_values(['Team', 'LapTime'])
Ce que nous demandons à Python de faire ici c’est de : « Récupérer les colonnes appelées Team, Driver et LapTime, regrouper en fonction de Team et Driver, et calculer la moyenne des LapTimes au sein de ces groupes. Ensuite, ordonnez les valeurs de façon à ce que les équipes soient dans l’ordre alphabétique et que le pilote le plus rapide soit en haut ».
Astuce 5 : Les pilotes les plus rapides « au piège à vitesse »
Comme la fonctionnalité groupby() est extrêmement importante dans de nombreux cas d’utilisation, je vais vous montrer un autre exemple d’utilisation.
À chaque tour, les pilotes passent par le « piège à vitesse » : un point de mesure spécifique pendant le tour qui enregistre la vitesse de la voiture chaque fois qu’elle passe devant ce point. Si nous voulons savoir quels pilotes ont enregistré les vitesses les plus élevées dans le « piège à vitesse » et quels pilotes ont enregistré les vitesses les plus faibles, nous pouvons procéder comme suit :
laps[['Driver', 'SpeedST']].groupby(['Driver']).max().sort_values('SpeedST', ascending=False)Nous demandons à Python de faire ce qui suit : « Prendre les colonnes Driver et SpeedST (= Vitesse au piège à vitesse : [S]peed [T]rap), regrouper les données par conducteur, renvoyer la valeur la plus élevée (de la vitesse) de ce conducteur, et ordonner les données par ordre décroissant en fonction de la vitesse ».
Plutôt simple, non ? Nous obtenons alors une liste de tous les pilotes et de leurs vitesses les plus élevées, avec le pilote le plus rapide en tête.
Et voilà, c’est tout ! J’espère que vous avez apprécié ces quelques techniques d’analyse de données en Python à travers des exemples de Formule 1.
Chaque analyse est différente et nécessite des approches différentes. Le but de ce (court) tutoriel était de vous aider à vous lancer si vous ne savez pas vraiment par où commencer. Maintenant que vous savez comment obtenir les données de toutes les courses de Formula 1, il est temps de vous lancer et de les analyser vous-même !
Pour aller plus loin sur la bibliothèque Pandas, vous pouvez consulter nos 12 techniques utiles de manipulation de données avec Pandas !
