tensorflow学习笔记及分类鸢尾花
TensorFlow框架介绍
tensorflow简介
tensorflow 版本：
2019.3 Tensorflow 2.0 测试版发布
2019.10 Tensorflow 2.0 正式版发布
2020.1 Tensorflow 2.1 发布
2020.5 Tensorflow 2.2 发布
2020.7 Tensorflow 2.3 发布
2020.12 Tensorflow 2.4 发布
张量
张量(Tensor)：多维数组(列表) 阶：张量的维数
| 维数 | 阶 | 名字 | 例子 |
|---|---|---|---|
| 0-D | 0 | 标量 scalar | s = 1 2 3 |
| 1-D | 1 | 向量 vector | v = [1, 2, 3] |
| 2-D | 2 | 矩阵 matrix | m = [[1, 2, 3],[4, 5, 6]] |
| 3-D | N | 张量 tensor | t = [[[(n个[)]]] |
张量可以表示0阶到n阶数组(列表)
数据类型
- tf.int, tf.float
- uf.int32, tf.float 32, tf.float 64
- tf.bool
- tf.constant([True, False])
- tf.string
- tf.constant(“Hello, world!”)
如何创建一个Tensor
创建一个张量
tf.constant(张量内容, dtype=数据类型(可选))
import tensorflow as tf
a = tf.constant([1,5], dtype=tf.int64)
print(a)
print(a.dtype)
print(a.shape)
tf.Tensor([1 5], shape=(2,), dtype=int64) # 有一个逗号，说明是1维，2说明这个张量里面有两个元素
<dtype: 'int64'>
(2,)
tf.convert_to_tensor 将numpy的数据类型转换为Tensor数据类型
import tensorflow as tf
import numpy as np
a = np.arange(0, 5)
b = tf.convert_to_tensor(a, dtype=tf.int64)
print(a)
print(b)
[0 1 2 3 4]
tf.Tensor([0 1 2 3 4], shape=(5,), dtype=int64)
创建全为0的张量 tf.zeros(维度)
创建全为1的张量 tf.ones(维度)
创建全为指定值的张量 tf.fill(维度，指定值)
维度：
一维：直接写个数
二维：用[行, 列]
多维：用[n, m, j, k, …]
import tensorflow as tf
a = tf.zeros([2, 3])
b = tf.ones(4)
c = tf.fill([2, 2], 9)
print(a)
print(b)
print(c)
tf.Tensor(
[[0. 0. 0.]
[0. 0. 0.]], shape=(2, 3), dtype=float32)
tf.Tensor([1. 1. 1. 1.], shape=(4,), dtype=float32)
tf.Tensor(
[[9 9]
[9 9]], shape=(2, 2), dtype=int32)
生成正态分布的随机数，默认均值为0，标准差为1 tf.random.normal(维度, mean=均值, stddev=标准差)
生成截断式正态分布的随机数 tf.random.truncated_normal(维度, mean=均值, stddev=标准差)
在tf.truncated_normal中如果随机生成数据的取值在(μ-2σ, μ+2σ)之外，则重新进行生成，保诚了生成值在均值附近
μ：均值， σ：标准差
import tensorflow as tf
d = tf.random.normal([2, 2], mean=0.5, stddev=1)
print(d)
e = tf.random.truncated_normal([2, 2], mean=0.5, stddev=1)
print(e)
tf.Tensor(
[[ 0.27887052 0.3107911 ]
[-0.22705865 0.69289273]], shape=(2, 2), dtype=float32)
tf.Tensor(
[[-0.06947243 2.1420374 ]
[ 0.2826671 0.04889098]], shape=(2, 2), dtype=float32)
生成均匀分布随机数 [minval, maxval]
tf.random.uniform(维度, minval=最小值, maxval=最大值)
import tensorflow as tf
f=tf.random.uniform([2,2],minval=0,maxval=1)
print(f)
tf.Tensor(
[[0.7174144 0.39671743]
[0.8941096 0.11793673]], shape=(2, 2), dtype=float32)
常用函数
强制tensor转换为该数据类型 tf.cast(张量名. dtype=数据类型)
计算张量维度上元素的最小值 tf.reduce_min(张量名)
计算张量维度上元素的最大值 tf.reduce_max(张量名)
计算张量维度上元素的平均值 tf.reduce_mean
计算张量维度上元素的和 tf.reduce_sum
import tensorflow as tf
x1 = tf.constant([1, 2, 3], dtype=tf.float64)
print(x1)
x2 = tf.cast(x1, tf.int32)
print(x2)
print(tf.reduce_min(x2), tf.reduce_max(x2))
tf.Tensor([1. 2. 3.], shape=(3,), dtype=float64)
tf.Tensor([1 2 3], shape=(3,), dtype=int32)
tf.Tensor(1, shape=(), dtype=int32)
tf.Tensor(3, shape=(), dtype=int32)
axis
在一个二维张量或数组中，可以通过调整axis等于0或1控制执行维度。
axis = 0代表跨行(经度，down)，而axis = 1代表跨列(纬度，across)
如果不指定axis，则所有元素参与计算
计算张量沿指定维度的平均值tf.reduce_mean(张量名, axis=操作轴)
计算张量沿指定维度的和 tf.reduce_sum(张量名, axis=操作轴)
import tensorflow as tf
x = tf.constant([[1, 2, 3], [2, 2, 3]])
print(x)
print(tf.reduce_mean(x))
print(tf.reduce_sum(x, axis=1))
print(tf.reduce_sum(x, axis=0))
tf.Tensor(
[[1 2 3]
[2 2 3]], shape=(2, 3), dtype=int32)
tf.Tensor(2, shape=(), dtype=int32)
tf.Tensor([6 7], shape=(2,), dtype=int32)
tf.Tensor([3 4 6], shape=(3,), dtype=int32)
tf.Variable
tf.Variable()将变量标记为“可训练”，被标记的变量会在反向传播中记录梯度信息。神经网络训练中，常用该函数标记待训练参数。
tf.Variable(初始值)
w = tf.Variable(tf.random.normal([2, 2], mean=0, stddev=1))
数学运算
对应元素的四则运算：tf.add, tf.subtract, tf.multiply, tf.divide
- 两个张量相加：
tf.add(张量1, 张量2) - 两个张量相减：
tf.subtract(张量1, 张量2) - 两个张量相乘：
tf.multiply(张量1, 张量2) - 两个张量相除：
tf.divide(张量1, 张量2) - 只有维度相同的张量才可以做四则运算
平方、次方与开方：tf.square, tf.pow, tf.sqrt
- 计算某个张量的平方：
tf.square(张量名) - 计算某个张量的n次方：
tf.pow(张量名, n次方数) - 计算某个张量的开方：
tf.sqrt(张量名)
矩阵乘：tf.matmul
- 实现两个矩阵的相乘：
tf.matmul(矩阵1, 矩阵2)
import tensorflow as tf
a = tf.ones([1, 3])
b = tf.fill([1, 3], 3.)
print(a)
print(b)
print(tf.add(a, b))
print(tf.subtract(a, b))
print(tf.multiply(a, b))
print(tf.divide(a, b))
tf.Tensor([[1. 1. 1.]], shape=(1, 3), dtype=float32)
tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)
tf.Tensor([[4. 4. 4.]], shape=(1, 3), dtype=float32)
tf.Tensor([[-2. -2. -2.]], shape=(1, 3), dtype=float32)
tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)
tf.Tensor([[0.33333334 0.33333334 0.33333334]], shape=(1, 3), dtype=float32)
import tensorflow as tf
a = tf.fill([1,3],3.)
print(a)
print(tf.pow(a, 3))
print(tf.square(a))
print(tf.sqrt(a))
tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)
tf.Tensor([[27. 27. 27.]], shape=(1, 3), dtype=float32)
tf.Tensor([[9. 9. 9.]], shape=(1, 3), dtype=float32)
tf.Tensor([[1.7320508 1.7320508 1.7320508]], shape=(1, 3), dtype=float32)
import tensorflow as tf
a = tf.ones([3,2])
b = tf.fill([2, 3], 3.)
print(tf.matmul(a, b))
tf.Tensor(
[[6. 6. 6.]
[6. 6. 6.]
[6. 6. 6.]], shape=(3, 3), dtype=float32)
tf.data.Dataset.from_tensor_slices
把数据集的特征和标签配对的函数
Numpy和Tensor格式抖可用该语句读入数据
切分传入张量的第一维度，生成输入特征/标签对，构建数据集
data = tf.data.Dataset.from_tensor_slices((输入特征, 标签))
import tensorflow as tf
features = tf.constant([12, 23, 10, 17])
labels = tf.constant([0, 1, 1, 0])
dataset = tf.data.Dataset.from_tensor_slices((features, labels))
print(dataset)
for element in dataset:
print(element)
<TensorSliceDataset shapes: ((), ()), types: (tf.int32, tf.int32)>
(<tf.Tensor: shape=(), dtype=int32, numpy=12>, <tf.Tensor: shape=(), dtype=int32, numpy=0>)
(<tf.Tensor: shape=(), dtype=int32, numpy=23>, <tf.Tensor: shape=(), dtype=int32, numpy=1>)
(<tf.Tensor: shape=(), dtype=int32, numpy=10>, <tf.Tensor: shape=(), dtype=int32, numpy=1>)
(<tf.Tensor: shape=(), dtype=int32, numpy=17>, <tf.Tensor: shape=(), dtype=int32, numpy=0>)
tf.GradientTape求导
with 结构记录计算过程，gradient求出张量的梯度
with tf.GradientTape() as tape:
若干个计算过程
grad = tape.gradient(函数, 对谁求导)
import tensorflow as tf
with tf.GradientTape() as tape:
w = tf.Variable(tf.constant(3.0))
loss = tf.pow(w, 2)
grad = tape.gradient(loss, w)
print(grad)
tf.Tensor(6.0, shape=(), dtype=float32)
enumerate
enumerate是python的内建函数，它可遍历每个元素（如列表、元组或字符串），组合为：索引 元素，常在for循环中使用enumerate(列表名)
seq = ['one', 'two', 'three']
for i,element in enumerate(seq):
print(i, element)
0 one
1 two
2 three
tf.one_hot
独热编码(one-hot encoding):在分类问题中，常用独热码做标签，标记类别：1表示是，0表示非
tf.one_hot()函数将待转换数据，转换为ont-hot形式的数据输出
tf.one_hot(待转换数据，depth=几分类)
classes = 3
import tensorflow as tf
classes = 3
labels = tf.constant([1, 0, 2]) # 输入的元素值最小为0，最大为2
output = tf.one_hot(labels, depth=classes)
print(output)
tf.Tensor(
[[0. 1. 0.]
[1. 0. 0.]
[0. 0. 1.]], shape=(3, 3), dtype=float32)
tf.nn.softmax
当n分类的n个输出(y0, y1, …, yn-1)通过softmax()函数，使符合概率分布
import tensorflow as tf
y = tf.constant([1.01, 2.01, -0.66])
y_pro = tf.nn.softmax(y)
print(y_pro)
tf.Tensor([0.25598174 0.69583046 0.04818781], shape=(3,), dtype=float32)
assign_sub
- 赋值操作，更新参数的值并返回，常用于参数的自更新
- 调用assign_sub前，先用tf.Variable定义变量w为可训练(可自更新)
- w.assign_sub(w要自减的内容)
import tensorflow as tf
w = tf.Variable(4)
w.assign_sub(1)
print(w)
<tf.Variable 'Variable:0' shape=() dtype=int32, numpy=3>
tf.argmax
返回张量沿指定维度最大值的索引tf.argmax(张量名, axis=操作轴)
import numpy as np
import tensorflow as tf
test = np.array([[1, 2, 3], [2, 3, 4], [5, 4, 3], [8, 7, 2]])
print(test)
print(tf.argmax(test, axis=1))
print(tf.argmax(test, axis=0))
[[1 2 3]
[2 3 4]
[5 4 3]
[8 7 2]]
tf.Tensor([2 2 0 0], shape=(4,), dtype=int64)
tf.Tensor([3 3 1], shape=(3,), dtype=int64)
tensorflow分类鸢尾花(Iris)
鸢尾花包括三类：0狗尾草鸢尾，1杂色鸢尾，2弗吉尼亚鸢尾
人们通过经验总结出了规律：通过测量画的花萼长、花萼宽、花瓣长、花瓣宽，可以得出鸢尾花的类别。
（如：花萼长 > 花萼宽 且 花瓣长/花瓣宽 > 2 则为 1杂色鸢尾）
if语句 case语句 —— 专家系统 把专家的经验告知计算机，计算机执行逻辑判别（理性计算 ），给出分类。
神经网络：采集大量（花萼长、花萼宽、花瓣长、花瓣宽（输入特征），对应的类别（标签、需人工标定））数据对构成数据集
把数据集喂入搭建好的神经网络结构，网络优化参数得到模型，模型读入新输入特征，输出识别结果。
Iris数据集：
- 数据总数：150组
- 特征数：4个
- 类别：3个（狗尾草鸢尾Setosa Iris，杂色鸢尾Versiccolour Iris，弗吉尼亚鸢尾Virginica Iris三类，分别用数字0，1，2表示
数据集读入并使用pandas处理：
import tensorflow as tf
import numpy as np
from sklearn import datasets
from pandas import DataFrame
import pandas as pd
x_data = datasets.load_iris().data # 返回Iris数据集所有输入特征
y_data = datasets.load_iris().target # 返回Iris数据集所有标签
print("x_data from datasets: \n", x_data)
print("y_data from datasets: \n", y_data)
x_data = DataFrame(x_data, columns=['花萼长度', '花萼宽度', '花萼长度', '花瓣宽度']) # 将数据转化为表格形式，并添加标题
pd.set_option('display.unicode.east_asian_width', True) # 设置列名对齐
print("x_data add index:\n", x_data)
x_data['类别'] = y_data # 新加一列，列标签为‘类别’，数据为y_data
print("x_data add a column:\n", x_data)
# 类型维度不确定时，建议用print函数打印出来确认效果
三部通过神经网络实现鸢尾花分类
-
准备数据
- 数据集读入
- 数据集乱序
- 生成训练集和测试集(即x_train/y_train, x_test / y_test)
- 配成（输入特征，标签）对，每次读入一小撮(batch)
-
搭建网络
- 定义神经网络中所有可训练参数
-
参数优化
- 嵌套循环迭代，with结构更新参数，显示当前loss
测试效果
- 计算当前参数前向传播后的准确率，显示当前acc
acc/loss可视化
# 导入所需模块
import tensorflow as tf
from sklearn import datasets
from matplotlib import pyplot as plt
import numpy as np
# 导入数据, 分别为输入特征标签
x_data = datasets.load_iris().data
y_data = datasets.load_iris().target
# 随机打乱数据(因为原始数据是顺序的，顺序不打乱会影响准确率)
# seed：随机数种子，是一个整数，当设置之后，每次生成的随机数都一样
np.random.seed(116)
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
# 将打乱后的数据集分割为训练集和测试集，训练集为前120行，测试集为后30行
x_train = x_data[:-30]
y_train = y_data[:-30]
x_test = x_data[-30:]
y_test = y_data[-30:]
# 转换x的数据类型，否则后面矩阵相乘时会因数据类型不一致报错
x_train = tf.cast(x_train, tf.float32)
x_test = tf.cast(x_test, tf.float32)
# from_tensor_slices函数使输入特征和标签值一一对应。 把数据集分批次，每个批次batch组数据
train_db = tf.data.Dataset.from_tensor_slices((x_train, y_train)).batch(32)
test_db = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(32)
# 生成神经网络的参数，4个输入特征，输入层为四个输入节点；因为三分类，输出层为3个神经元
# 用tf.Variable()标记参数为可训练
# 使用seed使每次生成的随机数相同
w1 = tf.Variable(tf.random.truncated_normal([4, 3], stddev=0.1, seed=1))
b1 = tf.Variable(tf.random.truncated_normal([3], stddev=0.1, seed=1))
lr = 0.1 # 学习率为0.1
train_loss_results = [] # 将每轮的loss记录在此列表中，为后续化loss曲线提供数据
test_acc = [] # 将每轮的acc记录在此列表中，为后续画acc曲线提供数据
epoch = 500 # 循环500轮
loss_all = 0 # 每轮分4个step，loss_all记录四个step生成的4个loss的和
# 训练部分
for epoch in range(epoch): # 数据集级别的循环，每个epoch循环一次数据集
for step, (x_train, y_train) in enumerate(train_db): # batch级别的循环
with tf.GradientTape() as tape: # with结构记录梯度信息
y = tf.matmul(x_train, w1) + b1 # 神经网络乘加运算
y = tf.nn.softmax(y) # 使输出y符合概率分布
y_ = tf.one_hot(y_train, depth=3) # 将标签值转换为独热码格式
loss = tf.reduce_mean(tf.square(y_ - y)) # 采用均方误差为损失函数
loss_all += loss.numpy() # 将每个step计算出的loss累加，为后续求loss平均值提供做准备
# 计算loss对各个参数的梯度
grads = tape.gradient(loss, [w1, b1])
# 实现梯度更新 w1 = w1 - lr * w1_grad b = b - lr * b_grad
w1.assign_sub(lr * grads[0]) # 参数w1自更新
b1.assign_sub(lr * grads[1]) # 参数b自更新
# 每个epoch，打印loss信息
print("Epoch {}, loss:{}".format(epoch, loss_all/4))
train_loss_results.append(loss_all / 4) # 将4个step的loss求平均记录在此变量中
loss_all = 0 # loss_all 归零，为记录下一个epoch的loss做准备
# 测试部分
# total_correct为预测对的样本个数，total_number为测试的总样本数，将这两个变量都初始化为0
total_correct, total_number = 0, 0
for x_test, y_test in test_db:
# 使用更新后的参数进行预测
y = tf.matmul(x_test, w1) + b1
y = tf.nn.softmax(y)
pred = tf.argmax(y, axis=1) # 返回y中最大值的索引
pred = tf.cast(pred, dtype=y_test.dtype) # 将pred转换为y_test的数据类型
correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32) # 若分类正确，则correct=1，否则为0，将bool型的结果转换为int
correct = tf.reduce_sum(correct) # 将每个batch中的correct数加起来
total_correct += int(correct) # 将所有batch中correct数加起来
total_number += x_test.shape[0] # 记录总样本数
# 总的准确率等于total_correct/total_number
acc = total_correct / total_number
test_acc.append(acc)
print("Test_acc:", acc)
print("---------------------------------")
# 绘制 loss 曲线
plt.title('Loss Function Curve') # 图片标题
plt.xlabel("Epoch") # x轴变量名称
plt.ylabel("Loss") # y轴变量名称
plt.plot(train_loss_results, label="$Loss$") # 逐点画出train_loss_results值并连线
plt.legend() # 画出曲线图标
plt.show() # 画出图像
# 绘制accuracy曲线
plt.title("Accuracy Curve")
plt.xlabel('Epoch')
plt.ylabel('Acc')
plt.plot(test_acc, label="$Accuracy$")
plt.legend()
plt.show()
