2021年 – Python技术交流与分享

TensorFlow2 构建模型-境界3

有三种计算图的构建方式：静态计算图，动态计算图，以及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数据集

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.定义卷积层及池化层

@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
性能也有一定提升！

Tensorflow2构建模型-境界2

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

TensorFlow2构建模型-境界1

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

TensorFlow2构建模型的五个境界

一、纯手工

定制化程度高，非常灵活，如自定义层、损失函数、优化器、性能评估、训练模型方法等，但编程难度较高。
具体实例

二、继承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环境（具体环境可参考下图）。

构建机器学习的一般步骤（基于TensorFlow2）

如何有效使用tf.data(基于TensorFlow2)？

1.机器学习一般流程

机器学习、深度学习的一般流程：
（1）分析业务需求
（2）确定数据源
（3）构建数据处理管道（pipeline）
（4）构建模型
（5）训练模型
（6）评估、优化模型
其中构建数据处理管道，在整个过程中，从时间上来说往往占60%左右，面对大数据其挑战更大。如何解决质量问题？如何解决内存瓶颈问题？如何解决处理效率问题等等。
接下来我们重点介绍如何使用TensorFlow2提供的tf.data工具有效构建数据流。

2.为何要构建数据管道？

使用tf.data API，我们可以使用简单的代码来构建复杂的输入 pipeline。
实现从从内存读取数据、从分布式文件系统中读取数据、进行预处理、合成为 batch、训练中使用数据集等。使用 tf.data API 可以轻松处理大量数据、不同的数据格式以及复杂的转换。
如果数据比较小，我们可以一次性处理后直接加入内存就可以了；但如果数据比较大，而且在数据训练过程中还需要一些动态的处理方法，如分批处理、添加数据增强方法、数据采样等等，此时，通过构建一个数据流就显得非常必要。
数据流可有效提高我们管理数据得效率，此外还可以帮助我们解耦数据的预处理和数据执行的过程，能够帮我们更高效的应用硬件资源，例如当分布式训练的时候，一个好的数据流能够帮我们高效的分发数据到不同的硬件上，从而提高整体的训练效率。
一个合理的数据流，能够让你模型训练更加的高效。数据流的本质就是 ETL。一般来说，数据流由三部分组成，具体如下：
（1）抽取、初始化源数据 (E:即Extract)
（2）添加各种预处理过程 (T: 即Transform)
（3）遍历数据流，把大数据导入模型、训练数据等 (L:Load)
在 Tensorflow2里，我们使用 tf.data 来构建数据管道。

3.tf.data简介

tf.data是TensorFlow提供的构建数据管道的一个工具，与PyTorch的utils.data类似，使用tf.data构建数据集（Dataset），构建和管理数据管道非常方便，它提供了很多操作，如：
shuffle、repeat、map、batch、padded_batch、prefetch等等，这些操作功能很实用，但使用的顺序是有讲究的，如果次序不当，将严重影响数据流的效率和质量，这些操作的顺利大致为：
（1）map->shuffle -> repeat -> map(parse) -> batch -> prefetch ；
（2）有些 map 操作放在 batch 前，有些 map 操作放在 batch 后；
（3）尽量把进行数据过滤和采样放数据流的前面，以提高后续处理效率；
（4）使用 AUTOTUNE 来设置并行执行的数量，不要去手动调节；
（5）使用 cache / interleave / prefetch 这些空间换时间的操作。

为便于更好理解这些操作，通过以下示例进行具体说明。

3.1 生成数据集

这里以手工创建一个非常简单的数据集，该数据包含10个样本，每个样本对应一个标签。

import numpy as np
import tensorflow as tf

data = np.array([0.1, 0.4, 0.6, 0.2, 0.8, 0.8, 0.4, 0.9, 0.3, 0.2])
#其中大于0.5的样本为正样本，即标签记为1，否则为0
label = np.array([0, 0, 1, 0, 1, 1, 0, 1, 0, 0])
#可以通过tf.data.Dataset.from_tensor_slices建立数据集
dataset = tf.data.Dataset.from_tensor_slices((data, label))

for x,y in dataset:
print("[{},{}]".format(x.numpy(),y.numpy()))

import numpy as np

import tensorflow as tf

data = np.array([0.1, 0.4, 0.6, 0.2, 0.8, 0.8, 0.4, 0.9, 0.3, 0.2])

#其中大于0.5的样本为正样本，即标签记为1，否则为0

label = np.array([0, 0, 1, 0, 1, 1, 0, 1, 0, 0])

#可以通过tf.data.Dataset.from_tensor_slices建立数据集

dataset = tf.data.Dataset.from_tensor_slices((data, label))

for x,y in dataset:

print("[{},{}]".format(x.numpy(),y.numpy()))

运行结果：
[0.1,0]
[0.4,0]
[0.6,1]
[0.2,0]
[0.8,1]
[0.8,1]
[0.4,0]
[0.9,1]
[0.3,0]
[0.2,0]

3.2 map

map对dataset中每个元素做出来，这里每个元素为[x,y],函数为one-hot
该函数把标签转换为one-hot编码。
介绍map()这一核心函数。该函数的输入参数map_func应为一个函数，在该函数中实现我们需要的对数据的变换。
具体应用场景如图片加载、数据增强、标签one hot化等。下面以one hot化和添加噪声为例具体说明。
one hot化的函数实现如下

def one_hot(x, y):
    if y == 0:
        return x, np.array([1, 0])
    else:
        return x, np.array([0, 1])

dataset = dataset.map(one_hot)
for x,y in dataset_one_hot:
print("[{},{}]".format(x.numpy(),y.numpy()))

def one_hot(x, y):

if y == 0:

return x, np.array([1, 0])

else:

return x, np.array([0, 1])

dataset = dataset.map(one_hot)

for x,y in dataset_one_hot:

print("[{},{}]".format(x.numpy(),y.numpy()))

运行结果
[0.1,[1 0]]
[0.4,[1 0]]
[0.6,[0 1]]
[0.2,[1 0]]
[0.8,[0 1]]
[0.8,[0 1]]
[0.4,[1 0]]
[0.9,[0 1]]
[0.3,[1 0]]
[0.2,[1 0]]

3.3 shuffle

shuffle()是随机打乱样本次序，参数buffer_size建议设为样本数量，过大会浪费内存空间，过小会导致打乱不充分。

dataset1 = dataset.shuffle(buffer_size=10)
for x,y in dataset1:
print("[{},{}]".format(x.numpy(),y.numpy()))

dataset1 = dataset.shuffle(buffer_size=10)

for x,y in dataset1:

print("[{},{}]".format(x.numpy(),y.numpy()))

运行结果
[0.6,[0 1]]
[0.2,[1 0]]
[0.3,[1 0]]
[0.8,[0 1]]
[0.4,[1 0]]
[0.8,[0 1]]
[0.2,[1 0]]
[0.4,[1 0]]
[0.1,[1 0]]
[0.9,[0 1]]

3.4 repeat

使用repeat方法，repeat的功能就是将整个序列或数据集重复多次，完成整个数据集的一次训练是一个epoch，使用repeat(5)就可以将之变成5个epoch 如果直接调用repeat()的话，生成的序列就会无限重复下去，没有结束，因此也不会抛出tf.errors.OutOfRangeError异常。

dataset_repeat = dataset1.repeat(2)
for x,y in dataset_repeat:
print("[{},{}]".format(x.numpy(),y.numpy()))

dataset_repeat = dataset1.repeat(2)

for x,y in dataset_repeat:

print("[{},{}]".format(x.numpy(),y.numpy()))

运行结果
[0.8,[0 1]]
[0.8,[0 1]]
[0.1,[1 0]]
[0.9,[0 1]]
[0.2,[1 0]]
[0.2,[1 0]]
[0.4,[1 0]]
[0.3,[1 0]]
[0.6,[0 1]]
[0.4,[1 0]]
[0.4,[1 0]]
[0.2,[1 0]]
[0.4,[1 0]]
[0.3,[1 0]]
[0.8,[0 1]]
[0.2,[1 0]]
[0.8,[0 1]]
[0.9,[0 1]]
[0.6,[0 1]]
[0.1,[1 0]]

3.5 batch

batch()是使数据集一次获取多个样本

# batch()是使迭代器一次获取多个样本
dataset_batch =dataset_repeat.batch(batch_size=4)  
for x,y in dataset_batch:
print("[{},{}]".format(x.numpy(),y.numpy()))

# batch()是使迭代器一次获取多个样本

dataset_batch =dataset_repeat.batch(batch_size=4)

for x,y in dataset_batch:

print("[{},{}]".format(x.numpy(),y.numpy()))

运行结果
[[0.4 0.3 0.6 0.2],[[1 0]
[1 0]
[0 1]
[1 0]]]
[[0.4 0.2 0.8 0.9],[[1 0]
[1 0]
[0 1]
[0 1]]]
[[0.8 0.1 0.6 0.9],[[0 1]
[1 0]
[0 1]
[0 1]]]
[[0.2 0.2 0.4 0.1],[[1 0]
[1 0]
[1 0]
[1 0]]]
[[0.3 0.8 0.8 0.4],[[1 0]
[0 1]
[0 1]
[1 0]]]

3.6map

map()函数，该函数的输入参数map_func应为一个函数，在该函数中实现我们需要的对数据的变换。具体应用场景如图片加载、数据增强、标签one hot化等。
对数据进行固定形式上的变化，可将函数直接作为参数输入。但是，包含随机信息的数据变化则需要tf.py_function辅助实现，
如数据增强中数据添加随机噪声、图像的随机翻转都属于包含随机信息。

def add_noise(x, y):
    x += np.random.normal(0.0, 1.0)
    return x, y
dataset_add_noise = dataset.map(lambda x, y: tf.py_function(add_noise, inp=[x, y], Tout=[tf.float64, tf.int32]))
for x,y in dataset_add_noise:
print("[{},{}]".format(x.numpy(),y.numpy()))

def add_noise(x, y):

x += np.random.normal(0.0, 1.0)

return x, y

dataset_add_noise = dataset.map(lambda x, y: tf.py_function(add_noise, inp=[x, y], Tout=[tf.float64, tf.int32]))

for x,y in dataset_add_noise:

print("[{},{}]".format(x.numpy(),y.numpy()))

运行结果
[[1.5635917 1.6635917 2.2635917 2.0635917],[[1 0]
[1 0]
[0 1]
[0 1]]]
[[1.29330552 0.89330552 1.39330552 0.79330552],[[0 1]
[1 0]
[0 1]
[1 0]]]
[[-0.04628853 -0.24628853 -0.04628853 -0.24628853],[[1 0]
[1 0]
[1 0]
[1 0]]]
[[-0.46844772 -0.96844772 -1.16844772 -0.66844772],[[0 1]
[1 0]
[1 0]
[0 1]]]
[[0.40181042 0.20181042 0.80181042 0.90181042],[[1 0]
[1 0]
[0 1]
[0 1]]]
在map()函数中，还有个很重要的参数num_parallel_calls，可以将数据加载与变换过程并行到多个CPU线程上。由于python语言本身的全局解释锁，想要实现真正的并行计算是非常困难的，所以这个参数实际上非常实用，通常的使用情景是网络训练时，GPU做模型运算的同时CPU加载数据。还可以直接设置num_parallel_calls=tf.data.experimental.AUTOTUNE，这样会自动设置为最大的可用线程数，可充分利用机器算资源。

AUTOTUNE = tf.data.experimental.AUTOTUNE
dataset_add_noise1 = dataset.map(lambda x, y: tf.py_function(add_noise, inp=[x, y], Tout=[tf.float64, tf.int32]),num_parallel_calls=AUTOTUNE)

1 2	AUTOTUNE = tf.data.experimental.AUTOTUNE dataset_add_noise1 = dataset.map(lambda x, y: tf.py_function(add_noise, inp=[x, y], Tout=[tf.float64, tf.int32]),num_parallel_calls=AUTOTUNE)

3.7 prefetch

prefetch(buffer_size)创建一个Dataset，从源数据集中预提取元素的，注意：examples.prefetch(2) 将预取2个元素（2个示例），
而examples.batch(20).prefetch(2) 将预取2个元素（2个批次，每个20个示例），buffer_size 表示预取时将缓冲的最大元素数，返回 Dataset。
使用prefetch可有效使用读取数据与模型处理之间松耦合。如下图所示

从上图可以看出，使用prefetch函数之后，读取数据与训练数据就可并发处理了，这就大大提升数据处理效率。

4.tf.data读取输入数据

tf.data的架构如下图所示：

从上图可知，Dataset是一个基类，这个类可实例化成迭代器（Iterator），

4.1 Dataset类

Dataset类下有多个子类，常见的有TextLineDataset、tf.data.FixedLengthRecordDataset、TFRecordDataset等，可用使用这些Dateset的子类获取数据，此外，Dataset还有很多方法，如from_tensor_slices、list_files、map、batch、repeat等等，Dataset的这些方法或子类通常用来读取或处理数据，当使用场景有些不同，tf.data常见的读取数据方式有以下几种：
（1）直接从内存中读取（如NumPy数据），tf.data.Dataset.from_tensor_slices()
（2）使用一个 python 生成器 (generator) 初始化，从生成器中读取数据可以使用
tf.data.Dataset.from_generator（）
（3）从 TFrecords格式文件读取数据，可使用tf.data.TFRecordDataset()
（4）读取文本数据，可使用tf.data.TextLineDataset（）
（5）从二进制文件读取数据，可用tf.data.FixedLengthRecordDataset（）
（6）读取cvs数据，可使用tf.data.experimental.make_csv_dataset（）
（7）从文件集中读取数据，可使用tf.data.Dataset.list_files（）

4.2对象Iterator

Iterator是Dataset中迭代方法的实例化，主要对数据进行访问，包括四种迭代方法，单次、可初始化、可重新初始化、可馈送等，可实现对数据集中元素的快速迭代，供模型训练使用。

TensorFlow2 如何构建自己的数据集？

1.背景说明

我们平时在网上、书上看到的有关深度学习的案例大多使用处理好、教规格的数据集，如MNIST, CIFAR10/100等数据集，这些数据集一般无需（或很少）做预处理，就看导入到模型中使用。但是很多情况下需要处理自己的数据集，这些数据集往往不规范，而且一般比较大。如何把自己的数据集转换成这些TensorFlow框架能够使用的数据形式至关重要，接下来将对TensorFlow2中官方推荐数据格式及预处理方法进行说明，小数据集处理方法很多，处理也比较方便，这里就不展开来说。这里主要介绍大中数据集，对大中数据集TensorFlow建议转换为TFRecord格式，使用TFRecord格式有哪些优势呢？

2.TFRecord的优势

正常情况下我们用于训练的文件夹内部往往会存着成千上万的图片或文本等文件，这些文件通常被散列存放。这种存储方式有一些缺点：
（1）占用磁盘空间；
（2）在一个个读取的时候会非常耗时；
（3）占用大量内存空间（有的大型数据不足以一次性加载）。
此时 TFRecord 格式的文件存储形式会很合理的帮我们存储数据。TFRecord 内部使用了 “Protocol Buffer” 二进制数据编码方案，它只占用一个内存块，只需要一次性加载一个二进制文件的方式即可，简单，快速，尤其对大型训练数据很友好。而且当我们的训练数据量比较大的时候，可以将数据分成多个 TFRecord 文件，来提高处理效率。

3.使用TFRecord的一般步骤

3.1 Exmple含义

freocrd的核心是其包含一系列的example，每个example可以认为是一条样本。example是tensorflow中的对象类型，用法是tf.train.example。
Example含义：如下图，假设有样本 (example)：（x，y）：输入x 和输出y一起叫做样本。这里每个x是六维向量，每个y是一维向量。
（1）表征 (representation)：x集合了代表个人的全部特征。
其中特征 (feature)： x 中的某个维：如学历，年龄，职业。是某人的一个特点。
（2）标签 (label)：y为输出。

对上表的数据的存储，通常我们把输入特征x与标签y分开进行保存。假设有100个样本，把所有输入存储在100x6的numpy矩阵中，把标签存储在100x1的向量中。
Example协议块格式：

message Example {
  Features features = 1;
};

message Features {
  map<string, Feature> feature = 1;
};

message Feature {
  one of kind {
    BytesList bytes_list = 1;
    FloatList float_list = 2;
    Int64List int64_list = 3;
  }
};

message Example {

Features features = 1;

};

message Features {

map<string, Feature> feature = 1;

};

message Feature {

one of kind {

BytesList bytes_list = 1;

FloatList float_list = 2;

Int64List int64_list = 3;

}

};

以TFRecord方式存储，输入和标签将以字典方式存放在一起，具体格式请参考下图。

3.2 TFRecord文件数据格式

3.3 加载TFRecord文件流程

TFRecord做好了，可以通过tf.data来生成一个迭代器，每次调用都返回一个大小为batch_size的batch。读取TFRecord可以通过tensorflow两个个重要的函数实现如下图所示，分别是读取器（Reader）: tf.data.TFRecordDataset和解码器（Decoder）:tf.io.parse_single_example解析器。如下图：

4.代码实例

整个过程为：
（1）先把源数据（可以是文本、图像、音频、Embedding等，这里是小猫、小狗图片）导入内存（如NumPy）
（2）把内存数据转换为TFRecord格式数据
（3）读取TFRecord数据
（4）构建模型
（5）训练模型

4.1 导入数据

导入模块及数据，这里是windows环境，如果是linux环境，请修改路径格式。
数据集下载

import tensorflow as tf
import os

data_dir = r"C:\Users\wumg\jupyter-ipynb\data\cat-dog"
train_cat_dir = data_dir + '\\train\\cats\\'
train_dog_dir = data_dir + "\\train\\dogs\\"
train_tfrecord_file = data_dir + r"\train\train.tfrecords"

test_cat_dir = data_dir + "\\test\\cats\\"
test_dog_dir = data_dir + "\\test\\dogs\\"
test_tfrecord_file = data_dir + r"\test\test.tfrecords"

train_cat_filenames = [train_cat_dir + filename for filename in os.listdir(train_cat_dir)]
train_dog_filenames = [train_dog_dir + filename for filename in os.listdir(train_dog_dir)]
train_filenames = train_cat_filenames + train_dog_filenames
train_labels = [0]*len(train_cat_filenames) + [1]*len(train_dog_filenames)

test_cat_filenames = [test_cat_dir + filename for filename in os.listdir(test_cat_dir)]
test_dog_filenames = [test_dog_dir + filename for filename in os.listdir(test_dog_dir)]
test_filenames = test_cat_filenames + test_dog_filenames
test_labels = [0]*len(test_cat_filenames) + [1]*len(test_dog_filenames)

import tensorflow as tf

import os

data_dir = r"C:\Users\wumg\jupyter-ipynb\data\cat-dog"

train_cat_dir = data_dir + '\\train\\cats\\'

train_dog_dir = data_dir + "\\train\\dogs\\"

train_tfrecord_file = data_dir + r"\train\train.tfrecords"

test_cat_dir = data_dir + "\\test\\cats\\"

test_dog_dir = data_dir + "\\test\\dogs\\"

test_tfrecord_file = data_dir + r"\test\test.tfrecords"

train_cat_filenames = [train_cat_dir + filename for filename in os.listdir(train_cat_dir)]

train_dog_filenames = [train_dog_dir + filename for filename in os.listdir(train_dog_dir)]

train_filenames = train_cat_filenames + train_dog_filenames

train_labels = [0]*len(train_cat_filenames) + [1]*len(train_dog_filenames)

test_cat_filenames = [test_cat_dir + filename for filename in os.listdir(test_cat_dir)]

test_dog_filenames = [test_dog_dir + filename for filename in os.listdir(test_dog_dir)]

test_filenames = test_cat_filenames + test_dog_filenames

test_labels = [0]*len(test_cat_filenames) + [1]*len(test_dog_filenames)

4.2 把数据转换为TFRecord格式

def encoder(filenames, labels, tfrecord_file):
    with tf.io.TFRecordWriter(tfrecord_file) as writer:
        for filename, label in zip(filenames, labels):
            image = open(filename, 'rb').read()

            # 建立feature字典，这里特征image，label都以向量方式存储
            feature = {
                'image': tf.train.Feature(bytes_list=tf.train.BytesList(value=[image])),
                'label': tf.train.Feature(int64_list=tf.train.Int64List(value=[label]))
            }

            # 通过字典创建example，example对象对label和image数据进行封装
            example = tf.train.Example(features=tf.train.Features(feature=feature))
            # 将example序列化并写入字典
            writer.write(example.SerializeToString())

encoder(train_filenames, train_labels, train_tfrecord_file)
encoder(test_filenames, test_labels, test_tfrecord_file)

def encoder(filenames, labels, tfrecord_file):

with tf.io.TFRecordWriter(tfrecord_file) as writer:

for filename, label in zip(filenames, labels):

image = open(filename, 'rb').read()

# 建立feature字典，这里特征image，label都以向量方式存储

feature = {

'image': tf.train.Feature(bytes_list=tf.train.BytesList(value=[image])),

'label': tf.train.Feature(int64_list=tf.train.Int64List(value=[label]))

}

# 通过字典创建example，example对象对label和image数据进行封装

example = tf.train.Example(features=tf.train.Features(feature=feature))

# 将example序列化并写入字典

writer.write(example.SerializeToString())

encoder(train_filenames, train_labels, train_tfrecord_file)

encoder(test_filenames, test_labels, test_tfrecord_file)

构建example的时候，这个tf.train.Feature()函数可以接收三种数据：
• bytes_list: 可以存储string 和byte两种数据类型。
• float_list: 可以存储float(float32)与double(float64) 两种数据类型。
• int64_list: 可以存储：bool, enum, int32, uint32, int64, uint64。
对于只有一个值（比如label）可以用float_list或int64_list，而像图片、视频、embedding这种列表型的数据，通常转化为bytes格式储存

4.3 从TFRecord读取数据

这里使用 tf.data.TFRecordDataset 类来读取 TFRecord 文件
使用 TFRecordDataset 对于标准化输入数据和优化性能十分有用。可以使用tf.io.parse_single_example函数对每个样本进行解析（tf.io.parse_example对批量样本进行解析）。请注意，这里的 feature_description 是必需的，因为数据集使用计算图执行，并且需要这些描述来构建它们的形状和类型签名。
使用 tf.data.Dataset.map 方法可将函数应用于 Dataset 的每个元素。

def decoder(tfrecord_file, is_train_dataset=None):
    #构建dataset
    dataset = tf.data.TFRecordDataset(tfrecord_file)
    #说明特征的描述属性，为解吗每个example使用
    feature_discription = {
        'image': tf.io.FixedLenFeature([], tf.string),
        'label': tf.io.FixedLenFeature([], tf.int64)
    }

    def _parse_example(example_string): # 解码每一个example
        #将文件读入到队列中
        feature_dic = tf.io.parse_single_example(example_string, feature_discription)
        feature_dic['image'] = tf.io.decode_jpeg(feature_dic['image'])
        #对图片进行resize
        feature_dic['image'] = tf.image.resize(feature_dic['image'], [256, 256])/255.0
        #tf.image.random_flip_up_down(image).shape        
        return feature_dic['image'], feature_dic['label']

    batch_size = 4

    if is_train_dataset is not None:
        #tf.data.experimental.AUTOTUNE#根据计算机性能进行运算速度的调整
        dataset = dataset.map(_parse_example).shuffle(buffer_size=2000).batch(batch_size).prefetch(tf.data.experimental.AUTOTUNE)
    else:
        dataset = dataset.map(_parse_example)
        dataset = dataset.batch(batch_size)

    return dataset

train_data = decoder(train_tfrecord_file, 1)
test_data = decoder(test_tfrecord_file)

def decoder(tfrecord_file, is_train_dataset=None):

#构建dataset

dataset = tf.data.TFRecordDataset(tfrecord_file)

#说明特征的描述属性，为解吗每个example使用

feature_discription = {

'image': tf.io.FixedLenFeature([], tf.string),

'label': tf.io.FixedLenFeature([], tf.int64)

}

def _parse_example(example_string): # 解码每一个example

#将文件读入到队列中

feature_dic = tf.io.parse_single_example(example_string, feature_discription)

feature_dic['image'] = tf.io.decode_jpeg(feature_dic['image'])

#对图片进行resize

feature_dic['image'] = tf.image.resize(feature_dic['image'], [256, 256])/255.0

#tf.image.random_flip_up_down(image).shape

return feature_dic['image'], feature_dic['label']

batch_size = 4

if is_train_dataset is not None:

#tf.data.experimental.AUTOTUNE#根据计算机性能进行运算速度的调整

dataset = dataset.map(_parse_example).shuffle(buffer_size=2000).batch(batch_size).prefetch(tf.data.experimental.AUTOTUNE)

else:

dataset = dataset.map(_parse_example)

dataset = dataset.batch(batch_size)

return dataset

train_data = decoder(train_tfrecord_file, 1)

test_data = decoder(test_tfrecord_file)

显示图片

import matplotlib.pyplot as plt 
%matplotlib inline
#查看dataset中样本的具体信息
i=1
for image,lable in train_data:
    plt.subplot(1,2,i)
    plt.imshow(image[0].numpy())
    i+=1
    if i==3:
        break
plt.show()

import matplotlib.pyplot as plt

%matplotlib inline

#查看dataset中样本的具体信息

i=1

for image,lable in train_data:

plt.subplot(1,2,i)

plt.imshow(image[0].numpy())

i+=1

if i==3:

break

plt.show()

4.4 构建模型

模型由两层卷积和两层全连接层构成。

class CNNModel(tf.keras.models.Model):
    def __init__(self):
        super(CNNModel, self).__init__()

        self.conv1 = tf.keras.layers.Conv2D(12, 3, activation='relu')
        self.maxpool1 = tf.keras.layers.MaxPooling2D()
        self.conv2 = tf.keras.layers.Conv2D(12, 5, activation='relu')
        self.maxpool2 = tf.keras.layers.MaxPooling2D()
        self.flatten = tf.keras.layers.Flatten()
        self.d1 = tf.keras.layers.Dense(64, activation='relu')
        self.d2 = tf.keras.layers.Dense(2, activation='softmax')

    def call(self, inputs):
        x = self.conv1(inputs)
        x = self.maxpool1(x)
        x = self.conv2(x)
        x = self.maxpool2(x)
        x = self.flatten(x)
        x = self.d1(x)
        x = self.d2(x)
        return x

class CNNModel(tf.keras.models.Model):

def __init__(self):

super(CNNModel, self).__init__()

self.conv1 = tf.keras.layers.Conv2D(12, 3, activation='relu')

self.maxpool1 = tf.keras.layers.MaxPooling2D()

self.conv2 = tf.keras.layers.Conv2D(12, 5, activation='relu')

self.maxpool2 = tf.keras.layers.MaxPooling2D()

self.flatten = tf.keras.layers.Flatten()

self.d1 = tf.keras.layers.Dense(64, activation='relu')

self.d2 = tf.keras.layers.Dense(2, activation='softmax')

def call(self, inputs):

x = self.conv1(inputs)

x = self.maxpool1(x)

x = self.conv2(x)

x = self.maxpool2(x)

x = self.flatten(x)

x = self.d1(x)

x = self.d2(x)

return x

4.5 训练模型

训练模型使用@tf.function装饰器将普通Python函数转换成对应的TensorFlow计算图构建代码。使用tf.GradientTape实现自动求导，使用TensorFlow2 autograph机制，该机制可以把动态图转换成静态图加速。

def train_CNNModel():
    model = CNNModel()
    loss_obj = tf.keras.losses.SparseCategoricalCrossentropy()
    optimizer = tf.keras.optimizers.Adam(0.001)

    train_acc = tf.keras.metrics.SparseCategoricalAccuracy(name='train_acc')
    test_acc = tf.keras.metrics.SparseCategoricalAccuracy(name='test_acc')

    @tf.function
    def train_step(images, labels):
        with tf.GradientTape() as tape:
            logits = model(images)
            loss = loss_obj(labels, logits)
        grads = tape.gradient(loss, model.trainable_variables)
        optimizer.apply_gradients(zip(grads, model.trainable_variables))

        train_acc(labels, logits)

    @tf.function
    def test_step(images, labels):
        logits = model(images)
        test_acc(labels, logits)

    Epochs =10
    for epoch in range(Epochs):
        train_acc.reset_states()
        test_acc.reset_states()

        for images, labels in train_data:
            train_step(images, labels)            

        for images, labels in test_data:
            test_step(images, labels)
            

        tmp = 'Epoch {}, Acc {}, Test Acc {}'
        print(tmp.format(epoch + 1,
                         train_acc.result() * 100,
                         test_acc.result() * 100))

train_CNNModel()

def train_CNNModel():

model = CNNModel()

loss_obj = tf.keras.losses.SparseCategoricalCrossentropy()

optimizer = tf.keras.optimizers.Adam(0.001)

train_acc = tf.keras.metrics.SparseCategoricalAccuracy(name='train_acc')

test_acc = tf.keras.metrics.SparseCategoricalAccuracy(name='test_acc')

@tf.function

def train_step(images, labels):

with tf.GradientTape() as tape:

logits = model(images)

loss = loss_obj(labels, logits)

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

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

train_acc(labels, logits)

@tf.function

def test_step(images, labels):

logits = model(images)

test_acc(labels, logits)

Epochs =10

for epoch in range(Epochs):

train_acc.reset_states()

test_acc.reset_states()

for images, labels in train_data:

train_step(images, labels)

for images, labels in test_data:

test_step(images, labels)

tmp = 'Epoch {}, Acc {}, Test Acc {}'

print(tmp.format(epoch + 1,

train_acc.result() * 100,

test_acc.result() * 100))

train_CNNModel()

运行结果：
Epoch 1, Acc 50.98039627075195, Test Acc 57.5
Epoch 2, Acc 68.13725280761719, Test Acc 52.499996185302734
Epoch 3, Acc 80.39215850830078, Test Acc 47.5
Epoch 4, Acc 91.66667175292969, Test Acc 57.5
Epoch 5, Acc 93.13725280761719, Test Acc 57.5
Epoch 6, Acc 97.54901885986328, Test Acc 52.499996185302734
Epoch 7, Acc 100.0, Test Acc 52.499996185302734
Epoch 8, Acc 100.0, Test Acc 50.0
Epoch 9, Acc 100.0, Test Acc 50.0
Epoch 10, Acc 100.0, Test Acc 52.499996185302734
有兴趣的读者可以从以下几方面提升性能
5.利用数据增强方法提升性能
6.利用现代经典网络提升性能
7.利用数据迁移方法提升性能
8.结合Transformer技术提升性能