tensoflow基础

Tensorflow基础

​ TensorFlow是现在比较火爆的一个深度学习的框架，内部集成了多种优化算法还有模型框架，所以对初学者十分友好，所以今天起开始自己的TensorFlow第一步

训练自己的第一个神经网络

代码如下

• 第一次上手tensorflow结果发现憨憨的自己抄的代码是temsoflow1.0的版本

  但是安装的tensorflow版本是2.1.3，在咨询了下csdn后在原代码的基础上做了下版本转换

  然而只是试水了下而已，个人认为tensorflow2.0版本更加友好，更简洁，没有session这种操作，后面都会用tensorflow2.0版本实现,指导课程为北大

import tensorflow.compat.v1 as tf
import numpy as np

tf.disable_v2_behavior()
# create data
x_data = np.random.rand(100).astype(np.float32)##随机生成100个数据
y_data = x_data * 0.1 + 0.3 #随机生成y
# create tensorflow struct start 新建
Weights = tf.Variable(tf.random_uniform((1,), -1.0, 1.0))#随机生成权重
biases = tf.Variable(tf.zeros((1,)))#初始化Biases
y = Weights * x_data + biases#定义函数
loss = tf.reduce_mean(tf.square(y - y_data))#根据均方根差进行梯度下降
optimizer = tf.train.GradientDescentOptimizer(0.5)#梯度下降，设置学习率为0.5
train = optimizer.minimize(loss)
init = tf.initialize_all_variables()
# 创建session
sess = tf.Session()#session是一个对话控制，对
sess.run(init)
for step in range(201):#训练200轮
    sess.run(train)
    if step % 20 == 0:
        print(step, sess.run(Weights), sess.run(biases), sess.run(loss))
        ##每20轮输出一次训练后的权重还有偏差还有损失

输出如下：

0 [-0.00268313] [0.5169402] 0.027608244
20 [0.0633762] [0.32074773] 0.00013127715
40 [0.09214579] [0.3044495] 6.037642e-06
60 [0.0983156] [0.30095425] 2.7768752e-07
80 [0.09963877] [0.30020466] 1.2771677e-08
100 [0.09992254] [0.3000439] 5.874353e-10
120 [0.09998339] [0.30000943] 2.7032572e-11
140 [0.09999646] [0.300002] 1.2318857e-12
160 [0.09999923] [0.30000046] 6.0014216e-14
180 [0.09999982] [0.3000001] 3.7214676e-15
200 [0.09999991] [0.30000007] 1.2079227e-15
##可见训练次数越多

进行线性回归预测

##懒得下数据集了，所以就自己生成了一个数据集
##线性回归
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

x_data = np.random.rand(100).astype(np.float32)
y_data = x_data * 0.1 + 0.3  # 很显然这个是个非常明显的线性回归
plt.scatter(x_data, y_data)    #绘制数据集的形状，是一个严格符合线性回归的散点图
# 建立顺序模型
model = tf.keras.Sequential()  # 实例化一个模型
model.add(tf.keras.layers.Dense(1, input_shape=(1,)))
#定义神经元的数目，由于输入的维度就一个就定义一个输入
model.compile(
    optimizer='adam', loss='mse'
)#选择优化算法，这里我们选择adam优化的梯度下降算法，基于均方根差
model.fit(x_data,y_data,epochs=10)#对模型训练10轮
print(model.predict(x_data))#这时训练结束，对输入X进行预测

神经网络计算

神经网络设计过程

鸢尾花设计分类

Y=x*w+b 一般神经网络的设计过程

import tensorflow as tf

w=tf.Variable(tf.constant(5,dtype=tf.float32))
#设置w的随机初始值为5
lr=0.2#学习率
epoch=40#迭代次数

for i in range(epoch):#在每一次的迭代中
    with  tf.GradientTape() as tape:#执行梯度下降算法
        loss=tf.square(w+1)#损失函数定义为loss=(w+1)^2
    grads=tape.gradient(loss,w)#告知对w求偏导
    w.assign_sub((lr*grads))#每次减去学习率乘上导数
    print("在%s 次迭代后,w变为%f ,loss变为 %f"%(epoch,w.numpy(),loss))

结果如下：

在1 次迭代后,w变为2.600000 ,loss变为 36.000000
在2 次迭代后,w变为1.160000 ,loss变为 12.959999
在3 次迭代后,w变为0.296000 ,loss变为 4.665599
在4 次迭代后,w变为-0.222400 ,loss变为 1.679616
在5 次迭代后,w变为-0.533440 ,loss变为 0.604662
在6 次迭代后,w变为-0.720064 ,loss变为 0.217678
在7 次迭代后,w变为-0.832038 ,loss变为 0.078364
在8 次迭代后,w变为-0.899223 ,loss变为 0.028211
在9 次迭代后,w变为-0.939534 ,loss变为 0.010156
在10 次迭代后,w变为-0.963720 ,loss变为 0.003656
在11 次迭代后,w变为-0.978232 ,loss变为 0.001316
在12 次迭代后,w变为-0.986939 ,loss变为 0.000474
在13 次迭代后,w变为-0.992164 ,loss变为 0.000171
在14 次迭代后,w变为-0.995298 ,loss变为 0.000061
在15 次迭代后,w变为-0.997179 ,loss变为 0.000022
在16 次迭代后,w变为-0.998307 ,loss变为 0.000008
在17 次迭代后,w变为-0.998984 ,loss变为 0.000003
在18 次迭代后,w变为-0.999391 ,loss变为 0.000001
在19 次迭代后,w变为-0.999634 ,loss变为 0.000000
在20 次迭代后,w变为-0.999781 ,loss变为 0.000000
…..

​ …..
在40 次迭代后,w变为-1.000000 ,loss变为 0.000000

多次改变学习率，发现结果不一样，

学习率过小时，40次loss都没达到0

学习率过大时也找不到

张量生成

张量含义

tensorflow中的tensor就是指张量的意思，多维数组和列表的意思

0-D的张量表示一个单独的数 1,2,3,4…..

1-D的张量表示一个向量 [1,2,3,4,…..]

2-D的张量表示一个矩阵[[1,2,3],[4,5,6],……]

3-D的张量表示一个立方，每一层是一个矩阵

[[[1,2,3],[3,4,5]],

[[8,9,0],[7,8,5]]]

n-D以此类推……

数据类型

• tf.int,tf.float…….

  • tf.int32,tf.float32,tf.float64

• tf.bool

  • tf.constant([True,False])

• tf.string

  • tf.constant(“hollow”)

创建张量

直接创建：

import tensorflow as tf

a=tf.constant([1,5],dtype=tf.int64)#实例化一个张量
print(a)
print(a.dtyppe)
print(a.shape)

numpy转换：

import tensorflow as tf
import numpy as np

a=np.arange(0,5)
b=tf.convert_to_tensor(a,dtype=tf.int64)#将numpy格式转换成tf张量格式
print(a)
print(b)

#[0 1 2 3 4]
#tf.Tensor([0 1 2 3 4], shape=(5,), dtype=int64)

一维直接写个数，二维用行列，三维用[n,m,j,k,…..]

#tf.zreos(维度)
#tf.fill(维度，指定值)
#tf.ones(维度)
a=tf.zeros([2,3])
b=tf.fill([2,2],9)

其他生成张量：

#tf.random.normal(维度，meaan=均值，stddv=标准差)
#生成符合正态分布的张量
#tf.random.truncated_normal(维度，均值，标准差)
#生成截断式分布的随机数，保证生成数在2sitar之间
a=tf.random.normal([2,2],mean=0.5,stddev=1)
b=tf.random.truncated_normal([2,2],mean=0.5,stddev=1)
#结果如下
tf.Tensor(
[[ 1.1104964  -0.04805636]
 [ 0.00457174 -0.14143777]], shape=(2, 2), dtype=float32)
tf.Tensor(
[[ 2.312311    1.8229972 ]
 [-0.07491392  0.20661339]], shape=(2, 2), dtype=float32)



a=tf.random.uniform([2,2],minval=0,maxval=1)
#生成平均分布的随机数
print(a)
#结果如下
tf.Tensor(
[[0.33741152 0.5539886 ]
 [0.8860432  0.18990982]], shape=(2, 2), dtype=float32)

常用函数

张量操作

tf.cast()/tf.reduce

tf.cast(a,dtype=iny64)
#转换数据类型用
tf.reduce_min(a)
#计算张量上的最小值
#同理tf.reduce_操作 还有其他的方法，

轴axis:

axis=0:表示纵轴

axis=1:表示横轴，

则可用其表示求解均值还有最大值的方向

不指定axis时，对所有元素进行操作

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

#结果如下：
tf.Tensor(
[[1 2 3]
 [2 2 3]], shape=(2, 3), dtype=int32)
tf.Tensor(2, shape=(), dtype=int32)
tf.Tensor([2 2], shape=(2,), dtype=int32)

tf.Variable

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

tf.Variable(初始值)

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

数学运算操作

四则运算函数

x=tf.constant([[1,2],[2,5]])
x=tf.cast(x,dtype=float)
y=tf.random.normal([2,2],mean=1,stddev=0.5)
print(x)
print(y)
print(tf.add(x,y))
print(tf.subtract(x,y))
print(tf.multiply(x,y))
print(tf.divide(x,y))

结果如下：

tf.Tensor(
[[1. 2.]
 [2. 5.]], shape=(2, 2), dtype=float32)
tf.Tensor(
[[1.2040572  0.82556653]
 [0.49909478 1.6746361 ]], shape=(2, 2), dtype=float32)
tf.Tensor(
[[2.2040572 2.8255665]
 [2.4990947 6.674636 ]], shape=(2, 2), dtype=float32)
tf.Tensor(
[[-0.20405722  1.1744335 ]
 [ 1.5009053   3.3253639 ]], shape=(2, 2), dtype=float32)
tf.Tensor(
[[1.2040572  1.6511331 ]
 [0.99818957 8.37318   ]], shape=(2, 2), dtype=float32)
tf.Tensor(
[[0.83052534 2.4225788 ]
 [4.007255   2.9857233 ]], shape=(2, 2), dtype=float32)

注意只有维度相同的张量才可以进行四则运算，所以是点乘点加，不是矩阵运算

幂操作

x=tf.constant([[1,2],[2,5]])
x=tf.cast(x,dtype=float)
print(x)
print(tf.pow(x,3))
print(tf.square(x))
print(tf.sqrt(x))

#结果如下：
tf.Tensor(
[[1. 2.]
 [2. 5.]], shape=(2, 2), dtype=float32)
tf.Tensor(
[[  1.   8.]
 [  8. 125.]], shape=(2, 2), dtype=float32)
tf.Tensor(
[[ 1.  4.]
 [ 4. 25.]], shape=(2, 2), dtype=float32)
tf.Tensor(
[[1.        1.4142135]
 [1.4142135 2.236068 ]], shape=(2, 2), dtype=float32)

以上都是矩阵的点操作

矩阵乘法

tf.matmul(矩阵1，矩阵2)

要符合矩阵运算

训练操作

特征与标签配对的函数

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

举例如下

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  tf.GradientTape() as tape:#执行梯度下降算法
    w=tf.Variable(tf.constant(3.0))
    loss=tf.square(w+1)#损失函数定义为loss=(w+1)^2
grad=tape.gradient(loss,w)
print(grad)
#结果如下：
tf.Tensor(8.0, shape=(), dtype=float32)

枚举

enumerate是python内建的函数，可以遍历每个列表元素

组合为索引 元素

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

独热码

tf.one_hot 特征向量形式表示分类

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

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

#表示如下
tf.Tensor(
[[0. 1. 0.]
 [1. 0. 0.]
 [0. 0. 1.]], shape=(3, 3), dtype=float32)

使符合概率分布

归一化处理：softmax()

让输出的每个分类的概率和为1

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)

参数自更新

相当于c语言中的++或者–

w=tf.Variable(4)#标记为可训练才能更新
w.assign_sub(1)
print(w)
#即w-1

返回索引

tf.argmax(张量名，axis=操作轴)

test=np.array([[1,2,3],[2,3,4],[4,5,3],[8,7,2]])
print(test)
print(tf.argmax(test,axis=0))#纵向最大值索引
print(tf.argmax(test,axis=1))#横向最大值索引
#结果如下
[[1 2 3]
 [2 3 4]
 [4 5 3]
 [8 7 2]]
tf.Tensor([3 3 1], shape=(3,), dtype=int64)
tf.Tensor([2 2 1 0], shape=(4,), dtype=int64)

鸢尾花数据集读入

通过sklearn中的dataset数据集引入

import tensorflow as tf
from sklearn import datasets
import pandas as pd
from  pandas import DataFrame
x_data=datasets.load_iris().data#.data 返回鸢尾花的输入特征
y_data=datasets.load_iris().target#.target返回鸢尾花的所有标签
print("x_data:\n",x_data)
print("y_data:\n",y_data)

x_data=DataFrame(x_data,columns=["花萼长","花萼宽","花瓣长","花瓣宽"])
#把数据变成表格形式，增加可读性
pd.set_option('display.unicode.east_asian_width',True)
#设置列名对齐
print("x_data and index:\n",x_data)

x_data['类别']=y_data#给增加一个类别标签
print("x_data add a colum:\n",x_data)

展示如下：

x_data:
 [[5.1 3.5 1.4 0.2]
 [4.9 3.  1.4 0.2]
 [4.7 3.2 1.3 0.2]
 [4.6 3.1 1.5 0.2]
         ..........
 [6.5 3.  5.2 2. ]
 [6.2 3.4 5.4 2.3]
 [5.9 3.  5.1 1.8]]
y_data:
 [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2
 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
 2 2]
x_data and index:
      花萼长  花萼宽  花瓣长  花瓣宽
0       5.1     3.5     1.4     0.2
1       4.9     3.0     1.4     0.2
2       4.7     3.2     1.3     0.2
3       4.6     3.1     1.5     0.2
4       5.0     3.6     1.4     0.2
..      ...     ...     ...     ...
145     6.7     3.0     5.2     2.3
146     6.3     2.5     5.0     1.9
147     6.5     3.0     5.2     2.0
148     6.2     3.4     5.4     2.3
149     5.9     3.0     5.1     1.8
[150 rows x 4 columns]
x_data add a colum:
      花萼长  花萼宽  花瓣长  花瓣宽  类别
0       5.1     3.5     1.4     0.2     0
1       4.9     3.0     1.4     0.2     0
2       4.7     3.2     1.3     0.2     0
3       4.6     3.1     1.5     0.2     0
4       5.0     3.6     1.4     0.2     0
..      ...     ...     ...     ...   ...
145     6.7     3.0     5.2     2.3     2
146     6.3     2.5     5.0     1.9     2
147     6.5     3.0     5.2     2.0     2
148     6.2     3.4     5.4     2.3     2
149     5.9     3.0     5.1     1.8     2
[150 rows x 5 columns]

神经网络实现鸢尾花分类

• 准备数据

  • 数据集读入
  • 数据集乱序
  • 生成测试集和训练集
  • 标签配对，每次读入一个batch

• 搭建网络

  • 定义神经网络中所有可训练参数

• 参数优化

  • 嵌套迭代循环，with结构更新参数，显示当前loss

• 测试效果

  • 计算当前参数前向传播后的准确率，显示当前acc

• acc/loss可视化

  • matplotlib库使用

以下是训练用代码，只用一层网络进行训练，Mooc的要求是都能把代码背下来

# -*- coding: UTF-8 -*-
# 利用鸢尾花数据集，实现前向传播、反向传播，可视化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)  # 使用相同的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(train_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.figure(figsize=(20,8),dpi=120)
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()

plt.savefig("./firstNetwork.png")#保存图片

神经网络优化

预备知识

tf.where()

• 条件语句真返回A，条件语句假返回B

• tf.where(条件语句,真返回A，假返回B)

  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)
    若a>b，返
    回a对应位置的元素,否则
    返回b对应位置的元素
  print("c:",c)
    运行结果:
  c:tf.Tensor([1 2345], shape=(5,), dtype=int32)

np.random.RandomState.rand()

• 返回一个[0,1)之间的随机数
• np.random.RandomState.rand(维度)
  维度为空，返回标量

import numpy as np
rdm=np.random.RandomState(seed:
1) #seed=常数每次生成随机数相同
a=rdm.rand()#返回一个随机标量
b=rdm.rand(2,3)#返回维度为2行3列随机数矩阵print("a:",a)
print("b:",b)
#运行结果:
a: 0.417022004702574
b: [[7.20324493e-01 1.14374817e-04 3.02332573e-01]
[1.46755891e-01 9.23385948e-02 1.86260211e-01]]

np.vstack()

• 将两个数组按垂直方向叠加np.vstack(数组1，数组2)

import numpy as np
a=np.array([1,2,3])
b = np.array([4,5,6])
C=np.vstack((a,b))
np.vstack()
print("c:ln",c)
运行结果:c:
        [[1,2,3],
         [4,5,6]]

np.mgrid[ ] .ravel() np.c_[]

生成网格坐标点

• np.mgrid[起始值:结束值:步长，起始值:结束值:步长，…]
• x.ravel() 将x变为一维数组，“把.前变量拉直”
• np.c [1使返回的间隔数值点配对
  np.c_[数组1，数组2，….]

- import numpy as np
  X, y= np.mgrid[1:3:1,2:4:0.5]
  grid =np.c_[x.ravel(), y.ravel
  print("x:",x)
  print("y:",y)
  print('grid:\n", grid)

复杂学习率

神经网络（NN）复杂度

• √NN复杂度:多用NN层数和NN参数的个数表示

  • 空间复杂度:

    • √层数=隐藏层的层数+1个输出层左图为2层NN
    • √总参数=总w＋总b

  • 时间复杂度:

    • √乘加运算次数

学习率

可以先用较大的学习率，快速得到较优的解，然后逐步减小学习率，使模型后期稳定

指数衰减学习率=初始学习率*当习率衰减率（当前轮数/多少轮衰减一次）

epoch=40

LR BASE =0.2

LR DECAY =0.99

LR STEP =1
for epoch in range (epoch):
    lr = LR BASE *LR DECAY **(epoch / LR STEP)
    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,lr is %f"%(epoch, w.numpy() , loss,lr))

激活函数

√优秀的激活函数:

• 非线性:激活函数非线性时，多层神经网络可逼近所有函数(只有网络是非线性的时候才不会被单层网络替代)

• 可微性:优化器大多用梯度下降更新参数

• 单调性:当激活函数是单调的，能保证单层网络的损失函数是凸函数（保证单层网络的损失函数是凸函数）

• 近似恒等性:f(x)sx当参数初始化为随机小值时，神经网络更稳定

√激活函数输出值的范围:

• 激活函数输出为有限值时，基于梯度的优化方法更稳定（权重对特征的影响更加显著）
• 激活函数输出为无限值时，建议调小学习

常用激活函数

sigmoid

近年来用sigmoid作为激活函数的网络越来越少，因为深层神经网络进行链式求导的时候，需要从输出层到输入层逐层进行链式求导，但是sigmoid函数的导数是0到0.25之间的小数，链式求导需要多层连续相乘，会出现多个0到0.25之间的连续相乘，结果将会趋于0,产生梯度消失，让参数无法继续更新

我们希望输入每层神经网络的特征是以0为均值的小数，但是sigmoid后的都是正数，收敛变慢，幂运算计算复杂度大训练时间长

• 容易造成梯度消失
• 输出非0均值，收敛慢
• 幂运算复杂，训练时间长

tanh

• 输出0均值
• 同样梯度消失
• 幂运算复杂，训练时间长

Relu

tf.nn.relu(x)

是个分段函数，

优点：

• 解决了梯度消失问题
• 只需判断输入是否大于0，计算速度快
• 收敛远远快于前两者

缺点：

• 输出不是0均值，收敛慢
• dead ReIU问题：当激活特征是负数时，某些神经元无法被激活，导致参数无法被更新
  • 设置更小学习率
  • 减少参数分布的巨大变化

Leaky Relu

tf.nn.leaky_relu(x)

为了解决relu负区间为0引起神经元死亡而设置的，使其负区间斜率不为0，无完全证明标书leaky relu比relu更好

但一般都用relu

总结

• 首选relu激活函数;
• √学习率设置较小值;
• 输入特征标准化,即让输特征满足以0为均值,1为标准差的正态分布;
• 初始参数中心化，即让随机生成的参数满足以0为均值,根下输入特征分之2为标准差的正态分布

损失函数

损失函数（loss） :预测值（y)与已知答案（y_）的差距

NN优化目标:loss最小

主流的损失函数：

• mse (Mean Squared Error)

• 自定义

• ce(Cross Entropy)交叉熵

均方误差mse:

loss_mse = tf.reduce_mean(tf.square(y_-y))

自定义损失函数：

对不同的损失赋予不同的惩罚

loss zdy= tf.reduce _sum(where :(tf.greatery,y_b, cOST(y -y_),PROFT(y_-y))

交叉熵：

√交叉嫡损失函数CE(Cross Entropy):表征两个概率分布之间的距离

eg.二分类已知答案y_=(1,0)预测y,=(0.6, 0.4)y2=(0.8, 0.2)哪个更接近标准答案?

H1((1.0),(0.6,0.4))=-(1ln0.6+Oln0.4)~~(-0.511 ＋0)=0.511

H2((1,0).(0.8,0.2))=-(1ln0.8+Oln0.2)~~(-0.223+0)=0.223

因为H>H，所以y,预测更准

tf.losses.categorical_crossentropy(y ,y)

loss_ce1=tf.losses.categorical_ crossentropy([1,0],[0.6,0.4])
loss_ce1=tf.losses.categorical_ crossentropy([1,0],[0.8,0.2])
print("loss_ce1:", loss_ce1)
print("loss_ce2:", loss_ce2)

softmax与交叉结合

√输出先过softmax函数，再计算第y与y_的交叉嫡损失函数。

tf.nn.softmax_cross_entropy_with_logits(y_,y)
Y_= np.array([[1, 0, 0],[0,1,0],[0, 0,1],[1,0,0],[0,1,0]])
y = np.array([[12,3,2],[3,10,1],[1,2, 5],[4,6.5,1.2],[3,6, 1]])
y_pro= tf.nn.softmax(y)
loss_ce1 = tf.losses.categorical_crossentropy(y_,y_pro)
loss_ce2 = tf.nn.softmax_cross_entropy_with_logits(y_y)
print('分步计算的结果:ln', loss_ce1)
print('结合计算的结果:ln', loss_ce2)

缓解过拟合

过拟合把数据点记住了，导致模型过度训练，泛化性弱

欠拟合的解决方法：

• 增加输入特征
• 增加网络参数
• 减少正则化参数

过拟合的解决方法：

• 数据清洗减少噪声
• 增大训练集
• 采用正则项
• 增大正则化参数

下面详细介绍正则化：

正则化就是在损失函数中引入模型复杂度指标：，给每个参数w加上权重，抑制训练集中的噪声(一般不正则化b)

loss = loss(y与y)+ REGULARIZER * loss(w)

loss(y与y)是模型中所有参数的损失函数
超参数REGULARIZER给出参数w在总loss中的比例，即正则化的权重
w是需要正则化的参数

一般：

• L1正则：loss(w)=lwI
• L2正则：loss 2(w)=sum(w^2)

√正则化的选择：

• L1正则化大概率会使很多参数变为零,
  因此该方法可通过稀疏参数，即减少参数的数量，降低复杂度。

• L2正则化会使参数很接近零但不为零,
  因此该方法可通过减小参数
  值的大小降低复杂度。

  下面是代码：

  with tf.GradientTape() as tape:
      hl = tf.matmul(x train, wl)+ b1
      h1 = tf.nn.relu(hl)
      y = tf.matmul(h1, w2)+ b2
  
      loss mse = tf.reduce mean (tf.square(y train - y))
      loss regularization = []
      loss regularization.append (tf.nn.l2_loss(wl))
      loss regularization. append (tf.nn. l2_ loss(w2))
      loss regularization = tf.reduce sum (loss regularization)
      loss = loss mse + 0.03 *loss regularization
  
  variables = [w1,b1， w2，b2]
  grads = tape. gradient (loss, variables)