Documentación API AIMET (7)

- - 1.1.10 API de cuantificación automática
  - 1.1.11 API de reestimación de BatchNorm

1.1.10 API de cuantificación automática

Enlace de la guía del usuario

Para obtener más información sobre esta tecnología, consulte AutoQuant

Enlace de cuaderno de muestra

Para obtener un cuaderno completo que muestra cómo usar PyTorch AutoQuant, consulte aquí.

API de nivel superior

类 aimet_torch.auto_quant_v2.AutoQuant（model、dummy_input、data_loader、eval_callback、param_bw=8、output_bw=8、quant_scheme=<QuantScheme.post_training_tf_enhanced: 2>、rounding_mode='nearest'、config_file=None、results_dir='/tmp'、 cache_id=Ninguno、strict_validation=正确）

Integrar y aplicar técnicas de cuantificación post-entrenamiento.

AutoQuant incluye 1) plegado de normas por lotes, 2) ecualización entre capas y 3) Adaround. Estas técnicas se aplicarán de la mejor manera posible hasta que el modelo cumpla con los objetivos de evaluación establecidos por Allow_accuracy_drop.

parámetro

modelo (Módulo): el modelo que se va a cuantificar. Suponiendo que el modelo está en el dispositivo correcto
dummy_input (Unión [Tensor, Tupla]): entrada ficticia al modelo. Suponiendo que dummy_input esté en el dispositivo correcto
data_loader (DataLoader[+T_co]): itera sobre una colección de conjuntos de datos sin etiquetar para calcular codificaciones
eval_callback (Callable[[Module], float]) – función que calcula la puntuación de evaluación
param_bw (int) – ancho de bits del parámetro
output_bw (int) – ancho de bits de salida
quant_scheme (QuantScheme) – Esquema de cuantificación
rounding_mode (str) – Modo de redondeo
config_file (Opcional[str]): ruta del archivo de configuración del cuantificador del modelo
results_dir (str) – directorio donde se guardan los resultados técnicos de PTQ
cache_id (Opcional[ str]): el ID asociado con el resultado almacenado en caché
estricto_validación (bool): indicador establecido en Verdadero de forma predeterminada. Si es falso, AutoQuant continuará la ejecución y manejará los errores internamente si es posible. Esto puede producir resultados subóptimos o poco intuitivos.

ejecutar_inferencia()

Crear modelos cuantitativos y realizar inferencias.

Tipo de retorno
Tupla[QuantizationSimModel, float]

Devuelve
QuantizationSimModel, la precisión del modelo es un número de coma flotante

optimizar (permitido_accuracy_drop = 0.0)

Integrar y aplicar técnicas de cuantificación post-entrenamiento.

Parámetro
permitido_accuracy_drop (flotante): caída de precisión máxima permitida

Tipo de retorno
Tupla[Módulo, flotante, cadena]

Devuelve
tupla (mejor modelo, puntuación de evaluación, ruta de codificación)

set_adaround_params（adaround_params）

Establezca los parámetros de Adaround. Si el usuario no llama explícitamente a este método, AutoQuant utilizará data_loader (pasado a __init__) para Adaround.

Parámetros
adaround_params (AdaroundParameters): parámetros de Adaround.

Tipo de devolución Ninguno

set_export_params(onnx_export_args=-1,propagate_encodings=Ninguno)

Establezca los parámetros de QuantizationSimModel.export.

parámetro

onnx_export_args (OnnxExportApiArgs): argumentos de exportación opcionales, con anulaciones específicas de onnx si la exportación no se proporciona a través de gráficos de torchscript.
propagate_encodings (Opcional[bool]): si es Verdadero, las entradas de codificación para operaciones intermedias (cuando una operación de PyTorch da como resultado múltiples nodos ONNX) se completarán con el mismo BW y tipo de datos que el tensor de salida de la serie de operaciones.

Tipo de devolución Ninguno

set_model_preparer_params（modules_to_exclude =无，module_classes_to_exclude =无，concrete_args =无）

Establezca los parámetros del preparador de modelos.

parámetro

module_to_exclude (Opcional[ Lista[Módulo]]): lista de módulos que se excluirán durante el seguimiento.
module_classes_to_exclude (Opcional[ Lista[Módulo]]): lista de clases de módulos que se excluirán al realizar el seguimiento.
crete_args (Opcional[ Dict[ str, Any]]): parámetros para el preparador de modelos. Le permite especializar parcialmente sus funciones, ya sea eliminando el flujo de control o las estructuras de datos. torch.fx no podrá rastrear el modelo si tiene flujo de control. Consulte la API torch.fx.symbolic_trace en detalle.

get_quant_scheme_candidates()

Devuelve los candidatos para la búsqueda del esquema de cuantificación. Durante optimizar(), se seleccionará el candidato con mayor precisión.

Tipo de retorno
Tupla[_QuantSchemePair,…]

Devuelve
candidatos para la búsqueda de soluciones cuantitativas

set_quant_scheme_candidates(candidatos)

Establece candidatos para la búsqueda de esquemas de cuantificación. Durante optimizar(), se seleccionará el candidato con mayor precisión.

Candidatos de parámetros
(Tuple[ _QuantSchemePair,…]) – Candidatos para la búsqueda de esquemas de cuantificación

Aimet_torch.auto_quant.AutoQuant( permitido_accuracy_drop、unlabeled_dataset_iterable、eval_callback、default_param_bw=8、default_output_bw=8、default_quant_scheme=<QuantScheme.post_training_tf_enhanced: 2>、default_rounding_mode='nearest'、default_config_ archivo=Ninguno)

ADVERTENCIA
auto_quant.AutoQuant_quant_v2.AutoQuant está obsoleto y será reemplazado en una versión posterior.

Integrar y aplicar técnicas de cuantificación post-entrenamiento.

parámetro

permitido_accuracy_drop (flotante): caída de precisión máxima permitida.
unlabeled_dataset_iterable (Union[DataLoader[+T_co], Collection[+T_co]]): una colección (es decir, iterada usando __len__) sobre un conjunto de datos sin etiquetar utilizado para codificar cálculos. Se espera que los valores producidos por esta iteración se pasen directamente al modelo. De forma predeterminada, esta iteración también se utilizará para Adaround a menos que self.set_adaround_params especifique lo contrario.
eval_callback (Invocable[[ Módulo, Opcional[int]], flotante]): función que asigna el modelo y el número de muestras a las puntuaciones de evaluación. Se espera que esta devolución de llamada devuelva un valor escalar que represente el rendimiento del modelo evaluado para N muestras, donde N es el número de muestras pasadas como segundo argumento de esta devolución de llamada. Nota: Si N es Ninguno, se espera que el modelo se evalúe con todo el conjunto de datos de evaluación.
default_param_bw (int): ancho de bits predeterminado (4-31) utilizado para cuantificar los parámetros de la capa.
default_output_bw (int): ancho de bits predeterminado (4-31) utilizado para la entrada y salida de la capa de cuantificación.
default_quant_scheme (QuantScheme): esquema de cuantificación. Los valores admitidos son QuantScheme.post_training_tf o QuantScheme.post_training_tf_enhanced.
default_rounding_mode (str): modo de redondeo. Las opciones admitidas son "Reciente" o "Aleatorio"
default_config_file (Opcional[ str]): ruta del archivo de configuración del cuantificador del modelo

aplicar (fp32_model、dummy_input_on_cpu、dummy_input_on_gpu=Ninguno、results_dir='/tmp'、cache_id=Ninguno)

Aplicar técnicas de cuantificación post-entrenamiento.

parámetro

fp32_model (Módulo) – Modelo aplicando tecnología PTQ.
dummy_input_on_cpu (Unión[Tensor, Tupla]): entrada ficticia al modelo en la memoria de la CPU.
dummy_input_on_gpu (Unión[Tensor, Tupla, Ninguno]): entrada ficticia para el modelo en la memoria de la GPU. Este parámetro es necesario si y sólo si fp32_model está en la GPU.
results_dir (str): directorio para guardar resultados.
cache_id (Opcional[ str]): una cadena que se combina con results_dir para formar la identificación de la caché. Si se especifica, AutoQuant cargará/guardará los resultados de PTQ en el sistema de archivos si hay resultados de PTQ anteriores generados bajo el mismo results_dir y cache_id.

Tipo de retorno
Tupla[Módulo, flotante, cadena]

Devuelve
una tupla (mejor modelo, puntuación de evaluación, frente de ruta de codificación).

Mejorado
Si el modelo está en una GPU y no se especifica dummy_input_on_gpu, se producirá un ValueError.

set_adaround_params（adaround_params）

Establezca los parámetros de Adaround. Si el usuario no llama explícitamente a este método, AutoQuant utilizará unlabeled_dataset_iterable (pasado a __init__) para Adaround.

Parámetros
adaround_params (AdaroundParameters): parámetros de Adaround.

Tipo de devolución Ninguno

set_export_params(onnx_export_args=-1,propagate_encodings=Ninguno)

Establezca los parámetros de QuantizationSimModel.export.

parámetro

onnx_export_args (OnnxExportApiArgs): argumentos de exportación opcionales, con anulaciones específicas de onnx si la exportación no se proporciona a través de gráficos de torchscript.
propagate_encodings (Opcional[bool]): si es Verdadero, las entradas de codificación para operaciones intermedias (cuando una operación de PyTorch da como resultado múltiples nodos ONNX) se completarán con el mismo BW y tipo de datos que el tensor de salida de la serie de operaciones.

Tipo de devolución Ninguno

ejemplo de código

import random
from typing import Optional

import torch
from torch.utils.data import Dataset, DataLoader, SubsetRandomSampler
from torchvision import models, datasets, transforms

from aimet_torch.adaround.adaround_weight import AdaroundParameters
from aimet_torch.auto_quant_v2 import AutoQuant

# Step 1. Define constants and helper functions
EVAL_DATASET_SIZE = 5000
CALIBRATION_DATASET_SIZE = 2000
BATCH_SIZE = 100

_subset_samplers = {
    
    }

def _create_sampled_data_loader(dataset, num_samples):
    if num_samples not in _subset_samplers:
        indices = random.sample(range(len(dataset)), num_samples)
        _subset_samplers[num_samples] = SubsetRandomSampler(indices=indices)
    return DataLoader(dataset,
                      sampler=_subset_samplers[num_samples],
                      batch_size=BATCH_SIZE)

# Step 2. Prepare model and dataset
fp32_model = models.resnet18(pretrained=True).eval()

input_shape = (1, 3, 224, 224)
dummy_input = torch.randn(input_shape)

transform = transforms.Compose((
    transforms.ToTensor(),
))
# NOTE: In the actual use cases, a real dataset should provide by the users.
eval_dataset = datasets.FakeData(size=EVAL_DATASET_SIZE,
                                 image_size=input_shape[1:],
                                 num_classes=1000,
                                 transform=transform)

# Step 3. Prepare unlabeled dataset
# NOTE: In the actual use cases, the users should implement this part to serve
#       their own goals if necessary.
class UnlabeledDatasetWrapper(Dataset):
    def __init__(self, dataset):
        self._dataset = dataset

    def __len__(self):
        return len(self._dataset)

    def __getitem__(self, index):
        images, _ = self._dataset[index]
        return images

unlabeled_dataset = UnlabeledDatasetWrapper(eval_dataset)
unlabeled_data_loader = _create_sampled_data_loader(unlabeled_dataset, CALIBRATION_DATASET_SIZE)

# Step 4. Prepare eval callback
# NOTE: In the actual use cases, the users should implement this part to serve
#       their own goals if necessary.
def eval_callback(model: torch.nn.Module, num_samples: Optional[int] = None) -> float:
    if num_samples is None:
        num_samples = len(eval_dataset)

    eval_data_loader = _create_sampled_data_loader(eval_dataset, num_samples)

    num_correct_predictions = 0
    for images, labels in eval_data_loader:
        predictions = torch.argmax(model(images.cuda()), dim=1)
        num_correct_predictions += torch.sum(predictions.cpu() == labels)

    return int(num_correct_predictions) / num_samples

# Step 5. Create AutoQuant object
auto_quant = AutoQuant(fp32_model.cuda(),
                       dummy_input.cuda(),
                       unlabeled_data_loader,
                       eval_callback)

# Step 6. (Optional) Set adaround params
ADAROUND_DATASET_SIZE = 2000
adaround_data_loader = _create_sampled_data_loader(unlabeled_dataset, ADAROUND_DATASET_SIZE)
adaround_params = AdaroundParameters(adaround_data_loader, num_batches=len(adaround_data_loader))
auto_quant.set_adaround_params(adaround_params)

# Step 7. Run AutoQuant
sim, initial_accuracy = auto_quant.run_inference()
model, optimized_accuracy, encoding_path = auto_quant.optimize(allowed_accuracy_drop=0.01)

print(f"- Quantized Accuracy (before optimization): {initial_accuracy:.4f}")
print(f"- Quantized Accuracy (after optimization):  {optimized_accuracy:.4f}")

Notas
Para utilizar auto_quant.AutoQuant (que quedará obsoleto), aplique los siguientes cambios de código en los pasos 5 y 7.

# Step 5. Create AutoQuant object
auto_quant = AutoQuant(allowed_accuracy_drop=0.01,
                       unlabeled_dataset_iterable=unlabeled_data_loader,
                       eval_callback=eval_callback)

# Step 6. (Optional) Set adaround params
ADAROUND_DATASET_SIZE = 2000
adaround_data_loader = _create_sampled_data_loader(unlabeled_dataset, ADAROUND_DATASET_SIZE)
adaround_params = AdaroundParameters(adaround_data_loader, num_batches=len(adaround_data_loader))
auto_quant.set_adaround_params(adaround_params)

# Step 7. Run AutoQuant
model, accuracy, encoding_path =\
    auto_quant.apply(fp32_model.cuda(),
                     dummy_input_on_cpu=dummy_input.cpu(),
                     dummy_input_on_gpu=dummy_input.cuda())

print(f"- Quantized Accuracy (after optimization):  {optimized_accuracy:.4f}")

1.1.11 API de reestimación de BatchNorm

Enlace de cuaderno de ejemplo
Para obtener un cuaderno de un extremo a otro que muestra cómo utilizar el entrenamiento con reconocimiento de cuantificación de PyTorch y la reestimación de BatchNorm, consulte aquí

Presentamos
la reestimación de la norma por lotes (BN) para volver a estimar las estadísticas de la capa BN después de realizar QAT. Utilizando las estadísticas reestimadas, la capa BN se contrae en la capa Conv y la capa Lineal anteriores.

API de nivel superior
para la API de reestimación BatchNorm

aimet_torch.bn_reestimation.reestimate_bn_stats (modelo, cargador de datos, num_batches=100, forward_fn=Ninguno)

Vuelva a estimar las estadísticas de BatchNorm (media móvil y varianza).

Modelo paramétrico
(módulo): modelo que reestima las estadísticas de BN.

cargador de datos (DataLoader[+T_co]) – conjunto de datos de entrenamiento.

num_batches (int): número de lotes que se utilizarán para la reestimación.

forward_fn (Opcional[ Invocable[[ Módulo, Cualquiera], Cualquiera]]): función de adaptador opcional que realiza un paso directo dado un modelo y un lote de entrada generado por el cargador de datos.

Tipo de retornoManejar

Volver Deshacer
BN Vuelve a evaluar el identificador con el efecto de handle.remove().

API para escalado de pliegues BatchNorm

aimet_torch.batch_norm_fold.fold_all_batch_norms_to_scale (simulación)
Pliega todas las capas de Batch_norm en el modelo en los parámetros de escala cuantificados de la capa de transformación correspondiente.

参数
sim (QuantizationSimModel) – QuantizationSimModel

Tipo de retorno
Lista[Tupla[QcQuantizeWrapper, QcQuantizeWrapper]]

Lista de pares de capas de retorno [(Conv/Lineal, capa BN contraída)]

Ejemplo de código: reestimación de BN

** Paso 1. Cargar modelo **

Para este ejemplo, cargaremos el modelo ResNet18 previamente entrenado desde torchvision.

def load_fp32_model():

    import torchvision
    from torchvision.models import resnet18
    from aimet_torch.model_preparer import prepare_model

    use_cuda = torch.cuda.is_available()
    if use_cuda:
        device = torch.device("cuda")
    else:
        device = torch.device("cpu")

    model = resnet18(pretrained=True).to(device)
    model = prepare_model(model)

    return model, use_cuda

Paso 2. Cree QuantSim con el aprendizaje de rango y la cuantificación por canal habilitados

Ejemplos de uso de rangos para aprender QuantScheme y crear QuantSim
Cómo habilitar la cuantificación por canal

Paso 3. Ejecute QAT

  # User action required
    # The following line of code is an example of how to use an example ImageNetPipeline's train function.
    # Replace the following line with your own pipeline's  train function.
    ImageNetPipeline.train(sim.model, epochs=1, learning_rate=5e-7, learning_rate_schedule=[5, 10], use_cuda=use_cuda)

Paso 4a: Realizar una reestimación de BatchNorm

 from aimet_torch.bn_reestimation import reestimate_bn_stats

    # User action required
    # The following line of code is an example of how to use the ImageNet data's training data loader.
    # Replace the following line with your own dataset's training data loader.
    train_loader = ImageNetDataPipeline.get_train_dataloader()

    reestimate_bn_stats(quant_sim.model, train_loader, forward_fn=forward_fn)

Paso 4 b. Ejecute BatchNorm Plegar a escala

 from aimet_torch.batch_norm_fold import fold_all_batch_norms_to_scale

    fold_all_batch_norms_to_scale(quant_sim)

Paso 5. Exportar modelo y codificación y probar en el objetivo