tensorflow学习笔记（一）

文章目录

• • 一、安装环境
  • 二、例子
  • 三、张量
  • • 3.1 创建一个tensor
    • • (1) 直接创建
      • (2) 将numpy的数据类型转换为tensor数据类型
      • (3) 直接调用相关函数
      • (4) 正态分布随机数
    • 3.2 常见函数
    • • 3.2.1 Variable()
      • 3.2.2 四则运算
      • 3.2.3 平方、次方、开方
      • 3.2.4 标签和特征配对函数
      • 3.2.5 tf.one_hot
      • 3.2.6 softmax
      • 3.2.7 assign_sub
      • 3.2.8 tf.argmax
  • 四、练习
  • • 4.1 鸢尾花数据读入
    • 4.2 实现鸢尾花分类
  • 五、总结
  • 六、参考资料

一、安装环境

anaconda，pycharm，tensorflow
我是跟着b站上北大老师的视频安装的
视频链接
anaconda先安装，我tensorflow版本是2.1,pycharm版本是2021.2.3
python版本是3.9

二、例子

优化参数的目的是找到是损失函数值最小的w
假设损失函数loss = (w+1)^2,详情见下图

附上代码：

import  tensorflow as tf

w = tf.Variable(tf.constant(5,dtype=tf.float32))
a = 0.2 #学习率
epoch = 40 # 迭代次数

for epoch in range(epoch):
    with tf.GradientTape() as tape:
        loss = tf.square(w+1)
    grads = tape.gradient(loss,w) #.gradient函数告知loss对w求导

    w.assign_sub(a*grads)
    print("After %s epoch,w is %f,loss is %f" %(epoch,w.numpy(),loss))

可以观察到，经过不到40轮，损失值已经降低到很低的程度

三、张量

看中括号有几个即可判断是几维张量

3.1 创建一个tensor (1) 直接创建

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

(2) 将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)

(3) 直接调用相关函数

a = tf.zeros([2,3])# 两行三列的零向量
b = tf.ones(4)
c = tf.fill([2,2,3,5],9)
print(a)
print(b)
print(c)

(4) 正态分布随机数

d = tf.random.normal([2,2],mean=0.5,stddev=1) #默认均值为0，标准差为1
e = tf.random.truncated_normal([2,2],mean=0.5,stddev=1) #生成截断式正态分布的随机数
print(d)
print(e)

3.2 常见函数 3.2.1 Variable()

该函数将变量标记为可训练，被标记的变量会在反向传播中记录梯度信息，神经网络训练中，常用该函数标记待训练参数。

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

3.2.2 四则运算

3.2.3 平方、次方、开方

3.2.4 标签和特征配对函数

features = tf.constant([12,23,10,17])
labels = tf.constant([0,1,1,0])
dataset = tf.data.Datasetfrom_tensor_slices((features,labels))
# 将特征和标签配对
print(dataset)
for element in dataset:
    print(element)

不知道3.2.4为什么要报错

3.2.5 tf.one_hot

将待转换数据转换为one-hot形式的数据来输出

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

3.2.6 softmax

交叉熵损失函数
s o f t m a x ( x i ) = e x i ∑ j = 0 n e x i softmax(x_i) = \frac{e^{x_i}}{\sum_{j=0}^n e^{x_i}} softmax(xi​)=∑j=0n​exi​exi​​

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

3.2.7 assign_sub

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

3.2.8 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))#返回每一行最大值的索引

四、练习 4.1 鸢尾花数据读入

鸢尾花数据读入,如果没有sklearn或者pandas可以通过pip install 下载

进入pycharm的terminal，然后输入

pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple

sklearn包的下载同理。

from sklearn import datasets
from pandas import DataFrame
import pandas as pd

x_data = datasets.load_iris().data
y_data = datasets.load_iris().target
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)
x_data['类别'] = y_data
print("\n")
print(x_data)

4.2 实现鸢尾花分类

import tensorflow as tf
import numpy as np
from matplotlib import pyplot as plt
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数据集所有标签

# 数据乱序
np.random.seed(116)
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)

# 配对[输入特征与标签对应] ，每次喂入一个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个，输入结果是三个，所以是建立4行3列的张量
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))
a = 0.12 #学习率
epoch = 500
train_loss_results = []
test_acc = []
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): #batch级别迭代
        with tf.GradientTape() as tape:
            y = tf.matmul(x_train,w1)+b1
            y = tf.nn.softmax(y)
            y_ = tf.one_hot(y_train,depth =3)
            loss = tf.reduce_mean(tf.square(y_-y))
            loss_all +=loss.numpy()
        grads = tape.gradient(loss,[w1,b1])
        # 更新梯度
        w1.assign_sub(a*grads[0])
        b1.assign_sub(a*grads[1])
    print("Epoch{},loss:{}".format(epoch,loss_all/4))

# 开始测试，显示测试结果
# total_correct：预测对的样本个数
# total_number:总样本数量
    total_correct = 0
    total_number = 0
    for x_test,y_test in test_db:
        y = tf.matmul(x_test,w1)+b1
        y = tf.nn.softmax(y) # 使y符合概率分布
        pred = tf.argmax(y,axis = 1) #返回y中最大值的索引，即模型预测的该花属于哪一类
        pred = tf.cast(pred,dtype = y_test.dtype)
        #若分类正确，则correct = 1
        correct = tf.cast(tf.equal(pred,y_test),dtype=tf.int32)
        correct = tf.reduce_sum(correct)
        total_correct+=int(correct)
        total_number+=x_test.shape[0]

    acc = total_correct/total_number
    test_acc.append(acc)
    print("Test_acc: ",acc)
    print("---------------")

# 绘制loss 曲线
plt.title('Loss Function Curve')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.plot(train_loss_results,label="$Loss$")
plt.legend()
plt.show()

#绘制Accuracy曲线
plt.title('Acc Curve')
plt.xlabel('Epoch')
plt.ylabel('Acc')
plt.plot(test_acc,label = "$Accuracy$")
plt.legend()
plt.show()

测试结果：

观察到在学习率较大时，容易造成准确率的不稳定，将学习率从0.32降到0.12：


总结：学习率不应该设置得过大。

五、总结

感觉大学生活在摆烂，要不是项目推动学习，也许还没有认真开始学tensorflow，终于把tensorflow和anaconda以及pycharm配置好了，也跟着视频敲了所谓第一个项目，希望能好好把项目做好吧，还有不到一个星期，加油

六、参考资料

b站视频