
Portuguese: 
Da última vez decidimos usar gradiente descendente para treinar nossa Rede Neural
para que pudesse fazer previsões melhores da sua pontuação em um teste
com base em quantas horas você dormiu e quantas horas você estudou na noite anterior.
Para executar gradiente descendente, precisamos de uma equação e algum código para o nosso gradiente ∂J / ∂W.
Nossos pesos W estão distribuídos em duas matrizes.
W(1) e W(2)
Separaremos nosso calculo ∂J / ∂W da mesma maneira, calculando ∂J / ∂W (1) e ∂J / ∂W (2)
independentemente.
Devemos ter tantos valores de gradiente quanto valores de peso, então quando terminarmos nossas matrizes
∂J / ∂W (1) e ∂J / ∂W (2) serão do mesmo tamanho que W(1) e W(2)
Vamos trabalhar em ∂J / ∂W (2) primeiro.
A soma em nossa função de custo adiciona o erro de cada um de exemplo para criar um custo global.

Korean: 
마지막 수업에서, 우리는 우리의 신경망 네트워크를 학습시키기 위해 점근적 하강법을 이용했습니다.
이를 통해 , 전 날 밤 공부 한 시간과 수면 시간에 따라 다음 날 시험에서 몇 점을 맞을 것인지를 더 정확하게 예측할 수 있었습니다.
점진적 하강법을 수행하기 위해,  우리는 dJ/dw 를 나타내는 방정식과  코드를 사용했습니다.
weight를 나타내는 W는 두 개의 매트릭스인 W1과 W2로 나뉩니다.
dj/DW에 대한 계산은 각각 같은 방식으로 수행합니다.
dj/Dw1, dj/dW1 를 독립적으로 계산하는 방식으로 말이죠.
계산이 끝난 후, 우리는 각 W 값 개수 만큼의 gradient 값을 가져야 합니다.
dJ/dW1과 dJ/dW2 가 각각 W1,W2와 사이즈가 같도록 말이죠.
dJ/dW1 를 먼저 계산해보겠습니다.
총 비용을 계산하기 위해, 각 example의 에러를 제곱하여 더합니다.

English: 
Last time we decided to use gradient descent to train our Neural Network
so it could make better predictions of your score on a test
based on how many hours you slept and how many hours you studied the night before.
To perform gradient descent we need an equation and some code for our gradient ∂J/∂W.
Our weights W are spread across two matrices.
W(1) and W(2)
We'll separate our ∂J/∂W computation in the same way, by computing ∂J/∂W(1) and ∂J/∂W(2)
independently.
We should have just as many gradient values as weight values, so when we're done our matrices
∂J/∂W(1) and ∂J/∂W(2) will be the same size as W(1) and W(2)
Let's work on ∂J/∂W(2) first
The sum in our cost function adds the error from each example to create an overall cost.

Portuguese: 
Vamos aproveitar a regra da soma de diferenciação que diz que a derivada da soma é igual à soma das derivadas
Podemos mover nosso sigma (Σ) para fora e apenas nos preocupar com a derivada da expressão interna primeiro.
Para simplificar, esquecemos temporariamente de nossa soma.
Depois que calcularmos ∂J / ∂W para um único exemplo,
vamos voltar e adicionar todos os nossos termos derivados individualmente juntos
Agora podemos avaliar nossa primeira derivada. A 'regra do tombo' nos diz para derrubar o nosso expoente 2 e multiplicar.
Para finalizar a nossa derivada, precisamos aplicar a regra da cadeia.
A regra da cadeia nos diz como pegar a derivada de uma função dentro de uma função
e geralmente diz que tomamos a derivada da função externa e a multiplicamos pela derivada da função interna
Uma maneira de expressar a regra da cadeia é como o produto das derivadas. Isso será muito útil à medida que avançamos na retropropagação
Na verdade, um nome melhor para a retropropagação pode ser: Não pare de fazer a regra da cadeia, nunca.

English: 
We'll take advantage of the sum rule in differentiation which says that the derivative of the sums equals the sum of the derivatives.
We can move our sigma (Σ) outside and just worry about the derivative of the inside expression first.
To keep things simple, we'll temporarily forget about our summation.
Once we've computed ∂J/∂W for a single example,
we'll go back and add all our individual derivative terms together
We can now evaluate our first derivative. The power rule tells us to bring down our exponent 2 and multiply.
To finish our derivative we need to apply the chain rule.
The chain rule tells us how to take the derivative of a function inside of a function
and generally says that we take the derivative of the outside function and multiply it by the derivative of the inside function
One way to express the chain rule is as the product of derivatives this will come in very handy as we progress through backpropagation
In fact a better name for backpropagation might be: Don't stop doing the chain rule, ever.

Korean: 
우리는 Sum Rule in Differentiation 을 이용합니다.
"미분의 합은 합의 미분과 같다"는 법칙이죠.
시그마를 밖으로 빼고, 안 쪽에 있는 미분 식에 대해서만 신경써서 계산 하면 된다는 겁니다.
문제를 단순화 하기 위해, 잠시 합치는 것에 대해서는 잊어버립시다.
일단 우리가 하나의 미분식에 대해서 계산을 마치면,  돌아가서 모든 미분항을 합치면 됩니다.
이제 첫 미분항을 계산해보겠습니다.
미분의 Power rule은, 차수인 2를 내려서 계수로 곱하게 해 줍니다.
미분을 마저 끝마치기 위해서, Chain rule을 적용해야 합니다.
Chain 법칙은 함수 안에 들어있는 함수를 어떻게 미분할 지 알려줍니다.
이 법칙에 따르면, 바깥 쪽에 있는 함수를 미분하고, 안 쪽에 있는 함수를 미분하여 곱하면 합성함수를 미분할 수 있다는 겁니다.
Chain Rule을 표현하는 한 가지 방법은, 미분항의 곱입니다.
이렇게 하는 것은 우리가 Back Propagation을 행할 때 매우 편리합니다.
사실상, Back Propagation의 더 나은 이름은 '절대 체인 법칙을 멈추지 마!' 라고도 할 수 있지요.

Portuguese: 
Nós tomamos a derivada externa da nossa função de custo. Agora precisamos multiplicá-lo pela derivada interna.
y é apenas a pontuação do nosso teste que não muda, então a derivada de y, uma constante, com relação a W é zero.
y-chapéu (ŷ), por outro lado, muda em relação a W (2)
Então vamos aplicar a regra da cadeia e multiplicar nossos resultados por menos ∂ŷ / ∂W(2)
Agora precisamos pensar sobre a derivada de ŷ em relação a W(2)
A equação (4) nos diz que ŷ é nossa função de ativação de z(3), então será útil aplicar a regra da cadeia novamente
para quebrar ∂ŷ / ∂W(2) em
∂ŷ / ∂z (3) vezes ∂z(3) / ∂W (2)
para encontrar a taxa de mudança de ŷ em relação a z (3), precisamos diferenciar nossa função de ativação sigmoid
com respeito a z.

Korean: 
우린 Cost Function의 바깥쪽 함수를 미분했습니다.
이제 이것을 안 쪽에 있는 함수의 미분에 곱해야 합니다.
Y는 우리의 시험 점수로서, 바뀌지 않는 상수 값입니다.
따라서 y를 W에 대해 미분하는 것은 0가 되는 것이죠.
반면에 Yhat은 W에 따라 바뀝니다.
따라서 우리는 체인룰을 적용해서 우리의 결과값을 - dyhat/dW2와 곱해야 합니다.
우리는 이제 y hat을 W에 대해 미분한 값이 어떤 것일지 생각해 보아야 합니다.
4번 방정식은 y hat은 z(3)의 activation function임을 알려줍니다.
 

English: 
We've taken the derivative of the outside of our cost function. Now we need to multiply it by the derivative of the inside.
y is just our test scores which won't change so the derivative of y, a constant, with respect to W is zero
y-hat (ŷ), on the other hand, does change with respect to W(2)
So we'll apply the chain rule and multiply our results by minus ∂ŷ/∂W(2)
We now need to think about the derivative of ŷ with respect to W(2)
Equation (4) tells us that ŷ is our activation function of z(3) so it will be helpful to apply the chain rule again
to break ∂ŷ/∂W(2) into
∂ŷ/∂z(3) times ∂z(3)/∂W(2)
to find the rate of change of ŷ with respect to z(3) we need to differentiate our sigmoid activation function
with respect to z

Portuguese: 
Agora é um bom momento para adicionar um novo método Python para nossa derivada de nossa função sigmoid,  sigmoidPrime
Nossa derivada deve ser maior onde a função sigmoid é a mais íngreme, no valor z = 0
agora podemos substituir ∂ŷ / ∂z (3) por f-prime de z(3)
Nossa peça final do quebra-cabeça é ∂z(3) / ∂W(2)
Este termo representa a mudança de z, nossa atividade de terceira camada, com relação aos pesos na segunda camada
z(3) é o produto matricial de nossas atividades a(2) e nossos pesos W(2).
As atividades da camada 2 são multiplicadas pelos pesos correspondentes e somadas para produzir z (3)
Se nos concentrarmos em uma única sinapse por um momento, vemos uma relação linear simples entre W e z, onde "a" é a inclinação.
Então, para cada sinapse, ∂z / ∂W (2) é apenas a ativação "a", nessa sinapse
Outra maneira de pensar sobre o que o cálculo está fazendo aqui é que ele está retropropagando o erro para cada peso

English: 
Now is a good time to add a new Python method for our derivative of our sigmoid function, sigmoidPrime
Our derivative should be largest where sigmoid function is the steepest, at the value z=0
we can now replace ∂ŷ/∂z(3) with f-prime of z(3)
Our final piece of the puzzle is ∂z(3)/∂W(2)
This term represents the change of z, our third layer activity, with respect to the weights in the second layer.
z(3) is the matrix product of our activities a(2) and our weights W(2).
The activities from layer 2 are multiplied by their corresponding weights and added together to yield z(3)
If we focus on a single synapse for a moment, we see a simple linear relationship between W and z where a is the slope.
So for each synapse, ∂z/∂W(2) is just the activation a, on that synapse
Another way to think about what the calculus is doing here is that it is backpropagating the error to each weight.

Portuguese: 
Multiplicando pela atividade em cada sinapse, os pesos que contribuem mais para o erro geral terão ativações maiores,
rendem maiores valores de ∂J / ∂W (2),
e será mais alterado quando realizarmos gradiente de descida.
Precisamos ter cuidado com a nossa dimensionalidade aqui, e se formos espertos, podemos cuidar das somas que nos livramos anteriormente
A primeira parte da nossa equação, y-ŷ, é da mesma dimensão de seus dados de saída, 3x1.
f-prime de z 3 é do mesmo tamanho e nossa primeira operação é uma multiplicação escalar
Nossa matriz 3x1 resultante é referida como erro de retropropagação, δ(3)
Determinamos que ∂z(3) / ∂W(2) é igual à atividade de cada sinapse.
Cada valor em δ(3) precisa ser multiplicado por cada atividade.
Podemos conseguir isso transpondo a(2) e multiplicando a matriz por δ(3)
O que é legal aqui é que a multiplicação de matrizes também cuida da nossa omissão anterior.

English: 
By multiplying by the activity on each synapse, the weights that contribute more to the overall error will have larger activations,
yield larger ∂J/∂W(2) values,
and will be changed more when we perform gradient descent.
We need to be careful with our dimensionality here, and if we're clever, we can take care of that summation we got rid of earlier.
The first part of our equation, y-ŷ, is of the same dimension of their output data, 3x1.
f-prime of z 3 is of the same size and our first operation is a scalar multiplication.
Our resulting 3x1 matrix is referred to as the backpropagating error, δ(3)
We determined that ∂z(3)/∂W(2) is equal to the activity of each synapse.
Each value in δ(3) needs to be multiplied by each activity.
We can achieve this by transposing a(2) and matrix multiplying by δ(3)
What's cool here Is that the matrix multiplication also takes care of our earlier omission.

English: 
It adds up the ∂J/∂W terms across all our examples
Another way to think about what's happening here is that each example our algorithm sees has a certain cost and a certain gradient.
The gradient with respect to each example pulls our gradient descent algorithm in a certain direction.
It's like every example gets a vote on which way is downhill and when we perform batch gradient descent,
we just add together everyone's vote, call it downhill, and move in that direction.
We'll code up our gradients in Python, in a new method, costFunctionPrime
Numpy's .multiply() method performs element-wise multiplication and the .dot() method performs matrix multiplication
We now have one final term to compute, ∂J/∂W(1)
The derivation begins the same way as before, by computing the derivative through our final layer,
first ∂J/∂ŷ, then ∂ŷ/∂z(3).
We now take the derivative across our synapses,

Portuguese: 
Adiciona os termos ∂J / ∂W em todos os nossos exemplos.
Outra maneira de pensar sobre o que está acontecendo aqui é que cada exemplo que nosso algoritmo vê tem um certo custo e um certo gradiente
O gradiente em relação a cada exemplo puxa nosso algoritmo de descida de gradiente em uma determinada direção
É como se todos os exemplos tivessem uma votação sobre o caminho a seguir e quando realizamos a descida gradiente em lote,
nós apenas somamos o voto de todo mundo, chamamos de descida e seguimos nessa direção
Vamos codificar nossos gradientes em Python, em um novo método, costFunctionPrime.
O método .multiply () do Numpy executa a multiplicação por elementos e o método .dot () executa a multiplicação de matrizes.
Agora temos um termo final para calcular, ∂J / ∂W(1)
A derivação começa da mesma forma que antes, calculando a derivada através de nossa camada final,
primeiro ∂J / ∂ŷ, depois ∂ŷ / ∂z(3).
Nós agora tomamos a derivada através de nossas sinapses,

Portuguese: 
o que é um pouco diferente do nosso trabalho da última vez, que estava computando a derivada em relação aos pesos em nossas sinapses.
Ainda há um bom relacionamento linear ao longo de cada sinapse,
mas agora estamos interessados ​​na taxa de mudança de z(3) em relação a um (2)
Agora a inclinação é igual ao valor do peso para aquela sinapse.
Podemos conseguir isso matematicamente pela multiplicação por W(2) transposto
Nosso próximo período para trabalhar é ∂a(2) / ∂z(2).
Este passo é como a derivada em nossos neurônios da camada 3, então podemos apenas multiplicar por f-primo de z(2).
Nossa computação final aqui é ∂z (2) / ∂W(1)
Isto é muito semelhante ao nosso cálculo ∂z(3) / ∂W(2). Existe uma linear simples
relação nas sinapses entre z e W (1). Neste caso, a inclinação é o valor de entrada, x.
Podemos usar a mesma técnica da última vez e multiplicada por x transposto,
efetivamente aplicando o derivado e adicionando nossos ∂J / ∂W (1)s juntos

English: 
which is a little different from our job last time, which was computing the derivative with respect to the weights on our synapses.
There's still a nice linear relationship along each synapse,
but now we're interested in the rate of change of z(3) with respect to a(2)
Now the slope is just equal to the weight value for that synapse.
We can achieve this mathematically by multiplying by W(2) transposed
Our next term to work on is ∂a(2)/∂z(2).
This step is just like the derivative across our layer 3 neurons, so we can just multiply by f-prime of z(2).
Our final computation here is ∂z(2)/∂W(1)
This is very similar to our ∂z(3)/∂W(2) computation. There is a simple linear
relationship on the synapses between z and W(1). In this case though, the slope is the input value, x.
We can use the same technique as last time and multiplied by x transposed,
effectively applying the derivative and adding our ∂J/∂W(1)s together

Portuguese: 
em todos os nossos exemplos. Tudo o que resta é codificar esta equação em Python.
O que é legal aqui é que, se quisermos fazer uma rede neural mais profunda, poderíamos juntar um monte dessas operações em conjunto.
Então, como devemos mudar nossos Ws para diminuir nosso custo?
Agora podemos calcular ∂J / ∂W, que nos informa qual é o caminho mais árduo em nosso espaço de otimização 9-dimensional.
Se nós nos movermos dessa forma adicionando um escalar vezes nossa derivada a todos os nossos pesos,
nosso custo aumentará. E se fizermos o oposto,
subtraindo nosso gradiente de nossos pesos, nos moveremos para baixo e reduziremos nosso custo.
Este simples passo em declive é o núcleo da descida de gradiente
e uma parte fundamental de como até mesmo algoritmos de aprendizado muito sofisticados são treinados.
Na próxima vez, executaremos a verificação numérica de gradiente para garantir que nossa matemática esteja correta.

English: 
across all our examples. All that's left is to code this equation in Python.
What's cool here is that if we want to make a deeper neural network, we could just stack a bunch of these operations together.
So how should we change our Ws to decrease our cost?
We can now compute ∂J/∂W, which tells us which way is uphill in our 9-dimensional optimization space.
If we move this way by adding a scalar times our derivative to all of our weights,
our cost will increase. And if we do the opposite,
subtract our gradient from our weights, we will move downhill and reduce our cost.
This simple step downhill is the core of gradient descent
and a key part of how even very sophisticated learning algorithms are trained.
Next time we'll perform numerical gradient checking to make sure our math is correct.
