TensorFlow学习笔记1

TensorFlow安装与入门

TensorFlow 是一个用于人工智能的开源神器

TensorFlow安装
安装：pip install tensorflow
安装指定版本:pip install tensorflow==1.9.0

TensorFlow入门
1.计算模型：计算图
2.数据模型：张量（tensor）
3.运行模型：会话（session）

Tensor：张量（数据类型）
Flow：流
通过计算图的形式表达计算的编程系统
计算图（可默认生成）：节点／操作（op）
a = tf.constant([1.0,2.0],name=‘a’)
b = tf.constant([2.0,3.0],name=‘b’)
result = a+b
注意：此过程只生成计算图，并不执行计算

TensorFlow程序的两个阶段
1.定义计算（在计算图中）
2.执行计算（在会话中）

import tensorflow as tf
# 第一步：定义计算（计算图）
a = tf.constant([1.0, 2])
b = tf.constant([2.0, 3])
res = a+b
print(res)

# 第二步：执行计算（会话中）
sess = tf.Session()    # 启动会话
res1 = sess.run(res)
sess.close()   # 关闭会话
print(res1)

结果：

Tensor(“add:0”, shape=(2,), dtype=float32)
[3. 5.]

TensorFlow数据类型

张量（tensor）
类比多维数组（numpy中的ndarray）
类型：标量、向量、矩阵、数组等
作用：对计算结果的引用、获得计算结果

使用图（graph）来表示计算任务
在被称之为会话（Session）的上下文（context）中执行图
使用tensor表示数据
通过变量（variable）维护状态
使用feed和fetch可以为任意的操作（operation）赋值或者从其中获取数据

会话（Session）
sess = tf.Session() #生成一个会话
sess.run(result) #在会话中执行计算
#sess.eval(result) #在会话中执行计
sess.close() #关闭会话

import numpy as np
import tensorflow as tf

data = np.float32(np.load('line_fit_data.npy'))  # 导入100个样本数据
x_data = data[:, :2]   # 样本自变量
y_data = data[:, 2:]   # 样本实际值
'''
定义计算（计算图）
'''
w = tf.Variable(tf.zeros([2, 1]))
bias = tf.Variable(tf.zeros([1]))
y = tf.matmul(x_data, w) + bias   # 构造一个线性模型
loss = tf.reduce_mean(tf.square(y_data - y))  # 定义损失函数，reduce_mean均值，square平方函数

optimizer = tf.train.GradientDescentOptimizer(0.5)   # 构建梯度下降法优化器
train = optimizer.minimize(loss)   # 定义训练函数
'''
执行计算（会话中）
'''
# 启动会话
sess = tf.Session()
sess.run(tf.global_variables_initializer())   # 初始化变量
# sess.run(y)
for i in range(100):
    print('第', i, '轮训练后的模型损失值：', sess.run(loss))
    sess.run(train)   # 开始训练

sess.run([w, bias])   # y = 0.1*x1 + 0.2*x2 + 0.3
sess.close()

SoftMax函数Mnist手写数字识别

SoftMax网络结构

常量占位符placeholder

确认网络的输入与目标输出，设置两个占位符，用户后续存放样本数据
x_data = tf.placeholder(tf.float32,[None,784]) #输入数据设置,(输入数据类型,数据尺寸[不限条数,784个维度])，x不是一个特定的值，而是一个占位符placeholder
y_data= tf.placeholder(tf.float32,[None,10]) #占位符：样本真实类别

变量声明Variable

构建网络权值和偏置项
W = tf.Variable(tf.zeros([784,10])) #784维(特征),10个类别
b = tf.Variable(tf.zeros([10])) #偏置项

数据在网络上进行传递

下面这行代码实现函数映射y=softmax(W*x+b)
＃y代表网络输出
y = tf.nn.softmax(tf.matmul(x,W)+b) #tf.nn包含大量网络组件,tf.matmul实现矩阵乘法

交叉熵cross-entropy

即两个分布之间的距离/相似度
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), axis=1)) #计算交叉熵#首先，用 tf.log 计算 y 的每个元素的对数。接下来，我们把 y_ 的每一个元素和 tf.log(y) 的对应元素相乘。最后，用 tf.reduce_sum 按行求和。

最小化损失函数

#权值优化算法:梯度下降法，0.5的学习速率
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

创建会话，准备训练模型

sess = tf.InteractiveSession() #创建一个会话
tf.global_variables_initializer().run() #全局参数初始化

传入训练集数据，进行模型训练

开始训练,每次随机抽100个样本作为输入

for i in range(1000):
batch_xs, batch_ys = mnist.train.next_batch(100)
train_step.run({x:batch_xs,y_:batch_ys})
if i % 50 == 0:
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, “float”))
print("Setp: ", i, "Accuracy: ", sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

模型评估

correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(y_,1)) #tf.argmax(y_,1):求预测出的数字中概率最大的那个,然后比较真实值和预测值是否匹配,返回一个布尔值向量
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32)) #将返回的布尔向量转化为浮点数,然后求均值
print(accuracy.eval({x:mnist.test.images,y_:mnist.test.labels})) #放入测试集数据,计算准确率
sess.close() #关闭会话

整体代码：

from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf

mnist = input_data.read_data_sets('MNIST_data', one_hot=True)   # 读取数据,且MNIST_data是已经处理好的数据
x_data = tf.placeholder(tf.float32, [None, 784])  # 占位符：样本自变量，不限定行数，784列
y_data = tf.placeholder(tf.float32, [None, 10])   # 占位符：样本目标变量，不限定行数，10列

w = tf.Variable(tf.zeros([784, 10]))   # 网络权值矩阵，初值全为0
bias = tf.Variable(tf.zeros([10]))     # 网络阈值，初值全为0
y = tf.nn.softmax(tf.matmul(x_data, w) + bias)   # 网络输出，使用softmax函数进行非线性映射

#axis=1，作用是按行求和，否则是全部数据的和
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_data*tf.log(y), axis=1))  # 交叉熵（损失函数）
optimizer = tf.train.GradientDescentOptimizer(0.03)   # 梯度下降法优化器
train = optimizer.minimize(cross_entropy)   # 训练节点
#argmax()是取最大值的位置，cast(a,dtype=tf.float32)是将a转为32位的浮点型，reduce_mean()取平均值
acc = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(y, axis=1), tf.argmax(y_data, axis=1)), dtype=tf.float32))  # 模型预测值与样本实际值比较的精度

sess = tf.Session()  # 启动会话
sess.run(tf.global_variables_initializer())  # 执行变量初始化操作
for i in range(20000):
    x_s, y_s = mnist.train.next_batch(100)#随机从mnist.train中取100个样本，自变量赋给x_s因变量赋给 y_s
    if i%1000 == 0:
        acc_tr = sess.run(acc, feed_dict={x_data: x_s, y_data: y_s})
        print(i, '轮训练的精度', acc_tr)
    sess.run(train, feed_dict={x_data:x_s, y_data:y_s})   # 模型训练

acc_te = sess.run(acc, feed_dict={x_data:mnist.test.images, y_data:mnist.test.labels})  # 测试集精度
print('模型测试精度：', acc_te)
sess.close()




# # MNIST数据探索
#mnist = input_data.read_data_sets('MNIST_data', one_hot=True)   # 读取数据
# MNIST_data是已经处理好的数据，有train.images，train.labels，test.images，test.labels
# mnist.train.images[0]   # 训练集样本自变量（灰度值）
# mnist.train.labels[0]
#
# mnist.train.images.shape   # (55000, 784) 55000张图片，每张图片有784个像素值
# mnist.train.labels.shape   # 一共有55000张图片，每张图片都有一个标签
#
# mnist.test.images.shape        # 测试集样本自变量（灰度值）
# mnist.test.labels.shape
# # '还原某张图片'
# import matplotlib.pyplot as plt
# a = mnist.train.images[2]
# b = a.reshape([28, 28])*255
# plt.imshow(b)

# '''
# 交叉熵
# '''
# # real: 0   [1,  0,  0,  0,  0,0,0,0,0,0]
# # p1: 1     [0.4,0.5,0.1,0,  0,0,0,0,0,0]
# # p2: 2     [0,  0.4,0.5,0.1,0,0,0,0,0,0]
#
# import numpy as np
#
# real = np.array([1,  0,  0,  0,  0,0,0,0,0,0])
# p1 =   np.array([0.4,0.5,0.1,0,  0,0,0,0,0,0])
# p2 =   np.array([0,  0.4,0.5,0.1,0,0,0,0,0,0])
#
# -sum(real*np.log(p1+0.0000001))
# -sum(real*np.log(p2+0.0000001))