
Chinese: 
人类如何学习？
尽管世事变迁，观念总是相同——
相比于我们的物理身体，信息长久不变
存储在我们的大脑中，
并且可以代代传承。
我们的大脑有能力
综合各种各样的输入信息——
我们称之为五感，然后利用
它们创造了一个概念层次结构。
如果你够幸运，
可以一边学习技能，一边
由老师手把手监督。
我们在环境活动时，
可以感受到我们的环境
感受到我们身边的障碍物并
尝试预测下一步。
如果我们首先尝试并且
失败，没关系。
通过审判过程
错误，我们可以学到任何东西。
那么到底是什么赋予了我们大脑这种能力
而不像别的较低级生物呢？
我们所经历的一切、
我们所有感受到的想法和记忆，
以及我们的自我认知，
都是由大脑产生的。
在分子水平上，
我们的大脑由大约
十亿个称为神经元的神经细胞组成。
每个神经元有三个任务，
01.接收来自树突的一组信号

Portuguese: 
Como podemos aprender?
Embora os tempos possam mudar, alguns conceitos permanecem os mesmos.
Inalterável, a informação supera o corpo.
É armazenado em nosso cérebro,
Mas pode ser transmitida de geração em geração.
Nosso cérebro é capaz de sintetizar o conjunto diversificado de
Entradas que chamamos nossos cinco sentidos, e deles, criando uma hierarquia de conceitos.
Se tivermos sorte,
Podemos aprender uma tarefa enquanto supervisionamos diretamente um professor.
Ao interagir com o nosso ambiente, podemos sentir o nosso entorno,
veja nossos obstáculos e
tentar prever os próximos passos.
Se tentarmos de primeira e falhar , esta tudo bem.
Através do processo de tentar e
errar, podemos aprender alguma coisa.
Mas o que é que dá ao nosso
cérebro essa capacidade especial
Ao contrário de qualquer outra coisa na natureza?
Tudo o que já experimentei ou
sentimos, todos os nossos pensamentos e memórias,
o nosso próprio sentido ,
é produzido pelo cérebro.
Ao nível molecular,
nosso cérebro consiste em um número estimado de 100
bilhões de células nervosas chamadas neurônios.
Cada neurônio tem três empregos,
receber um conjunto de sinais de
que são chamados de seus dendritos.

English: 
How do we learn?
Although times may change,
some concepts stay the same.
Unchanging, information
outlasts the body.
It's stored in our brain,
but can be passed down from
generation to generation.
Our brain is capable of
synthesizing the diverse set of
inputs we call our five senses, and from
them, creating a hierarchy of concepts.
If we're lucky,
we can learn a task while being
supervised by a teacher directly.
While interacting with our environment,
we can feel our surroundings,
see our obstacles and
try to predict the next steps.
If we try at first and
fail, that's okay.
Through the process of trial and
error, we can learn anything.
But what is it that gives our
brain this special capability
unlike anything else in nature?
Everything we've ever experienced or
felt, all our thoughts and memories,
our very sense of self,
is produced by the brain.
At the molecular level,
our brain consists of an estimated 100
billion nerve cells called neurons.
Each neuron has three jobs,
receive a set of signals from
what are called its dendrites.

English: 
Integrate those signals together
to determine whether or
not the information should be passed
on in the cell body, or soma.
And then if the sum of the signals
passes a certain threshold,
send this resulting signal,
called the action potential,
onwards via its axon to
the next set of neurons.
Hello world.
It's Siraj, and we're going to build
our own neural network in Python.
The rules that govern the brain
give rise to intelligence.
It's the same algorithm that invented
modern language, space flight,
Shia LaBeouf.
It's what makes us, us.
It's what allowed us to survive and
thrive on planet Earth.
But as far as we've come as a species,
we still face a host of existential
threats to our existence.
There's the impending
threat of climate change,
the possibility of biochemical warfare,
an asteroid impact.
These are nontrivial problems that could
take our biological neural networks
many generations to solve.
But what if we could harness this power,
what if we could create an artificial
neural network, and have it run on
a non-biological substrate like silicon?

Portuguese: 
Integrar os sinais juntos
para determinar se ou
não a informação deve ser passada
no corpo da célula, ou soma.
E então, se a soma dos sinais
ultrapassa um certo limiar,
enviar este sinal resultante,
chamado de potencial de ação,
em diante, através do seu axónio para
o próximo conjunto de neurónios.
Olá Mundo.
É Siraj, e nós estamos indo para construir
nossa própria rede neural em Python.
As regras que governam o cérebro
dar origem a inteligência.
É o mesmo algoritmo que inventou
linguagem moderna, voo espacial,
Shia LaBeouf.
É o que nos faz, nós.
É o que nos permitiu sobreviver e
prosperam no planeta Terra.
Mas, tanto quanto nós viemos como uma espécie,
continuamos a enfrentar uma série de existencial
ameaças à nossa existência.
Há a iminente
ameaça da mudança climática,
a possibilidade de guerra bioquímica,
impacto de um asteróide.
Estes são problemas não triviais que poderiam
tomar as nossas redes neurais biológicas
muitas gerações para resolver.
Mas o que se poderia aproveitar este poder,
e se pudéssemos criar um artificial
rede neural, e tê-lo executado em
um substrato não-biológica como o silício?

Chinese: 
02.将这些信号集结
以确定信息是否该向体细胞传递或者丢弃
 
03.如果信号的总和
达到一定阈值
发送这个称为动作电位的结果信号，
通过它的轴突向前
下一组神经元。
大家好
我是Siraj，我们将在Python中建造
我们的神经网络——
正是由它来管理大脑的规则
并引起情报。
这与发明
现代语言，太空飞行，
Shia LaBeouf的算法相同
我们也因此被塑造为我们自己
这也是我们能够生存下去
在地球上生生不息的原因
但就我们作为物种而言，
我们仍然面临着一系列存在主义
威胁到我们的存在。
有即将到来的
气候变化威胁，
生化战争，
小行星的影响……
通过我们几代人在生物神经网络上的努力研究，
这些问题可能得以解决
但是如果我们能够驾驭这种力量，
如果我们可以创建一个人造神经网络
并让它运行，
它是否可以在硅基生物中运行？

Portuguese: 
Poderíamos dar-lhe mais poder de computação
e dados do que qualquer um ser humano seria
capaz de manusear, e
tê-lo a resolver problemas de mil, ou
até um milhão de vezes mais rápido
do que poderíamos sozinhos.
Em 1943, dois primeiros computadores
cientistas chamado Warren McCulloch e
Walter Pitts inventou o primeiro
modelo computacional de um neurônio.
Seu modelo demonstrou um neurônio que
entradas binárias recebidas, resumiu-los, e
se a soma excedeu um certo
valor de limiar, a saída de um 1.
Se não, a saída de um 0.
Era um modelo simples.
Mas nos primeiros dias de AI,
este foi um grande negócio, e
tem cientistas da computação falando
sobre as possibilidades.
Alguns anos mais tarde, um psicólogo chamado
Frank Rosenblatt foi frustrado que
o modelo de McCulloch-Pitts ainda
faltava o mecanismo para a aprendizagem.
Então, ele concebeu um modelo neural
que construiu em sua ideia
que ele chamou de Perceptron,
que é uma outra palavra para
uma única camada de realimentação
rede neural.
Chamamos-lhe feedforward porque os dados
simplesmente flui em uma direção, para a frente.
O Perceptron incorporada
a idéia de pesos nas entradas.
Assim, dado um conjunto de treinamento
de exemplos de entrada-saída,

Chinese: 
我们可以给它比任何一个人都多的计算能力和数据
它是否能解决问题，或者
甚至比我们能一个人快一百万倍？
1943年，两台早期的电脑
科学家们命名为沃伦麦卡洛克和
沃尔特皮茨发明了第一个
神经元的计算模型。
他们的模型展示了一个神经元
接收到二进制输入，然后将它们相加
如果总和超过一定
阈值，则输出1。
如果不是，则输出0。
这是一个简单的模型。
但在人工智能的早期，
这是一桩大事，
它让计算机科学家谈论
其可实现性。
几年后，一位叫做
弗兰克罗森布拉特的心理学家沮丧地宣布
McCulloch-Pitts模型仍然
缺乏学习机制。
所以他基于他们的想法构思了一个神经模型
他称之为Perceptron，
这是另一个用来描述
单层前馈神经网络的专有名词。
我们称之为前馈，因为数据
只是向一个方向流动，向前。
感知器合并
对输入的权重的想法。
所以，给定一些
带由输入输出示例的训练集，

English: 
We could give it more computing power
and data than any one human would be
capable of handling, and
have it solve problems a thousand, or
even a million times faster
than we could alone.
In 1943, two early computer
scientists named Warren McCulloch and
Walter Pitts invented the first
computational model of a neuron.
Their model demonstrated a neuron that
received binary inputs, summed them, and
if the sum exceeded a certain
threshold value, output a 1.
If not, output a 0.
It was a simple model.
But in the early days of AI,
this was a big deal, and
got computer scientists talking
about the possibilities.
A few years later, a psychologist named
Frank Rosenblatt was frustrated that
the McCulloch-Pitts model still
lacked the mechanism for learning.
So he conceived a neural model
that built on their idea
which he called the Perceptron,
which is another word for
a single layer feedforward
neural network.
We call it feedforward because the data
just flows in one direction, forward.
The Perceptron incorporated
the idea of weights on the inputs.
So, given some training set
of input output examples,

Chinese: 
它应该不断通过为每个例子，从中学习一个函数
——增加或减少权重取决于它的输出
这些权值从算法中
重新应用于输入，
这样在每次迭代之后，
产出预测变得更加准确。
为了更好地理解我们所说的这个过程
培训，让我们在Python中建立自己的
多层神经网络
只使用Numpy作为我们的依赖包。
在我们的main函数中，我们将首先
初始化我们的神经网络，
这将在后面定义
作为自己的Class。
然后打印出它的起始权重
作为我们演示它时的参考。
我们现在可以定义我们的数据集。
我们有四个训练样本
每个样本都有三个输入值和
一个输出值，
仅仅由0 1两种取值（有监督分类问题）
T函数转置矩阵
从水平到垂直。
所以电脑正在储存
这样的数字→
我们将训练我们的神经
网络上的这些值如此
给出一个新的零和零列表，
它将能够预测是否或
不是输出应该是一个或零。
因为我们正在识别
它属于哪个类别，
这被认为是一种分类
机器学习任务。

English: 
it should learn a function from it by
increasing or decreasing the weights
continuously for each example,
depending on what its output was.
These weight values are mathematically
applied to the input,
such that after each iteration, the
output prediction gets more accurate.
To best understand this process we call
training, let’s build our own single
layer neural network in Python
using only Numpy as our dependency.
In our main function, we'll first
initialize our neural network,
which w'ell later define
as its own class.
Then print out its starting weights for
a reference when we demo it.
We can now define our data set.
We've got four examples.
Each example has three input values and
one output value.
They're all ones and zeros.
The T function transposes the matrix
from horizontal to vertical.
So the computer is storing
the numbers like this.
We'll train our neural
network on these values so
that given a new list of ones and zeros,
it'll be able to predict whether or
not the output should be a one or zero.
Since we are identifying
which category it belongs to,
this is considered a classification
task in machine learning.

Portuguese: 
ele deve aprender uma função dele por
aumentando ou diminuindo os pesos
continuamente para cada exemplo,
dependendo do que sua saída era.
Estes valores de peso são matematicamente
aplicado à entrada,
de tal modo que depois de cada iteração, a
previsão de saída fica mais preciso.
Para melhor compreender esse processo chamamos
formação, vamos construir o nosso próprio única
camada de rede neural em Python
usando apenas Numpy como a nossa dependência.
Em nossa função principal, vamos primeiro
inicializar nossa rede neural,
que w'ell depois definir
como a sua própria classe.
Em seguida, imprimir os seus pesos de partida para a
uma referência quando demonstrar isso.
Agora podemos definir o nosso conjunto de dados.
Nós temos quatro exemplos.
Cada exemplo tem três valores de entrada e
um valor de saída.
São todos uns e zeros.
A função t transpõe a matriz
a partir da horizontal para a vertical.
Assim, o computador está armazenando
os números como este.
Nós vamos treinar nosso neural
rede sobre esses valores tão
que deu uma nova lista de zeros e uns,
ele vai ser capaz de prever se ou
não a saída deve ser um ou zero.
Uma vez que estamos identificando
qual a categoria a que pertence,
esta é considerada uma classificação
tarefa na aprendizagem de máquina.

Portuguese: 
Vamos treinar nossa rede nesses dados
usando-os como argumentos para o nosso trem
função, bem como um número, 10000,
que é a quantidade de vezes que tinha
gostaria de fazer uma iteração durante o treinamento.
Depois que é feito o treinamento,
vamos imprimir os pesos atualizados assim
podemos compará-los e, finalmente, vamos
prever a saída dada uma nova entrada.
Nós temos a nossa função principal pronto, por isso
vamos agora definir a nossa
classe rede neural.
Quando inicializar a classe, o primeiro
coisa que queremos fazer é semear ele.
Vamos inicializar nossos valores de peso
aleatoriamente numa segunda, e semeando-
garante que ele gera o mesmo
números cada vez que o programa é executado.
Isso é útil para depuração mais tarde.
Vamos atribuir pesos aleatórios para um período de três
por uma matriz com valores no intervalo
de -1 para um com uma média de 0.
Desde o nosso único neurônio tem três entradas
conexões e uma ligação de saída.
Em seguida, vamos escrever a nossa activação
função, que, no nosso caso,
será um sigmóide.
Ele descreve uma curva em forma de s.
Passamos a soma ponderada
das entradas através dele,
e vai convertê-los para
uma probabilidade entre 0 e 1.
Esta probabilidade será
ajudar a tornar a nossa previsão.

English: 
We'll train our network on this data
by using them as arguments to our train
function, as well as a number, 10,000,
which is the amount of times we'd
like to iterate during training.
After it's done training,
we'll print out the updated weights so
we can compare them, and finally, we'll
predict the output given a new input.
We've got our main function ready, so
let's now define our
NeuralNetwork class.
When we initialize the class, the first
thing we want to do is seed it.
We'll initialize our weight values
randomly in a second, and seeding them
makes sure that it generates the same
numbers every time the program runs.
This is useful for debugging later on.
We'll assign random weights to a three
by one matrix with values in the range
of -1 to 1 with a mean of 0.
Since our single neuron has three input
connections and one output connection.
Next we'll write out our activation
function, which, in our case,
will be a sigmoid.
It describes an s shaped curve.
We pass the weighted sum
of the inputs through it,
and it will convert them to
a probability between 0 and 1.
This probability will
help make our prediction.

Chinese: 
我们将在这些数据上训练我们的网络
用它们作为我们训练的参数
功能，以及一个数字，10,000，
这是我们的时间量
喜欢在训练中迭代。
完成训练后，
我们将打印出更新的权重
我们可以比较他们，最后，我们会
预测给定新输入的输出。
我们已经准备好了我们的主要功能，所以
让我们现在定义我们的
NeuralNetwork类。
当我们初始化Class时，第一个
我们想要做的就是撒随机种子。
我们将在一秒钟内初始化我们的权重值
确保它产生相同的结果
每次程序运行时编号。
这对于稍后的调试很有用。
由于我们的单个神经元有三个输入
连接和一个输出连接,
我们将通过生成一个随机值的矩阵赋予三个权重, [-1,1)范围内,均值为0
 
接下来我们将写出我们的激活
函数，在本例中，
将是一个sigmoid函数
它描述了一个s形曲线。
我们通过将 w1*a + w2*b +w3*c之后，由 Sigmoid 作用，
它会将它们转换为
0到1之间的概率。
这个概率会
帮助做出我们的预测。

Chinese: 
我们将使用我们的sigmoid函数
直接作用在我们的predict函数中，
它将输入作为参数和
通过他们通过我们的神经元。
为了得到我们输入的加权和，
我们将
我们的输入空间和权重计算点乘（dot）
这便是我们的突触权重控制数据在神经网中流动的方法
通过这一函数，我们将得到我们的预测结果{[0,1]之间的某个数，代表这一性征的有/无 }
现在我们可以写出我们的train函数，
这是我们本次代码的真正灵魂。入参
[训练Input，训练Output，迭代次数]
我们将编写一个for循环来迭代
正如我们指定的那样，
然后使用我们的train函数来传递权值网与Input的作用
并获得输出值，
这就是我们的预测。
接下来我们将计算本回合偏差，
这是两者之间
期望的输出和我们的预测输出的差值
要想error在我们训练时最小化
我们会通过迭代来做到这一点
更新我们的权重。
通过计算Input 与 Sigmoid函数梯度的点积再放大Error倍
我们得到了本次反馈对突触权重的调整值
 
这样差得多的权值会调整得多，差得少的权值几乎不调整
0分量的输入不会对这一过程作用
这个过程被称为梯度下降。
>>是的，我正在降梯度！

English: 
We'll use our sigmoid function
directly in our predict function,
which takes inputs as parameters and
passes them through our neuron.
To get the weighted sum of our inputs,
we'll compute the dot product
of our inputs and our weights.
This is how our weights govern
the attention of how data flows in our
neural net, and this function
will return our prediction.
Now we can write out our train function,
which is the real meat of our code.
We'll write a for loop to iterate
10,000 times, as we specified,
then use our predict function to pass
the training set through the network and
get the output value,
which is our prediction.
We'll next calculate the error,
which is the difference between the
desired output and our predicted output.
We want to minimize
this error as we train,
and we'll do this by iteratively
updating our weights.
We'll calculate the necessary adjustment
by computing the dot product of our
input's transpose and
the error, multiplied by
the gradient of the sigmoid curve.
So less confident weights
are adjusted more, and
inputs that are zero don't
cause changes to the weights.
This process is called gradient descent.
>> Yeah, I'm descending that gradient!

Portuguese: 
Vamos usar nossa função sigmóide
diretamente em nossa prever função,
que leva insumos como parâmetros e
passa-los através do nosso neurônio.
Para obter a soma ponderada dos nossos entradas,
vamos calcular o produto escalar
dos nossos entradas e nossos pesos.
Esta é a forma como os nossos pesos governar
a atenção de como os dados fluem em nossa
rede neural, e esta função
vai voltar a nossa previsão.
Agora podemos escrever a nossa função de trem,
que é a carne real do nosso código.
Vamos escrever um loop for para iterar
10.000 vezes, como especificado,
em seguida, usar o nosso predizer a função de passar
o conjunto de treinamento através da rede e
obter o valor de saída,
que é a nossa previsão.
Vamos próximo calcular o erro,
que é a diferença entre o
saída desejada e a saída previsto.
Queremos minimizar
este erro como nós treinamos,
e nós vamos fazer isso de forma iterativa
atualizando nossos pesos.
Vamos calcular o ajuste necessário
calculando o produto do ponto de nossa
transposição de entrada e
o erro, multiplicado pela
o gradiente da curva sigmóide.
pesos de modo menos confiantes
são ajustadas mais, e
inputs que são zero não fazer
causar alterações dos pesos.
Este processo é chamado de gradiente descendente.
>> Sim, eu estou descendo esse gradiente!

English: 
>> We'll also write out the function
that calculates the derivative
of our sigmoid,
which gives us its gradient, or slope.
This measures how confident we are of
the existing weight value, and
helps us update our prediction
in the right direction.
Finally, once we have our adjustment,
we'll update our weights
with that value.
This process of propagating our
error value back into our network,
to adjust our weights,
is called back propagation.
Let's demo this baby in Terminal.
Because the training set is so small,
it took milliseconds to train it.
We can see that our weight
values updated themselves after
all those iterations.
And when we fed it a novel input,
it predicted that the output
was very likely a one.
We just made our first neural network,
from scratch!
Anyways, about backpropagation, I-
[MUSIC]

Chinese: 
>>我们也会写出这个功能
计算导数
我们的sigmoid，
这给了我们它的梯度，或斜率。
这表明我们
当前权值的合适程度的
并帮助我们沿正确的方向更新我们的预测
最后，一旦我们有了我们的调整，
我们会用这个偏差更新（累加到）上回合权值中
这个一播过程
将偏差值返回到我们的网络中，
调整我们的权重，
被称为反向传播。
让我们在终端中运行这个小可爱
由于训练集非常小，
训练它需要只几毫秒的时间。
我们可以看到我们的权值在1000次迭代之后的终值
所有这些迭代。
当我们给它一个新的输入时，
它预测了输出的可能值
我们只做了我们的第一个神经网络，
从头开始！
无论如何，关于反向传播，I-
[音乐]

Portuguese: 
>> Também vamos escrever a função
que calcula o derivado
do nosso sigmóide,
o que nos dá a sua inclinação ou declive.
Este mede o quão confiantes estamos de
o valor do peso existente, e
ajuda-nos a actualizar a nossa previsão
na direção certa.
Finalmente, uma vez que temos o nosso ajuste,
vamos atualizar nossos pesos
com esse valor.
Este processo de propagar nossa
valor de erro de volta para nossa rede,
para ajustar as nossas pesos,
é chamado de propagação de volta.
Vamos demonstrar este bebê no Terminal.
Porque o conjunto de treinamento é tão pequena,
levou milissegundos para treiná-lo.
Podemos ver que o nosso peso
próprios valores atualizados depois
todas essas iterações.
E quando alimentou uma entrada nova,
previu que a saída
era muito provável um.
Nós apenas fizemos nossa primeira rede neural,
do princípio!
De qualquer forma, cerca de backpropagation, I-
[MÚSICA]

English: 
So as dope as Rosenblatt's idea was,
in the decades following it,
neural networks didn't really give
us any kind of noteworthy results.
They could only
accomplish simple things.
But as the World Wide Web
grew from a CERN project
to the massive nervous system for
humanity that it is today,
we've seen an explosion in data and
computing power.
And a small group of researchers
funded by the Canadian government
held fast to their belief in
the power of neural networks
to help us find
solutions from this data.
When they took a neural net and made
it not one or two but many layers deep.
Gave it a huge data set and lots of
computing power, they discovered it
could outperform humans in tasks
that we thought only we could do.
This is profound.

Chinese: 
就像罗森布拉特的想法那样，
在接下来的几十年里，
神经网络并没有真正给予
我们有什么值得注意的结果。
他们只能
完成简单的事情。
但作为万维网
从CERN项目发展而来
以大量的神经系统为代价
它是今天的人类，
我们已经看到数据和数据的爆炸式增长
计算能力。
还有一小组研究人员
由加拿大政府资助
坚持自己的信念
神经网络的力量
帮助我们找到
这些数据的解决方案。
当他们拿了一个神经网络，并做出
它不是一两个，而是很多层。
给它一个庞大的数据集和很多
计算能力，他们发现了它
在任务上可以胜过人类
我们认为只有我们能做到。
这是深刻的。

Portuguese: 
Assim como drogas como a idéia de Rosenblatt foi,
nas décadas que se lhe segue,
redes neurais não realmente dar
-nos qualquer tipo de resultados notáveis.
Eles só poderia
realizar coisas simples.
Mas, como a World Wide Web
cresceu a partir de um projeto CERN
para o sistema nervoso enorme para
humanidade que é hoje,
temos visto uma explosão de dados e
poder de computação.
E um pequeno grupo de pesquisadores
financiado pelo governo canadense
manteve firme à sua crença em
o poder das redes neurais
para nos ajudar a encontrar
soluções a partir desses dados.
Quando tomaram uma rede neural e fez
não uma ou duas, mas muitas camadas de profundidade.
Deu-lhe um enorme conjunto de dados e um monte de
poder de computação, eles descobriram que
poderia superar os seres humanos em tarefas
que pensamos que pudéssemos fazer.
Isso é profundo.

Portuguese: 
Nossa rede neural biológica é
eletroquímicas à base de carbono, enviando,
como a acetilcolina, o glutamato,
e serotonina, como sinais.
Uma rede neural artificial não faz
sequer existe no espaço físico.
É um conceito que abstrato
programaticamente criado, e
é representado em transistores de silício.
No entanto, apesar da diferença completa
em meios, ambos desenvolvidos
um mecanismo muito semelhante para transformação
informações, e os resultados mostram isso.
Talvez haja uma lei de inteligência
codificado em nosso universo, e
nós estamos chegando cada vez mais perto de encontrá-lo.
Então, para quebrá-lo para baixo, uma rede neural é
um algoritmo biologicamente inspirado que
aprende a identificar padrões em dados.
backpropagation é
uma técnica popular para
treinar uma rede neural continuamente
actualização pesos através de gradiente descendente.
E quando nós treinamos uma camada muito profunda
rede neural em lotes de dados,
usando lotes de poder de computação,
nós chamamos isso de aprendizado profundo processo.
O vencedor do desafio de codificação para
na semana passada é Ludo Bouan.
Ludo fez uma ipython realmente liso
notebook para demonstrar a repressão não apenas em 2D,
mas regressão 3D, bem como sobre
uma base de dados de mudança climática definido.
Assistente da semana.

English: 
Our biological neural network is
carbon-based, sending electrochemicals,
like acetylcholine, glutamate,
and serotonin, as signals.
An artificial neural network doesn't
even exist in physical space.
It's an abstract concept we
programmatically created, and
it's represented on silicon transistors.
Yet despite the complete difference
in mediums, they both developed
a very similar mechanism for processing
information, and the results show that.
Perhaps there's a law of intelligence
encoded into our universe, and
we're coming ever closer to finding it.
So to break it down, a neural network is
a biologically inspired algorithm that
learns to identify patterns in data.
Backpropagation is
a popular technique to
train a neural network by continually
updating weights via gradient descent.
And when we train a many layer deep
neural network on lots of data,
using lots of computing power,
we call this process deep learning.
The coding challenge winner for
last week is Ludo Bouan.
Ludo made a really slick iPython
notebook to demo not just 2D repression,
but 3D regression as well on
a climate change data set.
Wizard of the week.

Chinese: 
我们的生物神经网络是
碳基，发送电化学，
如乙酰胆碱，谷氨酸盐，
和血清素，作为信号。
人工神经网络没有
甚至存在于物理空间中。
这是一个抽象的概念，我们
以编程方式创建，并且
它代表硅晶体管。
尽管在媒介上完全不同
，但结果表明
他们都演化出了一个非常类似的处理机制
信息，
也许有一个智力规律
编码到我们的宇宙，
而我们正在接近寻找它。
打断一下，神经网络是
一种生物启发式算法
学习识别数据中的模式。
反向传播是
一种流行的技术
不断训练神经网络
通过梯度下降更新权重。
当我们训练很多层时
神经网络上的大量数据，
使用大量的计算能力，
我们称这个过程为深度学习。
编码挑战获胜者
上周是卢多布恩。
鲁多通过Ipython notebook，完成了一个2D回归，
和3D回归以及
一个气候变化数据集的线性回归
本周精灵。

Chinese: 
亚军是Amanullah Tariq。
他完成了作业
效果很好。
本期的挑战是仅仅使用numpy
创造一个不只一个、两个，
而是三层前馈
神经网络。
发布您的GitHub链接
在评论和
我会在一周内宣布获胜者。
请订阅，现在，我已经有了
更新我的体重，
非常感谢观看。

English: 
And the runner up is Amanullah Tariq.
He completed the bonus
with great results.
The challenge for this video is
to create a not one, not two,
but three layer feedforward
neural network using just numpy.
Post your GitHub link
in the comments and
I'll announce the winner in one week.
Please subscribe, and for now, I've got
to update my weights, so thanks for
watching.

Portuguese: 
E o segundo colocado é Amanullah Tariq.
Ele completou o bônus
com excelentes resultados.
O desafio para este vídeo é
para criar um não um, não dois,
mas realimentação de três camadas
rede neural usando apenas numpy.
Postar seu link GitHub
nos comentários e
Vou anunciar o vencedor em uma semana.
Por favor, assine e, por enquanto, eu tenho
para atualizar meus pesos, por isso obrigado por
assistindo.
