Matrice hessienne : Guide des dérivés du second ordre dans l'optimisation et au-delà

Lorsque l'on parle d'optimisation, d'apprentissage de modèles ou de compréhension de la courbure d'une surface de perte, les fonctions de coût et les gradients viennent généralement à l'esprit. Alors que la fonction de coût explique les performances de notre modèle, le gradient, qui est sa dérivée première, indique la direction de la variation la plus forte pour réduire la perte. Mais les gradients ne nous indiquent que la pente et non la façon dont cette pente elle-même change.

C'est ici que la matrice hessienne, souvent négligée, prend toute son importance. Il s'agit d'une matrice carrée de dérivées partielles du second ordre d'une fonction à valeur scalaire qui rend compte de l'évolution du gradient, révélant la courbure de la surface de perte. En science des données, elle devient importante dans les tâches impliquant des algorithmes d'optimisation avancés, des diagnostics de modèles, ainsi que pour évaluer la stabilité et la convergence des modèles d'apprentissage automatique.

La matrice hessienne généralise le concept de dérivée seconde des fonctions à une seule variable à des contextes multivariables. Il encode des informations sur la courbure locale d'une fonction afin de quantifier la façon dont la fonction se courbe ou s'incurve près d'un point donné. Il aide à analyser les points critiques, tels que les minima, les maxima et les points de selle, et guide les techniques d'optimisation numérique avancées.

L'objectif de cet article est de comprendre la matrice hessienne qui aide à déterminer le comportement des algorithmes d'optimisation et leur vitesse de convergence. Il est particulièrement utile lorsqu'il s'agit de modèles complexes impliquant de nombreuses variables. Pour ceux qui sont familiers avec les vecteurs de gradient et les matrices jacobiennes, le hessien est l'étape suivante. Il vous indique comment les fonctions se comportent dans un espace à haute dimension.

Qu'est-ce que la matrice hessienne ?

Considérez cette équation commeune fonction scalaire deux fois différentiable :

Cela signifie que cette fonction peut être différenciée deux fois et qu'elle renvoie un nombre uniquele. La matrice hessienne de f, appelée _Hf(x), est unematrice carrée de n x n qui contient toutes les dérivées partielles du second ordre de f.

Formellement, chaque élément de la matrice hessienne est défini comme suit :

Cela signifie que le Hessien nous indique comment le gradient (dérivée première) d'une fonction évolue en fonction de chaque variable d'entrée.

Si toutes les dérivées partielles secondes de f sont continues dans un certain voisinage autour d'un point, le théorème de Clairaut (également appelé théorème de Schwarz) nous indique que les dérivées partielles mixtes sont égales, c'est-à-dire que l'ordre de différenciation n'a pas d'importance :

Cette propriété de symétrie signifie que la matrice hessienne est symétrique dans de tels cas.

Il est important de noter que la matrice hessienne n'est définie que pour les fonctions à valeur scalaire, c'est-à-dire les fonctions qui renvoient un seul nombre. Lorsqu'il s'agit de fonctions à valeurs vectorielles, procédez de la manière suivante :

le concept de dérivée seconde s'étend alors à une tensor du troisième ordre plutôt qu'à une matrice. Ce tenseur reflète la manière dont chaque composante de sortie de F change avec chaque paire d'entrées.

Soit ^Rn -> R une fonction à valeur scalaire deux fois différentiable. La matrice hessienne de f est la matrice n x n définie comme suit :

Chaque élément _Hij est la dérivée partielle seconde :

Exemple de matrice hessienne

Considérez la fonction :

Dérivées partielles du premier ordre :

Dérivées partielles du second ordre :

Matrice hessienne

Évaluer à (x,y) = (1,1)

Discriminant

Un discriminant négatif implique que le point critique est un point de selle. Consultez la technique du point de selle dans notre course, Introduction à l'optimisation en Python, pour apprendre les applications pratiques de la hessienne.

Voici le même exemple mis en œuvre en Python :

import sympy as sp

x, y = sp.symbols('x y')
f = x**3 - 2*x*y - y**6

# Compute gradient
grad_f = [sp.diff(f, var) for var in (x, y)]

# Compute Hessian
hessian_f = sp.hessian(f, (x, y))

# Evaluate at point (1,1)
eval_hessian = hessian_f.subs({x: 1, y: 1})
determinant = eval_hessian.det()

print("Gradient:")
sp.pprint(grad_f)
print("")
print("Hessian matrix:")
sp.pprint(hessian_f)
print("")
print("Hessian at (1,1):")
sp.pprint(eval_hessian)
print("")
print("Discriminant:", determinant)

Ce code utilise la différenciation symbolique pour calculer la matrice hessienne et l'évaluer en un point spécifique. Des outils tels que SymPy servent de "calculateur de matrice hessienne" pratique à des fins éducatives et de recherche appliquée.

Test discriminant et test de la deuxième dérivée

Le test de la dérivée seconde en plusieurs dimensions permet de classer les points critiques à l'aide de la matrice hessienne :

Soit _X0 un point critique où celaest vrai.

Soit le Hessien

L'interprétation dépend de la définition du hessien :

• défini positivement (toutes les valeurs propres > 0) : _X0 est un minimum local.
• Défini négatif (toutes les valeurs propres < 0) : _X0 est un maximum local.
• indéfini (valeurs propres de signe mixte) : _X0 est un point de selle.
• Singulier (déterminant nul) : Le test est et n'est pas concluant.

Comprenons-le à l'aide d'exemples de ces quatre cas :

import numpy as np
import matplotlib.pyplot as plt
from sympy import symbols, diff, hessian, lambdify

# Define symbols
x, y = symbols('x y')

# List of 4 functions for different discriminant cases
functions = [
    ("x**2 + y**2", "Positive definite (local minimum)"),
    ("-x**2 - y**2", "Negative definite (local maximum)"),
    ("x**2 - y**2", "Indefinite (saddle point)"),
    ("x**4 + y**4", "Zero determinant (inconclusive)")
]

# Prepare plots
fig, axes = plt.subplots(2, 2, figsize=(12, 10))
axes = axes.ravel()

for i, (func_str, title) in enumerate(functions):
    f = eval(func_str)
    
    # Compute gradients and Hessian
    fx = diff(f, x)
    fy = diff(f, y)
    H = hessian(f, (x, y))
    
    # Evaluate Hessian at (0,0) (critical point for all these functions)
    H0 = H.subs({x: 0, y: 0})
    det_H0 = H0.det()
    fxx0 = H0[0, 0]
    
    # Classification
    if det_H0 > 0 and fxx0 > 0:
        classification = "Local Minimum"
    elif det_H0 > 0 and fxx0 < 0:
        classification = "Local Maximum"
    elif det_H0 < 0:
        classification = "Saddle Point"
    else:
        classification = "Inconclusive"

    # Prepare function for plotting
    f_lamb = lambdify((x, y), f, 'numpy')
    X, Y = np.meshgrid(np.linspace(-2, 2, 100), np.linspace(-2, 2, 100))
    Z = f_lamb(X, Y)

    # Plot
    ax = axes[i]
    cp = ax.contourf(X, Y, Z, levels=50, cmap='coolwarm')
    ax.set_title(f"{title}\n{func_str}\nDet(H)={det_H0}, fxx={fxx0} → {classification}")
    ax.plot(0, 0, 'ko')  # critical point
    fig.colorbar(cp, ax=ax)

plt.tight_layout()
plt.show()

Dans le graphique ci-dessus, la hauteur augmente de "Bleu", le niveau le plus bas, à "Rouge", le niveau le plus élevé.

Ce test est une extension du test de la dérivée seconde pour les fonctions à une seule variable et est abordé en même temps que des sujets tels que les séries de Taylor et l'optimisation convexe.

La matrice hessienne dans l'optimisation

La matrice hessienne apparaît naturellement dans l'expansion de Taylor du second ordre d'une fonction scalaire :

Cette approximation quadratique permet aux méthodes de type Newton de trouver efficacement les points critiques. La méthode de Newton met à jour les variables en fonction de :

Dans les environnements à haute dimension, le calcul et le stockage du hessien complet peuvent être coûteux en termes de calcul. C'est pourquoi les méthodes de quasi-Newton, telles que BFGS et L-BFGS, approximent le hessien de manière itérative en utilisant des différences de gradient.

En outre, le produit vectoriel hessien _Hv peut être approximé sans calculer la matrice complète à l'aide de différences finies :

Cette approximation est particulièrement utile dans les cadres d'apprentissage profond qui exploitent la différenciation automatique.

Applications dans le domaine de l'apprentissage automatique et de la science des données

Dans le domaine de l'apprentissage automatique, la matrice hessienne donne une idée de la courbure du paysage des pertes :

• Dans les réseaux neuronaux, l'analyse de la hessienne peut révéler la présence de points de selle et de régions plates.
• Dans les problèmes d'optimisation convexe, la hessienne permet de vérifier la convexité et de guider les solveurs du second ordre.
• Dans les modèles de réglage fin, la connaissance de la hessienne permet d'adapter les taux d'apprentissage en fonction de la courbure locale.

Au-delà de l'optimisation, le hessien est utilisé dans :

• Diagnostics statistiques (par exemple, matrice d'information de Fisher dans l'estimation du maximum de vraisemblance).
• La vision par ordinateur, telle que le détecteur de blob du déterminant de la hessienne (DoH), est utilisée pour la détection des caractéristiques.
• Dynamique moléculaire, en particulier l'analyse des modes normaux pour les spectres vibrationnels.

Comprendre le hessien permet aux praticiens d'aller au-delà de la descente de gradient et d'appliquer des algorithmes plus sophistiqués comme le BFGS, utilisé dans des cours tels que Machine Learning Fundamentals in Python. Ces techniques dépendent de sujets de calcul avancés tels que les séries de Taylor et l'algèbre matricielle.

Conclusion

La matrice hessienne contient des informations de second ordre sur les fonctions à valeurs scalaires et fournit un cadre riche pour l'analyse de la courbure, l'identification des points critiques et la résolution des problèmes d'optimisation. Alors que les gradients guident la direction, la hessienne affine la compréhension de la forme et de la netteté, en particulier dans les problèmes à haute dimension courants dans l'apprentissage automatique.

Pour les praticiens déjà à l'aise avec les jacobiens et les gradients, la maîtrise de la hessienne offre une vision plus complète du comportement des algorithmes et de la structure des problèmes.