• 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏吧

3搭建神经网络的套路:用Tensorflow API–tf.keras搭建网络(六步法)

互联网 diligentman 2周前 (01-11) 12次浏览

搭建神经网络的套路

 

3.1六步法搭建神经网络

3.1.1 tf.keras搭建网络(六步法)来快速搭建神经网络于Sequential

可以搭建出上层输出就是下层输入的的顺序网络结构,但无法写出一些带有跳连的非顺序网络结构

提纲 举例
import import相关模块 import tensorflow as tf
train, test 告知要喂入网络的训练集和测试集是什么 指定训练集的输入特征x_train和训练集的标签y_train;测试集的输入特征x_test和训练集的标签y_test
model = tf.keras.models.Sequential 在Sequential中搭建网络结构,逐层描述每层网络 相当于走了一遍前向传播
model.compile 在compile中配置训练方法 告知选择那个优化器、哪个损失函数、哪个评测指标
model.fit 在fit中执行训练过程 告知训练集和测试集的输入特征和标签,告知每个batch是多少,告知要迭代多少次数据集
model.summary 用summary打印出网络的结构和参数统计

 

 

 


model = tf.keras.models.Sequential ([ 网络结构 ]) #描述各层网络

网络结构举例:

拉直层:

 tf.keras.layers.Flatten( )

全连接层:

 tf.keras.layers.Dense(神经元个数,
                       activation= "激活函数“ , 
                       kernel_regularizer=哪种正则化)

activation(字符串给出)可选: relu、 softmax、 sigmoid 、 tanh

kernel_regularizer可选: tf.keras.regularizers.l1()、tf.keras.regularizers.l2()

卷积层:

tf.keras.layers.Conv2D(filters = 卷积核个数,
                       kernel_size = 卷积核尺寸,
                       strides = 卷积步长,
                       padding = " valid" or "same")

LSTM层:

tf.keras.layers.LSTM()

model.compile(optimizer = 优化器,
              loss = 损失函数
              metrics = [“准确率”] )

Optimizer可选: (优化器)

sgd’ or tf.keras.optimizers.SGD (lr=学习率,momentum=动量参数)

adagrad’ or tf.keras.optimizers.Adagrad (lr=学习率)

adadelta’ or tf.keras.optimizers.Adadelta (lr=学习率)

adam’ or tf.keras.optimizers.Adam (lr=学习率, beta_1=0.9, beta_2=0.999)


loss可选: (损失函数)

mse’ 或 tf.keras.losses.MeanSquaredError()

sparse_categorical_crossentropy’ 或 tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False)

关于rom_logits=Ture还是Falsed的注:有些神经网络的输出是经过softmax等函数的概率分布,有些不经过概率分布直接输出,参数from_logits=是在询问这个输出是否是原始输出,false表示没有经过概率分布的输出。若神经网络预测结果输出前经过概率分布,用False;若神经网络预测结果输出前没有经过概率分布,直接输出了,用Ture。


Metrics可选: (告知评测指标给网络)

accuracy’ :y_和y都是数值,如y_=[1] y=[1]

categorical_accuracy’ :y_和y都是独热码(概率分布),如y_=[0,1,0] y=[0.256,0.695,0.048]

sparse_categorical_accuracy’ :y_是数值,y是独热码(概率分布),如y_=[1] y=[0.256,0.695,0.048](常用)


model.fit (训练集的输入特征, 训练集的标签,
           batch_size=每次喂入NN网络的样本数 , epochs=迭代数据集的次数 ,
           validation_data=(测试集的输入特征,测试集的标签),
           validation_split=从训练集划分多少比例给测试集,
           validation_freq = 每多少次epoch迭代使用测试集验证一次结果)

#  validation_data和validation_split二选一,前者是数据集和测试集已经分开,后者是从总数据集中分出测试集

model.summary()#打印网络的结构和参数统计

3搭建神经网络的套路:用Tensorflow API--tf.keras搭建网络(六步法)


例子:六步法实现鸢尾花分类

# --1-- import相关模块
import tensorflow as tf
from sklearn import datasets
import numpy as np

# --2-- train,test 交代训练集输入特征x_train和标签y_train
x_train = datasets.load_iris().data
y_train = datasets.load_iris().target
# 数据集乱序
np.random.seed(116)
np.random.shuffle(x_train)
np.random.seed(116)
np.random.shuffle(y_train)
tf.random.set_seed(116)

# --3-- 在Sequential中搭建网络结构
model = tf.keras.models.Sequential(
            [tf.keras.layers.Dense(3, 
                                   activation='softmax',                                                  
                                   kernel_regularizer=tf.keras.regularizers.l2())
            ])# 设置神经元个数、激活函数、正则化方法

# --4-- 在model.compilez中配置训练方法
model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])
             # SGD优化器、学习率0.1、选损失函数SparseCategoricalCrossentropy,
             # 由于NN网络末端用了softmax,使输出为概率分布非原始输出,故from_logits设为False
             # 由于花的分类是标签,而网络输出的是概率,使用评测指标用sparse_categorical_accuracy

# --5-- 在fit中执行训练过程
#  告知训练集特征和标签、一次喂入数据量、数据集迭代循环次数、
#   选训练集20%作测试集、每迭代20次验证一次准确率
model.fit(x_train, y_train, batch_size=32, epochs=500, 
          validation_split=0.2, validation_freq=20) 

# --6-- summary打印网络结构和参数统计
model.summary()

打印出的结构如下

3搭建神经网络的套路:用Tensorflow API--tf.keras搭建网络(六步法)

3.1.2 tf.keras搭建网络(六步法)来快速搭建神经网络于class类

用类class封装神经网络结构,可写出一些带有跳连的非顺序网络结构

提纲 举例
import import相关模块 import tensorflow as tf
train, test 告知要喂入网络的训练集和测试集是什么 指定训练集的输入特征x_train和训练集的标签y_train;测试集的输入特征x_test和训练集的标签y_test
class MyModel(Model) model=MyModel 在class类中搭建网络结构,逐层描述每层网络 相当于走了一遍前向传播
model.compile 在compile中配置训练方法 告知选择那个优化器、哪个损失函数、哪个评测指标
model.fit 在fit中执行训练过程 告知训练集和测试集的输入特征和标签,告知每个batch是多少,告知要迭代多少次数据集
model.summary 用summary打印出网络的结构和参数统计  

 

class MyModel(Model) model = MyModel

class MyModel(Model):
    def __init__(self):
        super(MyModel, self).__init__()
        定义网络结构块
    def call(self, x):
        调用网络结构块,实现前向传播
        return y
model = MyModel()

__init__( ) 定义所需网络结构块

call( ) 写出前向传播

程序开头记得调用from tensorflow.keras import Model

例子

class IrisModel(Model):
    def __init__(self):
        super(IrisModel, self).__init__()
        self.d1 = Dense(3)

    def call(self, x):
        y = self.d1(x)
        return y
model =IrisModel()

对比

3搭建神经网络的套路:用Tensorflow API--tf.keras搭建网络(六步法)

3.2 iris代码复现


import tensorflow as tf
from tensorflow.keras.layers import Dense
from tensorflow.keras import Model
from sklearn import datasets
import numpy as np

x_train = datasets.load_iris().data
y_train = datasets.load_iris().target

np.random.seed(116)
np.random.shuffle(x_train)
np.random.seed(116)
np.random.shuffle(y_train)
tf.random.set_seed(116)

class IrisModel(Model):
    def __init__(self):
        super(IrisModel, self).__init__()
        self.d1 = Dense(3, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2())

    def call(self, x):
        y = self.d1(x)
        return y

model = IrisModel()

model.compile(optimizer=tf.keras.optimizers.SGD(lr=0.1),
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

model.fit(x_train, y_train, batch_size=32, epochs=500, validation_split=0.2, validation_freq=20)
model.summary()

3.3 MNIST数据集


3搭建神经网络的套路:用Tensorflow API--tf.keras搭建网络(六步法)

提供 6万张 28*28 像素点的0~9手写数字图片和标签,用于训练。

提供 1万张 28*28 像素点的0~9手写数字图片和标签,用于测试。

导入MNIST数据集:

mnist = tf.keras.datasets.mnist
(x_train, y_train) , (x_test, y_test) = mnist.load_data()

作为输入特征,输入神经网络时,将数据拉伸为一维数组:

tf.keras.layers.Flatten( )

拉伸后效果,如:[ 0 0 0 48 238 252 252 …… …… …… 253 186 12 0 0 0 0 0]

绘制灰度图

plt.imshow(x_train[0], cmap='gray')#绘制灰度图
plt.show()

3搭建神经网络的套路:用Tensorflow API--tf.keras搭建网络(六步法)

打印:

print("x_train[0]:n" , x_train[0])

x_train[0]:3搭建神经网络的套路:用Tensorflow API--tf.keras搭建网络(六步法)

print("y_train[0]:", y_train[0])

print("x_test.shape:", x_test.shape

y_train[0]:5

x_test.shape: (10000, 28, 28)

import tensorflow as tf
from matplotlib import pyplot as plt

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 可视化训练集输入特征的第一个元素
plt.imshow(x_train[0], cmap='gray')  # 绘制灰度图
plt.show()

# 打印出训练集输入特征的第一个元素
print("x_train[0]:n", x_train[0])
# 打印出训练集标签的第一个元素
print("y_train[0]:n", y_train[0])

# 打印出整个训练集输入特征形状
print("x_train.shape:n", x_train.shape)
# 打印出整个训练集标签的形状
print("y_train.shape:n", y_train.shape)
# 打印出整个测试集输入特征的形状
print("x_test.shape:n", x_test.shape)
# 打印出整个测试集标签的形状
print("y_test.shape:n", y_test.shape)

3.4 训练MNIST数据集


基于sequential

import tensorflow as tf

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1)
model.summary()

基于class

import tensorflow as tf
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras import Model

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0


class MnistModel(Model):
    def __init__(self):
        super(MnistModel, self).__init__()
        self.flatten = Flatten()
        self.d1 = Dense(128, activation='relu')
        self.d2 = Dense(10, activation='softmax')

    def call(self, x):
        x = self.flatten(x)
        x = self.d1(x)
        y = self.d2(x)
        return y


model = MnistModel()

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

model.fit(x_train, y_train, batch_size=32, epochs=5, validation_data=(x_test, y_test), validation_freq=1)
model.summary()

3.5 Fashion数据集


3搭建神经网络的套路:用Tensorflow API--tf.keras搭建网络(六步法)

提供 6万张 28*28 像素点的衣裤等图片和标签,用于训练。

提供 1万张 28*28 像素点的衣裤等图片和标签,用于测试。

标签如下

3搭建神经网络的套路:用Tensorflow API--tf.keras搭建网络(六步法)

导入FASHION数据集:

fashion = tf.keras.datasets.fashion_mnist
(x_train, y_train),(x_test, y_test) = fashion.load_data()

1.基于sequential构建的神经网络

#  fashion_sequential.py 
import tensorflow as tf

fashion = tf.keras.datasets.fashion_mnist
(x_train, y_train),(x_test, y_test) = fashion.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

model = tf.keras.models.Sequential([
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])  #  平滑

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

model.fit(x_train, y_train,
          batch_size=50, epochs=200,
          validation_data=(x_test, y_test),
          validation_freq=1)
model.summary()

– loss: 0.0236

– sparse_categorical_accuracy: 0.9914

– val_loss: 1.2061

– val_sparse_categorical_accuracy: 0.8881

Model: "sequential"

3搭建神经网络的套路:用Tensorflow API--tf.keras搭建网络(六步法)

2.基于 class类构建的神经网络

#  fashion_class.py 
import tensorflow as tf
from tensorflow.keras import Model

fashion = tf.keras.datasets.fashion_mnist
(x_train, y_train), (x_test, y_test) = fashion.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

class FashionModel(Model):
    def __init__(self):
        super(FashionModel, self).__init__()
        self.flatten = tf.keras.layers.Flatten()
        self.d1 = tf.keras.layers.Dense(128, activation='relu')
        self.d2 = tf.keras.layers.Dense(10, activation='softmax')

    def call(self, x):
        x = self.flatten(x)
        x = self.d1(x)
        y = self.d2(x)
        return y

model = FashionModel()

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=False),
              metrics=['sparse_categorical_accuracy'])

model.fit(x_train, y_train,
          batch_size=50, epochs=20,
          validation_data=(x_test, y_test),
          validation_freq=1)
model.summary()

 – loss: 0.1825

– sparse_categorical_accuracy: 0.9326

– val_loss: 0.3410

– val_sparse_categorical_accuracy: 0.8912

Model: "fashion_model"

3搭建神经网络的套路:用Tensorflow API--tf.keras搭建网络(六步法)


喜欢 (0)