ดาวน์โหลด nncf - ดาวน์โหลด nncf ซอร์สโค้ด

nncf

โค้ดแหล่งที่มา AI

v2.14.0

ดาวน์โหลด

กรอบการบีบอัดโครงข่ายประสาทเทียม (NNCF)

คุณสมบัติที่สำคัญ • การติดตั้ง • เอกสารประกอบ • การใช้งาน • บทช่วยสอนและตัวอย่าง • การบูรณาการของบุคคลที่สาม • สวนสัตว์จำลอง

Neural Network Compression Framework (NNCF) มอบชุดอัลกอริธึมหลังการฝึกอบรมและเวลาฝึกอบรมเพื่อเพิ่มประสิทธิภาพการอนุมานของโครงข่ายประสาทเทียมใน OpenVINO™ โดยมีความแม่นยำลดลงน้อยที่สุด

NNCF ได้รับการออกแบบมาเพื่อทำงานร่วมกับโมเดลจาก PyTorch, TorchFX, TensorFlow, ONNX และ OpenVINO™

NNCF จัดเตรียมตัวอย่างที่สาธิตการใช้อัลกอริธึมการบีบอัดสำหรับกรณีการใช้งานและรุ่นต่างๆ ดูผลลัพธ์การบีบอัดที่ทำได้ด้วยตัวอย่างที่ขับเคลื่อนด้วย NNCF ในหน้า NNCF Model Zoo

เฟรมเวิร์กได้รับการจัดระเบียบเป็นแพ็คเกจ Python* ที่สามารถสร้างและใช้ในโหมดสแตนด์อโลนได้ สถาปัตยกรรมเฟรมเวิร์กเป็นแบบรวมเพื่อให้ง่ายต่อการเพิ่มอัลกอริธึมการบีบอัดที่แตกต่างกันสำหรับทั้งเฟรมเวิร์กการเรียนรู้เชิงลึก PyTorch และ TensorFlow

คุณสมบัติที่สำคัญ

อัลกอริธึมการบีบอัดหลังการฝึกอบรม

อัลกอริธึมการบีบอัด	OpenVINO	ไพทอร์ช	ทอร์ช FX	เทนเซอร์โฟลว์	สสส
การกำหนดปริมาณหลังการฝึกอบรม	รองรับ	รองรับ	การทดลอง	รองรับ	รองรับ
การบีบอัดน้ำหนัก	รองรับ	รองรับ	การทดลอง	ไม่รองรับ	ไม่รองรับ
การเปิดใช้งาน Sparity	ไม่รองรับ	การทดลอง	ไม่รองรับ	ไม่รองรับ	ไม่รองรับ

อัลกอริธึมการบีบอัดเวลาการฝึกอบรม

อัลกอริธึมการบีบอัด	ไพทอร์ช	เทนเซอร์โฟลว์
การฝึกอบรมการรับรู้เชิงปริมาณ	รองรับ	รองรับ
การหาปริมาณแบบผสมความแม่นยำ	รองรับ	ไม่รองรับ
ความเบาบาง	รองรับ	รองรับ
การตัดแต่งกิ่งกรอง	รองรับ	รองรับ
การตัดแต่งกิ่งเคลื่อนไหว	การทดลอง	ไม่รองรับ

การแปลงกราฟโมเดลที่กำหนดค่าได้อัตโนมัติเพื่อให้ได้โมเดลที่บีบอัด
หมายเหตุ : การสนับสนุนแบบจำกัดสำหรับรุ่น TensorFlow รองรับเฉพาะโมเดลที่สร้างโดยใช้ Sequential หรือ Keras Functional API เท่านั้น
อินเทอร์เฟซทั่วไปสำหรับวิธีการบีบอัด
เลเยอร์ที่เร่งด้วย GPU เพื่อการปรับแต่งโมเดลที่บีบอัดได้เร็วขึ้น
การสนับสนุนการฝึกอบรมแบบกระจาย
Git patch สำหรับพื้นที่เก็บข้อมูลบุคคลที่สามที่โดดเด่น (huggingface-transformers) สาธิตกระบวนการรวม NNCF เข้ากับไปป์ไลน์การฝึกแบบกำหนดเอง
การผสมผสานอย่างลงตัวของอัลกอริธึมการตัดแต่งกิ่ง ความกระจัดกระจาย และการหาปริมาณ โปรดดูตัวอย่างการตัดแต่งข้อต่อ (การเคลื่อนไหว) การหาปริมาณ และการกลั่น (JPQD) จากต้นทางถึงปลายทางตั้งแต่การเพิ่มประสิทธิภาพ NNCF ไปจนถึงการบีบอัด OpenVINO IR
ส่งออกโมเดลที่บีบอัด PyTorch ไปยังจุดตรวจสอบ ONNX* และโมเดลที่บีบอัด TensorFlow เป็นรูปแบบ SavedModel หรือ Frozen Graph พร้อมใช้กับชุดเครื่องมือ OpenVINO™
รองรับไปป์ไลน์การฝึกโมเดล Accuracy-Aware ผ่านการฝึกอบรมระดับการบีบอัดแบบปรับได้และการฝึกออกก่อนกำหนด

เอกสารประกอบ

เอกสารนี้ครอบคลุมข้อมูลโดยละเอียดเกี่ยวกับอัลกอริทึมและฟังก์ชันของ NNCF ที่จำเป็นสำหรับการสนับสนุน NNCF

เอกสารผู้ใช้ล่าสุดสำหรับ NNCF มีอยู่ที่นี่

สามารถดูเอกสาร NNCF API ได้ที่นี่

การใช้งาน

การกำหนดปริมาณหลังการฝึกอบรม

NNCF PTQ เป็นวิธีที่ง่ายที่สุดในการใช้การวัดปริมาณ 8 บิต หากต้องการเรียกใช้อัลกอริทึม คุณเพียงต้องการโมเดลและชุดข้อมูลการสอบเทียบขนาดเล็ก (ประมาณ 300 ตัวอย่าง)

OpenVINO เป็นแบ็กเอนด์ที่ต้องการเรียกใช้ PTQ ด้วย ในขณะที่รองรับ PyTorch, TensorFlow และ ONNX เช่นกัน

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 )

ไพทอร์ช

 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 )

หมายเหตุ หากอัลกอริธึมการหาปริมาณหลังการฝึกอบรมไม่ตรงตามข้อกำหนดด้านคุณภาพ คุณสามารถปรับแต่งโมเดลไพทอร์ชเชิงปริมาณได้อย่างละเอียด คุณสามารถดูตัวอย่างไปป์ไลน์การฝึกอบรม Quantization-Aware สำหรับโมเดล pytorch ได้ที่นี่

ทอร์ช FX

 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 )

การหาปริมาณเวลาการฝึกอบรม

นี่คือตัวอย่างของไปป์ไลน์ Accuracy Aware Quantization ที่น้ำหนักโมเดลและพารามิเตอร์การบีบอัดอาจมีการปรับแต่งอย่างละเอียดเพื่อให้ได้ความแม่นยำที่สูงขึ้น

ไพทอร์ช

 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

การบีบอัดเวลาฝึกซ้อม

นี่คือตัวอย่างของไปป์ไลน์การกระจายตัวของ RB ของ Accuracy Aware ซึ่งน้ำหนักแบบจำลองและพารามิเตอร์การบีบอัดอาจได้รับการปรับแต่งอย่างละเอียดเพื่อให้ได้ความแม่นยำที่สูงขึ้น

ไพทอร์ช

 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" )

หมายเหตุ (PyTorch) : เนื่องจากวิธีการทำงานของ NNCF ภายในแบ็กเอนด์ PyTorch import nncf จะต้องดำเนินการก่อนการนำเข้า torch อื่น ๆ ในแพ็คเกจของคุณ หรือ ในแพ็คเกจบุคคลที่สามที่โค้ดของคุณใช้ มิฉะนั้นอาจใช้การบีบอัดได้ไม่สมบูรณ์

เทนเซอร์โฟลว์

 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" )

สำหรับคำอธิบายโดยละเอียดเพิ่มเติมเกี่ยวกับการใช้งาน NNCF ในโค้ดการฝึกของคุณ โปรดดูบทช่วยสอนนี้

การสาธิต บทช่วยสอน และตัวอย่าง

เพื่อการเริ่มต้นที่รวดเร็วยิ่งขึ้นด้วยการบีบอัดที่ขับเคลื่อนโดย NNCF ลองใช้สมุดบันทึกและสคริปต์ตัวอย่างที่แสดงด้านล่าง

Jupyter* บทช่วยสอนและการสาธิตสมุดบันทึก

มีบทช่วยสอนและการสาธิตสมุดบันทึก Jupyter* ที่พร้อมใช้งานเพื่ออธิบายและแสดงอัลกอริธึมการบีบอัด NNCF สำหรับการเพิ่มประสิทธิภาพโมเดลสำหรับการอนุมานด้วยชุดเครื่องมือ OpenVINO:

ชื่อบทช่วยสอนสมุดบันทึก	อัลกอริธึมการบีบอัด	แบ็กเอนด์	โดเมน
การหาปริมาณของ BERT	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	เอ็นแอลพี
การหาปริมาณแบบจำลองการแบ่งส่วน MONAI	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	การแบ่งส่วน
การหาปริมาณแบบจำลอง PyTorch	การกำหนดปริมาณหลังการฝึกอบรม	ไพทอร์ช	การจำแนกประเภทภาพ
การหาปริมาณด้วยการควบคุมความแม่นยำ	การกำหนดปริมาณหลังการฝึกอบรมพร้อมการควบคุมความแม่นยำ	OpenVINO	พูดเป็นข้อความ การตรวจจับวัตถุ
การบีบอัดเวลาการฝึกอบรม PyTorch	การบีบอัดเวลาฝึกซ้อม	ไพทอร์ช	การจำแนกประเภทภาพ
การบีบอัดเวลาการฝึกอบรม TensorFlow	การบีบอัดเวลาฝึกซ้อม	เทนเซอร์โฟลว์	การจำแนกประเภทภาพ
การตัดแต่งกิ่งร่วม การหาปริมาณ และการกลั่นสำหรับ BERT	การตัดแต่งกิ่งร่วม การหาปริมาณ และการกลั่น	OpenVINO	เอ็นแอลพี

รายชื่อโน้ตบุ๊กที่สาธิตการแปลงและการอนุมาน OpenVINO พร้อมด้วยการบีบอัด NNCF สำหรับรุ่นจากโดเมนต่างๆ:

โมเดลสาธิต	อัลกอริธึมการบีบอัด	แบ็กเอนด์	โดเมน
โยโลฟ8	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	การตรวจจับวัตถุ การตรวจจับจุดสำคัญ การแบ่งส่วนอินสแตนซ์
SAM ที่มีประสิทธิภาพ	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	การแบ่งส่วนภาพ
แบ่งส่วนโมเดลอะไรก็ได้	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	การแบ่งส่วนภาพ
หนึ่งอดีต	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	การแบ่งส่วนภาพ
สอนPix2Pix	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	ภาพต่อภาพ
คลิป	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	รูปภาพเป็นข้อความ
บลิ๊พ	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	รูปภาพเป็นข้อความ
แบบจำลองความสอดคล้องแฝง	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	ข้อความเป็นรูปภาพ
สัตว์ประหลาดรหัส QR ControlNet	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	ข้อความเป็นรูปภาพ
SDXL-เทอร์โบ	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	ข้อความเป็นรูปภาพ ภาพต่อภาพ
กลั่น-กระซิบ	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	คำพูดเป็นข้อความ
กระซิบ	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	คำพูดเป็นข้อความ
การรู้จำเสียง MMS	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	คำพูดเป็นข้อความ
การแก้ไขข้อผิดพลาดทางไวยากรณ์	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	NLP การแก้ไขไวยากรณ์
คำสั่ง LLM ต่อไปนี้	การบีบอัดน้ำหนัก	OpenVINO	NLP, การปฏิบัติตามคำสั่ง
แชทบอท LLM	การบีบอัดน้ำหนัก	OpenVINO	NLP, แชทบอท

ตัวอย่างการกำหนดปริมาณหลังการฝึกอบรม

สคริปต์ขนาดกะทัดรัดที่สาธิตการหาปริมาณและการเพิ่มความเร็วในการอนุมานที่สอดคล้องกัน:

ชื่อตัวอย่าง	อัลกอริธึมการบีบอัด	แบ็กเอนด์	โดเมน
OpenVINO MobileNetV2	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	การจำแนกประเภทภาพ
OpenVINO YOLOv8	การกำหนดปริมาณหลังการฝึกอบรม	OpenVINO	การตรวจจับวัตถุ
OpenVINO YOLOv8 QwAС	การกำหนดปริมาณหลังการฝึกอบรมพร้อมการควบคุมความแม่นยำ	OpenVINO	การตรวจจับวัตถุ
การจำแนกความผิดปกติของ OpenVINO	การกำหนดปริมาณหลังการฝึกอบรมพร้อมการควบคุมความแม่นยำ	OpenVINO	การจำแนกประเภทความผิดปกติ
PyTorch MobileNetV2	การกำหนดปริมาณหลังการฝึกอบรม	ไพทอร์ช	การจำแนกประเภทภาพ
PyTorch SSD	การกำหนดปริมาณหลังการฝึกอบรม	ไพทอร์ช	การตรวจจับวัตถุ
ทอร์ช FX Resnet18	การกำหนดปริมาณหลังการฝึกอบรม	ทอร์ช FX	การจำแนกประเภทภาพ
เทนเซอร์โฟลว์ MobileNetV2	การกำหนดปริมาณหลังการฝึกอบรม	เทนเซอร์โฟลว์	การจำแนกประเภทภาพ
ONNX MobileNetV2	การกำหนดปริมาณหลังการฝึกอบรม	สสส	การจำแนกประเภทภาพ

ตัวอย่างการบีบอัดเวลาฝึกซ้อม

ตัวอย่างของไปป์ไลน์แบบเต็ม รวมถึงการบีบอัด การฝึกอบรม และการอนุมานสำหรับงานจำแนกประเภท การตรวจจับ และการแบ่งส่วน:

ชื่อตัวอย่าง	อัลกอริธึมการบีบอัด	แบ็กเอนด์	โดเมน
การจำแนกภาพ PyTorch	การบีบอัดเวลาฝึกซ้อม	ไพทอร์ช	การจำแนกประเภทภาพ
การตรวจจับวัตถุ PyTorch	การบีบอัดเวลาฝึกซ้อม	ไพทอร์ช	การตรวจจับวัตถุ
การแบ่งส่วนความหมาย PyTorch	การบีบอัดเวลาฝึกซ้อม	ไพทอร์ช	การแบ่งส่วนความหมาย
การจำแนกภาพ TensorFlow	การบีบอัดเวลาฝึกซ้อม	เทนเซอร์โฟลว์	การจำแนกประเภทภาพ
การตรวจจับวัตถุ TensorFlow	การบีบอัดเวลาฝึกซ้อม	เทนเซอร์โฟลว์	การตรวจจับวัตถุ
การแบ่งส่วนอินสแตนซ์ TensorFlow	การบีบอัดเวลาฝึกซ้อม	เทนเซอร์โฟลว์	การแบ่งส่วนอินสแตนซ์

การรวมพื้นที่เก็บข้อมูลของบุคคลที่สาม

NNCF อาจบูรณาการเข้ากับไปป์ไลน์การฝึกอบรม/การประเมินผลของที่เก็บข้อมูลของบุคคลที่สามได้อย่างง่ายดาย

ใช้โดย

ส่วนขยายการฝึกอบรม OpenVINO
NNCF ถูกรวมเข้ากับ OpenVINO Training Extensions เพื่อเป็นแบ็กเอนด์การเพิ่มประสิทธิภาพโมเดล คุณสามารถฝึก เพิ่มประสิทธิภาพ และส่งออกโมเดลใหม่ตามเทมเพลตโมเดลที่มีอยู่ ตลอดจนรันโมเดลที่ส่งออกด้วย OpenVINO
HuggingFace Optimum Intel
NNCF ถูกใช้เป็นแบ็คเอนด์การบีบอัดภายในพื้นที่เก็บ transformers ที่มีชื่อเสียงใน HuggingFace Optimum Intel

คู่มือการติดตั้ง

สำหรับคำแนะนำในการติดตั้งโดยละเอียด โปรดดูคู่มือการติดตั้ง

NNCF สามารถติดตั้งเป็นแพ็คเกจ PyPI ปกติผ่าน pip:

pip install nncf

NNCF ยังมีให้บริการผ่าน conda:

conda install -c conda-forge nncf

ความต้องการของระบบ

Ubuntu* 18.04 หรือใหม่กว่า (64 บิต)
Python* 3.9 หรือใหม่กว่า
กรอบการทำงานที่รองรับ:
- ไพทอร์ช* >=2.4, <2.6
- เทนเซอร์โฟลว์* >=2.8.4, <=2.15.1
- ONNX* ==1.17.0
- OpenVINO* >=2022.3.0

พื้นที่เก็บข้อมูลนี้ได้รับการทดสอบบน Python* 3.10.14, PyTorch* 2.5.0 (NVidia CUDA* Toolkit 12.4) และ TensorFlow* 2.12.1 (NVidia CUDA* Toolkit 11.8)

NNCF บีบอัดสวนสัตว์โมเดล NNCF

รายชื่อรุ่นและผลการบีบอัดสามารถดูได้ที่หน้า 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 }
}

คู่มือการมีส่วนร่วม

โปรดดูคำแนะนำในไฟล์ CONTRIBUTING.md เกี่ยวกับการมีส่วนร่วมในพื้นที่เก็บข้อมูล NNCF

ลิงค์ที่เป็นประโยชน์

เอกสารประกอบ
สคริปต์ตัวอย่าง (วัตถุโมเดลมีให้ผ่านลิงก์ในไฟล์ README.md ที่เกี่ยวข้อง):
- ไพทอร์ช
- เทนเซอร์โฟลว์
คำถามที่พบบ่อย
โน๊ตบุ๊ค
HuggingFace Optimum Intel
คู่มือการเพิ่มประสิทธิภาพโมเดล OpenVINO

การวัดและส่งข้อมูลทางไกล

NNCF ซึ่งเป็นส่วนหนึ่งของชุดเครื่องมือ OpenVINO™ จะรวบรวมข้อมูลการใช้งานที่ไม่ระบุชื่อเพื่อวัตถุประสงค์ในการปรับปรุงเครื่องมือ OpenVINO™ คุณสามารถเลือกไม่รับได้ตลอดเวลาโดยเรียกใช้คำสั่งต่อไปนี้ในสภาพแวดล้อม Python ที่คุณได้ติดตั้ง NNCF ไว้:

opt_in_out --opt_out

มีข้อมูลเพิ่มเติมเกี่ยวกับการวัดและส่งข้อมูลทางไกลของ OpenVINO

ขยาย

ข้อมูลเพิ่มเติม