Gains :
- Capacité à établir un flux de travail d'analyse reproductible qui charge et nettoie les données de télémétrie, de test et de production avec pandas
- Capacité à comprendre et à vérifier la sortie ligne par ligne tout en recevant le code, les attributs et l'aide à la visualisation de l'intelligence artificielle
- Capacité à vérifier les résultats d'analyse pour vérifier la cohérence des unités, les fuites de données et la reproductibilité
Dans les unités précédentes, nous utilisions l'intelligence artificielle comme un « conseiller ». Dans cette unité, nous allons encore plus loin et établissons un flux de travail qui analyse les données automobiles de nos propres mains, à l'aide de Python. Le but n’est pas de faire de vous un développeur de logiciels ; Il s'agit de former un ingénieur capable de comprendre et de vérifier ce code ligne par ligne tout en bénéficiant de l'assistance de l'IA pour le code. Parce que le code produit par l’IA peut être défectueux, tout comme le texte produit par l’IA ; peut confondre le volume, fuir les données, centrer la mauvaise colonne. Exécuter le code sans le comprendre revient à publier un rapport non signé.
Python, pourquoi ? Parce que c'est le standard de facto en matière d'analyse de données : vous pouvez facilement traiter les données de télémétrie, de test et de production avec les bibliothèques pandas (données tabulaires), numpy (traitement numérique), matplotlib (tracé) et scikit-learn (apprentissage automatique).
Six étapes pour une analyse reproductible
Une analyse solide suit toujours le même cadre :
- Charger : lire les données du fichier.
- Inspecter : dimension, colonnes, types de données, valeurs manquantes.
- Nettoyer : correction manquante/aberrante, unité, horodatage.
- Fonction d'extraction : dérivez des variables significatives.
- Analyse/modèle : statistiques, visualisation ou modèle.
- Vérifier et rapporter : fourniture des résultats, contrôle du volume/fuite, enregistrement.
Astuce : lorsque vous demandez du code à l’IA, dites « commentez ce que vous faites à chaque étape et écrivez vos hypothèses ». Vous pouvez donc vérifier le code au fur et à mesure que vous le lisez.
Exemple étape par étape : analyse de télémétrie
Le code suivant charge un enregistrement CAN/télémétrie et effectue une vérification de base. (Remarque : assurez-vous de bien comprendre les codes avant de les exécuter ; les noms de colonnes varient en fonction de vos données.)
importer des pandas en tant que pd# 1) Charger : CSV semi-pointillés, première colonne timestampdf = pd.read_csv("telemetry.csv", parse_dates=["time"])# 2) Checkprint(df.shape) # combien de lignes, combien de colonnesprint(df.dtypes) # type de chaque colonne (nombre ou texte)print(df.isna().sum()) # nombre de valeurs manquantes par columnprint(df.describe()) # statistiques récapitulatives : min, max, moyenne
La sortie describe() est votre première opportunité de vérifier : si la valeur maximale du régime moteur est de 45 000 tr/min (moteur de passager typique ~ 7 000 tr/min), il y a un défaut d'unité ou de capteur.
Les commandes pandas les plus fréquemment utilisées lors de l'étape d'audit et ce qu'elles font :
commande
Qu'est-ce que
Qu'est-ce que cela confirme ?
df.forme
Nombre de lignes/colonnes
Est-ce la taille attendue ?
df.dtypes
Types de colonnes
La colonne numérique est-elle devenue du texte ?
df.isna().sum()
Nombre de valeurs manquantes
Combien d'espace y a-t-il ?
df.describe()
Min/max/moyenne
Est-ce physiquement raisonnable ?
df.duplicate().sum()
ligne en double
Y a-t-il une double inscription ?
# 3) Clair : marquer les valeurs physiquement impossibles
Attention : Ne supprimez pas la valeur aberrante immédiatement ; Comprenez d’abord pourquoi c’est une valeur aberrante. S'agit-il d'un événement réel (échauffement soudain) ou d'une panne de capteur ? La suppression aveugle peut masquer le véritable défaut.
# 4) Extraire la fonctionnalité : taux d'augmentation de la température (dérivée)df = df.sort_values("time")df["sic_increase_speed"] = df["motor_sic"].diff() / df["time"].diff().dt.total_seconds()# 5) Visualisation simple : importer matplotlib.pyplot en tant que pltplt.plot(df["time"], df["motor_sic"])plt.xlabel("Heure"); plt.ylabel("Température du moteur (C)")plt.title("Cours de température du moteur")plt.show()
Prévenir les fuites de données en Python
L'erreur la plus dangereuse lors de la construction d'un modèle de prédiction est la fuite de données (unité 5) : lorsque le modèle voit des informations qui ne peuvent pas être connues au moment de la prédiction. La règle d'or pour éviter cela dans les séries chronologiques : s'entraîner avec le passé, tester avec le futur - pas de mélange aléatoire.
from sklearn.model_selection import train_test_split# FALSE : la division aléatoire de la série chronologique laisse filtrer le futur# df[df["time"] > seuil] # derniers 20 % du futur
Attention : train_test_split mélange les données par défaut (shuffle=True). Dans la série chronologique, cela confond l’avenir avec l’éducation et produit un score faussement élevé. Si l'IA a fait cela dans le code qu'elle produit, assurez-vous de le corriger.
Cohérence des unités : tueur silencieux
Les erreurs les plus insidieuses dans l’automobile sont les erreurs d’unité : km/h en m/s, Nm en lb-ft, bar en kPa, °C en K. Tenir un dictionnaire de l’unité de chaque colonne dans l’analyse et noter les conversions sauve clairement des vies.
# Documenter explicitement les unités = {"speed": "km/h", "motor_sic": "C", "pression": "bar"}# Conversion explicite si nécessaire (km/h -> m/s)df["speed_ms"] = df["speed"] / 3.6
Mini-études de cas
Cas 1 : Erreur détectée avec décrire(). Un analyste exécute le code de l'IA et fait une estimation de la plage ; Le résultat est absurdement élevé. Lorsque nous regardons la sortie describe(), nous voyons que la capacité de la batterie est saisie en Wh dans certaines lignes et en kWh dans d'autres (différence 1000 fois). Lorsque l'unité est amenée à un type uniforme, le résultat s'améliore. Conclusion : Une simple statistique récapitulative a évité une mauvaise prédiction.
Cas 2 – Piège à confusion. Le modèle d'usure des freins d'un stagiaire était précis à 98 % sur l'ensemble de tests. Lorsque le code est examiné, on peut voir que train_test_split(shuffle=True) et les séries temporelles sont mélangées, ce qui signifie que des points futurs s'infiltrent dans la formation. Divisée par le temps, la précision tombe à 80 %, mais elle est désormais réaliste. Conclusion : Ce n'est pas parce que le code de l'IA fonctionnait ; L'humain a détecté la fuite.
Cas 3 – Comprendre la valeur aberrante. Dans un enregistrement de durabilité, le code AI supprime automatiquement les valeurs de déformation aberrantes. L'ingénieur regarde les points supprimés ; C’est exactement à ces moments-là que le test s’est intéressé. Les suppressions sont supprimées et les violations sont examinées séparément. Résultat : Sous « Nettoyage », le signal réel peut être supprimé ; remettre en question chaque étape.
modèles d'invite
Modèle 1 - Code de demande (avec explication) :
Rôle : Vous êtes un mentor d'analyste de données Python. Tâche : Écrire du code qui charge et vérifie un CSV de télémétrie. Contexte : Colonnes : temps, vitesse (km/h), moteur_sic (C), révolution (rpm). Contrainte : Commentez chaque ligne ; Expliquez quel contrôle a été effectué et pourquoi ; ajouter un contrôle de valeur physiquement impossible ; ne supprimant rien en silence. Sortie : code commenté + quelle sortie je devrais regarder et pourquoi.
Modèle 2 – Inspection des fuites :
Rôle : Vous êtes un réviseur de code d'apprentissage automatique. Tâche : Vérifiez le code partagé de formation/test suivant pour détecter les fuites de données. Contexte : Il s'agit d'une série temporelle (télémétrie du véhicule). Contrainte : avertir en cas de brassage aléatoire ; Proposer et justifier le fractionnement par temps. Résultat : Résultats + code corrigé + explication.
Modèle 3 - Validation de l'unité :
Rôle : Vous êtes un auditeur de la qualité des données. Tâche : Suggérer des contrôles qui recherchent une incohérence d'unité dans un DataFrame. Contexte : La capacité peut être de kWh dans certaines lignes et de Wh dans d'autres. Résultat : Vérifier le code + comment trouver le modèle suspect.
Modèle 4 - Visualisation + commentaire :
Rôle : Vous êtes un expert en visualisation de données. Tâche : Écrire du code qui trace l'évolution de la température du moteur et son taux d'augmentation. Contrainte : Etiqueter les axes avec l'unité ; marquer visuellement l'anomalie ; ne prétendez pas à une faute définitive lors de l’interprétation du graphique. Résultat : Code + ce qu'il faut rechercher dans le graphique.
Invite faible/Invite forte
Invite faible :
Construisez un modèle avec ces données.
On ne sait pas quelle cible, quel compartiment, quelle vérification ; L’IA peut produire du code brouillé, fuyant et aveugle.
Invite puissante :
Rôle : Vous êtes un mentor Python ML. Tâche : Rédiger un flux de travail initial pour prédire l'usure des plaquettes de frein et démontrer les pièges de la validation. Contexte : Télémétrie de séries chronologiques ; cible : épaisseur restante du tampon. Contrainte : diviser les séries temporelles par temps (pas de brassage) ; signaler les attributs présentant un risque de fuite de données ; unités de document ; interpréter chaque étape ; Notez les contrôles requis avant que le résultat ne soit envoyé sur le terrain. Sortie : code commenté + liste de contrôle de vérification.
Erreurs courantes
- Exécuter le code sans le comprendre. Le code AI peut également être défectueux ; Lisez ligne par ligne.
- Mélanger des séries chronologiques. shuffle=True divulgue le futur et produit un faux score.
- Supprimez aveuglément la valeur aberrante. Le signal réel (apparition du défaut) peut être effacé.
- Ne pas documenter l'unité. Les erreurs telles que km/h vs m/s, Wh vs kWh augmentent silencieusement.
- Ignorer l'étape describe()/check. La plupart des erreurs apparaissent dans les premières statistiques récapitulatives.
En résumé
- Python (pandas, numpy, matplotlib, scikit-learn) est le standard de facto en matière d'analyse de données automobiles.
- Analyse reproductible : charger, inspecter, nettoyer, caractériser, analyser, valider et créer un rapport.
- Il est impératif de comprendre et de vérifier le code que l’IA produit ligne par ligne ; Ce n’est pas parce que ça marche que c’est bien.
- Maintenir la distinction passé/futur dans les séries chronologiques ; Le brassage aléatoire crée une fuite de données.
- La cohérence des unités et l’interprétation des valeurs aberrantes sont des points de vérification silencieux mais critiques.
Tâche de candidature
Prenez un petit ensemble de données (télémétrie réelle ou synthétique). (1) En suivant le cadre en six étapes, générez le code de chargement et de contrôle avec le modèle 1 et confirmez que vous comprenez chaque ligne. (2) Recherchez au moins une valeur suspecte dans la sortie describe() et recherchez pourquoi. (3) Dans une tâche de prédiction, chronométrez la répartition entraînement/test et vérifiez le risque de fuite avec le modèle 2. (4) Documentez l'unité de chaque colonne que vous utilisez dans un dictionnaire.
liste de contrôle
- [ ] J'ai mis en place l'analyse avec un cadre en six étapes.
- [ ] J'ai lu et compris le code produit par l'IA ligne par ligne.
- [ ] J'ai recherché des valeurs suspectes avec décrire()/audit.
- [ ] J'ai divisé la série chronologique par temps (pas de brassage).
- [ ] J'ai marqué les attributs qui risquent de fuir des données.
- [ ] J'ai documenté l'unité de chaque colonne et écrit explicitement les conversions.