深度学习算法部分

深度学习其实我学的懵懵懂懂的，确切来说，还是不会占大多数，但是百度看别人的算法，能大概理解是什么意思，说到底，深度学习还是基于算法，常见的算法大概有这些：最小二乘法    梯度下降    线性回归    感知机    人工神经网络    深度神经网络.

下面用python语言来解释这些算法：

声明：部分内容借阅微信公众号“大数据与机器学习文摘”

最小二乘法：

 所有的深度学习算法都始于下面这个数学公式

# y = mx + b

# m is slope, b is y-intercept

 

def compute_error_for_line_given_points(b, m, coordinates):

    totalError = 0

    for i in range(0, len(coordinates)):

        x = coordinates[i][0]

        y = coordinates[i][1]

        totalError += (y - (m * x + b)) ** 2

    return totalError / float(len(coordinates))

# example

compute_error_for_line_given_points(1, 2, [[3,6],[6,9],[12,18]])

深度学习的核心思想：给定输入值和期望的输出值，然后寻找两者之间的相关性。

梯度下降：

current_x = 0.5 # the algorithm starts at x=0.5

learning_rate = 0.01 # step size multiplier

num_iterations = 60 # the number of times to train the function

 

#the derivative of the error function (x**4 = the power of 4 or x^4)

def slope_at_given_x_value(x):

  return 5 * x**4 - 6 * x**2

 

# Move X to the right or left depending on the slope of the error function

for i in range(num_iterations):

  previous_x = current_x

  current_x += -learning_rate * slope_at_given_x_value(previous_x)

  print(previous_x)

 

print("The local minimum occurs at %f" % current_x)

这里的窍门在于 learning_rate。我们通过沿斜率的相反方向行进来逼近最低点。此外，越接近最低点，斜率越小。因此当斜率接近零时，每一步下降的幅度会越来越小。

num_iterations 是你预计到达最小值之前所需的迭代次数。可以通过调试该参数训练自己关于梯度下降算法的直觉。

线性回归

 最小二乘法配合梯度下降算法，就是一个完整的线性回归过程。在 20 世纪 50 年代和 60 年代，一批实验经济学家在早期的计算机上实现了这些想法。这个过程是通过实体打卡 —— 真正的手工软件程序实现的。准备这些打孔卡就需要几天的时间，而通过计算机进行一次回归分析最多需要 24 小时。

下面是用 Python 实现线性回归的一个示例（我们不需要在打卡机上完成这个操作）：

#Price of wheat/kg and the average price of bread

wheat_and_bread = [[0.5,5],[0.6,5.5],[0.8,6],[1.1,6.8],[1.4,7]]

 

def step_gradient(b_current, m_current, points, learningRate):

    b_gradient = 0

    m_gradient = 0

    N = float(len(points))

    for i in range(0, len(points)):

        x = points[i][0]

        y = points[i][1]

        b_gradient += -(2/N) * (y - ((m_current * x) + b_current))

        m_gradient += -(2/N) * x * (y - ((m_current * x) + b_current))

    new_b = b_current - (learningRate * b_gradient)

    new_m = m_current - (learningRate * m_gradient)

    return [new_b, new_m]

 

def gradient_descent_runner(points, starting_b, starting_m, learning_rate, num_iterations):

    b = starting_b

    m = starting_m

    for i in range(num_iterations):

        b, m = step_gradient(b, m, points, learning_rate)

    return [b, m]

 

gradient_descent_runner(wheat_and_bread, 1, 1, 0.01, 100)

线性回归本身并没有引入什么新的内容。但是，如何将梯度下降算法运用到误差函数上就需要动动脑子了。运行代码并使用这个线性回归模拟器来加深你的理解吧。

感知机

我们用经典的“或”逻辑来运行感知机。

下面是用 Python 实现的感知机模型：

from random import choice

from numpy import array, dot, random

1_or_0 = lambda x: 0 if x < 0 else 1

training_data = [ (array([0,0,1]), 0),

                    (array([0,1,1]), 1),

                    (array([1,0,1]), 1),

                    (array([1,1,1]), 1), ]

weights = random.rand(3)

errors = []

learning_rate = 0.2

num_iterations = 100

 

for i in range(num_iterations):

    input, truth = choice(training_data)

    result = dot(weights, input)

    error = truth - 1_or_0(result)

    errors.append(error)

    weights += learning_rate * error * input

   

for x, _ in training_data:

    result = dot(x, w)

    print("{}: {} -> {}".format(input[:2], result, 1_or_0(result)))

 

人工神经网络

学习这段代码之前，我们首先通过这个模拟器交互学习一到两个小时来掌握神经网络的核心逻辑。

import numpy as np

 

X_XOR = np.array([[0,0,1], [0,1,1], [1,0,1],[1,1,1]])

y_truth = np.array([[0],[1],[1],[0]])

 

np.random.seed(1)

syn_0 = 2*np.random.random((3,4)) - 1

syn_1 = 2*np.random.random((4,1)) - 1

 

def sigmoid(x):

    output = 1/(1+np.exp(-x))

    return output

def sigmoid_output_to_derivative(output):

    return output*(1-output)

 

for j in range(60000):

    layer_1 = sigmoid(np.dot(X_XOR, syn_0))

    layer_2 = sigmoid(np.dot(layer_1, syn_1))

    error = layer_2 - y_truth

    layer_2_delta = error * sigmoid_output_to_derivative(layer_2)

    layer_1_error = layer_2_delta.dot(syn_1.T)

    layer_1_delta = layer_1_error * sigmoid_output_to_derivative(layer_1)

    syn_1 -= layer_1.T.dot(layer_2_delta)

    syn_0 -= X_XOR.T.dot(layer_1_delta)

   

print("Output After Training: n", layer_2)

反向传播，矩阵乘法和梯度下降放在一起会让人很难理解。这个过程的可视化通常是对其背后原理的简化。专注于理解其背后的逻辑，但不要过多地考虑直觉上的理解。

另外，读者们也可以看看 Andrew Karpathy 关于反向传播的课程，在这个可视化网站交互学习，以及阅读 Michael Nielsen 关于反向传播的章节。

深度神经网络

深度神经网络就是在输入层和输出层之间具有多个中间层的神经网络。这个概念最早是由 Rina Dechter (Dechter, 1986) 引入的，但在2012年，也就是在 IBM 的人工智能程序 Watson 赢得美国电视智力竞赛节目 Jeopardy 和 Google 推出猫咪识别器之后才受到广泛关注。

GPU > Nvidia Tesla K80。该硬件常用于图形处理。它们深度学习的速度平均要比 CPU 快50-200倍。

CUDA > GPU 的底层编程语言

CuDNN > Nvidia 的库，用来优化 CUDA

Tensorflow > 由 Google 开发，基于 CuDNN 的深度学习框架

TFlearn > Tensorflow 的前端框架

下面我们来看看 MNIST 数字分类图像，它被称作深度学习的 “Hello World”。

 

我们用 TFlearn 来实现：

from __future__ import division, print_function, absolute_import

import tflearn

from tflearn.layers.core import dropout, fully_connected

from tensorflow.examples.tutorials.mnist import input_data

from tflearn.layers.conv import conv_2d, max_pool_2d

from tflearn.layers.normalization import local_response_normalization

from tflearn.layers.estimator import regression

 

# Data loading and preprocessing

mnist = input_data.read_data_sets("/data/", one_hot=True)

X, Y, testX, testY = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels

X = X.reshape([-1, 28, 28, 1])

testX = testX.reshape([-1, 28, 28, 1])

 

# Building convolutional network

network = tflearn.input_data(shape=[None, 28, 28, 1], name='input')

network = conv_2d(network, 32, 3, activation='relu', regularizer="L2")

network = max_pool_2d(network, 2)

network = local_response_normalization(network)

network = conv_2d(network, 64, 3, activation='relu', regularizer="L2")

network = max_pool_2d(network, 2)

network = local_response_normalization(network)

network = fully_connected(network, 128, activation='tanh')

network = dropout(network, 0.8)

network = fully_connected(network, 256, activation='tanh')

network = dropout(network, 0.8)

network = fully_connected(network, 10, activation='softmax')

network = regression(network, optimizer='adam', learning_rate=0.01,

                        loss='categorical_crossentropy', name='target')

 

# Training

model = tflearn.DNN(network, tensorboard_verbose=0)

model.fit({'input': X}, {'target': Y}, n_epoch=20,

            validation_set=({'input': testX}, {'target': testY}),

            snapshot_step=100, show_metric=True, run_id='convnet_mnist')