当前位置：极客教程 > 机器学习 > 机器学习教程 > 神经网络简介

神经网络简介

神经网络简介,适用于机器学习的初学者，假设你没有任何机器学习的知识。简单解释它们如何工作，以及如何在Python中从头实现一个神经网络。可能会让你大吃一惊的是:神经网络并没有那么复杂!“神经网络”这个词经常被用作流行语，但实际上它们往往比人们想象的要简单得多。

让我们开始吧！

构建块:神经元

首先，我们要讨论神经元，神经网络的基本单位。神经元接受输入，用它们做一些数学运算，然后产生一个输出。这是一个2-input neuron的样子:
神经网络简介

这里发生了三件事。首先，每个输入乘以一个权重:
x_1 \rightarrow x_1 * w_1
x_2 \rightarrow x_2 * w_2

然后将所有加权后的输入与偏置b相加:

x_1 * w_1 + x_2 * w_2 + b
最后，总和通过一个激活函数传递:
y = f(x_1 * w_1 + x_2 * w_2 + b)
激活函数用于将无界输入转换为具有良好的、可预测形式的输出。一个常用的激活函数是sigmoid函数:
神经网络简介

sigmoid函数只输出(0,1)范围内的数字。你可以把(-\infty， +\infty)压缩到(0,1)-大负数变成~0，大正数变成~1。

一个简单的例子
假设我们有一个使用sigmoid激活函数的2-input神经元，其参数如下:
w=[0,1]
b = 4
w=[0,1]是向量形式w_1 = 0,w_2 = 1的一种写法。现在，让神经元输入x = [2,3]。我们用点积来写得更简洁:
(w⋅x)+b =((w1∗x1)+(w2 ∗x 2))+b
=0∗2+1∗3+4
=7
y = f(w \cdot x + b) = f(7) = \boxed{0.999}
给定输入x=[2,3]，神经元输出0.999。就是这样!将输入向前传递以获得输出的过程称为前馈(feedforward)。

编码一个神经元
是时候实现一个神经元了!我们将使用NumPy，一个流行而强大的Python计算库，来帮助我们做数学:

import numpy as np

def sigmoid(x):
  # Our activation function: f(x) = 1 / (1 + e^(-x))
  return 1 / (1 + np.exp(-x))

class Neuron:
  def __init__(self, weights, bias):
    self.weights = weights
    self.bias = bias

  def feedforward(self, inputs):
    # Weight inputs, add bias, then use the activation function
    total = np.dot(self.weights, inputs) + self.bias
    return sigmoid(total)

weights = np.array([0, 1]) # w1 = 0, w2 = 1
bias = 4                   # b = 4
n = Neuron(weights, bias)

x = np.array([2, 3])       # x1 = 2, x2 = 3
print(n.feedforward(x))    # 0.9990889488055994

认识这些数字吗?这就是我们刚才做的例子!得到0.999。

将神经元组合成一个神经网络

神经网络只不过是一群连接在一起的神经元。下面是一个简单的神经网络的样子:
神经网络简介
该网络有2个输入，一个隐含层有2个神经元(h_1和h_2)，一个输出层有1个神经元(o_1)。注意o_1的输入是h_1和h_2的输出——这就是网络的组成。
隐藏层是在输入(第一个)层和输出(最后一个)层之间的任何层。可以有多个隐藏层!

一个例子:前馈
让我们使用上图所示的网络，假设所有的神经元都具有相同的权值w =[0,1]，相同的偏差b = 0，以及相同的sigmoid激活函数。设h_1、h_2、o_1表示它们所表示的神经元的输出。
如果我们输入x =[2,3]会发生什么?
神经网络简介
输入x=[2,3]的神经网络输出为0.7216。很简单,对吧?

一个神经网络可以有任意数量的层，其中包含任意数量的神经元。其基本思想是相同的:通过网络中的神经元向前提供输入，最终得到输出。为了简单起见，我们将在本文的其余部分继续使用上面所示的网络。

神经网络编码:前馈
我们来实现神经网络的前馈。这里是网络的图片，再次供参考:
神经网络简介

import numpy as np

# ... code from previous section here

class OurNeuralNetwork:
  '''
  A neural network with:
    - 2 inputs
    - a hidden layer with 2 neurons (h1, h2)
    - an output layer with 1 neuron (o1)
  Each neuron has the same weights and bias:
    - w = [0, 1]
    - b = 0
  '''
  def __init__(self):
    weights = np.array([0, 1])
    bias = 0

    # The Neuron class here is from the previous section
    self.h1 = Neuron(weights, bias)
    self.h2 = Neuron(weights, bias)
    self.o1 = Neuron(weights, bias)

  def feedforward(self, x):
    out_h1 = self.h1.feedforward(x)
    out_h2 = self.h2.feedforward(x)

    # The inputs for o1 are the outputs from h1 and h2
    out_o1 = self.o1.feedforward(np.array([out_h1, out_h2]))

    return out_o1

network = OurNeuralNetwork()
x = np.array([2, 3])
print(network.feedforward(x)) # 0.7216325609518421

我们得到0.7216 !看起来有用。

训练神经网络，第1部分

假设我们有以下测量值:
神经网络简介
让我们训练我们的网络，根据一个人的体重和身高来预测他的性别:
神经网络简介
我们将用0表示男性，用1表示女性，我们还将改变数据，使其更容易使用:
神经网络简介
随意选择了移位量(135和66)，以使数字看起来很漂亮。一般情况下，你会平移。

损失
在训练我们的网络之前，我们首先需要一种方法来量化它做得有多“好”，这样它就可以尝试做得“更好”。这就是损失。

我们将使用均方误差(MSE)损失:
神经网络简介

让我们来分解一下:

  • n是样本数，也就是4(Alice, Bob, Charlie, Diana)
  • y表示预测的变量，即性别。
  • $$y_{true}$$是变量的真值(“正确答案”)。例如，Alice的$$y_{true}$$为1(女性)。
  • $$y_{pred}$$是变量的预测值。它是我们的网络输出。
  • $$(y_{true} – y_{pred})^2$$被称为平方误差。损失函数只是取所有平方误差的平均值(因此得名均方误差)。我们的预测越好，我们的损失就会越低!

更好的预测=更低的损失。
训练一个网络=尽量减少它的损失。

损失计算实例
假设我们的网络总是输出 0 – 换句话说，它确信所有人类都是男性。我们的损失会是什么?
神经网络简介
代码:MSE损失
下面是一些计算损失的代码:

import numpy as np

def mse_loss(y_true, y_pred):
  # y_true and y_pred are numpy arrays of the same length.
  return ((y_true - y_pred) ** 2).mean()

y_true = np.array([1, 0, 0, 1])
y_pred = np.array([0, 0, 0, 0])

print(mse_loss(y_true, y_pred)) # 0.5

如果不理解这段代码的工作原理，请阅读NumPy quickstart on数组操作。

好了。开始!

训练神经网络，第2部分

我们现在有一个明确的目标:最小化神经网络的损失。我们知道我们可以改变网络的权重和偏差来影响它的预测，但我们如何才能以一种减少损失的方式做到这一点呢?

本节使用一些多变量微积分。如果你对微积分不熟悉，可以跳过数学部分。

为了简单起见，假设我们的数据集中只有Alice:
神经网络简介
那么平均平方误差损失就是Alice的平方误差:
神经网络简介
另一种考虑损失的方法是将损失看作权重和偏差的函数。让我们在我们的网络中标记每个权重和偏差:
神经网络简介

然后，我们可以将损失写成多元函数:
L(w_1,w_2,w_3,w_4,w_5,w_6,b_1,b_2,b_3)
假设我们想调整w_1。如果我们改变w_1，损失L会怎样变化?
这是偏导\frac{∂L}{∂w_1}可以回答的问题。我们怎么计算它?
这就是数学开始变得更加复杂的地方。不要气馁!我建议你带一支笔和一张纸，这样可以帮助你理解。

首先，我们把偏导写成\frac{∂y_{pred}}{∂w_1}的形式:
神经网络简介
因为链式法则所以这样写是有效的。

因为我们先前计算了L=(1-y_{pred})^2,所以我们可以计算\frac{∂L}{∂y_{pred}}:
神经网络简介

现在，我们来看看如何处理\frac{∂y_{pred}}{∂w_1}。就像之前一样，让h_1,h_2,o_1是它们所代表的神经元的输出,此时：
y_{pred}=o_1=f(w_5h_1+w_6h_2+b3)
f是sigmoid激活函数，记得吗?

因为w_1仅仅影响了h_1(而非h_2),所以我们可以这样写：
神经网络简介
更多的链式法则。

我们对\frac{∂h_1}{∂w_1}做同样的事情：
神经网络简介
你猜对了，链式法则。

这里x1是重量，x2是高度。这是我们第二次看到f'(x) (sigmoid函数的导数)了!让我们推导:
神经网络简介

我们稍后会用这个形式来表示f'(x)。
我们完成了!我们已经把\frac{∂L}{∂w_1}分解成几个部分，我们可以计算:
神经网络简介

这种通过逆向计算偏导数的系统称为反向传播，或“backprop”。

唷。有很多符号——如果你仍然有点困惑，也没关系。让我们做一个例子来看看它的实际效果!

例子:计算偏导数
我们将继续假装只有Alice在我们的数据集中:
神经网络简介
让我们初始化所有的权值为1，所有的偏差为0。如果我们做一个前馈通过网络，我们得到:
神经网络简介
网络输出y_{pred} =0.524，这并不强烈支持男性(0)或女性(1)。让我们计算\frac{∂L}{∂w_1}:
神经网络简介
提醒:我们推导了f'(x) = f(x) * (1 – f(x))用于之前的sigmoid激活函数。

我们做到了!这告诉我们，如果我们增加w_1, L会增加一点点。

训练:随机梯度下降
我们现在有了训练神经网络所需的所有工具!我们将使用一种称为随机梯度下降(SGD)的优化算法，它告诉我们如何改变权重和偏差以最小化损失。基本上就是这个更新方程:
神经网络简介
η是一个常数,称为学习速率,用于控制我们训练速度。我们要做的就是从w_1中减去η\frac{∂L}{∂w_1}:

  • 如果\frac{∂L}{∂w_1} 是正的，w_1将减少，那么会导致L也减少;
  • 如果\frac{∂L}{∂w_1} 是负的，w_1将增加，那么会导致L也增加;

如果我们对网络中的每一个权重和偏差都这样做，损失就会慢慢减少，我们的网络就会改善。

我们的训练流程如下:

  • 从数据集中选择一个示例。这就是随机梯度下降的原因——我们一次只对一个样本进行操作。
  • 计算所有损失对权重或偏差的偏导数(例如\frac{∂L}{∂w_1}，\frac{∂L}{∂w_2}，等等)
  • 使用更新方程更新每个权重和偏差。
  • 回到步骤1。

让我们看看它的行动!
代码:一个完整的神经网络
是时候实现一个完整的神经网络了:
神经网络简介
神经网络简介

import numpy as np

def sigmoid(x):
  # Sigmoid activation function: f(x) = 1 / (1 + e^(-x))
  return 1 / (1 + np.exp(-x))

def deriv_sigmoid(x):
  # Derivative of sigmoid: f'(x) = f(x) * (1 - f(x))
  fx = sigmoid(x)
  return fx * (1 - fx)

def mse_loss(y_true, y_pred):
  # y_true and y_pred are numpy arrays of the same length.
  return ((y_true - y_pred) ** 2).mean()

class OurNeuralNetwork:
  '''
  A neural network with:
    - 2 inputs
    - a hidden layer with 2 neurons (h1, h2)
    - an output layer with 1 neuron (o1)

  *** DISCLAIMER ***:
  The code below is intended to be simple and educational, NOT optimal.
  Real neural net code looks nothing like this. DO NOT use this code.
  Instead, read/run it to understand how this specific network works.
  '''
  def __init__(self):
    # Weights
    self.w1 = np.random.normal()
    self.w2 = np.random.normal()
    self.w3 = np.random.normal()
    self.w4 = np.random.normal()
    self.w5 = np.random.normal()
    self.w6 = np.random.normal()

    # Biases
    self.b1 = np.random.normal()
    self.b2 = np.random.normal()
    self.b3 = np.random.normal()

  def feedforward(self, x):
    # x is a numpy array with 2 elements.
    h1 = sigmoid(self.w1 * x[0] + self.w2 * x[1] + self.b1)
    h2 = sigmoid(self.w3 * x[0] + self.w4 * x[1] + self.b2)
    o1 = sigmoid(self.w5 * h1 + self.w6 * h2 + self.b3)
    return o1

  def train(self, data, all_y_trues):
    '''
    - data is a (n x 2) numpy array, n = # of samples in the dataset.
    - all_y_trues is a numpy array with n elements.
      Elements in all_y_trues correspond to those in data.
    '''
    learn_rate = 0.1
    epochs = 1000 # number of times to loop through the entire dataset

    for epoch in range(epochs):
      for x, y_true in zip(data, all_y_trues):
        # --- Do a feedforward (we'll need these values later)
        sum_h1 = self.w1 * x[0] + self.w2 * x[1] + self.b1
        h1 = sigmoid(sum_h1)

        sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2
        h2 = sigmoid(sum_h2)

        sum_o1 = self.w5 * h1 + self.w6 * h2 + self.b3
        o1 = sigmoid(sum_o1)
        y_pred = o1

        # --- Calculate partial derivatives.
        # --- Naming: d_L_d_w1 represents "partial L / partial w1"
        d_L_d_ypred = -2 * (y_true - y_pred)

        # Neuron o1
        d_ypred_d_w5 = h1 * deriv_sigmoid(sum_o1)
        d_ypred_d_w6 = h2 * deriv_sigmoid(sum_o1)
        d_ypred_d_b3 = deriv_sigmoid(sum_o1)

        d_ypred_d_h1 = self.w5 * deriv_sigmoid(sum_o1)
        d_ypred_d_h2 = self.w6 * deriv_sigmoid(sum_o1)

        # Neuron h1
        d_h1_d_w1 = x[0] * deriv_sigmoid(sum_h1)
        d_h1_d_w2 = x[1] * deriv_sigmoid(sum_h1)
        d_h1_d_b1 = deriv_sigmoid(sum_h1)

        # Neuron h2
        d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2)
        d_h2_d_w4 = x[1] * deriv_sigmoid(sum_h2)
        d_h2_d_b2 = deriv_sigmoid(sum_h2)

        # --- Update weights and biases
        # Neuron h1
        self.w1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w1
        self.w2 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w2
        self.b1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_b1

        # Neuron h2
        self.w3 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w3
        self.w4 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w4
        self.b2 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_b2

        # Neuron o1
        self.w5 -= learn_rate * d_L_d_ypred * d_ypred_d_w5
        self.w6 -= learn_rate * d_L_d_ypred * d_ypred_d_w6
        self.b3 -= learn_rate * d_L_d_ypred * d_ypred_d_b3

      # --- Calculate total loss at the end of each epoch
      if epoch % 10 == 0:
        y_preds = np.apply_along_axis(self.feedforward, 1, data)
        loss = mse_loss(all_y_trues, y_preds)
        print("Epoch %d loss: %.3f" % (epoch, loss))

# Define dataset
data = np.array([
  [-2, -1],  # Alice
  [25, 6],   # Bob
  [17, 4],   # Charlie
  [-15, -6], # Diana
])
all_y_trues = np.array([
  1, # Alice
  0, # Bob
  0, # Charlie
  1, # Diana
])

# Train our neural network!
network = OurNeuralNetwork()
network.train(data, all_y_trues)

在 Github上可以找到完整代码.
随着网络的训练学到更多，我们的损失逐渐减少:
神经网络简介
我们现在可以用这个网络来预测性别:

# Make some predictions
emily = np.array([-7, -3]) # 128 pounds, 63 inches
frank = np.array([20, 2])  # 155 pounds, 68 inches
print("Emily: %.3f" % network.feedforward(emily)) # 0.951 - F
print("Frank: %.3f" % network.feedforward(frank)) # 0.039 - M

现在怎么办呢?
你成功了!快速回顾一下我们所做的:

  • 介绍了神经元，神经网络的组成部分。
  • 在我们的神经元中使用sigmoid激活功能。
  • 看到神经网络只是连接在一起的神经元。
  • 创建一个数据集，将体重和身高作为输入(或特性)，性别作为输出(或标签)。
  • 学习了损失函数和均方误差损失。
  • 意识到培训一个网络只是把它的损失降到最低。
  • 使用反向传播计算偏导数。
  • 利用随机梯度下降法(SGD)对网络进行训练。

Thanks for reading!

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

机器学习教程