03 - 量化精度损失评估¶

评估和补偿量化带来的精度损失

📖 章节概述¶

本章将介绍如何评估量化带来的精度损失，包括精度评估指标、损失分析和补偿方法等内容。

🎯 学习目标¶

完成本章后，你将能够：

掌握精度评估的指标和方法
了解量化损失的分析技巧
实现精度补偿的方法
能够评估和优化量化效果

1. 精度评估指标¶

1.1 分类任务指标¶

Python

import numpy as np
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

def evaluate_classification(y_true, y_pred):
    """
    评估分类任务

    Args:
        y_true: 真实标签
        y_pred: 预测标签
    """
    metrics = {
        'accuracy': accuracy_score(y_true, y_pred),
        'precision': precision_score(y_true, y_pred, average='weighted'),
        'recall': recall_score(y_true, y_pred, average='weighted'),
        'f1_score': f1_score(y_true, y_pred, average='weighted')
    }

    return metrics

# 使用示例
# metrics = evaluate_classification(y_true, y_pred)
# print(metrics)

1.2 生成任务指标¶

Python

from nltk.translate.bleu_score import sentence_bleu
from rouge import Rouge

def evaluate_generation(references, hypotheses):
    """
    评估生成任务

    Args:
        references: 参考文本列表
        hypotheses: 生成文本列表
    """
    # BLEU分数
    bleu_scores = []
    for ref, hyp in zip(references, hypotheses):
        bleu = sentence_bleu([ref.split()], hyp.split())
        bleu_scores.append(bleu)

    # ROUGE分数
    rouge = Rouge()
    rouge_scores = rouge.get_scores(hypotheses, references, avg=True)

    metrics = {
        'bleu': np.mean(bleu_scores),
        'rouge_1': rouge_scores['rouge-1']['f'],
        'rouge_2': rouge_scores['rouge-2']['f'],
        'rouge_l': rouge_scores['rouge-l']['f']
    }

    return metrics

# 使用示例
# metrics = evaluate_generation(references, hypotheses)
# print(metrics)

2. 损失分析¶

2.1 量化误差分析¶

Python

import torch
import numpy as np

def analyze_quantization_error(original, quantized):
    """
    分析量化误差

    Args:
        original: 原始张量
        quantized: 量化张量
    """
    # 计算误差
    error = original - quantized

    # 计算统计信息
    metrics = {
        'mean_absolute_error': torch.mean(torch.abs(error)).item(),
        'mean_squared_error': torch.mean(error ** 2).item(),
        'root_mean_squared_error': torch.sqrt(torch.mean(error ** 2)).item(),
        'max_absolute_error': torch.max(torch.abs(error)).item(),
        'std_error': torch.std(error).item()
    }

    return metrics

# 使用示例
# error_metrics = analyze_quantization_error(original_weight, quantized_weight)
# print(error_metrics)

2.2 层级误差分析¶

Python

def analyze_layer_errors(model_fp32, model_quantized, dataloader):
    """
    分析层级误差

    Args:
        model_fp32: FP32模型
        model_quantized: 量化模型
        dataloader: 数据加载器
    """
    model_fp32.eval()
    model_quantized.eval()

    layer_errors = {}

    with torch.no_grad():
        for batch_x, _ in dataloader:
            # 获取FP32模型的输出
            output_fp32 = model_fp32(batch_x)

            # 获取量化模型的输出
            output_quantized = model_quantized(batch_x)

            # 计算每层的误差
            for name, (fp32_output, quant_output) in zip(  # zip并行遍历多个可迭代对象
                model_fp32.named_children(),
                model_quantized.named_children()
            ):
                if name not in layer_errors:
                    layer_errors[name] = []

                error = torch.mean(torch.abs(fp32_output - quant_output)).item()
                layer_errors[name].append(error)

    # 计算平均误差
    for name in layer_errors:
        layer_errors[name] = np.mean(layer_errors[name])

    return layer_errors

# 使用示例
# layer_errors = analyze_layer_errors(model_fp32, model_quantized, dataloader)
# print(layer_errors)

3. 补偿方法¶

3.1 量化后微调¶

Python

import torch
import torch.nn as nn

def post_quantization_finetune(quantized_model, dataloader, epochs=3):
    """
    量化后微调

    Args:
        quantized_model: 量化模型
        dataloader: 数据加载器
        epochs: 训练轮数
    """
    # 冻结量化参数
    for name, param in quantized_model.named_parameters():
        if 'weight' in name and 'quantized' in name:
            param.requires_grad = False

    # 训练
    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(
        filter(lambda p: p.requires_grad, quantized_model.parameters()),  # lambda匿名函数：简洁的单行函数
        lr=0.0001
    )

    quantized_model.train()
    for epoch in range(epochs):
        total_loss = 0
        for batch_x, batch_y in dataloader:
            optimizer.zero_grad()
            outputs = quantized_model(batch_x)
            loss = criterion(outputs, batch_y)
            loss.backward()
            optimizer.step()
            total_loss += loss.item()

        print(f"Epoch {epoch+1}, Loss: {total_loss/len(dataloader):.4f}")

    return quantized_model

# 使用示例
# finetuned_model = post_quantization_finetune(quantized_model, dataloader)

3.2 知识蒸馏补偿¶

Python

class DistillationLoss(nn.Module):
    """
    蒸馏损失
    """
    def __init__(self, temperature=5.0, alpha=0.5):
        super().__init__()  # super()调用父类方法
        self.temperature = temperature
        self.alpha = alpha
        self.kl_div = nn.KLDivLoss(reduction='batchmean')
        self.ce_loss = nn.CrossEntropyLoss()

    def forward(self, student_outputs, teacher_outputs, targets):
        """
        计算蒸馏损失
        """
        # 软标签损失
        soft_loss = self.kl_div(
            torch.log_softmax(student_outputs / self.temperature, dim=1),
            torch.softmax(teacher_outputs / self.temperature, dim=1)
        ) * (self.temperature ** 2)

        # 硬标签损失
        hard_loss = self.ce_loss(student_outputs, targets)

        # 组合损失
        loss = self.alpha * soft_loss + (1 - self.alpha) * hard_loss

        return loss

def distillation_compensation(teacher_model, student_model, dataloader, epochs=5):
    """
    蒸馏补偿

    Args:
        teacher_model: 教师模型（FP32）
        student_model: 学生模型（量化）
        dataloader: 数据加载器
        epochs: 训练轮数
    """
    # 冻结教师模型
    teacher_model.eval()
    for param in teacher_model.parameters():
        param.requires_grad = False

    # 训练学生模型
    criterion = DistillationLoss(temperature=5.0, alpha=0.5)
    optimizer = torch.optim.Adam(student_model.parameters(), lr=0.001)

    student_model.train()
    for epoch in range(epochs):
        total_loss = 0
        for batch_x, batch_y in dataloader:
            # 教师模型前向传播
            with torch.no_grad():
                teacher_outputs = teacher_model(batch_x)

            # 学生模型前向传播
            student_outputs = student_model(batch_x)

            # 计算损失
            loss = criterion(student_outputs, teacher_outputs, batch_y)

            # 反向传播和优化
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            total_loss += loss.item()

        print(f"Epoch {epoch+1}, Loss: {total_loss/len(dataloader):.4f}")

    return student_model

# 使用示例
# compensated_model = distillation_compensation(teacher_model, student_model, dataloader)

4. 面试题¶

基础题¶

Q1: 如何评估量化带来的精度损失？

A: 使用准确率、BLEU、ROUGE等指标在测试集上评估量化前后的模型性能，对比分析精度损失。

Q2: 什么是量化后微调？

A: 量化后微调是在量化后的模型上使用少量数据进行微调，以补偿量化带来的精度损失。

进阶题¶

Q3: 如何减少量化带来的精度损失？

A: 可以通过以下方法减少精度损失： 1. 使用量化感知训练（QAT） 2. 进行量化后微调 3. 使用知识蒸馏 4. 优化量化参数 5. 使用更好的量化算法

Q4: 如何分析量化误差的分布？

A: 可以计算量化误差的统计信息（均值、方差、最大值等），并可视化误差分布，分析误差的主要来源。

5. 练习题¶

基础练习¶

实现精度评估

Python

# TODO: 实现精度评估函数
def evaluate_accuracy(model, dataloader):
    # 你的代码
    pass

计算量化误差

Python

# TODO: 计算量化误差
def quantization_error(original, quantized):
    # 你的代码
    pass

进阶练习¶

实现量化后微调

Python

# TODO: 实现量化后微调
class PostQuantizationFinetune:
    def __init__(self, model):
        # 你的代码
        pass

    def finetune(self, dataloader, epochs):
        # 你的代码
        pass

实现蒸馏补偿

Python

# TODO: 实现蒸馏补偿
class DistillationCompensation:
    def __init__(self, teacher, student):
        # 你的代码
        pass

    def compensate(self, dataloader, epochs):
        # 你的代码
        pass

6. 最佳实践¶

✅ 推荐做法¶

全面评估
在多个数据集上评估
使用多种评估指标
记录详细结果
分析误差来源
分析层级误差
识别敏感层
针对性优化
应用补偿方法
使用量化后微调
应用知识蒸馏
迭代优化

❌ 避免做法¶

单一指标评估
不要只看准确率
使用多种指标
综合评估
忽略误差分析
分析误差分布
识别问题根源
针对性解决
过度补偿
不要过度微调
避免过拟合
保持泛化能力

7. 总结¶

本章介绍了量化精度损失的评估和补偿：

评估指标: 分类和生成任务的指标
损失分析: 误差分析和层级分析
补偿方法: 微调和蒸馏补偿

掌握这些方法可以有效减少量化带来的精度损失。

8. 下一步¶

继续学习04-常见面试问题和解答，准备常见的面试问题。