Download nncf - download do código-fonte nncf

nncf

Código-Fonte de IA

v2.14.0

Baixar

Estrutura de compressão de rede neural (NNCF)

Principais recursos • Instalação • Documentação • Uso • Tutoriais e amostras • Integração de terceiros • Model Zoo

O Neural Network Compression Framework (NNCF) fornece um conjunto de algoritmos pós-treinamento e de tempo de treinamento para otimizar a inferência de redes neurais no OpenVINO™ com uma queda mínima de precisão.

O NNCF foi projetado para funcionar com modelos PyTorch, TorchFX, TensorFlow, ONNX e OpenVINO™.

NNCF fornece exemplos que demonstram o uso de algoritmos de compactação para diferentes casos de uso e modelos. Veja os resultados de compactação obtidos com as amostras baseadas em NNCF na página NNCF Model Zoo.

A estrutura é organizada como um pacote Python* que pode ser construído e usado em modo independente. A arquitetura da estrutura é unificada para facilitar a adição de diferentes algoritmos de compactação para estruturas de aprendizagem profunda PyTorch e TensorFlow.

Principais recursos

Algoritmos de compressão pós-treinamento

Algoritmo de compressão	OpenVINO	PyTorch	TochaFX	TensorFlow	ONNX
Quantização Pós-Treinamento	Suportado	Suportado	Experimental	Suportado	Suportado
Compressão de Pesos	Suportado	Suportado	Experimental	Não compatível	Não compatível
Esparsidade de ativação	Não compatível	Experimental	Não compatível	Não compatível	Não compatível

Algoritmos de compressão de tempo de treinamento

Algoritmo de compressão	PyTorch	TensorFlow
Treinamento consciente de quantização	Suportado	Suportado
Quantização de precisão mista	Suportado	Não compatível
Esparsidade	Suportado	Suportado
Poda de filtro	Suportado	Suportado
Poda de movimento	Experimental	Não compatível

Transformação automática e configurável do gráfico do modelo para obter o modelo compactado.
NOTA : Suporte limitado para modelos TensorFlow. Somente modelos criados usando API Sequencial ou Keras Funcional são suportados.
Interface comum para métodos de compactação.
Camadas aceleradas por GPU para ajuste fino do modelo compactado mais rápido.
Suporte de treinamento distribuído.
Patch Git para repositório de terceiros proeminente (huggingface-transformers) demonstrando o processo de integração do NNCF em pipelines de treinamento personalizados.
Combinação perfeita de algoritmos de poda, dispersão e quantização. Consulte a ideal-intel para obter exemplos de poda, quantização e destilação de junta (movimento) (JPQD), de ponta a ponta, desde a otimização NNCF até o OpenVINO IR compactado.
Exportação de modelos compactados PyTorch para pontos de verificação ONNX* e modelos compactados TensorFlow para formato SavedModel ou Frozen Graph, prontos para uso com o kit de ferramentas OpenVINO™.
Suporte para pipelines de treinamento de modelo com reconhecimento de precisão por meio do treinamento de nível de compressão adaptativo e do treinamento de saída antecipada.

Documentação

Esta documentação cobre informações detalhadas sobre algoritmos e funções do NNCF necessárias para a contribuição ao NNCF.

A documentação do usuário mais recente do NNCF está disponível aqui.

A documentação da API NNCF pode ser encontrada aqui.

Uso

Quantização Pós-Treinamento

O NNCF PTQ é a maneira mais simples de aplicar a quantização de 8 bits. Para executar o algoritmo, você só precisa do seu modelo e de um pequeno conjunto de dados de calibração (~ 300 amostras).

OpenVINO é o backend preferido para executar PTQ, enquanto PyTorch, TensorFlow e ONNX também são suportados.

OpenVINO

 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 Se o algoritmo de quantização pós-treinamento não atender aos requisitos de qualidade, você poderá ajustar o modelo pytorch quantizado. Você pode encontrar um exemplo de pipeline de treinamento com reconhecimento de quantização para um modelo pytorch aqui.

TochaFX

 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 )

Quantização do Tempo de Treinamento

Aqui está um exemplo de pipeline de quantização com reconhecimento de precisão, onde os pesos do modelo e os parâmetros de compactação podem ser ajustados para obter uma precisão mais alta.

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

Compressão do tempo de treinamento

Aqui está um exemplo de pipeline de esparsificação RB com reconhecimento de precisão, onde os pesos do modelo e os parâmetros de compactação podem ser ajustados para obter uma precisão mais alta.

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) : Devido à forma como o NNCF funciona no backend do PyTorch, import nncf deve ser feita antes de qualquer outra importação do torch em seu pacote ou em pacotes de terceiros que seu código utiliza. Caso contrário, a compressão poderá ser aplicada de forma incompleta.

Fluxo 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 obter uma descrição mais detalhada do uso do NNCF no seu código de treinamento, consulte este tutorial.

Demonstrações, tutoriais e amostras

Para um início mais rápido com a compactação baseada em NNCF, experimente exemplos de notebooks e scripts apresentados abaixo.

Tutoriais e demonstrações do Jupyter* Notebook

Tutoriais e demonstrações do notebook Jupyter* prontos para execução estão disponíveis para explicar e exibir algoritmos de compactação NNCF para otimizar modelos para inferência com o OpenVINO Toolkit:

Nome do tutorial do notebook	Algoritmo de compressão	Back-end	Domínio
Quantização BERT	Quantização Pós-Treinamento	OpenVINO	PNL
Quantização do modelo de segmentação MONAI	Quantização Pós-Treinamento	OpenVINO	Segmentação
Quantização do modelo PyTorch	Quantização Pós-Treinamento	PyTorch	Classificação de imagens
Quantização com Controle de Precisão	Quantização pós-treinamento com controle de precisão	OpenVINO	Fala para Texto, Detecção de objetos
Compressão de tempo de treinamento PyTorch	Compressão do tempo de treinamento	PyTorch	Classificação de imagens
Compressão de tempo de treinamento do TensorFlow	Compressão do tempo de treinamento	Fluxo tensor	Classificação de imagens
Poda, Quantização e Destilação Conjunta para BERT	Poda, Quantização e Destilação Conjunta	OpenVINO	PNL

Uma lista de notebooks que demonstram conversão e inferência OpenVINO junto com compactação NNCF para modelos de vários domínios:

Modelo de demonstração	Algoritmo de compressão	Back-end	Domínio
YOLOv8	Quantização Pós-Treinamento	OpenVINO	Detecção de objetos, Detecção de ponto-chave, Segmentação de instância
EficienteSAM	Quantização Pós-Treinamento	OpenVINO	Segmentação de imagens
Segmentar qualquer modelo	Quantização Pós-Treinamento	OpenVINO	Segmentação de imagens
OneFormer	Quantização Pós-Treinamento	OpenVINO	Segmentação de imagens
InstructPix2Pix	Quantização Pós-Treinamento	OpenVINO	Imagem a imagem
GRAMPO	Quantização Pós-Treinamento	OpenVINO	Imagem para Texto
BLIPE	Quantização Pós-Treinamento	OpenVINO	Imagem para Texto
Modelo de consistência latente	Quantização Pós-Treinamento	OpenVINO	Texto para imagem
Monstro do código QR ControlNet	Quantização Pós-Treinamento	OpenVINO	Texto para imagem
SDXL-turbo	Quantização Pós-Treinamento	OpenVINO	Texto para imagem, Imagem a imagem
Distil-Sussurro	Quantização Pós-Treinamento	OpenVINO	Fala para Texto
Sussurrar	Quantização Pós-Treinamento	OpenVINO	Fala para texto
Reconhecimento de fala MMS	Quantização Pós-Treinamento	OpenVINO	Fala para texto
Correção de erros gramaticais	Quantização Pós-Treinamento	OpenVINO	PNL, correção gramatical
Seguinte instrução LLM	Compressão de Peso	OpenVINO	PNL, instruções seguindo
Bots de bate-papo LLM	Compressão de peso	OpenVINO	PNL, chatbot

Exemplos de quantização pós-treinamento

Scripts compactos demonstrando quantização e aumento de velocidade de inferência correspondente:

Nome do exemplo	Algoritmo de compressão	Back-end	Domínio
OpenVINO MobileNetV2	Quantização Pós-Treinamento	OpenVINO	Classificação de imagens
OpenVINO YOLOv8	Quantização Pós-Treinamento	OpenVINO	Detecção de objetos
OpenVINO YOLOv8 QwAС	Quantização pós-treinamento com controle de precisão	OpenVINO	Detecção de objetos
Classificação de anomalia OpenVINO	Quantização pós-treinamento com controle de precisão	OpenVINO	Classificação de anomalia
PyTorch MobileNetV2	Quantização Pós-Treinamento	PyTorch	Classificação de imagens
SSD PyTorch	Quantização Pós-Treinamento	PyTorch	Detecção de objetos
TorchFX Resnet18	Quantização Pós-Treinamento	TochaFX	Classificação de imagens
TensorFlow MobileNetV2	Quantização Pós-Treinamento	TensorFlow	Classificação de imagens
ONNX MobileNetV2	Quantização Pós-Treinamento	ONNX	Classificação de imagens

Exemplos de compressão de tempo de treinamento

Exemplos de pipelines completos, incluindo compactação, treinamento e inferência para tarefas de classificação, detecção e segmentação:

Nome do exemplo	Algoritmo de compressão	Back-end	Domínio
Classificação de imagens PyTorch	Compressão do tempo de treinamento	PyTorch	Classificação de imagens
Detecção de objetos PyTorch	Compressão do tempo de treinamento	PyTorch	Detecção de objetos
Segmentação Semântica PyTorch	Compressão do tempo de treinamento	PyTorch	Segmentação Semântica
Classificação de imagens do TensorFlow	Compressão do tempo de treinamento	TensorFlow	Classificação de imagens
Detecção de objetos do TensorFlow	Compressão do tempo de treinamento	TensorFlow	Detecção de objetos
Segmentação de instância do TensorFlow	Compressão do tempo de treinamento	TensorFlow	Segmentação de instância

Integração de repositórios de terceiros

O NNCF pode ser facilmente integrado em pipelines de treinamento/avaliação de repositórios de terceiros.

Usado por

Extensões de treinamento OpenVINO
O NNCF está integrado às extensões de treinamento OpenVINO como um back-end de otimização de modelo. Você pode treinar, otimizar e exportar novos modelos com base nos modelos disponíveis, bem como executar os modelos exportados com OpenVINO.
HuggingFace Intel ideal
NNCF é usado como back-end de compactação no renomado repositório transformers no HuggingFace Optimum Intel.

Guia de instalação

Para obter instruções detalhadas de instalação, consulte o Guia de instalação.

O NNCF pode ser instalado como um pacote PyPI normal via pip:

pip install nncf

NNCF também está disponível via conda:

conda install -c conda-forge nncf

Requisitos do sistema

Ubuntu* 18.04 ou posterior (64 bits)
Python* 3.9 ou posterior
Estruturas suportadas:
- PyTorch* >=2,4, <2,6
- TensorFlow* >=2.8.4, <=2.15.1
- ONNX* ==1.17.0
- OpenVINO* >=2022.3.0

Este repositório é testado em Python* 3.10.14, PyTorch* 2.5.0 (NVidia CUDA* Toolkit 12.4) e TensorFlow* 2.12.1 (NVidia CUDA* Toolkit 11.8).

Zoológico modelo NNCF compactado NNCF

A lista de modelos e resultados de compactação para eles podem ser encontrados em nossa 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 }
}

Guia de contribuição

Consulte o arquivo CONTRIBUTING.md para obter diretrizes sobre contribuições para o repositório NNCF.

Links úteis

Documentação
Scripts de exemplo (objetos modelo disponíveis através de links nos respectivos arquivos README.md):
- PyTorch
- TensorFlow
Perguntas frequentes
Cadernos
HuggingFace Intel ideal
Guia de otimização de modelo OpenVINO

Telemetria

O NNCF, como parte do kit de ferramentas OpenVINO™, coleta dados de uso anônimos com a finalidade de melhorar as ferramentas OpenVINO™. Você pode cancelar a qualquer momento executando o seguinte comando no ambiente Python onde o NNCF está instalado:

opt_in_out --opt_out

Mais informações disponíveis na telemetria OpenVINO.

Expandir

Informações adicionais