我的TensorFlow-GPU 2.0升级之路

我这次TensorFlow的升级之路，可以用一句话来概括：“山重水复疑无路，柳暗花明又一村”

1.1环境分析

1、目标：升级到TensorFlow-GPU 2.0

2、原有环境:

Python3.6，TensorFlow-GPU 1.6，ubuntu16.04，GPU驱动为NVIDIA-SMI 387.26

3、“硬核”：

①如果要升级到TensorFlow-gpu 2.0,cuda 应该是10.+，而10.+，根据表1-1可知，GPU的Driver Version应该>=410+,但我目前的Driver Version 387.26。

②TensorFlow支持Python3.7

4、在安装TensorFlow-gpu 2.0之前需要做的事情

①升级GPU Driver Version>=410（最关键）

②安装Python3.7

③安装cuda 10

④安装TensorFlow-gpu 2.0

1.2参考资料

sudo dpkg --get-selections |grep linux-image

②查看当前使用的内核

uname -r

③删除内核方法

sudo apt-get remove linux-image-***-generic

1.3 安装的准备工作

1.4 升级GPU驱动

Ubuntu 社区建立了一个命名为 Graphics Drivers PPA 的全新 PPA，专门为 Ubuntu 用户提供最新版本的各种驱动程序，如Nvidia 驱动。因此我采用通过 PPA 为 Ubuntu 安装 Nvidia 驱动程序，即使用PPA仓库进行自动化安装。

1、卸载系统里的Nvidia低版本显卡驱动

sudo apt-get purge nvidia*

2、把显卡驱动加入PPA

sudo add-apt-repository ppa:graphics-drivers

3、更新apt-get

sudo apt-get update

4、查找显卡驱动最新的版本号

sudo apt-get update

返回如下信息

5、采用apt-get命令在终端安装GPU驱动

sudo apt-get install nvidia-418 nvidia-settings nvidia-prime

6、重启系统并验证

（1）重启系统

sudo reboot

（2）查看安装情况

在终端输入以下命令行

lsmod | grep nvidia

lsmod | grep nvidia

1.5安装Python3.7

1、安装python3.7

因TensorFlow-GPU 2.0支持python3.7，故需删除python3.6，安装python3.7

（1）使用rm -rf 命令删除目录：anaconda3

rm -rf anaconda3

bash Anaconda3-2019.10-Linux-x86_64.sh

安装过程中，会有几个问题，一般回答yes即可：

第一个问题：

Do you accept the license terms? [yes|no]

选择yes

第二个问题：

Anaconda3 will now be installed into this location:

~/anaconda3

1.6安装TensorFlow-GPU 2.0

如果使用conda安装TensorFlow-gpu 2.0，可用一个命令搞定，如果用pip安装需要3步。

1.6.1 用conda安装

使用conda安装tensorflow-gpu时，它会自动下载依赖项，比如最重要的cuda和cudnn等，其中cuda将自动安装10版本。

①先查看能安装的TensorFlow包

conda search tensorflw

②安装TensorFlow-GPU 2.0

conda install tensorflow-gpu=2.0.0

1.6.2用pip安装

①先安装cudatoolkit

pip install cudatoolkit==10.0

②安装cudnn

pip install cudnn

③安装TensorFlow-gpu 2.0

pip install tensorflow-gpu==2.0.0

【说明】

①如果使用conda环境(如果只有一个Python版本，也可不使用conda环境)，创建环境时，采用conda create -n tf2 python=3.7，而不是之前版本的source create *。激活环境也是用conda activate tf2 。

②如果卸载需先卸载cudnn，然后再卸载cudatoolkit

1.7 Jupyter notebook的配置

可参考《Python深度学习基于TensorFlow》的8.3小节。

1.8 安装验证

1.9 TensorFlow一般方式处理实例

1.9、1.10小节，都基于以MNIST数据集，数据预处理相同，模型也相同。1.9节采用keras的一般模型训练方法，1.10节采用分布式处理方法，比较两种方式的处理逻辑、性能及所用时间等指标。

1.9.1导入需要的库

import os
import sys
import time
import tensorflow as tf
from matplotlib import pyplot as plt
%matplotlib inline
 
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten
from tensorflow.keras.layers import Conv2D, MaxPooling2D

1.9.2导入数据

#在Keras地自带数据集中导入所需的MNIST模块
from tensorflow.keras.datasets import mnist
#加载数据到Keras
(x_train, y_train), (x_test, y_test) = mnist.load_data()

1.9.3数据预处理

（1）转换为4维数组

x_train = x_train.reshape(60000, 28, 28, 1)
x_test = x_test.reshape(10000, 28, 28, 1)

（2）获取通道信息

# 定义输入图像数据的行列信息
img_rows, img_cols = 28, 28
 
#导入backend模块，使用函数image_data_format()获取通道位置信息
from tensorflow.keras import backend as K
if K.image_data_format() == 'channels_first':
    x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
    x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
    input_shape = (1, img_rows, img_cols)
else:
    x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
    x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
    input_shape = (img_rows, img_cols, 1)

（3）对数据进行缩放

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

（4）把标签数据转换为二值数据格式或one-hot格式

# 使用keras自带工具将标签数据转换成二值数据格式，以方便模型训练
import tensorflow.keras.utils as utils
y_train =utils.to_categorical(y_train, 10)
y_test = utils.to_categorical(y_test, 10)

1.9.4构建模型

model = Sequential()#初始化序贯模型
model.add(Conv2D(32, kernel_size=(3, 3),
                 activation='relu',
                 input_shape=(28,28,1)))#二维卷积层
model.add(MaxPooling2D(pool_size=(2, 2)))#最大池化层
model.add(Conv2D(64, (3, 3), activation='relu'))#二维卷积层
model.add(MaxPooling2D(pool_size=(2, 2)))#最大池化层
model.add(Flatten())#Flatten层，把tensor转换成一维形式
model.add(Dense(64, activation='relu'))#定义全连接层
model.add(Dense(10, activation='softmax'))#定义输出层
model.summary()#查看模型结构

1.9.5编译模型

import tensorflow.keras as keras
model.compile(loss=keras.losses.categorical_crossentropy,
              #optimizer=keras.optimizers.Adadelta(),
              optimizer=keras.optimizers.Adam(),
              metrics=['accuracy'])

1.9.6训练模型

model.fit(x_train, y_train,
          batch_size=128,
          epochs=12,
          verbose=1,
          validation_data=(x_test, y_test))

运行结果如下。

Epoch 9/12

60000/60000 [==============================] – 5s 81us/sample – loss: 0.0133 – accuracy: 0.9958 – val_loss: 0.0259 – val_accuracy: 0.9915

Epoch 10/12

60000/60000 [==============================] – 5s 79us/sample – loss: 0.0101 – accuracy: 0.9969 – val_loss: 0.0264 – val_accuracy: 0.9916

Epoch 11/12

60000/60000 [==============================] – 5s 81us/sample – loss: 0.0083 – accuracy: 0.9973 – val_loss: 0.0338 – val_accuracy: 0.9892

Epoch 12/12

60000/60000 [==============================] – 5s 80us/sample – loss: 0.0082 – accuracy: 0.9973 – val_loss: 0.0308 – val_accuracy: 0.9910

1.9.7 GPU的使用情况

一般情况下，实际上只有一个GPU在使用，另一个几乎没有运行。

1.10 TensorFlow分布式处理实例

1.10.1概述

TensorFlow 2.0 开始支持更优的多 GPU 与分布式训练。Tensorflow的分布策略目前主要有四个Strategy：

 MirroredStrategy

 CentralStorageStrategy

 MultiWorkerMirroredStrategy

 ParameterServerStrategy

这里主要介绍第1种策略，即镜像策略（MirroredStrategy）。TensorFlow 2.0 在多 GPU 训练上是否更好了呢？是的，镜像策略用于单机多卡数据并行同步更新的情况，在每个GPU上保存一份模型副本，模型中的每个变量都镜像在所有副本中。这些变量一起形成一个名为MirroredVariable的概念变量。通过apply相同的更新，这些变量保持彼此同步。

镜像策略用了高效的All-reduce算法来实现设备之间变量的传递更新。默认情况下，它使用NVIDIA NCCL作为all-reduce实现。用户还可以在官方提供的其他几个选项之间进行选择。如图1-3所示。

图1-3 TensorFlow使用多GPU示意图

（1）假设你的机器上有2个GPU。

（2）在单机单GPU的训练中，数据是一个batch一个batch的训练。 在单机多GPU中，数据一次处理2个batch(假设是2个GPU训练）， 每个GPU处理一个batch的数据计算。

（3）变量，或者说参数，保存在CPU上。

（4）刚开始的时候数据由CPU分发给2个GPU， 在GPU上完成了计算，得到每个batch要更新的梯度。

（5）然后在CPU上收集完了2个GPU上的要更新的梯度， 计算一下平均梯度，然后更新参数。

（6）然后继续循环这个过程。

1.10.2创建一个分发变量和图形的镜像策略

strategy = tf.distribute.MirroredStrategy()
print ('Number of devices: {}'.format(strategy.num_replicas_in_sync))
#训练脚本就会自动进行分布式训练。如果你只想用主机上的部分GPU训练
#strategy = tf.distribute.MirroredStrategy(devices=["/gpu:0", "/gpu:1"])

1.10.3定义批处理等变量

BUFFER_SIZE = len(x_train)
BATCH_SIZE_PER_REPLICA = 64
GLOBAL_BATCH_SIZE = BATCH_SIZE_PER_REPLICA * strategy.num_replicas_in_sync
EPOCHS = 12

1.10.4创建数据集并进行分发

train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train)).shuffle(BUFFER_SIZE).batch(GLOBAL_BATCH_SIZE) 
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test)).batch(GLOBAL_BATCH_SIZE) 
 
train_dist_dataset = strategy.experimental_distribute_dataset(train_dataset)
test_dist_dataset = strategy.experimental_distribute_dataset(test_dataset)

1.10.5创建模型

def create_model():
  model = tf.keras.Sequential([
      tf.keras.layers.Conv2D(32, 3, activation='relu',input_shape=(28,28,1)),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Conv2D(64, 3, activation='relu'),
      tf.keras.layers.MaxPooling2D(),
      tf.keras.layers.Flatten(),
      tf.keras.layers.Dense(64, activation='relu'),
      tf.keras.layers.Dense(10, activation='softmax')
    ])
 
  return model

1.10.6创建存储检查点

# 创建检查点目录以存储检查点。
checkpoint_dir = './training_checkpoints'
checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt")

1.10.7定义损失函数

with strategy.scope():
  # 将减少设置为“无”，以便我们可以在之后进行这个减少并除以全局批量大小。
  loss_object = tf.keras.losses.CategoricalCrossentropy(
      reduction=tf.keras.losses.Reduction.NONE)
  # 或者使用 loss_fn = tf.keras.losses.sparse_categorical_crossentropy
  def compute_loss(labels, predictions):
    per_example_loss = loss_object(labels, predictions)
    return tf.nn.compute_average_loss(per_example_loss, global_batch_size=GLOBAL_BATCH_SIZE)

1.10.8定义性能衡量指标

如损失和准确性

ith strategy.scope():
  test_loss = tf.keras.metrics.Mean(name='test_loss')
 
  #train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
  train_accuracy = tf.keras.metrics.CategoricalAccuracy(
      name='train_accuracy')
  #test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
  test_accuracy = tf.keras.metrics.CategoricalAccuracy(
      name='test_accuracy')

1.10.9训练模型

（1）定义优化器、计算损失值

# 必须在`strategy.scope`下创建模型和优化器。
with strategy.scope():
  model = create_model()
 
  optimizer = tf.keras.optimizers.Adam()
 
  checkpoint = tf.train.Checkpoint(optimizer=optimizer, model=model)
with strategy.scope():
  def train_step(inputs):
    images, labels = inputs
 
    with tf.GradientTape() as tape:
      predictions = model(images, training=True)
      loss = compute_loss(labels, predictions)
 
    gradients = tape.gradient(loss, model.trainable_variables)
    optimizer.apply_gradients(zip(gradients, model.trainable_variables))
 
    train_accuracy.update_state(labels, predictions)
    return loss 
 
  def test_step(inputs):
    images, labels = inputs
 
    predictions = model(images, training=False)
    t_loss = loss_object(labels, predictions)
 
    test_loss.update_state(t_loss)
    test_accuracy.update_state(labels, predictions)

（2）训练模型

with strategy.scope():
  # `experimental_run_v2`将复制提供的计算并使用分布式输入运行它。
  @tf.function
  def distributed_train_step(dataset_inputs):
    per_replica_losses = strategy.experimental_run_v2(train_step,
                                                      args=(dataset_inputs,))
    return strategy.reduce(tf.distribute.ReduceOp.SUM, per_replica_losses,
                           axis=None)
 
  @tf.function
  def distributed_test_step(dataset_inputs):
    return strategy.experimental_run_v2(test_step, args=(dataset_inputs,))
 
  for epoch in range(EPOCHS):
    # 训练循环
    total_loss = 0.0
    num_batches = 0
    for x in train_dist_dataset:
      total_loss += distributed_train_step(x)
      num_batches += 1
    train_loss = total_loss / num_batches
 
    # 测试循环
    for x in test_dist_dataset:
      distributed_test_step(x)
 
    if epoch % 2 == 0:
      checkpoint.save(checkpoint_prefix)
 
    template = ("Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, "
                "Test Accuracy: {}")
    print (template.format(epoch+1, train_loss,
                           train_accuracy.result()*100, test_loss.result(),
                           test_accuracy.result()*100))

运行结果如下。

Epoch 9, Loss: 1.0668369213817641e-05, Accuracy: 99.91753387451172, Test Loss: 0.041710007935762405, Test Accuracy: 99.09666442871094

Epoch 10, Loss: 0.006528814323246479, Accuracy: 99.90166473388672, Test Loss: 0.04140192270278931, Test Accuracy: 99.10091400146484

Epoch 11, Loss: 0.001252010464668274, Accuracy: 99.90159606933594, Test Loss: 0.04158545285463333, Test Accuracy: 99.10043334960938

Epoch 12, Loss: 0.0014430719893425703, Accuracy: 99.90159606933594, Test Loss: 0.041613057255744934, Test Accuracy: 99.09874725341797

1.10.10 GPU使用情况

由此可知，采用分布式方式，两个GPU都得到充分使用。

1.11 建议使用conda安装TensorFlow

https://zhuanlan.zhihu.com/p/46599887

使用 TensorFlow 开展机器学习工作的朋友，应该有不少是通过 pip 下载的 TensorFlow。但是近日机器学习专家 Michael Nguyen 大声疾呼：“为了性能起见，别再用 pip 下载 TensorFlow了！”，他强力建议的理由基于以下两点：

1、更快的CPU性能Conda TensorFlow 包利用了用于深度神经网络或 1.9.0 版本以上的 MKL-DNN 网络的英特尔 Math Kernel Library（MKL），这个库能让性能大幅提升。如下图所示：

可以看到，相比 pip 安装，使用 Conda 安装后的性能足足提升了 8 倍。这对于仍然经常使用 CPU 训练的人来说，无疑帮助很大。我（Michael Nguyen——译者注）自己平时在把代码放到 GPU 驱动的机器之前，会先使用 CPU 机器跑一遍，使用 Conda 安装 TensorFlow 能大幅加快迭代速度。

MKL 库不仅能加快 TensorFlow 包的运行速度，也能提升其它一些广泛使用的程序库的速度，比如 Numpy、NumpyExr、Scikit-Learn。

2、简化 GPU 版的安装

Conda 安装会自动安装 CUDA 和 GPU 支持所需的 CuDNN 库，但 pip 安装需要你手动完成。大家都比较喜欢一步到位的吧，特别是下载很多个库的时候。

【说明】有些软件或版本使用conda安装可能找不到，这时需要使用pip安装，使用pip可以安装一些较新版本。

1.12 安装PyTorch

conda install pytorch torchvision cpuonly -c pytorch

1.13 修改安装源

我们用pip或conda安装软件时，很慢甚至时常报连接失败等问题，出现这些情况，一般是下载的源是国外的网站。可以修改安装源来大大加速下载速度及其稳定性，以下介绍几种利用清华源的方法。

1、修改conda安装源

在用户当前目录下，创建.condarc文件，然后把以下内容放入该文件即可。

channels:
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/pytorch/
  - defaults
show_channel_urls: true

【说明】windows环境也是如此，如果没有.condarc文件，就创建。

2、修改pip安装源

为了和conda保持一致，选择还是清华的镜像源。步骤如下：

（1）修改 ~/.pip/pip.conf 文件。

vi ~/.pip/pip.conf

【说明】如果是windows环境，在用户当前目录下，修改pip\pip.ini文件

没有就创建。

（2）添加源

[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple
[install]
trusted-host = pypi.tuna.tsinghua.edu.cn