
English: 
Last time, we did a bunch of calculus to find the rate of change of our cost, J,
with respect to our parameters, W.
Although each calculus step was pretty straight forward, it’s still relatively easy to make mistakes.
What’s worse, is that our network doesn’t have a good way to tell us that it’s broken
– code with incorrectly implemented gradients may appear to be functioning just fine.
This is the most nefarious kind of error when building complex systems.
Big, in-your-face errors suck initially
but it’s clear that you must fix this error for your work to succeed.
More subtle errors can be more troublesome because they hide in your code and steal hours of your time,
slowly degrading performance, while you wonder what the problem is.
A good solution here is to test the gradient computation part of our code,
just as developer would unit test new portions of their code.
We’ll combine a simple understanding of the derivative with some mild cleverness to perform numerical gradient checking.
If our code passes this test,

Portuguese: 
Última vez, nós fizemos um monte de cálculo para encontrar a taxa de mudança do nosso custo, J,
com relação aos nossos parâmetros, W.
Embora cada etapa do cálculo tenha sido bastante direta, ainda é relativamente fácil cometer erros.
O pior é que nossa rede não tem uma boa maneira de nos dizer que está quebrada
código com gradientes implementados incorretamente pode parecer estar funcionando bem.
Este é o tipo mais abominável de erro ao construir sistemas complexos.
Erros grandes e imediatos inicialmente
mas é claro que você deve corrigir esse erro para que seu trabalho seja bem-sucedido.
Erros mais sutis podem ser mais problemáticos, porque eles escondem seu código e roubam horas do seu tempo,
desempenho lentamente degradante, enquanto você se pergunta qual é o problema.
Uma boa solução aqui é testar a parte de computação de gradiente do nosso código,
assim como o desenvolvedor testaria unidades novas partes de seu código.
Combinaremos uma compreensão simples da derivada com uma leve esperteza para realizar a verificação do gradiente numérico.
Se o nosso código passar neste teste,

English: 
we can be quite confident that we have computed and coded up our gradients correctly.
To get started, let’s quickly review derivatives.
Derivatives tell us the slope, or how steep a function is.
Once you’re familiar with calculus,
it’s easy to take for granted the inner workings of the derivative
we just accept that the derivative of x^2 is 2x by the power rule.
However, depending on how mean your calculus teacher was,
you may have spent months not being taught the power rule, and instead required to compute derivatives using the definition.
Taking derivatives this way is a bit tedious,
but still important
it provides us a deeper understanding of what a derivative is,
and it’s going to help us solve our current problem.
The definition of the derivative is really a glorified slope formula.
The numerator gives us the change in y values,
while the denominator is convenient way to express the change in x values.
By including the limit, we are applying the slope formula across an infinitely small region

Portuguese: 
Podemos estar bastante confiantes de que calculamos e codificamos nossos gradientes corretamente.
Para começar, vamos revisar rapidamente as derivadas.
Derivadas nos dizem a inclinação, ou quão íngreme é uma função.
Quando estiver familiarizado com o cálculo,
é fácil dar por certo o funcionamento interno da derivada
nós apenas aceitamos que a derivada de x ^ 2 é 2x pela regra da potência.
No entanto, dependendo de como o seu professor de cálculo era ruim,
você pode ter passado meses sem aprender a regra da potência e, em vez disso, precisou calcular derivadas usando a definição.
Calcular derivada dessa maneira é um pouco entediante,
mas ainda importante
nos fornece uma compreensão mais profunda do que é uma derivada,
e isso vai nos ajudar a resolver nosso problema atual.
A definição da derivada é realmente uma fórmula de inclinação glorificada.
O numerador nos dá a mudança nos valores y
enquanto o denominador é uma maneira conveniente de expressar a mudança nos valores de x.
Ao incluir o limite, estamos aplicando a fórmula da inclinação em uma região infinitamente pequena

English: 
it’s like zooming in on our function, until it becomes linear.
The definition tells us to zoom in until our x distance is infinitely small,
but computers can’t really handle infinitely small numbers,
especially when they’re in the bottom parts of fractions
if we try to plug in something too small,
we will quickly lose precision.
The good news here is that if we plug in something reasonable small,
we can still get surprisingly good numerical estimates of the derivative.
We’ll modify our approach slightly by picking a point in the middle of the interval we would like to test,
and call the distance we move in each direction epsilon.
Let’s test our method with a simple function, x squared.
We’ll choose a reasonable small value for epsilon,
and compute the slope of x^2 at a given point by finding the function value just above and just below our test point.
We can then compare our result to our symbolic derivative 2x,
at the test point
If the numbers match, we’re in business!

Portuguese: 
é como ampliar a nossa função até se tornar linear.
A definição nos diz para aumentar o zoom até que nossa distância x seja infinitamente pequena,
mas os computadores não conseguem lidar com números infinitamente pequenos
especialmente quando eles estão nas partes inferiores das frações
se tentarmos ligar algo muito pequeno,
nós rapidamente perderemos precisão.
A boa notícia aqui é que se ligarmos algo razoável pequeno,
Ainda podemos obter estimativas numéricas surpreendentemente boas da derivada.
Vamos modificar um pouco nossa abordagem escolhendo um ponto no meio do intervalo que gostaríamos de testar
e chamar a distância que nos movemos em cada direção épsilon.
Vamos testar nosso método com uma função simples, x ao quadrado.
Nós vamos escolher um pequeno valor razoável para epsilon,
e calcular a inclinação de x ^ 2 em um dado ponto, encontrando o valor da função logo acima e logo abaixo do nosso ponto de teste.
Podemos então comparar o nosso resultado com a nossa derivada simbólica 2x,
no ponto de teste
Se os números coincidirem, estamos preparados para começar!

Portuguese: 
Podemos usar a mesma abordagem para avaliar numericamente o gradiente de nossa rede neural.
É um pouco mais complicado desta vez, já que temos 9 valores gradientes,
e estamos interessados no gradiente da nossa função de custo.
Vamos simplificar as coisas testando um gradiente de cada vez.
Nós vamos "perturbar" cada peso
adicionando epsilon ao valor atual e calculando a função de custo,
subtraindo epsilon do valor atual e calculando a função de custo,
e, em seguida, calcular a inclinação entre esses dois valores.
Repetiremos este processo em todos os nossos pesos
e quando terminarmos teremos um vetor gradiente numérico,
com o mesmo número de valores que temos pesos.
É esse vetor que gostaríamos de comparar ao nosso cálculo oficial de gradiente.
Nós vemos que nossos vetores parecem muito semelhantes,
o que é um bom sinal, mas precisamos quantificar o quão semelhantes eles são.
Uma boa maneira de fazer isso é dividir a norma da diferença
pela norma da soma dos vetores que gostaríamos de comparar.

English: 
We can use the same approach to numerically evaluate the gradient of our neural network.
It’s a little more complicated this time, since we have 9 gradient values,
and we’re interested in the gradient of our cost function.
We’ll make things simpler by testing one gradient at a time.
We’ll “perturb” each weight
adding epsilon to the current value and computing the cost function,
subtracting epsilon from the current value and computing the cost function,
and then computing the slope between these two values.
We’ll repeat this process across all our weights,
and when we’re done we’ll have a numerical gradient vector,
with the same number of values as we have weights.
It’s this vector we would like to compare to our official gradient calculation.
We see that our vectors appear very similar,
which is a good sign, but we need to quantify just how similar they are.
A nice way to do this is to divide the norm of the difference
by the norm of the sum of the vectors we would like to compare.

English: 
Typical results should be on the order of 10^-8 or less if you’ve computed your gradient correctly.
And that’s it, we can now check our computations and eliminate gradient errors before they become a problem.
Next time we’ll train our Neural Network.

Portuguese: 
Os resultados típicos devem ser da ordem de 10 ^ -8 ou menos, se você tiver calculado o gradiente corretamente.
E é isso, agora podemos verificar nossos cálculos e eliminar erros de gradiente antes que eles se tornem um problema.
Da próxima vez, vamos treinar nossa Rede Neural.
