人工智能实践入门Tensorflow2.0-Day1引入

引入

最近开始学Tensorflow2.0啦，自己码了一遍代码，我也是新手，难免有错，欢迎大家指出错误、学习交流、共同进步。

一、整体知识概览

先从整体看看要学哪些知识吧~总共分为六个章节，我计划每次更新一个章节，重点在卷积神经网络。

1.1 第一章知识概览

（1）Tensorflow基本概念

（2）Tensorflow常用函数

1.2第二章知识概览

1.3 第三章知识概览

1.4 第四章知识概览

1.5 第五章知识概览

1.6第六章知识概览

二、第一章代码实现

2.1 Tensorflow基础与常用函数

# 反向传播
import tensorflow as tf

w = tf.Variable(tf.constant(5, dtype=tf.float32))  # 变量标记为可训练
lr = 0.2
epoch = 40
for epoch in range(epoch):
    with tf.GradientTape() as tape:  # with结构到grads框起了梯度计算的过程
        loss = tf.square(w + 1)
    grads = tape.gradient(loss, w)  # gradient函数告知谁对谁求导
    w.assign_sub(lr * grads)  # assign_sub对变量作自减
    print("After %s epoch, w is %f，loss is %f" % (epoch, w.numpy(), loss))

# 创建一个张量
import tensorflow as tf

a = tf.constant([1, 5], dtype=tf.int64)
print(a)
print(a.dtype)
print(a.shape)

# 将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)

# 创建特定的Tensor
a = tf.zeros([2, 3])
b = tf.ones(4)
c = tf.fill([2, 2], 9)
print(a)
print(b)
print(c)
d = tf.random.normal([2, 2], means=0.5, stddev=1)
print(d)
e = tf.random.truncated_normal([2, 2], means=0.5, stddev=1)
print(e)
f = tf.random.uniform([2, 2], minval=0, maxval=1)

# 常用函数
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))

x = tf.constant([1, 2, 3], [2, 2, 3])
print(x)
print(tf.reduce_mean(x))
print(tf.reduce_sum(x, axis=1))

w = tf.Variable(tf.random.normal([2, 2], means=0, stddev=1))

# 数学运算
a = tf.ones([3, 2])
b = tf.fill([2, 3], 3.)
print(tf.matmul(a, b))

# 特征和标签配对
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)

# 函数对参数的求导运算,with结构记录计算过程，gradient求出张量的梯度
with tf.GradientTape() as tape:
    w = tf.Variable(tf.constant(3.0))
    loss = tf.pow(w, 2)
grad = tape.gradient(loss, w)
print(grad)

# enumerate
seq = ['one', 'two', 'three']
for i, element in enumerate(seq):
    print(i, element)

#tf.one_hot
classes=3
labels=tf.constant([1,0,2])
output=tf.one_hot(labels,depth=classes)
print(output)

#tf.nn.softmax
y=tf.constant([1.01,2.01,-0.66])
y_pro=tf.nn.softmax(y)
print(y_pro)

#assign_sub
w=tf.Variable(4)
w.assign_sub(1)
print(w)

#tf.argmax
import numpy as np
test=np.array([[1,2,3],[2,3,4],[5,4,3],[8,7,2]])
print(test)
print(tf.argmax(test,axis=0))#返回每一列最大值的索引
print(tf.argmax(test,axis=1))#返回每一行最大值的索引

2.2 鸢尾花分类Tensorflow实例

# 鸢尾花数据集读入
from sklearn import datasets
#from pandas import DataFrame
#import pandas as pd
import tensorflow as tf
import numpy as np
from matplotlib import pyplot as plt

x_data = datasets.load_iris().data  # 返回iris数据集所有数据集
y_data = datasets.load_iris().target  # 返回iris数据集所有标签
print("x_data:\n", x_data)
print("y_data:\n", y_data)

# x_data = DataFrame(x_data, colums=['花萼长', '花萼宽', '花瓣长', '花瓣宽'])
# pd.set_option('display.unicode.east_asian_width', True)  # 设置列名对齐
# print('x_data add index:\n', x_data)
#
# x_data['类别'] = y_data
# print('x_data add a column:\n', x_data)

# 数据集乱序


np.random.seed(116)  # 使用相同的seed，使输入特征/标签一一对应
np.random.shuffle(x_data)  # 打乱
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)  # ？

# 数据集分出永不相见的训练集和测试集
x_train = x_data[:-30]
y_train = y_data[:-30]
x_test = x_data[-30:]
y_test = y_data[-30:]

# 转换数据类型
x_train = tf.cast(x_train, tf.float32)
x_test = tf.cast(x_test, tf.float32)

# 配成输入特征，标签对，每次喂入一小撮
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)

# 定义神经网络中所有可训练参数
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
train_loss_result = []  # 将每轮loss记录在此列表中，为后续画loss曲线提供数据
test_acc = []
epoch = 500
loss_all = 0  # 每轮分4个step，loss_all记录四个step生成4个loss值

# 训练部分
# 嵌套循环迭代，with结构更新参数，显示当前loss
for epoch in range(epoch):  # 针对整个数据集进行循环，
    for step, (x_train, y_train) in enumerate(train_db):
        with tf.GradientTape() as tape:  # 记录梯度信息
            # 前向传播过程记录y
            y = tf.matmul(x_train, w1) + b  # y为预测结果
            y = tf.nn.softmax(y)  # y符合概率分布
            y_ = tf.one_hot(y_train, depth=3)  # 将标签值独热编码
            # 记录总loss
            loss = tf.reduce_mean(tf.square(y_ - y))  # 采用均方误差损失值mse
            loss_all += loss.numpy()
        # 计算loss对各个参数的梯度
        grads = tape.gradient(loss, [w1, b1])
        # 实现梯度更新，w1=w1-lr*w1_grad b=b-lr*b_grad
        w1.assign_sub(lr * grads[0])
        b1.assign_sub(lr * grads[1])
    # 每个epoch打印loss信息
    print("epoch{},loss{}".format(epoch, loss_all / 4))  # (训练集有120组数据，每个step只能喂入32组数据，需要batch级别循环4次，求每个step的平均loss)
    train_loss_result.append(loss_all / 4)  # 将四个step的loss求平均值记录在此变量中
    loss_all = 0  # loss_all值归0，为下一个epoch的loss做准备

    # 测试部分
    # 计算当前参数前向传播后的准确率，显示当前acc
    total_correct, total_number = 0, 0
    for x_test, y_test in test_db:  # 遍历测试集中所有数据
        y = tf.matmul(x_test, w1) + b1  # y为预测结果
        y = tf.nn.softmax(y)  # y符合概率分布
        pred = tf.argmax(y, axis=1)  # 返回y中最大值的索引，即预测的分类
        pred = tf.cast(pred, dttype=y_test)  # 调整数据类型与标签一致
        correct = tf.cast(tf.equal(pred, y_test),
                          dtype=tf.int32)  # equal，相等的意思。顾名思义，就是判断，x, y 是不是相等，它的判断方法不是整体判断，而是逐个元素进行判断，如果相等就是True，不相等，就是False。由于是逐个元素判断，所以x，y 的维度要一致。
        correct = tf.reduce_sum(correct)  # 将所有batch中的correct数加起来
        total_correct += int(correct)  # 将所有batch中的correct数加起来
        total_number += x_test.shape[0]  # 在矩阵中，[0]就表示行数，[1]则表示列数，[2]代表通道数
    acc = total_correct / total_number
    test_acc.append(acc)
    print("test_acc", acc)
    print("------------------------------")

# acc/loss可视化
# 绘制loss曲线
plt.title('loss Curve')  # 图片隐私
plt.xlabel('Epoch')  # x轴名称
plt.ylabel('loss')
plt.plot(train_loss_result, label="$loss$")  # 逐点画出test_acc值并连线，？epoch?
plt.legend()
plt.show()

# 绘制accuracy曲线
plt.title('Acc Curve')  # 图片隐私
plt.xlabel('Epoch')  # x轴名称
plt.ylabel('Acc')
plt.plot(test_acc, label="$Accuracy$")  # 逐点画出test_acc值并连线，？epoch?
plt.legend()
plt.show()