es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Cuantizando los pesos y sesgos de la red neuronal al formato int16.

Estoy tratando de cuantizar los pesos y sesgos de mi red neuronal a un formato entero de 16 bits. La razón de esto es utilizar estas matrices en CCS para programar la red en un MCU. Si bien seguí el proceso de cuantización posterior al entrenamiento utilizando TensorflowLite y también obtuve los resultados para una conversión al formato uint8, no estoy seguro de cómo puedo lograr esto también para un formato de 16 bits. Mi código para la conversión a uint8 fue el siguiente:

def generar_datos_representativos():
    datos = np.array(x_train, dtype=np.float32)
    for valor_entrada in datos:
        yield [valor_entrada]

convertidor = tf.lite.TFLiteConverter.from_model(model)

# Establecer el modo de optimización
convertidor.optimizations = [tf.lite.Optimize.DEFAULT]

# Pasar el conjunto de datos representativo al convertidor
convertidor.representative_dataset = generar_datos_representativos

# Restringir la especificación de operaciones de destino admitidas a INT8
convertidor.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]

# Establecer los tensores de entrada y salida como uint8
convertidor.inference_input_type = tf.uint8
convertidor.inference_output_type = tf.uint8

# Convertir y guardar el modelo
modelo_tflite = convertidor.convert()
open("modelo_clap.tflite", "wb").write(modelo_tflite)

Mi matriz x_train contiene valores flotantes en el formato float32. Al leer los enfoques disponibles en la página de TensorFlow Lite, vi un caso donde utilizan un enfoque de 16×8 pero los pesos siguen siendo de formato de 8 bits en ese escenario.

Si hay alguna otra forma de convertir estos valores de punto flotante o incluso los enteros de 8 bits obtenidos a un formato de entero de 16 bits, eso también sería extremadamente útil. La única aproximación que se me ocurre es una cuantización manual desde punto flotante a entero de 16 bits, pero supongo que eso sería un poco tedioso computacionalmente ya que copio o uso los pesos y sesgos y luego los paso a través de la función de cuantización mencionada.

Tags:  , , , ,

Answer

  1. Avatar for davy.ai

    Para lograr el formato de cuantificación de 16 bits, puedes modificar el código proporcionado arriba configurando el parámetro converter.target_spec.supported_ops a [tf.lite.OpsSet.TFLITE_BUILTINS_INT16].

    Además, también puedes modificar los parámetros converter.inference_input_type y converter.inference_output_type a tf.int16 para establecerlos en el formato de entero de 16 bits.

    Aquí tienes un fragmento de código actualizado usando las modificaciones anteriores:

    def representative_data_gen():
        data = np.array(x_train, dtype=np.float32);
        for input_value in data:
            yield [input_value]
    
    converter = tf.lite.TFLiteConverter.from_keras_model(model)
    
    # Establecer el modo de optimización
    converter.optimizations = [tf.lite.Optimize.DEFAULT]
    
    # Pasar el conjunto de datos representativo al convertidor
    converter.representative_dataset = representative_data_gen
    
    # Restringir la especificación de las operaciones objetivo admitidas a INT16
    converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT16]
    
    # Establecer los tensores de entrada y salida en int16
    converter.inference_input_type = tf.int16
    converter.inference_output_type = tf.int16
    
    # Convertir y guardar el modelo
    tflite_model = converter.convert()
    open("clap_model.tflite", "wb").write(tflite_model)
    

    También cabe mencionar que cuantizar manualmente los pesos y sesgos de punto flotante al formato de entero de 16 bits es una tarea tediosa y requiere de muchos cálculos. Se recomienda utilizar los métodos de cuantificación incorporados proporcionados por TensorflowLite.

Comments are closed.