Estás leyendo la publicación: ¿Cómo condensar modelos de aprendizaje profundo para dispositivos perimetrales mediante la cuantificación?
La cuantificación es el proceso de implementar modelos de aprendizaje profundo o de aprendizaje automático en dispositivos periféricos como teléfonos inteligentes, televisores inteligentes, relojes inteligentes y muchos más. Pero no es posible implementar el modelo enorme en los dispositivos perimetrales debido a las limitaciones de memoria y aquí es donde se emplea el proceso de cuantificación. Condensa los modelos enormes para implementarlos en los dispositivos perimetrales sin problemas. Este artículo proporciona una breve descripción general de cómo condensar grandes modelos de Tensorflow en modelos ligeros mediante TensorFlow lite y Tensorflow Model Optimization.
Tabla de contenido
- Introducción a la Cuantización
- Diferentes tipos de técnicas de Cuantización
- Creación de un modelo de aprendizaje profundo desde cero
- Implementación de la técnica de cuantificación posterior al entrenamiento
- Implementación de la técnica Aware Model Quantization
- Comparación del modelo original y la predicción del modelo cuantificado
- Resumen
Introducción a la Cuantización
La cuantificación con respecto al aprendizaje profundo es el proceso de aproximar los pesos de la red neuronal obtenidos después de la propagación a través de las diversas capas al valor entero más cercano o en números de bits más bajos. Esta conversión facilita que cualquier modelo pesado de aprendizaje profundo se implemente fácilmente en dispositivos perimetrales sin problemas, ya que el modelo pesado ahora se condensará en modelos más livianos y los resultados del modelo se pueden visualizar en los dispositivos perimetrales.
¿Está buscando un repositorio completo de bibliotecas de Python utilizadas en ciencia de datos, echa un vistazo aquí.
La discrepancia asociada con la ejecución de modelos de aprendizaje profundo más pesados en unidades de procesamiento más bajas, como dispositivos inteligentes, se supera mediante la cuantificación, en la que el consumo total de memoria del modelo se reducirá a casi un tercio o un cuarto de los pesos del modelo Tensorflow original.
Ahora veamos los diferentes tipos de técnicas de Cuantización.
Diferentes tipos de técnicas de Cuantización
Existen principalmente dos tipos de técnicas de cuantificación posibles para modelos de aprendizaje profundo más pesados. Ellos son:-
- Cuantificación posterior al entrenamiento
- Cuantificación de entrenamiento consciente
Ambas técnicas de cuantificación funcionan bajo la supervisión del módulo TensorFlow-lite que se utiliza para condensar los modelos más pesados y llevarlos a los dispositivos de borde.
Cuantificación posterior al entrenamiento
En la técnica de cuantificación posterior al entrenamiento, un modelo de TensorFlow más pesado se condensa en uno más pequeño usando el módulo Tensorflow-lite y en los dispositivos de borde, probablemente se implementará como modelos pequeños de Tensorflow. Pero el problema con esta técnica de cuantificación es que solo se comprime la ocupación de memoria del modelo en el dispositivo de borde, pero el modelo en los dispositivos de borde no se puede usar para ninguno de los parámetros e incluso el rendimiento del modelo si se compara sobre la base de la precisión sería menor en comparación con el modelo Tensorflow en la fase de prueba. Por lo tanto, esta técnica de cuantificación generaría un modelo poco confiable en producción que mostraría signos de bajo rendimiento.
Cuantificación de entrenamiento consciente
La técnica de cuantificación de entrenamiento consciente se usa para superar las limitaciones de la técnica posterior al entrenamiento, donde esta técnica es responsable de madurar el modelo pesado de TensorFlow en desarrollo para progresar a través de un modelo cuantificado con parámetros bien definidos y producir un modelo cuantificado ajustado que se puede pasar al módulo Tensorflow-lite para realizar un ajuste fino y obtener un paquete completo más ligero del modelo Tensorflow desarrollado listo para implementarse en los dispositivos de borde.
Construyendo un modelo de Deep Learning desde cero
En este estudio de caso, el conjunto de datos Fashion MNIST se usa para construir un modelo de Tensorflow. Este conjunto de datos tiene 10 clases de ropa para clasificar. Así que veamos cómo construir un modelo de aprendizaje profundo para clasificar las 10 clases presentes en el conjunto de datos.
Los pasos iniciales comienzan con la importación de las bibliotecas de TensorFlow requeridas y la adquisición del conjunto de datos. Este conjunto de datos está fácilmente disponible en el módulo de Tensorflow y este conjunto de datos tiene que ser preprocesado dividiendo apropiadamente el conjunto de datos en entrenar y probar y también realizar la remodelación y codificación requerida. Una vez que los datos preprocesados completos están disponibles, la construcción del modelo se puede retomar con el número requerido de capas y compilar con funciones de pérdida y métricas apropiadas. Con todo esto en la mano, el modelo finalmente se puede ajustar para el número requerido de iteraciones.
importar tensorflow como tf importar numpy como np importar matplotlib.pyplot como plt de tensorflow.keras.layers importar Flatten,Dense,Dropout,Conv2D,MaxPooling2D de tensorflow.keras.models importar secuencial de tensorflow.keras.utils importar to_categorical %matplotlib en línea de tensorflow.keras.datasets import fashion_mnist (X_train,Y_train),(X_test,Y_test)=fashion_mnist.load_data() plt.figure(figsize=(15,5)) for i in range(10): plt.subplot(2, 5,i+1) plt.imshow(X_tren[i]) plt.axis(‘off’) plt.show()
Entonces, ahora que hemos validado la división de los datos con éxito, podemos continuar con la construcción del modelo.
modelo1=secuencial() modelo1.add(Conv2D(32,kernel_size=2,input_shape=(28,28,1),activation=’relu’)) modelo1.add(MaxPooling2D(pool_size=(2,2))) modelo1 .add(Conv2D(16,kernel_size=2,activation=’relu’)) model1.add(MaxPooling2D(pool_size=(2,2))) model1.add(Flatten()) model1.add(Dense(125,activation =’relu’)) modelo1.add(Dense(10,activation=’softmax’)) modelo1.resumen()
model1.compile(pérdida=”escasa_categorical_entropía cruzada”,optimizador=”adam”,métricas=[‘accuracy’]) model1_fit_res=model1.fit(X_train,Y_train,epochs=10,validation_data=(X_test,Y_test))
print(‘Pérdida de entrenamiento del modelo: {} y la precisión del entrenamiento es: {}’.format(model1.evaluate(X_train,Y_train)[0],modelo1.evaluar(tren_X,tren_Y)[1]))
print(‘Pérdida de prueba del modelo: {} y la precisión de la prueba es: {}’.format(model1.evaluate(X_test,Y_test)[0],modelo1.evaluar(X_prueba,Y_prueba)[1]))
Ahora guardemos este modelo de Tensorflow, ya que se puede usar para la cuantificación más adelante.
modelo1.save(‘TF-Modelo’)
Ahora veamos cómo implementar las técnicas de cuantificación utilizando el modelo guardado.
Cuantificación posterior al entrenamiento
Antes de realizar la cuantificación, observemos la ocupación general de memoria del Tensorflow completo en el entorno de trabajo.
tf_lite_conv=tf.lite.TFLiteConverter.from_saved_model(‘/content/drive/MyDrive/Colab notebooks/Quantization in neural network]/TF-Model’) tf_lite_mod=tf_lite_conv.convert() print(‘Memoria del modelo TF en el disco es ‘,len(tf_lite_mod))
Realización de cuantización posterior al entrenamiento
Esta técnica de cuantificación se toma mediante el uso de la técnica de optimización predeterminada del módulo TensorFlow lite y las optimizaciones predeterminadas obtenidas se convertirán en un modelo cuantificado mediante la función de conversión. Con este modelo, podemos validar la ocupación de memoria del modelo cuantificado mediante el entrenamiento posterior. mejoramiento.
post_tr_conv=tf.lite.TFLiteConverter.from_saved_model(“/content/drive/MyDrive/Colab notebooks/Quantization in neural network]/TF-Model”) post_tr_conv.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quant_model = post_tr_conv.convert() print(‘La memoria del modelo TF cuantificado en el disco es ‘,len(tflite_quant_model))
Así que aquí podemos observar claramente las diferencias en la ocupación de memoria del modelo original de Tensorflow y el modelo Quantized donde podemos ver claramente que la técnica de Quantization ha condensado el modelo original de Tensorflow a un tercio de la ocupación de memoria original. Pero como se mencionó anteriormente, esta técnica es más adecuada solo para comprimir el modelo y validar la ocupación de memoria. Entonces, para una mejor evaluación del rendimiento del modelo en dispositivos de borde, se utiliza la técnica Aware Training Quantization.
Implementación de la técnica Aware Model Quantization
Esta técnica de cuantificación es una de las técnicas de cuantificación más efectivas, ya que no solo condensa los modelos más pesados, sino que también genera parámetros de rendimiento del modelo confiables y también muestra un rendimiento considerable cuando el modelo TensorFlow condensado se implementa en los dispositivos de borde. Veamos los pasos involucrados en la implementación de esta técnica de Cuantización.
!pip install tensorflow-model-optimization importar tensorflow_model_optimization como tfmod_opt quant_aw_model=tfmod_opt.quantization.keras.quantize_model quant_aw_model_fit=quant_aw_model(model1)
Entonces, ahora que hemos creado un modelo cuantificado, tenemos que volver a compilar el modelo con funciones de pérdida y métricas apropiadas y luego ajustar este mismo modelo con los datos divididos.
quant_aw_model_fit.compile(loss=”sparse_categorical_crossentropy”,metrics=[‘accuracy’],optimizador=”adam”) quant_aw_model_fit.resumen()
quant_mod_res=quant_aw_model_fit.fit(X_train,Y_train,epochs=10,validation_data=(X_test,Y_test))
Evaluación de los parámetros del modelo cuantificados
print(‘Pérdida de entrenamiento del modelo cuantificado: {} y la precisión del entrenamiento es: {}’. format(quant_aw_model_fit.evaluate(X_train,Y_train)[0],quant_aw_model_fit.evaluate(X_tren,Y_tren)[1]))
print(‘Pérdida de prueba del modelo cuantificado: {} y la precisión de la prueba es: {}’. format(quant_aw_model_fit.evaluate(X_test,Y_test)[0],quant_aw_model_fit.evaluate(X_test,Y_test)[1]))
Ahora validemos la ocupación de memoria del modelo cuantificado y el modelo original de Tensorflow usando algunos paquetes de TensorFlow lite.
print(‘La memoria del modelo TF en el disco es ‘,len(tf_lite_mod)) print() print(‘Asignación de memoria del modelo consciente de cuantificación’,len(tflite_qaware_model))
Así que aquí podemos ver claramente la diferencia entre los bits del modelo cuantificados y los bits del modelo original de TensorFlow en términos de consumo de memoria. Como también evaluamos ciertos parámetros tanto del modelo Tensorflow original como del modelo Quantized y no se observó ninguna caída en el rendimiento. Para una mejor comparación, intentemos comparar la capacidad de clasificación de los modelos Tensorflow y Quantized para clasificar correctamente los diferentes tipos de ropa.
Comparación del modelo original y la predicción del modelo cuantificado
y_pred=model1.predict(X_test) figure = plt.figure(figsize=(15,5)) for i, index in enumerate(np.random.choice(X_test.shape[0]size=15, replace=False)): ax = figure.add_subplot(3, 5, i + 1, xticks=[]yticks=[]) ax.imshow(np.squeeze(X_test[index])) predict_index=np.argmax(y_pred[index]) índice_verdadero=Y_prueba[index]
ax.set_title(“{} ({})”.formato(etiquetas[predict_index]etiquetas[true_index]), color=(“verde” si predict_index == true_index else “rojo”))
Como hemos visualizado la capacidad del modelo original de TensorFlow para clasificar la ropa, intentemos validar si hay clasificaciones erróneas por parte del modelo cuantificado que se implementaría en la producción en dispositivos de borde.
y_pred_quant_aw=quant_aw_model_fit.predict(X_test) figure = plt.figure(figsize=(15,5)) for i, index in enumerate(np.random.choice(X_test.shape[0]size=15, replace=False)): ax = figure.add_subplot(3, 5, i + 1, xticks=[]yticks=[]) ax.imshow(np.squeeze(X_test[index])) predict_index=np.argmax(y_pred[index]) índice_verdadero=Y_prueba[index]
ax.set_title(“{} ({})”.formato(etiquetas[predict_index]etiquetas[true_index]), color=(“verde” si predict_index == true_index else “rojo”))
Resumen
Entonces, como se menciona claramente en este artículo, así es como se utilizan diferentes técnicas de Cuantización para condensar grandes modelos de aprendizaje profundo en bits más pequeños al reducir la ocupación general de memoria del modo desarrollado en un tercio o un cuarto de la ocupación total de memoria del modelo e implementar en dispositivos de borde que serían relativamente de menor memoria. Entonces, si se adopta la técnica de cuantificación, cualquier modelo complejo de aprendizaje profundo puede condensarse en modelos más ligeros y desplegarse en dispositivos de borde.
