Cos'è la convergenza, in generale
Il concetto di convergenza è un termine matematico ben definito. Significa essenzialmente che "eventualmente" una sequenza di elementi si avvicina sempre di più a un singolo valore. Chiamiamo questo valore singolo "limite".
La definizione formale va in questo modo:
Data la sequenza (infinita) di numeri reali X0, X1, X2, ... Xn ...diciamo Xn converges to a given number Lse per ogni errore positivo che pensi, esiste un Xmtale che ogni elemento Xnche viene dopo Xmdifferisce Lda meno di quell'errore.
Esempio:
Immagina una sequenza come tale:
- X0 = 1
- X1 = 0.1
- X2 = 0,01
- X3 = 0,001
- X4 = 0,0001
- ...
- Xn = 1 / (10 ^ n)
Xn converge a zero? Sì! Perché?
Pensa a un errore E (ad esempio E = 0.0025). C'è un elemento nella sequenza che dopo che ogni elemento è sotto 0.025? Sì! Quell'elemento è X3 = 0.001. Dopo X2, tutto XNè sotto 0.0025. Questo può essere fatto per ogni E> 0? Sì. Per ogni errore positivo che scegliamo, possiamo vedere quanti zeri ha prima del suo primo punto decimale e la sequenza sarà inferiore a partire dall'elemento che ha lo stesso numero di zeri.
Questo significa che Xn = 1/(10^5) converges to 0. Come in "può avvicinarsi sempre di più a zero" quanto vogliamo.
Cosa significa convergere un algoritmo?
"Tecnicamente" ciò che converge non è l'algoritmo, ma un valore che l'algoritmo sta manipolando o iterando. Ad esempio, supponiamo che stiamo scrivendo un algoritmo che stampa tutte le cifre di PI.
L'algoritmo inizia a stampare numeri come:
- X0 = 3.14
- X1 = 3.141
- X2 = 3.1415
- X3 = 3.14159
- ...
Potremmo chiederci: l'algoritmo stampa numeri sempre più vicini a PI? In altre parole, la sequenza X0, X1, ... XN ...stampata dal nostro algoritmo converge in PI?
In tal caso, diciamo che il nostro algoritmo converge in PI.
Di solito siamo interessati a dimostrare la correttezza di un algoritmo.
Di solito, quando scriviamo un algoritmo, siamo interessati a sapere se la soluzione fornita dall'algoritmo è quella corretta per il problema che risolve. Questo a volte può presentarsi sotto forma di convergenza.
In generale, gli algoritmi hanno ciò che chiamiamo metriche . Una metrica è un numero che diamo a un dato risultato che l'algoritmo produce. Ad esempio, negli algoritmi iterativi di AI / Machine Learning è molto comune per noi tenere traccia dell'errore che l'algoritmo sta generando in base all'input. Questo errore è una metrica.
In quegli algoritmi iterativi, ogni passaggio genera un errore diverso. E ciò che l'algoritmo tenta di fare è minimizzare quell'errore in modo che diventi sempre più piccolo. Diciamo che l'algoritmo converge se converge la sequenza di errori.
In questi casi, di global optimumsolito viene definito il programma di installazione con l'errore più basso possibile. In tal caso, "l'algoritmo converge all'ottimale globale" significa che "l'algoritmo genera errori in una sequenza che converge all'errore più basso possibile".
Se "l'ottimale globale" è la nostra "soluzione corretta", affermare che il nostro algoritmo converge equivale a dichiarare che il nostro algoritmo è corretto.
Inoltre, tieni presente che affermare che un algoritmo converge richiede una prova (come abbiamo fatto per il nostro esempio 0,001, 0,0001, ...).
Ad esempio, un classificatore
Un esempio di ciò potrebbe essere nel caso di un classificatore. Supponiamo di voler classificare se i numeri sono dispari o addirittura utilizzando un algoritmo di apprendimento automatico e che disponiamo del seguente set di dati:
- (1, dispari)
- (2, anche)
- (3, dispari)
- (77, dispari)
- (4, anche)
Il nostro algoritmo per ogni serie di numeri sputa per ciascuno di essi se sono pari o dispari. Per questo, possiamo definire un errore metrico come il numero di volte in cui è stato sbagliato diviso per il numero totale di elementi che sono stati dati.
Quindi, se il nostro algoritmo sputa quanto segue:
- (1, pari) // sbagliato
- (2, anche)
- (3, anche) // sbagliato
- (77, anche) // sbagliato
- (4, anche)
La nostra metrica di errore sarebbe 3/5 = 0.6. Ora diciamo che eseguiamo di nuovo l'algoritmo e ora sputa:
- (1, pari) // sbagliato
- (2, anche)
- (3, dispari)
- (77, dispari)
- (4, anche)
La nostra metrica di errore sarebbe 1/5 = 0.2.
Diciamo che funziona sempre più volte e la nostra sequenza di errori è simile a questa:
0.6, 0.2, 0.1, 0.01, 0.000456, 0.00000543, 0.000000000444 ....
Quindi la grande domanda è: il nostro algoritmo sarà mai zero? Converrà mai a zero? Il nostro algoritmo converge tutti? Possiamo dimostrare che alla fine riuscirà a farlo bene (o il più vicino possibile a destra)?
Speriamo di sì :)