Tensorflow三层全连接MNIST

本文介绍了如何使用TensorFlow构建一个多层神经网络来识别MNIST数据集中的手写数字。首先,数据预处理包括归一化和数据集划分。然后,构建神经网络模型,包含两个隐藏层,激活函数为ReLU,并使用随机梯度下降优化器进行训练。在训练过程中,通过计算损失并反向传播更新权重。经过多个训练周期,模型能够对手写数字进行有效识别。
摘要由CSDN通过智能技术生成

手写数字体识别

手写数字体属于监督学习中的分类算问题。Image Classification中经典数据集ImageNet解决的就是图像分类问题

机器学习
监督学习
回归
线性回归
非线性回归
分类
非监督学习
聚类
半监督学习
半监督学习

数据集:MNIST

对线性回归方程引入一个非线性因子ReLu函数,使得线性回归方程变成非线性方程。
一层的非线性模型过于简单,因此通过多层非线性函数叠加:将上一层的输出作为下一层的输入。增加模型的非线性因子和复杂度。

数据预处理

train/test splitting 分割数据集

把数据集分为Train
图片大小为28*28,每个像素点都是一个[0-255]的灰度值:手写数字体的每一张图片数据格式为[28,28,1]。输入将图片打平
Input and Output

  • 输入为:x:[b,784]
    输出分类用OneHotCoding编码表示
    输出结果为置信度的最大的类别,所有类别置信度之和为1

神经网络的训练

  • step1 Compute [h1,h2,out]
  • step2 Compute Loss
  • step3 Compute Gradient and update [W1`, b`, W2`, b2`,W3`,b3`]
  • step4 loop
  • prediction
Computation Graph
  • out = x@w + b
  • x:[1,784]
  • W:[784,10]
  • b:[10]
Loss

Loss = MSE(out,label)
MSE计算输出值与真实值之间的欧式距离

  • minimize loss 更新w`和b`
step 0 x and y
import tensorflow as tf
from tensorflow.keras import datasets, layers, optimizers

(xs,ys),_ = datasets.mnist.load_data()
print('datasets:',xs.shape,ys.shape)

xs = tf.convert_to_tensor(xs, dtype = tf.float32)/255.
db = td.data.Dataset.from_tensor_slices((xs,ys))

for step, (x, y) in enumerate(db):
    print(step, x.shape, y, y.shape)
model & optimizers
model = tf.kearas.Sequential([
    layers.Dense(512,activation="relu"),
    layers.Dense(256,activation="relu"),
    layers.Dense(10)])
#Dense层:全连接层
optimizers = optimizers.SGD(learning_rate = 0.001)
#optimizer:梯度下降梯度的更新方式
#SGD:随机梯度下降算法
step1 & step2 Compute out & loss
with tf.GradientTape() as tape :
    #[b,28,28] => [b, 784]

    x =tf.reshape(x, (-1, 28*28))

    #把图片由[28, 28, 1]打平成 [1, 784]
    #step1. compute output
    #[b, 784] => [b, 10]

    out = model(x)

    #进行前向运算,拿到out用来计算loss值
    #step2 compute loss

    loss = tf.reduce_sum(tf.square(out - y)) / x.shape[0]
    
    #square:平方   
    计算out与y的欧式距离
step3 loss & updata
    # step3 optimize and update w1, w2, w3, b1, b2, b3
    grads = tape.gradient(loss, model.trainable_variables)
    # 通过loss值与模型的参数值计算每个参数的梯度值
    # w` = w - lr * grad

    optimizers.apply_gradients(zip(grads, model.trainable_variables))
    # 根据grads梯度值自动对模型参数进行更新
loop
def train_epoch(epoch):
    #step4 loop
    for step, (x,y) in enumerate(train_dataset):
        with tf.GradientTape() as tape:
            # [b,28,28] => [b, 784]

            x = tf.reshape(x, (-1, 28 * 28))
            # 把图片由[28, 28, 1]打平成 [1, 784]
            # step1. compute output
            # [b, 784] => [b, 10]

            out = model(x)
            # 进行前向运算,拿到out用来计算loss值
            # step2 compute loss

            loss = tf.reduce_sum(tf.square(out - y)) / x.shape[0]
            # square:平方,计算out与y的欧式距离
    # step3 optimize and update w1, w2, w3, b1, b2, b3
    grads = tape.gradient(loss, model.trainable_variables)
    # 通过loss值与模型的参数值计算每个参数的梯度值
    # w` = w - lr * grad

    optimizers.apply_gradients(zip(grads, model.trainable_variables))
    # 根据grads梯度值自动对模型参数进行更新
    if step % 100 ==0:
        print(epoch, step, loss.numpy())
ALL code

环境

  • anaconda3
  • tensorflow2
  • python3.7
import  os
os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
#可以减少运行时的警告信息

import  tensorflow as tf
from    tensorflow import keras
from    tensorflow.keras import layers, optimizers, datasets



(x, y), (x_val, y_val) = datasets.mnist.load_data() 
x = tf.convert_to_tensor(x, dtype=tf.float32) / 255.
y = tf.convert_to_tensor(y, dtype=tf.int32)
y = tf.one_hot(y, depth=10)
print(x.shape, y.shape)
train_dataset = tf.data.Dataset.from_tensor_slices((x, y))
train_dataset = train_dataset.batch(200)

 


model = keras.Sequential([ 
    layers.Dense(512, activation='relu'),
    layers.Dense(256, activation='relu'),
    layers.Dense(10)])

optimizer = optimizers.SGD(learning_rate=0.001)


def train_epoch(epoch):

    # Step4.loop
    for step, (x, y) in enumerate(train_dataset):


        with tf.GradientTape() as tape:
            # [b, 28, 28] => [b, 784]
            x = tf.reshape(x, (-1, 28*28))
            # Step1. compute output
            # [b, 784] => [b, 10]
            out = model(x)
            # Step2. compute loss
            loss = tf.reduce_sum(tf.square(out - y)) / x.shape[0]

        # Step3. optimize and update w1, w2, w3, b1, b2, b3
        grads = tape.gradient(loss, model.trainable_variables)
        # w' = w - lr * grad
        optimizer.apply_gradients(zip(grads, model.trainable_variables))

        if step % 100 == 0:
            print(epoch, step, 'loss:', loss.numpy())



def train():

    for epoch in range(30):

        train_epoch(epoch)
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值