En hoy aprendizaje profundo Landscape, optimizar modelos para la implementación en entornos con recursos limitados es más importante que nunca. La cuantificación de peso aborda esta necesidad al reducir la precisión de los parámetros del modelo, típicamente desde valores de punto flotante de 32 bits hasta representaciones de ancho de bits más bajos, lo que produce modelos más pequeños que pueden funcionar más rápido en hardware con recursos limitados. Este tutorial presenta el concepto de cuantización de peso utilizando la técnica de cuantización dinámica de Pytorch en un modelo RESNET18 previamente capacitado. El tutorial explorará cómo inspeccionar las distribuciones de peso, aplicará cuantificación dinámica a capas clave (como capas totalmente conectadas), comparará los tamaños del modelo y visualizará los cambios resultantes. Este tutorial lo equipará con los antecedentes teóricos y las habilidades prácticas requeridas para implementar modelos de aprendizaje profundo.
import torch
import torch.nn as nn
import torch.quantization
import torchvision.models as models
import matplotlib.pyplot as plt
import numpy as np
import os
print("Torch version:", torch.__version__)Importamos las bibliotecas requeridas como Pytorch, TorchVision y Matplotlib, e imprime la versión de Pytorch, asegurando que todos los módulos necesarios estén listos para la manipulación y visualización del modelo.
model_fp32 = models.resnet18(pretrained=True)
model_fp32.eval()
print("Pretrained ResNet18 (FP32) model loaded.")Un modelo Resnet18 previamente se carga en la precisión FP32 (punto flotante) y se establece en el modo de evaluación, preparándolo para su posterior procesamiento y cuantificación.
fc_weights_fp32 = model_fp32.fc.weight.data.cpu().numpy().flatten()
plt.figure(figsize=(8, 4))
plt.hist(fc_weights_fp32, bins=50, color="skyblue", edgecolor="black")
plt.title("FP32 - FC Layer Weight Distribution")
plt.xlabel("Weight values")
plt.ylabel("Frequency")
plt.grid(True)
plt.show()
En este bloque, los pesos de la capa final totalmente conectada del modelo FP32 se extraen y se aplanan, luego se traza un histograma para visualizar su distribución antes de que se aplique cualquier cuantificación.
quantized_model = torch.quantization.quantize_dynamic(model_fp32, {nn.Linear}, dtype=torch.qint8)
quantized_model.eval()
print("Dynamic quantization applied to the model.")Aplicamos cuantización dinámica al modelo, específicamente dirigido a las capas lineales, para convertirlas en formatos de menor precisión, lo que demuestra una técnica clave para reducir el tamaño del modelo y la latencia de inferencia.
def get_model_size(model, filename="temp.p"):
torch.save(model.state_dict(), filename)
size = os.path.getsize(filename) / 1e6
os.remove(filename)
return size
fp32_size = get_model_size(model_fp32, "fp32_model.p")
quant_size = get_model_size(quantized_model, "quant_model.p")
print(f"FP32 Model Size: {fp32_size:.2f} MB")
print(f"Quantized Model Size: {quant_size:.2f} MB")Se define una función auxiliar para guardar y verificar el tamaño del modelo en el disco; Luego, se usa para medir y comparar los tamaños del modelo FP32 original y el modelo cuantificado, mostrando el impacto de la cuantización de la compresión.
dummy_input = torch.randn(1, 3, 224, 224)
with torch.no_grad():
output_fp32 = model_fp32(dummy_input)
output_quant = quantized_model(dummy_input)
print("Output from FP32 model (first 5 elements):", output_fp32[0][:5])
print("Output from Quantized model (first 5 elements):", output_quant[0][:5])Se crea un tensor de entrada ficticia para simular una imagen, y tanto los modelos FP32 como los cuantizados se ejecutan en esta entrada para que pueda comparar sus salidas y validar que la cuantización no altera drásticamente las predicciones.
if hasattr(quantized_model.fc, 'weight'):
fc_weights_quant = quantized_model.fc.weight().dequantize().cpu().numpy().flatten()
else:
fc_weights_quant = quantized_model.fc._packed_params._packed_weight.dequantize().cpu().numpy().flatten()
plt.figure(figsize=(14, 5))
plt.subplot(1, 2, 1)
plt.hist(fc_weights_fp32, bins=50, color="skyblue", edgecolor="black")
plt.title("FP32 - FC Layer Weight Distribution")
plt.xlabel("Weight values")
plt.ylabel("Frequency")
plt.grid(True)
plt.subplot(1, 2, 2)
plt.hist(fc_weights_quant, bins=50, color="salmon", edgecolor="black")
plt.title("Quantized - FC Layer Weight Distribution")
plt.xlabel("Weight values")
plt.ylabel("Frequency")
plt.grid(True)
plt.tight_layout()
plt.show()
En este bloque, los pesos cuantificados (después de la descantización) se extraen de la capa totalmente conectada y se comparan mediante histogramas contra los pesos FP32 originales para ilustrar los cambios en la distribución del peso debido a la cuantización.
En conclusión, el tutorial ha proporcionado una guía paso a paso para comprender e implementar cuantización de peso, destacando su impacto en el tamaño y el rendimiento del modelo. Al cuantificar un modelo RESNET18 previamente capacitado, observamos los cambios en las distribuciones de peso, los beneficios tangibles en la compresión del modelo y potenciales mejoras de velocidad de inferencia. Esta exploración prepara el escenario para una mayor experimentación, como la implementación de la capacitación consciente de cuantización (QAT), lo que puede optimizar aún más el rendimiento en los modelos cuantificados.
Aquí está el Cuaderno de colab. Además, no olvides seguirnos Gorjeo y únete a nuestro Canal de telegrama y LinkedIn GRsalpicar. No olvides unirte a nuestro 85k+ ml de subreddit.
Asif Razzaq es el CEO de MarktechPost Media Inc .. Como empresario e ingeniero visionario, ASIF se compromete a aprovechar el potencial de la inteligencia artificial para el bien social. Su esfuerzo más reciente es el lanzamiento de una plataforma de medios de inteligencia artificial, MarktechPost, que se destaca por su cobertura profunda de noticias de aprendizaje automático y de aprendizaje profundo que es técnicamente sólido y fácilmente comprensible por una audiencia amplia. La plataforma cuenta con más de 2 millones de vistas mensuales, ilustrando su popularidad entre el público.