深度学习 | Tensorflow2.0使用心得

Tensorflow2.0使用心得

---

Keras

    Tensorflow2推荐使用keras构建网络，常见的神经网络都包含在keras.layer中

    Keras 是一个用于构建和训练深度学习模型的高阶 API。它可用于快速设计原型、高级研究和生产。

    keras的3个优点： 方便用户使用、模块化和可组合、易于扩展

import tensorflow as tf
from tensorflow.keras import layers
print(tf.version)
print(tf.keras.version)

一、Dataset加载数据

Tensorflow2推荐使用Dataset加入数据。数据的格式为：numpy.ndarray

1.0 设定超参数

# MNIST数据集
num_classes = 10 # 0到9总共10个数字
num_features = 784 # 28*28

# 设定训练超参数
learning_rate = 0.1 # 学习率
training_steps = 2000 # 迭代步数
batch_size = 256 # 一批数据的大小
display_step = 100 # 展示间隔步数

# 神经网络超参数
n_hidden_1 = 128 # 第1层神经网络隐层的神经元个数
n_hidden_2 = 256 # 第2层神经网络隐层的神经元个数

1.1 从csv读取

csv文件，笔者个人建议先利用pandas进行特征工程的创建，然后再将pandas.DataFrame中的数据以values的形式提取出来，导入到Tensorflow中的Dataset。

注意，输入数据不能为字符串类型，否则会报错，如果是文本类的输入，需要做LabelEncoder，One-hot，或Embedding处理。

import tensorflow as tf
import pandas as pd
import numpy as np
from tensorflow.keras import Model, layers

#train, test Dataset
file_train_path = r'./mnist_train.csv'
file_test_path = r'./mnist_test.csv'

# Pandas读取csv
df_train = pd.read_csv(file_train_path)
df_test = pd.read_csv(file_test_path)

# Pandas提取特征与标签，并转为ndarray
x_train = df_train.drop(columns = ['5']).values
y_train = df_train['5'].values
x_test = df_test.drop(columns = ['7']).values
y_test = df_test['7'].values

x_train, x_test = x_train/255.0, x_test/255.0 

# 将ndarray数据导入Dataset
train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_data = train_data.repeat().shuffle(5000).batch(batch_size).prefetch(1)

1.2 从npz读取

部分数据集会将数据以npz的形式存储，这是numpy保存的数据格式，加载后的数据均为ndarray格式，使用方法如下：

import tensorflow as tf
import numpy as np
from tensorflow.keras import Model, layers
# 加载npz数据集
mnist_np = np.load(r'./mnist.npz')

# 创建训练集，测试集
(x_train,y_train),(y_test,y_test) = (mnist_np['x_train'],mnist_np['y_train']),(mnist_np['x_test'],mnist_np['y_test'])
#执行完这一步，建议查看一下数据的shape
x_train, x_test = x_train.reshape([-1, num_features]), x_test.reshape([-1, num_features])
# 把[0, 255]范围的像素输入幅度缩放到[0, 1].
x_train, x_test = x_train / 255., x_test / 255.

# 将ndarray数据导入Dataset
train_data = tf.data.Dataset.from_tensor_slices((x_train, y_train))
train_data = train_data.repeat().shuffle(5000).batch(batch_size).prefetch(1)

二、搭建网络结构

# 构建TF网络模型类
class NeuralNet(Model):
    # 设定层次
    def __init__(self):
        super(NeuralNet, self).__init__() #super表继承
        # 第1个全连接层，相当于添加一个层
        self.fc1 = layers.Dense(n_hidden_1, activation=tf.nn.relu) #n_hidden_1 = 128 # 第1层神经网络隐层的神经元个数
        # 第2个全连接层，相当于添加一个层
        self.fc2 = layers.Dense(n_hidden_2, activation=tf.nn.relu) #n_hidden_2 = 256 # 第2层神经网络隐层的神经元个数
        # 输出层
        self.out = layers.Dense(num_classes)

    # 前向传播，调用call方法
    def call(self, x, is_training=False):
        x = self.fc1(x) #input: x
        x = self.fc2(x) 
        x = self.out(x)
        if not is_training:
            # 训练阶段要计算交叉熵的函数需要，拿到softmax归一化之前得分
            x = tf.nn.softmax(x)
        return x

# 构建神经网络
neural_net = NeuralNet()

三、损失函数与评估构建

3.1 损失函数

分类问题中，常用交叉熵作为损失函数。

# 交叉熵损失
def cross_entropy_loss(x, y):
    # 把label转成int64类型
    y = tf.cast(y, tf.int64) #或者用y = np.array(y, np.int64)
    # 应用sparse_softmax_cross_entropy_with_logits对未归一化之前的得分计算交叉熵
    loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y, logits=x)
    # 求一个batch数据上的平均loss
    return tf.reduce_mean(loss)

关于交叉熵损失函数，主要具备两种形态：

• tf.nn.sparse_softmax_cross_entropy_with_logits
• tf.nn.softmax_cross_entropy_with_logits

    sparse_softmax_cross_entropy_with_logits中 labels接受直接的数字标签
如[1], [2], [3], [4] （类型只能为int32，int64），

    而softmax_cross_entropy_with_logits中的label只能接收One-hot后的标签，如[1,0,0,0], [0,1,0,0],[0,0,1,0], [0,0,0,1] （类型为int32， int64）

    相当于sparse_softmax_cross_entropy_with_logits 对标签多做一个one-hot动作
详情可见此链接
https://blog.csdn.net/yxq5997/article/details/83033843

3.2 评估函数

# 准确率
def accuracy(y_pred, y_true):
    # tf.argmax(y_pred, 1)把每一行的最大元素的索引记录下来
    correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.cast(y_true, tf.int64))
    return tf.reduce_mean(tf.cast(correct_prediction, tf.float32), axis=-1)

四、优化函数构建

4.1 构建优化器

优化器常使用随机梯度下降

# 设定优化器为随机梯度下降
optimizer = tf.keras.optimizers.SGD(learning_rate)

4.2 优化函数构建

def run_optimization(x, y):
    # tf 2.0的写法，把prediction和loss都写到GradientTape中，以便自动微分
    with tf.GradientTape() as g:
        # 前向传播(正向传播)
        pred = neural_net(x, is_training=True)
        # 计算损失
        loss = cross_entropy_loss(pred, y)
        
    # 需要更新的变量
    trainable_variables = neural_net.trainable_variables

    # 计算梯度
    gradients = g.gradient(loss, trainable_variables)
    
    # 基于梯度更新W和b
    optimizer.apply_gradients(zip(gradients, trainable_variables))

五、开始迭代

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 = neural_net(batch_x, is_training=True)
        loss = cross_entropy_loss(pred, batch_y)
        acc = accuracy(pred, batch_y)
        print("step: %i, loss: %f, accuracy: %f" % (step, loss, acc))

六、评估结果

pred = neural_net(x_test, is_training=False)
print("Test Accuracy: %f" % accuracy(pred, y_test))