TensorFlow

TF高级别API TF.Learn    http://tflearn.org/

从零开始学TF-Learn 

https://blog.csdn.net/u013745804/article/details/78285166

https://blog.csdn.net/u013745804/article/details/78291425

TensorFlow入门

TensorFlow是Google公司2015年11月开源的第二代深度学习框架,是第一代框架DistBelief的改进版本.

TensorFlow支持python和c/c++语言, 可以在cpu或gpu上进行运算, 支持使用virtualenv或docker打包发布.

TensorFlow并不是一个纯粹的神经网络框架, 而是使用数据流图进行数值分析的框架.

TensorFlow使用有向图(graph)表示一个计算任务.图的节点称为ops(operations)表示对数据的处理,图的边flow 描述数据的流向.

该框架计算过程就是处理tensor组成的流. 这也是TensorFlow名称的来源.

TensorFlow使用tensor表示数据. tensor意为张量即高维数组,在python中使用numpy.ndarray表示.

TensorFlow使用Session执行图, 使用Variable维护状态.tf.constant是只能输出的ops, 常用作数据源.

在TensorFlow的世界里，变量的定义和初始化是分开的，所有关于图变量的赋值和计算都要通过tf.Session的run来进行。想要将所有图变量进行集体初始化时应该使用tf.global_variables_initializer

用TensorFlow实现一个简单神经网络

Neural Network Demo powered by tensorflow

import tensorflow as tf

import numpy as np

def make_layer(inputs, in_size, out_size,activate=None):

  weights = tf.Variable(tf.random_normal([in_size, out_size]))

    basis= tf.Variable(tf.zeros([1, out_size]) + 0.1)

  result = tf.matmul(inputs, weights) + basis

    ifactivate is None:

      return result

    else:

      return activate(result)

class BPNeuralNetwork:

    def__init__(self):

      self.input_layer = None

      self.label_layer = None

      self.loss = None

      self.optimizer = None

      self.layers = []

    def train(self, cases, labels, limit=100, learn_rate=0.05):

        #build network

      self.input_layer = tf.placeholder(tf.float32, [None, 2])

      self.label_layer = tf.placeholder(tf.float32, [None, 1])

      self.layers.append(make_layer(self.input_layer, 2, 10,activate=tf.nn.relu))

      self.layers.append(make_layer(self.layers[0], 10, 2, activate=None))

      self.loss = tf.reduce_mean(tf.reduce_sum(tf.square((self.label_layer -self.layers[1])), reduction_indices=[1]))

      self.optimizer =tf.train.GradientDescentOptimizer(learn_rate).minimize(self.loss)

        # do training

      self.session.run(tf.initialize_all_variables())

      for i in range(limit):

          self.session.run(self.optimizer, feed_dict={self.input_layer: cases,self.label_layer: labels})

    defpredict(self, case):

      return self.session.run(self.layers[-1], feed_dict={self.input_layer:case})

    deftest(self):

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

      y_data = np.array([[0, 1, 1, 0]]).transpose()

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

      self.train(x_data, y_data)

      print self.predict(test_data)

def main():

    withtf.Session() as session:

      model = BPNeuralNetwork()

      model.session = session

      model.test()

TensorFlow的reduce_sum()函数

调用reduce_sum(arg1, arg2)时，参数arg1即为要求和的数据，arg2有两个取值分别为0和1，通常用reduction_indices=[0]或reduction_indices=[1]来传递参数。从上图可以看出，当arg2 = 0时，是纵向对矩阵求和，原来矩阵有几列就得到几个值；相似地，当arg2 = 1时，是横向对矩阵求和；当省略arg2参数时，默认对矩阵所有元素进行求和。

看到这里，函数名的前缀为什么是reduce_其实也就很容易理解了，reduce就是“对矩阵降维”的含义，下划线后面的部分就是降维的方式，在reduce_sum()中就是按照求和的方式对矩阵降维。那么其他reduce前缀的函数也举一反三了，比如reduce_mean()就是按照某个维度求平均值，等等。

E:\Anaconda3\lib\site-packages\h5py\__init__.py:36:FutureWarning: Conversion of the second argument of issubdtype from `float` to`np.floating` is deprecated. In future, it will be treated as `np.float64 ==np.dtype(float).type`. from ._conv import register_converters as_register_converters

anaconda指的是一个开源的Python发行版本，其包含了conda、Python等180多个科学包及其依赖项。因为包含了大量的科学包，Anaconda的下载文件比较大（约515 MB），如果只需要某些包，或者需要节省带宽或存储空间，也可以使用Miniconda这个较小的发行版（仅包含conda和 Python）。

安装TensorFlow

基于 Anaconda 的安装

Anaconda 是一个集成许多第三方科学计算库的Python 科学计算环境,Anaconda使用 conda 作为自己的包管理工具,同时具有自己的计算环境,类似Virtualenv.

和Virtualenv 一样,不同 Python 工程需要的依赖包,conda 将他们存储在不同的地方。 TensorFlow 上安装的 Anaconda 不会对之前安装的 Python 包进行覆盖.

- 安装Anaconda

- 建立一个 conda 计算环境

- 激活环境,使用conda 安装TensorFlow

- 安装成功后,每次使用TensorFlow 的时候需要激活conda 环境

安装Anaconda :

参考 Anaconda 的下载页面的指导

建立一个 conda 计算环境名字叫tensorflow：

激活tensorflow环境，然后使用其中的 pip 安装 TensorFlow. 当使用easy_install使用--ignore-installed标记防止错误的产生。

ValueError: Cannot feed value of shape (200,)

for Tensor 'Placeholder_32:0', which has shape '(?, 1)'

I am new to tensorflow. This code isjust for a simple neural network. I think the problem maybe is from:

x_data =np.linspace(-0.5,0.5,200)[:np..newaxis]

I tried to write without [:np.newaxis], but it looks like the same.

1 Answer

Thedefined placeholders (both x and y) are 2-dimensional, so you should reshape the inputarrays to rank 2. Try to add this:

x_data = x_data.reshape([-1,1])

y_data = y_data.reshape([-1,1])

Tensorflow: You must feed a value for placeholder tensor'inputs/y_input' with dtype float and shape

从字面理解是：你必须给占位符y_input喂入一个向量值即赋值

交叉熵（Cross Entropy）是Shannon信息论中一个重要概念，主要用于度量两个概率分布间的差异性信息，将交叉熵引入计算语言学消岐领域，采用语句的真实语义作为交叉熵的训练集的先验信息，将机器翻译的语义作为测试集后验信息。计算两者的交叉熵，并以交叉熵指导对歧义的辨识和消除。实例表明，该方法简洁有效

tf.reduce_mean

一，tensorflow中有一类在tensor的某一维度上求值的函数。如：

求最大值tf.reduce_max(input_tensor, reduction_indices=None,keep_dims=False, name=None)

求平均值tf.reduce_mean(input_tensor, reduction_indices=None,keep_dims=False, name=None)

举例说明：

# 'x' is [[1., 2.]

          [3., 4.]]

x是一个2维数组，分别调用reduce_*函数如下：

首先求平均值：

tf.reduce_mean(x) ==> 2.5 #如果不指定第二个参数，那么就在所有的元素中取平均值

tf.reduce_mean(x, 0) ==> [2., 3.]

#指定第二个参数为0，则第一维的元素取平均值，即每一列求平均值

tf.reduce_mean(x, 1) ==> [1.5,3.5]  #指定第二个参数为1，则第二维的元素取平均值，即每一行求平均值  同理，还可用tf.reduce_max()求最大值等。

tf.argmax 返回张量在某一维度上最大值的索引值

TensorFlow TensorFlow TensorFlow

Colaboratory可以让你在浏览器中运行 TensorFlow 程序

Colaboratory是一种数据分析工具，可将文字、代码和代码输出内容合并到一个协作文档中。

借助 Colaboratory，您只需点击一下鼠标，即可在浏览器中执行 TensorFlow 代码。

Colaboratory 包含很多已被广泛使用的库（例如 matplotlib），因而能够简化数据的可视化过程。

Colaboratory 可与 Google Cloud BigQuery 结合使用。

要运行此程序，请执行以下操作

点击代码块中的任意位置（例如，点击字词 import）。

点击代码块左上角的右向三角图标，或按 ⌘/Ctrl+Enter 键。

程序需要几秒钟才会运行。

整个程序仅包含一个代码块。不过，大部分练习都会包含多个代码块，在这种情况下，您应按从上到下的顺序逐个运行代码块。

不按顺序运行代码块通常会导致错误。

实用的键盘快捷键

⌘/Ctrl+m、b：在当前选择的单元格下方创建一个空白代码单元格

⌘/Ctrl+m、i：中断单元格的运行

⌘/Ctrl+m、h：显示所有键盘快捷键列表

要查看关于任何 TensorFlow API 方法的文档，请将光标放置在其左括号的正后方，然后按Tab键：

广播

在数学中，您只能对形状相同的张量执行元素级运算（例如，相加和等于）。不过，在 TensorFlow 中，您可以对张量执行传统意义上不可行的运算。TensorFlow支持广播（一种借鉴自 Numpy 的概念）。利用广播，元素级运算中的较小数组会增大到与较大数组具有相同的形状。

张量变形

由于张量加法和矩阵乘法均对运算数施加了限制条件，TensorFlow编程者肯定会频繁改变张量的形状。

您可以使用 tf.reshape 方法改变张量的形状。 例如，您可以将 8x2 张量变形为 2x8 张量或 4x4 张量

变量、初始化和赋值

到目前为止，我们执行的所有运算都是针对静态值(tf.constant)进行的；调用 eval() 始终返回同一结果。在TensorFlow 中可以定义 Variable 对象，它的值是可以更改的。

创建变量时，您可以明确设置一个初始值，也可以使用初始化程序

张量处理器（英语：tensor processing unit，缩写：TPU）是Google为机器学习定制的专用芯片（ASIC），专为Google的深度学习框架TensorFlow而设计。

与图形处理器（GPU）相比，TPU采用低精度（8位）计算，以降低每步操作使用的晶体管数量。降低精度对于深度学习的准确度影响很小，但却可以大幅降低功耗、加快运算速度。同时，TPU使用了脉动阵列（英语：Systolic array）的设计，用来优化矩阵乘法与卷积运算，减少I/O操作。此外，TPU还采用了更大的片上内存，以此减少对DRAM的访问，从而更大程度地提升性能。

Google在2016年的Google I/O年会上首次公布了TPU。不过在此之前TPU已在Google内部的一些项目中使用了一年多，如Google街景服务、RankBrain（英语：RankBrain）以及其旗下DeepMind公司的围棋软件AlphaGo等都用到了TPU。[2][3]而在2017年的Google

I/O年会上，Google又公布了第二代TPU，并将其部署在Google云平台之上。第二代TPU的浮点运算能力高达每秒180万亿次。

第一代

第一代的TPU使用8-bit矩阵乘法引擎，透过PCIe 3.0与CISC指令操作。晶片为28nm制程，die ≤ 331 mm2，700 Mhz，功耗在28至40瓦。

第二代

第二代于2017年五月发表。

第三代

第三代于2018年五月发表。

TensorFlow DNN for regression

from __future__ import absolute_import

from __future__ import division

from __future__ import print_function

import tensorflow as tf

from tensorflow.contrib import learn

import matplotlib.pyplot as plt

from sklearn.pipeline import Pipeline

from sklearn import datasets, linear_model

from sklearn import cross_validation

import numpy as np

boston = learn.datasets.load_dataset('boston')

x, y = boston.data, boston.target

X_train, X_test, Y_train, Y_test = cross_validation.train_test_split(

x, y, test_size=0.2, random_state=42)

total_len = X_train.shape[0]

# Parameters

learning_rate = 0.001

training_epochs = 500

batch_size = 10

display_step = 1

dropout_rate = 0.9

# Network Parameters

n_hidden_1 = 32 # 1st layer number of features

n_hidden_2 = 200 # 2nd layer number of features

n_hidden_3 = 200

n_hidden_4 = 256

n_input = X_train.shape[1]

n_classes = 1

# tf Graph input

x = tf.placeholder("float", [None,13])

y = tf.placeholder("float", [None])

# Create model

def multilayer_perceptron(x, weights, biases):

    #Hidden layer with RELU activation

  layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1'])

  layer_1 = tf.nn.relu(layer_1)

    #Hidden layer with RELU activation

  layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2'])

  layer_2 = tf.nn.relu(layer_2)

    #Hidden layer with RELU activation

  layer_3 = tf.add(tf.matmul(layer_2, weights['h3']), biases['b3'])

  layer_3 = tf.nn.relu(layer_3)

    #Hidden layer with RELU activation

  layer_4 = tf.add(tf.matmul(layer_3, weights['h4']), biases['b4'])

  layer_4 = tf.nn.relu(layer_4)

    #Output layer with linear activation

  out_layer = tf.matmul(layer_4, weights['out']) + biases['out']

  return out_layer

# Store layers weight & bias

weights = {

    'h1':tf.Variable(tf.random_normal([n_input, n_hidden_1], 0, 0.1)),

    'h2':tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2], 0, 0.1)),

    'h3':tf.Variable(tf.random_normal([n_hidden_2, n_hidden_3], 0, 0.1)),

    'h4':tf.Variable(tf.random_normal([n_hidden_3, n_hidden_4], 0, 0.1)),

  'out': tf.Variable(tf.random_normal([n_hidden_4, n_classes], 0, 0.1))

}

biases = {

    'b1':tf.Variable(tf.random_normal([n_hidden_1], 0, 0.1)),

    'b2':tf.Variable(tf.random_normal([n_hidden_2], 0, 0.1)),

    'b3':tf.Variable(tf.random_normal([n_hidden_3], 0, 0.1)),

    'b4':tf.Variable(tf.random_normal([n_hidden_4], 0, 0.1)),

  'out': tf.Variable(tf.random_normal([n_classes], 0, 0.1))

}

# Construct model

pred = multilayer_perceptron(x, weights,biases)

# Define loss and optimizer

cost = tf.reduce_mean(tf.square(pred-y))

optimizer =tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

# Launch the graph

with tf.Session() as sess:

  sess.run(tf.initialize_all_variables())

    #Training cycle

    forepoch in range(training_epochs):

      avg_cost = 0.

      total_batch = int(total_len/batch_size)

        #Loop over all batches

      for i in range(total_batch-1):

          batch_x = X_train[i*batch_size:(i+1)*batch_size]

          batch_y = Y_train[i*batch_size:(i+1)*batch_size]

          # Run optimization op (backprop) and cost op (to get loss value)

          _, c, p = sess.run([optimizer, cost, pred], feed_dict={x: batch_x,

                                                        y:batch_y})

          # Compute average loss

          avg_cost += c / total_batch

        #sample prediction

      label_value = batch_y

      estimate = p

      err = label_value-estimate

        print ("num batch:", total_batch)

        #Display logs per epoch step

      if epoch % display_step == 0:

          print ("Epoch:", '%04d' % (epoch+1), "cost=", \

              "{:.9f}".format(avg_cost))

          print ("[*]----------------------------")

          for i in xrange(3):

              print ("label value:", label_value[i], \

                    "estimatedvalue:", estimate[i])

          print ("[*]============================")

    print("Optimization Finished!")

    #Test model

  correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))

    #Calculate accuracy

  accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float"))

    print("Accuracy:", accuracy.eval({x: X_test, y: Y_test}))

TensorFlow回归

在运行到 loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(output,Y))

时，报错：

ValueError: Only call sigmoid_cross_entropy_with_logitswith named arguments (labels=…, logits=…, …)

应该改为

loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=output,logits=Y))

tensorflow中tf.random_normal和tf.truncated_normal的区别

1、tf.truncated_normal使用方法

tf.truncated_normal(shape, mean=0.0, stddev=1.0,dtype=tf.float32, seed=None, name=None)

从截断的正态分布中输出随机值。生成的值服从具有指定平均值和标准偏差的正态分布，如果生成的值大于平均值2个标准偏差的值则丢弃重新选择。

在正态分布的曲线中，横轴区间（μ-σ，μ+σ）内的面积为68.268949%。横轴区间（μ-2σ，μ+2σ）内的面积为95.449974%。横轴区间（μ-3σ，μ+3σ）内的面积为99.730020%。

X落在（μ-3σ，μ+3σ）以外的概率小于千分之三，在实际问题中常认为相应的事件是不会发生的，基本上可以把区间（μ-3σ，μ+3σ）看作是随机变量X实际可能的取值区间，这称之为正态分布的“3σ”原则。在tf.truncated_normal中如果x的取值在区间（μ-2σ，μ+2σ）之外则重新进行选择。这样保证了生成的值都在均值附近。

参数:

shape:一维的张量，也是输出的张量。

mean:正态分布的均值。

stddev:正态分布的标准差。

dtype:输出的类型。

seed:一个整数，当设置之后，每次生成的随机数都一样。

name:操作的名字

2、tf.random_normal使用方法

tf.random_normal(shape, mean=0.0, stddev=1.0,

dtype=tf.float32, seed=None, name=None)

从正态分布中输出随机值。参数:

shape:一维的张量，也是输出的张量。

mean:正态分布的均值。

stddev:正态分布的标准差。

dtype:输出的类型。

seed:一个整数，当设置之后，每次生成的随机数都一样。

name:操作的名字。

代码

a = tf.Variable(tf.random_normal([2,2],seed=1))

b = tf.Variable(tf.truncated_normal([2,2],seed=2))

init = tf.global_variables_initializer()

with tf.Session() as sess:

sess.run(init)

print(sess.run(a))

print(sess.run(b))

输出：

[[-0.81131822  1.48459876]

[ 0.06532937 -2.44270396]]

[[-0.85811085 -0.19662298]

[ 0.13895047 -1.22127688]]

tf.cast TensorFlow中的类型转换函数 cast(x, dtype, name=None) #将x的数据格式转换成dtype

tensorflow中的图上的节点称之为operations或者ops。我们可以使用 graph.get_operations()命令来获取图中的operations.

tf.matrix_solve(matrix, rhs, adjoint=None, name=None)

求解tf.matrix_solve(matrix,rhs, adjoint=None, name=None) matrix为方阵 shape为[M,M], rhs的shape为[M,K]，output为[M,K]

Tensorflow:AttributeError: 'module' object has no attribute 'mul'

tensorflow 版本为1.0.1后，

将tf.mul替换为tf.multiply后，错误问题解决。

Tensorflow中随机数生成种子tf.set_random_seed()

Tensorflow中的随机数生成种子是在数据流图资源上运作的。每一个数据流图中，我们可以执行针对随机数生成种子应用不同的操作（operation）。事实上，随机数生成种子作为random系列函数的参数之一，可在相应的参数列表进行设置，这就是op-level的操作。与之对应的是graph-level的操作tf.set_random_seed()，它管理着同一数据流图下的资源。

tensorflow中设置随机种子，可分为两类，图级seed和操作级seed, 情况1：当没有设置图级seed和操作级seed时，生成的随机数是随机的 情况2：当设置操作级seed时，生成的随机数是同一组随机数，没有设置操作级seed的操作，生成的随机数是随机的 情况3：当设置图级seed,将会生成同一组随机数，如果设置操作级seed又和情况2相同

tf.random_normal()函数

用于从服从指定正太分布的数值中取出指定个数的值。

tf.random_normal(shape,mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

  shape: 输出张量的形状，必选

  mean: 正态分布的均值，默认为0

  stddev: 正态分布的标准差，默认为1.0

  dtype: 输出的类型，默认为tf.float32

  seed: 随机数种子，是一个整数，当设置之后，每次生成的随机数都一样

  name: 操作的名称

tf.random_uniform 函数

从均匀分布中输出随机值。

生成的值在该 [minval,

maxval) 范围内遵循均匀分布。下限 minval 包含在范围内，而上限 maxval 被排除在外。

对于浮点数，默认范围是 [0, 1)。对于整数，至少 maxval 必须明确地指定。

在整数情况下，随机整数稍有偏差，除非 maxval -

minval 是 2 的精确幂。对于maxval - minval的值，偏差很小，明显小于输出（2**32 或者 2**64）的范围。

参数：

shape：一维整数张量或 Python 数组。输出张量的形状。

minval：dtype 类型的 0-D 张量或 Python 值；生成的随机值范围的下限；默认为0。

maxval：dtype 类型的 0-D 张量或 Python 值。要生成的随机值范围的上限。如果 dtype 是浮点，则默认为1 。

dtype：输出的类型：float16、float32、float64、int32、orint64。

seed：一个 Python 整数。用于为分布创建一个随机种子。查看 tf.set_random_seed 行为。

name：操作的名称（可选）。

返回：

用于填充随机均匀值的指定形状的张量。

可能引发的异常：

ValueError：如果 dtype 是整数并且 maxval 没有被指定。

TensorFlow四舍五入：tf.round函数

tf.round 函数

round(x,name=None)

定义在：tensorflow/python/ops/math_ops.py。

请参阅指南：数学函数>基本数学函数

将张量的值四舍五入为最接近的整数，元素。

均匀的舍入。也被称为banker四舍五入。如果要根据当前系统舍入模式进行舍入，请使用tf ::

cint。例如：

x = tf.constant([0.9, 2.5, 2.3, 1.5, -4.5])

tf.round(x)  # [1.0, 2.0, 2.0, 2.0, -4.0 ]

参数：

x：一个Tensor，类型必须为float32或float64。

name：操作的名称（可选）。

返回：

tf.round函数返回一个与x具有相同的形状和类型的Tensor。

tf.round(x,name=None) 舍入最接近的整数

# ‘a’ is [0.9, 2.5, 2.3, -4.4]

tf.round(a) ==> [ 1.0, 3.0, 2.0, -4.0 ]