《tensorflow 学习》

鸢尾花案例
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

# 打乱顺序
np.random.seed(116)
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)

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

# 将输入特征与标签一一对应
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_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):
    for step,(x_train,y_train) in enumerate(train_db):
        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_all+loss.numpy
        grads=tape.gradient(loss,[w1,b1])

        w1.assign_sub(lr*grads[0])
        b1.assign_sub(lr*grads[1])

        # 每个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, 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)
            pred=tf.cast(pred,dtype=y_test.dtype)
            correct=tf.cast(tf.equal(pred,y_test),dtyoe=tf.int32)
            correct=tf.reduce_sum(correct)
            total_correct=total_correct+int (correct)
            total_number=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')  # x轴变量名称
        plt.ylabel('Loss')  # y轴变量名称
        plt.plot(train_loss_results, label="$Loss$")  # 逐点画出trian_loss_results值并连线，连线图标是Loss
        plt.legend()  # 画出曲线图标
        plt.show()  # 画出图像

        # 绘制 Accuracy 曲线
        plt.title('Acc Curve')  # 图片标题
        plt.xlabel('Epoch')  # x轴变量名称
        plt.ylabel('Acc')  # y轴变量名称
        plt.plot(test_acc, label="$Accuracy$")  # 逐点画出test_acc值并连线，连线图标是Accuracy
        plt.legend()
        plt.show()

深度学习介绍

1 机器学习和深度学习的区别：

机器学习是手动处理数据，深度学习由多个层组成，将更简单的模型组合在一起，将数据从一层传递到另一层，通过训练大量数据自动得出模型。

深度学习适合难以提取特征的图像、语音、等自然语言处理领域。

2 算法代表：

机器学习：朴素贝叶斯、决策树

深度学习：神经网络

3 深度学习框架

Tensorflow：上手难，Google python

Caffe：图像领域 c++

pytorch：python

4 Tensorflow 框架

用tendorflow实现简单加法：

a_t=tf.constant(2)
b_t=tf.constant(3)
c_t=a_t+b_t
print(c_t)
with tf.Session() as sess:
        c_t_value=sess.run(c_t)
        print(c_t_value)

5 图

图：tf.Operation(操作）+tf.tensor（数据）

默认图：

        1）调用方法 tf.get_default_graph()

        2）查看属性.graph

创建图：

        new_g=tf.Graph;

        with new_g.as_default():

6 tensorboard的可视化

6.1序列化-events文件

tf.summary.FileWriter("./tempt/summary",c_t.gragh)

6.2启动tensorboard

tensorboard --logdir="./tmpt/summary"  127.0.0.1:6006

7 OP

数据：tensor对象

caozuo：Operation 对象

7.1常见OP

 操作函数                                                         操作对象

tf.constant(tensor对象）                 输入tensor对象 Const   tensor对象

tf.add(Tensor对象1，Tensor对象2）       输入Tensor对象1和Tensor对象2  Add对象   Tensor对象3

7.2 指令名称

一张图一个命名空间

8 前向传播

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:
        loss=tf.square(w+1)
    grads=tape.gradient(loss,w)
    w.assign_sub(lr*grads)
    print("after %s epoch,w is %f,loss is %f"%(epoch,w,loss))

tf基本操作

matmul是矩阵相乘

tensor：张量（类似矩阵，任意维矩阵）

tensorflow：对张量做计算

x1= tf.ones([3,2])
#构造一个3*2的1矩阵

x=tf.cast(x,tf.float32)#将张量x int32类型转化为float32类型

<tf.Tensor: shape=(3, 2), dtype=float32, numpy=
array([[1., 1.],
       [1., 1.],
       [1., 1.]], dtype=float32)>

#将numpy转化为tensor张量
b=tf.convert_to_tensor(a,dtype=(tf.float32))

c=tf.random.normal([3],3,1)
//array([3.9480739 , 0.62052894, 3.5969484 ], dtype=float32)  标准差

d=tf.random.uniform([2,3],2,5)
//均匀分布随机数