深度学习在花椒直播的应用:原理篇

栏目: 数据库 · 发布时间: 5年前

内容简介:TensorFlow是Google在2015年开源的深度学习框架,是目前最主流的深度学习计算框架。代码库本身有高达100万+的代码量,分为前端代码和后端代码。如此庞大的代码量造成了很多人不理解TensorFlow到底如何工作。为此,GitHub上有个名为TensorSlow的项目,使用纯Python的方式重构了TensorFlow底层。该项目旨在帮助理解TensorFlow的工作机制而不在意效率,所以取名TensorSlow。本文就以TensorSlow项目为基础,向大家梳理一下TensorFlow底层到底

深度学习的应用

花椒直播的深度学习使用

  • 使用Spark进行数据清洗,构建用户画像和物品画像,挖掘数据特征,形成数据集存储在HDFS。
  • 使用TensorFlow作为深度学习计算框架,通过Hbox调度深度学习作业,使用集群分布式训练。训练模型使用TF Serving部署,封装成TF-Web对内提供预测接口,线上使用Go Server提供推荐服务。

深度学习在花椒直播的应用:原理篇

TensorFlow和TensorSlow

TensorFlow是Google在2015年开源的深度学习框架,是目前最主流的深度学习计算框架。代码库本身有高达100万+的代码量,分为前端代码和后端代码。如此庞大的代码量造成了很多人不理解TensorFlow到底如何工作。

为此,GitHub上有个名为TensorSlow的项目,使用纯 Python 的方式重构了TensorFlow底层。该项目旨在帮助理解TensorFlow的工作机制而不在意效率,所以取名TensorSlow。本文就以TensorSlow项目为基础,向大家梳理一下TensorFlow底层到底干了哪些事,对理解深度学习框架底层原理大有裨益。

深度学习简介

深度学习是机器学习的重要分支,是为了研究深层神经网络的结构和有效训练而演化来的一系列方法。

神经网络

概念:常见的深度模型使用的是前馈神经网络(多层感知机),它使用一个映射函数:

深度学习在花椒直播的应用:原理篇

来定义模型,其中为输入,θ为模型参数。由于模型函数可以和一个有向无环图(DAG)等价,所以被称为网络。

隐藏层:映射函数通常是多层的复合函数,例如:

深度学习在花椒直播的应用:原理篇

输入x是输入层,中间函数对应于隐藏层,输出y是输出层。

代价函数:衡量模型函数和数据集之间的距离的函数(最大似然)。它是模型参数θ的函数,记为J(θ)。

梯度下降:选择模型参数能使代价函数J(θ)最小化的优化方法。以梯度下降为代表的一系列优化方法,通过向参数θ的负梯度方向迭代,来寻找最优的参数θ。

数量级:参数的数量通常有几十万到数百亿不等。

深度学习在花椒直播的应用:原理篇

前向传播

当神经网络接收到输入层x后,经过网络不断向前流动,经过每一个隐藏层,最后传播到输出层y的过程,称为前向传播。在监督学习中,通常输出层y还会进一步得到代价函数J(θ)。

反向传播

从代价函数J(θ)出发,经过网络向后流动,传播到每一个参数上,计算出J(θ)对该参数θ的梯度的过程,称为方向传播。之后,可以通过梯度下降等优化方法,得到模型的最优参数。

TensorFlow做了什么?

计算图(Computational Graph)

深度学习模型的落地离不开计算图,计算图可以认为是深度模型的描述语言,是神经网络计算的函数描述。计算图被定义为有向图(DAG),其中的节点对应于变量。通过计算图,可以方便的表达复杂计算。

深度学习在花椒直播的应用:原理篇

上面的图例展示了一个简单的计算图,它对应于这么一个仿射变换:

深度学习在花椒直播的应用:原理篇

其中x是输入节点,A,b 是模型参数。

节点(Vertex)

在计算图中,节点用来表示一个变量。节点的输入和输出称为Tensor(它可以是标量,向量,矩阵或者更高维的)。根据输入输出的不同,节点可以分为以下三类:

Placeholder节点:整个计算图的输入节点。节点只有输出值,传递给它的子节点consumers。

class placeholder:



def __init__(self):



    self.consumers = []



    _default_graph.placeholders.append(self)

Variable节点:计算图中表示模型参数的节点。Variable节点拥有初始值value,将输出传递给它的子节点consumers。

class Variable:



def __init__(self, initial_value = None):



    self.value = initial_value

    self.consumers = []



    _default_graph.variables.append(self)

Operation节点:使用Variable节点或Placeholder节点来组成简单的函数,可以通过复合Operation节点来建立复杂网络。它具有输入和输出,输入由父节点input_nodes传递,输出传递到子节点consumers中。而compute方法需要继承,用来表述Operation节点所表示的函数计算。

class Operation:



def __init__(self, input_nodes=[]):

    self.input_nodes = input_nodes



    self.consumers = []



    for input_node in input_nodes:

        input_node.consumers.append(self)



    _default_graph.operations.append(self)



def compute(self):

    pass

Addition Operation的具体写法:

class add(Operation):



def __init__(self, x, y):

    super().__init__([x, y])



def compute(self, x_value, y_value):

    self.inputs = [x_value, y_value]

    return x_value + y_value

图(Graph)

使用一个Graph类来绑定计算图中的所有节点(opeartions、placeholders和varaibles)。当创建新的graph的时候,可以调用as_default方法来设置为这张图的_default_graph,这样不用显式地将节点绑定到图中。

class Graph:



def __init__(self):

    """Construct Graph"""

    self.operations = []

    self.placeholders = []

    self.variables = []



def as_default(self):

    global _default_graph

    _default_graph = self

会话(Session)

完成了图定义,如何执行图?在TensorFlow中,通过定义Session实例,Client将计算图传递给后端,通过Session.run方法传递给master执行。

计算图的输出是特定的Operation节点。而输出节点的计算依赖其他中间节点,必须保证operations是按拓扑顺序执行的,计算节点o之前,节点o的所有输入节点已经完成计算。比如,要计算z节点必须先计算出中间节点y。这里通过反向的后序遍历来完成拓扑排序。类似的,Session可以这么定义:

class Session:



def run(self, operation, feed_dict = {}):

    """Computes the output of an operation

    """

    ...





def traverse_postorder(operation):



nodes_postorder = []

def recurse(node):

    if isinstance(node, Operation):

        for input_node in node.input_nodes:

            recurse(input_node)

    nodes_postorder.append(node)



recurse(operation)

return nodes_postorder

session.run方法首先对节点进行拓扑排序,并根据 排序 结果依次计算节点输出,完成图的执行。

前向传递算法

再回顾这张计算图:

深度学习在花椒直播的应用:原理篇

它对应的放射变换可以用线性变换的方式写出,可以通过之前定义的代码完成前向传递的计算。

深度学习在花椒直播的应用:原理篇

# Create a new graph

Graph().as_default()



# Create variables

A = Variable([[1, 0], [0, -1]])

b = Variable([1, 1])



# Create placeholder

x = placeholder()



# Create hidden node y

y = matmul(A, x)



# Create output node z

z = add(y, b)



session = Session()

output = session.run(z, {x: [1, 2]})

print(output)

可以得到结果:

[ 2 -1]

构建损失函数

深度学习中,分类任务通常使用交叉熵作为损失函数,它的公式如下:

深度学习在花椒直播的应用:原理篇

其中c是数据集中的真实分类标签。损失函数的Operation节点J由许多基础Operation来构建。将输入和参数向量化,并添加节点J,改写后的计算图如下:

深度学习在花椒直播的应用:原理篇

# Create a new graph

Graph().as_default()



X = placeholder()

c = placeholder()



W = Variable([[1, -1],

          [1, -1]])

b = Variable([0, 0])

p = softmax( add(matmul(X, W), b) )



# Cross-entropy loss

J = negative(reduce_sum(reduce_sum(multiply(c, log(p)), axis=1)))



session = Session()

print(session.run(J, {

X: np.concatenate((blue_points, red_points)),

c:

    [[1, 0]] * len(blue_points)

    + [[0, 1]] * len(red_points)}))

梯度下降优化算法

通过使用梯度下降方法来最小化代价函数,流程如下:

  1. 模型参数W和b设置随机初始值。
  2. 计算代价函数J对W和b的梯度。
  3. 分别在其负梯度的方向上下降一小步(使用learning_rate控制步长大小)。
  4. 回到步骤2,继续执行。
class GradientDescentOptimizer:



def __init__(self, learning_rate):

    self.learning_rate = learning_rate



def minimize(self, loss):

    learning_rate = self.learning_rate



    class MinimizationOperation(Operation):

        def compute(self):

            # Compute gradients

            grad_table = compute_gradients(loss)



            for node in grad_table:

                if type(node) == Variable:

                    grad = grad_table[node]

                    node.value -= learning_rate * grad



    return MinimizationOperation()

compute_gradients函数通过反向传递算法计算梯度,grad_table字典存放了代价函数J节点对计算图中所有variable节点的当前梯度。

反向传递算法

链式法则是计算梯度的基本法则。下图和公式显示了e对a的梯度计算:

深度学习在花椒直播的应用:原理篇

深度学习在花椒直播的应用:原理篇

反向传递的算法用链式法则来计算节点n的梯度:

  1. J节点自身的梯度为1。
  2. 对任意节点z的所有子节点consumer,计算子节点的梯度。
  3. 将子节点的梯度乘以节点z本身的梯度得到J节点对任意节点z的梯度。

按照这种方式,直到反向传递到节点n。如果节点J经过多个路径方向传递到该节点,那么对该节点来自不同路径的梯度求和。

compute_gradients方法从J节点开始,使用BFS的方式执行上面的流程。它会先计算所有子节点的梯度,然后计算当前节点的梯度,直到传递到输出节点。

from queue import Queue



def compute_gradients(loss):



# grad_table[node] will contain the gradient of the loss w.r.t. the node's output



...

return grad_table

节点自身的梯度

Operation的自身梯度通过预先定义,使用RegisterGradient注册到全局变量_gradient_registry中。以sigmoid函数为例:

@RegisterGradient("sigmoid")

def _sigmoid_gradient(op, grad):



sigmoid = op.output



return grad * sigmoid * (1-sigmoid)

实践:搭建MLP

MLP是经典的神经网络,在深度学习中广泛使用。MLP由多个节点层组成,每一层全连接到下一层。除了输入节点,每个节点都是一个带有非线性激活函数的神经元。下面构建了一个含有3个隐层的MLP来进行分类任务:

深度学习在花椒直播的应用:原理篇

# Create a new graph

ts.Graph().as_default()



# Create training input placeholder

X = ts.placeholder()



# Create placeholder for the training classes

c = ts.placeholder()



# Build a hidden layer

W_hidden1 = ts.Variable(np.random.randn(2, 4))

b_hidden1 = ts.Variable(np.random.randn(4))

p_hidden1 = ts.sigmoid(ts.add(ts.matmul(X, W_hidden1), b_hidden1))



# Build a hidden layer

W_hidden2 = ts.Variable(np.random.randn(4, 8))

b_hidden2 = ts.Variable(np.random.randn(8))

p_hidden2 = ts.sigmoid(ts.add(ts.matmul(p_hidden1, W_hidden2), b_hidden2))



# Build a hidden layer

W_hidden3 = ts.Variable(np.random.randn(8, 2))

b_hidden3 = ts.Variable(np.random.randn(2))

p_hidden3 = ts.sigmoid(ts.add(ts.matmul(p_hidden2, W_hidden3), b_hidden3))



# Build the output layer

W_output = ts.Variable(np.random.randn(2, 2))

b_output = ts.Variable(np.random.randn(2))

p_output = ts.softmax(ts.add(ts.matmul(p_hidden3, W_output), b_output))



# Build cross-entropy loss

J = ts.negative(ts.reduce_sum(ts.reduce_sum(ts.multiply(c, ts.log(p_output)), axis=1)))



# Build minimization op

minimization_op = ts.train.GradientDescentOptimizer(learning_rate=0.03).minimize(J)



# Build placeholder inputs

feed_dict = {

X: np.concatenate((blue_points, red_points)),

c:

    [[1, 0]] * len(blue_points)

    + [[0, 1]] * len(red_points)



}



# Create session

session = ts.Session()



# Perform 100 gradient descent steps

for step in range(2000):

J_value = session.run(J, feed_dict)

if step % 100 == 0:

    print("Step:", step, " Loss:", J_value)

session.run(minimization_op, feed_dict)

通过可视化决策边界,可以发现模型学习到了比较复杂的非线性关系。

深度学习在花椒直播的应用:原理篇

联系TensorFlow

  1. TensorSlow简单深刻的展示了深度学习框架底层的一般原理,加深理解生产使用的TensorFlow。
  2. TensorFlow后端使用C++高效实现。
  3. TensroFlow优化了算法过程,比如公共表达式消除,常量折叠。
  4. TensorFlow支持分布式,支持GPU等硬件设备。
  5. TensorFlow提供生产化的一系列工具。

主要参考资料

原文链接: https://mp.weixin.qq.com/s/HBMcddlq-QIp691mdPUebg


以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

Single Page Web Applications

Single Page Web Applications

Michael Mikowski、Josh Powell / Manning Publications / 2013-9-30 / USD 44.99

Code for most web sites mostly runs on the server. When a user clicks on a link, the site reacts slowly because the browser sends information to the server and the server sends it back again before di......一起来看看 《Single Page Web Applications》 这本书的介绍吧!

XML、JSON 在线转换
XML、JSON 在线转换

在线XML、JSON转换工具

Markdown 在线编辑器
Markdown 在线编辑器

Markdown 在线编辑器

RGB HSV 转换
RGB HSV 转换

RGB HSV 互转工具