深度学习之模型压缩、加速模型推理-51CTO.COM

简介

当将一个机器学习模型部署到生产环境中时，通常需要满足一些在模型原型阶段没有考虑到的要求。例如，在生产中使用的模型将不得不处理来自不同用户的大量请求。因此，您将希望进行优化，以获得较低的延迟和/或吞吐量。

延迟：是任务完成所需的时间，就像单击链接后加载网页所需的时间。它是开始某项任务和看到结果之间的等待时间。
吞吐量：是系统在一定时间内可以处理的请求数。

这意味着机器学习模型在进行预测时必须非常快速，为此有各种技术可以提高模型推断的速度，本文将介绍其中最重要的一些。

模型压缩

有一些旨在使模型更小的技术，因此它们被称为模型压缩技术，而另一些则侧重于使模型在推断阶段更快，因此属于模型优化领域。但通常使模型更小也有助于提高推断速度，因此在这两个研究领域之间的界限非常模糊。

1.低秩分解

这是我们首次看到的第一种方法，它正在受到广泛研究，事实上，最近已经有很多关于它的论文发布。

基本思想是用低维度的矩阵（虽然更正确的说法是张量，因为我们经常有超过2维的矩阵）替换神经网络的矩阵（表示网络层的矩阵）。通过这种方式，我们将减少网络参数的数量，从而提高推断速度。

一个微不足道的例子是，在CNN网络中，将3x3的卷积替换为1x1的卷积。这种技术被用于网络结构中，比如SqueezeNet。

最近，类似的思想也被应用于其他用途，比如允许在资源有限的情况下微调大型语言模型。当为下游任务微调预训练模型时，仍然需要在预训练模型的所有参数上训练模型，这可能非常昂贵。

因此，名为“大型语言模型的低秩适应”（或LoRA）的方法的思想是用较小的矩阵对原始模型进行替换（使用矩阵分解），这些矩阵具有较小的尺寸。这样，只需要重新训练这些新矩阵，以使预训练模型适应更多下游任务。

图片

在LoRA中的矩阵分解

现在，让我们看看如何使用Hugging Face的PEFT库来实现对LoRA进行微调。假设我们想要使用LoRA对bigscience/mt0-large进行微调。首先，我们必须确保导入我们需要的内容。

!pip install peft
!pip install transformers1.
2.

  from transformers import AutoModelForSeq2SeqLM
  from peft import get_peft_model, LoraConfig, TaskType

  model_name_or_path = "bigscience/mt0-large"
  tokenizer_name_or_path = "bigscience/mt0-large"1.
2.
3.
4.
5.

接下来的步骤将是创建在微调期间应用于LoRA的配置。

peft_config = LoraConfig(
    task_type=TaskType.SEQ_2_SEQ_LM, inference_mode=False, r=8, lora_alpha=32, lora_dropout=0.1
)1.
2.
3.

然后，我们使用Transformers库的基本模型以及我们为LoRA创建的配置对象来实例化模型。

model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
model = get_peft_model(model, peft_config)
model.print_trainable_parameters()1.
2.
3.

2.知识蒸馏

这是另一种方法，允许我们将“小”模型放入生产中。思想是有一个称为教师的大模型，和一个称为学生的较小模型，我们将使用教师的知识来教学生如何进行预测。这样，我们可以只将学生放入生产环境中。

这种方法的一个经典示例是以这种方式开发的模型DistillBERT，它是BERT的学生模型。DistilBERT比BERT小40%，但保留了97%的语言理解能力，并且推断速度快60%。这种方法有一个缺点是：您仍然需要拥有大型教师模型，以便对学生进行训练，而您可能没有足够的资源来训练类似教师的模型。

让我们看看如何在Python中进行知识蒸馏的简单示例。要理解的一个关键概念是Kullback–Leibler散度，它是一个用于理解两个分布之间差异的数学概念，实际上在我们的案例中，我们想要理解两个模型的预测之间的差异，因此训练的损失函数将基于这个数学概念。

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
import numpy as np

# Load the MNIST dataset
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# Preprocess the data
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

# Define the teacher model (a larger model)
teacher_model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

teacher_model.compile(optimizer='adam',
                      loss='categorical_crossentropy',
                      metrics=['accuracy'])

# Train the teacher model
teacher_model.fit(train_images, train_labels, epochs=5, batch_size=64, validation_split=0.2)

# Define the student model (a smaller model)
student_model = models.Sequential([
    layers.Flatten(input_shape=(28, 28, 1)),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

student_model.compile(optimizer='adam',
                      loss='categorical_crossentropy',
                      metrics=['accuracy'])

# Knowledge distillation step: Transfer knowledge from the teacher to the student
def distillation_loss(y_true, y_pred):
    alpha = 0.1  # Temperature parameter (adjust as needed)
    return tf.keras.losses.KLDivergence()(tf.nn.softmax(y_true / alpha, axis=1),
                                           tf.nn.softmax(y_pred / alpha, axis=1))

# Train the student model using knowledge distillation
student_model.fit(train_images, train_labels, epochs=10, batch_size=64,
                  validation_split=0.2, loss=distillation_loss)

# Evaluate the student model
test_loss, test_acc = student_model.evaluate(test_images, test_labels)
print(f'Test accuracy: {test_acc * 100:.2f}%')1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.

3.剪枝

剪枝是我在研究生论文中研究过的一种模型压缩方法，事实上，我之前曾发表过一篇关于如何在Julia中实现剪枝的文章：Julia中用于人工神经网络的迭代剪枝方法。

剪枝是为了解决决策树中的过拟合问题而诞生的，实际上是通过剪掉树的分支来减小树的深度。该概念后来被用于神经网络，其中会删除网络中的边和/或节点（取决于是否执行非结构化剪枝或结构化剪枝）。

假设要从网络中删除整个节点，表示层的矩阵将变小，因此您的模型也会变小，因此也会变快。相反，如果我们删除单个边，矩阵的大小将保持不变，但是我们将在删除的边的位置放置零，因此我们将获得非常稀疏的矩阵。因此，在非结构化剪枝中，优势不在于增加速度，而在于内存，因为将稀疏矩阵保存在内存中比保存密集矩阵要占用更少的空间。

但我们要剪枝的是哪些节点或边呢？通常是最不必要的节点或边，推荐大家可以研究下下面两篇论文：《Optimal Brain Damage》和《Optimal Brain Surgeon and general network pruning》。

让我们看一个如何在简单的MNIST模型中实现剪枝的Python脚本。

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
from tensorflow_model_optimization.sparsity import keras as sparsity
import numpy as np

# Load the MNIST dataset
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# Preprocess the data
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

# Create a simple neural network model
def create_model():
    model = Sequential([
        tf.keras.layers.Flatten(input_shape=(28, 28, 1)),
        tf.keras.layers.Dense(128, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(64, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(10, activation='softmax')
    ])
    return model

# Create and compile the original model
model = create_model()
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# Train the original model
model.fit(train_images, train_labels, epochs=5, batch_size=64, validation_split=0.2)

# Prune the model
# Specify the pruning parameters
pruning_params = {
    'pruning_schedule': sparsity.PolynomialDecay(initial_sparsity=0.50,
                                                 final_sparsity=0.90,
                                                 begin_step=0,
                                                 end_step=2000,
                                                 frequency=100)
}

# Create a pruned model
pruned_model = sparsity.prune_low_magnitude(create_model(), **pruning_params)

# Compile the pruned model
pruned_model.compile(optimizer='adam',
                     loss='categorical_crossentropy',
                     metrics=['accuracy'])

# Train the pruned model (fine-tuning)
pruned_model.fit(train_images, train_labels, epochs=2, batch_size=64, validation_split=0.2)

# Strip pruning wrappers to create a smaller and faster model
final_model = sparsity.strip_pruning(pruned_model)

# Evaluate the final pruned model
test_loss, test_acc = final_model.evaluate(test_images, test_labels)
print(f'Test accuracy after pruning: {test_acc * 100:.2f}%')1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.

量化

我认为没有错的说量化可能是目前最广泛使用的压缩技术。同样，基本思想很简单。通常，我们使用32位浮点数表示神经网络的参数。但如果我们使用更低精度的数值呢？我们可以使用16位、8位、4位，甚至1位，并且拥有二进制网络！

这意味着什么？通过使用较低精度的数字，模型将更轻，更小，但也会失去精度，提供比原始模型更近似的结果。当我们需要在边缘设备上部署时，特别是在某些特殊硬件上，如智能手机上，这是一种经常使用的技术，因为它允许我们大大缩小网络的大小。许多框架允许轻松应用量化，例如TensorFlow Lite、PyTorch或TensorRT。

量化可以在训练前应用，因此我们直接截断了一个网络，其参数只能在某个范围内取值，或者在训练后应用，因此最终会对参数的值进行四舍五入。在这里，我们再次快速看一下如何在Python中应用量化。

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten, Dropout
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
import numpy as np

# Load the MNIST dataset
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# Preprocess the data
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

# Create a simple neural network model
def create_model():
    model = Sequential([
        Flatten(input_shape=(28, 28, 1)),
        Dense(128, activation='relu'),
        Dropout(0.2),
        Dense(64, activation='relu'),
        Dropout(0.2),
        Dense(10, activation='softmax')
    ])
    return model

# Create and compile the original model
model = create_model()
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

# Train the original model
model.fit(train_images, train_labels, epochs=5, batch_size=64, validation_split=0.2)

# Quantize the model to 8-bit integers
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
quantized_model = converter.convert()

# Save the quantized model to a file
with open('quantized_model.tflite', 'wb') as f:
    f.write(quantized_model)

# Load the quantized model for inference
interpreter = tf.lite.Interpreter(model_path='quantized_model.tflite')
interpreter.allocate_tensors()

# Evaluate the quantized model
test_loss, test_acc = 0.0, 0.0
for i in range(len(test_images)):
    input_data = np.array([test_images[i]], dtype=np.float32)
    interpreter.set_tensor(interpreter.get_input_details()[0]['index'], input_data)
    interpreter.invoke()
    output_data = interpreter.get_tensor(interpreter.get_output_details()[0]['index'])
    test_loss += tf.keras.losses.categorical_crossentropy(test_labels[i], output_data).numpy()
    test_acc += np.argmax(test_labels[i]) == np.argmax(output_data)

test_loss /= len(test_images)
test_acc /= len(test_images)

print(f'Test accuracy after quantization: {test_acc * 100:.2f}%')1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.

结论

在本文中，我们探讨了几种模型压缩方法，以加速模型推断阶段，这对于生产中的模型来说可能是一个关键要求。特别是，我们关注了低秩分解、知识蒸馏、剪枝和量化等方法，解释了基本思想，并展示了Python中的简单实现。模型压缩对于在具有有限资源（RAM、GPU等）的特定硬件上部署模型也非常有用，比如智能手机。