月度归档：2021年04月

1.导入CIFAR-10数据集

CIFAR-10是由 Hinton 的学生 Alex Krizhevsky 和 Ilya Sutskever 整理的一个用于识别普适物体的小型数据集。一共包含 10 个类别的 RGB 彩色图片：飞机（ a叩lane ）、汽车（ automobile ）、鸟类（ bird ）、猫（ cat ）、鹿（ deer ）、狗（ dog ）、蛙类（ frog ）、马（ horse ）、船（ ship ）和卡车（ truck ）。图片的尺寸为 32×32，3个通道，数据集中一共有 50000 张训练圄片和 10000 张测试图片。 CIFAR-10数据集有3个版本，这里使用python版本。

1.1 导入需要的库

import os
import math
import numpy as np
import pickle as p
import tensorflow as tf
import matplotlib.pyplot as plt
%matplotlib inline

import os

import math

import numpy as np

import pickle as p

import tensorflow as tf

import matplotlib.pyplot as plt

%matplotlib inline

1.2 定义批量导入数据的函数

def load_CIFAR_batch(filename):
    """ load single batch of cifar """  
    with open(filename, 'rb')as f:
        # 一个样本由标签和图像数据组成
        #  (3072=32x32x3)
        # ...
        # 
        data_dict = p.load(f, encoding='bytes')
        images= data_dict[b'data']
        labels = data_dict[b'labels']
                
        # 把原始数据结构调整为: BCWH
        images = images.reshape(10000, 3, 32, 32)
        # tensorflow处理图像数据的结构：BWHC
        # 把通道数据C移动到最后一个维度
        images = images.transpose (0,2,3,1)
     
        labels = np.array(labels)
        
        return images, labels

def load_CIFAR_batch(filename):

""" load single batch of cifar """

with open(filename, 'rb')as f:

# 一个样本由标签和图像数据组成

# (3072=32x32x3)

# ...

data_dict = p.load(f, encoding='bytes')

images= data_dict[b'data']

labels = data_dict[b'labels']

# 把原始数据结构调整为: BCWH

images = images.reshape(10000, 3, 32, 32)

# tensorflow处理图像数据的结构：BWHC

# 把通道数据C移动到最后一个维度

images = images.transpose (0,2,3,1)

labels = np.array(labels)

return images, labels

1.3 定义加载数据函数

def load_CIFAR_data(data_dir):
    """load CIFAR data"""
 
    images_train=[]
    labels_train=[]
    for i in range(5):
        f=os.path.join(data_dir,'data_batch_%d' % (i+1))
        print('loading ',f)
        # 调用 load_CIFAR_batch( )获得批量的图像及其对应的标签
        image_batch,label_batch=load_CIFAR_batch(f)
        images_train.append(image_batch)
        labels_train.append(label_batch)
        Xtrain=np.concatenate(images_train)
        Ytrain=np.concatenate(labels_train)
        del image_batch ,label_batch
    
    Xtest,Ytest=load_CIFAR_batch(os.path.join(data_dir,'test_batch'))
    print('finished loadding CIFAR-10 data')
    
    # 返回训练集的图像和标签，测试集的图像和标签
    return (Xtrain,Ytrain),(Xtest,Ytest)

def load_CIFAR_data(data_dir):

"""load CIFAR data"""

images_train=[]

labels_train=[]

for i in range(5):

f=os.path.join(data_dir,'data_batch_%d' % (i+1))

print('loading ',f)

# 调用 load_CIFAR_batch( )获得批量的图像及其对应的标签

image_batch,label_batch=load_CIFAR_batch(f)

images_train.append(image_batch)

labels_train.append(label_batch)

Xtrain=np.concatenate(images_train)

Ytrain=np.concatenate(labels_train)

del image_batch ,label_batch

Xtest,Ytest=load_CIFAR_batch(os.path.join(data_dir,'test_batch'))

print('finished loadding CIFAR-10 data')

# 返回训练集的图像和标签，测试集的图像和标签

return (Xtrain,Ytrain),(Xtest,Ytest)

1.4 加载数据

data_dir = r'data\cifar-10-batches-py'
(x_train,y_train),(x_test,y_test) = load_CIFAR_data(data_dir)

1 2	data_dir = r'data\cifar-10-batches-py' (x_train,y_train),(x_test,y_test) = load_CIFAR_data(data_dir)

运行结果
loading data\cifar-10-batches-py\data_batch_1
loading data\cifar-10-batches-py\data_batch_2
loading data\cifar-10-batches-py\data_batch_3
loading data\cifar-10-batches-py\data_batch_4
loading data\cifar-10-batches-py\data_batch_5
finished loadding CIFAR-10 data

1.5 可视化加载数据

label_dict = {0:"airplane", 1:"
automobile", 2:"bird", 3:"cat", 4:"deer",
              5:"dog", 6:"frog", 7:"horse", 8:"ship", 9:"truck"}


def plot_images_labels(images, labels, num):
    total = len(images)
    fig = plt.gcf()
    fig.set_size_inches(15, math.ceil(num / 10) * 7)
    for i in range(0, num):
        choose_n = np.random.randint(0, total)
        
        ax = plt.subplot(math.ceil(num / 5), 5, 1 + i)
        ax.imshow(images[choose_n], cmap='binary')
        title = label_dict[labels[choose_n]]
        ax.set_title(title, fontsize=10)        
    plt.show()
	
plot_images_labels(x_train, y_train, 10)

label_dict = {0:"airplane", 1:"

automobile", 2:"bird", 3:"cat", 4:"deer",

5:"dog", 6:"frog", 7:"horse", 8:"ship", 9:"truck"}

def plot_images_labels(images, labels, num):

total = len(images)

fig = plt.gcf()

fig.set_size_inches(15, math.ceil(num / 10) * 7)

for i in range(0, num):

choose_n = np.random.randint(0, total)

ax = plt.subplot(math.ceil(num / 5), 5, 1 + i)

ax.imshow(images[choose_n], cmap='binary')

title = label_dict[labels[choose_n]]

ax.set_title(title, fontsize=10)

plt.show()

plot_images_labels(x_train, y_train, 10)

运行结果

2 .数据预处理并设置超参数

x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

train_num = len(x_train)
num_classes = 10

learning_rate = 0.0002
batch_size = 64
training_steps = 20000
display_step = 1000

conv1_filters = 32
conv2_filters = 64
fc1_units = 256

x_train = x_train.astype('float32') / 255.0

x_test = x_test.astype('float32') / 255.0

train_num = len(x_train)

num_classes = 10

learning_rate = 0.0002

batch_size = 64

training_steps = 20000

display_step = 1000

conv1_filters = 32

conv2_filters = 64

fc1_units = 256

3.使用tf.data构建数据管道

AUTOTUNE = tf.data.experimental.AUTOTUNE
train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_data = train_data.shuffle(5000).repeat(training_steps).batch(batch_size).prefetch(buffer_size=AUTOTUNE)

AUTOTUNE = tf.data.experimental.AUTOTUNE

train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))

train_data = train_data.shuffle(5000).repeat(training_steps).batch(batch_size).prefetch(buffer_size=AUTOTUNE)

4.构建模型

使用子类方法自定义模型结构的一般步骤：

class MyCNN(tf.keras.Model):
    def __init__(self):
        super().__init__()
        self.conv1 = tf.keras.layers.Conv2D(
            filters=32,             # 卷积层神经元（卷积核）数目
            kernel_size=[3, 3],     # 感受野大小
            padding='same',         # padding策略（vaild 或 same）
            activation=tf.nn.relu   # 激活函数
        )
        self.pool1 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
        self.conv2 = tf.keras.layers.Conv2D(
            filters=64,
            kernel_size=[3, 3],
            padding='same',
            activation=tf.nn.relu
        )
        self.pool2 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)
        self.flatten = tf.keras.layers.Reshape(target_shape=(8 * 8 * 64,))
        self.dense1 = tf.keras.layers.Dense(units=256, activation=tf.nn.relu)
        self.dense2 = tf.keras.layers.Dense(units=10)

  
    def call(self, inputs):
        x = self.conv1(inputs)                  # [batch_size, 32, 32, 3]
        x = self.pool1(x)                       # [batch_size, 32, 32, 32]
        x = self.conv2(x)                       # [batch_size, 16, 16, 64]
        x = self.pool2(x)                       # [batch_size, 8, 8, 64]
        x = self.flatten(x)                     # [batch_size, 8 * 8 * 64]
        x = self.dense1(x)                      # [batch_size, 256]
        x = self.dense2(x)                      # [batch_size, 10]
        output = tf.nn.softmax(x)
        return output
    #为使用summary时能显示tensor的shape
    def model01(self):
        x = tf.keras.Input(shape=(32, 32, 3))
        return tf.keras.Model(inputs=[x], outputs=self.call(x))

class MyCNN(tf.keras.Model):

def __init__(self):

super().__init__()

self.conv1 = tf.keras.layers.Conv2D(

filters=32, # 卷积层神经元（卷积核）数目

kernel_size=[3, 3], # 感受野大小

padding='same', # padding策略（vaild 或 same）

activation=tf.nn.relu # 激活函数

)

self.pool1 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)

self.conv2 = tf.keras.layers.Conv2D(

filters=64,

kernel_size=[3, 3],

padding='same',

activation=tf.nn.relu

)

self.pool2 = tf.keras.layers.MaxPool2D(pool_size=[2, 2], strides=2)

self.flatten = tf.keras.layers.Reshape(target_shape=(8 * 8 * 64,))

self.dense1 = tf.keras.layers.Dense(units=256, activation=tf.nn.relu)

self.dense2 = tf.keras.layers.Dense(units=10)

def call(self, inputs):

x = self.conv1(inputs) # [batch_size, 32, 32, 3]

x = self.pool1(x) # [batch_size, 32, 32, 32]

x = self.conv2(x) # [batch_size, 16, 16, 64]

x = self.pool2(x) # [batch_size, 8, 8, 64]

x = self.flatten(x) # [batch_size, 8 * 8 * 64]

x = self.dense1(x) # [batch_size, 256]

x = self.dense2(x) # [batch_size, 10]

output = tf.nn.softmax(x)

return output

#为使用summary时能显示tensor的shape

def model01(self):

x = tf.keras.Input(shape=(32, 32, 3))

return tf.keras.Model(inputs=[x], outputs=self.call(x))

5.训练模型

（1）实例化模型
model = MyCNN()
（2）查看模型的详细结构
model.model01().summary()
Model: "model"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_1 (InputLayer) [(None, 32, 32, 3)] 0
_________________________________________________________________
conv2d (Conv2D) (None, 32, 32, 32) 896
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 16, 16, 32) 0
_________________________________________________________________
conv2d_1 (Conv2D) (None, 16, 16, 64) 18496
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 8, 8, 64) 0
_________________________________________________________________
reshape (Reshape) (None, 4096) 0
_________________________________________________________________
dense (Dense) (None, 256) 1048832
_________________________________________________________________
dense_1 (Dense) (None, 10) 2570
_________________________________________________________________
tf_op_layer_Softmax (TensorF [(None, 10)] 0
=================================================================
Total params: 1,070,794
Trainable params: 1,070,794
Non-trainable params: 0
（3）编译及训练模型
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
epochs = 10
batch_size = 64
learning_rate = 0.0002

train_history = model.fit(x_train, y_train,
validation_split=0.2,
epochs=epochs,
#steps_per_epoch=100,
batch_size=batch_size,
verbose=1)
运行结果
Train on 40000 samples, validate on 10000 samples
Epoch 1/10
40000/40000 [==============================] - 5s 113us/sample - loss: 1.4482 - accuracy: 0.4811 - val_loss: 1.1808 - val_accuracy: 0.5889
Epoch 2/10
40000/40000 [==============================] - 2s 53us/sample - loss: 1.0530 - accuracy: 0.6291 - val_loss: 1.0052 - val_accuracy: 0.6466
Epoch 3/10
40000/40000 [==============================] - 2s 51us/sample - loss: 0.9031 - accuracy: 0.6814 - val_loss: 0.9358 - val_accuracy: 0.6751
Epoch 4/10
40000/40000 [==============================] - 2s 50us/sample - loss: 0.7926 - accuracy: 0.7207 - val_loss: 0.8919 - val_accuracy: 0.6909
Epoch 5/10
40000/40000 [==============================] - 2s 53us/sample - loss: 0.6966 - accuracy: 0.7573 - val_loss: 0.8932 - val_accuracy: 0.6904
Epoch 6/10
40000/40000 [==============================] - 2s 50us/sample - loss: 0.6029 - accuracy: 0.7889 - val_loss: 0.8699 - val_accuracy: 0.7036
Epoch 7/10
40000/40000 [==============================] - 2s 51us/sample - loss: 0.5131 - accuracy: 0.8210 - val_loss: 0.8832 - val_accuracy: 0.7092
Epoch 8/10
40000/40000 [==============================] - 2s 52us/sample - loss: 0.4263 - accuracy: 0.8533 - val_loss: 0.9517 - val_accuracy: 0.7028
Epoch 9/10
40000/40000 [==============================] - 2s 53us/sample - loss: 0.3407 - accuracy: 0.8815 - val_loss: 0.9970 - val_accuracy: 0.7065
Epoch 10/10
40000/40000 [==============================] - 2s 52us/sample - loss: 0.2693 - accuracy: 0.9078 - val_loss: 1.0540 - val_accuracy: 0.7090

6.可视化运行结果

plt.title('the train and validate')
plt.xlabel('Times')
plt.ylabel('Loss value')
plt.plot(train_history.history['loss'], color=(1, 0, 0), label='Loss train')
plt.plot(train_history.history['val_accuracy'], color=(0, 0, 1), label='Accuracy train')
plt.legend(loc='best')
plt.show()

plt.title('the train and validate')

plt.xlabel('Times')

plt.ylabel('Loss value')

plt.plot(train_history.history['loss'], color=(1, 0, 0), label='Loss train')

plt.plot(train_history.history['val_accuracy'], color=(0, 0, 1), label='Accuracy train')

plt.legend(loc='best')

plt.show()

7.测试模型

test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print('test_loss:', test_loss,'\ntest_acc:', test_acc,'\nmetrics_names:', model.metrics_names)

1 2	test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2) print('test_loss:', test_loss,'\ntest_acc:', test_acc,'\nmetrics_names:', model.metrics_names)

运行结果
10000/10000 - 1s - loss: 1.1505 - accuracy: 0.6936
test_loss: 1.1505295364379884
test_acc: 0.6936
metrics_names: ['loss', 'accuracy']

8.保存恢复整个模型

（1）保存模型参数及网络结构等
可以使用两种格式将整个模型保存到磁盘：TensorFlow SavedModel 格式和较早的 Keras H5 格式。 tensorflow官方推荐使用 SavedModel 格式。它是使用 model.save() 时的默认格式,这种保存方式适合Sequential, Functional Model, or Model subclass。

model.save('my_model')

1	model.save('my_model')

（2）恢复模型

newmodel = keras.models.load_model('my_model')

1	newmodel = keras.models.load_model('my_model')

（3）检查恢复模型的结构

newmodel.summary()

1	newmodel.summary()

运行结果
Model: "my_cnn_1"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
conv2d_2 (Conv2D) multiple 896
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 multiple 0
_________________________________________________________________
conv2d_3 (Conv2D) multiple 18496
_________________________________________________________________
max_pooling2d_3 (MaxPooling2 multiple 0
_________________________________________________________________
reshape_1 (Reshape) multiple 0
_________________________________________________________________
dense_2 (Dense) multiple 1048832
_________________________________________________________________
dense_3 (Dense) multiple 2570
=================================================================
Total params: 1,070,794
Trainable params: 1,070,794
Non-trainable params: 0
_______________________________
与原模型结构完全一致！

（4）基于恢复模型进行测试

test_loss, test_acc = newmodel.evaluate(x_test, y_test, verbose=2)
print('test_loss:', test_loss,'\ntest_acc:', test_acc,'\nmetrics_names:', model.metrics_names)

1 2	test_loss, test_acc = newmodel.evaluate(x_test, y_test, verbose=2) print('test_loss:', test_loss,'\ntest_acc:', test_acc,'\nmetrics_names:', model.metrics_names)

运行结果
10000/10000 - 1s - loss: 1.1488 - accuracy: 0.6936
test_loss: 1.1488204129219055
test_acc: 0.6936
metrics_names: ['loss', 'accuracy']
模型精度与原模型完全一致！

有三种计算图的构建方式：静态计算图，动态计算图，以及Autograph。 TensorFlow 2.0主要使用的是动态计算图和Autograph。动态计算图易于调试，编码效率较高，但执行效率偏低。静态计算图执行效率很高，但较难调试。而Autograph机制可以将动态图转换成静态计算图，兼收执行效率和编码效率之利。当然Autograph机制能够转换的代码并不是没有任何约束的，有一些编码规范需要遵循，否则可能会转换失败或者不符合预期。我们将着重介绍Autograph的编码规范和Autograph转换成静态图的原理。
Autograph编码规范:
• 1.被@tf.function修饰的函数应尽可能使用TensorFlow中的函数而不是Python中的其他函数。例如使用tf.print而不是print，使用tf.range而不是range，使用tf.constant(True)而不是True.
• 2.避免在@tf.function修饰的函数内部定义tf.Variable.
• 3.被@tf.function修饰的函数不可修改该函数外部的Python列表或字典等数据结构变量。

1.导入CIFAR-10数据集

1.1 导入需要的库

import os
import math
import numpy as np
import pickle as p
import tensorflow as tf
import matplotlib.pyplot as plt
%matplotlib inline

import os

import math

import numpy as np

import pickle as p

import tensorflow as tf

import matplotlib.pyplot as plt

%matplotlib inline

1.2 定义批量导入数据的函数

def load_CIFAR_batch(filename):
    """ load single batch of cifar """  
    with open(filename, 'rb')as f:
        # 一个样本由标签和图像数据组成
        #  (3072=32x32x3)
        # ...
        # 
        data_dict = p.load(f, encoding='bytes')
        images= data_dict[b'data']
        labels = data_dict[b'labels']
                
        # 把原始数据结构调整为: BCWH
        images = images.reshape(10000, 3, 32, 32)
        # tensorflow处理图像数据的结构：BWHC
        # 把通道数据C移动到最后一个维度
        images = images.transpose (0,2,3,1)
     
        labels = np.array(labels)
        
        return images, labels

def load_CIFAR_batch(filename):

""" load single batch of cifar """

with open(filename, 'rb')as f:

# 一个样本由标签和图像数据组成

# (3072=32x32x3)

# ...

data_dict = p.load(f, encoding='bytes')

images= data_dict[b'data']

labels = data_dict[b'labels']

# 把原始数据结构调整为: BCWH

images = images.reshape(10000, 3, 32, 32)

# tensorflow处理图像数据的结构：BWHC

# 把通道数据C移动到最后一个维度

images = images.transpose (0,2,3,1)

labels = np.array(labels)

return images, labels

1.3 定义加载数据函数

def load_CIFAR_data(data_dir):
    """load CIFAR data"""
 
    images_train=[]
    labels_train=[]
    for i in range(5):
        f=os.path.join(data_dir,'data_batch_%d' % (i+1))
        print('loading ',f)
        # 调用 load_CIFAR_batch( )获得批量的图像及其对应的标签
        image_batch,label_batch=load_CIFAR_batch(f)
        images_train.append(image_batch)
        labels_train.append(label_batch)
        Xtrain=np.concatenate(images_train)
        Ytrain=np.concatenate(labels_train)
        del image_batch ,label_batch
    
    Xtest,Ytest=load_CIFAR_batch(os.path.join(data_dir,'test_batch'))
    print('finished loadding CIFAR-10 data')
    
    # 返回训练集的图像和标签，测试集的图像和标签
    return (Xtrain,Ytrain),(Xtest,Ytest)

def load_CIFAR_data(data_dir):

"""load CIFAR data"""

images_train=[]

labels_train=[]

for i in range(5):

f=os.path.join(data_dir,'data_batch_%d' % (i+1))

print('loading ',f)

# 调用 load_CIFAR_batch( )获得批量的图像及其对应的标签

image_batch,label_batch=load_CIFAR_batch(f)

images_train.append(image_batch)

labels_train.append(label_batch)

Xtrain=np.concatenate(images_train)

Ytrain=np.concatenate(labels_train)

del image_batch ,label_batch

Xtest,Ytest=load_CIFAR_batch(os.path.join(data_dir,'test_batch'))

print('finished loadding CIFAR-10 data')

# 返回训练集的图像和标签，测试集的图像和标签

return (Xtrain,Ytrain),(Xtest,Ytest)

1.4 加载数据

data_dir = r'data\cifar-10-batches-py'
(x_train,y_train),(x_test,y_test) = load_CIFAR_data(data_dir)

1 2	data_dir = r'data\cifar-10-batches-py' (x_train,y_train),(x_test,y_test) = load_CIFAR_data(data_dir)

1.5 可视化加载数据

label_dict = {0:"airplane", 1:"
automobile", 2:"bird", 3:"cat", 4:"deer",
              5:"dog", 6:"frog", 7:"horse", 8:"ship", 9:"truck"}


def plot_images_labels(images, labels, num):
    total = len(images)
    fig = plt.gcf()
    fig.set_size_inches(15, math.ceil(num / 10) * 7)
    for i in range(0, num):
        choose_n = np.random.randint(0, total)
        
        ax = plt.subplot(math.ceil(num / 5), 5, 1 + i)
        ax.imshow(images[choose_n], cmap='binary')
        title = label_dict[labels[choose_n]]
        ax.set_title(title, fontsize=10)        
    plt.show()
	
plot_images_labels(x_train, y_train, 10)

label_dict = {0:"airplane", 1:"

automobile", 2:"bird", 3:"cat", 4:"deer",

5:"dog", 6:"frog", 7:"horse", 8:"ship", 9:"truck"}

def plot_images_labels(images, labels, num):

total = len(images)

fig = plt.gcf()

fig.set_size_inches(15, math.ceil(num / 10) * 7)

for i in range(0, num):

choose_n = np.random.randint(0, total)

ax = plt.subplot(math.ceil(num / 5), 5, 1 + i)

ax.imshow(images[choose_n], cmap='binary')

title = label_dict[labels[choose_n]]

ax.set_title(title, fontsize=10)

plt.show()

plot_images_labels(x_train, y_train, 10)

运行结果

2 .数据预处理并设置超参数

x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

train_num = len(x_train)
num_classes = 10

learning_rate = 0.0002
batch_size = 64
training_steps = 20000
display_step = 1000

conv1_filters = 32
conv2_filters = 64
fc1_units = 256

x_train = x_train.astype('float32') / 255.0

x_test = x_test.astype('float32') / 255.0

train_num = len(x_train)

num_classes = 10

learning_rate = 0.0002

batch_size = 64

training_steps = 20000

display_step = 1000

conv1_filters = 32

conv2_filters = 64

fc1_units = 256

3.使用tf,data构建数据管道

AUTOTUNE = tf.data.experimental.AUTOTUNE
train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_data = train_data.shuffle(5000).repeat(training_steps).batch(batch_size).prefetch(buffer_size=AUTOTUNE)

AUTOTUNE = tf.data.experimental.AUTOTUNE

train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))

train_data = train_data.shuffle(5000).repeat(training_steps).batch(batch_size).prefetch(buffer_size=AUTOTUNE)

4.定义卷积层及池化层

@tf.function
def conv2d(x, W, b, strides=1):
    x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
    x = tf.nn.bias_add(x, b)
    return tf.nn.relu(x)

@tf.function
def maxpool2d(x, k=2):
    return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME')

@tf.function

def conv2d(x, W, b, strides=1):

x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')

x = tf.nn.bias_add(x, b)

return tf.nn.relu(x)

@tf.function

def maxpool2d(x, k=2):

return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME')

5.构建模型

class CNNModel(tf.Module):
    def __init__(self,name = None):
        super(CNNModel, self).__init__(name=name)
        self.w1 = tf.Variable(random_normal([3, 3, 3, conv1_filters]))#[k_width, k_height, input_chn, output_chn]
        self.b1 = tf.Variable(tf.zeros([conv1_filters]))
        #输入通道：32，输出通道：64，卷积后图像尺寸不变，依然是16x16
        self.w2 = tf.Variable(random_normal([3, 3, conv1_filters, conv2_filters]))
        self.b2 = tf.Variable(tf.zeros([conv2_filters]))
        #将池第2个池化层的64个8x8的图像转换为一维的向量，长度是 64*8*8=4096
        self.w3 = tf.Variable(random_normal([4096, fc1_units]))
        self.b3 = tf.Variable(tf.zeros([fc1_units]))
        self.wout = tf.Variable(random_normal([fc1_units, num_classes]))
        self.bout = tf.Variable(tf.zeros([num_classes]))

     
    # 正向传播
    @tf.function
    def __call__(self,x):
        conv1 = conv2d(x, self.w1, self.b1)
        pool1 = maxpool2d(conv1, k=2)  #将32x32图像缩小为16x16，池化不改变通道数量，因此依然是32个
        conv2 = conv2d(pool1, self.w2, self.b2)
        pool2 = maxpool2d(conv2, k=2)
        flat = tf.reshape(pool2, [-1, self.w3.get_shape().as_list()[0]])
        fc1 = tf.add(tf.matmul(flat, self.w3), self.b3)
        fc1 = tf.nn.relu(fc1)
        out = tf.add(tf.matmul(fc1, self.wout), self.bout)
    
        return tf.nn.softmax(out) 
    
    # 损失函数(二元交叉熵)
    @tf.function
    def cross_entropy(self,y_pred, y_true):
        y_pred = tf.clip_by_value(y_pred, 1e-9, 1.)
        loss_ = tf.keras.losses.sparse_categorical_crossentropy(y_true=y_true, y_pred=y_pred)
    
        return tf.reduce_mean(loss_)
    
    # 评估指标(准确率)
    @tf.function
    def accuracy(self,y_pred, y_true):
        correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.reshape(tf.cast(y_true, tf.int64), [-1]))
        return tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
   
    
model = CNNModel()
#通过添加属性的方法进行封装
model.optimizer = tf.optimizers.Adam(learning_rate)

class CNNModel(tf.Module):

def __init__(self,name = None):

super(CNNModel, self).__init__(name=name)

self.w1 = tf.Variable(random_normal([3, 3, 3, conv1_filters]))#[k_width, k_height, input_chn, output_chn]

self.b1 = tf.Variable(tf.zeros([conv1_filters]))

#输入通道：32，输出通道：64，卷积后图像尺寸不变，依然是16x16

self.w2 = tf.Variable(random_normal([3, 3, conv1_filters, conv2_filters]))

self.b2 = tf.Variable(tf.zeros([conv2_filters]))

#将池第2个池化层的64个8x8的图像转换为一维的向量，长度是 64*8*8=4096

self.w3 = tf.Variable(random_normal([4096, fc1_units]))

self.b3 = tf.Variable(tf.zeros([fc1_units]))

self.wout = tf.Variable(random_normal([fc1_units, num_classes]))

self.bout = tf.Variable(tf.zeros([num_classes]))

# 正向传播

@tf.function

def __call__(self,x):

conv1 = conv2d(x, self.w1, self.b1)

pool1 = maxpool2d(conv1, k=2) #将32x32图像缩小为16x16，池化不改变通道数量，因此依然是32个

conv2 = conv2d(pool1, self.w2, self.b2)

pool2 = maxpool2d(conv2, k=2)

flat = tf.reshape(pool2, [-1, self.w3.get_shape().as_list()[0]])

fc1 = tf.add(tf.matmul(flat, self.w3), self.b3)

fc1 = tf.nn.relu(fc1)

out = tf.add(tf.matmul(fc1, self.wout), self.bout)

return tf.nn.softmax(out)

# 损失函数(二元交叉熵)

@tf.function

def cross_entropy(self,y_pred, y_true):

y_pred = tf.clip_by_value(y_pred, 1e-9, 1.)

loss_ = tf.keras.losses.sparse_categorical_crossentropy(y_true=y_true, y_pred=y_pred)

return tf.reduce_mean(loss_)

# 评估指标(准确率)

@tf.function

def accuracy(self,y_pred, y_true):

correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.reshape(tf.cast(y_true, tf.int64), [-1]))

return tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

model = CNNModel()

#通过添加属性的方法进行封装

model.optimizer = tf.optimizers.Adam(learning_rate)

6.定义训练模型函数

自定训练过程：
（1）打开一个遍历各epoch的for循环
（2）对于每个epoch，打开一个分批遍历数据集的 for 循环
（3）对于每个批次，打开一个 GradientTape() 作用域
（4）在此作用域内，调用模型（前向传递）并计算损失
（5）在作用域之外，检索模型权重相对于损失的梯度
（6）根据梯度使用优化器来更新模型的权重
（7）评估模型指标

@tf.function
def train_step(model, features, labels):
    
    # 正向传播求损失
    with tf.GradientTape() as tape:
        predictions = model(features)
        loss = model.cross_entropy(predictions,labels) 
        
    # 反向传播求梯度
    grads = tape.gradient(loss, model.trainable_variables)
    
    # 执行梯度下降   
    model.optimizer.apply_gradients(zip(grads, model.trainable_variables))        
    # 计算评估指标
    metric = model.accuracy(predictions,labels)
    
    return loss, metric

train_loss_list1 = []
train_acc_list1 = []
def train_model(model,train_data,training_steps,display_step):
    #for epoch in tf.range(1,epochs+1): 
    for step, (batch_x, batch_y) in enumerate(train_data.take(training_steps), 1):
        starttime=time.time()
        loss,metric = train_step(model,batch_x,batch_y)
        
        if step % display_step == 0:
            #printbar()
            train_loss_list1.append(loss)
            train_acc_list1.append(metric)
            tf.print("step ={},loss = {:.4f},accuracy ={:.4f} ,times={:.4f}".format(step,loss,metric,(time.time() - starttime)))

@tf.function

def train_step(model, features, labels):

# 正向传播求损失

with tf.GradientTape() as tape:

predictions = model(features)

loss = model.cross_entropy(predictions,labels)

# 反向传播求梯度

grads = tape.gradient(loss, model.trainable_variables)

# 执行梯度下降

model.optimizer.apply_gradients(zip(grads, model.trainable_variables))

# 计算评估指标

metric = model.accuracy(predictions,labels)

return loss, metric

train_loss_list1 = []

train_acc_list1 = []

def train_model(model,train_data,training_steps,display_step):

#for epoch in tf.range(1,epochs+1):

for step, (batch_x, batch_y) in enumerate(train_data.take(training_steps), 1):

starttime=time.time()

loss,metric = train_step(model,batch_x,batch_y)

if step % display_step == 0:

#printbar()

train_loss_list1.append(loss)

train_acc_list1.append(metric)

tf.print("step ={},loss = {:.4f},accuracy ={:.4f} ,times={:.4f}".format(step,loss,metric,(time.time() - starttime)))

train_model(model,train_data,training_steps,display_step)
运行结果
step =1000,loss = 1.3011,accuracy =0.5781 ,times=0.0000
step =2000,loss = 1.2720,accuracy =0.6094 ,times=0.0000
step =3000,loss = 1.2153,accuracy =0.5469 ,times=0.0000
step =4000,loss = 0.8636,accuracy =0.7500 ,times=0.0000
step =5000,loss = 0.7936,accuracy =0.7500 ,times=0.0000
step =6000,loss = 0.9527,accuracy =0.6875 ,times=0.0156
step =7000,loss = 0.9352,accuracy =0.7344 ,times=0.0000
step =8000,loss = 0.6892,accuracy =0.7969 ,times=0.0000
step =9000,loss = 0.7949,accuracy =0.7031 ,times=0.0000
step =10000,loss = 0.4768,accuracy =0.8438 ,times=0.0000
step =11000,loss = 0.7983,accuracy =0.7188 ,times=0.0000
step =12000,loss = 0.5601,accuracy =0.8281 ,times=0.0000
step =13000,loss = 0.7934,accuracy =0.7031 ,times=0.0000
step =14000,loss = 0.6450,accuracy =0.8438 ,times=0.0000
step =15000,loss = 0.5681,accuracy =0.7656 ,times=0.0000
step =16000,loss = 0.5413,accuracy =0.8125 ,times=0.0000
step =17000,loss = 0.3914,accuracy =0.8438 ,times=0.0000
step =18000,loss = 0.3687,accuracy =0.8906 ,times=0.0000
step =19000,loss = 0.4534,accuracy =0.8750 ,times=0.0000
step =20000,loss = 0.3855,accuracy =0.8438 ,times=0.0000

从运行结果来看，运行时间快了很多！

7.可视化运行结果

plt.title('the train and validate')
plt.xlabel('Times')
plt.ylabel('Loss value')
plt.plot(train_loss_list, color=(1, 0, 0), label='Loss train')
plt.plot(train_acc_list, color=(0, 0, 1), label='Accuracy train')
plt.legend(loc='best')
plt.show()

plt.title('the train and validate')

plt.xlabel('Times')

plt.ylabel('Loss value')

plt.plot(train_loss_list, color=(1, 0, 0), label='Loss train')

plt.plot(train_acc_list, color=(0, 0, 1), label='Accuracy train')

plt.legend(loc='best')

plt.show()

8.测试模型

test_total_batch = int(len(x_test) / batch_size)
test_acc_sum = 0.0
for i in range(test_total_batch):
    test_image_batch = x_test[i*batch_size:(i+1)*batch_size]
    test_label_batch = y_test[i*batch_size:(i+1)*batch_size]
    pred = conv_net(test_image_batch)
    test_batch_acc = accuracy(pred,test_label_batch)
    test_acc_sum += test_batch_acc
test_acc = float(test_acc_sum / test_total_batch)
print("Test accuracy:{:.6f}".format(test_acc))

test_total_batch = int(len(x_test) / batch_size)

test_acc_sum = 0.0

for i in range(test_total_batch):

test_image_batch = x_test[i*batch_size:(i+1)*batch_size]

test_label_batch = y_test[i*batch_size:(i+1)*batch_size]

pred = conv_net(test_image_batch)

test_batch_acc = accuracy(pred,test_label_batch)

test_acc_sum += test_batch_acc

test_acc = float(test_acc_sum / test_total_batch)

print("Test accuracy:{:.6f}".format(test_acc))

运行结果
Test accuracy:0.720653
性能也有一定提升！

1.导入CIFAR-10数据集

1.1 导入需要的库

import os
import math
import numpy as np
import pickle as p
import tensorflow as tf
import matplotlib.pyplot as plt
%matplotlib inline

import os

import math

import numpy as np

import pickle as p

import tensorflow as tf

import matplotlib.pyplot as plt

%matplotlib inline

1.2 定义批量导入数据的函数

def load_CIFAR_batch(filename):
    """ load single batch of cifar """  
    with open(filename, 'rb')as f:
        # 一个样本由标签和图像数据组成
        #  (3072=32x32x3)
        # ...
        # 
        data_dict = p.load(f, encoding='bytes')
        images= data_dict[b'data']
        labels = data_dict[b'labels']
                
        # 把原始数据结构调整为: BCWH
        images = images.reshape(10000, 3, 32, 32)
        # tensorflow处理图像数据的结构：BWHC
        # 把通道数据C移动到最后一个维度
        images = images.transpose (0,2,3,1)
     
        labels = np.array(labels)
        
        return images, labels

def load_CIFAR_batch(filename):

""" load single batch of cifar """

with open(filename, 'rb')as f:

# 一个样本由标签和图像数据组成

# (3072=32x32x3)

# ...

data_dict = p.load(f, encoding='bytes')

images= data_dict[b'data']

labels = data_dict[b'labels']

# 把原始数据结构调整为: BCWH

images = images.reshape(10000, 3, 32, 32)

# tensorflow处理图像数据的结构：BWHC

# 把通道数据C移动到最后一个维度

images = images.transpose (0,2,3,1)

labels = np.array(labels)

return images, labels

1.3 定义加载数据函数

def load_CIFAR_data(data_dir):
    """load CIFAR data"""
 
    images_train=[]
    labels_train=[]
    for i in range(5):
        f=os.path.join(data_dir,'data_batch_%d' % (i+1))
        print('loading ',f)
        # 调用 load_CIFAR_batch( )获得批量的图像及其对应的标签
        image_batch,label_batch=load_CIFAR_batch(f)
        images_train.append(image_batch)
        labels_train.append(label_batch)
        Xtrain=np.concatenate(images_train)
        Ytrain=np.concatenate(labels_train)
        del image_batch ,label_batch
    
    Xtest,Ytest=load_CIFAR_batch(os.path.join(data_dir,'test_batch'))
    print('finished loadding CIFAR-10 data')
    
    # 返回训练集的图像和标签，测试集的图像和标签
    return (Xtrain,Ytrain),(Xtest,Ytest)

def load_CIFAR_data(data_dir):

"""load CIFAR data"""

images_train=[]

labels_train=[]

for i in range(5):

f=os.path.join(data_dir,'data_batch_%d' % (i+1))

print('loading ',f)

# 调用 load_CIFAR_batch( )获得批量的图像及其对应的标签

image_batch,label_batch=load_CIFAR_batch(f)

images_train.append(image_batch)

labels_train.append(label_batch)

Xtrain=np.concatenate(images_train)

Ytrain=np.concatenate(labels_train)

del image_batch ,label_batch

Xtest,Ytest=load_CIFAR_batch(os.path.join(data_dir,'test_batch'))

print('finished loadding CIFAR-10 data')

# 返回训练集的图像和标签，测试集的图像和标签

return (Xtrain,Ytrain),(Xtest,Ytest)

1.4 加载数据

data_dir = r'data\cifar-10-batches-py'
(x_train,y_train),(x_test,y_test) = load_CIFAR_data(data_dir)

1 2	data_dir = r'data\cifar-10-batches-py' (x_train,y_train),(x_test,y_test) = load_CIFAR_data(data_dir)

1.5 可视化加载数据

label_dict = {0:"airplane", 1:"
automobile", 2:"bird", 3:"cat", 4:"deer",
              5:"dog", 6:"frog", 7:"horse", 8:"ship", 9:"truck"}


def plot_images_labels(images, labels, num):
    total = len(images)
    fig = plt.gcf()
    fig.set_size_inches(15, math.ceil(num / 10) * 7)
    for i in range(0, num):
        choose_n = np.random.randint(0, total)
        
        ax = plt.subplot(math.ceil(num / 5), 5, 1 + i)
        ax.imshow(images[choose_n], cmap='binary')
        title = label_dict[labels[choose_n]]
        ax.set_title(title, fontsize=10)        
    plt.show()
	
plot_images_labels(x_train, y_train, 10)

label_dict = {0:"airplane", 1:"

automobile", 2:"bird", 3:"cat", 4:"deer",

5:"dog", 6:"frog", 7:"horse", 8:"ship", 9:"truck"}

def plot_images_labels(images, labels, num):

total = len(images)

fig = plt.gcf()

fig.set_size_inches(15, math.ceil(num / 10) * 7)

for i in range(0, num):

choose_n = np.random.randint(0, total)

ax = plt.subplot(math.ceil(num / 5), 5, 1 + i)

ax.imshow(images[choose_n], cmap='binary')

title = label_dict[labels[choose_n]]

ax.set_title(title, fontsize=10)

plt.show()

plot_images_labels(x_train, y_train, 10)

运行结果

2 .数据预处理并设置超参数

x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

train_num = len(x_train)
num_classes = 10

learning_rate = 0.0002
batch_size = 64
training_steps = 20000
display_step = 1000

conv1_filters = 32
conv2_filters = 64
fc1_units = 256

x_train = x_train.astype('float32') / 255.0

x_test = x_test.astype('float32') / 255.0

train_num = len(x_train)

num_classes = 10

learning_rate = 0.0002

batch_size = 64

training_steps = 20000

display_step = 1000

conv1_filters = 32

conv2_filters = 64

fc1_units = 256

3.使用tf.data构建数据管道

AUTOTUNE = tf.data.experimental.AUTOTUNE
train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_data = train_data.shuffle(5000).repeat(training_steps).batch(batch_size).prefetch(buffer_size=AUTOTUNE)

AUTOTUNE = tf.data.experimental.AUTOTUNE

train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))

train_data = train_data.shuffle(5000).repeat(training_steps).batch(batch_size).prefetch(buffer_size=AUTOTUNE)

4.定义卷积层及池化层

def conv2d(x, W, b, strides=1):
    #tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, name=None)
    x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
    x = tf.nn.bias_add(x, b)
    return tf.nn.relu(x)


def maxpool2d(x, k=2):
    #tf.nn.max_pool(value, ksize, strides, padding, name=None) 
return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME')

def conv2d(x, W, b, strides=1):

#tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, name=None)

x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')

x = tf.nn.bias_add(x, b)

return tf.nn.relu(x)

def maxpool2d(x, k=2):

#tf.nn.max_pool(value, ksize, strides, padding, name=None)

return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME')

5.构建模型

class CNNModel(tf.Module):
    def __init__(self,name = None):
        super(CNNModel, self).__init__(name=name)
        self.w1 = tf.Variable(random_normal([3, 3, 3, conv1_filters]))#[k_width, k_height, input_chn, output_chn]
        self.b1 = tf.Variable(tf.zeros([conv1_filters]))
        #输入通道：32，输出通道：64，卷积后图像尺寸不变，依然是16x16
        self.w2 = tf.Variable(random_normal([3, 3, conv1_filters, conv2_filters]))
        self.b2 = tf.Variable(tf.zeros([conv2_filters]))
        #将池第2个池化层的64个8x8的图像转换为一维的向量，长度是 64*8*8=4096
        self.w3 = tf.Variable(random_normal([4096, fc1_units]))
        self.b3 = tf.Variable(tf.zeros([fc1_units]))
        self.wout = tf.Variable(random_normal([fc1_units, num_classes]))
        self.bout = tf.Variable(tf.zeros([num_classes]))

     
    # 正向传播    
    def __call__(self,x):
        conv1 = conv2d(x, self.w1, self.b1)
        pool1 = maxpool2d(conv1, k=2)  #将32x32图像缩小为16x16，池化不改变通道数量，因此依然是32个
        conv2 = conv2d(pool1, self.w2, self.b2)
        pool2 = maxpool2d(conv2, k=2)
        flat = tf.reshape(pool2, [-1, self.w3.get_shape().as_list()[0]])
        fc1 = tf.add(tf.matmul(flat, self.w3), self.b3)
        fc1 = tf.nn.relu(fc1)
        out = tf.add(tf.matmul(fc1, self.wout), self.bout)
    
        return tf.nn.softmax(out) 
    
    # 损失函数(二元交叉熵)
    #@tf.function(input_signature=[tf.TensorSpec(shape = [None,1], dtype = tf.float32),tf.TensorSpec(shape = [None,1], dtype = tf.float32)])  
    def cross_entropy(self,y_pred, y_true):
        y_pred = tf.clip_by_value(y_pred, 1e-9, 1.)
        loss_ = tf.keras.losses.sparse_categorical_crossentropy(y_true=y_true, y_pred=y_pred)
    
        return tf.reduce_mean(loss_)
    
    # 评估指标(准确率)    
    def accuracy(self,y_pred, y_true):
        correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.reshape(tf.cast(y_true, tf.int64), [-1]))
        return tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
   
    
model = CNNModel()
model.optimizer = tf.optimizers.Adam(learning_rate)

class CNNModel(tf.Module):

def __init__(self,name = None):

super(CNNModel, self).__init__(name=name)

self.w1 = tf.Variable(random_normal([3, 3, 3, conv1_filters]))#[k_width, k_height, input_chn, output_chn]

self.b1 = tf.Variable(tf.zeros([conv1_filters]))

#输入通道：32，输出通道：64，卷积后图像尺寸不变，依然是16x16

self.w2 = tf.Variable(random_normal([3, 3, conv1_filters, conv2_filters]))

self.b2 = tf.Variable(tf.zeros([conv2_filters]))

#将池第2个池化层的64个8x8的图像转换为一维的向量，长度是 64*8*8=4096

self.w3 = tf.Variable(random_normal([4096, fc1_units]))

self.b3 = tf.Variable(tf.zeros([fc1_units]))

self.wout = tf.Variable(random_normal([fc1_units, num_classes]))

self.bout = tf.Variable(tf.zeros([num_classes]))

# 正向传播

def __call__(self,x):

conv1 = conv2d(x, self.w1, self.b1)

pool1 = maxpool2d(conv1, k=2) #将32x32图像缩小为16x16，池化不改变通道数量，因此依然是32个

conv2 = conv2d(pool1, self.w2, self.b2)

pool2 = maxpool2d(conv2, k=2)

flat = tf.reshape(pool2, [-1, self.w3.get_shape().as_list()[0]])

fc1 = tf.add(tf.matmul(flat, self.w3), self.b3)

fc1 = tf.nn.relu(fc1)

out = tf.add(tf.matmul(fc1, self.wout), self.bout)

return tf.nn.softmax(out)

# 损失函数(二元交叉熵)

#@tf.function(input_signature=[tf.TensorSpec(shape = [None,1], dtype = tf.float32),tf.TensorSpec(shape = [None,1], dtype = tf.float32)])

def cross_entropy(self,y_pred, y_true):

y_pred = tf.clip_by_value(y_pred, 1e-9, 1.)

loss_ = tf.keras.losses.sparse_categorical_crossentropy(y_true=y_true, y_pred=y_pred)

return tf.reduce_mean(loss_)

# 评估指标(准确率)

def accuracy(self,y_pred, y_true):

correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.reshape(tf.cast(y_true, tf.int64), [-1]))

return tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

model = CNNModel()

model.optimizer = tf.optimizers.Adam(learning_rate)

6.定义训练模型函数

自定义训练过程：
（1）打开一个遍历各epoch的for循环
（2）对于每个epoch，打开一个分批遍历数据集的 for 循环
（3）对于每个批次，打开一个 GradientTape() 作用域
（4）在此作用域内，调用模型（前向传递）并计算损失
（5）在作用域之外，检索模型权重相对于损失的梯度
（6）根据梯度使用优化器来更新模型的权重
（7）评估模型指标

def train_step(model, features, labels):
    
    # 正向传播求损失
    with tf.GradientTape() as tape:
        predictions = model(features)
        loss = model.cross_entropy(predictions,labels) 
        
    # 反向传播求梯度
    grads = tape.gradient(loss, model.trainable_variables)
    
    # 执行梯度下降   
    model.optimizer.apply_gradients(zip(grads, model.trainable_variables))        
    # 计算评估指标
    metric = model.accuracy(predictions,labels)
    
    return loss, metric

train_loss_list1 = []
train_acc_list1 = []
def train_model(model,train_data,training_steps,display_step):
    #for epoch in tf.range(1,epochs+1): 
    for step, (batch_x, batch_y) in enumerate(train_data.take(training_steps), 1):
        starttime=time.time()
        loss,metric = train_step(model,batch_x,batch_y)
        
        if step % display_step == 0:
            #printbar()
            train_loss_list1.append(loss)
            train_acc_list1.append(metric)
            tf.print("step ={},loss = {:.4f},accuracy ={:.4f} ,times={:.4f}".format(step,loss,metric,(time.time() - starttime)))

def train_step(model, features, labels):

# 正向传播求损失

with tf.GradientTape() as tape:

predictions = model(features)

loss = model.cross_entropy(predictions,labels)

# 反向传播求梯度

grads = tape.gradient(loss, model.trainable_variables)

# 执行梯度下降

model.optimizer.apply_gradients(zip(grads, model.trainable_variables))

# 计算评估指标

metric = model.accuracy(predictions,labels)

return loss, metric

train_loss_list1 = []

train_acc_list1 = []

def train_model(model,train_data,training_steps,display_step):

#for epoch in tf.range(1,epochs+1):

for step, (batch_x, batch_y) in enumerate(train_data.take(training_steps), 1):

starttime=time.time()

loss,metric = train_step(model,batch_x,batch_y)

if step % display_step == 0:

#printbar()

train_loss_list1.append(loss)

train_acc_list1.append(metric)

tf.print("step ={},loss = {:.4f},accuracy ={:.4f} ,times={:.4f}".format(step,loss,metric,(time.time() - starttime)))

train_model(model,train_data,training_steps,display_step)
运行结果
step =1000,loss = 1.2807,accuracy =0.5781 ,times=0.0080
step =2000,loss = 1.1832,accuracy =0.6562 ,times=0.0080
step =3000,loss = 0.9727,accuracy =0.6562 ,times=0.0080
step =4000,loss = 1.0398,accuracy =0.6406 ,times=0.0050
step =5000,loss = 0.8615,accuracy =0.6406 ,times=0.0156
step =6000,loss = 0.7207,accuracy =0.7188 ,times=0.0000
step =7000,loss = 1.0945,accuracy =0.5938 ,times=0.0090
step =8000,loss = 0.7337,accuracy =0.7656 ,times=0.0080
step =9000,loss = 0.5792,accuracy =0.7812 ,times=0.0080
step =10000,loss = 0.7154,accuracy =0.7500 ,times=0.0080
step =11000,loss = 0.6398,accuracy =0.8125 ,times=0.0156
step =12000,loss = 0.6413,accuracy =0.7500 ,times=0.0080
step =13000,loss = 0.5555,accuracy =0.7812 ,times=0.0156
step =14000,loss = 0.6729,accuracy =0.8281 ,times=0.0156
step =15000,loss = 0.5163,accuracy =0.7500 ,times=0.0156
step =16000,loss = 0.5521,accuracy =0.7969 ,times=0.0000
step =17000,loss = 0.4475,accuracy =0.8594 ,times=0.0156
step =18000,loss = 0.3158,accuracy =0.8594 ,times=0.0080
step =19000,loss = 0.3829,accuracy =0.9062 ,times=0.0090
step =20000,loss = 0.2731,accuracy =0.9062 ,times=0.0080

7.可视化运行结果

plt.title('the train and validate')
plt.xlabel('Times')
plt.ylabel('Loss value')
plt.plot(train_loss_list, color=(1, 0, 0), label='Loss train')
plt.plot(train_acc_list, color=(0, 0, 1), label='Accuracy train')
plt.legend(loc='best')
plt.show()

plt.title('the train and validate')

plt.xlabel('Times')

plt.ylabel('Loss value')

plt.plot(train_loss_list, color=(1, 0, 0), label='Loss train')

plt.plot(train_acc_list, color=(0, 0, 1), label='Accuracy train')

plt.legend(loc='best')

plt.show()

8.测试型

test_total_batch = int(len(x_test) / batch_size)
test_acc_sum = 0.0
for i in range(test_total_batch):
    test_image_batch = x_test[i*batch_size:(i+1)*batch_size]
    test_label_batch = y_test[i*batch_size:(i+1)*batch_size]
    pred = conv_net(test_image_batch)
    test_batch_acc = accuracy(pred,test_label_batch)
    test_acc_sum += test_batch_acc
test_acc = float(test_acc_sum / test_total_batch)
print("Test accuracy:{:.6f}".format(test_acc))

test_total_batch = int(len(x_test) / batch_size)

test_acc_sum = 0.0

for i in range(test_total_batch):

test_image_batch = x_test[i*batch_size:(i+1)*batch_size]

test_label_batch = y_test[i*batch_size:(i+1)*batch_size]

pred = conv_net(test_image_batch)

test_batch_acc = accuracy(pred,test_label_batch)

test_acc_sum += test_batch_acc

test_acc = float(test_acc_sum / test_total_batch)

print("Test accuracy:{:.6f}".format(test_acc))

运行结果
Test accuracy:0.712640

1.导入CIFAR-10数据集

1.1 导入需要的库

import os
import math
import numpy as np
import pickle as p
import tensorflow as tf
import matplotlib.pyplot as plt
%matplotlib inline

import os

import math

import numpy as np

import pickle as p

import tensorflow as tf

import matplotlib.pyplot as plt

%matplotlib inline

1.2 定义批量导入数据的函数

def load_CIFAR_batch(filename):
    """ load single batch of cifar """  
    with open(filename, 'rb')as f:
        # 一个样本由标签和图像数据组成
        #  (3072=32x32x3)
        # ...
        # 
        data_dict = p.load(f, encoding='bytes')
        images= data_dict[b'data']
        labels = data_dict[b'labels']
                
        # 把原始数据结构调整为: BCWH
        images = images.reshape(10000, 3, 32, 32)
        # tensorflow处理图像数据的结构：BWHC
        # 把通道数据C移动到最后一个维度
        images = images.transpose (0,2,3,1)
     
        labels = np.array(labels)
        
        return images, labels

def load_CIFAR_batch(filename):

""" load single batch of cifar """

with open(filename, 'rb')as f:

# 一个样本由标签和图像数据组成

# (3072=32x32x3)

# ...

data_dict = p.load(f, encoding='bytes')

images= data_dict[b'data']

labels = data_dict[b'labels']

# 把原始数据结构调整为: BCWH

images = images.reshape(10000, 3, 32, 32)

# tensorflow处理图像数据的结构：BWHC

# 把通道数据C移动到最后一个维度

images = images.transpose (0,2,3,1)

labels = np.array(labels)

return images, labels

1.3 定义加载数据函数

def load_CIFAR_data(data_dir):
    """load CIFAR data"""
 
    images_train=[]
    labels_train=[]
    for i in range(5):
        f=os.path.join(data_dir,'data_batch_%d' % (i+1))
        print('loading ',f)
        # 调用 load_CIFAR_batch( )获得批量的图像及其对应的标签
        image_batch,label_batch=load_CIFAR_batch(f)
        images_train.append(image_batch)
        labels_train.append(label_batch)
        Xtrain=np.concatenate(images_train)
        Ytrain=np.concatenate(labels_train)
        del image_batch ,label_batch
    
    Xtest,Ytest=load_CIFAR_batch(os.path.join(data_dir,'test_batch'))
    print('finished loadding CIFAR-10 data')
    
    # 返回训练集的图像和标签，测试集的图像和标签
    return (Xtrain,Ytrain),(Xtest,Ytest)

def load_CIFAR_data(data_dir):

"""load CIFAR data"""

images_train=[]

labels_train=[]

for i in range(5):

f=os.path.join(data_dir,'data_batch_%d' % (i+1))

print('loading ',f)

# 调用 load_CIFAR_batch( )获得批量的图像及其对应的标签

image_batch,label_batch=load_CIFAR_batch(f)

images_train.append(image_batch)

labels_train.append(label_batch)

Xtrain=np.concatenate(images_train)

Ytrain=np.concatenate(labels_train)

del image_batch ,label_batch

Xtest,Ytest=load_CIFAR_batch(os.path.join(data_dir,'test_batch'))

print('finished loadding CIFAR-10 data')

# 返回训练集的图像和标签，测试集的图像和标签

return (Xtrain,Ytrain),(Xtest,Ytest)

1.4 加载数据

data_dir = r'data\cifar-10-batches-py'
(x_train,y_train),(x_test,y_test) = load_CIFAR_data(data_dir)

1 2	data_dir = r'data\cifar-10-batches-py' (x_train,y_train),(x_test,y_test) = load_CIFAR_data(data_dir)

1.5 可视化加载数据

label_dict = {0:"airplane", 1:"
automobile", 2:"bird", 3:"cat", 4:"deer",
              5:"dog", 6:"frog", 7:"horse", 8:"ship", 9:"truck"}


def plot_images_labels(images, labels, num):
    total = len(images)
    fig = plt.gcf()
    fig.set_size_inches(15, math.ceil(num / 10) * 7)
    for i in range(0, num):
        choose_n = np.random.randint(0, total)
        
        ax = plt.subplot(math.ceil(num / 5), 5, 1 + i)
        ax.imshow(images[choose_n], cmap='binary')
        title = label_dict[labels[choose_n]]
        ax.set_title(title, fontsize=10)        
    plt.show()
	
plot_images_labels(x_train, y_train, 10)

label_dict = {0:"airplane", 1:"

automobile", 2:"bird", 3:"cat", 4:"deer",

5:"dog", 6:"frog", 7:"horse", 8:"ship", 9:"truck"}

def plot_images_labels(images, labels, num):

total = len(images)

fig = plt.gcf()

fig.set_size_inches(15, math.ceil(num / 10) * 7)

for i in range(0, num):

choose_n = np.random.randint(0, total)

ax = plt.subplot(math.ceil(num / 5), 5, 1 + i)

ax.imshow(images[choose_n], cmap='binary')

title = label_dict[labels[choose_n]]

ax.set_title(title, fontsize=10)

plt.show()

plot_images_labels(x_train, y_train, 10)

运行结果

2 .数据预处理并设置超参数

x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0

train_num = len(x_train)
num_classes = 10

learning_rate = 0.0002
batch_size = 64
training_steps = 20000
display_step = 1000

conv1_filters = 32
conv2_filters = 64
fc1_units = 256

x_train = x_train.astype('float32') / 255.0

x_test = x_test.astype('float32') / 255.0

train_num = len(x_train)

num_classes = 10

learning_rate = 0.0002

batch_size = 64

training_steps = 20000

display_step = 1000

conv1_filters = 32

conv2_filters = 64

fc1_units = 256

3.使用tf,data构建数据管道

AUTOTUNE = tf.data.experimental.AUTOTUNE
train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_data = train_data.shuffle(5000).repeat(training_steps).batch(batch_size).prefetch(buffer_size=AUTOTUNE)

AUTOTUNE = tf.data.experimental.AUTOTUNE

train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))

train_data = train_data.shuffle(5000).repeat(training_steps).batch(batch_size).prefetch(buffer_size=AUTOTUNE)

4.定义卷积层及池化层

def conv2d(x, W, b, strides=1):
    #tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, name=None)
    x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')
    x = tf.nn.bias_add(x, b)
    return tf.nn.relu(x)


def maxpool2d(x, k=2):
    #tf.nn.max_pool(value, ksize, strides, padding, name=None) 
return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME')

def conv2d(x, W, b, strides=1):

#tf.nn.conv2d(input, filter, strides, padding, use_cudnn_on_gpu=None, name=None)

x = tf.nn.conv2d(x, W, strides=[1, strides, strides, 1], padding='SAME')

x = tf.nn.bias_add(x, b)

return tf.nn.relu(x)

def maxpool2d(x, k=2):

#tf.nn.max_pool(value, ksize, strides, padding, name=None)

return tf.nn.max_pool(x, ksize=[1, k, k, 1], strides=[1, k, k, 1], padding='SAME')

5.定义并初始化权重参数

random_normal = tf.initializers.RandomNormal()

weights = { 
    'wc1': tf.Variable(random_normal([3, 3, 3, conv1_filters])),#[k_width, k_height, input_chn, output_chn]
    'wc2': tf.Variable(random_normal([3, 3, conv1_filters, conv2_filters])),#输入通道：32，输出通道：64，卷积后图像尺寸不变，依然是16x16
    'wd1': tf.Variable(random_normal([4096, fc1_units])),#将池第2个池化层的64个8x8的图像转换为一维的向量，长度是 64*8*8=4096
    'out': tf.Variable(random_normal([fc1_units, num_classes]))
}

biases = {
    'bc1': tf.Variable(tf.zeros([conv1_filters])),
    'bc2': tf.Variable(tf.zeros([conv2_filters])),
    'bd1': tf.Variable(tf.zeros([fc1_units])),
    'out': tf.Variable(tf.zeros([num_classes]))
}

random_normal = tf.initializers.RandomNormal()

weights = {

'wc1': tf.Variable(random_normal([3, 3, 3, conv1_filters])),#[k_width, k_height, input_chn, output_chn]

'wc2': tf.Variable(random_normal([3, 3, conv1_filters, conv2_filters])),#输入通道：32，输出通道：64，卷积后图像尺寸不变，依然是16x16

'wd1': tf.Variable(random_normal([4096, fc1_units])),#将池第2个池化层的64个8x8的图像转换为一维的向量，长度是 64*8*8=4096

'out': tf.Variable(random_normal([fc1_units, num_classes]))

}

biases = {

'bc1': tf.Variable(tf.zeros([conv1_filters])),

'bc2': tf.Variable(tf.zeros([conv2_filters])),

'bd1': tf.Variable(tf.zeros([fc1_units])),

'out': tf.Variable(tf.zeros([num_classes]))

}

6.构建模型

def conv_net(x):
    x = tf.reshape(x, [-1, 32, 32, 3])## 32x32图像，通道为3（RGB）
    conv1 = conv2d(x, weights['wc1'], biases['bc1'])
    pool1 = maxpool2d(conv1, k=2)  #将32x32图像缩小为16x16，池化不改变通道数量，因此依然是32个
    conv2 = conv2d(pool1, weights['wc2'], biases['bc2'])
    pool2 = maxpool2d(conv2, k=2)
    flat = tf.reshape(pool2, [-1, weights['wd1'].get_shape().as_list()[0]])
    fc1 = tf.add(tf.matmul(flat, weights['wd1']), biases['bd1'])
    fc1 = tf.nn.relu(fc1)
    out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])
    
    return tf.nn.softmax(out)

def conv_net(x):

x = tf.reshape(x, [-1, 32, 32, 3])## 32x32图像，通道为3（RGB）

conv1 = conv2d(x, weights['wc1'], biases['bc1'])

pool1 = maxpool2d(conv1, k=2) #将32x32图像缩小为16x16，池化不改变通道数量，因此依然是32个

conv2 = conv2d(pool1, weights['wc2'], biases['bc2'])

pool2 = maxpool2d(conv2, k=2)

flat = tf.reshape(pool2, [-1, weights['wd1'].get_shape().as_list()[0]])

fc1 = tf.add(tf.matmul(flat, weights['wd1']), biases['bd1'])

fc1 = tf.nn.relu(fc1)

out = tf.add(tf.matmul(fc1, weights['out']), biases['out'])

return tf.nn.softmax(out)

7.定义损失函数、评估函数

def cross_entropy(y_pred, y_true):
    y_pred = tf.clip_by_value(y_pred, 1e-9, 1.)
    loss_ = tf.keras.losses.sparse_categorical_crossentropy(y_true=y_true, y_pred=y_pred)
    
    return tf.reduce_mean(loss_)


def accuracy(y_pred, y_true):
    correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.reshape(tf.cast(y_true, tf.int64), [-1]))

    return tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

optimizer = tf.optimizers.Adam(learning_rate)

def cross_entropy(y_pred, y_true):

y_pred = tf.clip_by_value(y_pred, 1e-9, 1.)

loss_ = tf.keras.losses.sparse_categorical_crossentropy(y_true=y_true, y_pred=y_pred)

return tf.reduce_mean(loss_)

def accuracy(y_pred, y_true):

correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.reshape(tf.cast(y_true, tf.int64), [-1]))

return tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

optimizer = tf.optimizers.Adam(learning_rate)

8.定义梯度计算函数

自定义梯度计算过程：
（1）打开一个 GradientTape() 作用域
（2）在此作用域内，调用模型（正向传播）并计算损失
（3）在作用域之外，检索模型权重相对于损失的梯度
（4）根据梯度使用优化器来更新模型的权重
（5）利用优化器进行反向传播（更新梯度）

[{"metadata":{"trusted":false},"cell_type":"code","source":"def run_optimization(x, y):\n    with tf.GradientTape() as g:\n        pred = conv_net(x)\n        loss = cross_entropy(pred, y)\n        \n    trainable_variables = list(weights.values()) + list(biases.values())\n    gradients = g.gradient(loss, trainable_variables)\n    optimizer.apply_gradients(zip(gradients, trainable_variables))\n","execution_count":13,"outputs":[]}]

[{"metadata":{"trusted":false},"cell_type":"code","source":"def run_optimization(x, y):\n with tf.GradientTape() as g:\n pred = conv_net(x)\n loss = cross_entropy(pred, y)\n \n trainable_variables = list(weights.values()) + list(biases.values())\n gradients = g.gradient(loss, trainable_variables)\n optimizer.apply_gradients(zip(gradients, trainable_variables))\n","execution_count":13,"outputs":[]}]

9.训练模型

train_loss_list = []
train_acc_list = []

for step, (batch_x, batch_y) in enumerate(train_data.take(training_steps), 1):
    run_optimization(batch_x, batch_y)
    
    if step % display_step == 0:
        pred = conv_net(batch_x)
        loss = cross_entropy(pred, batch_y)
        acc = accuracy(pred, batch_y)
        train_loss_list.append(loss)
        train_acc_list.append(acc)
        print("step: %i, loss: %f, accuracy: %f" % (step, loss, acc))

train_loss_list = []

train_acc_list = []

for step, (batch_x, batch_y) in enumerate(train_data.take(training_steps), 1):

run_optimization(batch_x, batch_y)

if step % display_step == 0:

pred = conv_net(batch_x)

loss = cross_entropy(pred, batch_y)

acc = accuracy(pred, batch_y)

train_loss_list.append(loss)

train_acc_list.append(acc)

print("step: %i, loss: %f, accuracy: %f" % (step, loss, acc))

10.可视化运行结果

plt.title('the train and validate')
plt.xlabel('Times')
plt.ylabel('Loss value')
plt.plot(train_loss_list, color=(1, 0, 0), label='Loss train')
plt.plot(train_acc_list, color=(0, 0, 1), label='Accuracy train')
plt.legend(loc='best')
plt.show()

plt.title('the train and validate')

plt.xlabel('Times')

plt.ylabel('Loss value')

plt.plot(train_loss_list, color=(1, 0, 0), label='Loss train')

plt.plot(train_acc_list, color=(0, 0, 1), label='Accuracy train')

plt.legend(loc='best')

plt.show()

运行结果

11.测试模型

test_total_batch = int(len(x_test) / batch_size)
test_acc_sum = 0.0
for i in range(test_total_batch):
    test_image_batch = x_test[i*batch_size:(i+1)*batch_size]
    test_label_batch = y_test[i*batch_size:(i+1)*batch_size]
    pred = conv_net(test_image_batch)
    test_batch_acc = accuracy(pred,test_label_batch)
    test_acc_sum += test_batch_acc
test_acc = float(test_acc_sum / test_total_batch)
print("Test accuracy:{:.6f}".format(test_acc))

test_total_batch = int(len(x_test) / batch_size)

test_acc_sum = 0.0

for i in range(test_total_batch):

test_image_batch = x_test[i*batch_size:(i+1)*batch_size]

test_label_batch = y_test[i*batch_size:(i+1)*batch_size]

pred = conv_net(test_image_batch)

test_batch_acc = accuracy(pred,test_label_batch)

test_acc_sum += test_batch_acc

test_acc = float(test_acc_sum / test_total_batch)

print("Test accuracy:{:.6f}".format(test_acc))

运行结果
Test accuracy:0.704327

一、纯手工

定制化程度高，非常灵活，如自定义层、损失函数、优化器、性能评估、训练模型方法等，但编程难度较高。
下载所有实例使用数据（提取码为：fg29）

具体实例

二、继承tf.Module

定制化程度高，如自定义层、损失函数、优化器、性能评估、训练模型方法等，且可以使用保存或恢复模型。
具体实例

三、继承tf.Module且使用AutoGraph

定制化程度高，如自定层、损失函数、优化器、性能评估、训练模型方法等，且可以使用保存或恢复模型。通过使用Autograph可达到静态图的性能，极大提升训练模型效率。不过使用Autograph时要注意对应的编码规范，如被@tf,function装饰的函数尽可能tensorflow函数，如tf.print,tf.range等（控制语句无此限制），避免在被@tf,function装饰的函数内部定义tf.Variabe等。
具体实例

四、网络层和模型使用子类方法构建

用子类方法构建网络层、网络模型是tensorflow2才有的，这种风格类似于PyTorch构建方法。TensorFlow1构建网络一般使用Sequential按层顺序构建模型，使用函数式API构建任意结构模型。当然，这两种方法在TensorFlow2也是常用方法。构建网络层时继承
tf.keras.layers.Layer，构建网络模型继承tf.keras.Model，然后使用compile编辑模型，用fit训练模型。这样构建的网络既有一定的灵活性，又不失简洁性。
具体实例

五、使用tf,keras的Sequential模型按层顺序构建模型

最简洁，构建模型很简单，可是直接使用内置的层、损失函数、优化器、评估指标等，训练也可直接使用函数fit即可。Keras 提供了称为tf.keras.Model 的全功能模型类。它继承自 tf.keras.layers.Layer，使用SaveModel保存模型，可以非常方便移植到其他非Python环境（具体环境可参考下图）。构建这个模型相对较简单，有兴趣的朋友作为练习。