Rede neural na prática: Função de reta

Introdução

Olá pessoal, e sejam bem-vindos a mais um artigo sobre Rede Neural.

No artigo anterior Rede neural na prática: Mínimos Quadrados, vimos como poderíamos, em casos muito, mas muito simples mesmo. Conseguir encontrar a equação que melhor descreve o conjunto de dados, que temos para utilizar. A equação gerada naquele sistema, era uma do tipo muito simples, onde haveria apenas uma única variável sendo usada. Apesar de ter feito a demonstração de como poderíamos criar o cálculo. Aqui iremos ser um pouco mais diretos. Isto por que, a matemática utilizada, a fim de conseguir criar a equação, baseada em valores presentes em um banco de dados, é algo que envolve muito conhecimento da matemática analítica e cálculo algébrico. Além é claro de saber que tipo de dados existe no banco que estamos usando.

E sendo este um artigo, cujo objetivo é ser o mais didático possível. Não quero complicar a vida de nenhum de vocês, meus caros leitores. Caso você de fato, se sinta interessado em aprofundar na parte relacionada aos cálculos. Sugiro que você leia artigos matemáticos, ou livro sobre o tema. Basicamente você terá que estudar matemática analítica e cálculo algébrico. E para deixar a coisa menos teórica e chata, sugiro que comece estudando teoria dos jogos. Ali você terá contato com os cálculos e analise de forma um pouco mais divertida. Sem toda aquela chatice se ver contas e mais contas sem fim.

Existe uma boa quantidade de material, muito bem explicado, e de fácil compreensão na Internet sobre o tema. Mas se o seu objetivo, é apenas ver o código, sinta-se bem vindo. Já que neste artigo, não irei entrar profundamente na parte matemática da coisa. Já que esta questão matemática é bastante densa e envolve de fato entender, cada um dos detalhes presentes, o que tomaria muito tempo para explicar todos eles. E muitos talvez não estejam de fato interessando nestas questões.

Então neste artigo, vamos passar rapidamente, por alguns métodos para conseguir a função que poderá representar os nossos dados no banco. Não irei me aprofundar em detalhes relacionados ao como usar estatísticas e estudos de probabilidade para interpretar os resultados. Deixo isto como dever de casa, para cada um que realmente deseja se aprofundar, na parte matemática da coisa. De qualquer forma, estudar tais coisas será primordial para que você de fato consiga compreender tudo que envolve estudos de redes neurais. Aqui irei pegar bem leve no tema.

Criando a equação de forma genérica

Então vamos começar fazendo alguns cálculos. ( Ai meu DEUS, lá vem ele de novo ). Calma meu caro leitor, não precisa começar a ficar aflito e com receio do que vamos fazer. Desta vez prometo que serei mais simpático. Então vamos fazer diferente do que foi feito no artigo anterior. Aqui nosso objetivo, será criar um sistema, que consiga gerar uma equação de reta, bem mais genérica. E para não lhe deixar completamente atordoado com desenvolvimento das fórmulas a serem usadas. Não vamos ver como é feito o desenvolvimento matemático por trás das equações usadas. Mesmo por que, acredito, que isto não é de fato necessário. Isto devido ao fato de termos feito uma demonstração básica, de como seria o desenvolvimento de uma equação matemática, com base em algumas ideias e princípios básicos. Isto foi feito no artigo anterior. Aqui vamos apenas entender o que tais equações de fato significam. Claro que vou tentar a medida do possível, tentarei deixar as coisas o mais palatável quando for possível ser feito. Mesmo que inicialmente as coisas possam parecer confusas. Vou tentar evitar que você tenha tal sensação. Então leia o artigo com calma e sem pressa. Veja como a coisa toda vai se desenhando. Pois aqui estarei resumindo diversas pesquisas na área de matemática, para lhe mostrar como podemos fazer uma rede neural, assimilar um dado conhecimento, com base em informações contidas em um banco de dados.

Porém antes de começarmos, quero deixar claro uma coisa: O que será visto aqui, diz respeito, a uma rede neural, que não irá receber nenhuma nova informação no seu banco de dados. Ou seja, o banco de dados, já está completamente construído e apenas queremos que ela gere uma equação que melhor represente o que se encontra no banco de dados. Para somente depois, usando outros mecanismos, possamos filtrar as probabilidade de uma nova informação, estar ou não relacionada ao que já se encontra no banco de dados. Tais mecanismos normalmente, já partem para a questão sobre inteligência artificial. Mas isto já é algo para um outro momento.

Bem, então vamos voltar ao nosso código de exemplo. Nele temos dois conjuntos de dados, que podem ser plotados em uma plano 2D. Fazendo uso de coordenadas X e Y somente. Desta forma, e analisando as coisas com calma, podemos notar que a equação procurada, será relativamente simples de ser construída. Já que nossos dados podem ser expressos tendo uma certa proximidade com uma provável reta. Existem casos em que isto não acontece, onde a equação pode ser uma curva, ou uma função trigonométrica. Mas vamos com calma. Primeiro é preciso entender estes casos mais simples. Assim, vamos começar entendendo o seguinte: A equação que desejamos obter, tem seu formato visto na imagem abaixo.

Aqui o valor da constante < a > representa o coeficiente angular. Já a constante < b > é o ponto de intersecção. Onde quando < b > é igual a zero, a raiz da função é zero. No artigo anterior, vimos calcular este coeficiente, quando < b > é zero. E mais no final daquele mesmo artigo, vimos como mudar ambos pontos, a fim de tentar acertar os valores das constantes na equação. Construindo assim a função de reta mostrada acima. Lembrando mais uma vez, que se você mudar o valor da constante < b > também mudará a raiz da função. Entender isto é importante, para se poder resolver este mesmo sistema via polinômios. Mas aqui vamos usar um método, que será uma adaptação do que foi visto e explicado no artigo anterior.

Acredito que ficou claro e evidente que usar laços para tentar encontrar estes valores. O que em programação é conhecido como força bruta. Onde testamos todos os valores possíveis. Não é, nem de longe, o melhor dos caminhos. Apesar de poder ser feito, o tempo de processamento seria enorme, e isto em grande parte dos casos. Em casos como o nosso, seria apenas bastante longo e demorado, mas poderia ser feito. Mas quando o número de variáveis, começa a se tornar realmente grande. Ai a coisa se torna impraticável de ser feita manualmente ou via força bruta.

Porém, mesmo que você se planejasse fazer as coisas na base da força bruta, no artigo anterior, demonstrei uma maneira de fazer um cálculo, que quando a constante < b > fosse igual a zero. Tornava encontrar o coeficiente angular, uma tarefa relativamente simples e rápida. E isto independente da quantidade de informações presentes no banco de dados. A única restrição, seria que a equação a ser gerada, precisaria ser uma reta. Mas se a constante < b > não fosse zero, aquele mesmo cálculo mostrado no artigo, não nos serviria para nada. Nos dando apenas uma leve estimativa da direção que deveríamos tomar, e isto será explorado em outro momento. Mas por agora, vamos tentar fazer as coisas baseando-se em funções conhecidas. Estilo a que é vista no começo deste tópico.

Muito bem, então vamos pensar em um caso genérico de solução. E lembrando novamente, que precisamos conhecer o tipo de polinômio que será usado. Caso não saibamos, qual seria o tipo, a procura da equação que melhor represente os dados, pode se tornar bastante lenta. Mesmo em casos simples. Então comece entendendo isto. Tudo que veremos agora, se baseia nisto: Conhecimento prévio.

Ok, vamos então generalizar o método de mínimo quadrado para qualquer caso. Para fazer isto, precisamos saber que tipo de polinômio será usado. Vamos começar com um bem simples, que dá origem a uma reta. Este polinômio, pode ser generalizado, usando a expressão vista abaixo.

Espere um pouco, esta não é a mesma fórmula vista no artigo anterior ?!?! Sim, é basicamente a mesma. Só que agora temos a variável < b > sendo colocada na fórmula. Isto por que agora, ela não será considerada mais como sendo igual a zero. Se você desenvolver este somatório, irá chegar em algo parecido com o que fizemos no artigo anterior. Mas para que você entenda. Quando generalizamos este cálculo, devemos considerar a derivada tanto em relação a variável < a > como também para  < b >. Assim temos a definição vista abaixo.

Ou seja, a mesma coisa que foi feita no artigo anterior. Porém isto não se limita a apenas uma equação de reta. Podemos usar este mesmo princípio para qualquer caso. Por exemplo, suponhamos que o conjunto de dados, possa ser melhor expresso, ou representado, como sendo uma parábola. Ou seja, deveríamos pensar em como fazer para procurar uma equação quadrática, usando o banco de dados que possuímos. Estas duas últimas definições, seriam transformadas no que se pode ver abaixo.

Desta forma, você somente precisaria desenvolver este somatório novo somatório, para encontrar a maneira de criar a equação, que neste caso seria uma equação quadrática. Ou melhor dizendo, encontrar as constantes usadas na equação, para que a equação quadrática, pudesse representar tudo que estaria no banco de dados. Mas voltando ao nosso caso, onde podemos usar a equação de reta. Se desenvolvermos o cálculo, agora fazendo < b > diferente de zero. Obteremos primeiro a seguinte equação vista abaixo.

Esta equação nos permite calcular o valor de < a > com base nas informações encontrados no nosso banco de dados.

Uma vez que conseguimos obter o valor da constante < a > podemos usar a equação mostrada abaixo, para procurar a constante < b >.

Em ambos casos, o valor de < k > é o número de pontos no gráfico. Talvez olhando apenas as equações, você meu caro leitor, possa ter ficado confuso, e ache isto um tanto quanto complicado de entender. Mas principalmente não consiga pensar em uma forma de colocar estas expressões em um código. Usando para isto uma linguagem de programação qualquer. E assim conseguir obter os valores das constantes sem precisar fazer isto de forma manual. Porém, da mesma maneira que fizemos no artigo anterior. Aqui vamos traduzir este formato matemático, para um formato em linguagem de programação. No caso, MQL5. Mas você poderia usar qualquer linguagem que desejasse, e os resultados com toda a certeza serão os mesmos. Então veja como ficaria, estas mesmas equações no nosso código em MQL5. Isto pode ser visto, no fragmento logo abaixo.

28. //+------------------------------------------------------------------+
29. void Func_01(void)
30. {
31.     int A[]={
32.                   -100, -150,
33.                    -80,  -50,
34.                     30,   80,
35.                    100,  120
36.             };
37. 
38.     int vx, vy;
39.     uint k;
40.     double ly, err, dx, dy, dxy, dx2, a, b;
41.     string s0 = "";
42. 
43.     canvas.LineVertical(global.x, global.y - _SizeLine, global.y + _SizeLine, ColorToARGB(clrRoyalBlue, 255));
44.     canvas.LineHorizontal(global.x - _SizeLine, global.x + _SizeLine, global.y, ColorToARGB(clrRoyalBlue, 255));
45. 
46.     err = dx = dy = dxy = dx2 = 0;
47.     k = 0;    
48.     for (uint c0 = 0, c1 = 0; c1 < A.Size(); c0++, k++)
49.     {
50.         vx = A[c1++];
51.         vy = A[c1++];
52.         dx += vx;
53.         dy += vy;
54.         dxy += (vx * vy);
55.         dx2 += MathPow(vx, 2);
56.         canvas.FillCircle(global.x + vx, global.y - vy, 5, ColorToARGB(clrRed, 255));
57.         ly = vy - (vx * -MathTan(_ToRadians(global.Angle))) - global.Const_B;
58.         s0 += StringFormat("%.4f || ", MathAbs(ly));
59.         canvas.LineVertical(global.x + vx, global.y - vy, global.y + (int)(ly - vy), ColorToARGB(clrPurple));
60.         err += MathPow(ly, 2);
61.     }
62.     a = ((k * dxy) - (dx * dy)) / ((k * dx2) - MathPow(dx, 2));
63.     b = (dy - (a * dx)) / k;
64.     PlotText(3, StringFormat("Error: %.8f", err));
65.     PlotText(4, s0);
66.     PlotText(5, StringFormat("f(x) = %.4fx %c %.4f", a, (b < 0 ? '-' : '+'), MathAbs(b)));
67. }
68. //+------------------------------------------------------------------+

Muito bem, vamos entender o que está acontecendo neste fragmento acima. Nas linhas 46 e 47, estamos iniciando todas as variáveis com o valor zero. Isto por que queremos mostrar explicitamente que elas estão começando em zero. Mas poderíamos deixar sem tal declaração, pois normalmente o compilador fará esta inicialização em zero de forma implícita. Pois bem, na linha 52 estamos calculando a somatória de todos os valores em X, e na linha 53 o somatório dos valores em Y. Já na linha 54, estamos computando a somatória do produto entre os valores de X e Y. E por fim, na linha 55, fazemos a computação do somatório do quadrado dos valores em X.

Todos estes cálculos dos quais menciono, são usados nas fórmulas mostradas anteriormente. Ou seja, fazer os cálculos é muito mais simples do que parece. Já na linha 60 temos justamente a fatoração para descobrir o mínimo quadrado. Baseando-se no valor do comprimento das linhas purpuras nas quais falei no artigo anterior.

Agora vamos efetivamente calcular os valores para as constantes usadas na equação da reta. Para fazer isto, usamos a linha 62, onde calculamos o valor do coeficiente de inclinação, e na linha 63 calculamos o valor de intersecção. Perceberão como é muito fácil, transformar uma fórmula matemática em um cálculo a ser executado pelo nosso programa ?!?! Tem gente que diz conseguir entender a matemática, mas não consegue escrever isto em termos de programa. Ao meu ver, esta pessoa está se iludindo. Pois escrever uma fórmula matemática em termos de programa, é tal simples como ler a própria fórmula. Se bem, que se você não entende a fórmula, não conseguirá dizer ao computador, que nada mais é do que uma calculadora gigante, como fazer para calcular algo.

De qualquer forma, não plotamos a reta no gráfico. Apenas plotamos a equação gerada. Isto é feito na linha 66, de forma que você, possa visualizar manualmente se a fórmula encontrada. Ou melhor dizendo, os valores que foram calculados, são ou não os melhores para aquele banco de dados específico. Na animação abaixo, mostro o resultado da execução do nosso programa, com os valores indicados na matriz A, presente na linha 31.

Note como os valores de erro mudam conforme tentando encontrar o ponto perfeito. E compare a equação da reta, mostrada como sendo a ideal, com a equação da reta que estamos tentando montar usando justamente as setas de direção. Por conta do fato de não termos um ajuste muito preciso, acabamos por encontrar um valor que gira próximo dos valores ideais. E entender isto é importante. Pois em breve iremos justamente explorar esta mesma propriedade. Porém de uma outra forma.

Agora você pode estar se perguntando: Mas será que existe uma forma de chegarmos ainda mais próximos do valor calculado ?!?! Sim, meu caro leitor. Para fazer isto, basta que você mude um único valor no programa. Este valor é mostrado no código abaixo.

void NewAngle(const char direct, const char updow, const double step = 0.1)

O valor a ser modificado é do argumento step. Aqui estamos usando um passo de 0.1 como você pode ver claramente no código. Mas você pode usar um valor ainda menor ou maior. Claro que se usar um valor menor, irá precisar de mais tempos para alcançar os valores calculados pelo código. Porém a precisão alcançada na questão do erro, será ainda melhor, justamente por conta que a variação será menor. Veja que uma coisa compensa a outra. Não existe uma solução 100% perfeita. Existe sim um ponto de balanço ideal.

Uma vez que já temos este código capaz de calcular a equação de reta. Podemos mexer a vontade, nos valores presentes na matriz A, criando qualquer tipo de condição ou banco de conhecimento. Talvez, seja necessário apenas ajustar o tipo de variáveis sendo usadas. Já que aqui, estamos usando do tipo inteiro. Mas se você desejar usar do tipo flutuante, estilo double ou float. É só mudar o tipo usado. O cálculo não precisará mudar. Isto para conseguir a equação de reta. Mas se os dados que estiverem no banco, forem melhor representados usando uma equação quadrática por exemplo. Você deverá mudar o cálculo, para que encontre a melhor sistema de constantes que consiga representar o seu banco de dados. Como foi dito antes. Tudo depende, não existe uma solução 100% eficaz para todos os casos possíveis e imagináveis.

Muito bem, mas você pode estar pensando, que só existe esta forma de fazer o cálculo para encontrar a equação de reta. Porém, se você pensou isto, significa que você ainda não conhece o bastante. Assim para mostrar uma outra forma de conseguir os mesmos valores vistos neste tópico. Vamos ver um novo tópico, para separar adequadamente as coisas. Só que este próximo tópico será apenas a apresentação do que será visto de fato, no próximo artigo.

Pseudo Inversa

Muito bem, até este momento, as coisas podem ser se mostrado como muito complexas e difíceis de serem implementadas em termos de código. Isto por que, cada mudança necessária, precisa ser igualmente implementada em termos de código gerado. Mas existe uma forma um pouco mais agradável de codificar coisas que mudam muito, em termos de uso de variáveis. Pelo menos eu penso assim, não sei quanto a você, meu caro leitor. Mas quando o assunto é codificar algo que a todo momento muda a quantidade de variáveis sendo usadas. Prefiro deixar de lado os cálculos escalares e passo a usar cálculos matriciais. Isto por que, trabalhar com matrizes no permite fatorar qualquer coisa, sem precisar ficar criando variáveis e mais variáveis a fim de comportar valores temporários. Sei que muitos de vocês, devem achar o cúmulo da complexidade criar um código cujo objetivo é fatorar matrizes. E muitos usam bibliotecas que efetuam tais fatorações, sem ao menos se darem conta de como elas funcionam. Mas acabam se tornando escravos de tais bibliotecas, justamente por não entender a forma de calcular as coisas.

A um tempo atrás, fiz dois artigos, cujo objetivo era justamente apresentar a fatoração de matrizes. Ali mostrei os elementos mais básicos, dos quais você precisa aprender para conseguir fazer um código que efetue operações de fatoração, só que usando matrizes para isto. E muitos problemas, são mais simples e rápidos de serem resolvidos, quando usamos matrizes para efetuar os cálculos.

Os artigos são: Fatorando Matrizes - O Básico e Fatorando Matrizes - Uma modelagem mais prática quem tiver interesse em aprender um pouco mais sobre o assunto. Considere ler e praticar o que está sendo mostrado naqueles dois artigos. Claro que ali, estou mostrando apenas o básico. Mas se você entendeu o conteúdo presente ali, conseguirá entender o que iremos fazer neste tópico. Pois aqui iremos usar matrizes para encontrar os tais valores encontrados no tópico anterior.

Para entender o que vamos fazer aqui, é preciso entender como fatorar matrizes. E não estou falando em termos de programação. Programar as coisas é a parte fácil. Estou falando, que você meu caro leitor, deve sim, conseguir efetuar cálculos usando matrizes. Não vou entrar em detalhes de como fazer tais cálculos. Irei assumir que você, meu caro e estimado leitor, tenha o mínimo de conhecimento sobre o assunto. Não precisa ser um expert. Basta saber o mínimo que já será o suficiente para o que iremos fazer.

Muito bem, então vamos voltar a questão de como procurar a equação da reta. Isto considerando que temos um banco de dados, cujo conteúdo queremos preservar em forma de equação matemática. Bem, olhando desta maneira, parece que vamos fazer algo extremamente complexo. Onde apenas um gênio conseguiria tal façanha. Mas não, iremos fazer o mesmo que foi feito no tópico anterior. Só que de uma maneira um pouco diferente.

Comecemos pelo básico, novamente. A equação de erro é vista na imagem abaixo.

Muito bem, esta é a forma escalar de escrever a equação. Mas podemos escrever a mesma equação de forma matricial. Como é visto logo abaixo.

Esta representação matricial, vista acima. É exatamente o que esta sendo mostrado na imagem anterior. Exatamente, sem nem colocar ou tirar absolutamente nada. Mas podemos simplificar ainda mais esta representação matricial. Da seguinte forma.

Sei que esta representação, pode parecer extremamente complicada. Mas ainda estamos representando exatamente, o que o cálculo escalar estará efetuando. Porém esta representação mais compacta da fatoração matricial, nos permitirá entender como os cálculos serão feitos. Pois precisaremos escrever menos elementos na fórmula. Aqui estamos dizendo que o vetor < e > é igual a matriz < M > que contém os valores de x. Multiplicado pelo vetor < q > que contém os valores das constantes que estamos procurando. Elas são: O coeficiente angular e o ponto de intersecção. Subtraído do vetor < p > que representa os valores da matriz contendo valores de y.

Agora quero lembrar você, meu caro leitor do seguinte: Estamos procurado a derivada das constantes < a > e < b > em relação ao erro que podemos calcular facilmente. Visto que temos a localização dos pontos a serem usado no cálculo. Assim quando representado na forma matricial, poderemos ver as coisas sendo mostradas como é visto logo abaixo.

Só que, aqui temos um pequeno detalhe, que pode ser visto imediatamente abaixo.

Lembrando que < n > representa o índex no array, dentro do nosso código. Ou seja, a equação acima, pode ser reescrita como mostrado abaixo.

Legal. Agora temos algo realmente interessante em mão. Já que olhando as matrizes anteriores, você pode ver que este mesmo resultado mostrado aqui. Também aparece em outro local. Só que esta matriz daqui está virada ou transposta como é a nomenclatura usada. Deixando a fórmula em um formato mais compacto, você verá a imagem abaixo.

O próximo passo, será fazer algumas substituições, com dados que já temos em mãos. Desta forma, obtemos a seguinte formulação, vista a seguir.

Ok, agora vamos desenvolver este cálculo, ou fórmula com queira, mostrado acima. Com isto passamos a ter o seguinte:

Agora se a matriz transposta, puder ser invertida, teremos algo como mostrado abaixo.

Este resultado de agora, é de fato uma fatoração muito bonita, e interessante de ser vista. Tanto que a pessoa que a criou, de fato mereceu o prêmio nobel de matemática de 2020. Esta formulação é conhecida como Pseudo Inversa, ou Moore-Penrose Inverso, em homenagem aos seus criadores. Já que ela nos dá exatamente o que procuramos, ou seja, os valores do coeficiente angular e da intersecção. E eles estarão dentro do vetor < q >. Este tipo de coisa, pode ser implementado em diversos programas diferentes. Muitos deles voltados a trabalhar apenas com cálculos. Por exemplo, usando o SCILab, você pode usar o programa abaixo. Este irá conseguirá calcular os valores para o coeficiente angular e o ponto de intersecção.

clc;
clear;
clf;

x=[-100; -80; 30; 100];
y=[-150; -50; 80; 120];

A = [ones(x), x];

plot(x, y, 'ro');
zoom_rect([-150, -180, 180, 180]);
xgrid;

x = pinv(A) * y;
b = x(1);
a = x(2);

x =[-120:1:120];
y = a * x + b;

plot(x, y, 'b-');

Já o resultado da execução pode ser visto logo abaixo:

Os pontos em vermelho mostram onde está localizados, os mesmos pontos vistos no programa em MQL5. Já a linha em azul, mostra o resultado, do que seria a equação da reta encontrada via pseudo inversa. A mesma coisa pode ser conseguida usando o MATLab, além de diversos outros programas, como por exemplo o Excel. Isto por conta da grande utilidade desta pseudo inversa, em diversas áreas do conhecimento.

Para que você, meu caro leitor, tenha uma ideia do quanto esta pseudo inversa é interessante. Apenas mudando ligeiramente os vetores usados, assim como as matrizes da equação. Podemos resolver qualquer tipo de polinômio. E isto de forma bastante eficiente.

Considerações finais

Como a pseudo inversa, é uma fatoração que deve ser feita, essencialmente usando matrizes. Não vou mostrar neste artigo como ficaria o programa para encontrar as constantes < a > e < b >. Isto por conta do que precisará ser explicado, para que você de fato consiga entender o que está acontecendo. Não é só uma questão de mostrar o código em si. Trabalhar com matrizes, exige um nível de atenção muito maior. Devido a forma como se trabalha com elas. Quando fazemos isto na mão, as operações efetuadas são relativamente simples. Porém fazer isto em forma de código é algo completamente diferente. Mesmo nos artigos que menciono como fazer uso de fatorações em matrizes. As coisas feitas lá não são genéricas. Elas são bem específicas. E para o nosso objetivo, precisamos de um código mais genérico. Caso contrário, a pseudo inversa, não poderá ser calculada corretamente em qualquer caso em que tentarmos fazer isto.