TensorFlow是由Google创建的开源软件库，用于实现机器学习和深度学习系统. 这两个名字包含了一系列强大的算法，它们都面临着一个共同的挑战——让计算机学会如何自动识别复杂的模式和/或做出最佳决策.

如果你对这些系统的细节感兴趣, 你可以从Toptal的博客文章中了解更多 机器学习 和 深度学习.

TensorFlow的核心是一个用于数据流编程的库. 它利用各种优化技术使数学表达式的计算更容易、性能更高.

TensorFlow的一些关键特性是:

• 有效地处理涉及多维数组的数学表达式
• 对深度神经网络和机器学习概念的良好支持
• GPU/CPU计算，相同的代码可以在两种架构上执行
• 跨机器和庞大数据集的高可扩展性计算

在一起, 这些特性使TensorFlow成为生产规模机器智能的完美框架.

在这个TensorFlow教程, 你将学习如何在TensorFlow中使用简单而强大的机器学习方法，以及如何使用它的一些辅助库进行调试, 可视化, 并调整用它创建的模型.

安装TensorFlow

我们将使用TensorFlow Python API，它与Python 2一起工作.7和Python 3.3+. GPU版本(仅Linux)需要Cuda Toolkit 7.0+和cuDNN v2+.

我们将使用Conda包依赖管理系统来安装TensorFlow. Conda允许我们在一台机器上分离多个环境. 您可以从 在这里.

安装Conda后, 我们可以创建用于TensorFlow安装和使用的环境. 下面的命令将使用一些附加库创建我们的环境，例如 NumPy，这在我们开始使用TensorFlow时非常有用.

在此环境中安装的Python版本为2.7，我们将在本文中使用此版本.

conda创建——名字。 TensorflowEnv bioppython

为了方便起见，我们在这里安装的是bioppython，而不是NumPy. 这包括NumPy和我们将需要的其他一些包. 您总是可以在需要时使用 conda安装 或者是 pip安装 命令.

下面的命令将激活创建的Conda环境. 我们将能够使用其中安装的包, 而不会与全局安装或在其他环境中安装的包混合.

源激活TensorFlowEnv 

pip安装工具是Conda环境的标准部分. 我们将使用它来安装TensorFlow库. 在此之前, 好的第一步是将PIP更新到最新版本, 使用如下命令:

PIP install——升级PIP

现在我们已经准备好安装TensorFlow了，运行:

PIP安装tensorflow

下载和构建TensorFlow可能需要几分钟. 在撰写本文时，这将安装TensorFlow 1.1.0.

数据流程图

在TensorFlow中，计算使用数据流图来描述. 图的每个节点表示一个数学运算(如加法)的实例, 部门, (或乘法)，每条边是一个多维数据集(张量)，在其上执行操作.

因为TensorFlow与计算图一起工作, 它们在每个节点表示操作实例的情况下进行管理，其中每个操作具有零个或多个输入和零个或多个输出.

TensorFlow中的边可以分为两类:正常边传输数据结构(张量)，其中一个操作的输出可能成为另一个操作和特殊边的输入, 哪些用于控制两个节点之间的依赖关系，以设置一个节点等待另一个节点完成的操作顺序.

简单的表达式

在我们继续讨论TensorFlow的元素之前, 我们将首先使用TensorFlow, 来感受一下TensorFlow程序是什么样的.

让我们从简单的表达式开始，假设, 出于某种原因, 我们想求这个函数的值 y = 5*x + 13 以TensorFlow的方式.

在简单的Python代码中，它看起来像:

x = -2.0
y = 5*x + 13
打印y

在这种情况下，结果是3.0.

现在我们将把上面的表达式转换成TensorFlow项.

常量

在TensorFlow中，常量是使用函数常数创建的，该函数具有签名 常数(价值, dtype=N一个, 形状=N一个, 名字。='Const'， verify_形状=False),在那里 价值 是一个实际的常数值，将用于进一步的计算， dtype 数据类型参数(e.g.float32/64、int8/16等.), 形状 为可选尺寸， 名字。 张量的名字是可选的吗, 最后一个参数是布尔值，表示对值的形状进行验证.

如果您需要在训练模型中具有特定值的常量，则 常数 对象的用法如下:

Z = tf.常数(5.2、名字。=“x”，dtype=tf.float32)

变量

TensorFlow中的变量是包含张量的内存缓冲区，这些张量必须显式初始化，并在图中使用以保持会话状态. 通过简单地调用构造函数，变量被添加到计算图中.

当你开始训练模型时，变量是特别有用的, 它们用来保存和更新参数. 作为构造函数参数传递的初始值表示可以作为张量转换或返回的张量或对象. 这意味着，如果我们想用一些预定义的或随机的值填充一个变量，以便在训练过程中使用，并在迭代中更新, 我们可以这样定义它:

K = tf.变量(特遣部队.0 ([1]), 名字。 = " k ")

在TensorFlow中使用变量的另一种方法是在计算中，该变量不可训练，可以通过以下方式定义:

K = tf.变量(特遣部队.添加(a, b)， 火车able=False)

会话

为了实际评估节点，我们必须在会话中运行计算图.

会话封装了TensorFlow运行时的控制和状态. 没有参数的会话将使用当前会话中创建的默认图形, 否则，会话类接受一个图形参数, 要执行的会话中使用的是哪个.

下面是一个简短的代码片段，它展示了如何在TensorFlow中使用上面定义的术语来计算一个简单的线性函数.

导入tensorflow为tf

X = tf.常数(2.0, 名字。="x"， dtype= " tf ".float32)
A = tf.常数(5.0, 名字。="a"， dtype= " tf ".float32)
B = tf.常数(13.0, 名字。="b"， dtype= " tf ".float32)

Y = tf.变量(特遣部队.添加(特遣部队.* (a, x)， b))

Init = tf.global_variables_initializer ()

与特遣部队.Session()作为Session:
    会话.运行(init)
    打印会话.运行(y)

使用TensorFlow:定义计算图

使用数据流图的好处是，执行模型与其在CPU上的执行是分离的, GPU, 或者一些组合)在哪里, 一旦实现, TensorFlow中的软件可以在CPU或GPU上使用，所有与代码执行相关的复杂性都是隐藏的.

计算图可以在使用TensorFlow库的过程中构建，而无需显式实例化 图 对象.

TensorFlow中的图形对象可以通过一行简单的代码创建，例如 C = tf.添加(a, b). 这将创建一个带有两个张量的操作节点 a 和 b 生成它们的和 c 作为输出.

计算图是一个内置进程，它使用库而不需要调用 图 对象直接. TensorFlow中的一个图形对象, 它包含一组操作和张量作为数据单位, 在允许相同进程并包含多个图的操作之间使用，其中每个图将分配给不同的会话. 例如，这行简单的代码 C = tf.添加(a, b) 会创建一个需要两个张量的操作节点吗 a 和 b 作为输入并产生它们的和 c 作为输出.

TensorFlow还提供了一个feed机制，用于将张量修补到图中的任何操作, 在哪里饲料取代了一个操作的输出与张量值. 的参数传递提要数据 运行 () 函数调用.

占位符是TensorFlow的一种方式，它允许开发人员通过在一些表达式中绑定的占位符将数据注入计算图. 占位符的签名为:

占位符(dtype, 形状=N一个, 名字。=N一个)

其中dtype是张量中元素的类型并且可以提供要输入的张量的形状和操作的名称.

如果没有传递形状，这个张量可以被输入任何形状. 一个重要的注意事项是，占位符张量必须被输入数据, 否则, 在会话执行时，如果该部分丢失, 占位符使用以下结构生成错误:

InvalidArgumentError(参见上面的回溯):您必须为占位符张量'y'提供一个dtype float的值

占位符的优点是，它们允许开发人员创建操作, 一般的计算图, 不需要提前提供数据, 并且可以在运行时从外部源添加数据.

我们来看一个简单的两个整数相乘的问题 x 和 y 以TensorFlow的方式, 在会话中，占位符将与提要机制一起使用 运行 方法.

导入tensorflow为tf

X = tf.占位符(特遣部队.float32 名字。 = " x ")
Y = tf.占位符(特遣部队.float32 名字。 = " y ")

Z = tf.乘法(x, y, 名字。="z")

与特遣部队.Session()作为Session:
    打印会话.运行(z, feed_dict={x: 2).1, y: 3.0})

用TensorBoard可视化计算图

TensorBoard是一个分析数据流图的可视化工具. 这有助于更好地理解机器学习模型.

与TensorBoard, 您可以深入了解关于参数的不同类型的统计信息，以及关于计算图的各个部分的详细信息. 深度神经网络有大量节点是很正常的. TensorBoard允许开发人员深入了解每个节点以及计算是如何在TensorFlow运行时执行的.

现在让我们回到本TensorFlow教程开始时的例子，在那里我们用格式定义了一个线性函数 Y = a*x + b.

为了记录会话中的事件，以后可以在TensorBoard中使用，TensorFlow提供了 FileWriter class. 它可用于创建用于存储的事件文件 摘要 其中构造函数接受6个形参，如下所示:

__init__(日志dir, 图=N一个, 马克斯_queue=10, flush_secs=120, 图_def=N一个, file名字。_suffix=N一个)

其中日志dir参数是必需的，而其他参数有默认值. 图参数将从训练程序中创建的会话对象传递. 完整的示例代码如下:

导入tensorflow为tf


X = tf.常数(2.0, 名字。="x"， dtype= " tf ".float32)
A = tf.常数(5.0, 名字。="a"， dtype= " tf ".float32)
B = tf.常数(13.0, 名字。="b"， dtype= " tf ".float32)


Y = tf.变量(特遣部队.添加(特遣部队.* (a, x)， b))


Init = tf.global_variables_initializer ()


与特遣部队.Session()作为Session:
    合并= tf.summary.Merge_all() //新建
    Writer = tf.summary.FileWriter(“日志”,会话.图)//新建


    会话.运行(init)
    打印会话.运行(y)

我们只添加了两条新行. 我们合并了默认图中收集的所有摘要，并且 FileWriter 分别用于将事件转储到我们上面描述的文件中.

在运行程序之后，我们在目录日志s中有了这个文件，最后一步是运行 tensorboard:

Tensorboard——日志dir日志/

现在TensorBoard已经启动并运行在默认端口6006上. 打开后 http://localhost:6006 点击“图形”菜单项(位于页面顶部), 你就能看到图表了, 如下图所示:

TensorBoard标记常量和汇总节点的特定符号，如下所述.

数学与TensorFlow

张量是TensorFlow中的基本数据结构, 它们表示数据流图中的连接边.

张量只是标识一个多维数组或列表. 张量结构可以用三个参数来识别:秩、形状和类型.

• Rank:标识张量的维数. 秩被称为张量的阶或n维, 比如秩1张量是一个向量或者秩2张量是一个矩阵.
• 形状:张量的形状是它的行数和列数.
• 类型:分配给张量元素的数据类型.

为了在TensorFlow中构建一个张量，我们可以构建一个n维数组. 这可以通过使用NumPy库轻松完成, 或者将Python n维数组转换为TensorFlow张量.

来建立一个一维张量, 我们将使用NumPy数组, 我们将通过传递一个内置的Python列表来构造它.

导入numpy为np
Tensor_1d = np.阵列([1.45, -1, 0.2, 102.1])

使用这种数组类似于使用内置的Python列表. 主要区别在于NumPy数组还包含一些附加属性, 像维, 形状, 和类型.

> > print tensor1d
[   1.45   -1.      0.2   102.1 ]

> > print tensor1d[0]
1.45

> > print tensor1d[2]
0.2

> > print tensor1d.ndim
1

> > print tensor1d.形状
(4,)

> > print tensor1d.dtype
float64

NumPy数组可以通过辅助函数很容易地转换为TensorFlow张量 convert_to_tensor，它可以帮助开发人员将Python对象转换为张量对象. 这个函数接受张量对象、NumPy数组、Python列表和Python标量.

张量= tf.convert_to_tensor (tensor_1d dtype =特遣部队.float64)

现在如果我们将张量绑定到TensorFlow会话, 我们将能够看到我们转换的结果.

张量= tf.convert_to_tensor (tensor_1d dtype =特遣部队.float64)

与特遣部队.Session()作为Session:
    打印会话.运行(张量)
    打印会话.运行(张量[0])
    打印会话.运行(张量[1])

输出:

[   1.45   -1.      0.2   102.1 ]
1.45
-1.0

我们可以用类似的方法创建一个二维张量，或者矩阵:

Tensor_2d = np.阵列(np.随机.R和 (4,4)， dtype='float32')
Tensor_2d_1 = np.阵列(np.随机.R和 (4,4)， dtype='float32')
Tensor_2d_2 = np.阵列(np.随机.R和 (4,4)， dtype='float32')

M1 = tf.convert_to_tensor (tensor_2d)
M2 = tf.convert_to_tensor (tensor_2d_1)
M3 = tf.convert_to_tensor (tensor_2d_2)
Mat_产品 = tf.matmul (m1、m2)
Mat_sum = tf.添加(m2, m3)
Mat_det = tf.matrix_行列式 (m3)

与特遣部队.Session()作为Session:
    打印会话.运行(mat_产品)
    打印会话.运行(mat_sum)
    打印会话.运行(mat_det)

张量操作

在上面的例子中，我们在向量和矩阵上引入了一些TensorFlow操作. 这些运算对张量进行一定的计算. 下表中显示了哪些计算方法.

上表中列出的TensorFlow操作适用于张量对象, 并且是按元素执行的. 如果你想计算向量x的余弦, TensorFlow操作将对传递的张量中的每个元素进行计算.

Tensor_1d = np.数组([0,0,0])
张量= tf.convert_to_tensor (tensor_1d dtype =特遣部队.float64)
与特遣部队.Session()作为Session:
    打印会话.运行(特遣部队.因为(张量))

输出:

[ 1.  1.  1.]

矩阵运算

矩阵运算对于机器学习模型是非常重要的, 比如线性回归, 因为他们经常在他们中使用. TensorFlow支持所有最常见的矩阵操作，比如 乘法, 置换, 反演，计算 行列式,解决 线性方程, 更多的.

接下来，我们将解释一些矩阵运算. 当涉及到机器学习模型时，它们往往很重要，比如线性回归. 让我们写一些代码来做一些基本的矩阵运算，比如乘法，得到 转置求行列式，乘法，sol，等等.

下面是调用这些操作的基本示例.

导入tensorflow为tf
导入numpy为np

Def convert(v, t=tf).float32):
    返回特遣部队.convert_to_tensor (v, dtype = t)

M1 = convert(np.阵列(np.随机.R和 (4, 4)， dtype='float32'))
M2 = convert(np.阵列(np.随机.R和 (4, 4)， dtype='float32'))
M3 = convert(np.阵列(np.随机.R和 (4, 4)， dtype='float32'))
M4 =转换(np.阵列(np.随机.R和 (4, 4)， dtype='float32'))
M5 =转换(np).阵列(np.随机.R和 (4, 4)， dtype='float32'))

m_转置= tf.置(m1)
M_mul = tf.matmul (m1、m2)
M_det = tf.matrix_行列式 (m3)
M_inv = tf.matrix_inverse (m4)
M_solve = tf.Matrix_solve (m5， [[1]， [1]， [1]， [1]])

与特遣部队.Session()作为Session:
    打印会话.运行(m_tranpose)
    打印会话.运行(m_mul)
    打印会话.运行(m_inv)
    打印会话.运行(m_det)
    打印会话.运行(m_solve)

转换数据

减少

TensorFlow支持不同类型的约简. 约简是一种操作，通过在张量的一个或多个维度上执行某些操作，从这些维度上移除一个或多个维度. 当前版本TensorFlow支持的缩减列表可以在这里找到. 我们将在下面的示例中展示其中的一些.

导入tensorflow为tf
导入numpy为np

Def convert(v, t=tf).float32):
    返回特遣部队.convert_to_tensor (v, dtype = t)

X = convert(
    np.阵列(
        [
            (1, 2, 3),
            (4, 5, 6),
            (7, 8, 9)
        ]), tf.int32)

bool_tensor = convert([(True, False, True)， (False, False, True)， (True, False, False)]， tf.bool)

Red_sum_0 = tf.reduce_sum (x)
Red_sum = tf.reduce_sum (x轴= 1)

Red_prod_0 = tf.reduce_prod (x)
Red_prod = tf.reduce_prod (x轴= 1)

Red_最小值_0 = tf.reduce_最小值 (x)
Red_最小值 = tf.reduce_最小值 (x轴= 1)

Red_马克斯_0 = tf.reduce_马克斯 (x)
Red_maX = tf.reduce_马克斯 (x轴= 1)

Red_的意思是_0 = tf.reduce_的意思是 (x)
Red_的意思是 = tf.reduce_的意思是 (x轴= 1)

Red_bool_all_0 = tf.reduce_all (bool_tensor)
Red_bool_all = tf.reduce_all (bool_tensor轴= 1)

Red_bool_any_0 = tf.reduce_any (bool_tensor)
Red_bool_anY = tf.reduce_any (bool_tensor轴= 1)


与特遣部队.Session()作为Session:
    打印“Reduce sum without passed axis parameter:”，会话.运行(red_sum_0)
    打印“Reduce sum with passed axis=1:”，会话.运行(red_sum)

    打印“减少产品没有传递轴参数:”，会话.运行(red_prod_0)
    print“Reduce 产品 with passed axis=1:”，会话.运行(red_prod)

    打印“减少最小值没有传递轴参数:”，会话.运行(red_最小值_0)
    print "Reduce 最小值 with passed axis=1 "，会话.运行(red_最小值)

    打印“在没有传递轴参数的情况下减少马克斯”，会话.运行(red_马克斯_0)
    print "Reduce 马克斯 with passed axis=1 "，会话.运行(red_马克斯)

    打印“减少平均值没有传递轴参数:”，会话.运行(red_的意思是_0)
    打印“Reduce 的意思是 with passed axis=1:”，会话.运行(red_的意思是)

    print "Reduce bool all without passed axis parameter: "，会话.运行(red_bool_all_0)
    print“Reduce bool all with passed axis=1:”，会话.运行(red_bool_all)

    print "Reduce bool any没有传递轴参数:"，会话.运行(red_bool_any_0)
    print "Reduce bool any with passed axis=1: "，会话.运行(red_bool_any)

输出:

减少没有传递轴参数的总和:45
Reduce sum with passed axis=1: [6 15 24]
减少产品不通过轴参数:362880
通过轴减积=1:[6 120 504]
减少不传递轴参数的最小值
通过轴减小最小值=1:[1 4 7]
在不传递轴参数的情况下减小马克斯: 9
减少马克斯与传递轴=1:[3 6 9]
减少平均值没有传递轴参数:5
经轴减平均值=1:[2 5 8]
减少没有传递轴参数的bool: False
Reduce bool all with passed axis=1: [False False False]
减少没有传递轴参数的bool: True
减少bool与传递轴=1:[True True True]

约简算子的第一个参数是我们想要约简的张量. 第二个参数是我们想要执行约简的维度的索引. 该参数是可选的，如果不传递，将沿所有维度执行约简.

我们可以看看 reduce_sum 操作. 我们传递一个二维张量，想要沿着维1进行约简.

在本例中，结果和为:

[1 + 2 + 3 = 6, 4 + 5 + 6 = 15, 7 + 8 + 9 = 24]

如果我们传递维度0，结果将是:

[1 + 4 + 7 = 12, 2 + 5 + 8 = 15, 3 + 6 + 9 = 18]

如果我们不传递任何轴，结果就是以下的总和:

1 + 4 + 7 = 12, 2 + 5 + 8 = 15, 3 + 6 + 9 = 45

所有约简函数都有类似的接口，并在TensorFlow中列出 减少文档.

分割

分割是将其中一个维度映射到所提供的段索引上的过程, 结果元素由索引行确定.

分割实际上是将元素分组在重复索引下, 举个例子, 在我们的例子中, 我们有分段id [0, 0, 1, 2, 2] 作用于张量 tens1, 这意味着第一个和第二个数组将在分割操作之后被转换(在我们的例子中是求和)，并将得到一个新的数组, 看起来像 (2, 8, 1, 0) = (2+0, 5+3, 3-2, -5+5). 张量的第三个元素 tens1 因为它没有在任何重复索引中分组而未被触及, 最后两个数组的求和方法和第一组相同. 除了求和，TensorFlow还支持 产品, 的意思是, 马克斯, 最小值.

导入tensorflow为tf
导入numpy为np




Def convert(v, t=tf).float32):
    返回特遣部队.convert_to_tensor (v, dtype = t)


Seg_ids = tf.常量([0,0,1,2,2])
Tens1 = convert(np.数组([(2、5、3、5)(0、3、2、5)(4,3、5、3),(6、1 4 0),(6、1 4 0))),特遣部队.int32)
Tens2 = convert(np.Array ([1, 2, 3, 4, 5]).int32)


Seg_sum = tf.segment_sum (tens1 seg_ids)
Seg_sum_1 = tf.segment_sum (tens2 seg_ids)


与特遣部队.Session()作为Session:
    print“分割和tens1:”，会话.运行(seg_sum)
    print“分割 sum tens2:”，会话.运行(seg_sum_1)

分割和tens1:  
[[ 2  8  1  0]
 [ 4  3  5  3]
 [12  2  8  0]]
 
分割sum tens2: [3 3 9]

序列公用事业

序列实用程序包括以下方法:

• arg最小值 函数，它在输入张量的坐标轴上返回具有最小值的索引，
• arg马克斯 函数，它在输入张量的坐标轴上返回具有最大值的索引，
• setdiff它计算两个数字或字符串列表之间的差，
• 在哪里 函数, 哪个将从两个传递的元素x或y返回元素, 这取决于通过的条件, or
• 独特的 函数，它将返回一维张量中的唯一元素.

我们在下面演示几个执行示例:

导入numpy为np
导入tensorflow为tf

Def convert(v, t=tf).float32):
    返回特遣部队.convert_to_tensor (v, dtype = t)

X = convert(np.数组([
    [2, 2, 1, 3],
    [4, 5, 6, -1],
    [0, 1, 1, -2],
    [6, 2, 3, 0]
]))

Y = convert(np.Array ([1,2,5,3,7])
Z =转换(np.Array ([1,0,4,6,2])

Arg_最小值 = tf.arg最小值 (x, 1)
Arg_maX = tf.arg马克斯 (x, 1)
Unique = tf.独特的(y)
Diff = tf.setdiff1d (y, z)

与特遣部队.Session()作为Session:
    打印“Arg最小值 =”，会话.运行(arg_最小值)
    打印“Arg马克斯 =”，会话.运行(arg_马克斯)

    打印“Unique_价值s =”，会话.运行(独特的)[0]
    打印“Unique_idx =”，会话.运行(独特的)[1]

    打印“Setdiff_价值s =”，会话.运行(diff) [0]
    打印“Setdiff_idx =”，会话.运行(diff) [1]

    打印会话.运行(diff) [1]

输出:

Arg最小值 = [2 3 3 3]
Arg马克斯 = [3 2 10 0]
Unique_价值s = [1].  2.  5.  3.  7.]
Unique_idx = [0 1 2 3 4]
Setdiff_价值s = [5].  3.  7.]
Setdiff_idx = [2 3 4]

机器学习与TensorFlow

在本节中，我们将介绍一个使用TensorFlow的机器学习用例. 第一个示例将是一个使用 然而, 方法，第二个将使用 线性回归算法.

然而,

第一个算法是k近邻(然而,). 这是一个使用距离度量的监督学习算法, 比如欧氏距离, 根据训练对数据进行分类. 它是最简单的算法之一，但在分类数据方面仍然非常强大. 该算法的优点:

• 当训练模型足够大时，具有较高的准确率
• 通常对异常值不敏感，我们不需要对数据有任何假设.

该算法的缺点:

• 计算成本高，而且
• 需要大量内存，需要将新的分类数据添加到所有初始训练实例中.

在这个代码示例中，我们将使用欧几里得距离, 它定义了两点之间的距离:

在这个公式中， n 是空间的维数， x 是训练数据的向量，和 y 是我们想要分类的新数据点吗.

进口操作系统
导入numpy为np
导入tensorflow为tf

Ccf_火车_data = "火车_dataset . cn.csv”
Ccf_test_data = "test_dataset.csv”

Dataset_dir =操作系统.路径.腹肌路径 (os.路径.加入(os.路径.目录名(__file__)”,../数据集”))

Ccf_火车_file路径 = OS.路径.加入(dataset_dir ccf_火车_data)
Ccf_test_file路径 = OS.路径.加入(dataset_dir ccf_test_data)

def load_data (file路径):
    从numpy导入genfromext

    Csv_data = genfromtxt(file路径, delimiter="，"， skip_header=1)
    数据= []
    标签= []

    对于csv_data中的d:
        data.追加(d (: 1))
        标签.追加(d [1])

    返回np.数组(数据),np.阵列(标签)

Train_dataset, 火车_标签 = load_data(ccf_火车_file路径)
Test_dataset, test_标签 = load_data(ccf_test_file路径)

Train_pl = tf.占位符("float"， [N一个, 28])
Test_pl = tf.占位符(“浮动”,[28])

Knn_prediction = tf.reduce_sum(特遣部队.腹肌(特遣部队.添加 (火车_pl,特遣部队.负(test_pl))),轴= 1)

Pred = tf.arg最小值 (knn_prediction, 0)

与特遣部队.Session()作为tf_会话:
    错过= 0

    For I in xrange(len(test_dataset)):
        Knn_indeX = tf_会话.运行(pred, feed_dict={火车_pl: 火车_dataset, test_pl: test_dataset[i]})

        打印“预测类{}—真实类{}”.格式(火车_标签 knn_index, test_标签[我])

        如果火车_标签 knn_index != test_标签[我]:
            错过+= 1

    tf.summary.FileWriter(“..”,tf_会话 /样本/文章/日志.图)

打印“遗漏:{}—总数:{}”.格式(错过,len (test_dataset))

我们在上面的例子中使用的数据集可以在 Kaggle数据集 section. 我们使用 一个 里面有欧洲持卡人的信用卡交易记录吗. 我们使用的数据没有经过任何清理或过滤，并按照Kaggle对该数据集的描述, 它是高度不平衡的. 数据集包含31个变量:Time、V1、…、V28、Amount、Class. 在这个代码示例中，我们只使用V1，…，V28和Class. 类用1标记欺诈的交易，用0标记不欺诈的交易.

代码示例包含了我们在前几节中描述的大部分内容，除了我们引入了加载数据集的函数. 这个函数 load_data (file路径) 将采取CSV文件作为参数，并将返回一个元组的数据和标签定义在CSV.

在该函数下面，我们为测试和训练数据定义了占位符. 在预测模型中使用经过训练的数据来解析需要分类的输入数据的标签. 在我们的例子中，然而,使用欧几里德距离来获得最近的标签.

错误率可以通过简单地除以分类器缺失的总样本数来计算，在我们的例子中，这个数据集是0.2 (i.e.，分类器为我们提供了20%测试数据的错误数据标签).

线性回归

线性回归算法寻找两个变量之间的线性关系. 如果我们把因变量标记为y, 自变量是x, 然后我们试着估计函数的参数 y = Wx + b.

线性回归是应用科学领域中应用广泛的一种算法. 该算法允许在实现中添加两个重要的机器学习概念: 成本函数 和 梯度下降法 求函数的最小值.

使用这种方法实现的机器学习算法必须预测的值 y 作为的函数 x 在哪里线性回归算法将确定值 W 和 b，这些实际上是未知的，是在整个培训过程中确定的. 选择一个代价函数, 通常使用均方误差梯度下降是用于寻找代价函数的局部最小值的优化算法.

梯度下降法只是一个局部函数最小值, 但它可以用于搜索全局最小值，一旦它找到了一个局部最小值，随机选择一个新的起点，并重复这个过程多次. 如果函数的最小值是有限的，并且尝试的次数非常多, 那么很有可能在某一时刻发现全球最小值. 关于此技术的更多细节我们将留给 article 我们在介绍部分提到过.

导入tensorflow为tf
导入numpy为np

Test_data_size = 2000
迭代次数= 10000次
Learn_rate = 0.005

def generate_test_价值s ():
    火车x = []
    Train_y = []

    对于_in xrange(test_data_size):
        X1 = np.随机.r和 ()
        X2 = np.随机.r和 ()
        X3 = np.随机.r和 ()
        Y_f = 2 * x1 + 3 * x2 + 7 * x3 + 4
        火车_x.Append ([x1, x2, x3])
        火车_y.追加(y_f)

    返回np.阵列(火车_x), np.置([火车_y])

X = tf.占位符(特遣部队.float32， [N一个, 3]， 名字。="x")
W = tf.变量(特遣部队.0 ([3,1])， 名字。="W")
B = tf.变量(特遣部队.0 ([1]), 名字。 = " b ")
Y = tf.占位符(特遣部队.float32， [N一个, 1])

模型= tf.添加(特遣部队.matmul(x, W)， b)

成本= tf.reduce_的意思是(特遣部队.方形(y型)
火车= tf.火车.GradientDescentOptimizer (learn_rate).最小化(成本)

Train_dataset, 火车_价值s = generate_test_价值s()

Init = tf.global_variables_initializer ()

与特遣部队.Session()作为Session:
    会话.运行(init)

    For _in xrange(iterations):

        会话.运行(火车,feed_dict = {
            x: 火车_dataset,
            y: 火车_价值s
        })

    打印“成本 ={}”.格式(会话.运行(成本、feed_dict = {
        x: 火车_dataset,
        y: 火车_价值s
    }))

    print "W = {}".格式(会话.运行(W))
    打印"b = {}".格式(会话.运行(b))

输出:

成本= 3.1083032809e-05
W = [[ 1.99049103]
 [ 2.9887135 ]
 [ 6.98754263]]
b = [ 4.01742554]

在上面的例子中，我们有两个新变量，我们称之为 成本 和 火车. 有了这两个变量, 我们定义了一个我们想要在训练模型中使用的优化器和我们想要最小化的函数.

的输出参数 W 和 b 应该与定义的相同 generate_test_价值s 函数. 在第17行, 我们实际上定义了一个函数用来生成要训练的线性数据点 w1=2, w2=3, w3=7 和 b=4. 以上例子中的线性回归是多元的，其中使用了多个自变量.

结论

正如你可以从这个TensorFlow教程中看到的, TensorFlow是一个强大的框架，它使处理数学表达式和多维数组变得轻而易举——这在机器学习中是必不可少的. 它还抽象了执行数据图和缩放的复杂性.

随着时间的推移, TensorFlow越来越受欢迎，现在被开发人员用于解决使用深度学习方法进行图像识别的问题, 视频检测, 文本处理，比如情感分析, 等. 和其他图书馆一样, 您可能需要一些时间来习惯TensorFlow所基于的概念. 和, 一旦你做到了, 在文档和社区支持的帮助下, 将问题表示为数据图并使用TensorFlow解决它们可以使大规模机器学习成为一个不那么繁琐的过程.