张倩 思源 晓坤参与easy-tensorflow来源

从框架优缺点说起,这是一份TensorFlow入门极简教程

随着 TensorFlow 在研究及产品中的应用日益广泛,很多开发者及研究者都希望能深入学习这一深度学习框架。而在昨天机器之心发起的框架投票中,2144 位参与者中有 1441 位都在使用 TensorFlow 框架,是所有框架中使用率最高的。但 TensorFlow 这种静态计算图有一定的学习成本,因此也阻挡了很多准备入坑的初学者。本文介绍了学习 TensorFlow 的系列教程,旨在通过简单的理论与实践帮助初学者一步步掌握 TensorFlow 的编程技巧。

这一系列教程分为 6 部分,从为什么选择 TensorFlow 到卷积神经网络的实现,介绍了初学者所需要的技能。机器之心在本文介绍了 PyTorch 和 Caffe 等深度学习框架的优缺点及 TensorFlow 基础,包括静态计算图、张量TensorBoard 可视化和模型参数的保存等。

教程地址:http://www.easy-tensorflow.com

机器之心此前也介绍过很多 TensorFlow 的学习资源,读者可结合这些资源阅读该系列教程:

为什么选择 TensorFlow?

在本文中,我们将对比当前最流行的深度学习框架(包括 Caffe、Theano、PyTorch、TensorFlow 和 Keras),帮助你为应用选择最合适的框架。

1. Caffe:第一个主流产品级深度学习库,于 2014 年由 UC Berkeley 启动。

优点:

  • 快速

  • 支持 GPU

  • 漂亮的 Matlab 和 Python 接口

缺点:

  • 不灵活。在 Caffe 中,每个节点被当做一个层,因此如果你想要一种新的层类型,你需要定义完整的前向、后向和梯度更新过程。这些层是网络的构建模块,你需要在无穷无尽的列表中进行选择。(相反,在 TensorFlow 中,每个节点被当做一个张量运算例如矩阵相加、相乘或卷积。你可以轻易地定义一个层作为这些运算的组合。因此 TensorFlow 的构建模块更小巧,允许更灵活的模块化。)

  • 需要大量的非必要冗长代码。如果你希望同时支持 CPU 和 GPU,你需要为每一个实现额外的函数。你还需要使用普通的文本编辑器来定义你的模型。真令人头疼!几乎每个人都希望程序化地定义模型,因为这有利于不同组件之间的模块化。有趣的是,Caffe 的主要架构师现在在 TensorFlow 团队工作。

  • 专一性。仅定位在计算机视觉(但做得很不错)。

  • 不是以 Python 编写!如果你希望引入新的变动,你需要在 C++ 和 CUDA 上编程(对于更小的变动,你可以使用它的 Python 和 Matlab 接口)。

  • 糟糕的文档。

  • 安装比较困难!有大量的依赖包。

  • 只有少量种类的输入格式,仅有一种输出格式 HDF5(虽然你总是可以使用它的 Python/C++/Matlab 接口来运行,并从中得到输出数据)。

  • 不适用于构建循环网络。

2. Theano:由蒙特利尔大学研究团队构建。Theano 的顶层构建了数值开源深度库,包括 Keras、Lasagne 和 Blocks。Yoshua Bengio 在 2017 年 9 月 28 日宣布,Theano 的开发将终止。因此实际上 Theano 已死!

优点:

  • 计算图的抽象很漂亮(可媲美 TensorFlow)

  • 为 CPU 和 GPU 都做了优化

  • 很好地适应数值优化任务

  • 高级封装(Keras、Lasagne)

缺点:

  • 原始的 Theano 只有比较低级的 API

import numpy
           for _ in range(T):
               h = torch.matmul(W, h) + b
  • 大型模型可能需要很长的编译时间

  • 不支持多 GPU

  • 错误信息可能没有帮助(有时候令人懊恼)

3. Pytorch:2017 年 1 月,Facebook 将 Python 版本的 Torch 库(用 Lua 编写)开源。

优点:

  • 提供动态计算图(意味着图是在运行时生成的),允许你处理可变长度的输入和输出,例如,在使用 RNN 时非常有用。

  • 另一个例子是,在 PyTorch 中,可以使用标准 Python 语法编写 for 循环语句。

  • 大量预训练模型

  • 大量易于组合的模块化组件

  • 易于编写自己的图层类型,易于在 GPU 上运行

  • TensorBoard」缺少一些关键功能时,「Losswise」可以作为 Pytorch 的替代品

缺点:

  • 正式文档以外的参考资料 / 资源有限

  • 无商业支持

4. TensorFlow: 由较低级别的符号计算库(如 Theano)与较高级别的网络规范库(如 Blocks 和 Lasagne)组合而成。

优点:

  • 由谷歌开发、维护,因此可以保障支持、开发的持续性。

  • 巨大、活跃的社区

  • 网络训练的低级、高级接口

  • TensorBoard」是一款强大的可视化套件,旨在跟踪网络拓扑和性能,使调试更加简单。

  • 用 Python 编写(尽管某些对性能有重要影响的部分是用 C++ 实现的),这是一种颇具可读性的开发语言

  • 支持多 GPU。因此可以在不同的计算机上自由运行代码,而不必停止或重新启动程序

  • 比基于 Theano 的选项更快的模型编译

  • 编译时间比 Theano 短

  • TensorFlow 不仅支持深度学习,还有支持强化学习和其他算法的工具。

缺点:

  • 计算图是纯 Python 的,因此速度较慢

  • 图构造是静态的,意味着图必须先被「编译」再运行

5. Keras:Keras 是一个更高级、对用户最友好的 API,具有可配置的后端,由 Google Brain 团队成员 Francis Chollet 编写和维护。

优点:

  • 提供高级 API 来构建深度学习模型,使其易于阅读和使用

  • 编写规范的文档

  • 大型、活跃的社区

  • 位于其他深度学习库(如 Theano 和 TensorFlow,可配置)之上

  • 使用面向对象的设计,因此所有内容都被视为对象(如网络层、参数优化器等)。所有模型参数都可以作为对象属性进行访问。

例如:

  • model.layers[3].output 将提供模型的第三层

  • model.layers[3].weights 是符号权重张量的列表

缺点:

  • 由于用途非常普遍,所以在性能方面比较欠缺

  • TensorFlow 后端配合使用时会出现性能问题(因为并未针对其进行优化),但与 Theano 后端配合使用时效果良好

  • 不像 TensorFlow 或 PyTorch 那样灵活

TensorFlow 基础

TensorFlow 是一种采用数据流图(data flow graphs),用于数值计算的开源软件库。其中 Tensor 代表传递的数据为张量(多维数组),Flow 代表使用计算图进行运算。数据流图用「节点」(nodes)和「边」(edges)组成的有向图来描述数学运算。「节点」一般用来表示施加的数学操作,但也可以表示数据输入的起点和输出的终点,或者是读取 / 写入持久变量(persistent variable)的终点。边表示节点之间的输入 / 输出关系。这些数据边可以传送维度可动态调整的多维数据数组,即张量(tensor)。

计算图与会话

学习 TensorFlow 的第一步是了解它的主要特色——「计算图」方法。基本上所有的TensorFlow 代码都包含两个重要部分:

1. 创建「计算图」,表示计算的数据流

2. 运行「会话」,执行图中的运算

事实上,TensorFlow 将计算的定义与其执行分开。这两个部分将在以下各节中详细说明。在此之前,请记住第一步是导入 TensorFlow !

import tensorflow as tf

这样,Python 就可以访问 TensorFlow 的所有类、方法和符号。使用此命令,TensorFlow 库将在别名「tf」下导入,以便以后我们可以使用它而不必每次键入其全称「TensorFlow」。

1. 计算图

TensorFlow 的创意中的最大创意是数值计算被表达成计算图。换种说法,任何 TensorFlow 程序的骨干都是一个计算图。正如 TensorFlow 官网上提及的,「一个计算图是被组织到图节点上的一系列 TensorFlow 运算」。

首先,什么是节点和运算?最好的解释方式是,举个例子。假设我们为函数「f(x,y)=x^2y+y+2」编写代码。TensorFlow 中的计算图如下所示:

图 2:TensorFlow 构建的计算图。

如上图所示,计算图有一系列由边互相连接的节点构成。每个节点称为 op,即 operation(运算)的缩写。因此每个节点代表一个运算,可能是张量运算或生成张量的操作。每个节点以零或更多张量为输入,并生成一个张量作为输出。

现在我们来构建一个简单的计算图。

import tensorflow as tf
a = 2
b = 3
c = tf.add(a, b, name='Add')
print(c)
______________________________________________________
Tensor("Add:0", shape=(), dtype=int32)

生成的计算图和变量为:

图 3:左:生成的图在 Tensorboard 中可视化;右:生成的变量(在 debug 模式下运行时从 PyCharm 调试器获取的屏幕截图)

为了实际评估节点,必须在会话内运行计算图。简言之,编写的代码只生成仅仅用来确定张量的预期大小以及对它们执行的运算的图。但是,它不会为任何张量赋值。

因此,TensorFlow Graph 类似于 Python 中的函数定义。它「不会」为你执行任何计算(就像函数定义不会有任何执行结果一样)。它「仅」定义计算操作。

2. 会话(Session)

TensorFlow 中,所有不同的变量和运算都是储存在计算图。所以在我们构建完模型所需要的图之后,还需要打开一个会话(Session)来运行整个计算图。在会话中,我们可以将所有计算分配到可用的 CPU 和 GPU 资源中。举个简单的例子,运行计算图并获取 c 的值:

sess = tf.Session()
print(sess.run(c))
sess.close()
__________________________________________
5

这些代码创建了一个 Session() 对象(分配到 sess),然后(第二行)调用它的运行方法来运行足够的计算图以评估 c。计算完毕后需要关闭会话来帮助系统回收资源,不然就会出现资源泄漏的问题。

TensorFlow 张量

import tensorflow as tf

TensorFlow 中最基本的单位是常量(Constant)、变量(Variable)和占位符(Placeholder)。常量定义后值和维度不可变,变量定义后值可变而维度不可变。在神经网络中,变量一般可作为储存权重和其他信息的矩阵,而常量可作为储存超参数或其他结构信息的变量。

1. 常量

创建一个节点取常数值,它接收以下的变量:

tf.constant(value, dtype=None, shape=None, name='Const', verify_shape=False)

我们来创建两个常量并将它们加起来。常量张量可以通过定义一个值来简单地定义:

# create graph
a = tf.constant(2)
b = tf.constant(3)
c = a + b
# launch the graph in a session
with tf.Session() as sess:
    print(sess.run(c))
____________________________________________________
5    

现在我们来看看创建的计算图和生成的数据类型:

2. 变量

变量是状态性的节点,输出的是它们当前的值,意味着它们可以在一个计算图的多次执行中保留它们的值。它们有一系列的有用特征,例如:

它们可以在训练期间或训练后保存到硬盘上。这允许来自不同公司和团队的人们保存、恢复和发送他们的模型参数给别人。

默认情况下,梯度更新(在所有神经网络中应用)将应用到计算图中的所有变量。实际上,变量是你希望调整以最小化损失函数的东西。

为了创建变量,你可以按如下方式使用 tf.Variable:

# Create a variable.
w = tf.Variable(<initial-value>, name=<optional-name>)

以下语句声明一个 2 行 3 列的变量矩阵,该变量的值服从标准差为 1 的正态分布,并随机生成。

w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))

TensorFlow 还有 tf.truncated_normal() 函数,即截断正态分布随机数,它只保留 [mean-2*stddev,mean+2*stddev] 范围内的随机数。

调用 tf.Variable 来创建一个变量是一种老方法。TensorFlow 推荐使用封装器 tf.get_variable,它能接收命名、形状等参数

tf.get_variable(name,
                shape=None,
                dtype=None,
                initializer=None,
                regularizer=None,
                trainable=True,
                collections=None,
                caching_device=None,
                partitioner=None,
                validate_shape=True,
                use_resource=None,
                custom_getter=None,
                constraint=None)

变量在使用前需要初始化。为此,我们必须调用「变量初始值设定项操作」,并在 session 上运行该操作。

a = tf.get_variable(name="var_1", initializer=tf.constant(2))
b = tf.get_variable(name="var_2", initializer=tf.constant(3))
c = tf.add(a, b, name="Add1")

# launch the graph in a session
with tf.Session() as sess:
    # now let's evaluate their value
    print(sess.run(a))
    print(sess.run(b))
    print(sess.run(c))

3. 占位符

我们已经创建了各种形式的常量和变量,但 TensorFlow 同样还支持占位符。占位符并没有初始值,它只会分配必要的内存。在会话中,占位符可以使用 feed_dict 馈送数据。

feed_dict 是一个字典,在字典中需要给出每一个用到的占位符的取值。在训练神经网络时需要每次提供一个批量的训练样本,如果每次迭代选取的数据要通过常量表示,那么 TensorFlow 的计算图会非常大。因为每增加一个常量,TensorFlow 都会在计算图中增加一个节点。所以说拥有几百万次迭代的神经网络会拥有极其庞大的计算图,而占位符却可以解决这一点,它只会拥有占位符这一个节点。

a = tf.constant([5, 5, 5], tf.float32, name='A')
b = tf.placeholder(tf.float32, shape=[3], name='B')
c = tf.add(a, b, name="Add")

with tf.Session() as sess:
    # create a dictionary:
    d = {b: [1, 2, 3]}
    # feed it to the placeholder
    print(sess.run(c, feed_dict=d)) 
 ___________________________________________________
 [6. 7. 8.]

它生成的计算图与变量如下所示:

现在,我们已经能创建一个简单的神经网络。如下利用随机生成的数据创建了一个三层全连接网络:

import tensorflow as tf
from numpy.random import RandomState

batch_size=10
w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))

# None 可以根据batch 大小确定维度,在shape的一个维度上使用None
x=tf.placeholder(tf.float32,shape=(None,2))
y=tf.placeholder(tf.float32,shape=(None,1))

#激活函数使用ReLU
a=tf.nn.relu(tf.matmul(x,w1))
yhat=tf.nn.relu(tf.matmul(a,w2))

#定义交叉熵损失函数,训练过程使用Adam算法最小化交叉熵
cross_entropy=-tf.reduce_mean(y*tf.log(tf.clip_by_value(yhat,1e-10,1.0)))
train_step=tf.train.AdamOptimizer(0.001).minimize(cross_entropy)

rdm=RandomState(1)
data_size=516

#生成两个特征,共data_size个样本
X=rdm.rand(data_size,2)
#定义规则给出样本标签,所有x1+x2<1的样本认为是正样本,其他为负样本。Y,1为正样本
Y = [[int(x1+x2 < 1)] for (x1, x2) in X]

with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    print(sess.run(w1))
    print(sess.run(w2))
    steps=11000
    for i in range(steps):

        #选定每一个批量读取的首尾位置,确保在1个epoch内采样训练
        start = i * batch_size % data_size
        end = min(start + batch_size,data_size)
        sess.run(train_step,feed_dict={x:X[start:end],y:Y[start:end]})
        if i % 1000 == 0:
            training_loss= sess.run(cross_entropy,feed_dict={x:X,y:Y})
            print("在迭代 %d 次后,训练损失为 %g"%(i,training_loss))

上面的代码定义了一个简单的三层全连接网络(输入层、隐藏层和输出层分别为 2、3 和 2 个神经元),隐藏层和输出层的激活函数使用的是 ReLU 函数。该模型训练的样本总数为 512,每次迭代读取的批量为 10。这个简单的全连接网络以交叉熵损失函数,并使用 Adam 优化算法进行权重更新。

其中需要注意的几个函数如 tf.nn.relu() 代表调用 ReLU 激活函数,tf.matmul() 为矩阵乘法等。tf.clip_by_value(yhat,1e-10,1.0) 这一语句代表的是截断 yhat 的值,因为这一语句是嵌套在 tf.log() 函数内的,所以我们需要确保 yhat 的取值不会导致对数无穷大。

TensorBoard 基础

TensorBoard 是一个可视化软件,在所有的 TensorFlow 标准安装中都包含了 TensorBoard。按谷歌的话说:「使用 TensorFlow 执行的计算,例如训练一个大规模深度神经网络,可能复杂且令人困惑。为了更加容易理解、调试和优化 TensorFlow 程序,我们内置了一套可视化工具,即 TensorBoard。」

TensorFlow 程序既能解决非常简单也能解决非常复杂的问题,它们都有两种基本组件——运算和张量。如前所述,你创建了一个由一系列运算构成的模型,馈送数据到模型上,张量将在运算之间流动,直到得到了输出张量,即你的结果。

完全配置好后,TensorBoard 窗口将呈现与下图类似的画面:

TensorBoard 的创建是为了帮助你了解模型中张量的流动,以便调试和优化模型。它通常用于两项任务:

1. 图形可视化

2. 编写摘要(或可视化学习)

在本教程中,我们将介绍 TensorBoard 的上述两项主要用法。尽早学习使用 TensorBoard,可以让使用 TensorFlow 的工作更有趣也更有成效。

1. 计算图可视化

强大的 TensorFlow 计算图会变得极其复杂。可视化图形有助于理解并对其进行调试。这是一个在 TensorFlow 网站工作的可视化示例。

为了激活 TensorFlow 程序 TensorBoard,需要向其中添加几行代码。这将把 TensorFlow 运算导出到一个名为「event file」(或 event log file)的文件中。TensorBoard 能够读取此文件并深入了解模型图及其性能。

现在我们来编写一个简单的 TensorFlow 程序,并用 TensorBoard 可视化其计算图。先创建两个常量并将其添加到一起。常数张量可以简单地通过定义它们的值来定义:

import tensorflow as tf

# create graph
a = tf.constant(2)
b = tf.constant(3)
c = tf.add(a, b)
# launch the graph in a session
with tf.Session() as sess:
    print(sess.run(c))
_____________________________________________
5 

为了用 TensorBoard 可视化程序,我们需要编写程序的日志文件。为了编写事件文件,我们首先需要为那些日志编写一个 writer,使用以下代码:

writer = tf.summary.FileWriter([logdir], [graph])

其中 [logdir] 是你想要保存那些日志文件的文件夹。你可以选择 [logdir] 作为某些有意义的东西,例如『./graphs』。第二个参数 [graph] 是我们正在编写的程序的计算图。有两种获取计算图的方法:

1. 使用 tf.get_default_graph() 调用计算图,返回程序的默认计算图

2. 将计算图设置为 sess.graph,返回会话的计算图(注意这里需要我们已经创建了会话)

我们将在以下的例子中展示两种方法。然而,第二种方法更加常用。不管用哪种方法,确保仅当你定义了计算图之后才创建一个 writer。否则,TensorBoard 中可视化的计算图将是不完整的。让我们添加 writer 到第一个例子中并可视化计算图。

import tensorflow as tf

# create graph
a = tf.constant(2)
b = tf.constant(3)
c = tf.add(a, b)

# creating the writer out of the session
# writer = tf.summary.FileWriter('./graphs', tf.get_default_graph())

# launch the graph in a session
with tf.Session() as sess:
    # or creating the writer inside the session
    writer = tf.summary.FileWriter('./graphs', sess.graph)
    print(sess.run(c))
    # don't forget to close the writer at the end
    writer.close()

接下来转到 Terminal,确保当前工作目录与运行 Python 代码的位置相同。例如,此处我们可以使用以下代码切换到目录

$ cd ~/Desktop/tensorboard

接下来运行:

$ tensorboard --logdir="./graphs" —port 6006

这将为你生成一个链接。ctrl + 左键单击该链接(或将其复制到浏览器中,或只需打开浏览器并转到 http://localhost:6006/)。接下来将显示 TensorBoard 页面,如下所示:

参数存储与加载

在基础部分中,最后还介绍了模型参数的保存与恢复。一般 TensorFlow 模型持久化可使用 tf.train.Saver() 完成,它会将 TensorFlow 模型保存为 .ckpt 格式的文件。一般该文件目录下会有三个文件,第一个 model.ckpt.meta 保存了 TensorFlow 计算图的结构,第二个 model.ckpt 文件保存了 TensorFlow 中每一个变量的取值,而最后一个 cheekpoint 文件保存了同目录下所有的模型文件列表。

为了保存和恢复模型变量,我们需要在构建计算图后调用 tf.train.Saver(),例如:

# create the graph
X = tf.placeholder(..)
Y = tf.placeholder(..)
w = tf.get_variale(..)
b = tf.get_variale(..)
...
loss = tf.losses.mean_squared_error(..)
optimizer = tf.train.AdamOptimizer(..).minimize(loss)
...

saver = tf.tfain.Saver()

在训练模式中,我们需要打开会话初始化变量和运行计算图,并在训练结束时调用 saver.save() 保存变量:

# TRAIN
with tf.Session() as sess:
    sess.run(tf.globale_variables_initializer())
    # train our model
    for step in range(steps):
        sess.run(optimizer)
        ...
    saved_path = saver.save(sess, './my-model', global_step=step)

在测试模式中,我们需要使用 saver.restore() 恢复参数

# TEST
with tf.Session() as sess:
    saver.restore(sess, './my-model')
    ...

当然,模型持久化还有非常多的内容,例如由 MetaGraphDef Protocol Buffer 定义的计算图节点元数据。读者可继续阅读完整的教程或其它书籍以了解详细信息。

入门深度学习框架入门谷歌TensorFlow
71
相关数据
深度学习技术

深度学习(deep learning)是机器学习的分支,是一种试图使用包含复杂结构或由多重非线性变换构成的多个处理层对数据进行高层抽象的算法。 深度学习是机器学习中一种基于对数据进行表征学习的算法,至今已有数种深度学习框架,如卷积神经网络和深度置信网络和递归神经网络等已被应用在计算机视觉、语音识别、自然语言处理、音频识别与生物信息学等领域并获取了极好的效果。

激活函数技术

在 计算网络中, 一个节点的激活函数定义了该节点在给定的输入或输入的集合下的输出。标准的计算机芯片电路可以看作是根据输入得到"开"(1)或"关"(0)输出的数字网络激活函数。这与神经网络中的线性感知机的行为类似。 一种函数(例如 ReLU 或 S 型函数),用于对上一层的所有输入求加权和,然后生成一个输出值(通常为非线性值),并将其传递给下一层。

权重技术

线性模型中特征的系数,或深度网络中的边。训练线性模型的目标是确定每个特征的理想权重。如果权重为 0,则相应的特征对模型来说没有任何贡献。

交叉熵技术

交叉熵(Cross Entropy)是Loss函数的一种(也称为损失函数或代价函数),用于描述模型预测值与真实值的差距大小

机器学习技术

机器学习是人工智能的一个分支,是一门多领域交叉学科,涉及概率论、统计学、逼近论、凸分析、计算复杂性理论等多门学科。机器学习理论主要是设计和分析一些让计算机可以自动“学习”的算法。因为学习算法中涉及了大量的统计学理论,机器学习与推断统计学联系尤为密切,也被称为统计学习理论。算法设计方面,机器学习理论关注可以实现的,行之有效的学习算法。

参数技术

在数学和统计学裡,参数(英语:parameter)是使用通用变量来建立函数和变量之间关系(当这种关系很难用方程来阐述时)的一个数量。

损失函数技术

在数学优化,统计学,计量经济学,决策理论,机器学习和计算神经科学等领域,损失函数或成本函数是将一或多个变量的一个事件或值映射为可以直观地表示某种与之相关“成本”的实数的函数。

超参数技术

在机器学习中,超参数是在学习过程开始之前设置其值的参数。 相反,其他参数的值是通过训练得出的。 不同的模型训练算法需要不同的超参数,一些简单的算法(如普通最小二乘回归)不需要。 给定这些超参数,训练算法从数据中学习参数。相同种类的机器学习模型可能需要不同的超参数来适应不同的数据模式,并且必须对其进行调整以便模型能够最优地解决机器学习问题。 在实际应用中一般需要对超参数进行优化,以找到一个超参数元组(tuple),由这些超参数元组形成一个最优化模型,该模型可以将在给定的独立数据上预定义的损失函数最小化。

TensorFlow技术

TensorFlow是一个开源软件库,用于各种感知和语言理解任务的机器学习。目前被50个团队用于研究和生产许多Google商业产品,如语音识别、Gmail、Google 相册和搜索,其中许多产品曾使用过其前任软件DistBelief。

张量技术

张量是一个可用来表示在一些矢量、标量和其他张量之间的线性关系的多线性函数,这些线性关系的基本例子有内积、外积、线性映射以及笛卡儿积。其坐标在 维空间内,有 个分量的一种量,其中每个分量都是坐标的函数,而在坐标变换时,这些分量也依照某些规则作线性变换。称为该张量的秩或阶(与矩阵的秩和阶均无关系)。 在数学里,张量是一种几何实体,或者说广义上的“数量”。张量概念包括标量、矢量和线性算子。张量可以用坐标系统来表达,记作标量的数组,但它是定义为“不依赖于参照系的选择的”。张量在物理和工程学中很重要。例如在扩散张量成像中,表达器官对于水的在各个方向的微分透性的张量可以用来产生大脑的扫描图。工程上最重要的例子可能就是应力张量和应变张量了,它们都是二阶张量,对于一般线性材料他们之间的关系由一个四阶弹性张量来决定。

计算机视觉技术

计算机视觉(CV)是指机器感知环境的能力。这一技术类别中的经典任务有图像形成、图像处理、图像提取和图像的三维推理。目标识别和面部识别也是很重要的研究领域。

神经网络技术

(人工)神经网络是一种起源于 20 世纪 50 年代的监督式机器学习模型,那时候研究者构想了「感知器(perceptron)」的想法。这一领域的研究者通常被称为「联结主义者(Connectionist)」,因为这种模型模拟了人脑的功能。神经网络模型通常是通过反向传播算法应用梯度下降训练的。目前神经网络有两大主要类型,它们都是前馈神经网络:卷积神经网络(CNN)和循环神经网络(RNN),其中 RNN 又包含长短期记忆(LSTM)、门控循环单元(GRU)等等。深度学习是一种主要应用于神经网络帮助其取得更好结果的技术。尽管神经网络主要用于监督学习,但也有一些为无监督学习设计的变体,比如自动编码器和生成对抗网络(GAN)。

封装器技术

智能代理和外部知识源之间的接口称为封装器。 封装器在智能代理使用的知识表示和外部知识源待处理的查询之间进行转换。 通常,封装器被封装器通常被用来使得通过一个智能代理可以对多个知识源进行相同的查询。 Wrapper方法寻找所有特征子集中能使后续学习算法达到较高性能的子集,在特征选择阶段,wrapper可以看做:搜索方法+学习算法。

卷积神经网络技术

卷积神经网路(Convolutional Neural Network, CNN)是一种前馈神经网络,它的人工神经元可以响应一部分覆盖范围内的周围单元,对于大型图像处理有出色表现。卷积神经网路由一个或多个卷积层和顶端的全连通层(对应经典的神经网路)组成,同时也包括关联权重和池化层(pooling layer)。这一结构使得卷积神经网路能够利用输入数据的二维结构。与其他深度学习结构相比,卷积神经网路在图像和语音识别方面能够给出更好的结果。这一模型也可以使用反向传播算法进行训练。相比较其他深度、前馈神经网路,卷积神经网路需要考量的参数更少,使之成为一种颇具吸引力的深度学习结构。 卷积网络是一种专门用于处理具有已知的、网格状拓扑的数据的神经网络。例如时间序列数据,它可以被认为是以一定时间间隔采样的一维网格,又如图像数据,其可以被认为是二维像素网格。

神经元技术

(人工)神经元是一个类比于生物神经元的数学计算模型,是神经网络的基本组成单元。 对于生物神经网络,每个神经元与其他神经元相连,当它“兴奋”时会向相连的神经元发送化学物质,从而改变这些神经元的电位;神经元的“兴奋”由其电位决定,当它的电位超过一个“阈值”(threshold)便会被激活,亦即“兴奋”。 目前最常见的神经元模型是基于1943年 Warren McCulloch 和 Walter Pitts提出的“M-P 神经元模型”。 在这个模型中,神经元通过带权重的连接接处理来自n个其他神经元的输入信号,其总输入值将与神经元的阈值进行比较,最后通过“激活函数”(activation function)产生神经元的输出。

强化学习技术

强化学习是一种试错方法,其目标是让软件智能体在特定环境中能够采取回报最大化的行为。强化学习在马尔可夫决策过程环境中主要使用的技术是动态规划(Dynamic Programming)。流行的强化学习方法包括自适应动态规划(ADP)、时间差分(TD)学习、状态-动作-回报-状态-动作(SARSA)算法、Q 学习、深度强化学习(DQN);其应用包括下棋类游戏、机器人控制和工作调度等。

深度神经网络技术

深度神经网络(DNN)是深度学习的一种框架,它是一种具备至少一个隐层的神经网络。与浅层神经网络类似,深度神经网络也能够为复杂非线性系统提供建模,但多出的层次为模型提供了更高的抽象层次,因而提高了模型的能力。

优化器技术

优化器基类提供了计算梯度loss的方法,并可以将梯度应用于变量。优化器里包含了实现了经典的优化算法,如梯度下降和Adagrad。 优化器是提供了一个可以使用各种优化算法的接口,可以让用户直接调用一些经典的优化算法,如梯度下降法等等。优化器(optimizers)类的基类。这个类定义了在训练模型的时候添加一个操作的API。用户基本上不会直接使用这个类,但是你会用到他的子类比如GradientDescentOptimizer, AdagradOptimizer, MomentumOptimizer(tensorflow下的优化器包)等等这些算法。

推荐文章
谢谢