AI REDES NEURAIS ETC

Example Width Length Bug

1 3.0 1.0 ladybird
2 1.0 3.0 caterpillar

Para ladybird = (x,y) = (3.0, 1.0)\

Vamos chutar o valor de A colocando 0.25
y = (0.25) * (3.0) = 0.75
Mas vimos que nao deu certo o valor correto de y seria 1.0.
Então temos que aumentar um pouco o 0.25 para y chegar a 1, mas quanto? Vamos ver mais
pra frente
Como y deu 0.75 mas o correto é 1 o erro é 0.25
E = 1 - 0.75 = 0.25

Agora vamos testar com uma joaninha com 1.1 de altura:

y = (0.25) * (3.0) = 0.75
Nesse caso o erro aumentou (0.35 > 0.25). Deu 0.75 mas o correto é 1.1, então:
E = 1.1 - 0.75 = 0.35
Vamos representar o valor correto como t, que é:
t = (A + ΔA)x
Então se ​y = (A)x ​&&​ t = (A + ΔA)x ​&&​ E = t - y ​Então​:
t​ - ​y​ = ​(A + ΔA)x​ - ​Ax
Simplificando:
E = t - y = ​Ax + (ΔA)x​ - ​Ax
E = (ΔA)x
ΔA = E / x
Agora podemos encontrar o slope (delta) com base no erro:
Que é quanto devemos aumentar o nosso chute para acertar a joaninha de 1.1:
ΔA = E / x
0.1167 = 0.35 / 3.0

Agora que sabemos o slope, podemos pegar nosso chute de 0.25 e testar nele:
Obtemos o valor correto para a joaninha de 1.1
Lembrando que esse slope é da joaninha 1.1, não da 1.0:
y = (A + ΔA)x
y = (0.25 + 0.1167) * 3
y = 1.1

Agora vamos testa com a lagarta, mas vamos diminuir um pouco par x,y = (1.0, 2.9)
Agora vamos pegar esse chute de 0.25, aplicar o slope para quando estamos em x = 1
(lagarta), pois ja fizemos isso quando x = 3 (joaninha acima)
Mas 0.3667 é longe de 2.9 .. nao deu muito certo:
t = (A + ΔA)x
0.3667 = (0.25 + 0.1167) * 1.0 (Lembrando que o x dessa lagarta é 1.0)

Então o erro desse novo teste da lagarta em 0.25 será:

E=t-y
2.5333 = (2.9 - 0.3667)

Se ​ΔA = E / x​ Então:
2.5333 = 2.5333 / 1.0 (Lembrando que o x dessa lagarta é 1.0)
Agora achamos um novo slope 2.5333

---------
Para a joaninha (x,y) = (3, 1.1)
Adicionamos um moderador ou learning rate L
ΔA = L (E / x )
0.0583 = 0.5 * (0.35 / 3.0)
Antes deu ​0.1167​, agora deu​ 0.0583
E se agora ΔA é 0.0583, o novo A é
novoA = (A + ΔA)
0.3083 = 0.25 + 0.0583
Se testarmos esse novo A para tentar achar o y:
y = Ax
0.9250 = 0.3083 * 3.0
Percebemos que y está agora mais próximo do valor correto 1.1

Testando esse novo A na lagarta (x, y) = (1.0, 2.9) temos:

y = Ax
0.3083 = 0.3083 * 1
Calculamos o novo erro (Que é até maior)
E=t=y
2.5917 = (2.9 - 0.3083)
Com o moderador e o erro calculamos um novo ΔA:
ΔA = L (E / x )
1.2958 = 0.5 (2.5917 / 1)
E por consequência temos um novo A também:
novoA = (A + ΔA)
1.6042 = 0.3083 + 1.2958
Esse valor está mais próximo do que buscamos
Ex:
1 CAMADA = ​2​ NODES
2 CAMADA = 2​ ​ NODES

1 Passo:
2CAM1NODE = (1CAMNODE1 * W1,1) + (1CAM2NODE + W2,1) + ….
2CAM2NODE = (1CAMNODE1 * W1,2) + (1CAM2NODE + W2,2) + ….

Isso também pode ser expressado como multiplicação de matriz:

X = W​​·​I (Weights x Inputs)

Lembrando que cada camada tem seus próprios weights. Entre a camada 1 e 2 tem weights
diferentes da camada 2 e 3.

2 Passo:
Aplica a ​activation function​ ​SIGMOID​ para esse resultado, Assim temos como resultado final
os inputs da próxima camada.
O​​ = sigmoid (​​X​)
Agora podemos passar passar para a próxima camada e repetir os passos 1 e 2.

3 Passo:
Back Propagating errors. Essa parte é somente utilizada no treino. Não na query da rede em si.
Quando chegamos no final temos uma matrix O de outputs. Também temos um matriz de
resultados corretos (targets). Diminuímos Outputs - Targets para achar uma matriz de erros
iniciais para a última camada.

Agora começamos a voltar nas camadas distribuindo os erros uniformemente:

Essa matriz enorme de weights pode ser transcrita como uma matriz transposta:

Ficando assim a expressão final para encontrar os erros da segunda camada:

Pronto, agora encontramos a matriz de erros da segunda camada (escondida).

Agora é só fazer o mesmo com a primeira camada. Ou seja, pegar os erros da segunda
camada que acabamos de encontrar e colocar eles nessa mesma fórmula acima junto com os
weights da primeira camada para achar os novos erros da primeira camada.

4 Passo:
Encontrar a expressão para o slope, ΔW e o novo W.
gradient descent​​ nos ajuda a encontrar o mínimo sem precisar calcular toda a função, que
seria muito complicada para um computador.

Agora que encontramos o slope. Também utilizamos um learning rate (alpha) para moderar a
força dessas mudanças nos weights simplesmente multiplicando ​α​ pelo SLOPE.
ΔW = ​α * SLOPE
Simplificando essas expressões temos a ​diferença entre os weights antigos e os novos
(Repare que delta indica diferença):
Repare que​ T​k​ - O​k​ foi simplificado como ​E​k​.
E que no passo 2 já aplicamos sigmoid nos outputs das camadas. Não aplicamos de novo. ​O​k​ e
O​j ​em vermelho já são os outputs do passo 2. E também Oj no final é transposta.

Repare também que essa simplificação já incluímos o sinal negativo de W = W - ΔW. Então se
formos utilizar ela fazemos ​W = W + ΔW
Mas se não utilizar a simplificação utilizamos ​W = W - ΔW​ mesmo

Segundo essa figura ​montamos um exemplo​ para achar ​W​11​ (Que era 2.0 mas vai mudar):

( ​T​k​ ​- ​O​k​ ​) é o erro ​E​1​ ​= ​0.8​.

Σ​j ​W​jk ​O​j​ ​ é ------> (​W​11​ * ​O​j​=1​) + (​W​21​ * ​O​j​=2​) ------> (2.0 * 0.4) + (3.0 * 0.5) = 2.3.
Sigmoid de ​Σj​ ​Wj​ k ​Oj​ ​ ​é sig(2.3) = 0.0.09. Então a ​parte vermelha​ é 0.909 * (1 - 0.909) = ​0.083​.
O​j​ é ​0.4

Então para achar o SLOPE:

S = - E * VERMELHA * O​j ​ ------->​ ​S = - 0.8 * 0.083 * 0.4 = -0.02652
Então para achar ΔW
ΔW = ​α * SLOPE ​ --------> 0.1 * ​-0.0265 = -0.002650
Então para achar W
W = W - ΔW​ ---------> 2.0 - (-0.002650) = ​2.00265

PONTOS A SE OBSERVAR:

● Neural networks don’t work well if the input, output and initial weight data is not prepared to
match the network design and the actual problem being solved.
● A common problem is ​saturation​​ - where large signals, sometimes driven by large weights,
lead to signals that are at the very shallow slopes of the activation function. This reduces the
ability to learn better weights.
● Another problem is ​zero​​ value signals or weights. These also kill the ability to learn better
weights.
● The internal link weights should be ​random​​ and ​small​​, avoiding zero. Some will use more
sophisticated rules, for example, reducing the size of these weights if there are more links into a
node.
● ​Inputs​​ should be scaled to be small, but not zero. A common range is 0.01 to 0.99, or -1.0 to
+1.0, depending on which better matches the problem.
● ​Outputs​​ should be within the range of what the activation function can produce. Values below
0 or above 1, inclusive, are impossible for the logistic sigmoid. Setting training targets outside
the valid range will drive ever larger weights, leading to saturation. A good range is 0.01 to 0.99.

MELHORIAS:

Nao ha um método exato para saber como melhorar a rede. Podemos tentar as seguintes
mudanças:

AJUSTAR O LEARNING RATE: Quanto mais training data, um LR menor é melhor.

AJUSTAR O EPOCH:
NÚMERO DE INPUTS DA HIDDEN LAYER:

Podemos achar uma porcentagem de quantas vezes a passaram acertou ou não colocando os
resultados em um array 1 para certo e 0 para errado, e assim achar a performance:
performance = [1, 0, 1, 1, 1, 1, 1, 0, 0, 0]
performance = performance.sum() / performance.size

Assim podemos fazer um for de lrs, epochs ou inputs e ir testando as performances conforme
diferentes valores e assim achar os melhores valores possíveis:
lrs = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7]
for lr im lrs:
if calcperformance(lr) > lastPerformance:
…….

--------------------------------------------------------------------------------------------------------------------------------

CLASSIFICATION
REGRESSION
ASSOCIATION
CLUSTERING

--------------------------------------------------------------------------------------------------------------------------------
#CALCULO

Queremos ​descobrir a rate of change do ponto p

Vamos ​tentar com o ponto t = 3

Então inicialmente pegamos dois pontos a direita e esquerda com distância de 2, ou seja, como
pegamos os pontos t = 1 e t = 5. Poderia ser qualquer distancia, 2 porque fica fácil de visualizar

Então a partir desses dois pontos podemos traçar uma reta como na figura
Pra achar a distância dessa reta entre esses dois pontos é so usar pitágoras.
Primeiro devemos​ achar os valores de S nesses pontos. ​Pra isso simplesmente calculamos a
funcao:

A função desse gráfico é ​y = x²

Ou ​speed = time²

s = 01 em t = 01 pois ​s = 1²
s = 25 em t = 05 opis ​s = 5²

Extent e height
Height é s1 - s0​ = 25 - 1 = ​24
Extent é t1 - t0​ = 5 - 1 = ​4

O gradiente de um ponto é aproximadamente a diferenca entre extent e height:

gradient = height / extent

Então calculando, descobrimos o gradient no ponto 3:

gradient = 24 / 4 =​ 6

Mas lembrando que ​isso é um valor aproximado.

Para ​melhorar a aproximação​ usamos distâncias menos, bem pequenas.
Invés de 2 poderíamos utilizar 0,1 ou 0,0001, etc

GRADIENTE EM QUALQUER PONTO DO GRÁFICO

Se T​ 0 = (t - Δx)
Se​ T1 = (t + Δx)

Se s = t², então ​S0 = (t - Δx)²

Se s = t², então​ S1 = (t + Δx)²

Se h = s1 - s0, então ​H = (t + Δx)²​ - ​(t - Δx)²

Se e = t1 - t0, então ​E = (t + Δx) - (t - Δx) ​ou​ E = 2Δx

Se g = h / e, então​ G = ( (t + Δx)²​ - ​(t - Δx)²​ ) / ​(t + Δx) - (t - Δx)

Simplificando: ​G = 2T​ para qualquer ponto a linha
OUTRO EXEMPLO COM FUNÇÃO S = T² + 2T

G = ( (t + Δx)² + 2(t + Δx) - (t - Δx)² - 2(t - Δx) ) / 2Δx

G = 2T - 2

OUTRO EXEMPLO COM FUNÇÃO S = T³

G = ….
G = 3T² + Δx

Repare que nesse exemplo o gradiente depende do intervalo escolhido entre t1 e t0

Então o ideal é colocarmos um número infinitamente pequeno em Δx
Podendo até mesmo retirá-lo da equação, pois é como se Δx fosse 0:

G = 3T²

REGRA GERAL

B B−1
G de A * T é igual a B AT

Ex:

T 5 =========== 5 * 1 * T 5 − 1 ================== 5T 4
T 3 + C ======= (3T 3 − 1 ) + C ================== 3T 2 + C = 3T 2

6T 6 + 9T + 4 == (6 * 6 * T 6 − 1 ) + (1 * 9 * T 1 − 1 ) + 4 == 36T 5 + 9

FUNÇÕES COMPOSTAS E CHAIN RULE

Para… ​ f(y) = y²​ ​ e ​y(x) = x³ + x​ ​temos os seguintes gradientes:

δf
δy
​=​ ​2y
δy
δx
​=​ ​3x² + 1
δf
Então… =​ (2y) * (3y² + 1) ​simplificando…. (​2x³ + 2x) (3x² + 1)
δx

APLICANDO TUDO ISSO A UMA REDE NEURAL

Z = w*a*b
A = Sigmoid(z)
C = (e - a)²

Analisando a figura…. vemos que conforme mudamos certos parâmetros seus resultados
também são alterados. Por exemplo ali em w*a*b = z, se w for maior z vai ser maior, se w for
menor, z vai ser menor. Isso também ocorreria com a e b, mas a é fixo, nao varia e nao estamos
interessados na variação de B por enquanto. Essa mesma lógica pode ser utilizada em A e C,
Então:

δz
Z varia conforme W ( )
δw
 δa
A varia conforme Z ( )
δz
δc
C varia conforme A ( )
δa

A partir de tudo isso vemos que o valor de W no início influencia o valor de C lá no final. Ou seja
C varia conforme W. Assim podemos ​usar a chain rule e descobrir a derivada de C conforme W​:

Calculando a derivada de cada um dos itens

δc
Obtemos a derivada de
δa
=

δc
Agora vamos ver derivada de C sobre B ​(​ )
δb

Também podemos encontrar a derivada de C sobre A, embora esse parâmetro não vai mudar:
SEGUINDO A MESMA LÓGICA, MAS PELO LIVRO:

Erro conforme Weights ->

Derivada de sigmoid é ​sigmoid * (1 - sigmoid) ​ ---->

Assim encontramos a equação final do slope

Nao entendi aonde foi o 2 e pq tem esse Oj no final
Isso somente é utilizado na backpropagation, ou seja, no treino

Usamos esse slope para atualizar os novos weights: (Negativo pois estamos tentando diminuir o slope
para achar o mínimo)

W​new​ = W​old​ * - SLOPE

Na verdade tb devemos colocar um learning rate junto:

W​new​ = W​old​ * - (LEARNING_RATE * SLOPE)

SIGMOID COM RELU PARA ENCONTRAR PADRÕES

CONVOLUTIONAL NEURAL NETWORKS

ETAPA 1 - CONVOLUTION

Vários blocos. Cada bloco é comparado com a imagem inteira:

No exemplo abaixo um bloco foi comparado com uma porção da imagem, como todos os pixels são
iguais, a média resultou 1, ou seja essa porção da imagem é exatamente igual a porção que estamos
comparando.

Já nesse exemplo apenas alguns pixels são iguais, resultando um resultado menor que 1:

Fazendo todas essas comparações para um bloco obtemos uma cada de comparacao.
Fazendo em vários blocos temos várias camadas, um para cada bloco.
ETAPA 2 - POOLING

Separamos o resultado da primeira etapa em quadrados e pegamos o valor maior.

Assim obtemos uma imagem menor que a anterior

ETAPA 3 - NORMALIZATION

Aplicamos um ​RELU​ para retirar os itens negativos:

As etapas anteriores ​não​ precisam seguir essa ordem, inclusive várias redes têm combinações diferentes
de etapas:
ETAPA 4 - FULLY CONNECTED LAYER

Agora pegamos o resultado das camadas e passamos para uma rede neural comum de classificação:

RECURRENT NEURAL NETWORKS

Ver mais sobre mais tarde.