Gains :
- Capacité à automatiser les calculs techniques, la gestion des unités et le traitement des données avec du code Python alimenté par l'IA
- Capacité à valider le code de l'IA avec la vérification des unités, les tests de résultats connus et les cas extrêmes
- Capacité à prendre l'habitude de produire des documents comptables reproductibles, traçables et dont les versions sont contrôlées
En génie mécanique, le même calcul est répété encore et encore : contraintes d'une famille de pièces, puissance de pompe pour une plage de points de fonctionnement, tableaux de propriétés à différentes températures. Les faire manuellement est à la fois lent et sujet aux erreurs. Python (un langage de programmation facile à apprendre doté de riches bibliothèques pour l'ingénierie) automatise ces itérations ; Cela rend le compte reproductible, traçable et contrôlé par les versions. Intelligence artificielle (IA) Python est incroyablement rapide pour générer du code : convertir une formule en fonction, ajouter la gestion des unités, lire des données, tracer des graphiques. Mais il existe ici une idée fausse et dangereuse : ce n’est pas parce que le code fonctionne sans erreur qu’il calcule correctement. Le code AI peut renvoyer silencieusement des résultats incorrects en raison d'une conversion d'unité incorrecte, d'une formule incorrecte ou dans des cas extrêmes, et le programme continuera à s'exécuter sans aucune erreur. C'est pourquoi chaque code d'ingénierie produit avec l'IA ; Les entrées de test avec des résultats connus ne sont pas fiables sans vérification par vérification d'unité (taille) et essais de cas extrêmes. Dans cette unité, vous apprendrez comment configurer en toute sécurité l'automatisation des comptes Python avec l'IA.
Pourquoi Coder Compte ? Traçabilité et reproductibilité
Un calcul manuel est ponctuel ; Lorsqu'une entrée change, elle est effectuée à partir de zéro et les étapes intermédiaires sont perdues. Le calcul effectué en code est comme un document : les entrées, les formules et les sorties sont clairement écrites ; vous modifiez une entrée et obtenez un nouveau résultat en quelques secondes ; Avec le contrôle de version (comme git), "ce que j'ai calculé avec quelle valeur à quelle date" peut être suivi. Cela est inestimable en termes de contrôle et de responsabilité. Mais ce pouvoir dépend de l’exactitude du code ; Un mauvais code produit un mauvais résultat, également reproductible et rapide.
Astuce : écrivez un test pour chaque fonction de calcul avec un résultat vrai connu à côté (assertion en Python). Par exemple, votre fonction de contrainte devrait donner 28,1 MPa dans un échantillon connu. Ce test vous avertit immédiatement si vous cassez quelque chose lorsque vous modifiez le code ultérieurement. Un code d'ingénierie qui n'est pas testé est un compte non vérifié.
Gestion des volumes : source d'erreur la plus courante
Dans le code d'ingénierie, la plupart des erreurs proviennent d'unités : N avec kN, m avec mm, Pa avec MPa, qui peuvent être confondues d'un facteur 1 000 ou 1 000 000. Il y a deux défenses. La première est la discipline : choisir un système d'unités uniques dès le début (par exemple N, mm, MPa), y convertir toutes les entrées et ajouter des unités aux noms de variables (length_mm, force_N). Le second est l'outil : une bibliothèque comme pint contient les unités dans le code et détecte l'opération incohérente comme une erreur.
Approche
Comment ça marche
Avantage
Nommer la discipline
comme force_N, length_mm
Simple, pas de dépendances
système à unité unique
Le tout converti en N-mm-MPa
Simplicité, rapidité
bibliothèque de pintes
Déplace l'unité par variable
Détecte automatiquement les incohérences
Test de résultat connu
référence avec assert
Détecte l'erreur de formule/unité
Attention : Une conversion d'unité peut être manquante ou incorrecte dans le code généré par l'IA et le code "fonctionnera" toujours. Par exemple, si le diamètre est en mm et que la surface est attendue en m², le résultat s'écartera de 1 000 000 de fois, mais le programme ne donnera pas d'erreur. Avant d'exécuter le code, commentez les unités des entrées et des sorties ; puis fournissez le résultat avec un exemple connu.
Étape par étape : code de compte vérifiable par l'IA
- Clarifiez le problème et le système d’unités. Entrées, sorties, unités.
- Générez la fonction. Responsable unique, interprétatif, solidaire.
- Ajouter un test de résultats connus. Affirmez avec un exemple de référence.
- Essayez les cas extrêmes. Entrée nulle, négative, très grande/petite.
- Faites une vérification de l'unité. L’unité de production correspond-elle à ce qui est attendu ?
- Document et version. Hypothèses, source, date ; traçabilité avec git.
Invite qui génère des fonctions et des tests
Rôle : Développeur Python expérimenté rédigeant des calculs d'ingénierie. Tâche : Écrivez une fonction qui calcule la contrainte de flexion maximale dans une poutre en porte-à-faux de section rectangulaire. Entrée : F (N), L (mm), b (mm), h (mm). Sortie : sigma (MPa).Convention : Système d'unités N-mm-MPa ; commentez l'unité de chaque entrée. Règle : utilisez I = b*h^3/12 et sigma = M*c/I ; commentez les étapes.Règle : Ajouter un test avec RÉSULTAT CONNU : sigma ~28.1 MPa pour F=500,L=300,b=20,h=40 ; Vérifiez avec assert (petite tolérance).
Invite d'état du dispositif Edge
Ajoutez des vérifications de cas extrêmes à la fonction ci-dessus : - Si b, h ou L sont nuls ou négatifs, donnez une erreur significative (augmentez ValueError). - Commentez s'il y a un problème de débordement/précision avec des entrées très grandes/petites. Ajoutez également 3 autres entrées de test différentes et écrivez le résultat attendu ; expliquer les résultats de manière à ce que je puisse les vérifier manuellement.
Invite de sécurité de l'unité (pinte)
Sécurisez le même compte avec la bibliothèque 'pint'. Laissez les entrées être définies en unités (par exemple 500 * ureg.newton). Convertissez la sortie en MPa et imprimez-la. Ajoutez un petit exemple montrant comment pint échoue lorsqu'on lui donne une entrée avec la mauvaise unité.
Invite de vérification du code
Critiquez mon code de calcul d'ingénierie ci-dessous du point de vue de la révision du code, ne soyez pas d'accord avec moi. En particulier : la conversion d'unités est-elle correcte, la formule est-elle correcte, les cas extrêmes (zéro, négatif) ont-ils été pris en compte, les tests sont-ils vraiment confirmatifs ? Pour chaque résultat, écrivez comment le corriger.[code]
Invite faible/Invite forte
Invite faible :
Écrivez du code Python pour le calcul des contraintes.
Aucun choix d'unités, de formules, de définitions d'entrée et de tests ; L'IA génère du code qui fonctionne mais qui n'est pas vérifié et dont l'unité est inconnue.
Invite puissante :
Écrivez la fonction de contrainte de flexion dans la poutre en porte-à-faux. Entrée F(N), L(mm), b(mm),h(mm); Sigma de sortie (MPa). Système N-mm-MPa, précisez chaque unité dans le commentaire. Ajoutez un test avec des résultats connus (F=500, L=300, b=20, h=40 → ~28,1 MPa, assert). Donne une erreur sur une entrée nulle/négative. Interpréter les cas extrêmes.
La deuxième invite nécessite le système d'unités, la formule, les entrées, le test et les cas extrêmes ; Cela rend le code vérifiable.
Trois mini-étuis (par numéros)
Cas 1 – Erreur de volume silencieux. Le calcul de surface produit par AI prend le diamètre en mm et donne mm² avec pi*d**2/4, mais la ligne suivante le met dans une formule qui attend m² ; Le code fonctionne sans erreur et donne une contrainte 1 000 000 fois inférieure. Lorsque l'ingénieur exécute le test avec un résultat connu (affirmation abs(sigma-28.1)<0,5), le test explose et l'erreur est détectée. S'il n'y avait pas eu de test, un résultat erroné serait entré dans le rapport sans que l'on s'en aperçoive. Leçon : code fonctionnel ≠ code correct.
Cas 2 – Crash de l’état Edge. Dans le code qui boucle pour une famille de pièces, l'épaisseur h=0 est saisie sur une seule ligne ; Lorsque I = b*h**3/12 = 0, sigma = M*c/I donne une division par erreur nulle. Grâce au contrôle if h<=0: raise ValueError ajouté par l'IA, le code s'arrête avec un message significatif et ne produit pas d'inf en silence. Leçon : gérer les cas extrêmes au préalable.
Cas 3 - Gain de répétabilité. Il a fallu une demi-journée à un ingénieur pour calculer manuellement la puissance de la pompe pour 40 points de fonctionnement différents. Écrit en IA, le script lit le CSV, calcule la puissance de chaque ligne et vérifie un point connu avec assert, réduisant le travail à environ 2 minutes et écrivant les résultats dans un fichier traçable. Lorsqu'une entrée change, le tableau entier est mis à jour toutes les secondes. Leçon : l’automatisation vérifiée est à la fois rapide et fiable.
Erreurs courantes
- Erreur « Travaillé = correct » : penser que le code qui fonctionne sans erreurs est correct.
- Ne pas écrire de tests : s'appuyer sur du code sans test de référence avec un résultat connu.
- Ambiguïté de l'unité : laisser les unités d'entrée/sortie non interprétées, ignorer la conversion.
- Ignorer les cas extrêmes : erreur silencieuse ou crash sur entrée nulle/négative.
- Ne pas documenter la source/hypothèse : Ne pas noter la source et l'hypothèse de la formule utilisée.
- Pas de versionnage : laisser le compte sous forme de fichier unique sans le rendre traçable (git).
En résumé
- Python rend les calculs d'ingénierie reproductibles, traçables et contrôlés par les versions.
- L’IA génère très rapidement du code ; Mais le fait que le code fonctionne sans erreur ne signifie pas qu'il calcule correctement.
- Chaque code doit être validé par des tests à résultats connus, une vérification unitaire et des cas extrêmes.
- Les erreurs unitaires sont la source d’erreur la plus fréquente et la plus insidieuse ; Défendre par système d'unité unique, nomenclature ou pinte.
- L'automatisation validée fait gagner du temps et donne confiance ; Un code non vérifié est dangereux.
Tâche de candidature
Choisissez un calcul technique récurrent (comme la contrainte, la puissance de la pompe, la charge thermique). Écrivez une fonction Python à l'IA qui effectue ce calcul ; Commentez l'unité de chaque entrée et sortie et ajoutez un test d'assertion avec un résultat connu. Exécutez le test et voyez s’il réussit. Effectuez ensuite deux vérifications supplémentaires : essayez un cas limite (entrée nulle ou négative) pour vérifier que le code renvoie une erreur significative, et fournissez manuellement l'unité de sortie dans un exemple. Si possible, faites également produire une version sans danger pour l'unité en pinte. Enfin, ajoutez les hypothèses du calcul, la source de la formule et la date au code sous forme de titre court et écrivez pourquoi ce code nécessite toujours l'approbation de l'ingénieur.
liste de contrôle
- [ ] Les unités d'entrée et de sortie sont clairement documentées dans le code ; Un système à unité unique a été choisi.
- [ ] Un test (assert) avec un résultat connu a été ajouté et réussi.
- [ ] Au moins un cas limite (zéro/négatif) a été tenté ; Le code a donné une erreur significative.
- [ ] L'unité de sortie a été fournie par un exemple manuel (sans supposer "travaillé = correct").
- [ ] Source de la formule, hypothèses et date notées dans le code.
- [ ] Compte tenu traçable/suivi ; l'approbation finale était laissée à l'ingénieur.