O que é convergência, em geral
O conceito de convergência é um termo matemático bem definido. Significa essencialmente que "eventualmente" uma sequência de elementos se aproxima cada vez mais de um único valor. Chamamos esse valor único de "limite".
A definição formal é mais ou menos assim:
Dada (infinita) sequência de números reais X0, X1, X2, ... Xn ...
, dizemos Xn converges to a given number L
que, para cada erro positivo que você pensa, existe um Xm
tal que todo elemento Xn
que vem depois Xm
difere de L
menos que esse erro.
Exemplo:
Imagine uma sequência como tal:
- X0 = 1
- X1 = 0,1
- X2 = 0,01
- X3 = 0,001
- X4 = 0,0001
- ...
- Xn = 1 / (10 ^ n)
Xn converge para zero? Sim! Por quê?
Pense em um erro E (por exemplo E = 0.0025
). Existe um elemento na sequência que depois disso todos os elementos estão abaixo 0.025
? Sim! Esse elemento é X3 = 0.001
. Após o X2, todos XN
estão abaixo 0.0025
. Isso pode ser feito para todos os E> 0? Sim. Para cada erro positivo que escolhemos, podemos ver quantos zeros ela possui antes de seu primeiro ponto decimal e a sequência será menor que a partir do elemento que possui o mesmo número de zeros.
Isso significa isso Xn = 1/(10^5) converges to 0
. Como em "ele pode chegar cada vez mais perto de zero", tanto quanto queremos.
O que significa para um algoritmo convergir?
"Tecnicamente" o que converge não é o algoritmo, mas um valor que o algoritmo está manipulando ou iterando. Por exemplo, digamos que estamos escrevendo um algoritmo que imprime todos os dígitos do PI.
O algoritmo começa a imprimir números como:
- X0 = 3,14
- X1 = 3,141
- X2 = 3,1415
- X3 = 3,14159
- ...
Poderíamos nos perguntar: o algoritmo imprime números cada vez mais próximos do PI? Em outras palavras, a sequência X0, X1, ... XN ...
impressa pelo algoritmo converge para o PI?
Nesse caso, dizemos que nosso algoritmo converge para PI.
Normalmente, estamos interessados em provar a correção de um algoritmo.
Normalmente, quando escrevemos um algoritmo, estamos interessados em saber se a solução que o algoritmo fornece é a correta para o problema que ele resolve. Às vezes, isso pode vir na forma de uma convergência.
Em geral, os algoritmos têm o que chamamos de métricas . Uma métrica é um número que damos a um determinado resultado que o algoritmo produz. Por exemplo, nos algoritmos iterativos de IA / Machine Learning, é muito comum acompanharmos o "erro" que o algoritmo está gerando com base na entrada. Este erro é uma métrica.
Nesses algoritmos iterativos, cada etapa gera um erro diferente. E o que o algoritmo tenta fazer é minimizar esse erro para que fique cada vez menor. Dizemos que o algoritmo converge se a sequência de erros converge.
Nesses casos, global optimum
geralmente é definido como a configuração que possui o menor erro possível. Nesse caso, o "algoritmo converge para o ideal global" significa que "o algoritmo gera erros em uma sequência que converge para o menor erro possível".
Se o "ideal global" for nossa "solução correta", declarar que nosso algoritmo converge é o mesmo que afirmar que nosso algoritmo está correto.
Além disso, lembre-se de que declarar que um algoritmo converge exige uma prova (como fizemos no nosso exemplo de 0,001, 0,0001, ...).
Como exemplo, um classificador
Um exemplo disso pode ser no caso de um classificador. Suponha que desejemos classificar se os números são ímpares ou pares usando um algoritmo de aprendizado de máquina e se temos o seguinte conjunto de dados:
- (1, ímpar)
- (2, par)
- (3, ímpar)
- (77, ímpar)
- (4, par)
Nosso algoritmo para cada conjunto de números cospe para cada um deles, se eles são pares ou ímpares. Para isso, podemos definir um erro de métrica como o número de vezes que ele errou dividido pelo número total de elementos que foram fornecidos.
Portanto, se nosso algoritmo cuspir o seguinte:
- (1, par) // errado
- (2, par)
- (3, par) // errado
- (77, par) // errado
- (4, par)
Nossa métrica de erro seria 3/5 = 0.6
. Agora, digamos que executemos o algoritmo novamente e agora cospe:
- (1, par) // errado
- (2, par)
- (3, ímpar)
- (77, ímpar)
- (4, par)
Nossa métrica de erro seria 1/5 = 0.2
.
Digamos que ele seja executado mais e mais vezes, e nossa sequência de erros se parece com isso:
0.6, 0.2, 0.1, 0.01, 0.000456, 0.00000543, 0.000000000444 ....
Portanto, a grande questão é: nosso algoritmo será zero? Irá alguma vez convergir para zero? Todo o nosso algoritmo convergirá? Podemos provar que, eventualmente, ele vai acertar (ou o mais próximo possível)?
Espero que sim :)