python-tensorflow-神经网络

python-tensorflow学习

一、 常用函数

1.constant(value, shape, dtype=None, name=None)用法

用途：声明定义一个张量

value，张量内容（int float bool string)
shape，数据形状（标量，向量，矩阵，等高维）shape=(2,)括号里的逗号隔开几个数字，就代表张量是几维的。2代表这个一阶张量中包含两个元素，代表每一维所包含的元素个数
dtype，数据类型
name，名称
import tensorflow as tf
#x=[1,2],[3,4],[5,6]]
x=t.constant([1,2,3,4,5,6],shape=[3,2] )
注：在shape中逗号隔开几个数字，该张量就是几维的

1.1各阶张量例子

零阶张量 是 标量 s=1
一阶张量 是 向量 v=[1,2,3]
二阶张量 是 矩阵 m=[[1,2,3],[4,5,6],[7,8,9]]
…

1.2判断张量阶数

t=[[[… 看左边有几个括号即是几阶张量

2.python关键字with

用途：方便及时释放资源与异常查询（with结构记录计算过程）

Python 中的 with 语句用于异常处理，封装了 try…except…finally 编码范式，提高了易用性。
with 语句实现原理建立在上下文管理器之上。
上下文管理器是一个实现 enter 和 exit 方法的类。
使用 with 语句确保在嵌套块的末尾调用 exit 方法。

3.tf.GradientTape()的常用方法

用途：进行梯度计算

GradientTape，字面意思就是‘梯度磁带’，是Tensorflow 的 eager模式下计算梯度用的，这是一个自动求解模型梯度的利器。

tf.GradientTape()中 默认 参数watch_accessed_variables=True ，也就是监控所有可训练变量。当然我们也可以自己指定需要计算梯度的变量，可以使用.watch()对其进行监控（求梯度）

3.1代码实例

with tf.GradientTape() as gfg:
  gfg.watch(x) 
  y = x * x * x 
res  = gfg.gradient(y, x)

4.from sklearn import datasets

用途：从sklearn包中的datasets中引入自带的数据集

从sklearn包中的datasets中读入数据集，sklearn中包含很多数据集，方便初学者学习与测试

# 导入数据，分别为输入特征和标签
x_data = datasets.load_iris().data
y_data = datasets.load_iris().target

5.pandas.DataFrame( data, index, columns, dtype, copy)

用途：将数据集转换成表格的形式

data：一组数据(ndarray、series, map, lists, dict 等类型)。

index：索引值，或者可以称为行标签。

columns：列标签，默认为 RangeIndex (0, 1, 2, …, n) 。

dtype：数据类型。

copy：拷贝数据，默认为 False。

6.numpy.random.seed(n)

用途：设置固定的随机种子，固定离它最近的那个函数的随机状态，当随机种子n相同时，从一个数据集中取出的随机数据相同或打乱的顺序相同

7.numpy.random. shuffle(x)

用途：打乱数据集中数据的顺序

当有两个数据集且两个数据集中的数据一一对应时，我们想打乱数据集的顺序且保持两个数据集一一对应的规则，这时我们可以调用seed与shuffle函数来完成这一功能。

8.tf.set_random_seed()

用途：使取得的随机数跨session后不变

当在代码中使用了随机数，但是希望代码在不同时间或者不同的机器上运行能够得到相同的随机数，以至于能够得到相同的结果

9.python x[:] x[::] x[:::]

用途：从数据集x中按不同规则取出数据

x[-n:0]负数在左侧，则从后往前数n个
1x[:-n]负数在右侧，则是排除了后n个

10.tf.cast(x_train, tf.float32)

用途：改变数据集x_train中变量的类型

11.tf.data.Dataset.from_tensor_slices((输入特征，标签))

用途：实现两个数据集的数据实现一一对应，并进行切片。即切分传入张量的第一维度，生成输入特征/标签对，构建数据集。

将输入的张量的第一个维度看做样本的个数，沿其第一个维度将tensor切片，得到的每个切片是一个样本数据。实现了输入张量的自动切片。

12.数据集.batch(n)

用途：进行数据打包，将数据集以n个数据为一组进行打包

13.enumerate()

用途：用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标

i = 0
seq = [‘one’, ‘two’, ‘three’]
for element in seq:
… print i, seq[i]
… i += 1
…
0 one
1 two
2 three

seq = [‘one’, ‘two’, ‘three’]
for i, element in enumerate(seq):
… print i, element
…
0 one
1 two
2 three

14.tf.truncated_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32, seed=None, name=None)

用途：生成截断的正态分布的随机数，生成的数更向均值集中。

shape: 一维的张量，也是输出的张量。初始化参数时使用。
mean: 正态分布的均值。
stddev: 正态分布的标准差。
dtype: 输出的类型。
seed: 一个整数，当设置之后，每次生成的随机数都一样。
name: 操作的名字。

15.tf.random_normal(shape, mean=均值, stddev=标准差, dtype=tf.float32, seed=None, name=None)

用途： 生成正态分布的随机数，默认均值为0，标准差为1。初始化参数时使用。

shape: 一维的张量，也是输出的张量。
mean: 正态分布的均值。
stddev: 正态分布的标准差。
dtype: 输出的类型。
seed: 一个整数，当设置之后，每次生成的随机数都一样。
name: 操作的名字。

16.tf.random.uniform(维度,minval=最小值,maxval=最大值)

用途：生成均匀分布的随机数，生成数区间是前开后闭区间。

17.tf.Variable（）

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

18.tensorflow中的数学运算

tf.matmul（）用途：将矩阵 a 乘以矩阵 b,生成a * b

四则运算：tf.add；tf.subtract；tf.multiply；tf.divide。这些四则运算张量维度必须一样

平方、次方与开方：tf.square；tf.pow；tf.sqrt

19.tf.nn.softmax(待转换数据)

用途：把一个N*1的向量归一化为（0，1）之间的值，且其和为1。由于其中采用指数运算，使得向量中数值较大的量特征更加明显。

使输出y符合概率分布（此操作后与独热码同量级，可相减求loss）

20.tf.one_hot(待转换数据，depth=几分类)

用途：将‘待转换数据’转化为‘one-hot’类型数据输出

假设输出类型有五类，那么第1类那么其独热编码为： [ 1 , 0 , 0 , 0 , 0 ]如果是第2类那么独热编码为：[ 0 , 1 , 0 , 0 , 0 ] 也就是说只对存在有该类别数的位置上进行标记为1，其他皆为0。‘1’表示是，‘0’表示非。

21.tf.cast(张量名,dtype=数据类型)

强制tensor转换为该数据类型

22.assign_sub(参数自减的内容)

用途：更新参数并返回，注参数必须是可训练的，由variable标记。

23.tf.where(条件语句，真返回，假返回)

 a=tf.constant([1,2,3,1,1])
 b=tf.constant([0,1,3,4,5])
 c=tf.where(tf.greater(a,b),a,b)
 # c=[1,2,3,4,5]

24.tf.greater(a,b)

判断a是否大于b

25.np.random.RandomState.rand(维度)

25.1 维度为空则返回标量
25.2 返回一个[0,1)之间的随机数
25.3 np.random.RandomState(seed=1)seed=常数每次生成随机数相同

26.np.vstack(数组一，数组二)

将两个数组按垂直方向叠加

27.np.mgrid[起始值：结束值：步长，起始值：结束值：步长，…]

左闭右开

28.x.ravel()

将变量x变为一维数组

29.np.c_[数组1，数组2，…]

使返回的间隔数值点配对

注：经常一起使用27.28.29来生成网格点

二、对y=x^2做梯度下降法寻找最小值，及最小值的坐标。

梯度下降法算出函数最小值，以及最小值的坐标，可以用于神经网络，求损失函数最小值，从而获得最优参数。

import tensorflow as tf
# 对y=x*x做梯度下降法
time = 60
stepLength = 0.1
# 必须这样设置变量的值转换成张量，否则tensorflow不识别
# tf.Variable()将变量标记为可训练，被标记的变量才能在反向传播中通过梯度下降更新参数x，即才能调用tf.GradientTape使损失函数对参数求导
x = tf.Variable(tf.constant(15, dtype=tf.float32))

for i in range(time):
    with tf.GradientTape() as gra:
        y = x * x
    Gra = gra.gradient(y, x)
#  自加自减需使用自带的函数
    x.assign_sub(stepLength * Gra)

    print(i, x.numpy(), Gra.numpy())

0 12.0 30.0
1 9.6 24.0
2 7.6800003 19.2
3 6.144 15.360001
4 4.9152 12.288
5 3.9321601 9.8304
6 3.145728 7.8643203
7 2.5165825 6.291456
8 2.013266 5.033165
9 1.6106129 4.026532
10 1.2884903 3.2212257
11 1.0307922 2.5769806
12 0.8246338 2.0615845
13 0.659707 1.6492676
14 0.52776563 1.319414
15 0.4222125 1.0555313
16 0.33777002 0.844425
17 0.27021602 0.67554003
18 0.21617281 0.54043204
19 0.17293826 0.43234563
20 0.1383506 0.34587651
21 0.11068048 0.2767012
22 0.08854438 0.22136097
23 0.07083551 0.17708877
24 0.05666841 0.14167102
25 0.045334727 0.11333682
26 0.03626778 0.09066945
27 0.029014224 0.07253556
28 0.023211379 0.05802845
29 0.018569103 0.046422757
30 0.014855282 0.037138205
31 0.0118842255 0.029710565
32 0.00950738 0.023768451
33 0.0076059042 0.01901476
34 0.0060847234 0.0152118085
35 0.0048677786 0.012169447
36 0.003894223 0.009735557
37 0.0031153783 0.007788446
38 0.0024923026 0.0062307566
39 0.001993842 0.004984605
40 0.0015950736 0.003987684
41 0.0012760588 0.0031901472
42 0.0010208471 0.0025521177
43 0.0008166777 0.0020416942
44 0.00065334217 0.0016333554
45 0.0005226737 0.0013066843
46 0.00041813898 0.0010453474
47 0.0003345112 0.00083627796
48 0.00026760896 0.0006690224
49 0.00021408717 0.0005352179
50 0.00017126973 0.00042817433
51 0.00013701578 0.00034253945
52 0.00010961263 0.00027403157
53 8.76901e-05 0.00021922526
54 7.0152084e-05 0.0001753802
55 5.6121666e-05 0.00014030417
56 4.4897333e-05 0.00011224333
57 3.5917867e-05 8.979467e-05
58 2.8734294e-05 7.183573e-05
59 2.2987435e-05 5.7468587e-05

三、神经网络实现鸢尾花分类

输入数据集data包含四个特征，结构为14的矩阵输入，输出Data为三层，结构为13的矩阵输出，因此设定参数w为43的矩阵结构，参数b为13的矩阵结构。公式为data*w+b=Data

# 导入所需模块
import tensorflow as tf
#从sklearn包中的datasets中读入数据集，sklearn中包含很多数据集，方便初学者学习与测试
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)  # 使用相同的seed，保证输入特征和标签一一对应
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)

# 将打乱后的数据集分割为训练集和测试集，训练集为前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个输入特征故，输入层为4个输入节点；因为3分类，故输出层为3个神经元
# 用tf.Variable()标记参数可训练
# 使用seed使每次生成的随机数相同（方便教学，使大家结果都一致，在现实使用时不写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(train33_db):  # batch级别的循环 ，每个step循环一个batch
        with tf.GradientTape() as tape:  # with结构记录梯度信息
            y = tf.matmul(x_train, w1) + b1  # 神经网络乘加运算
            y = tf.nn.softmax(y)  # 使输出y符合概率分布（此操作后与独热码同量级，可相减求loss）
            y_ = tf.one_hot(y_train, depth=3)  # 将标签值转换为独热码格式，方便计算loss和accuracy
            loss = tf.reduce_mean(tf.square(y_ - y))  # 采用均方误差损失函数mse = mean(sum(y-out)^2)
            loss_all += loss.numpy()  # 将每个step计算出的loss累加，为后续求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转换为y_test的数据类型
        pred = tf.cast(pred, dtype=y_test.dtype)
        # 若分类正确，则correct=1，否则为0，将bool型的结果转换为int型
        correct = tf.cast(tf.equal(pred, y_test), dtype=tf.int32)
        # 将每个batch的correct数加起来
        correct = tf.reduce_sum(correct)
        # 将所有batch中的correct数加起来
        total_correct += int(correct)
        # total_number为测试的总样本数，也就是x_test的行数，shape[0]返回变量的行数
        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$")  # 逐点画出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()

epoch理解

来源:https://www.jianshu.com/p/22c50ded4cf7

激活函数sigmoid和softmax的理解与选择

将函数映射到0到1之间来表示拟合效果
输出维度=1，用sigmoid
输出维度>=2，用softmax
想要详细了解请点击来源
来源：https://blog.csdn.net/xiaotiig/article/details/122251454

张量的运算规则

当两个张量维度相同时，对应轴的值需要一样，或者为1。
相加时，把所有为1的轴进行复制扩充，从而得到两个维度完全相同的张量。然后对应位置相加即可。

a = torch.ones([2，4])
b = torch.ones([1, 4])
//此时a与b的维度都是2但一个是2*4，一个是1*4，这时就需要将b再复制一层使其变为2*4，即b=[[1,2,3,4]]变为b=[[1,2,3,4],[1,2,3,4]]
c = a+b

来源：https://blog.csdn.net/bxdzyhx/article/details/110831005