Documentação da API AIMET (4)

1.1.6 API de Simulação Quantitativa

1.1.6.1 Link do Guia do Usuário

Para saber mais sobre simulação quantizada, consulte Simulação quantizada

1.1.6.2 Exemplo de link de bloco de notas

Para um notebook completo mostrando como usar o treinamento com reconhecimento de quantização PyTorch, veja aqui .

1.1.6.3 Diretrizes

AIMET Quantization Sim exige que as definições do modelo PyTorch sigam certas diretrizes. Essas diretrizes são descritas em detalhes aqui. Guia de modelo

AIMET fornece uma API de preparação de modelo que permite aos usuários preparar modelos PyTorch para funções de quantificação AIMET. A API e os exemplos de uso são detalhados aqui. API do preparador de modelo

AIMET também inclui um utilitário validador de modelo que permite aos usuários verificar as definições de seu modelo. Veja a API e exemplos de uso deste utilitário aqui. API validadora de modelo

1.1.6.4 API de nível superior

classe aimet_torch.quantsim.QuantizationSimModel (modelo, dummy_input, quant_scheme=<QuantScheme.post_training_tf_enhanced: 2>, rounding_mode='mais próximo', default_output_bw=8, default_param_bw=8, in_place=False, config_file=None, default_data_type=<QuantizationDataType.int: 1>, master_opdef_file=Nenhum, backend_opdef_files=Nenhum)[fonte]

Implementa um mecanismo para adicionar operações de simulação quantizadas aos modelos. Isso permite a simulação fora do alvo da precisão da inferência. Também permite o ajuste fino do modelo para neutralizar os efeitos da quantização.

Construtor de QuantizationSimModel.

parâmetro:

modelo (Módulo) – Adicione um modelo para simular a operação
dummy_input (Union[Tensor, Tuple]) – Passa a entrada para o modelo. Usado para analisar diagramas de modelo. Se o modelo tiver múltiplas entradas, uma tupla será passada. Os usuários devem colocar tensores em dispositivos apropriados.
quant_scheme (Union[str, QuantScheme]) – Esquema de quantização. O esquema de quantização é usado para calcular o código quantizado. Existem várias opções para escolher. Consulte a definição de enumeração QuantScheme.
rounding_mode (str) – Modo de arredondamento. As opções suportadas são "Recentes" ou "Aleatórias"
default_output_bw (int) – Largura de bits padrão (4-31) usada para quantizar todas as entradas e saídas da camada
default_param_bw (int) – Largura de bits padrão (4-31) usada para quantizar todos os parâmetros da camada
in_place (bool) – Se True, modifique o “modelo” fornecido no local para adicionar um nó de simulação quantizado. Esta opção só é recomendada se o usuário quiser evitar a criação de uma cópia do modelo
config_file (Opcional[str]) – Caminho do arquivo de configuração do quantizador do modelo
default_data_type (QuantizationDataType) – Tipo de dados padrão usado para quantificar todas as entradas, saídas e parâmetros da camada. As opções possíveis são QuantizationDataType.int e QuantizationDataType.float. Observe que o padrão default_data_type=QuantizationDataType.float suporta apenas default_output_bw=16 e default_param_bw=16
master_opdef_file (opcional[str]) – caminho do arquivo xml da definição da operação mestre
backend_opdef_files (Opcional[List[str]]) – Lista de caminhos para arquivos xml para definições de operação de backend. Se nenhuma correspondência for encontrada, a largura de bits aplicada e o tipo de dados serão processados de acordo com a ordem do xml fornecido.

As seguintes APIs estão disponíveis para codificação de modelos computacionais

QuantizationSimModel.compute_encodings (forward_pass_callback, forward_pass_callback_args)[fonte]

Codificação de todos os nós de simulação quantizados no modelo computacional. Também é usado para encontrar a codificação inicial para aprendizado de intervalo

parâmetro:

forward_pass_callback – Uma função de retorno de chamada que simplesmente executa para frente passará o modelo. Essa função de retorno de chamada deve usar dados representativos para passes de encaminhamento, para que a codificação calculada se aplique a todas as amostras de dados. Esse retorno de chamada seleciona internamente o número de amostras de dados a serem usadas para calcular a codificação.
forward_pass_callback_args – Esses argumentos são passados para forward_pass_callback como estão. O tipo deste parâmetro é determinado pelo usuário. Por exemplo, poderia ser simplesmente um número inteiro representando o número de amostras de dados a serem usadas. Ou poderia ser uma tupla de parâmetros ou um objeto representando algo mais complexo. Se definido como Nenhum, forward_pass_callback será chamado sem parâmetros.

Retorno: vazio

As APIs a seguir podem ser usadas para salvar e restaurar modelos quantizados

quantsim.save_checkpoint (caminho_do_arquivo)

Esta API fornece uma maneira para os usuários salvarem pontos de verificação do modelo quantizado que podem ser carregados posteriormente para continuar o ajuste fino, por exemplo, consulte também load_checkpoint()

parâmetro:

quant_sim_model (QuantizationSimModel) – QuantizationSimModel usado para salvar pontos de verificação
file_path (str) – Caminho para o arquivo no qual salvar o ponto de verificação

Retorno: vazio

quantsim.load_checkpoint ()
carrega o modelo de quantificação

Parâmetros: file_path (str) – Caminho para o arquivo para salvar o checkpoint
Tipo de retorno: QuantizationSimModel
Retorna: Uma nova instância do QuantizationSimModel criada após carregar o checkpoint

As APIs a seguir podem ser usadas para exportar modelos para destinos

QuantizationSimModel.export (caminho, filename_prefix, dummy_input, onnx_export_args=Nenhum, propagate_encodings=False, export_to_torchscript=False, use_embedded_encodings=False)[fonte]

Este método exporta um modelo de simulação quantizado para que possa ser executado no alvo.

Especificamente, salve o seguinte:

sim-model exporta como um modelo PyTorch regular sem quaisquer operações de simulação
A codificação de quantização é exportada para um arquivo separado no formato JSON, que pode então ser importado pelo tempo de execução de destino (se necessário)
(Opcional) Exporte o modelo equivalente no formato ONNX. Além disso, os nós nos modelos ONNX são nomeados da mesma forma que os nomes dos módulos PyTorch correspondentes. Isso ajuda a combinar o nó ONNX com sua codificação de quantização no nº 2.

parâmetro:

path (str) – caminho para armazenar o modelo pth e codificação
filename_prefix (str) – Prefixo a ser usado para nomes de arquivos do modelo pth e arquivos de codificação
dummy_input (Union[Tensor, Tuple]) – Entrada fictícia para o modelo. Usado para analisar diagramas de modelo. Dummy_input precisa ser colocado na CPU.
onnx_export_args (Union[OnnxExportApiArgs, Dict[~KT, ~VT], None]) – Argumentos de exportação opcionais com substituições específicas de onnx fornecidas como um dicionário ou objeto OnnxExportApiArgs. Se não for fornecido, o padrão é "opset_version" = None, "input_names" = None, "output_names" = None e "enable_onnx_checker" = False para versões do torch < 1.10.0.
propagate_encodings (bool) – Se True, as entradas de codificação para operações intermediárias (quando uma operação PyTorch resulta em vários nós ONNX) serão preenchidas com o mesmo BW e data_type que o tensor de saída da série de operações. O padrão é falso.
export_to_torchscript (bool) – Se True, exporta para torchscript. Caso contrário, exporte para onnx. O padrão é falso.
use_embedded_encodings (bool) – Se True, outro modelo onnx com nó fakequant incorporado será exportado

O formato de codificação é descrito na Especificação de Codificação Quantizada

1.1.6.5 Definição de enumeração

Enumeração do esquema de quantização

classe aimet_common.defs.QuantScheme[fonte]

Enumeração de esquemas de quantização

pós_treinamento_percentil = 6

Para tensores, seleciona os valores mínimo e máximo ajustados com base nos valores percentuais passados. O código de quantização é calculado usando os valores mínimo e máximo ajustados.

pós_treinamento_tf = 1

Para tensores, os valores mínimo e máximo absolutos do tensor são usados para calcular a codificação quantizada.

post_training_tf_enhanced = 2

Para tensores, pesquise e selecione os melhores valores mínimos e máximos que minimizem o ruído de quantização. Calcule o código de quantização usando os valores mínimo e máximo selecionados. '

training_range_learning_with_tf_enhanced_init = 4

Para tensores, os valores codificados são inicializados usando o esquema post_training_tf_enhanced. Então, a codificação é aprendida durante o treinamento.

treinamento_range_learning_with_tf_init = 3

Para tensores, os valores codificados são inicializados usando o esquema post_training_tf. Então, a codificação é aprendida durante o treinamento.

1.1.6.6 Exemplo de Código - Treinamento de Conscientização Quantitativa (QAT)

Este exemplo demonstra como usar AIMET para realizar QAT (treinamento consciente de quantização). QAT é um recurso AIMET que adiciona operações de simulação de quantização (às vezes chamadas de operações de pseudo-quantização) a um modelo de ML treinado e ajusta ou treina o modelo para várias épocas usando o pipeline de treinamento padrão. O modelo resultante deve mostrar maior precisão em relação ao acelerador de aprendizado de máquina quantizado.

QAT para abreviar - Os parâmetros de quantização (por exemplo, ativações para cada escala/deslocamento de tensor) são calculados uma vez. Durante o processo de ajuste fino, os pesos do modelo são atualizados para minimizar o impacto da quantização na propagação direta, mantendo os parâmetros de quantização constantes.

Precisa importar

import torch
import torch.cuda

Carregar modelo PyTorch

Para este exemplo, carregaremos o modelo ResNet18 pré-treinado do torchvision. Da mesma forma, você pode carregar qualquer modelo PyTorch pré-treinado.

from torchvision.models import resnet18

    model = resnet18(pretrained=True)
    model = model.cuda()

Prepare modelos de simulação quantitativos

A simulação quantitativa AIMET exige que os usuários sigam certas diretrizes na definição do modelo. Por exemplo, as funções definidas na passagem direta devem ser alteradas para o equivalente torch.nn.Module. O Guia do usuário AIMET lista todas essas diretrizes. A API ModelPreparer a seguir usa os novos recursos de transformação de gráfico disponíveis no PyTorch 1.9+ e automatiza as alterações na definição do modelo necessárias para cumprir as diretrizes acima.

Para obter mais detalhes, consulte: API do Preparador de Modelo :

from aimet_torch.model_preparer import prepare_model
    prepared_model = prepare_model(model)

Crie modelos de simulação quantitativos

Agora criamos QuantizationSimModel usando AIMET. Isso basicamente significa que o AIMET irá inserir operações de quantização falsas no gráfico do modelo e configurá-las. Aqui estão alguns parâmetros explicados

from aimet_common.defs import QuantScheme
    from aimet_torch.quantsim import QuantizationSimModel
    input_shape = (1, 3, 224, 224)
    dummy_input = torch.randn(input_shape).cuda()

    quant_sim = QuantizationSimModel(prepared_model, dummy_input=dummy_input,
                                     quant_scheme=QuantScheme.post_training_tf_enhanced,
                                     default_param_bw=8, default_output_bw=8,
                                     config_file='../../TrainingExtensions/common/src/python/aimet_common/quantsim_config/'
                                                 'default_config.json')

Função de exemplo criada pelo usuário a partir do retorno de chamada compute_encodings()

Embora o AIMET tenha adicionado o nó Quantizer ao gráfico do modelo, o modelo ainda não está pronto para uso. Antes de podermos usar o modelo sim para inferência ou treinamento, precisamos encontrar os parâmetros de quantização de escala/deslocamento apropriados para cada nó "quantizador". Para ativar o nó de quantização, precisamos passar amostras de dados não rotuladas através do modelo para coletar estatísticas de intervalo e, em seguida, deixar o AIMET calcular os parâmetros de quantização de escala/deslocamento apropriados. Este processo às vezes é chamado de calibração. A AIMET simplesmente chama isso de “codificação computacional”.

Portanto, criamos uma rotina para passar amostras de dados não rotuladas através do modelo. Isso deve ser bastante simples - use um carregador de dados de treinamento ou validação existente para extrair algumas amostras e passá-las para o modelo. Não precisamos calcular nenhuma métrica de perda, etc. Portanto, podemos ignorar a saída do modelo para esta finalidade. Algumas dicas sobre amostras de dados

Na prática, precisamos de uma pequena porção de toda a amostra de dados para calcular a codificação. Por exemplo, o conjunto de dados de treinamento do ImageNet possui 1 milhão de amostras. Para codificação computacional, precisamos apenas de 500 ou 1.000 amostras.

Isto pode ser benéfico se as amostras usadas para calcular a codificação estiverem bem distribuídas. Não há necessidade de cobrir todas as classes, etc., pois estamos apenas observando a faixa de valores quando cada camada é ativada. No entanto, definitivamente queremos evitar casos extremos, como usar todas as amostras "escuras" ou "claras" - por exemplo, usar apenas fotos tiradas à noite pode não fornecer resultados ideais.

def pass_calibration_data(sim_model, forward_pass_args=None):
    """
    The User of the QuantizationSimModel API is expected to write this function based on their data set.
    This is not a working function and is provided only as a guideline.

    :param sim_model:
    :param args: other arguments for the forwards
    :return:
    """

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

    # User action required
    # For computing the activation encodings, around 1000 unlabelled data samples are required.
    # Edit the following 2 lines based on your batch size.
    # batch_size * max_batch_counter should be 1024
    batch_size = 64
    max_batch_counter = 16

    sim_model.eval()

    current_batch_counter = 0
    with torch.no_grad():
        for input_data, target_data in data_loader:

            inputs_batch = input_data  # labels are ignored
            sim_model(inputs_batch)

            current_batch_counter += 1
            if current_batch_counter == max_batch_counter:
                break

Calcular codificação quantizada

Agora chamamos AIMET usando a rotina acima para passar os dados para o modelo e então calcular a codificação quantizada. A codificação aqui se refere aos parâmetros de quantização de escala/deslocamento.

quant_sim.compute_encodings(pass_calibration_data, forward_pass_callback_args=None)

Ajustando modelos de simulação quantitativa

Para realizar o treinamento com reconhecimento de quantização (QAT), precisamos apenas treinar o modelo por mais algumas épocas (geralmente 15-20 épocas). Como acontece com qualquer esforço de treinamento, os hiperparâmetros precisam ser pesquisados para obter os melhores resultados. Um bom ponto de partida é usar uma taxa de aprendizagem da mesma ordem de grandeza que a taxa de aprendizagem final ao treinar o modelo original e reduzir a taxa de aprendizagem por um fator de 10 a cada 5 épocas ou mais.

Para efeitos deste exemplo, treinaremos apenas por 1 época. Mas fique à vontade para alterar esses parâmetros conforme achar necessário.

# User action required
    # The following line of code illustrates that the model is getting finetuned.
    # Replace the following finetune() unction with your pipeline's finetune() function.
    ImageNetDataPipeline.finetune(quant_sim.model, epochs=1, learning_rate=5e-7, learning_rate_schedule=[5, 10],
                                  use_cuda=use_cuda)

    # Determine simulated accuracy
    accuracy = ImageNetDataPipeline.evaluate(quant_sim.model, use_cuda)
    print(accuracy)

Modelo de exportação

Portanto, temos um modelo melhorado após o QAT. Agora, o próximo passo é realmente usar esse modelo contra o alvo. Para fazer isso precisamos derivar o modelo com pesos atualizados sem usar operações de quantização espúrias. Também derivamos a codificação (parâmetros de quantização de escala/deslocamento) atualizada durante o treinamento desde o uso do QAT. AIMET QuantizationSimModel fornece uma API de exportação para essa finalidade.

# Export the model which saves pytorch model without any simulation nodes and saves encodings file for both
    # activations and parameters in JSON format
    quant_sim.export(path='./', filename_prefix='quantized_resnet18', dummy_input=dummy_input.cpu())

1.1.7 API de arredondamento adaptativo

1.1.7.1 Link do Guia do Usuário

Para saber mais sobre esta tecnologia, consulte AdaRound

1.1.7.2 Exemplo de link de notebook

Para um notebook completo mostrando como usar o PyTorch AdaRound, veja aqui .

1.1.7.3 API de nível superior

aimet_torch.adaround.adaround_weight.Adaround.apply_adaround (modelo, dummy_input, params, caminho, filename_prefix, default_param_bw=4, param_bw_override_list=Nenhum, ignore_quant_ops_list=Nenhum, default_quant_scheme=<QuantScheme.post_training_tf_enhanced: 2>, default_config_file=Nenhum)

Retorna um modelo com arredondamento de peso otimizado para cada módulo (Conv e Linear) e salva a codificação de quantização correspondente em um arquivo separado no formato JSON, que pode então ser importado pelo QuantSim para inferência ou QAT

parâmetro:

modelo (Módulo) – Modelo para Adaround
dummy_input (Union[Tensor, Tuple]) – Entrada fictícia para o modelo. Usado para analisar diagramas de modelo. Se o modelo tiver múltiplas entradas, uma tupla será passada. Os usuários devem colocar tensores em dispositivos apropriados.
params (AdaroundParameters) – Parâmetros do Adaround
path (str) – caminho para armazenar a codificação do parâmetro
filename_prefix (str) – O prefixo usado para o nome do arquivo codificado
default_param_bw (int) – Largura de bits padrão (4-31) usada para quantizar os parâmetros da camada
param_bw_override_list (Optional[List[Tuple[Module, int]]]) – Lista de tuplas. Cada tupla é um módulo e a largura do parâmetro correspondente a ser usada por esse módulo
ignore_quant_ops_list (Optional[List[Module]]) – As operações listadas aqui são ignoradas durante a quantização exigida pelo AdaRounding. Não especifique os módulos Conv e Linear nesta lista. Isso afetará a precisão
default_quant_scheme (QuantScheme) – Esquema de quantização. As opções suportadas usam a enumeração QuantScheme QuantScheme.post_training_tf ou QuantScheme.post_training_tf_enhanced
default_config_file (opcional[str]) – Arquivo de configuração padrão para o quantizador de modelo

Tipo de retorno: Module
Retorna: Modelado usando pesos Adarounded e salva o arquivo JSON codificado por parâmetro correspondente no caminho fornecido

1.1.7.4 Parâmetros Adaround

classe aimet_torch.adaround.adaround_weight.AdaroundParameters (data_loader, num_batches, default_num_iterations=None, default_reg_param=0,01, default_beta_range=(20, 2), default_warm_start=0,2, forward_fn=None)[fonte]

Parâmetros de configuração Adaround

parâmetro:

data_loader (DataLoader[+T_co]) – carregador de dados
num_batches (int) – Número de lotes a serem usados para Adaround. O valor geralmente recomendado para este parâmetro é o menor entre (1) len(data_loader) e (2) ceil(2000/batch_size)
default_num_iterations (Opcional[int]) – Número de iterações em torno de cada camada. O valor padrão é 10K para modelos com pesos de 8 bits ou superiores e 15K para modelos com pesos inferiores a 8 bits.
default_reg_param (float) – Parâmetro de regularização que compensa perda de arredondamento versus perda de reconstrução. Padrão 0,01
default_beta_range (Tuple) – Parâmetros beta de início e parada (start_beta, end_beta) para recozimento de perda de arredondamento. Padrão(20, 2)
default_warm_start (float) – Período de aquecimento durante o qual o impacto da perda de arredondamento é zero. Padrão 20% (0,2)
forward_fn (Optional[Callable[[Module, Any], Any]]) – Função opcional do adaptador que executa uma passagem de encaminhamento dada a entrada gerada pelo modelo e pelo carregador de dados. A função espera o modelo como primeiro argumento e o modelo de entrada como segundo argumento.

1.1.7.5 Definição de enumeração

Enumeração do esquema de quantização

classe aimet_common.defs.QuantScheme [fonte]

Enumeração de esquemas de quantização

pós_treinamento_percentil = 6

Para tensores, seleciona os valores mínimo e máximo ajustados com base nos valores percentuais passados. O código de quantização é calculado usando os valores mínimo e máximo ajustados.

pós_treinamento_tf = 1

Para tensores, os valores mínimo e máximo absolutos do tensor são usados para calcular a codificação quantizada.

post_training_tf_enhanced = 2

Training_range_learning_with_tf_enhanced_init = 4

Para tensores, os valores codificados são inicializados usando o esquema post_training_tf_enhanced. Então, a codificação é aprendida durante o treinamento.

treinamento_range_learning_with_tf_init = 3

Para tensores, os valores codificados são inicializados usando o esquema post_training_tf. Então, a codificação é aprendida durante o treinamento.