Matrice hessiana: una guida alle derivate di secondo ordine nell’ottimizzazione e oltre

Quando parliamo di ottimizzazione, addestramento dei modelli o comprensione della curvatura di una superficie di perdita, di solito pensiamo alle funzioni di costo e ai gradienti. Mentre la funzione di costo spiega quanto bene si comporta il modello, il gradiente, che è la sua derivata prima, indica la direzione di variazione più ripida per ridurre la perdita. Tuttavia, i gradienti ci dicono solo la pendenza e non come cambia essa stessa.

Ed è qui che entra in gioco la spesso trascurata matrice hessiana. È una matrice quadrata di derivate parziali seconde di una funzione scalare che cattura come evolve il gradiente, rivelando la curvatura della superficie di perdita. In data science, diventa importante in compiti che coinvolgono algoritmi di ottimizzazione avanzati, diagnostica dei modelli, nonché per valutare la stabilità e la convergenza dei modelli di machine learning.

La matrice hessiana generalizza il concetto di derivata seconda dalle funzioni a variabile singola ai contesti multivariati. Codifica informazioni sulla curvatura locale di una funzione per quantificare come la funzione si piega o curva vicino a un punto dato. Aiuta ad analizzare i punti critici, come minimi, massimi e punti di sella, e guida tecniche di ottimizzazione numerica avanzate.

L’obiettivo di questo articolo è comprendere la matrice hessiana, che aiuta a capire come si comportano gli algoritmi di ottimizzazione e quanto velocemente convergono. È particolarmente utile quando si lavora con modelli complessi che coinvolgono molte variabili. Per chi ha familiarità con i vettori gradiente e le matrici jacobiane, l’Hessiana è il passo successivo. Ti dice come si comportano le funzioni in spazi ad alta dimensionalità.

Che cos’è la matrice hessiana?

Osserva questa equazione s come funzione scalare due volte derivabile:

Significa che questa funzione è due volte derivabile e restituisce un unico numero. La matrice hessiana di f, indicata con H_f(x), è una matrice quadrata n x n che contiene tutte le derivate parziali seconde di f.

Formalmente, ogni elemento della matrice hessiana è definito come:

Questo significa che l’Hessiana ci dice come cambia il gradiente (derivata prima) di una funzione rispetto a ciascuna variabile di input.

Se tutte le derivate parziali seconde di f sono continue in un intorno di un punto, il teorema di Clairaut (chiamato anche teorema di Schwarz) ci dice che le derivate parziali miste sono uguali, cioè l’ordine di derivazione non importa:

Questa proprietà di simmetria implica che, in tali casi, la matrice hessiana è simmetrica.

È importante notare che la matrice hessiana è definita solo per funzioni scalari, ossia, funzioni che restituiscono un unico numero. Quando si trattano funzioni a valori vettoriali, come segue:

allora il concetto di derivata seconda si estende a un tensore di terzo ordine anziché a una matrice. Questo tensore cattura come ogni componente di output di F cambia rispetto a ciascuna coppia di input.

Sia Rⁿ -> R una funzione scalare due volte derivabile. La matrice hessiana di f è la matrice n x n definita come:

Ogni elemento H_ij è la derivata parziale seconda:

Esempio di matrice hessiana

Considera la funzione:

Derivate parziali di primo ordine:

Derivate parziali di secondo ordine:

Matrice hessiana

Valutata in (x,y) = (1,1)

Discriminante

Un discriminante negativo implica che il punto critico è un punto di sella. Dai un’occhiata alla tecnica del punto di sella nel nostro corso, Introduction to Optimization in Python, per imparare le applicazioni pratiche dell’Hessiana.

Ecco lo stesso esempio implementato in 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)

Questo codice usa la differenziazione simbolica per calcolare la matrice hessiana e valutarla in un punto specifico. Strumenti come SymPy fungono da pratico "calcolatore della matrice hessiana" sia per scopi didattici sia per la ricerca applicata.

Discriminante e test della derivata seconda

Il test della derivata seconda in più dimensioni classifica i punti critici usando la matrice hessiana:

Sia X₀ un punto critico per cui questo è vero.

Sia l’Hessiana

L’interpretazione dipende dalla definitezza dell’Hessiana:

• Definita positiva (tutti gli autovalori > 0): X₀ è un minimo locale.
• Definita negativa (tutti gli autovalori < 0): X₀ è un massimo locale.
• Indefinita (autovalori di segno misto): X₀ è un punto di sella.
• Singolare (determinante zero): Il test è inconcludente.

Capciamolo con esempi di questi quattro casi:

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()

Nel grafico a contorni sopra, l’altezza aumenta dal “Blu” (più basso) al “Rosso” (più alto).

Questo test è un’estensione del test della derivata seconda per le funzioni a variabile singola ed è trattato insieme a temi come le serie di Taylor e l’ottimizzazione convessa.

La matrice hessiana nell’ottimizzazione

La matrice hessiana emerge naturalmente nello sviluppo di Taylor al secondo ordine di una funzione scalare:

Questa approssimazione quadratica consente ai metodi di tipo Newton di trovare efficacemente i punti critici. Il metodo di Newton aggiorna le variabili secondo:

In contesti ad alta dimensionalità, calcolare e memorizzare l’Hessiana completa può essere costoso in termini computazionali. Per questo motivo, metodi quasi-Newton come BFGS e L-BFGS approssimano iterativamente l’Hessiana usando differenze di gradienti.

Inoltre, il prodotto Hessiana-vettore H_v può essere approssimato senza calcolare l’intera matrice usando differenze finite:

Questa approssimazione è particolarmente utile nei framework di deep learning che sfruttano la differenziazione automatica.

Applicazioni nel machine learning e nella data science

Nel machine learning, la matrice hessiana fornisce informazioni sulla curvatura del paesaggio di perdita:

• Nelle reti neurali, analizzare l’Hessiana può rivelare la presenza di punti di sella e regioni piatte.
• Nei problemi di ottimizzazione convessa, l’Hessiana aiuta a verificare la convessità e a guidare i risolutori di secondo ordine.
• Nel fine-tuning dei modelli, la conoscenza dell’Hessiana aiuta ad adattare i tassi di apprendimento in base alla curvatura locale.

Oltre all’ottimizzazione, l’Hessiana è usata in:

• Diagnostica statistica (ad es., matrice di informazione di Fisher nella massima verosimiglianza).
• Computer vision, come il rilevatore DoH (Determinant of Hessian) per l’individuazione di feature.
• Dinamica molecolare, in particolare nell’analisi dei modi normali per gli spettri vibrazionali.

Comprendere l’Hessiana permette ai professionisti di andare oltre il gradient descent e applicare algoritmi più sofisticati come BFGS, usati in corsi come Machine Learning Fundamentals in Python. Queste tecniche si basano su argomenti di analisi avanzata come le serie di Taylor e l’algebra delle matrici.

Conclusione

La matrice hessiana racchiude informazioni di secondo ordine sulle funzioni scalari e fornisce un quadro ricco per analizzare la curvatura, identificare i punti critici e risolvere problemi di ottimizzazione. Mentre i gradienti guidano la direzione, l’Hessiana affina la comprensione di forma e “acutezza”, soprattutto nei problemi ad alta dimensionalità comuni nel machine learning.

Per chi ha già dimestichezza con Jacobiani e gradienti, padroneggiare l’Hessiana offre una visione più completa del comportamento degli algoritmi e della struttura dei problemi.