nncf
v2.14.0
Fonctionnalités clés • Installation • Documentation • Utilisation • Tutoriels et exemples • Intégration tierce • Model Zoo
Neural Network Compression Framework (NNCF) fournit une suite d'algorithmes de post-formation et de temps de formation pour optimiser l'inférence des réseaux de neurones dans OpenVINO™ avec une perte de précision minimale.
NNCF est conçu pour fonctionner avec les modèles de PyTorch, TorchFX, TensorFlow, ONNX et OpenVINO™.
NNCF fournit des exemples qui démontrent l'utilisation d'algorithmes de compression pour différents cas d'utilisation et modèles. Consultez les résultats de compression réalisables avec les exemples basés sur NNCF sur la page NNCF Model Zoo.
Le framework est organisé sous la forme d'un package Python* qui peut être construit et utilisé en mode autonome. L'architecture du framework est unifiée pour faciliter l'ajout de différents algorithmes de compression pour les frameworks d'apprentissage en profondeur PyTorch et TensorFlow.
| Algorithme de compression | OuvrirVINO | PyTorch | TorchFX | TensorFlow | ONNX |
|---|---|---|---|---|---|
| Quantification post-formation | Soutenu | Soutenu | Expérimental | Soutenu | Soutenu |
| Compression des poids | Soutenu | Soutenu | Expérimental | Non pris en charge | Non pris en charge |
| Rareté d'activation | Non pris en charge | Expérimental | Non pris en charge | Non pris en charge | Non pris en charge |
| Algorithme de compression | PyTorch | TensorFlow |
|---|---|---|
| Formation prenant en compte la quantification | Soutenu | Soutenu |
| Quantification à précision mixte | Soutenu | Non pris en charge |
| Rareté | Soutenu | Soutenu |
| Taille de filtre | Soutenu | Soutenu |
| Taille de mouvement | Expérimental | Non pris en charge |
REMARQUE : prise en charge limitée des modèles TensorFlow. Seuls les modèles créés à l'aide de l'API fonctionnelle Sequential ou Keras sont pris en charge.
Cette documentation couvre des informations détaillées sur les algorithmes et les fonctions NNCF nécessaires à la contribution à NNCF.
La dernière documentation utilisateur de NNCF est disponible ici.
La documentation de l'API NNCF peut être trouvée ici.
Le NNCF PTQ est le moyen le plus simple d'appliquer une quantification sur 8 bits. Pour exécuter l'algorithme, vous n'avez besoin que de votre modèle et d'un petit ensemble de données d'étalonnage (~ 300 échantillons).
OpenVINO est le backend préféré pour exécuter PTQ, tandis que PyTorch, TensorFlow et ONNX sont également pris en charge.
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 ) 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 )REMARQUE Si l'algorithme de quantification post-formation ne répond pas aux exigences de qualité, vous pouvez affiner le modèle pytorch quantifié. Vous pouvez trouver un exemple du pipeline de formation Quantization-Aware pour un modèle pytorch ici.
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 ) 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 ) 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 )Voici un exemple de pipeline de quantification sensible à la précision dans lequel les poids du modèle et les paramètres de compression peuvent être ajustés pour obtenir une plus grande précision.
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 pipelineVoici un exemple de pipeline de sparsification Accuracy Aware RB où les poids du modèle et les paramètres de compression peuvent être ajustés pour obtenir une plus grande précision.
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" ) REMARQUE (PyTorch) : En raison de la façon dont NNCF fonctionne dans le backend PyTorch, import nncf doit être effectuée avant toute autre importation de torch dans votre package ou dans des packages tiers que votre code utilise. Sinon, la compression pourrait être appliquée de manière incomplète.
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" )Pour une description plus détaillée de l’utilisation de NNCF dans votre code de formation, consultez ce didacticiel.
Pour démarrer plus rapidement avec la compression basée sur NNCF, essayez les exemples de blocs-notes et de scripts présentés ci-dessous.
Des didacticiels et des démos de notebook Jupyter* prêts à l'emploi sont disponibles pour expliquer et afficher les algorithmes de compression NNCF afin d'optimiser les modèles pour l'inférence avec la boîte à outils OpenVINO :
| Nom du didacticiel du bloc-notes | Algorithme de compression | Back-end | Domaine |
|---|---|---|---|
| Quantification BERT | Quantification post-formation | OuvrirVINO | PNL |
| Quantification du modèle de segmentation MONAI | Quantification post-formation | OuvrirVINO | Segmentation |
| Quantification du modèle PyTorch | Quantification post-formation | PyTorch | Classement des images |
| Quantification avec contrôle de précision | Quantification post-formation avec contrôle de précision | OuvrirVINO | synthèse vocale, Détection d'objet |
| Compression du temps de formation PyTorch | Compression du temps d'entraînement | PyTorch | Classement des images |
| Compression du temps d'entraînement TensorFlow | Compression du temps d'entraînement | Flux tensoriel | Classement des images |
| Taille conjointe, quantification et distillation pour BERT | Taille conjointe, quantification et distillation | OuvrirVINO | PNL |
Une liste de blocs-notes démontrant la conversion et l'inférence OpenVINO ainsi que la compression NNCF pour les modèles de divers domaines :
| Modèle de démonstration | Algorithme de compression | Back-end | Domaine |
|---|---|---|---|
| YOLOv8 | Quantification post-formation | OuvrirVINO | Détection d'objets, Détection des points clés, Segmentation des instances |
| SAM efficace | Quantification post-formation | OuvrirVINO | Segmentation d'images |
| Segmenter n'importe quel modèle | Quantification post-formation | OuvrirVINO | Segmentation d'images |
| Unancien | Quantification post-formation | OuvrirVINO | Segmentation d'images |
| InstruirePix2Pix | Quantification post-formation | OuvrirVINO | Image à image |
| AGRAFE | Quantification post-formation | OuvrirVINO | Image en texte |
| SPOT | Quantification post-formation | OuvrirVINO | Image en texte |
| Modèle de cohérence latente | Quantification post-formation | OuvrirVINO | Texte en image |
| Monstre de code QR ControlNet | Quantification post-formation | OuvrirVINO | Texte en image |
| SDXL-turbo | Quantification post-formation | OuvrirVINO | Texte à image, Image à image |
| Distiller-chuchoter | Quantification post-formation | OuvrirVINO | Parole en texte |
| Chuchoter | Quantification post-formation | OuvrirVINO | Parole en texte |
| Reconnaissance vocale MMS | Quantification post-formation | OuvrirVINO | Parole en texte |
| Correction des erreurs de grammaire | Quantification post-formation | OuvrirVINO | PNL, correction grammaticale |
| Instruction LLM suivante | Compression du poids | OuvrirVINO | PNL, suivi d'instruction |
| Bots de discussion LLM | Compression du poids | OuvrirVINO | PNL, Chat Bot |
Scripts compacts démontrant la quantification et l'augmentation de la vitesse d'inférence correspondante :
| Exemple de nom | Algorithme de compression | Back-end | Domaine |
|---|---|---|---|
| OpenVINO MobileNetV2 | Quantification post-formation | OuvrirVINO | Classement des images |
| OuvrirVINO YOLOv8 | Quantification post-formation | OuvrirVINO | Détection d'objet |
| OpenVINO YOLOv8 QwAС | Quantification post-formation avec contrôle de précision | OuvrirVINO | Détection d'objet |
| Classification des anomalies OpenVINO | Quantification post-formation avec contrôle de précision | OuvrirVINO | Classification des anomalies |
| PyTorch MobileNetV2 | Quantification post-formation | PyTorch | Classement des images |
| SSD PyTorch | Quantification post-formation | PyTorch | Détection d'objet |
| TorchFX Resnet18 | Quantification post-formation | TorchFX | Classement des images |
| TensorFlow MobileNetV2 | Quantification post-formation | TensorFlow | Classement des images |
| ONNX MobileNetV2 | Quantification post-formation | ONNX | Classement des images |
Exemples de pipelines complets comprenant la compression, la formation et l'inférence pour les tâches de classification, de détection et de segmentation :
| Exemple de nom | Algorithme de compression | Back-end | Domaine |
|---|---|---|---|
| Classification des images PyTorch | Compression du temps d'entraînement | PyTorch | Classement des images |
| Détection d'objets PyTorch | Compression du temps d'entraînement | PyTorch | Détection d'objet |
| Segmentation sémantique PyTorch | Compression du temps d'entraînement | PyTorch | Segmentation sémantique |
| Classification des images TensorFlow | Compression du temps d'entraînement | TensorFlow | Classement des images |
| Détection d'objets TensorFlow | Compression du temps d'entraînement | TensorFlow | Détection d'objet |
| Segmentation des instances TensorFlow | Compression du temps d'entraînement | TensorFlow | Segmentation des instances |
NNCF peut être facilement intégré aux pipelines de formation/évaluation de référentiels tiers.
Extensions de formation OpenVINO
NNCF est intégré à OpenVINO Training Extensions en tant que backend d'optimisation de modèle. Vous pouvez entraîner, optimiser et exporter de nouveaux modèles en fonction des modèles de modèles disponibles, ainsi qu'exécuter les modèles exportés avec OpenVINO.
HuggingFace Intel optimal
NNCF est utilisé comme backend de compression dans le célèbre référentiel transformers dans HuggingFace Optimum Intel.
Pour des instructions d'installation détaillées, reportez-vous au guide d'installation.
NNCF peut être installé en tant que package PyPI standard via pip :
pip install nncfNNCF est également disponible via conda :
conda install -c conda-forge nncfCe référentiel est testé sur Python* 3.10.14, PyTorch* 2.5.0 (NVidia CUDA* Toolkit 12.4) et TensorFlow* 2.12.1 (NVidia CUDA* Toolkit 11.8).
La liste des modèles et leurs résultats de compression sont disponibles sur notre page NNCF Model Zoo.
@ 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 }
} Reportez-vous au fichier CONTRIBUTING.md pour obtenir des directives sur les contributions au référentiel NNCF.
NNCF, dans le cadre de la boîte à outils OpenVINO™, collecte des données d'utilisation anonymes dans le but d'améliorer les outils OpenVINO™. Vous pouvez vous désinscrire à tout moment en exécutant la commande suivante dans l'environnement Python sur lequel NNCF est installé :
opt_in_out --opt_out
Plus d'informations disponibles sur la télémétrie OpenVINO.
