Quantização pós-treinamento

A quantização pós-treinamento é uma técnica de conversão que pode reduzir o tamanho do modelo e, ao mesmo tempo, melhorar a latência da CPU e do acelerador de hardware, com pouca degradação na precisão do modelo. Você pode quantizar um modelo flutuante do TensorFlow já treinado ao convertê-lo para o formato TensorFlow Lite usando o TensorFlow Lite Converter .

Métodos de otimização

Existem várias opções de quantização pós-treinamento para você escolher. Aqui está uma tabela resumida das opções e dos benefícios que elas oferecem:

A árvore de decisão a seguir pode ajudar a determinar qual método de quantização pós-treinamento é melhor para seu caso de uso:

Quantização de faixa dinâmica

A quantização de faixa dinâmica é um ponto de partida recomendado porque fornece uso reduzido de memória e computação mais rápida sem a necessidade de fornecer um conjunto de dados representativo para calibração. Este tipo de quantização quantiza estaticamente apenas os pesos de ponto flutuante para inteiro no tempo de conversão, o que fornece 8 bits de precisão:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quant_model = converter.convert()

Para reduzir ainda mais a latência durante a inferência, os operadores de "faixa dinâmica" quantizam dinamicamente as ativações com base em sua faixa de 8 bits e realizam cálculos com pesos e ativações de 8 bits. Essa otimização fornece latências próximas às inferências de ponto totalmente fixo. No entanto, as saídas ainda são armazenadas usando ponto flutuante, de modo que o aumento da velocidade das operações de faixa dinâmica é menor do que um cálculo completo de ponto fixo.

Quantização inteira completa

Você pode obter mais melhorias de latência, reduções no pico de uso de memória e compatibilidade com dispositivos ou aceleradores de hardware somente com números inteiros, certificando-se de que toda a matemática do modelo seja quantizada por números inteiros.

Para quantização inteira completa, você precisa calibrar ou estimar o intervalo, ou seja, (min, max) de todos os tensores de ponto flutuante no modelo. Ao contrário dos tensores constantes, como pesos e vieses, tensores variáveis, como entrada do modelo, ativações (saídas de camadas intermediárias) e saída do modelo não podem ser calibrados, a menos que executemos alguns ciclos de inferência. Como resultado, o conversor requer um conjunto de dados representativo para calibrá-los. Este conjunto de dados pode ser um pequeno subconjunto (cerca de 100-500 amostras) dos dados de treinamento ou validação. Consulte a função representative_dataset() abaixo.

Na versão TensorFlow 2.7, você pode especificar o conjunto de dados representativo por meio de uma assinatura como no exemplo a seguir:

def representative_dataset():
  for data in dataset:
    yield {
      "image": data.image,
      "bias": data.bias,
    }

Se houver mais de uma assinatura no modelo do TensorFlow fornecido, você poderá especificar vários conjuntos de dados especificando as chaves de assinatura:

def representative_dataset():
  # Feed data set for the "encode" signature.
  for data in encode_signature_dataset:
    yield (
      "encode", {
        "image": data.image,
        "bias": data.bias,
      }
    )

  # Feed data set for the "decode" signature.
  for data in decode_signature_dataset:
    yield (
      "decode", {
        "image": data.image,
        "hint": data.hint,
      },
    )

Você pode gerar o conjunto de dados representativo fornecendo uma lista de tensores de entrada:

def representative_dataset():
  for data in tf.data.Dataset.from_tensor_slices((images)).batch(1).take(100):
    yield [tf.dtypes.cast(data, tf.float32)]

Desde a versão 2.7 do TensorFlow, recomendamos usar a abordagem baseada em assinatura em vez da abordagem baseada em lista de tensores de entrada porque a ordem do tensor de entrada pode ser facilmente invertida.

Para fins de teste, você pode usar um conjunto de dados fictício da seguinte maneira:

def representative_dataset():
    for _ in range(100):
      data = np.random.rand(1, 244, 244, 3)
      yield [data.astype(np.float32)]
 

Inteiro com fallback flutuante (usando entrada/saída flutuante padrão)

Para quantizar totalmente um modelo, mas usar operadores float quando eles não tiverem uma implementação inteira (para garantir que a conversão ocorra sem problemas), use as seguintes etapas:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
tflite_quant_model = converter.convert()

Apenas números inteiros

A criação de modelos somente inteiros é um caso de uso comum do TensorFlow Lite para microcontroladores e TPUs Coral Edge .

Além disso, para garantir a compatibilidade apenas com dispositivos inteiros (como microcontroladores de 8 bits) e aceleradores (como o Coral Edge TPU), você pode impor a quantização completa de números inteiros para todas as operações, incluindo entrada e saída, usando as seguintes etapas:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.int8  # or tf.uint8
converter.inference_output_type = tf.int8  # or tf.uint8
tflite_quant_model = converter.convert()

Quantização Float16

Você pode reduzir o tamanho de um modelo de ponto flutuante quantizando os pesos para float16, o padrão IEEE para números de ponto flutuante de 16 bits. Para habilitar a quantização de pesos float16, use as seguintes etapas:

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_types = [tf.float16]
tflite_quant_model = converter.convert()

As vantagens da quantização float16 são as seguintes:

• Reduz o tamanho do modelo em até metade (uma vez que todos os pesos passam a ter metade do seu tamanho original).
• Causa perda mínima de precisão.
• Ele suporta alguns delegados (por exemplo, o delegado GPU) que podem operar diretamente nos dados float16, resultando em uma execução mais rápida do que os cálculos float32.

As desvantagens da quantização float16 são as seguintes:

• Não reduz a latência tanto quanto uma quantização para matemática de ponto fixo.
• Por padrão, um modelo quantizado float16 irá "desquantizar" os valores dos pesos para float32 quando executado na CPU. (Observe que o delegado da GPU não realizará essa desquantização, pois pode operar em dados float16.)

Somente números inteiros: ativações de 16 bits com pesos de 8 bits (experimental)

Este é um esquema de quantização experimental. É semelhante ao esquema "somente número inteiro", mas as ativações são quantizadas com base em seu intervalo de 16 bits, os pesos são quantizados em números inteiros de 8 bits e a polarização é quantizada em números inteiros de 64 bits. Isto é ainda referido como quantização 16x8.

A principal vantagem desta quantização é que ela pode melhorar significativamente a precisão, mas apenas aumentar ligeiramente o tamanho do modelo.

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.representative_dataset = representative_dataset
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_ops = [tf.lite.OpsSet.EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8]
tflite_quant_model = converter.convert()

Se a quantização 16x8 não for suportada para alguns operadores no modelo, então o modelo ainda poderá ser quantizado, mas os operadores não suportados serão mantidos em flutuação. A opção a seguir deve ser adicionada ao target_spec para permitir isso.

import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.representative_dataset = representative_dataset
converter.optimizations = [tf.lite.Optimize.DEFAULT]
converter.target_spec.supported_ops = [tf.lite.OpsSet.EXPERIMENTAL_TFLITE_BUILTINS_ACTIVATIONS_INT16_WEIGHTS_INT8,
tf.lite.OpsSet.TFLITE_BUILTINS]
tflite_quant_model = converter.convert()

Exemplos de casos de uso em que as melhorias de precisão fornecidas por este esquema de quantização incluem:

• super-resolução,
• processamento de sinal de áudio, como cancelamento de ruído e formação de feixe,
• remoção de ruído de imagem,
• Reconstrução HDR a partir de uma única imagem.

A desvantagem desta quantização é:

• Atualmente a inferência é visivelmente mais lenta que o número inteiro completo de 8 bits devido à falta de implementação otimizada do kernel.
• Atualmente é incompatível com os delegados TFLite acelerados por hardware existentes.

Um tutorial para este modo de quantização pode ser encontrado aqui .

Precisão do modelo

Como os pesos são quantizados após o treinamento, pode haver perda de precisão, principalmente em redes menores. Modelos totalmente quantizados pré-treinados são fornecidos para redes específicas no TensorFlow Hub . É importante verificar a precisão do modelo quantizado para verificar se qualquer degradação na precisão está dentro dos limites aceitáveis. Existem ferramentas para avaliar a precisão do modelo TensorFlow Lite .

Alternativamente, se a queda na precisão for muito alta, considere usar o treinamento com reconhecimento de quantização . No entanto, fazer isso requer modificações durante o treinamento do modelo para adicionar nós de quantização falsos, enquanto as técnicas de quantização pós-treinamento nesta página usam um modelo pré-treinado existente.

Representação para tensores quantizados

A quantização de 8 bits aproxima os valores de ponto flutuante usando a seguinte fórmula.

\[real\_value = (int8\_value - zero\_point) \times scale\]

A representação tem duas partes principais:

• Pesos por eixo (também conhecidos como por canal) ou por tensor representados por valores de complemento de dois int8 no intervalo [-127, 127] com ponto zero igual a 0.

• Ativações/entradas por tensor representadas por valores de complemento de dois int8 no intervalo [-128, 127], com ponto zero no intervalo [-128, 127].

Para uma visão detalhada do nosso esquema de quantização, consulte nossas especificações de quantização . Os fornecedores de hardware que desejam se conectar à interface delegada do TensorFlow Lite são incentivados a implementar o esquema de quantização descrito lá.