Descargar nncf - Descarga del código fuente nncf

nncf

Código Fuente de IA

v2.14.0

Descargar

Marco de compresión de redes neuronales (NNCF)

Características clave • Instalación • Documentación • Uso • Tutoriales y muestras • Integración con terceros • Model Zoo

Neural Network Compression Framework (NNCF) proporciona un conjunto de algoritmos posteriores al entrenamiento y de tiempo de entrenamiento para optimizar la inferencia de redes neuronales en OpenVINO™ con una caída mínima de precisión.

NNCF está diseñado para funcionar con modelos de PyTorch, TorchFX, TensorFlow, ONNX y OpenVINO™.

NNCF proporciona ejemplos que demuestran el uso de algoritmos de compresión para diferentes casos de uso y modelos. Vea los resultados de compresión que se pueden lograr con las muestras impulsadas por NNCF en la página NNCF Model Zoo.

El marco está organizado como un paquete Python* que se puede construir y utilizar en modo independiente. La arquitectura del marco está unificada para facilitar la adición de diferentes algoritmos de compresión para los marcos de aprendizaje profundo PyTorch y TensorFlow.

Características clave

Algoritmos de compresión posteriores al entrenamiento

Algoritmo de compresión	AbiertoVINO	PyTorch	AntorchaFX	TensorFlow	ONNX
Cuantización post-entrenamiento	Apoyado	Apoyado	Experimental	Apoyado	Apoyado
Compresión de pesas	Apoyado	Apoyado	Experimental	No compatible	No compatible
Escasez de activación	No compatible	Experimental	No compatible	No compatible	No compatible

Algoritmos de compresión del tiempo de entrenamiento

Algoritmo de compresión	PyTorch	TensorFlow
Entrenamiento consciente de la cuantificación	Apoyado	Apoyado
Cuantización de precisión mixta	Apoyado	No compatible
Escasez	Apoyado	Apoyado
Poda de filtro	Apoyado	Apoyado
Poda de movimiento	Experimental	No compatible

Transformación automática y configurable del gráfico del modelo para obtener el modelo comprimido.
NOTA : Soporte limitado para modelos TensorFlow. Solo se admiten modelos creados con Sequential o Keras Functional API.
Interfaz común para métodos de compresión.
Capas aceleradas por GPU para un ajuste más rápido del modelo comprimido.
Soporte de formación distribuida.
Parche de Git para un destacado repositorio de terceros (huggingface-transformers) que demuestra el proceso de integración de NNCF en canales de capacitación personalizados.
Combinación perfecta de algoritmos de poda, escasez y cuantificación. Consulte Optimum-Intel para ver ejemplos de poda, cuantificación y destilación (JPQD) conjunta (movimiento), de extremo a extremo, desde la optimización NNCF hasta OpenVINO IR comprimido.
Exportación de modelos comprimidos de PyTorch a puntos de control ONNX* y modelos comprimidos de TensorFlow a formato SavedModel o Frozen Graph, listos para usar con el kit de herramientas OpenVINO™.
Soporte para canales de capacitación de modelos Accuracy-Aware a través de la capacitación de nivel de compresión adaptativa y la capacitación de salida temprana.

Documentación

Esta documentación cubre información detallada sobre los algoritmos y funciones de NNCF necesarios para la contribución a NNCF.

La documentación de usuario más reciente para NNCF está disponible aquí.

La documentación de la API NNCF se puede encontrar aquí.

Uso

Cuantización post-entrenamiento

El NNCF PTQ es la forma más sencilla de aplicar la cuantificación de 8 bits. Para ejecutar el algoritmo solo necesita su modelo y un pequeño conjunto de datos de calibración (~300 muestras).

OpenVINO es el backend preferido para ejecutar PTQ, mientras que PyTorch, TensorFlow y ONNX también son compatibles.

AbiertoVINO

 import nncf
import openvino . runtime as ov
import torch
from torchvision import datasets , transforms

# Instantiate your uncompressed model
model = ov . Core (). read_model ( "/model_path" )

# Provide validation part of the dataset to collect statistics needed for the compression algorithm
val_dataset = datasets . ImageFolder ( "/path" , transform = transforms . Compose ([ transforms . ToTensor ()]))
dataset_loader = torch . utils . data . DataLoader ( val_dataset , batch_size = 1 )

# Step 1: Initialize transformation function
def transform_fn ( data_item ):
    images , _ = data_item
    return images

# Step 2: Initialize NNCF Dataset
calibration_dataset = nncf . Dataset ( dataset_loader , transform_fn )
# Step 3: Run the quantization pipeline
quantized_model = nncf . quantize ( model , calibration_dataset )

PyTorch

 import nncf
import torch
from torchvision import datasets , models

# Instantiate your uncompressed model
model = models . mobilenet_v2 ()

# Provide validation part of the dataset to collect statistics needed for the compression algorithm
val_dataset = datasets . ImageFolder ( "/path" , transform = transforms . Compose ([ transforms . ToTensor ()]))
dataset_loader = torch . utils . data . DataLoader ( val_dataset )

# Step 1: Initialize the transformation function
def transform_fn ( data_item ):
    images , _ = data_item
    return images

# Step 2: Initialize NNCF Dataset
calibration_dataset = nncf . Dataset ( dataset_loader , transform_fn )
# Step 3: Run the quantization pipeline
quantized_model = nncf . quantize ( model , calibration_dataset )

NOTA Si el algoritmo de cuantificación posterior al entrenamiento no cumple con los requisitos de calidad, puede ajustar el modelo de pytorch cuantificado. Puede encontrar un ejemplo del proceso de capacitación con reconocimiento de cuantificación para un modelo de pytorch aquí.

AntorchaFX

 import nncf
import torch . fx
from torchvision import datasets , models
from nncf . torch import disable_patching

# Instantiate your uncompressed model
model = models . mobilenet_v2 ()

# Provide validation part of the dataset to collect statistics needed for the compression algorithm
val_dataset = datasets . ImageFolder ( "/path" , transform = transforms . Compose ([ transforms . ToTensor ()]))
dataset_loader = torch . utils . data . DataLoader ( val_dataset )

# Step 1: Initialize the transformation function
def transform_fn ( data_item ):
    images , _ = data_item
    return images

# Step 2: Initialize NNCF Dataset
calibration_dataset = nncf . Dataset ( dataset_loader , transform_fn )

# Step 3: Export model to TorchFX
input_shape = ( 1 , 3 , 224 , 224 )
with nncf . torch . disable_patching ():
    fx_model = torch . export . export_for_training ( model , args = ( ex_input ,)). module ()
    # or
    # fx_model = torch.export.export(model, args=(ex_input,)).module()

    # Step 4: Run the quantization pipeline
    quantized_fx_model = nncf . quantize ( fx_model , calibration_dataset )

TensorFlow

 import nncf
import tensorflow as tf
import tensorflow_datasets as tfds

# Instantiate your uncompressed model
model = tf . keras . applications . MobileNetV2 ()

# Provide validation part of the dataset to collect statistics needed for the compression algorithm
val_dataset = tfds . load ( "/path" , split = "validation" ,
                        shuffle_files = False , as_supervised = True )

# Step 1: Initialize transformation function
def transform_fn ( data_item ):
    images , _ = data_item
    return images

# Step 2: Initialize NNCF Dataset
calibration_dataset = nncf . Dataset ( val_dataset , transform_fn )
# Step 3: Run the quantization pipeline
quantized_model = nncf . quantize ( model , calibration_dataset )

ONNX

 import onnx
import nncf
import torch
from torchvision import datasets

# Instantiate your uncompressed model
onnx_model = onnx . load_model ( "/model_path" )

# Provide validation part of the dataset to collect statistics needed for the compression algorithm
val_dataset = datasets . ImageFolder ( "/path" , transform = transforms . Compose ([ transforms . ToTensor ()]))
dataset_loader = torch . utils . data . DataLoader ( val_dataset , batch_size = 1 )

# Step 1: Initialize transformation function
input_name = onnx_model . graph . input [ 0 ]. name
def transform_fn ( data_item ):
    images , _ = data_item
    return { input_name : images . numpy ()}

# Step 2: Initialize NNCF Dataset
calibration_dataset = nncf . Dataset ( dataset_loader , transform_fn )
# Step 3: Run the quantization pipeline
quantized_model = nncf . quantize ( onnx_model , calibration_dataset )

Cuantización del tiempo de entrenamiento

A continuación se muestra un ejemplo de canalización de cuantificación consciente de la precisión donde los pesos del modelo y los parámetros de compresión se pueden ajustar para lograr una mayor precisión.

PyTorch

 import nncf
import torch
from torchvision import datasets , models

# Instantiate your uncompressed model
model = models . mobilenet_v2 ()

# Provide validation part of the dataset to collect statistics needed for the compression algorithm
val_dataset = datasets . ImageFolder ( "/path" , transform = transforms . Compose ([ transforms . ToTensor ()]))
dataset_loader = torch . utils . data . DataLoader ( val_dataset )

# Step 1: Initialize the transformation function
def transform_fn ( data_item ):
    images , _ = data_item
    return images

# Step 2: Initialize NNCF Dataset
calibration_dataset = nncf . Dataset ( dataset_loader , transform_fn )
# Step 3: Run the quantization pipeline
quantized_model = nncf . quantize ( model , calibration_dataset )

# Now use compressed_model as a usual torch.nn.Module
# to fine-tune compression parameters along with the model weights

# Save quantization modules and the quantized model parameters
checkpoint = {
    'state_dict' : model . state_dict (),
    'nncf_config' : model . nncf . get_config (),
    ... # the rest of the user-defined objects to save
}
torch . save ( checkpoint , path_to_checkpoint )

# ...

# Load quantization modules and the quantized model parameters
resuming_checkpoint = torch . load ( path_to_checkpoint )
nncf_config = resuming_checkpoint [ 'nncf_config' ]
state_dict = resuming_checkpoint [ 'state_dict' ]

quantized_model = nncf . torch . load_from_config ( model , nncf_config , example_input )
model . load_state_dict ( state_dict )
# ... the rest of the usual PyTorch-powered training pipeline

Compresión del tiempo de entrenamiento

A continuación se muestra un ejemplo de canalización de Sparsification de RB Accuracy Aware donde los pesos del modelo y los parámetros de compresión se pueden ajustar para lograr una mayor precisión.

PyTorch

 import torch
import nncf . torch  # Important - must be imported before any other external package that depends on torch

from nncf import NNCFConfig
from nncf . torch import create_compressed_model , register_default_init_args

# Instantiate your uncompressed model
from torchvision . models . resnet import resnet50
model = resnet50 ()

# Load a configuration file to specify compression
nncf_config = NNCFConfig . from_json ( "resnet50_imagenet_rb_sparsity.json" )

# Provide data loaders for compression algorithm initialization, if necessary
import torchvision . datasets as datasets
representative_dataset = datasets . ImageFolder ( "/path" , transform = transforms . Compose ([ transforms . ToTensor ()]))
init_loader = torch . utils . data . DataLoader ( representative_dataset )
nncf_config = register_default_init_args ( nncf_config , init_loader )

# Apply the specified compression algorithms to the model
compression_ctrl , compressed_model = create_compressed_model ( model , nncf_config )

# Now use compressed_model as a usual torch.nn.Module
# to fine-tune compression parameters along with the model weights

# ... the rest of the usual PyTorch-powered training pipeline

# Export to ONNX or .pth when done fine-tuning
compression_ctrl . export_model ( "compressed_model.onnx" )
torch . save ( compressed_model . state_dict (), "compressed_model.pth" )

NOTA (PyTorch) : debido a la forma en que funciona NNCF dentro del backend de PyTorch, import nncf debe realizarse antes de cualquier otra importación de torch en su paquete o en paquetes de terceros que utilice su código. De lo contrario, es posible que la compresión se aplique de forma incompleta.

flujo tensor

 import tensorflow as tf

from nncf import NNCFConfig
from nncf . tensorflow import create_compressed_model , register_default_init_args

# Instantiate your uncompressed model
from tensorflow . keras . applications import ResNet50
model = ResNet50 ()

# Load a configuration file to specify compression
nncf_config = NNCFConfig . from_json ( "resnet50_imagenet_rb_sparsity.json" )

# Provide dataset for compression algorithm initialization
representative_dataset = tf . data . Dataset . list_files ( "/path/*.jpeg" )
nncf_config = register_default_init_args ( nncf_config , representative_dataset , batch_size = 1 )

# Apply the specified compression algorithms to the model
compression_ctrl , compressed_model = create_compressed_model ( model , nncf_config )

# Now use compressed_model as a usual Keras model
# to fine-tune compression parameters along with the model weights

# ... the rest of the usual TensorFlow-powered training pipeline

# Export to Frozen Graph, TensorFlow SavedModel or .h5  when done fine-tuning
compression_ctrl . export_model ( "compressed_model.pb" , save_format = "frozen_graph" )

Para obtener una descripción más detallada del uso de NNCF en su código de entrenamiento, consulte este tutorial.

Demostraciones, tutoriales y muestras

Para comenzar más rápido con la compresión impulsada por NNCF, pruebe los cuadernos y scripts de muestra que se presentan a continuación.

Tutoriales y demostraciones de Jupyter* Notebook

Hay disponibles demostraciones y tutoriales de portátiles Jupyter* listos para ejecutar para explicar y mostrar los algoritmos de compresión NNCF para optimizar modelos para inferencia con OpenVINO Toolkit:

Nombre del tutorial del cuaderno	Algoritmo de compresión	backend	Dominio
Cuantización BERT	Cuantización post-entrenamiento	AbiertoVINO	PNL
Cuantización del modelo de segmentación MONAI	Cuantización post-entrenamiento	AbiertoVINO	Segmentación
Cuantización del modelo PyTorch	Cuantización post-entrenamiento	PyTorch	Clasificación de imágenes
Cuantización con control de precisión	Cuantización post-entrenamiento con control de precisión	AbiertoVINO	voz a texto, Detección de objetos
Compresión del tiempo de entrenamiento de PyTorch	Compresión del tiempo de entrenamiento	PyTorch	Clasificación de imágenes
Compresión del tiempo de entrenamiento de TensorFlow	Compresión del tiempo de entrenamiento	flujo tensor	Clasificación de imágenes
Poda, cuantificación y destilación conjuntas para BERT	Poda, Cuantización y Destilación Conjuntas	AbiertoVINO	PNL

Una lista de cuadernos que demuestran la conversión e inferencia de OpenVINO junto con la compresión NNCF para modelos de varios dominios:

Modelo de demostración	Algoritmo de compresión	backend	Dominio
YOLOv8	Cuantización post-entrenamiento	AbiertoVINO	detección de objetos, detección de puntos clave, Segmentación de instancias
EficienteSAM	Cuantización post-entrenamiento	AbiertoVINO	Segmentación de imágenes
Segmentar cualquier modelo	Cuantización post-entrenamiento	AbiertoVINO	Segmentación de imágenes
uno ex	Cuantización post-entrenamiento	AbiertoVINO	Segmentación de imágenes
InstruirPix2Pix	Cuantización post-entrenamiento	AbiertoVINO	Imagen a imagen
ACORTAR	Cuantización post-entrenamiento	AbiertoVINO	Imagen a texto
PUNTO LUMINOSO EN UN RADAR	Cuantización post-entrenamiento	AbiertoVINO	Imagen a texto
Modelo de consistencia latente	Cuantización post-entrenamiento	AbiertoVINO	Texto a imagen
Monstruo del código QR de ControlNet	Cuantización post-entrenamiento	AbiertoVINO	Texto a imagen
SDXL-turbo	Cuantización post-entrenamiento	AbiertoVINO	texto a imagen, Imagen a imagen
Destilar-Susurro	Cuantización post-entrenamiento	AbiertoVINO	Voz a texto
Susurro	Cuantización post-entrenamiento	AbiertoVINO	Voz a texto
Reconocimiento de voz MMS	Cuantización post-entrenamiento	AbiertoVINO	Voz a texto
Corrección de errores gramaticales	Cuantización post-entrenamiento	AbiertoVINO	PNL, corrección gramatical
Seguimiento de instrucciones de LLM	Compresión de peso	AbiertoVINO	PNL, seguimiento de instrucciones
Bots de chat de LLM	Compresión de peso	AbiertoVINO	PNL, chatbot

Ejemplos de cuantización post-entrenamiento

Scripts compactos que demuestran la cuantificación y el correspondiente aumento de velocidad de inferencia:

Nombre de ejemplo	Algoritmo de compresión	backend	Dominio
OpenVINO MobileNetV2	Cuantización post-entrenamiento	AbiertoVINO	Clasificación de imágenes
OpenVINO YOLOv8	Cuantización post-entrenamiento	AbiertoVINO	Detección de objetos
OpenVINO YOLOv8 QwAС	Cuantización post-entrenamiento con control de precisión	AbiertoVINO	Detección de objetos
Clasificación de anomalías de OpenVINO	Cuantización post-entrenamiento con control de precisión	AbiertoVINO	Clasificación de anomalías
PyTorch MobileNetV2	Cuantización post-entrenamiento	PyTorch	Clasificación de imágenes
SSD PyTorch	Cuantización post-entrenamiento	PyTorch	Detección de objetos
AntorchaFX Resnet18	Cuantización post-entrenamiento	AntorchaFX	Clasificación de imágenes
TensorFlow MobileNetV2	Cuantización post-entrenamiento	TensorFlow	Clasificación de imágenes
ONNX MobileNetV2	Cuantización post-entrenamiento	ONNX	Clasificación de imágenes

Ejemplos de compresión del tiempo de entrenamiento

Ejemplos de canalizaciones completas que incluyen compresión, entrenamiento e inferencia para tareas de clasificación, detección y segmentación:

Nombre de ejemplo	Algoritmo de compresión	backend	Dominio
Clasificación de imágenes de PyTorch	Compresión del tiempo de entrenamiento	PyTorch	Clasificación de imágenes
Detección de objetos PyTorch	Compresión del tiempo de entrenamiento	PyTorch	Detección de objetos
Segmentación semántica de PyTorch	Compresión del tiempo de entrenamiento	PyTorch	Segmentación semántica
Clasificación de imágenes de TensorFlow	Compresión del tiempo de entrenamiento	TensorFlow	Clasificación de imágenes
Detección de objetos TensorFlow	Compresión del tiempo de entrenamiento	TensorFlow	Detección de objetos
Segmentación de instancias de TensorFlow	Compresión del tiempo de entrenamiento	TensorFlow	Segmentación de instancias

Integración de repositorios de terceros

NNCF se puede integrar fácilmente en procesos de capacitación/evaluación de repositorios de terceros.

Utilizado por

Extensiones de formación OpenVINO
NNCF está integrado en OpenVINO Training Extensions como un backend de optimización del modelo. Puede entrenar, optimizar y exportar nuevos modelos basados en las plantillas de modelos disponibles, así como ejecutar los modelos exportados con OpenVINO.
HuggingFace Optimum Intel
NNCF se utiliza como backend de compresión dentro del renombrado repositorio transformers en HuggingFace Optimum Intel.

Guía de instalación

Para obtener instrucciones de instalación detalladas, consulte la guía de instalación.

NNCF se puede instalar como un paquete PyPI normal mediante pip:

pip install nncf

NNCF también está disponible a través de conda:

conda install -c conda-forge nncf

Requisitos del sistema

Ubuntu* 18.04 o posterior (64 bits)
Python* 3.9 o posterior
Marcos soportados:
- PyTorch* >=2.4, <2.6
- TensorFlow* >=2.8.4, <=2.15.1
- ONNX* ==1.17.0
- OpenVINO* >=2022.3.0

Este repositorio se prueba en Python* 3.10.14, PyTorch* 2.5.0 (NVidia CUDA* Toolkit 12.4) y TensorFlow* 2.12.1 (NVidia CUDA* Toolkit 11.8).

NNCF Zoológico modelo NNCF comprimido

La lista de modelos y los resultados de compresión para ellos se pueden encontrar en nuestra página NNCF Model Zoo.

Citando

@ article{kozlov2020neural,
    title =   {Neural network compression framework for fast model inference},
    author =  {Kozlov, Alexander and Lazarevich, Ivan and Shamporov, Vasily and Lyalyushkin, Nikolay and Gorbachev, Yury},
    journal = {arXiv preprint arXiv: 2002.08679 },
    year =    { 2020 }
}

Guía contribuyente

Consulte el archivo CONTRIBUTING.md para obtener pautas sobre las contribuciones al repositorio de NNCF.

Enlaces útiles

Documentación
Scripts de ejemplo (objetos modelo disponibles a través de enlaces en los respectivos archivos README.md):
- PyTorch
- TensorFlow
Preguntas frecuentes
Cuadernos
HuggingFace Optimum Intel
Guía de optimización del modelo OpenVINO

Telemetria

NNCF, como parte del kit de herramientas OpenVINO™, recopila datos de uso anónimos con el fin de mejorar las herramientas OpenVINO™. Puede optar por no participar en cualquier momento ejecutando el siguiente comando en el entorno Python donde tiene instalado NNCF:

opt_in_out --opt_out

Más información disponible sobre telemetría OpenVINO.

Expandir

Información adicional