一、神经网络（DNN算法）

实例网站：[http://playground.tensorflow.org

深度神经.png
image.png
image.png
image.png

• 激活函数：relu,sigmoid,
• 作用：由直变曲

• 值代表线性问题

  
  image.png
  image.png

三、神经网络算法代码实现

• prefetch ---预先取出数据，加快计算的数据、
  *什么是激活函数？激活函数有哪些？

（1）代码--自己写多层隐藏层

import warnings
warnings.filterwarnings('ignore')
import numpy as np

import tensorflow as tf

from tensorflow.keras.datasets import mnist

加载数据，处理数据

(X_train,y_train),(X_test,y_test) = mnist.load_data()

# 归一化
X_train = (X_train/255.0).astype(np.float32)
X_test = (X_test/255.0).astype(np.float32)

# reshape,二维的数据，矩阵运算了
X_train = X_train.reshape(-1,784)
X_test = X_test.reshape(-1,784)

# one-hot 概率表示类别
y_train = tf.one_hot(y_train,depth=10)
y_test = tf.one_hot(y_test,depth=10)

# prefetch fetch取出来的意思，预先取出来，更快，加快计算速度
# 训练数据
data_train = tf.data.Dataset.from_tensor_slices((X_train,y_train)).repeat(50).shuffle(1000).batch(512).prefetch(1)
# 测试数据，验证模型好坏！每训练50次，取出一批测试数据，进行测试准确率
data_test = tf.data.Dataset.from_tensor_slices((X_test,y_test)).repeat(10).shuffle(1000).batch(512).prefetch(1)

构建模型

# 系数，3层隐含层
# 数据 X_train 样本，特征 784
# 第一层隐含层，多少个神经元：256个神经元，相当于线性方程，矩阵运算批量的计算
w1 = tf.Variable(tf.random.normal(shape = [784,256],stddev = 0.01))
b1 = tf.Variable(tf.random.normal(shape = [256],stddev = 0.01))

# 第二层隐含层，给256个神经元
w2 = tf.Variable(tf.random.normal(shape = [256,256],stddev = 0.01))
b2 = tf.Variable(tf.random.normal(shape = [256],stddev = 0.01))

#第三层，使用第二层数据的输出为数据
# 第三层给，512个神经元
w3 = tf.Variable(tf.random.normal(shape = [256,512],stddev = 0.01))
b3 = tf.Variable(tf.random.normal(shape = [512],stddev = 0.01))

# 输出层，输出几个类别，10分类问题，确定了，输出的类别是10个

out_w = tf.Variable(tf.random.normal(shape = [512,10],stddev = 0.01))
out_b = tf.Variable(tf.random.normal(shape = [10],stddev = 0.01))

def dnn(X):#深度神经网络
#     第一层的连接：矩阵运算
    d1 = tf.matmul(X,w1) + b1
    d1 = tf.nn.relu(d1) # 激活函数
    
#     第二层的连接，矩阵运算
    d2 = tf.nn.relu(tf.matmul(d1,w2) + b2)
    
#     第三层的连接，矩阵预算
    d3 = tf.nn.relu(tf.matmul(d2,w3) + b3)
    
#     输出层连接，矩阵运算，softmax概率问题
    y_pred = tf.nn.softmax(tf.matmul(d3,out_w) + out_b)
    return y_pred

# 损失函数，样本平均cross_entropy交叉熵
def cross_entropy(y_true,y_pred):
    y_pred = tf.clip_by_value(y_pred,1e-9,1.0)
    loss = tf.reduce_mean(tf.reduce_sum(y_true*tf.math.log(1/y_pred),axis = -1))#数据是二维的
    return loss

# 计算准确率
def accuracy(y_pred,y_true):#y_和y_true,都是tensor
    y_pred = y_pred.numpy().argmax(axis = -1)
    y_true = y_true.numpy().argmax(axis = -1)
    acc = (y_pred == y_true).mean()
    return acc #返回准确率
# 优化算法，梯度下降
# 学习率，太小，学的太慢！
sgd = tf.optimizers.SGD(learning_rate=0.2)

定义运行方法

def run_optimizer(X_train,y_train):
    with tf.GradientTape() as g:
        y_pred = dnn(X_train)
        loss = cross_entropy(y_train,y_pred)
    gradients = g.gradient(loss,[w1,b1,w2,b2,w3,b3,out_w,out_b])
    sgd.apply_gradients(zip(gradients,[w1,b1,w2,b2,w3,b3,out_w,out_b]))

for循环运行代码

for i,(X_train,y_train) in enumerate(data_train.take(1000),1):
    run_optimizer(X_train,y_train)
    if i%10 == 0:
        #计算准确率
        for (X_test,y_test) in data_test.take(1):
            y_pred = dnn(X_test)
            acc = accuracy(y_pred,y_test)
            print('执行次数：%d。准确率是：%0.4f'%(i,acc))

执行次数：10。准确率是：0.1348
执行次数：20。准确率是：0.1191
执行次数：30。准确率是：0.1133
执行次数：40。准确率是：0.1270
执行次数：50。准确率是：0.1152
执行次数：60。准确率是：0.1270
执行次数：70。准确率是：0.1016
执行次数：80。准确率是：0.1328
执行次数：90。准确率是：0.1211
执行次数：100。准确率是：0.1191
执行次数：110。准确率是：0.1406
执行次数：120。准确率是：0.1289
执行次数：130。准确率是：0.1309
执行次数：140。准确率是：0.1348
执行次数：150。准确率是：0.1367
执行次数：160。准确率是：0.1309
执行次数：170。准确率是：0.1191
执行次数：180。准确率是：0.1113
执行次数：190。准确率是：0.1250
执行次数：200。准确率是：0.1191
执行次数：210。准确率是：0.1309
执行次数：220。准确率是：0.1348
执行次数：230。准确率是：0.1191
执行次数：240。准确率是：0.1074
执行次数：250。准确率是：0.1035
执行次数：260。准确率是：0.1328
执行次数：270。准确率是：0.1250
执行次数：280。准确率是：0.1035
执行次数：290。准确率是：0.1348
执行次数：300。准确率是：0.1211
执行次数：310。准确率是：0.1367
执行次数：320。准确率是：0.1426
执行次数：330。准确率是：0.1309
执行次数：340。准确率是：0.1426
执行次数：350。准确率是：0.1973
执行次数：360。准确率是：0.2012
执行次数：370。准确率是：0.2129
执行次数：380。准确率是：0.2285
执行次数：390。准确率是：0.2461
执行次数：400。准确率是：0.3496
执行次数：410。准确率是：0.4570
执行次数：420。准确率是：0.3867
执行次数：430。准确率是：0.4336
执行次数：440。准确率是：0.5566
执行次数：450。准确率是：0.5293
执行次数：460。准确率是：0.5938
执行次数：470。准确率是：0.5664
执行次数：480。准确率是：0.6406
执行次数：490。准确率是：0.5977
执行次数：500。准确率是：0.5488
执行次数：510。准确率是：0.6602
执行次数：520。准确率是：0.5996
执行次数：530。准确率是：0.7031
执行次数：540。准确率是：0.7227
执行次数：550。准确率是：0.7520
执行次数：560。准确率是：0.7246
执行次数：570。准确率是：0.8223
执行次数：580。准确率是：0.8047
执行次数：590。准确率是：0.8301
执行次数：600。准确率是：0.8105
执行次数：610。准确率是：0.7988
执行次数：620。准确率是：0.8633
执行次数：630。准确率是：0.8047
执行次数：640。准确率是：0.8594
执行次数：650。准确率是：0.8516
执行次数：660。准确率是：0.8594
执行次数：670。准确率是：0.8887
执行次数：680。准确率是：0.8594
执行次数：690。准确率是：0.8555
执行次数：700。准确率是：0.8848
执行次数：710。准确率是：0.8789
执行次数：720。准确率是：0.8574
执行次数：730。准确率是：0.8848
执行次数：740。准确率是：0.9023
执行次数：750。准确率是：0.8711
执行次数：760。准确率是：0.8945
执行次数：770。准确率是：0.8242
执行次数：780。准确率是：0.8887
执行次数：790。准确率是：0.8906
执行次数：800。准确率是：0.8945
执行次数：810。准确率是：0.9023
执行次数：820。准确率是：0.8984
执行次数：830。准确率是：0.9102
执行次数：840。准确率是：0.9160
执行次数：850。准确率是：0.8906
执行次数：860。准确率是：0.9141
执行次数：870。准确率是：0.9277
执行次数：880。准确率是：0.9023
执行次数：890。准确率是：0.9141
执行次数：900。准确率是：0.9180
执行次数：910。准确率是：0.9258
执行次数：920。准确率是：0.9238
执行次数：930。准确率是：0.9277
执行次数：940。准确率是：0.9297
执行次数：950。准确率是：0.9336
执行次数：960。准确率是：0.9199
执行次数：970。准确率是：0.9277
执行次数：980。准确率是：0.9336
执行次数：990。准确率是：0.9336
执行次数：1000。准确率是：0.9199

（2）代码（tensorflow封装好的）：

import warnings
warnings.filterwarnings('ignore')
import numpy as np

import tensorflow as tf

from tensorflow.keras.datasets import mnist
from tensorflow.keras import Model,layers
# model 模型--就是算法数学的公式，深度神经网络，3层的隐含层
# layers 定义好的层

(X_train,y_train),(X_test,y_test) = mnist.load_data()

# 归一化
X_train = (X_train/255.0).astype(np.float32)
X_test = (X_test/255.0).astype(np.float32)

# reshape,二维的数据，矩阵运算了
X_train = X_train.reshape(-1,784)
X_test = X_test.reshape(-1,784)

# one-hot 概率表示类别
y_train = tf.one_hot(y_train,depth=10)
y_test = tf.one_hot(y_test,depth=10)

# prefetch fetch取出来的意思，预先取出来，更快，加快计算速度
# 训练数据
data_train = tf.data.Dataset.from_tensor_slices((X_train,y_train)).repeat(50).shuffle(1000).batch(512).prefetch(1)
# 测试数据，验证模型好坏！每训练50次，取出一批测试数据，进行测试准确率
data_test = tf.data.Dataset.from_tensor_slices((X_test,y_test)).repeat(10).shuffle(1000).batch(512).prefetch(1)

构建模型--tf2.0写法，损失，准确率\学习率

class Dnn(Model):
#     layers 会自动的帮助我们写出变量
#     变量是对应神经元的数量
    def __init__(self):
        super(Dnn,self).__init__() #调用父类的方法
        self.h1=layers.Dense(256,activation="relu") # Dense相当于矩阵运算128神经元
        self.h2=layers.Dense(256,activation="relu")
        self.h3=layers.Dense(512,activation="relu")
        self.out=layers.Dense(10,activation=tf.nn.softmax)
#       #tf.nn.softmax--转为概率的问题
    def call(self,x,is_training=False): 
        # is_training=False区分训练和测试的情况
        x=self.h1(x)
        x=self.h2(x)
        x=self.h3(x)
        y_pred=self.out(x)
        return y_pred
dnn=Dnn()
# 损失函数，样本平均cross_entropy交叉熵
def cross_entropy(y_true,y_pred):
    y_pred = tf.clip_by_value(y_pred,1e-9,1.0)
    loss = tf.reduce_mean(tf.reduce_sum(tf.multiply(y_true,tf.math.log(1/y_pred)),axis=1))#数据是二维的
    return loss


# 声明准确率
def accuracy(y_pred,y_true):#y_和y_true,都是tensor
    y_pred =tf.argmax(y_pred,axis = -1)
    y_true =tf.argmax(y_true,axis = -1)
#     acc = (y_pred == y_true).mean()
    acc=tf.reduce_mean(tf.cast(tf.equal(y_true,y_pred),tf.float16)).numpy()
    return acc #返回准确率
sgd = tf.optimizers.SGD(learning_rate=0.1)

优化算法

def run_optimizer(X_train,y_train):
    with tf.GradientTape() as g:
        y_pred = dnn(X_train)
        loss = cross_entropy(y_train,y_pred)
#  cross_entropy交叉熵       
    gradients = g.gradient(loss,dnn.trainable_variables)
#     dnn可以直接获取到系数--dnn为我们声明好的
    sgd.apply_gradients(zip(gradients,dnn.trainable_variables))

for循环运行代码

for i,(X_train,y_train) in enumerate(data_train.take(1000),1):
    run_optimizer(X_train,y_train)
    if i%10 == 0:
        #计算准确率
        for (X_test,y_test) in data_test.take(1):
            y_pred = dnn(X_test)
            acc = accuracy(y_pred,y_test)
            print('执行次数：%d。准确率是：%0.4f'%(i,acc))

执行次数：10。准确率是：0.5723
执行次数：20。准确率是：0.6660
执行次数：30。准确率是：0.7402
执行次数：40。准确率是：0.7422
执行次数：50。准确率是：0.7422
执行次数：60。准确率是：0.8496
执行次数：70。准确率是：0.7910
执行次数：80。准确率是：0.8496
执行次数：90。准确率是：0.8691
执行次数：100。准确率是：0.8535
执行次数：110。准确率是：0.8750
执行次数：120。准确率是：0.8652
执行次数：130。准确率是：0.8809
执行次数：140。准确率是：0.8359
执行次数：150。准确率是：0.8906
执行次数：160。准确率是：0.8730
执行次数：170。准确率是：0.8887
执行次数：180。准确率是：0.9043
执行次数：190。准确率是：0.8867
执行次数：200。准确率是：0.8906
执行次数：210。准确率是：0.8848
执行次数：220。准确率是：0.8984
执行次数：230。准确率是：0.9082
执行次数：240。准确率是：0.8945
执行次数：250。准确率是：0.9180
执行次数：260。准确率是：0.9395
执行次数：270。准确率是：0.9180
执行次数：280。准确率是：0.9082
执行次数：290。准确率是：0.9219
执行次数：300。准确率是：0.9141
执行次数：310。准确率是：0.9277
执行次数：320。准确率是：0.9160
执行次数：330。准确率是：0.9141
执行次数：340。准确率是：0.9004
执行次数：350。准确率是：0.9082
执行次数：360。准确率是：0.9121
执行次数：370。准确率是：0.9238
执行次数：380。准确率是：0.9102
执行次数：390。准确率是：0.9238
执行次数：400。准确率是：0.9219
执行次数：410。准确率是：0.9355
执行次数：420。准确率是：0.9141
执行次数：430。准确率是：0.9336
执行次数：440。准确率是：0.9180
执行次数：450。准确率是：0.9336
执行次数：460。准确率是：0.9316
执行次数：470。准确率是：0.9238
执行次数：480。准确率是：0.9395
执行次数：490。准确率是：0.9219
执行次数：500。准确率是：0.9297
执行次数：510。准确率是：0.9355
执行次数：520。准确率是：0.9258
执行次数：530。准确率是：0.9258
执行次数：540。准确率是：0.9297
执行次数：550。准确率是：0.9375
执行次数：560。准确率是：0.9336
执行次数：570。准确率是：0.9238
执行次数：580。准确率是：0.9180
执行次数：590。准确率是：0.9180
执行次数：600。准确率是：0.9297
执行次数：610。准确率是：0.9375
执行次数：620。准确率是：0.9414
执行次数：630。准确率是：0.9375
执行次数：640。准确率是：0.9238
执行次数：650。准确率是：0.9199
执行次数：660。准确率是：0.9355
执行次数：670。准确率是：0.9375
执行次数：680。准确率是：0.9316
执行次数：690。准确率是：0.9570
执行次数：700。准确率是：0.9531
执行次数：710。准确率是：0.9453
执行次数：720。准确率是：0.9395
执行次数：730。准确率是：0.9512
执行次数：740。准确率是：0.9336
执行次数：750。准确率是：0.9512
执行次数：760。准确率是：0.9375
执行次数：770。准确率是：0.9414
执行次数：780。准确率是：0.9453
执行次数：790。准确率是：0.9277
执行次数：800。准确率是：0.9336
执行次数：810。准确率是：0.9414
执行次数：820。准确率是：0.9570
执行次数：830。准确率是：0.9473
执行次数：840。准确率是：0.9609
执行次数：850。准确率是：0.9473
执行次数：860。准确率是：0.9570
执行次数：870。准确率是：0.9414
执行次数：880。准确率是：0.9434
执行次数：890。准确率是：0.9434
执行次数：900。准确率是：0.9629
执行次数：910。准确率是：0.9414
执行次数：920。准确率是：0.9492
执行次数：930。准确率是：0.9473
执行次数：940。准确率是：0.9590
执行次数：950。准确率是：0.9473
执行次数：960。准确率是：0.9492
执行次数：970。准确率是：0.9531
执行次数：980。准确率是：0.9375
执行次数：990。准确率是：0.9570
执行次数：1000。准确率是：0.9590