6.17. Solveurs et nombres aléatoires

Lorsque la fonction étudiée est définie par du code Python plutôt que par un tampon d’échantillons, une autre famille d’outils est le bon choix : où se trouve la racine de la fonction, son minimum, son intégrale sur un intervalle donné ? Les sous-modules scipy.integrate et scipy.optimize couvrent ce travail. Chaque algorithme rappelle la fonction Python fournie par l’utilisateur, de sorte que le coût par itération est plus élevé qu’une réduction sur tampon ; la commodité réside dans le fait de ne pas avoir à écrire le solveur.

Le sous-module scipy.special couvre les fonctions spéciales statistiques (fonction d’erreur, gamma) qui interviennent lors du calcul de la fonction de répartition (CDF, la probabilité qu’un échantillon soit au plus égal à une valeur donnée) ou de la fonction de densité de probabilité (PDF, la vraisemblance relative à une valeur donnée) d’une distribution de probabilité. numpy.random couvre le générateur pseudo-aléatoire pour le tramage, la simulation et les données de test synthétiques.

6.17.1. Intégration numérique d’une fonction appelable

Lorsque l’intégrande est une fonction Python plutôt qu’un tampon d’échantillons, scipy.integrate expose quatre algorithmes de quadrature :

• quad() – Gauss-Kronrod adaptatif. Le bon choix par défaut pour les intégrandes lisses. Renvoie (value, error).

• romberg() – Romberg / Newton-Cotes classique. Renvoie un unique flottant. Déprécié en amont ; inclus pour compatibilité.

• simpson() – règle de Simpson adaptative. Renvoie un unique flottant.

• tanhsinh() – quadrature double-exponentielle. À utiliser lorsque l’intégrande présente des singularités aux bornes ou une limite infinie. Renvoie (value, error).

L’intégrale gaussienne évaluée avec la règle double-exponentielle (tanhsinh)

from math import exp
from math import pi
from math import sqrt
from ulab import numpy as np
from ulab import scipy as sp

f = lambda x: exp(-x * x)
value, err = sp.integrate.tanhsinh(f, -np.inf, np.inf)
print("approx:", value, "   exact:", sqrt(pi))

Sortie

approx: 1.7724538...   exact: 1.7724538...

6.17.2. Recherche de racine et minimisation

scipy.optimize couvre trois solveurs classiques à une seule variable. Chaque itération rappelle la fonction Python fournie par l’utilisateur, de sorte que le gain de vitesse par rapport à un solveur en Python pur est modeste (environ 2x) ; la commodité réside dans le fait de ne pas avoir à écrire le solveur.

• bisect() – trouve une racine de f sur [a, b] en divisant l’intervalle par deux. f(a) et f(b) doivent avoir des signes opposés

  def f(x):
      return x * x - 1
  
  sp.optimize.bisect(f, 0, 4)        # ~1.0
  

• newton() – trouve une racine par itération de la sécante / Newton-Raphson

  def f(x):
      return x * x * x - 2.0
  
  sp.optimize.newton(f, 3., tol=0.001, rtol=0.01)
  # ~1.260
  

• fmin() – trouve un minimum local par la méthode du simplexe descendant (Nelder-Mead)

  def f(x):
      return (x - 1) ** 2 - 1
  
  sp.optimize.fmin(f, 3.0)           # ~1.0
  

La portée à une seule variable suffit pour la plupart des optimisations côté caméra – une constante de calibration d’un capteur, le gain qui maximise une mesure de contraste, le seuil où la bimodalité d’un histogramme est la plus marquée. Pour les problèmes à plusieurs variables, la bonne réponse consiste généralement à reformuler le problème comme une petite résolution d’algèbre linéaire plutôt que de recourir à un optimiseur non linéaire général.

6.17.3. Fonctions spéciales

scipy.special expose une poignée de fonctions statistiques et de probabilité qui se comportent comme des fonctions universelles – elles acceptent un scalaire, un itérable ou un ndarray et renvoient un ndarray de flottants

x = np.linspace(0, 4, num=8)

sp.special.erf(x)         # error function
sp.special.erfc(x)        # complementary error function
sp.special.gamma(x + 1)   # gamma function
sp.special.gammaln(x + 1) # log-gamma function

La fonction d’erreur et son complément apparaissent dans la CDF d’une gaussienne – l’application de prédilection pour convertir entre un score z mesuré et une probabilité, ou pour calculer l’intégrale de queue d’une distribution normale. Les fonctions gamma et log-gamma apparaissent dans les calculs bêta / khi-deux / student-t ; gammaln est la forme numériquement stable pour les grands arguments où gamma lui-même déborderait.

6.17.4. Nombres aléatoires

numpy.random fournit une classe Generator qui tire des échantillons de distributions courantes. Le générateur est à état : chaque appel fait avancer son état interne, de sorte que des appels consécutifs renvoient des échantillons indépendants

from ulab import numpy as np

rng = np.random.Generator(seed=42)

rng.random(size=5)             # 5 uniform [0.0, 1.0) samples
rng.uniform(low=-1.0, high=1.0, size=10)
rng.normal(loc=0.0, scale=1.0, size=(2, 4))

Le dtype de sortie est toujours float. size= accepte un entier (sortie à une dimension) ou un uplet (sortie à n dimensions) ; lorsqu’il est omis, un unique flottant Python est renvoyé.

Le générateur convient à la simulation, au tramage, aux données de test synthétiques et à toute autre application où une robustesse cryptographique n’est pas requise. Il n’est pas adapté aux clés ou aux jetons ; utilisez pour cela la source aléatoire du système via os.

6.17.5. Disponibilité à la compilation

La présence effective de chaque sous-module dépend de la façon dont la caméra a été compilée. scipy.optimize et scipy.special ne sont pas activés sur toutes les caméras ; appeler une fonction que la caméra n’inclut pas lève AttributeError. dir(sp), dir(sp.optimize), dir(np.random) et consorts indiquent ce qui est disponible sur la caméra ciblée.