nncf
v2.14.0
Hauptmerkmale • Installation • Dokumentation • Verwendung • Tutorials und Beispiele • Integration von Drittanbietern • Model Zoo
Das Neural Network Compression Framework (NNCF) bietet eine Reihe von Post-Training- und Trainingsalgorithmen zur Optimierung der Inferenz neuronaler Netze in OpenVINO™ mit minimalem Genauigkeitsabfall.
NNCF ist für die Zusammenarbeit mit Modellen von PyTorch, TorchFX, TensorFlow, ONNX und OpenVINO™ konzipiert.
NNCF stellt Beispiele bereit, die die Verwendung von Komprimierungsalgorithmen für verschiedene Anwendungsfälle und Modelle veranschaulichen. Sehen Sie sich die mit den NNCF-basierten Beispielen erreichbaren Komprimierungsergebnisse auf der Seite „NNCF Model Zoo“ an.
Das Framework ist als Python*-Paket organisiert, das im Standalone-Modus erstellt und verwendet werden kann. Die Framework-Architektur ist vereinheitlicht, um das Hinzufügen verschiedener Komprimierungsalgorithmen für die Deep-Learning-Frameworks PyTorch und TensorFlow zu vereinfachen.
| Komprimierungsalgorithmus | OpenVINO | PyTorch | TorchFX | TensorFlow | ONNX |
|---|---|---|---|---|---|
| Quantisierung nach dem Training | Unterstützt | Unterstützt | Experimental | Unterstützt | Unterstützt |
| Gewichtskompression | Unterstützt | Unterstützt | Experimental | Nicht unterstützt | Nicht unterstützt |
| Aktivierungsparsity | Nicht unterstützt | Experimental | Nicht unterstützt | Nicht unterstützt | Nicht unterstützt |
| Komprimierungsalgorithmus | PyTorch | TensorFlow |
|---|---|---|
| Quantisierungsbewusstes Training | Unterstützt | Unterstützt |
| Quantisierung mit gemischter Präzision | Unterstützt | Nicht unterstützt |
| Sparsamkeit | Unterstützt | Unterstützt |
| Filterbeschneidung | Unterstützt | Unterstützt |
| Bewegungsbeschneidung | Experimental | Nicht unterstützt |
HINWEIS : Begrenzte Unterstützung für TensorFlow-Modelle. Es werden nur Modelle unterstützt, die mit Sequential oder Keras Functional API erstellt wurden.
Diese Dokumentation enthält detaillierte Informationen zu NNCF-Algorithmen und -Funktionen, die für den Beitrag zu NNCF erforderlich sind.
Die neueste Benutzerdokumentation für NNCF ist hier verfügbar.
Die NNCF-API-Dokumentation finden Sie hier.
Der NNCF PTQ ist die einfachste Möglichkeit, eine 8-Bit-Quantisierung anzuwenden. Um den Algorithmus auszuführen, benötigen Sie lediglich Ihr Modell und einen kleinen Kalibrierungsdatensatz (ca. 300 Proben).
OpenVINO ist das bevorzugte Backend für die Ausführung von PTQ, während PyTorch, TensorFlow und ONNX ebenfalls unterstützt werden.
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 )HINWEIS Wenn der Post-Training-Quantisierungsalgorithmus die Qualitätsanforderungen nicht erfüllt, können Sie das quantisierte Pytorch-Modell feinabstimmen. Ein Beispiel für die Quantization-Aware-Trainingspipeline für ein Pytorch-Modell finden Sie hier.
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 )Hier ist ein Beispiel einer Accuracy Aware Quantization-Pipeline, bei der Modellgewichte und Komprimierungsparameter fein abgestimmt werden können, um eine höhere Genauigkeit zu erreichen.
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 pipelineHier ist ein Beispiel einer Accuracy Aware RB Sparsification-Pipeline, bei der Modellgewichte und Komprimierungsparameter fein abgestimmt werden können, um eine höhere Genauigkeit zu erreichen.
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" ) HINWEIS (PyTorch) : Aufgrund der Art und Weise, wie NNCF im PyTorch-Backend funktioniert, muss import nncf vor jedem anderen Import von torch in Ihr Paket oder in Paketen von Drittanbietern, die Ihr Code verwendet, erfolgen. Andernfalls wird die Komprimierung möglicherweise unvollständig angewendet.
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" )Eine detailliertere Beschreibung der NNCF-Nutzung in Ihrem Trainingscode finden Sie in diesem Tutorial.
Für einen schnelleren Einstieg in die NNCF-gestützte Komprimierung probieren Sie die unten aufgeführten Beispielnotizbücher und -skripte aus.
Zur Erläuterung und Anzeige von NNCF-Komprimierungsalgorithmen zur Optimierung von Modellen für die Inferenz mit dem OpenVINO Toolkit stehen betriebsbereite Jupyter*-Notebook-Tutorials und Demos zur Verfügung:
| Name des Notebook-Tutorials | Komprimierungsalgorithmus | Backend | Domain |
|---|---|---|---|
| BERT-Quantisierung | Quantisierung nach dem Training | OpenVINO | NLP |
| Quantisierung des MONAI-Segmentierungsmodells | Quantisierung nach dem Training | OpenVINO | Segmentierung |
| PyTorch-Modellquantisierung | Quantisierung nach dem Training | PyTorch | Bildklassifizierung |
| Quantisierung mit Genauigkeitskontrolle | Quantisierung nach dem Training mit Genauigkeitskontrolle | OpenVINO | Speech-to-Text, Objekterkennung |
| PyTorch-Trainingszeitkomprimierung | Trainingszeitkomprimierung | PyTorch | Bildklassifizierung |
| TensorFlow-Trainingszeitkomprimierung | Trainingszeitkomprimierung | Tensorflow | Bildklassifizierung |
| Gemeinsames Beschneiden, Quantisieren und Destillieren für BERT | Gemeinsames Beschneiden, Quantisieren und Destillieren | OpenVINO | NLP |
Eine Liste von Notebooks, die die OpenVINO-Konvertierung und -Inferenz zusammen mit der NNCF-Komprimierung für Modelle aus verschiedenen Domänen demonstrieren:
| Demomodell | Komprimierungsalgorithmus | Backend | Domain |
|---|---|---|---|
| YOLOv8 | Quantisierung nach dem Training | OpenVINO | Objekterkennung, KeyPoint-Erkennung, Instanzsegmentierung |
| Effizientes SAM | Quantisierung nach dem Training | OpenVINO | Bildsegmentierung |
| Segment Anything-Modell | Quantisierung nach dem Training | OpenVINO | Bildsegmentierung |
| OneFormer | Quantisierung nach dem Training | OpenVINO | Bildsegmentierung |
| InstructPix2Pix | Quantisierung nach dem Training | OpenVINO | Bild-zu-Bild |
| CLIP | Quantisierung nach dem Training | OpenVINO | Bild-zu-Text |
| BLIP | Quantisierung nach dem Training | OpenVINO | Bild-zu-Text |
| Modell der latenten Konsistenz | Quantisierung nach dem Training | OpenVINO | Text-zu-Bild |
| ControlNet QR-Code-Monster | Quantisierung nach dem Training | OpenVINO | Text-zu-Bild |
| SDXL-Turbo | Quantisierung nach dem Training | OpenVINO | Text-zu-Bild, Bild-zu-Bild |
| Destillieren-Flüstern | Quantisierung nach dem Training | OpenVINO | Speech-to-Text |
| Flüstern | Quantisierung nach dem Training | OpenVINO | Speech-to-Text |
| MMS-Spracherkennung | Quantisierung nach dem Training | OpenVINO | Speech-to-Text |
| Korrektur von Grammatikfehlern | Quantisierung nach dem Training | OpenVINO | NLP, Grammatikkorrektur |
| Nachfolgende LLM-Anweisungen | Gewichtskompression | OpenVINO | NLP, Anleitung befolgen |
| LLM-Chat-Bots | Gewichtskompression | OpenVINO | NLP, Chatbot |
Kompakte Skripte, die die Quantisierung und die entsprechende Steigerung der Inferenzgeschwindigkeit demonstrieren:
| Beispielname | Komprimierungsalgorithmus | Backend | Domain |
|---|---|---|---|
| OpenVINO MobileNetV2 | Quantisierung nach dem Training | OpenVINO | Bildklassifizierung |
| OpenVINO YOlov8 | Quantisierung nach dem Training | OpenVINO | Objekterkennung |
| OpenVINO YOlov8 QwAС | Quantisierung nach dem Training mit Genauigkeitskontrolle | OpenVINO | Objekterkennung |
| OpenVINO-Anomalieklassifizierung | Quantisierung nach dem Training mit Genauigkeitskontrolle | OpenVINO | Anomalieklassifizierung |
| PyTorch MobileNetV2 | Quantisierung nach dem Training | PyTorch | Bildklassifizierung |
| PyTorch-SSD | Quantisierung nach dem Training | PyTorch | Objekterkennung |
| TorchFX Resnet18 | Quantisierung nach dem Training | TorchFX | Bildklassifizierung |
| TensorFlow MobileNetV2 | Quantisierung nach dem Training | TensorFlow | Bildklassifizierung |
| ONNX MobileNetV2 | Quantisierung nach dem Training | ONNX | Bildklassifizierung |
Beispiele für vollständige Pipelines einschließlich Komprimierung, Training und Inferenz für Klassifizierungs-, Erkennungs- und Segmentierungsaufgaben:
| Beispielname | Komprimierungsalgorithmus | Backend | Domain |
|---|---|---|---|
| PyTorch-Bildklassifizierung | Trainingszeitkomprimierung | PyTorch | Bildklassifizierung |
| PyTorch-Objekterkennung | Trainingszeitkomprimierung | PyTorch | Objekterkennung |
| Semantische Segmentierung von PyTorch | Trainingszeitkomprimierung | PyTorch | Semantische Segmentierung |
| TensorFlow-Bildklassifizierung | Trainingszeitkomprimierung | TensorFlow | Bildklassifizierung |
| TensorFlow-Objekterkennung | Trainingszeitkomprimierung | TensorFlow | Objekterkennung |
| TensorFlow-Instanzsegmentierung | Trainingszeitkomprimierung | TensorFlow | Instanzsegmentierung |
NNCF kann problemlos in Trainings-/Evaluierungspipelines von Drittanbieter-Repositories integriert werden.
OpenVINO-Schulungserweiterungen
NNCF ist als Modelloptimierungs-Backend in OpenVINO Training Extensions integriert. Sie können neue Modelle basierend auf verfügbaren Modellvorlagen trainieren, optimieren und exportieren sowie die exportierten Modelle mit OpenVINO ausführen.
HuggingFace Optimum Intel
NNCF wird als Komprimierungs-Backend im renommierten transformers -Repository in HuggingFace Optimum Intel verwendet.
Ausführliche Installationsanweisungen finden Sie im Installationshandbuch.
NNCF kann als reguläres PyPI-Paket über pip installiert werden:
pip install nncfNNCF ist auch über Conda verfügbar:
conda install -c conda-forge nncfDieses Repository wurde auf Python* 3.10.14, PyTorch* 2.5.0 (NVidia CUDA* Toolkit 12.4) und TensorFlow* 2.12.1 (NVidia CUDA* Toolkit 11.8) getestet.
Eine Liste der Modelle und deren Komprimierungsergebnisse finden Sie auf unserer NNCF Model Zoo-Seite.
@ 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 }
} Richtlinien zu Beiträgen zum NNCF-Repository finden Sie in der Datei CONTRIBUTING.md.
NNCF sammelt als Teil des OpenVINO™-Toolkits anonyme Nutzungsdaten zum Zweck der Verbesserung der OpenVINO™-Tools. Sie können sich jederzeit abmelden, indem Sie den folgenden Befehl in der Python-Umgebung ausführen, in der Sie NNCF installiert haben:
opt_in_out --opt_out
Weitere Informationen zur OpenVINO-Telemetrie.
