neutone_sdk
v1.4.0: Benchmarking Tools and PyTorch Updates
Neutone SDK เป็นเครื่องมือสำหรับนักวิจัยที่ช่วยให้พวกเขาสามารถห่อโมเดลเสียงของตัวเองและเรียกใช้ใน DAW โดยใช้ปลั๊กอิน Neutone ของเรา เรานำเสนอฟังก์ชั่นสำหรับการโหลดทั้งสองรุ่นในปลั๊กอินและสนับสนุนพวกเขาในรายการเริ่มต้นของรุ่นเริ่มต้นที่พร้อมใช้งานสำหรับทุกคนที่ใช้ปลั๊กอิน เราหวังว่าสิ่งนี้จะช่วยให้นักวิจัยสามารถลองแบบจำลองของพวกเขาใน DAW ได้อย่างง่ายดาย แต่ยังช่วยให้ผู้สร้างมีคอลเลกชันของแบบจำลองที่น่าสนใจ
Juce เป็นมาตรฐานอุตสาหกรรมสำหรับการสร้างปลั๊กอินเสียง ด้วยเหตุนี้จึงจำเป็นต้องมีความรู้เกี่ยวกับ C ++ เพื่อให้สามารถสร้างปลั๊กอินเสียงที่ง่ายมาก อย่างไรก็ตามมันเป็นเรื่องยากสำหรับนักวิจัยด้านเสียง AI ที่จะมีประสบการณ์อย่างกว้างขวางกับ C ++ และสามารถสร้างปลั๊กอินดังกล่าวได้ ยิ่งกว่านั้นเป็นการลงทุนที่ร้ายแรงซึ่งสามารถใช้ในการพัฒนาอัลกอริทึมที่ดีขึ้น Neutone ทำให้สามารถสร้างโมเดลโดยใช้เครื่องมือที่คุ้นเคยเช่น Pytorch และด้วยรหัส Python จำนวนน้อยที่สุดจะห่อโมเดลเหล่านี้เพื่อให้สามารถดำเนินการได้โดยปลั๊กอิน Neutone การสร้างแบบจำลองและทำงานภายใน DAW สามารถทำได้ในเวลาน้อยกว่าหนึ่งวันโดยไม่จำเป็นต้องใช้รหัสหรือความรู้ C ++
SDK ให้การสนับสนุนการบัฟเฟอร์อัตโนมัติของอินพุตและเอาต์พุตไปยังโมเดลของคุณและอัตราตัวอย่างแบบ on-the-fly และการแปลงสเตอริโอ-โมโน มันเปิดใช้งานโมเดลที่สามารถดำเนินการได้ด้วยจำนวนตัวอย่างที่กำหนดไว้ล่วงหน้าที่จะใช้ใน DAW ในอัตราการสุ่มตัวอย่างและขนาดบัฟเฟอร์ใด ๆ อย่างราบรื่น นอกจากนี้ภายในเครื่องมือ SDK สำหรับการเปรียบเทียบและการทำโปรไฟล์พร้อมใช้งานได้อย่างง่ายดายเพื่อให้คุณสามารถดีบักและทดสอบประสิทธิภาพของโมเดลของคุณได้อย่างง่ายดาย
คุณสามารถติดตั้ง neutone_sdk โดยใช้ PIP:
pip install neutone_sdk
ปลั๊กอิน Neutone มีให้ที่ https://neutone.space ขณะนี้เราเสนอปลั๊กอิน VST3 และ AU ที่สามารถใช้ในการโหลดรุ่นที่สร้างขึ้นด้วย SDK นี้ กรุณาเยี่ยมชมเว็บไซต์สำหรับข้อมูลเพิ่มเติม
หากคุณเพียงแค่ต้องการห่อโมเดลโดยไม่ต้องผ่านคำอธิบายโดยละเอียดเกี่ยวกับสิ่งที่เราเตรียมตัวอย่างเหล่านี้ให้คุณ
SDK ให้ฟังก์ชั่นสำหรับการห่อโมเดล Pytorch ที่มีอยู่ในแบบที่สามารถทำให้สามารถทำงานได้ภายในปลั๊กอิน VST ที่แกนกลางปลั๊กอินกำลังส่งชิ้นตัวอย่างเสียงในอัตราตัวอย่างที่แน่นอนเป็นอินพุตและคาดว่าจะมีตัวอย่างจำนวนเท่ากันที่เอาต์พุต ผู้ใช้ SDK สามารถระบุอัตราตัวอย่างและขนาดของบัฟเฟอร์ (S) รุ่นของพวกเขาทำงานได้อย่างเหมาะสม จากนั้น SDK รับประกันได้ว่าการส่งต่อของโมเดลจะได้รับเสียงที่หนึ่งในนั้น (sample_rate, buffer_size) ชุดค่าผสม มีลูกบิดสี่ตัวที่อนุญาตให้ผู้ใช้ปลั๊กอินฟีดในพารามิเตอร์เพิ่มเติมไปยังรุ่นที่รันไทม์ สามารถเปิดใช้งานหรือปิดใช้งานได้ตามต้องการผ่าน SDK
การใช้ฟังก์ชั่นการส่งออกที่รวมอยู่ในชุดของการทดสอบจะถูกเรียกใช้โดยอัตโนมัติเพื่อให้แน่ใจว่าโมเดลทำงานตามที่คาดไว้และพร้อมที่จะโหลดโดยปลั๊กอิน
เครื่องมือเปรียบเทียบและการทำโปรไฟล์ CLI มีให้สำหรับการดีบักและการทดสอบรุ่นที่ห่อหุ้มเพิ่มเติม เป็นไปได้ที่จะเปรียบเทียบความเร็วและเวลาแฝงของแบบจำลองในช่วงของ DAW ทั่วไปจำลอง (Sample_rate, Buffere_Size) รวมถึงการใช้งานหน่วยความจำและการใช้งาน CPU
เรามีหลายรุ่นในไดเรกทอรีตัวอย่าง เราจะผ่านหนึ่งในรุ่นที่ง่ายที่สุดคือโมเดลการบิดเบือนเพื่อแสดงให้เห็น
สมมติว่าเรามีโมเดล pytorch ต่อไปนี้ พารามิเตอร์จะได้รับการคุ้มครองในภายหลังเราจะมุ่งเน้นไปที่อินพุตและเอาต์พุตในตอนนี้ สมมติว่ารุ่นนี้ได้รับเทนเซอร์ของรูปร่าง (2, buffer_size) เป็นอินพุตที่ buffer_size เป็นพารามิเตอร์ที่สามารถระบุได้
class ClipperModel ( nn . Module ):
def forward ( self , x : Tensor , min_val : float , max_val : float , gain : float ) -> Tensor :
return torch . clip ( x , min = min_val * gain , max = max_val * gain )ในการเรียกใช้สิ่งนี้ภายใน VST wrapper ที่ง่ายที่สุดที่เราสามารถเขียนได้คือการแบ่งย่อย baseclass waveformtowaveformbase
class ClipperModelWrapper ( WaveformToWaveformBase ):
@ torch . jit . export
def is_input_mono ( self ) -> bool :
return False
@ torch . jit . export
def is_output_mono ( self ) -> bool :
return False
@ torch . jit . export
def get_native_sample_rates ( self ) -> List [ int ]:
return [] # Supports all sample rates
@ torch . jit . export
def get_native_buffer_sizes ( self ) -> List [ int ]:
return [] # Supports all buffer sizes
def do_forward_pass ( self , x : Tensor , params : Dict [ str , Tensor ]) -> Tensor :
# ... Parameter unwrap logic
x = self . model . forward ( x , min_val , max_val , gain )
return x วิธีการทำงานส่วนใหญ่คือ do_forward_pass ในกรณีนี้มันเป็นเพียงการผ่านง่าย แต่เราจะใช้มันเพื่อจัดการพารามิเตอร์ในภายหลัง
โดยค่าเริ่มต้น VST จะทำงานเป็น stereo-stereo แต่เมื่อต้องการโมโนสำหรับรุ่นเราสามารถใช้ is_input_mono และ is_output_mono เพื่อแจ้ง SDK และมีอินพุตและเอาต์พุตแปลงโดยอัตโนมัติ หาก is_input_mono ถูกสลับค่าเฉลี่ย (1, buffer_size) เทนเซอร์รูปจะถูกส่งผ่านเป็นอินพุตแทน (2, buffer_size) หาก is_output_mono ถูกสลับ do_forward_pass คาดว่าจะส่งคืนเทนเซอร์โมโน (รูปร่าง (1, buffer_size) ) ที่จะทำซ้ำข้ามทั้งสองช่องที่เอาต์พุตของ VST สิ่งนี้ทำภายใน SDK เพื่อหลีกเลี่ยงการจัดสรรหน่วยความจำที่ไม่จำเป็นในระหว่างการส่งผ่านแต่ละครั้ง
get_native_sample_rates และ get_native_buffer_sizes สามารถใช้เพื่อระบุอัตราตัวอย่างหรือขนาดบัฟเฟอร์ที่ต้องการ ในกรณีส่วนใหญ่สิ่งเหล่านี้คาดว่าจะมีเพียงองค์ประกอบเดียว แต่มีความยืดหยุ่นเป็นพิเศษสำหรับรุ่นที่ซับซ้อนมากขึ้น ในกรณีที่มีตัวเลือกหลายตัวเลือก SDK จะพยายามค้นหาตัวเลือกที่ดีที่สุดสำหรับการตั้งค่าปัจจุบันของ DAW เมื่อใดก็ตามที่อัตราตัวอย่างหรือขนาดบัฟเฟอร์แตกต่างจากหนึ่งใน DAW A wrapper จะถูกเรียกใช้โดยอัตโนมัติที่แปลงเป็นอัตราการสุ่มตัวอย่างที่ถูกต้องหรือใช้คิว FIFO สำหรับขนาดบัฟเฟอร์ที่ร้องขอหรือทั้งสองอย่าง สิ่งนี้จะทำให้เกิดการลงโทษประสิทธิภาพเล็กน้อยและเพิ่มความล่าช้า ในกรณีที่โมเดลเข้ากันได้กับอัตราตัวอย่างและ/หรือขนาดบัฟเฟอร์รายการเหล่านี้สามารถทิ้งไว้ได้
ซึ่งหมายความว่าเทนเซอร์ x ในวิธี do_forward_pass รับประกันว่าจะเป็นรูปร่าง (1 if is_input_mono else 2, buffer_size) โดยที่ buffer_size จะถูกเลือกที่รันไทม์จากรายการที่ให้ไว้ในวิธี get_native_buffer_sizes เทนเซอร์ x จะอยู่ในอัตราการสุ่มตัวอย่างอย่างใดอย่างหนึ่งจากรายการที่ให้ไว้ในวิธี get_native_sample_rates
เรามีฟังก์ชั่นผู้ช่วย save_neutone_model ที่ช่วยประหยัดรุ่นไปยังดิสก์ โดยค่าเริ่มต้นสิ่งนี้จะแปลงโมเดลเป็น Torchscript และเรียกใช้ผ่านชุดตรวจสอบเพื่อให้แน่ใจว่าปลั๊กอินสามารถโหลดได้ ไฟล์ model.nm ที่ได้คือสามารถโหลดได้ภายในปลั๊กอินโดยใช้ปุ่ม load your own อ่านด้านล่างสำหรับวิธีการส่งโมเดลไปยังคอลเลกชันเริ่มต้นที่ทุกคนมองเห็นได้โดยใช้ปลั๊กอิน
สำหรับรุ่นที่สามารถใช้สัญญาณปรับอากาศเรามีพารามิเตอร์ลูกบิดที่กำหนดค่าได้สี่ตัว ภายใน ClipperModelWrapper ที่กำหนดไว้ข้างต้นเราสามารถรวมสิ่งต่อไปนี้:
class ClipperModelWrapper ( WaveformToWaveformBase ):
...
def get_neutone_parameters ( self ) -> List [ NeutoneParameter ]:
return [ NeutoneParameter ( name = "min" , description = "min clip threshold" , default_value = 0.5 ),
NeutoneParameter ( name = "max" , description = "max clip threshold" , default_value = 1.0 ),
NeutoneParameter ( name = "gain" , description = "scale clip threshold" , default_value = 1.0 )]
def do_forward_pass ( self , x : Tensor , params : Dict [ str , Tensor ]) -> Tensor :
min_val , max_val , gain = params [ "min" ], params [ "max" ], params [ "gain" ]
x = self . model . forward ( x , min_val , max_val , gain )
return x ในระหว่างการส่งต่อ params พารามิเตอร์จะเป็นพจนานุกรมดังต่อไปนี้:
{
"min" : torch . Tensor ([ 0.5 ] * buffer_size ),
"max" : torch . Tensor ([ 1.0 ] * buffer_size ),
"gain" : torch . Tensor ([ 1.0 ] * buffer_size )
} คีย์ของพจนานุกรมมีการระบุไว้ในฟังก์ชัน get_parameters
พารามิเตอร์จะใช้ค่าระหว่าง 0 ถึง 1 และฟังก์ชั่น do_forward_pass สามารถใช้ในการปรับขนาดที่จำเป็นก่อนที่จะเรียกใช้วิธีการส่งต่อภายในของโมเดล
ยิ่งไปกว่านั้นพารามิเตอร์ที่ส่งโดยปลั๊กอินเข้ามาในระดับตัวอย่าง โดยค่าเริ่มต้นเราใช้ค่าเฉลี่ยของบัฟเฟอร์แต่ละตัวและส่งคืนลอยเดี่ยว (เป็นเทนเซอร์) แต่วิธีการ aggregate_param สามารถใช้เพื่อแทนที่วิธีการรวม ดูไฟล์ส่งออก Clipper เต็มรูปแบบสำหรับตัวอย่างของการรักษาความละเอียดนี้
รุ่นเสียงบางรุ่นจะชะลอเสียงสำหรับตัวอย่างจำนวนหนึ่ง ขึ้นอยู่กับสถาปัตยกรรมของแต่ละรุ่น เพื่อให้สัญญาณเปียกและแห้งที่ผ่านปลั๊กอินเพื่อให้ผู้ใช้จัดตำแหน่งจะต้องรายงานจำนวนตัวอย่างของความล่าช้าแบบจำลองของพวกเขา calc_model_delay_samples สามารถใช้เพื่อระบุจำนวนตัวอย่างล่าช้า โมเดล RAVE โดยเฉลี่ยมีบัฟเฟอร์ความล่าช้า (2048 ตัวอย่าง) ซึ่งสื่อสารแบบคงที่ในวิธี calc_model_delay_samples และสามารถดูได้ในตัวอย่าง แบบจำลองที่ใช้กับ ADD ที่ทับซ้อนกันจะมีความล่าช้าเท่ากับจำนวนตัวอย่างที่ใช้สำหรับการตัดขวางตามที่เห็นใน Wrapper โมเดล Demucs หรือตัวอย่างตัวกรองสเปกตรัม
การคำนวณความล่าช้าแบบจำลองของคุณเพิ่มอาจเป็นเรื่องยากโดยเฉพาะอย่างยิ่งเนื่องจากอาจมีหลายแหล่งที่แตกต่างกันของความล่าช้าที่จำเป็นต้องรวมกัน (เช่นการหน่วงเวลา cossfading, การหน่วงตัวกรอง, การหน่วงเวลาบัฟเฟอร์ lookahead และ / หรือเครือข่ายประสาท . มันคุ้มค่าที่จะใช้เวลาพิเศษในการทดสอบโมเดลใน DAW ของคุณเพื่อให้แน่ใจว่าความล่าช้ากำลังรายงานอย่างถูกต้อง
การเพิ่มบัฟเฟอร์ LookBehind ให้กับโมเดลของคุณจะเป็นประโยชน์สำหรับรุ่นที่ต้องใช้บริบทเพิ่มเติมจำนวนหนึ่งเพื่อผลลัพธ์ที่เป็นประโยชน์ สามารถเปิดใช้งานบัฟเฟอร์ Lookbehind ได้อย่างง่ายดายโดยระบุจำนวนตัวอย่างของ Lookbehind ที่คุณต้องการในวิธี get_look_behind_samples เมื่อวิธีการนี้ส่งคืนตัวเลขที่มากกว่าศูนย์วิธี do_forward_pass จะได้รับเทนเซอร์ของรูปร่างเสมอ (in_n_ch, look_behind_samples + buffer_size) แต่จะต้องส่งคืนเทนเซอร์ของรูปร่าง (out_n_ch, buffer_size) ของตัวอย่างล่าสุด
เราขอแนะนำให้หลีกเลี่ยงการใช้บัฟเฟอร์รูปลักษณ์เมื่อเป็นไปได้เนื่องจากมันทำให้โมเดลของคุณมีประสิทธิภาพน้อยลงและอาจส่งผลให้การคำนวณเสียระหว่างการส่งต่อแต่ละครั้ง หากใช้โมเดล convolutional อย่างหมดจดลองสลับ convolutions ทั้งหมดเป็น convolutions แคชแทน
เป็นเรื่องปกติที่โมเดล AI จะดำเนินการในรูปแบบที่ไม่คาดคิดเมื่อนำเสนอด้วยอินพุตนอกสิ่งที่มีอยู่ในการกระจายการฝึกอบรมของพวกเขา เราให้บริการตัวกรองทั่วไป (เบสต่ำ, ผ่านสูง, ผ่านวง, หยุดวงดนตรี) ในไฟล์ neutone_sdk/filters.py สิ่งเหล่านี้สามารถใช้ในระหว่างการส่งต่อเพื่อ จำกัด โดเมนของอินพุตที่จะเข้าสู่โมเดล บางคนสามารถชักนำให้เกิดความล่าช้าเล็กน้อยลองดูตัวอย่าง/ตัวอย่าง _clipper_prefilter.py ไฟล์สำหรับตัวอย่างง่ายๆเกี่ยวกับวิธีการตั้งค่าตัวกรอง
ปลั๊กอินมีรายการเริ่มต้นของรุ่นที่มุ่งเน้นไปที่ผู้สร้างที่ต้องการใช้ประโยชน์จากพวกเขาในระหว่างกระบวนการสร้างสรรค์ เราสนับสนุนให้ผู้ใช้ส่งแบบจำลองของพวกเขาเมื่อพวกเขามีความสุขกับผลลัพธ์ที่พวกเขาได้รับเพื่อให้พวกเขาสามารถใช้งานโดยชุมชนโดยรวม สำหรับการส่งเราต้องการข้อมูลเมตาเพิ่มเติมบางอย่างที่จะใช้เพื่อแสดงข้อมูลเกี่ยวกับแบบจำลองที่มุ่งเป้าไปที่ทั้งผู้สร้างและนักวิจัยอื่น ๆ สิ่งนี้จะปรากฏบนทั้งเว็บไซต์ Neutone และภายในปลั๊กอิน
การข้ามโมเดล Clipper ก่อนหน้านี้เป็นตัวอย่างที่สมจริงยิ่งขึ้นตามโมเดล Overdrive TCN แบบสุ่มที่ได้รับแรงบันดาลใจจาก Micro-TCN
class OverdriveModelWrapper ( WaveformToWaveformBase ):
def get_model_name ( self ) -> str :
return "conv1d-overdrive.random"
def get_model_authors ( self ) -> List [ str ]:
return [ "Nao Tokui" ]
def get_model_short_description ( self ) -> str :
return "Neural distortion/overdrive effect"
def get_model_long_description ( self ) -> str :
return "Neural distortion/overdrive effect through randomly initialized Convolutional Neural Network"
def get_technical_description ( self ) -> str :
return "Random distortion/overdrive effect through randomly initialized Temporal-1D-convolution layers. You'll get different types of distortion by re-initializing the weight or changing the activation function. Based on the idea proposed by Steinmetz et al."
def get_tags ( self ) -> List [ str ]:
return [ "distortion" , "overdrive" ]
def get_model_version ( self ) -> str :
return "1.0.0"
def is_experimental ( self ) -> bool :
return False
def get_technical_links ( self ) -> Dict [ str , str ]:
return {
"Paper" : "https://arxiv.org/abs/2010.04237" ,
"Code" : "https://github.com/csteinmetz1/ronn"
}
def get_citation ( self ) -> str :
return "Steinmetz, C. J., & Reiss, J. D. (2020). Randomized overdrive neural networks. arXiv preprint arXiv:2010.04237."ตรวจสอบเอกสารของวิธีการภายใน core.py รวมถึงโมเดลการสุ่มเกินพิกัดบนเว็บไซต์และในปลั๊กอินเพื่อทำความเข้าใจว่าแต่ละฟิลด์จะแสดงที่ใด
หากต้องการส่งแบบจำลองโปรดเปิดปัญหาเกี่ยวกับที่เก็บ GitHub ขณะนี้เราต้องการสิ่งต่อไปนี้:
model.nm ที่ส่งออกโดยฟังก์ชั่นผู้ช่วย save_neutone_model SDK มีเครื่องมือ CLI สามตัวที่สามารถใช้ในการดีบักและทดสอบโมเดลที่ห่อหุ้ม
ตัวอย่าง:
$ python -m neutone_sdk.benchmark benchmark-speed --model_file model.nm
INFO:__main__:Running benchmark for buffer sizes (128, 256, 512, 1024, 2048) and sample rates (48000,). Outliers will be removed from the calculation of mean and std and displayed separately if existing.
INFO:__main__:Sample rate: 48000 | Buffer size: 128 | duration: 0.014±0.002 | 1/RTF: 5.520 | Outliers: [0.008]
INFO:__main__:Sample rate: 48000 | Buffer size: 256 | duration: 0.028±0.003 | 1/RTF: 5.817 | Outliers: []
INFO:__main__:Sample rate: 48000 | Buffer size: 512 | duration: 0.053±0.003 | 1/RTF: 6.024 | Outliers: []
INFO:__main__:Sample rate: 48000 | Buffer size: 1024 | duration: 0.106±0.000 | 1/RTF: 6.056 | Outliers: []
INFO:__main__:Sample rate: 48000 | Buffer size: 2048 | duration: 0.212±0.000 | 1/RTF: 6.035 | Outliers: [0.213]
การเรียกใช้เบนช์มาร์กความเร็วจะเรียกใช้อินพุตแบบสุ่มผ่านโมเดลโดยอัตโนมัติในอัตราตัวอย่าง 48000 และขนาดบัฟเฟอร์ (128, 256, 512, 1024, 2048) และรายงานเวลาเฉลี่ยในการดำเนินการอนุมานหนึ่งบัฟเฟอร์ จากนี้ 1/RTF จะถูกคำนวณซึ่งแสดงถึงจำนวนของแบบจำลองที่เร็วกว่าแบบเรียลไทม์ เมื่อตัวเลขนี้สูงขึ้นโมเดลจะใช้ทรัพยากรน้อยลงภายใน DAW มันเป็นสิ่งจำเป็นสำหรับจำนวนนี้ที่จะใหญ่กว่า 1 สำหรับโมเดลที่จะสามารถดำเนินการในเรียลไทม์บนเครื่องที่มาตรฐานวิ่งต่อไป
อัตราตัวอย่างและขนาดบัฟเฟอร์ที่ถูกทดสอบเช่นเดียวกับจำนวนครั้งที่เกณฑ์มาตรฐานถูกทำซ้ำภายในเพื่อคำนวณค่าเฉลี่ยและจำนวนเธรดที่ใช้สำหรับการคำนวณมีให้เป็นพารามิเตอร์ เรียกใช้ python -m neutone_sdk.benchmark benchmark-speed --help สำหรับข้อมูลเพิ่มเติม เมื่อระบุอัตราตัวอย่างที่กำหนดเองหรือขนาดบัฟเฟอร์แต่ละตัวจะต้องส่งผ่านไปยัง CLI แยกกัน ตัวอย่างเช่น: --sample_rate 48000 --sample_rate 44100 --buffer_size 32 --buffer_size 64
ในขณะที่เกณฑ์มาตรฐานความเร็วควรเร็วเนื่องจากแบบจำลองโดยทั่วไปจะต้องพูดแบบเรียลไทม์ แต่ก็เป็นไปได้ที่จะติดอยู่หากโมเดลช้าเกินไป ตรวจสอบให้แน่ใจว่าคุณเลือกจำนวนตัวอย่างและขนาดของบัฟเฟอร์เพื่อทดสอบ
ตัวอย่าง:
$ python -m neutone_sdk.benchmark benchmark-latency model.nm
INFO:__main__:Native buffer sizes: [2048], Native sample rates: [48000]
INFO:__main__:Model exports/ravemodel/model.nm has the following delays for each sample rate / buffer size combination (lowest delay first):
INFO:__main__:Sample rate: 48000 | Buffer size: 2048 | Total delay: 0 | (Buffering delay: 0 | Model delay: 0)
INFO:__main__:Sample rate: 48000 | Buffer size: 1024 | Total delay: 1024 | (Buffering delay: 1024 | Model delay: 0)
INFO:__main__:Sample rate: 48000 | Buffer size: 512 | Total delay: 1536 | (Buffering delay: 1536 | Model delay: 0)
INFO:__main__:Sample rate: 48000 | Buffer size: 256 | Total delay: 1792 | (Buffering delay: 1792 | Model delay: 0)
INFO:__main__:Sample rate: 44100 | Buffer size: 128 | Total delay: 1920 | (Buffering delay: 1920 | Model delay: 0)
INFO:__main__:Sample rate: 48000 | Buffer size: 128 | Total delay: 1920 | (Buffering delay: 1920 | Model delay: 0)
INFO:__main__:Sample rate: 44100 | Buffer size: 256 | Total delay: 2048 | (Buffering delay: 2048 | Model delay: 0)
INFO:__main__:Sample rate: 44100 | Buffer size: 512 | Total delay: 2048 | (Buffering delay: 2048 | Model delay: 0)
INFO:__main__:Sample rate: 44100 | Buffer size: 1024 | Total delay: 2048 | (Buffering delay: 2048 | Model delay: 0)
INFO:__main__:Sample rate: 44100 | Buffer size: 2048 | Total delay: 2048 | (Buffering delay: 2048 | Model delay: 0) การเรียกใช้เกณฑ์มาตรฐานความเร็วจะคำนวณเวลาแฝงของโมเดลโดยอัตโนมัติที่การรวมกันของ sample_rate=(44100, 48000) และ buffer_size=(128, 256, 512, 1024, 2048) สิ่งนี้ให้ภาพรวมทั่วไปของสิ่งที่จะเกิดขึ้นสำหรับการตั้งค่า DAW ทั่วไป ความล่าช้าทั้งหมดจะถูกแบ่งออกเป็นความล่าช้าของการบัฟเฟอร์และความล่าช้าของแบบจำลอง ผู้สร้างความล่าช้าของโมเดลถูกรายงานโดยโมเดลใน wrapper โมเดลตามที่อธิบายไว้ข้างต้น ความล่าช้าในการบัฟเฟอร์จะถูกคำนวณโดยอัตโนมัติโดย SDK โดยพิจารณาการรวมกันของ (sample_rate, buffer_size) ที่ระบุโดย wrapper (คนพื้นเมือง) และหนึ่งที่ระบุโดย DAW ที่รันไทม์ การเรียกใช้แบบจำลองที่การรวมกันของดั้งเดิม (sample_rate, buffer_size) จะทำให้เกิดความล่าช้าขั้นต่ำ
เช่นเดียวกับเกณฑ์มาตรฐานความเร็วด้านบนการรวมการทดสอบของ (sample_rate, buffer_size) สามารถระบุได้จาก CLI เรียกใช้ python -m neutone_sdk.benchmark benchmark-latency --help สำหรับข้อมูลเพิ่มเติม
$ python -m neutone_sdk.benchmark profile --model_file exports/ravemodel/model.nm
INFO:__main__:Profiling model exports/ravemodel/model.nm at sample rate 48000 and buffer size 128
STAGE:2023-09-28 14:34:53 96328:4714960 ActivityProfilerController.cpp:311] Completed Stage: Warm Up
30it [00:00, 37.32it/s]
STAGE:2023-09-28 14:34:54 96328:4714960 ActivityProfilerController.cpp:317] Completed Stage: Collection
STAGE:2023-09-28 14:34:54 96328:4714960 ActivityProfilerController.cpp:321] Completed Stage: Post Processing
INFO:__main__:Displaying Total CPU Time
INFO:__main__:-------------------------------- ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------
Name Self CPU % Self CPU CPU total % CPU total CPU time avg CPU Mem Self CPU Mem # of Calls
-------------------------------- ------------ ------------ ------------ ------------ ------------ ------------ ------------ ------------
forward 98.54% 799.982ms 102.06% 828.603ms 26.729ms 0 b -918.17 Kb 31
aten::convolution 0.12% 963.000us 0.95% 7.739ms 175.886us 530.62 Kb -143.50 Kb 44
...
...
Full output removed from GitHub.
เครื่องมือการทำโปรไฟล์จะเรียกใช้โมเดลในอัตราตัวอย่าง 48000 และขนาดบัฟเฟอร์ที่ 128 ภายใต้ Pytorch Profiler และเอาท์พุทชุดข้อมูลเชิงลึกเช่นเวลา CPU ทั้งหมดการใช้หน่วยความจำ CPU ทั้งหมด (ต่อฟังก์ชั่น) และการใช้หน่วยความจำ CPU ที่จัดกลุ่ม (ต่อกลุ่มของการโทรฟังก์ชั่น) สิ่งนี้สามารถใช้เพื่อระบุคอขวดในรหัสโมเดลของคุณ (แม้ภายในการโทรแบบจำลองภายในการโทร do_forward_pass )
เช่นเดียวกับการเปรียบเทียบสามารถวิ่งได้ที่การรวมกันของอัตราตัวอย่างและขนาดบัฟเฟอร์ที่แตกต่างกันรวมถึงจำนวนเธรดที่แตกต่างกัน เรียกใช้ python -m neutone_sdk.benchmark profile --help สำหรับข้อมูลเพิ่มเติม
เรายินดีต้อนรับการมีส่วนร่วมใด ๆ กับ SDK โปรดเพิ่มประเภททุกที่ที่เป็นไปได้และใช้ Formatter black เพื่อการอ่าน
แผนงานปัจจุบันคือ:
โครงการ Audacitorch เป็นแรงบันดาลใจที่สำคัญสำหรับการพัฒนา SDK ตรวจสอบที่นี่
