Penanda aras GPU pembelajaran mendalam telah merevolusikan cara kita menyelesaikan masalah yang rumit, dari pengiktirafan imej kepada pemprosesan bahasa semula jadi. Walau bagaimanapun, semasa melatih model-model ini sering bergantung kepada GPU berprestasi tinggi, menggunakannya dengan berkesan dalam persekitaran yang terkawal sumber seperti peranti kelebihan atau sistem dengan perkakasan terhad memberikan cabaran yang unik. CPU, yang tersedia secara meluas dan cekap kos, sering berfungsi sebagai tulang belakang untuk kesimpulan dalam senario tersebut. Tetapi bagaimana kita memastikan bahawa model yang digunakan pada CPU memberikan prestasi yang optimum tanpa menjejaskan ketepatan?
Artikel ini menyelam ke dalam penanda aras kesimpulan model pembelajaran mendalam pada CPU, yang memberi tumpuan kepada tiga metrik kritikal: latency, penggunaan CPU dan penggunaan ingatan. Menggunakan contoh klasifikasi spam, kami meneroka bagaimana kerangka popular seperti Pytorch, Tensorflow, Jax, dan ONNX Runtime Handle Handle Inference Workloads. Akhirnya, anda akan mempunyai pemahaman yang jelas tentang cara mengukur prestasi, mengoptimumkan penyebaran, dan memilih alat dan kerangka yang tepat untuk kesimpulan berasaskan CPU dalam persekitaran yang terkawal sumber.
Kesan: Pelaksanaan kesimpulan yang optimum dapat menjimatkan sejumlah besar wang dan sumber bebas untuk beban kerja lain.
Artikel ini diterbitkan sebagai sebahagian daripada Blogathon Sains Data.
Kelajuan kesimpulan adalah penting untuk pengalaman pengguna dan kecekapan operasi dalam aplikasi pembelajaran mesin. Pengoptimuman runtime memainkan peranan penting dalam meningkatkan ini dengan menyelaraskan pelaksanaan. Menggunakan perpustakaan yang dipercepatkan perkakasan seperti runtime ONNX mengambil kesempatan daripada pengoptimuman yang disesuaikan dengan seni bina tertentu, mengurangkan latensi (masa per kesimpulan).
Di samping itu, format model ringan seperti ONNX meminimumkan overhead, membolehkan pemuatan dan pelaksanaan yang lebih cepat. Runtime yang dioptimumkan memanfaatkan pemprosesan selari untuk mengedarkan pengiraan di seluruh teras CPU yang tersedia dan meningkatkan pengurusan memori, memastikan prestasi yang lebih baik terutama pada sistem dengan sumber yang terhad. Pendekatan ini menjadikan model lebih cepat dan lebih cekap sambil mengekalkan ketepatan.
Untuk menilai prestasi model kami, kami memberi tumpuan kepada tiga metrik utama:
Untuk memastikan kajian penanda aras ini difokuskan dan praktikal, kami membuat andaian berikut dan menetapkan beberapa sempadan:
Andaian ini memastikan penanda aras tetap relevan untuk pemaju dan pasukan yang bekerja dengan perkakasan yang terkawal sumber atau yang memerlukan prestasi yang boleh diramal tanpa kerumitan sistem yang diedarkan.
Kami akan meneroka alat dan kerangka penting yang digunakan untuk menanda aras dan mengoptimumkan kesimpulan model pembelajaran yang mendalam pada CPU, memberikan gambaran tentang keupayaan mereka untuk pelaksanaan yang cekap dalam persekitaran yang terkawal sumber.
Kami menggunakan GitHub Codespace (mesin maya) dengan konfigurasi di bawah:
Versi pakej yang digunakan adalah seperti berikut dan utama ini termasuk lima perpustakaan kesimpulan pembelajaran mendalam: Tensorflow, Pytorch, Onnx Runtime, Jax, dan Openvino:
! Pip memasang numpy == 1.26.4 ! Pip Pasang Obor == 2.2.2 ! Pip Pasang TensorFlow == 2.16.2 ! Pip Install Onnx == 1.17.0 ! Pip Pasang onnxruntime == 1.17.0! Pip Pasang Jax == 0.4.30 ! Pip Pasang JaxLib == 0.4.30 ! Pip Pasang OpenVino == 2024.6.0 ! Pip memasang matplotlib == 3.9.3 ! Pip memasang matplotlib: 3.4.3 ! Pip memasang bantal: 8.3.2 ! Pip Pasang PSUTIL: 5.8.0
Oleh kerana kesimpulan model terdiri daripada melakukan beberapa operasi matriks antara berat rangkaian dan data input, ia tidak memerlukan latihan model atau dataset. Untuk contoh kami proses penandaarasan, kami mensimulasikan kes penggunaan klasifikasi standard. Ini menyerupai tugas klasifikasi binari yang biasa seperti pengesanan spam dan keputusan permohonan pinjaman (kelulusan atau penafian). Sifat binari masalah ini menjadikan mereka ideal untuk membandingkan prestasi model di seluruh rangka kerja yang berbeza. Persediaan ini mencerminkan sistem dunia sebenar tetapi membolehkan kita memberi tumpuan kepada prestasi kesimpulan merentasi rangka kerja tanpa memerlukan dataset besar atau model terlatih.
Tugas sampel melibatkan meramalkan sama ada sampel yang diberikan adalah spam atau tidak (kelulusan pinjaman atau penafian), berdasarkan satu set ciri input. Masalah klasifikasi binari ini adalah efisien yang komputasi, membolehkan analisis fokus prestasi kesimpulan tanpa kerumitan tugas klasifikasi pelbagai kelas.
Untuk mensimulasikan data e-mel dunia sebenar, kami menjana input secara rawak. Lembaran ini meniru jenis data yang mungkin diproses oleh penapis spam tetapi mengelakkan keperluan untuk dataset luaran. Data input simulasi ini membolehkan penandaarasan tanpa bergantung pada mana -mana dataset luaran tertentu, menjadikannya sesuai untuk menguji masa kesimpulan model, penggunaan memori, dan prestasi CPU. Sebagai alternatif, anda boleh menggunakan klasifikasi imej, tugas NLP atau tugas pembelajaran mendalam yang lain untuk melaksanakan proses penandaarasan ini.
Pemilihan model adalah langkah kritikal dalam penandaarasan kerana ia secara langsung mempengaruhi prestasi kesimpulan dan pandangan yang diperoleh dari proses profil. Seperti yang disebutkan dalam bahagian sebelumnya, untuk kajian penandaarasan ini, kami memilih kes penggunaan klasifikasi standard, yang melibatkan mengenal pasti sama ada e -mel yang diberikan adalah spam atau tidak. Tugas ini adalah masalah klasifikasi dua kelas yang mudah dikomputasi namun memberikan hasil yang bermakna untuk perbandingan merentasi kerangka.
Model untuk tugas klasifikasi adalah rangkaian neural feedforward (FNN) yang direka untuk klasifikasi binari (spam vs tidak spam). Ia terdiri daripada lapisan berikut:
self.fc1 = obor.nn.linear (200,128)
self.fc2 = obor.nn.linear (128, 64) self.fc3 = obor.nn.linear (64, 32) self.fc4 = obor.nn.linear (32, 16) self.fc5 = obor.nn.linear (16, 8) self.fc6 = obor.nn.linear (8, 1)
self.sigmoid = obor.nn.sigmoid ()
Model ini mudah tetapi berkesan untuk tugas klasifikasi.
Gambar rajah seni bina model yang digunakan untuk penandaarasan dalam kes penggunaan kami ditunjukkan di bawah:
Aliran kerja ini bertujuan untuk membandingkan prestasi kesimpulan pelbagai kerangka pembelajaran dalam (Tensorflow, Pytorch, Onnx, Jax, dan Openvino) menggunakan tugas klasifikasi. Tugas ini melibatkan menggunakan data input yang dijana secara rawak dan penanda aras setiap rangka kerja untuk mengukur masa purata yang diambil untuk ramalan.
Untuk memulakan dengan penanda aras model pembelajaran mendalam, kita perlu mengimport pakej Python penting yang membolehkan integrasi dan penilaian prestasi lancar.
masa import Import OS import numpy sebagai np obor import Import Tensorflow sebagai TF dari input import tensorflow.keras import onnxruntime sebagai ort import matplotlib.pyplot sebagai PLT dari gambar import pil Import psutil Import Jax import jax.numpy sebagai jnp dari Openvino.Runtime Import Core Import CSV
os.environ ["cuda_visible_devices"] = "-1" # lumpuhkan gpu os.environ ["tf_cpp_min_log_level"] = "3" #Suppress Tensorflow Log
Dalam langkah ini, kami secara rawak menjana data input untuk klasifikasi spam:
Kami menjana data randome menggunakan Numpy untuk berfungsi sebagai ciri input untuk model.
#Generate data dummy input_data = np.random.rand (1000, 200) .Astype (np.float32)
Dalam langkah ini, kami mentakrifkan seni bina Netwrok atau membuat model dari setiap rangka kerja pembelajaran yang mendalam (Tensorflow, Pytorch, Onnx, Jax dan Openvino). Setiap rangka memerlukan kaedah khusus untuk memuatkan model dan menetapkannya untuk kesimpulan.
kelas pytorchmodel (obor.nn.module):
def __init __ (diri):
super (pytorchmodel, diri) .__ init __ ()
self.fc1 = obor.nn.linear (200, 128)
self.fc2 = obor.nn.linear (128, 64)
self.fc3 = obor.nn.linear (64, 32)
self.fc4 = obor.nn.linear (32, 16)
self.fc5 = obor.nn.linear (16, 8)
self.fc6 = obor.nn.linear (8, 1)
self.sigmoid = obor.nn.sigmoid ()
def forward (diri, x):
x = obor.relu (self.fc1 (x))
x = obor.relu (self.fc2 (x))
x = obor.relu (self.fc3 (x))
x = obor.relu (self.fc4 (x))
x = obor.relu (self.fc5 (x))
x = self.sigmoid (self.fc6 (x))
kembali x
# Buat Model PyTorch
pytorch_model = pytorchModel () tensorflow_model = tf.keras.sequential ([[
Input (bentuk = (200,)),
tf.keras.layers.dense (128, pengaktifan = 'relu'),
tf.keras.layers.dense (64, pengaktifan = 'relu'),
tf.keras.layers.dense (32, pengaktifan = 'relu'),
tf.keras.layers.dense (16, pengaktifan = 'relu'),
tf.keras.layers.dense (8, pengaktifan = 'relu'),
tf.keras.layers.dense (1, pengaktifan = 'sigmoid')
])
tensorflow_model.compile () def jax_model (x):
x = jax.nn.relu (jnp.dot (x, jnp.ones ((200, 128))))
x = jax.nn.relu (jnp.dot (x, jnp.ones ((128, 64))))
x = jax.nn.relu (jnp.dot (x, jnp.ones ((64, 32))))
x = jax.nn.relu (jnp.dot (x, jnp.ones ((32, 16))))
x = jax.nn.relu (jnp.dot (x, jnp.ones ((16, 8))))
x = jax.nn.sigmoid (jnp.dot (x, jnp.ones ((8, 1))))
kembali x # Tukar model pytorch ke onnx
dummy_input = obor.randn (1, 200)
onnx_model_path = "model.onnx"
obor.onnx.export (
pytorch_model,
dummy_input,
onnx_model_path,
export_params = benar,
opset_version = 11,
input_names = ['input'],
output_names = ['output'],
dynamic_axes = {'input': {0: 'batch_size'}, 'output': {0: 'batch_size'}}
)
onnx_session = ort.inferencesession (onnx_model_path)# Definisi Model Openvino teras = teras () openVino_model = core.read_model (model = "model.onnx") compiled_model = core.compile_model (openVino_model, device_name = "cpu")
Fungsi ini melaksanakan ujian penanda aras merentasi rangka kerja yang berbeza dengan mengambil tiga argumen: predict_function, input_data, dan num_runs. Secara lalai, ia melaksanakan 1,000 kali tetapi ia boleh ditingkatkan mengikut keperluan.
DEF Benchmark_model (predict_function, input_data, num_runs = 1000):
start_time = time.time ()
proses = psutil.process (os.getPid ())
cpu_usage = []
Memory_usage = []
untuk _ dalam julat (num_runs):
predict_function (input_data)
cpu_usage.append (process.cpu_percent ())
Memory_usage.append (process.memory_info (). RSS)
end_time = time.time ()
avg_latency = (end_time - start_time) / num_runs
avg_cpu = np.mean (cpu_usage)
avg_memory = np.mean (memory_usage) / (1024 * 1024) # Tukar ke MB
Kembalikan AVG_LATENCY, AVG_CPU, AVG_MEMORYSekarang kita telah memuatkan model, sudah tiba masanya untuk menanda aras prestasi setiap rangka kerja. Proses penandaarasan melakukan kesimpulan pada data input yang dihasilkan.
# Model Pytorch Benchmark
def pytorch_predict (input_data):
pytorch_model (obor.tensor (input_data))
pytorch_latency, pytorch_cpu, pyTorch_memory = Benchmark_model (lambda x: pytorch_predict (x), input_data) # Model Tensorflow Benchmark
def tensorflow_predict (input_data):
tensorflow_model (input_data)
tensorflow_latency, tensorflow_cpu, tensorflow_memory = benchmark_model (lambda x: tensorflow_predict (x), input_data) # Model penanda aras jax
def jax_predict (input_data):
jax_model (jnp.array (input_data))
JAX_LATENCY, JAX_CPU, JAX_MEMORY = Benchmark_model (Lambda X: JAX_PREDICT (X), input_data) # Model onnx penanda aras
def onnx_predict (input_data):
# Proses input dalam kelompok
untuk i dalam julat (input_data.shape [0]):
single_input = input_data [i: i 1] # Ekstrak input tunggal
onnx_session.run (none, {onnx_session.get_inputs () [0] .name: single_input})
onnx_latency, onnx_cpu, onnx_memory = benchmark_model (lambda x: onnx_predict (x), input_data) # Model Openvino penanda aras
def openvino_predict (input_data):
# Proses input dalam kelompok
untuk i dalam julat (input_data.shape [0]):
single_input = input_data [i: i 1] # Ekstrak input tunggal
compiled_model.infer_new_request ({0: single_input})
OpenVino_Latency, OpenVino_CPU, OpenVino_Memory = Benchmark_Model (lambda x: openvino_predict (x), input_data)
Di sini kita membincangkan hasil penanda aras prestasi yang disebutkan sebelumnya. Kami membandingkannya - latensi, penggunaan CPU, dan penggunaan memori. Kami telah memasukkan data tabular dan plot untuk perbandingan cepat.
| Rangka Kerja | Latihan (MS) | Latihan relatif (vs Pytorch) |
| Pytorch | 1.26 | 1.0 (garis dasar) |
| Tensorflow | 6.61 | ~ 5.25 × |
| Jax | 3.15 | ~ 2.50 × |
| Onnx | 14.75 | ~ 11.72 × |
| Openvino | 144.84 | ~ 115 × |
Wawasan:
| Rangka Kerja | Penggunaan CPU (%) | Penggunaan CPU Relatif 1 |
| Pytorch | 99.79 | ~ 1.00 |
| Tensorflow | 112.26 | ~ 1.13 |
| Jax | 130.03 | ~ 1.31 |
| Onnx | 99.58 | ~ 1.00 |
| Openvino | 99.32 | 1.00 (garis dasar) |
Wawasan:
| Rangka Kerja | Memori (MB) | Penggunaan Memori Relatif (vs Pytorch) |
| Pytorch | ~ 959.69 | 1.0 (garis dasar) |
| Tensorflow | ~ 969.72 | ~ 1.01 × |
| Jax | ~ 1033.63 | ~ 1.08 × |
| Onnx | ~ 1033.82 | ~ 1.08 × |
| Openvino | ~ 1040.80 | ~ 1.08-1.09 × |
Wawasan:
Berikut adalah plot yang membandingkan prestasi kerangka pembelajaran mendalam:
Dalam artikel ini, kami membentangkan aliran kerja penanda aras yang komprehensif untuk menilai prestasi kesimpulan kerangka pembelajaran mendalam -tensorflow, Pytorch, Onnx, Jax, dan Openvino -menggunakan tugas klasifikasi spam sebagai rujukan. Dengan menganalisis metrik utama seperti latensi, penggunaan CPU dan penggunaan memori, hasilnya menyerlahkan perdagangan antara kerangka dan kesesuaian mereka untuk senario penempatan yang berbeza.
Pytorch menunjukkan prestasi yang paling seimbang, cemerlang dalam latensi rendah dan penggunaan memori yang cekap, menjadikannya sesuai untuk aplikasi sensitif latency seperti ramalan masa nyata dan sistem cadangan. Tensorflow menyediakan penyelesaian tengah tanah dengan penggunaan sumber yang lebih tinggi. Jax mempamerkan melalui pengiraan pengiraan yang tinggi tetapi pada kos penggunaan CPU yang meningkat, yang mungkin merupakan faktor yang membatasi untuk persekitaran yang terkawal sumber. Sementara itu, Onnx dan Openvino tertinggal dalam latensi, dengan prestasi Openvino terutamanya terhalang oleh ketiadaan percepatan perkakasan.
Penemuan ini menggariskan kepentingan menyelaraskan pemilihan kerangka dengan keperluan penggunaan. Sama ada mengoptimumkan kelajuan, kecekapan sumber, atau perkakasan tertentu, memahami perdagangan adalah penting untuk penggunaan model yang berkesan dalam persekitaran dunia sebenar.
Grafik pengiraan dinamik Pytorch dan saluran paip pelaksanaan yang cekap membolehkan kesimpulan latency rendah (1.26 ms), menjadikannya sesuai untuk aplikasi seperti sistem cadangan dan ramalan masa nyata.
S2. Apa yang mempengaruhi prestasi Openvino dalam kajian ini?Pengoptimuman Openvino direka untuk perkakasan Intel. Tanpa pecutan ini, latensi (144.84 ms) dan penggunaan memori (1040.8 MB) kurang kompetitif berbanding dengan rangka kerja lain.
Q3. Bagaimanakah saya memilih rangka kerja untuk persekitaran yang terkawal sumber?A. Untuk persediaan CPU sahaja, pytorch adalah yang paling berkesan. TensorFlow adalah alternatif yang kuat untuk beban kerja yang sederhana. Elakkan kerangka seperti JAX melainkan penggunaan CPU yang lebih tinggi dapat diterima.
Q4. Apakah peranan yang dimainkan oleh perkakasan dalam prestasi kerangka?A. Prestasi kerangka bergantung pada keserasian perkakasan. Sebagai contoh, Openvino cemerlang pada CPU Intel dengan pengoptimuman khusus perkakasan, manakala pytorch dan tensorflow melakukan secara konsisten merentasi pelbagai persediaan.
S5. Bolehkah hasil penandaarasan berbeza dengan model atau tugas yang kompleks?A. Ya, hasil ini mencerminkan tugas klasifikasi binari yang mudah. Prestasi boleh berbeza -beza dengan seni bina yang kompleks seperti resnet atau tugas seperti NLP atau yang lain, di mana rangka kerja ini mungkin memanfaatkan pengoptimuman khusus.
Media yang ditunjukkan dalam artikel ini tidak dimiliki oleh Analytics Vidhya dan digunakan atas budi bicara penulis.
Atas ialah kandungan terperinci Penanda aras CPU pembelajaran yang mendalam. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
Bagaimana untuk memulihkan set kepala Bluetooth kepada mod binaural
Apakah pelayar edge?
Win10 tidak menyokong penyelesaian susun atur cakera perisian tegar Uefi
Bagaimana untuk menggunakan fungsi dict dalam Python
Apakah perbezaan antara hibernate dan mybatis
Apakah yang perlu saya lakukan jika iis tidak boleh bermula?
apa maksud bbs
Kelebihan dan Kelemahan Pelayan Laman Web Luar Negara Percuma
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
