Calcul numérique, Python et génération de code

Gains :

• Capacité à distinguer le calcul symbolique du calcul numérique et à choisir le bon outil (SymPy ou NumPy/SciPy) pour chaque problème
• Capacité à lire et à comprendre le code numérique produit par l'intelligence artificielle, à l'exécuter vous-même et à le vérifier en effectuant un test de bon sens avec une entrée connue.
• Comprenez les limites de la précision des nombres à virgule flottante, utilisez la tolérance au lieu de l'égalité exacte et gérez l'impact des suppositions initiales sur les méthodes numériques.

Le calcul symbolique donne la formule exacte d'une intégrale ou d'une équation ; Mais la plupart des problèmes pratiques en mathématiques ne peuvent être résolus par une formule fermée. C'est là que le calcul numérique entre en jeu : produire un résultat numérique approximatif avec la précision souhaitée, plutôt qu'une formule exacte. Trouver la valeur d'une intégrale avec une précision de 0,001, calculer la racine d'une équation à l'approximation décimale, extraire des statistiques d'un ensemble de données, ce sont tous des calculs numériques. En Python, les outils pour cela sont les bibliothèques NumPy (tableaux numériques et mathématiques) et SciPy (informatique scientifique). Dans cette unité, vous apprendrez à utiliser l'IA comme assistant qui génère du code Python pour le calcul numérique et vérifierez l'exactitude du code.

Une définition critique : un nombre à virgule flottante est un format dans lequel un ordinateur stocke des nombres décimaux avec une précision limitée. C'est pourquoi, en arithmétique informatique, 0,1 + 0,2 peut s'avérer être 0,30000000000000004, pas exactement 0,3. Ce n’est pas une erreur, c’est la nature du calcul numérique – mais cela conduira à des résultats incorrects si vous n’en êtes pas conscient. En calcul numérique, on travaille avec « assez proche » plutôt qu'avec « égalité exacte ».

Symbolique ou numérique ? Choisir le bon outil

Statut

Symbolique (SymPy)

Numérique (NumPy/SciPy)

Il existe une formule fermée

préféré

pas nécessaire

Pas de formule/trop complexe

je ne peux pas résoudre

préféré

Précision totale requise

Oui

Env.

Big data / multi-traitements

lent

très vite

Le résultat avec décimal est suffisant

—

approprié

Un bon praticien utilise les deux : résoudre symboliquement si possible, passer au numérique sinon et recouper l'un avec l'autre autant que possible.

Pas à pas : calcul numérique sécurisé avec l'IA

1. Identifiez le problème et la sensibilité. "Combien de décimales ?" et "dans quelle plage?" Clarifiez vos questions.

2. Écrivez du code sur l'IA, pas de sortie. Rappelez-vous de l'unité 4 : ne faites pas sortir le code de prédiction de l'IA. Vous exécutez le code.

3. Lisez et comprenez le code. Comprenez le code généré ligne par ligne. Bonne bibliothèque, bonne fonction, bons paramètres ? N'exécutez pas de code que vous ne comprenez pas.

4. Testez avec une situation connue. Essayez le code avec une simple saisie pour laquelle vous connaissez déjà la réponse. Par exemple, sin(0)=0, comme la valeur d’une intégrale connue. Si le code le donne correctement, vous lui ferez davantage confiance.

5. Vérifiez symboliquement ou manuellement. Si possible, confirmez le même résultat avec SymPy ou une approche manuelle.

6. Méfiez-vous des pièges à virgule flottante. Au lieu d'une égalité stricte avec ==, utilisez des tolérances telles que abs(a - b) < 1e-9.

Astuce : Testez toujours un code numérique « avec une réponse que vous connaissez ». Si vous avez écrit un outil de recherche de racine, appliquez-le d'abord à une équation avec une racine connue (x=±2), telle que x²−4=0. Si le code trouve cela correct, il devient plus susceptible d'être fiable sur des équations que vous ne connaissez pas. Ce « contrôle d’intégrité » est la vérification la moins chère.

Le piège du calcul numérique : convergence et accumulation d’erreurs.

La plupart des méthodes numériques fonctionnent de manière itérative : en partant d’une supposition initiale et en s’approchant progressivement de la réponse réelle. Ce processus de rapprochement s’appelle la convergence. Mais toutes les méthodes itératives ne convergent pas toujours ; certains divergent (s'éloignent du résultat) ou convergent vers une valeur incorrecte. Si un code généré par l’IA ne vérifie pas si la méthode converge, il peut vous donner silencieusement un mauvais numéro. Ainsi, ce n'est pas parce qu'un résultat numérique « a produit un nombre » qu'il est vrai ; Il faut également confirmer que ce nombre converge effectivement vers la solution recherchée.

Une deuxième subtilité est l’accumulation d’erreurs. Dans une longue chaîne de calculs, de petites erreurs d'arrondi en virgule flottante à chaque étape peuvent s'accumuler et devenir plus importantes ; Surtout lorsque vous faites la différence entre deux grands nombres très proches (c'est ce qu'on appelle une annulation catastrophique), des chiffres significatifs du résultat peuvent être perdus. L’intelligence artificielle ne prédit pas toujours de tels problèmes de stabilité numérique. Dans les calculs critiques, recalculer et comparer le résultat avec une méthode différente ou avec une précision plus élevée révèle une accumulation d’erreurs cachées.

Attention : « Donner un résultat » et « converger vers le bon résultat » d'une méthode numérique sont deux choses différentes. Assurez-vous que le code inclut une vérification de convergence (par exemple, que la différence entre deux étapes successives devient suffisamment petite) ; S’il ne le contient pas, demandez à l’intelligence artificielle d’ajouter ce contrôle.

trois mini-cases

Cas 1 — Sélection de fonction incorrecte. Un étudiant a demandé à l’IA du code pour trouver la racine d’une fonction. L'IA a utilisé scipy.optimize.fsolve, mais a choisi une mauvaise estimation initiale et a convergé vers la mauvaise racine. L’élève a d’abord examiné la fonction en la représentant graphiquement (voir l’unité de visualisation), a donné la bonne hypothèse initiale et a trouvé la vraie racine. Leçon : les chercheurs de racines numériques sont sensibles au point de départ.

Cas 2 — Piège à virgule flottante. Un ingénieur a exécuté un code d'IA qui écrivait si 0,1 + 0,2 == 0,3 : et s'est rendu compte que la condition n'était jamais vraie. L’IA avait ignoré la précision en virgule flottante. Le code a été corrigé avec abs((0.1+0.2) - 0.3) < 1e-9. 1e-9 signifie « dix puissance moins neuf », une très petite tolérance.

Cas 3 — Les tests de bon sens ont détecté le bug. Un enseignant a reçu du code de scipy.integrate.quad qui calcule numériquement une intégrale définie. Il l'a d'abord testé avec une intégrale connue telle que ∫₀¹ x dx = 0,5 ; le code donnait 0,5. Ensuite, il a calculé l'intégrale réelle et a confirmé le résultat avec SymPy. Il faisait confiance lorsque deux méthodes indépendantes donnaient le même résultat. Durée totale : 6 minutes.

Quatre modèles copiables

1) Demander un code de compte numérique :

Écrivez du code Python qui résout NUMÉRIQUEMENT le problème suivant : [problème]. Utilisez NumPy/SciPy. Sensibilité : [par ex. 6 décimal]. Je vais exécuter le code ; prédire la sortie. Expliquez brièvement dans une ligne de commentaire quelle fonction vous avez choisie et pourquoi.

2) Ajout d'un test de bon sens :

Ajoutez une vérification de bon sens à ce code pour tester son EXACTITUDE avant de l'exécuter : essayez-le avec une entrée simple où la réponse est déjà connue (par exemple racine ±2 pour x²-4=0) et vérifiez qu'il donne le résultat attendu.Code : [ici]

3) Recoupement symbolique-numérique :

Écrivez du code qui résout l'intégrale/l'équation suivante avec À LA FOIS SymPy (symbolique) ET SciPy (numérique) : [problème]. Imprimez les deux résultats pour que je puisse les comparer. Ajoutez une ligne qui vérifie les différences avec abs().

4) Sécurité en virgule flottante :

Passez en revue les comparaisons de nombres à virgule flottante dans ce code. S'il existe des égalités strictes '==', remplacez-les par une tolérance appropriée (abs(a-b) < 1e-9) et expliquez pourquoi. Code : [ici]

Invite faible/Invite forte

Faible : "Trouvez la racine de cette équation : x³ − 2x − 5 = 0. Écrivez la réponse."

Résultat : L'IA correspond à un nombre décimal (par exemple "2,0946..."). Cela peut être vrai ou non ; Il n'a pas été vérifié car il n'a pas été exécuté.

Puissant : "Écrivez un code qui trouve la racine réelle de l'équation x³ − 2x − 5 = 0 avec SciPy. Pour la supposition initiale, spécifiez d'abord l'intervalle où la fonction change de signe. Ajoutez une ligne qui remplace la racine et vérifie que le résultat est ~ 0. Je verrai le résultat. "

Résultat : code exécutable, estimation initiale précise, hachages intégrés. La validité de la racine est prouvée.

Erreurs courantes

• Faire confiance au résultat sans exécuter le code. La sortie numérique que l’IA « prédit » n’est pas une validation.
• Test de l'égalité en virgule flottante avec `==`. C'est presque toujours faux ; Faites preuve de tolérance.
• Mauvaise prévision initiale. Les méthodes de racine numérique/optimisation sont sensibles au point de départ ; Il se peut qu’elle converge vers la mauvaise racine.
• Ne pas exprimer de sensibilité. "Combien de pas?" Si cette question n'est pas posée, le résultat risque de ne pas répondre aux besoins.
• Ne pas passer un test de bon sens. Appliquer du code à un problème réel sans le tester avec une entrée connue est risqué.
• Exécuter le code sans le comprendre. Le code que vous ne comprenez pas utilise peut-être la mauvaise fonction ; comprendre chaque ligne.

Attention : les résultats numériques sont toujours approximatifs. Au lieu de dire « le résultat est exactement ceci », dites « c’est exactement cela ». Dans un rapport technique ou scientifique, indiquer la méthode et la précision utilisées fait partie de l’exactitude. Il est trompeur de présenter un résultat approximatif comme définitif.

En résumé

Le calcul numérique donne des résultats approximatifs mais pratiques pour des problèmes qui ne peuvent être résolus par une formule fermée ; En Python, ses outils sont NumPy et SciPy. L'IA génère rapidement du code pour ces bibliothèques, mais vous devez exécuter le code, le lire et le comprendre, et le tester avec une entrée connue. Soyez prudent avec la précision en virgule flottante : utilisez la tolérance plutôt que l'égalité exacte. Si possible, vérifiez les méthodes symboliques et numériques. Les tests de bon sens et la substitution sont les vérifications les moins chères et les plus efficaces.

Tâche de candidature

Choisissez un problème difficile à résoudre avec une formule fermée (par exemple, la racine x³ − 2x − 5 = 0, ou la valeur définie d'une intégrale non élémentaire). Demandez à l'IA d'imprimer à la fois le code numérique et, si possible, le code de recoupement symbolique-numérique avec les modèles 1 et 3. Exécutez le code dans un véritable environnement Python. Faites d’abord un test de bon sens avec une entrée connue, puis résolvez le problème réel. Assurez-vous d'utiliser des tolérances s'il existe une comparaison à virgule flottante. Notez le résultat ainsi que sa sensibilité.

liste de contrôle

• [ ] J'ai identifié le problème et la sensibilité requise.
• [ ] J'ai lu et compris le code produit par l'IA ligne par ligne.
• [ ] J'ai exécuté le code dans un véritable environnement Python.
• [ ] J'ai fait un test de bon sens avec une entrée connue.
• [ ] J'ai ajouté une vérification croisée symbolique/manuelle si possible.
• [ ] J'ai utilisé la tolérance dans les comparaisons à virgule flottante.