8）Python模块：tensorflow

深度学习框架排名：

TensorFlow
Keras
Caffe

三大框架介绍
Microsoft Cognitive Toolkit
PyTorch
Apache MXnet
----------------------收藏人数10000
DeepLearning4J
Theano
TFLearn
Torch
Caffe2
PaddlePaddle
DLib
Chainer
Neon
Lasagne

TensorFlow
TensorFlow最初由谷歌的Machine Intelligence research organization 中Google Brain Team的研究人员和工程师开发的。这个框架旨在方便研究人员对机器学习的研究，并简化从研究模型到实际生产的迁移的过程。
收藏: 96655, 贡献人数: 1432, 程序提交次数: 31714, 建立日期: 2015年11月1日。
链接：
https://github.com/tensorflow/tensorflow

Keras
Keras是一个高层神经网络API，Keras由纯Python编写而成并基Tensorflow、Theano以及CNTK后端。Keras 为支持快速实验而生，能够把你的idea迅速转换为结果，如果你有如下需求，请选择Keras：
收藏: 28385, 贡献人数: 653, 程序提交次数: 4468, 建立日期: 2015年3月22日。
链接：
https://github.com/keras-team/keras

Caffe
Caffe是一个重在表达性、速度和模块化的深度学习框架，它由Berkeley Vision and Learning Center（伯克利视觉和学习中心）和社区贡献者共同开发。
收藏: 23750, 贡献人数: 267, 程序提交次数: 4128, 建立日期: 2015年9月8日。
链接：
https://github.com/BVLC/caffe

Microsoft Cognitive Toolkit
Microsoft Cognitive Toolkit（以前叫做CNTK）是一个统一的深度学习工具集，它将神经网络描述为一系列通过有向图表示的计算步骤。
收藏: 14243, 贡献人数: 174, 程序提交次数: 15613, 建立日期: 2014年7月27日。
链接：
https://github.com/Microsoft/CNTK

PyTorch
PyTorch是与Python相融合的具有强大的GPU支持的张量计算和动态神经网络的框架。
收藏: 14101, 贡献人数: 601, 程序提交次数: 10733, 建立日期: 2012年1月22日。
链接：
https://github.com/pytorch/pytorch

Apache MXnet
Apache MXnet是为了提高效率和灵活性而设计的深度学习框架。它允许使用者将符号编程和命令式编程混合使用，从而最大限度地提高效率和生产力。
收藏: 13699, 贡献人数: 516, 程序提交次数: 6953, 建立日期: 2015年4月26日。
链接：
https://github.com/apache/incubator-mxnet

sklearn和tensorflow区别

tf官网

Tensorflow是基于graph的并行计算模型，先学习 阵列(array),机器学习。

大部分 TensorFlow 函数会返回 tf.Tensors，少部分返回 tf.Operations。圆形或方形的节点被称为node，在node中流动的数据流被称为张量(tensor)

0阶张量 == 标量
1阶张量 == 向量（一维数组）
2阶张量 == 二维数组
…
n阶张量 == n维数组

tf核心数据单位是张量。一个张量由一组形成阵列（任意维数）的原始值组成。张量的阶是它的维数，形状是一个整数元组，指定了阵列每个维度的长度。TensorFlow 使用 numpy 阵列来表示张量值。tf.Tensors 不具有值，它们只是计算图中元素的手柄。

低级别 TensorFlow API (TensorFlow Core)，可以将 TensorFlow Core 程序看作由两个互相独立的部分组成：

1. 构建计算图 (tf.Graph)。
2. 运行计算图（ tf.Session）。

计算图是排列成一个图的一系列 TensorFlow 指令。图由两种类型的对象组成。

• 操作（op）：图的节点。操作描述了消耗和生成张量的计算。
• 张量 (tensor)：图的边。它们代表将流经图的值。

数据类型:tf.

int8 int16  int32 int64 
uint8 uint16  
float16 float32 float64(double)
string  bool
complex64 complex128

constant op:

在TensorFlow中，+−×÷+-\times \div+−×÷都有其特殊的函数表示。实际上，TensorFlow定义了足够多的函数来表示所有的数学运算，当然也对部分数学运算进行了运算符重载，但保险起见，我还是建议你使用函数代替运算符。比如用tf.add() replace +

a = tf.constant([[3.0,2.0],[1,1]], dtype=tf.float32,shape=(2,2),verify_shape=True)
b = tf.constant(4.0) # also tf.float32 implicitly
total = a + b

verify_shape=True：验证定义的content与shape是否相符，不符合会报错

a+b: a and b must are the same type

name: 如果不定义name,自动根据类型起名，如a is const1，b is const2, total is add0

constant: 图的输入层，肯定是常量，需要constant，中间运算过程还会用到variable，都用tensor承载

result:以上只是构建了图，想运作还要session.  sess=tf.Session();sess.run(total)

run 方法以透明方式处理元组或字典的任何组合，如下例所示：
print(sess.run({'ab':(a, b), 'total':total}))

vec = tf.random_uniform(shape=(3,))  生成tensor，生成随机3元矢量
out1 = vec + 1
out2 = vec + 2
print(sess.run(vec))

print(sess.run(vec)) 
print(sess.run((out1, out2))) （）仅仅是希望两者一起run，，3次run得到的vec不同

图可以参数化以便接受外部输入，也称为占位符。占位符表示承诺在稍后提供值，它就像函数参数。
x = tf.placeholder(tf.float32)
y = tf.placeholder(tf.float32)
z = x + y 有点像函数
print(sess.run(z, feed_dict={x: [1, 3], y: [2, 4]})) run的同时利用feed_dict给占位符赋值

数据集，迭代器
my_data = [
    [0, 1,],
    [2, 3,],
    [4, 5,],
    [6, 7,],
]
dataset = tf.data.Dataset.from_tensor_slices(my_data)
next_item = dataset.make_one_shot_iterator().get_next()
while True:
  try:
    print(sess.run(next_item))
  except tf.errors.OutOfRangeError:
    break

r = tf.random_normal([10,3])
dataset = tf.data.Dataset.from_tensor_slices(r)
iterator = dataset.make_initializable_iterator()  单独拆出iterator 供下面初始化
next_item = iterator.get_next()
sess.run(iterator.initializer)  Dataset 依赖于有状态操作，需要在使用迭代器之前先初始化它
while True:
  try:
    print(sess.run(next_item))
  except tf.errors.OutOfRangeError:
    break

层(dense):
层将变量和作用于它们的操作打包在一起。例如，密集连接层会对每个输出对应的所有输入执行加权和，并应用激活函数（可选）。连接权重和偏差由层对象管理。

创建层
x = tf.placeholder(tf.float32, shape=[None, 3])
linear_model = tf.layers.Dense(units=1);y = linear_model(x)
or  y=tf.layers.Dense(x,units=1)
初始化层
init = tf.global_variables_initializer() 初始化变量
sess.run(init)
执行层
print(sess.run(y, {x: [[1, 2, 3],[4, 5, 6]]}))

特征列？？？

features = {
    'sales' : [[5], [10], [8], [9]],
    'department': ['sports', 'sports', 'gardening', 'gardening']}

department_column = tf.feature_column.categorical_column_with_vocabulary_list('department', ['sports', 'gardening'])
department_column = tf.feature_column.indicator_column(department_column)

columns = [
    tf.feature_column.numeric_column('sales'),
    department_column
]

inputs = tf.feature_column.input_layer(features, columns)  函数只接受密集列作为输入

var_init = tf.global_variables_initializer()    初始化内部状态
table_init = tf.tables_initializer()  对照表初始化
sess = tf.Session()
sess.run((var_init, table_init))
print(sess.run(inputs)) 运行 inputs 张量会将 features 解析为一批向量。

train

import tensorflow as tf
#定义数据
x = tf.constant([[1], [2], [3], [4]], dtype=tf.float32)
y_true = tf.constant([[0], [-1], [-2], [-3]], dtype=tf.float32)
#定义模型,采用线性模型
linear_model = tf.layers.Dense(units=1)
y_pred = linear_model(x)
#要优化模型，您首先需要定义损失。使用均方误差，这是回归问题的标准损失。
loss = tf.losses.mean_squared_error(labels=y_true, predictions=y_pred)
#优化器 梯度下降算法，通过这个改变模型的系数
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
#初始化
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
#训练100次，训练次数越大，结果越准确
for i in range(1000):
  _, loss_value = sess.run((train, loss))
  print(loss_value)

print(sess.run(y_pred))

 

batch_size：

https://www.cnblogs.com/gengyi/p/9853664.html

实例2

import tensorflow as tf

#取数据
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)


# 超参数
learning_rate = 0.5  #学习率
epochs = 10  #训练次数
batch_size = 100  #批数目

# 输入图片为28 x 28 像素 = 784
x = tf.placeholder(tf.float32, [None, 784])
# 输出为0-9的one-hot编码
y = tf.placeholder(tf.float32, [None, 10])

# hidden layer => w, b
W1 = tf.Variable(tf.random_normal([784, 300], stddev=0.03), name='W1')
b1 = tf.Variable(tf.random_normal([300]), name='b1')
# output layer => w, b
W2 = tf.Variable(tf.random_normal([300, 10], stddev=0.03), name='W2')
b2 = tf.Variable(tf.random_normal([10]), name='b2')

# hidden layer
hidden_out = tf.add(tf.matmul(x, W1), b1)
hidden_out = tf.nn.relu(hidden_out)

# 计算输出
y_ = tf.nn.softmax(tf.add(tf.matmul(hidden_out, W2), b2))

#损失为交叉熵
y_clipped = tf.clip_by_value(y_, 1e-10, 0.9999999)#对n个标签计算交叉熵
cross_entropy = -tf.reduce_mean(tf.reduce_sum(y * tf.log(y_clipped) +
                                              (1 - y) * tf.log(1 - y_clipped), axis=1))#对m个样本取平均

# 创建优化器，确定优化目标
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cross_entropy)

# init operator
init_op = tf.global_variables_initializer()

# 创建准确率节点
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))#返回一个m×1m×1的tensor，tensor的值为True/False表示是否正确预测。
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

# 创建session
with tf.Session() as sess:
    # 变量初始化
    sess.run(init_op)
    total_batch = int(len(mnist.train.labels) / batch_size)
    for epoch in range(epochs):
        avg_cost = 0
        for i in range(total_batch):
            batch_x, batch_y = mnist.train.next_batch(batch_size=batch_size)
            _, c = sess.run([optimizer, cross_entropy], feed_dict={x: batch_x, y: batch_y})
            avg_cost += c / total_batch
        print("Epoch:", (epoch + 1), "cost = ", "{:.3f}".format(avg_cost))
    print('accuracy:', sess.run(accuracy, feed_dict={x: mnist.test.images, y: mnist.test.labels}))