深度學習CPU基準

深度學習GPU基準測試徹底改變了我們解決複雜問題的方式，從圖像識別到自然語言處理。但是，在培訓這些模型時，通常依賴於高性能的GPU，將它們有效地部署在資源受限的環境中，例如邊緣設備或有限的硬件系統提出了獨特的挑戰。 CPU，廣泛可用且具有成本效益，通常是在這種情況下推斷的骨幹。但是，我們如何確保部署在CPU上的模型在不損害準確性的情況下提供最佳性能？

本文深入研究了對CPU的深度學習模型推斷的基準測試，重點介紹了三個關鍵指標：延遲，CPU利用率和內存利用率。使用垃圾郵件分類示例，我們探討了Pytorch，Tensorflow，Jax和ONNX運行時手柄推理工作負載等流行框架。最後，您將對如何衡量性能，優化部署並為資源受限環境中的基於CPU推斷的推理選擇正確的工具和框架有清晰的了解。

影響：最佳推理執行可以節省大量資金，並為其他工作量提供免費資源。

學習目標

• 了解深度學習CPU基准在評估AI模型培訓和推理硬件性能中的作用。
• 評估Pytorch，Tensorflow，Jax，OnNX運行時和OpenVino運行時，以選擇最適合您的需求。
• 諸如psutil的主工具和收集準確的性能數據並優化推理的時間。
• 準備模型，運行推理並衡量性能，將技術應用於圖像分類和NLP等各種任務。
• 確定瓶頸，優化模型並提高性能，同時有效地管理資源。

本文作為數據科學博客馬拉鬆的一部分發表。

目錄

• 通過運行時加速進行優化推理
• 模型推理性能指標
• 假設和局限性
• 工具和框架
• 安裝依賴項
• 問題說明和輸入規範
• 模型架構和格式
• 基準測試的其他網絡的示例
• 基準的工作流程
• 基準函數定義
• 模型推理並為每個框架執行基準測試
• 結果與討論
• 結論
• 常見問題

通過運行時加速進行優化推理

推理速度對於用戶體驗和機器學習應用程序的運營效率至關重要。運行時優化在通過簡化執行來增強它方面起著關鍵作用。使用諸如ONNX運行時的硬件加速庫會利用針對特定體系結構的優化，減少延遲（每次推理時間）。

此外，輕巧的模型格式，例如ONNX最小化開銷，從而更快地加載和執行。優化的運行時間利用並行處理來在可用的CPU內核上分發計算並改善內存管理，從而確保更好的性能，尤其是在資源有限的系統上。這種方法使模型在保持準確性的同時更快，更有效。

模型推理性能指標

為了評估模型的性能，我們專注於三個關鍵指標：

潛伏期

• 定義：延遲是指在接收輸入後進行預測所需的時間。這通常是作為從發送輸入數據到接收輸出（預測）所花費的時間來衡量的。
• 重要性：在實時或近實時應用程序中，高潛伏期會導致延遲，這可能會導致響應較慢。
• 測量：延遲通常以毫秒（MS）或秒為單位。較短的延遲意味著該系統響應效率更高，對需要立即決策或行動的應用至關重要。

CPU利用率

• 定義：CPU利用率是執行推理任務時消耗的CPU處理能力的百分比。它告訴您模型推斷期間系統使用了多少計算資源。
• 重要性：高CPU使用意味著機器可能很難同時處理其他任務，從而導致瓶頸。有效利用CPU資源可確保模型推斷不會壟斷系統資源。
• 測量人員T：通常以可用CPU資源總數的百分比（％）測量。同一工作負載的較低利用通常表明更優化的模型，更有效地利用CPU資源。

內存利用率

• 定義：內存利用率是指模型在推理過程中使用的RAM量。它通過模型的參數，中間計算和輸入數據跟踪內存消耗。
• 重要性：在將模型部署到邊緣設備或系統有限的內存中時，優化內存使用量尤為重要。高內存消耗可能會導致內存過浮力，較慢的處理或系統崩潰。
• 測量：內存利用率是Megabytes（MB）或GB（GB）中的測量值。在推理的不同階段跟踪內存消耗可以幫助識別內存效率低下或內存洩漏。

假設和局限性

為了保持這項基準研究的重點和實用，我們做出了以下假設並設定了一些界限：

• 硬件約束：測試旨在在具有有限的CPU內核的單台計算機上運行。儘管現代硬件能夠處理並行工作負載，但此設置反映了在邊緣設備或較小規模部署中經常看到的約束。
• 沒有多系統並行化：我們沒有合併分佈式計算設置或基於群集的解決方案。基準反映了性能獨立條件，適用於有限的CPU內核和內存的單節點環境。
• 範圍：主要重點僅在於CPU推理性能。雖然基於GPU的推理是資源密集型任務的絕佳選擇，但該基準測試旨在提供對僅CPU的設置的見解，在成本敏感或便攜式應用程序中更常見。

這些假設確保基準與使用資源受限硬件的開發人員和團隊相關，或者需要可預測的性能而沒有分佈式系統的複雜性。

工具和框架

我們將探討用於基準和優化CPU的深度學習模型推斷的基本工具和框架，從而提供了對其能力的見解，以在資源受限的環境中有效執行。

分析工具

• Python Time （時間庫） ：Python中的時間庫是用於測量代碼塊的執行時間的輕量級工具。通過記錄開始和結束時間戳記，它有助於計算模型推理或數據處理等操作所花費的時間。
• PSUTIL（CPU，內存分析） ： PSUTI L是用於維持監視和分析的Python庫。它提供有關CPU使用，內存消耗，磁盤I/O等的實時數據，也非常適合在模型培訓或推理過程中分析使用情況。

推理框架

• TensorFlow ：一個強大的深度學習框架，廣泛用於培訓和推理任務。它為各種模型和部署策略提供了強有力的支持。
• Pytorch： Pytorch以易用性和動態計算圖而聞名，是研究和生產部署的流行選擇。
• ONNX運行時：用於運行ONXX（開放神經網絡交換）模型的開源，跨平台引擎，可在各種硬件和框架上提供有效的推斷。
• JAX ：一個功能框架，側重於高性能數值計算和機器學習，提供自動分化和GPU/TPU加速度。
• OpenVino：OpenVino針對英特爾硬件進行了優化，為Intel CPU，GPU和VPU提供了模型優化和部署的工具。

硬件規範和環境

我們正在利用github codespace（虛擬機），以下配置：

• 虛擬機的規格： 2個內核，8 GB RAM和32 GB存儲
• Python版本： 3.12.1

安裝依賴項

所使用的包裝的版本如下，此主要包括五個深度學習推理庫：Tensorflow，Pytorch，Onnx Runtime，Jax和OpenVino：

 ！pip安裝numpy == 1.26.4
！pip安裝火炬== 2.2.2
！PIP安裝TensorFlow == 2.16.2
！pip安裝onnx == 1.17.0
！pip安裝onnxRuntime == 1.17.0！
！pip安裝jaxlib == 0.4.30
！PIP安裝OpenVino == 2024.6.0
！pip安裝matplotlib == 3.9.3
！pip安裝matplotlib：3.4.3
！PIP安裝枕頭：8.3.2
！pip安裝psutil：5.8.0

問題說明和輸入規範

由於模型推斷包括在網絡權重和輸入數據之間執行一些矩陣操作，因此它不需要模型培訓或數據集。對於我們的示例，我們模擬了標準分類用例。這模擬了常見的二進制分類任務，例如垃圾郵件檢測和貸款申請決策（批准或拒絕）。這些問題的二進制性質使它們是比較不同框架模型性能的理想選擇。該設置反映了現實世界中的系統，但使我們能夠將重點放在跨框架的推理性能上，而無需大型數據集或預訓練的模型。

問題陳述

樣本任務涉及根據一組輸入功能預測給定樣本是垃圾郵件（貸款批准還是拒絕）。這個二進制分類問題在計算上是有效的，可以重點分析推理性能，而沒有多類分類任務的複雜性。

輸入規範

為了模擬現實世界電子郵件數據，我們生成了隨機輸入。這些嵌入模仿垃圾郵件過濾器可能處理的數據類型，但避免了對外部數據集的需求。該模擬輸入數據允許在不依賴任何特定外部數據集的情況下進行基準測試，這是測試模型推理時間，內存使用情況和CPU性能的理想選擇。另外，您可以使用圖像分類，NLP任務或任何其他深度學習任務來執行此基準測試過程。

模型架構和格式

模型選擇是基準測試的關鍵步驟，因為它直接影響了從分析過程中獲得的推理性能和見解。如上一節所述，對於這項基準測試研究，我們選擇了標準分類用例，其中涉及確定給定的電子郵件是否是垃圾郵件。此任務是一個直接的兩類分類問題，它在計算上有效，但為跨框架進行比較提供了有意義的結果。

基準測試模型架構

分類任務的模型是為二進制分類設計的饋電神經網絡（FNN）（垃圾郵件與垃圾郵件）。它由以下層組成：

• 輸入層：接受尺寸200的向量（嵌入功能）。我們提供了Pytorch的示例，其他框架遵循完全相同的網絡配置

self.fc1 = torch.nn.linear（200,128）

• 隱藏層：該網絡具有5個隱藏的圖層，每個連續的圖層包含的單位少於前面的單元。

 self.fc2 = torch.nn.linear（128，64）
self.fc3 = torch.nn.linear（64，32）
self.fc4 = torch.nn.linear（32，16）
self.fc5 = torch.nn.linear（16，8）
self.fc6 = torch.nn.linear（8，1）

• 輸出層：具有Sigmoid激活函數的單個神經元以輸出概率（對於不垃圾郵件為0，垃圾郵件為1）。我們利用Sigmoid層作為二進制分類的最終輸出。

 self.sigmoid = torch.nn.sigmoid（）

該模型對於分類任務很簡單，但有效。

在我們的用例中用於基準測試的模型體系結構圖如下所示：

基準測試的其他網絡的示例

• 圖像分類：可以將諸如Resnet-50（中等複雜性）和Mobilenet（輕量級）之類的模型添加到基準套件中，以進行涉及圖像識別的任務。 Resnet-50在計算複雜性和準確性之間提供了平衡，而Mobilenet則針對低資源環境進行了優化。
• NLP任務： Distilbert ：BERT模型的較小，更快的變體，適合自然語言理解任務。

模型格式

• 天然格式：每個框架都支持其本機模型格式，例如Pytorch的.pt和tensorflow的.h5 。
• 統一格式（ONNX） ：為了確保跨框架的兼容性，我們將Pytorch模型導出到ONNX格式（model.onnx）。 ONNX（開放的神經網絡交換）充當橋樑，使模型可以在Pytorch，Tensorflow，Jax或OpenVino等其他框架中使用，而無需進行重大修改。這對於互操作性至關重要的多框架測試和現實部署方案特別有用。
• 這些格式針對其各自的框架進行了優化，使其易於保存，加載和部署這些生態系統。

基準的工作流程

該工作流旨在比較使用分類任務的多個深度學習框架（Tensorflow，Pytorch，Onnx，Jax和OpenVino）的推理性能。該任務涉及使用隨機生成的輸入數據並根據每個框架進行基準測試以測量預測所花費的平均時間。

• 導入Python軟件包
• 禁用GPU使用並抑制TensorFlow記錄
• 輸入數據準備
• 每個框架的模型實現
• 基準功能定義
• 每個框架的模型推理和基準測試執行
• 基準結果的可視化和導出

導入必要的Python軟件包

為了開始基準測試深度學習模型，我們首先需要導入實現無縫集成和性能評估的基本Python軟件包。

進口時間
導入操作系統
導入numpy作為NP
導入火炬
導入TensorFlow作為TF
來自TensorFlow.keras導入輸入
導入OnnxRuntime AS Ort
導入matplotlib.pyplot作為PLT
從PIL導入圖像
導入psutil
導入JAX
導入jax.numpy作為jnp
來自OpenVino.runtime Import Core
導入CSV

禁用GPU使用並抑制TensorFlow記錄

os.environ [“ cuda_visible_devices”] =“ -1”＃disable gpu
os.environ [“ tf_cpp_min_log_level”] =“ 3” #suppress tensorflow log

輸入數據準備

在此步驟中，我們隨機生成用於垃圾郵件分類的輸入數據：

• 樣本的維度（200段的特徵）
• 類的數量（2：垃圾郵件或不垃圾郵件）

我們使用Numpy生成Randome數據，以作為模型的輸入功能。

 #Generate虛擬數據
input_data = np.random.rand（1000，200）.stype（np.float32）

模型定義

在此步驟中，我們從每個深度學習框架（Tensorflow，Pytorch，Onnx，Jax和OpenVino）定義NetWrok體系結構或設置模型。每個框架都需要一種特定的方法來加載模型並將其設置為推斷。

• Pytorch模型：在Pytorch中，我們定義了一個具有五個完全連接層的簡單神經網絡結構。
• TensorFlow模型：使用KERAS API定義了TensorFlow模型，並由用於分類任務的簡單饋電神經網絡組成。
• JAX模型：該模型是用參數初始化的，並且使用JAX的JAX-IN-INTIME（JIT）彙編編輯了預測函數，以進行有效的執行。
• ONNX模型：對於ONNX，我們從Pytorch導出了一個模型。導出到ONNX格式後，我們使用OnnxRuntime加載模型。推論API。這使我們可以通過不同的硬件規範對模型進行推斷。
• OpenVino模型：OpenVino用於運行優化和部署模型，尤其是使用其他框架（例如Pytorch或Tensorflow）訓練的模型。我們加載ONNX型號並使用OpenVino的運行時進行編譯。

Pytorch

 Pytorchmodel類（Torch.nn.Module）：
    def __init __（自我）：
        超級（pytorchmodel，self）.__ init __（）
        self.fc1 = torch.nn.linear（200，128）
        self.fc2 = torch.nn.linear（128，64）
        self.fc3 = torch.nn.linear（64，32）
        self.fc4 = torch.nn.linear（32，16）
        self.fc5 = torch.nn.linear（16，8）
        self.fc6 = torch.nn.linear（8，1）
        self.sigmoid = torch.nn.sigmoid（）

    def向前（self，x）：
        x = torch.relu（self.fc1（x））
        x = torch.relu（self.fc2（x））
        x = torch.relu（self.fc3（x））
        x = torch.relu（self.fc4（x））
        x = torch.relu（self.fc5（x））
        x = self.sigmoid（self.fc6（x））
        返回x
        
     ＃創建Pytorch模型
    pytorch_model = pytorchmodel（）

張量

tensorflow_model = tf.keras.Sequeential（[[
    輸入（Shape =（200，）），
    tf.keras.layers.dense（128，激活='relu'），
    tf.keras.layers.dense（64，activation ='relu'），
    tf.keras.layers.dense（32，activation ='relu'），
    tf.keras.layers.dense（16，activation ='relu'），
    tf.keras.layers.dense（8，activation ='relu'），
    tf.keras.layers.dense（1，激活='Sigmoid'）
）））
tensorflow_model.compile（）

JAX

 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）））））））
    返回x

onnx

 ＃將Pytorch型號轉換為ONNX
dummy_input = torch.randn（1，200）
onnx_model_path =“ model.onnx”
TORCH.ONNX.EXPORT（
    pytorch_model， 
    dummy_input， 
    onnx_model_path， 
    export_params = true， 
    opset_version = 11， 
    input_names = ['input']， 
    output_names = ['輸出']， 
    dynamic_axes = {'input'：{0：'batch_size'}，'output'：{0：'batch_size'}}}
）

onnx_session = ort.inferencesession（onnx_model_path）

Openvino

 ＃OpenVino模型定義
core = core（）
OpenVino_model = core.Read_model（model =“ model.onnx”）
compiled_model = core.compile_model（openvino_model，device_name =“ cpu”）

基準函數定義

該功能通過採用三個參數來執行跨不同框架的基準測試：prection_function，input_data和num_runs。默認情況下，它執行1000次，但可以根據要求增加。

 def benchmark_model（prection_function，input_data，num_runs = 1000）：
    start_time = time.time（）
    process = psutil.process（os.getPid（））
    cpu_usage = []
    memory_usage = []
    對於_範圍（num_runs）：
        preditive_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）＃轉換為MB
    返回avg_latency，avg_cpu，avg_memory

模型推理並為每個框架執行基準測試

現在我們已經加載了模型了，現在該基於每個框架的性能進行基準測試了。基準測試過程對生成的輸入數據執行推斷。

Pytorch

 ＃基準Pytorch模型
def pytorch_predict（input_data）：
    pytorch_model（torch.tensor（input_data）））

pytorch_latency，pytorch_cpu，pytorch_memory = benchmark_model（lambda x：pytorch_predict（x），input_data）

張量

＃基準TensorFlow模型
def tensorflow_predict（input_data）：
    tensorflow_model（input_data）

tensorflow_latency，tensorflow_cpu，tensorflow_memory = benchmark_model（lambda x：tensorflow_predict（x），input_data）

JAX

 ＃基準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）

onnx

 ＃基準ONNX模型
def onnx_predict（input_data）：
    ＃批量的過程輸入
    對於i在範圍內（input_data.shape [0]）：
        single_input = input_data [i：i 1]＃提取單輸入
        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）

Openvino

 ＃基準OpenVino模型
DEF OPENVINO_PREDICT（INPUT_DATA）：
    ＃批量的過程輸入
    對於i在範圍內（input_data.shape [0]）：
        single_input = input_data [i：i 1]＃提取單輸入
        compiled_model.infer_new_request（{0：single_input}）

OpenVINO_LATENCY，OPENVINO_CPU，OPENVINO_MEMORY = BENCHMARK_MODEL（LAMBDA X：OPENVINO_PREDICT（X），INPUT_DATA）

結果與討論

在這裡，我們討論了前面提到的深度學習框架的性能基準測試結果。我們將它們進行比較 - 延遲，CPU使用和內存使用情況。我們包含了表格數據和圖，以進行快速比較。

延遲比較

框架	潛伏期（MS）	相對延遲（與Pytorch）
Pytorch	1.26	1.0（基線）
張量	6.61	〜5.25×
JAX	3.15	〜2.50×
onnx	14.75	〜11.72×
Openvino	144.84	〜115×

見解：

• Pytorch是最快的框架，延遲〜1.26毫秒。
• TensorFlow具有〜6.61毫秒的延遲，約5.25×Pytorch的時間。
• JAX位於Pytorch和Tensorflow之間，絕對延遲。
• ONNX也相對較慢，約為14.75毫秒。
• OpenVino是該實驗中最慢的，約為145 ms （比Pytorch慢115倍）。

CPU用法

框架	CPU使用（％）	相對CPU用法 1
Pytorch	99.79	〜1.00
張量	112.26	〜1.13
JAX	130.03	〜1.31
onnx	99.58	〜1.00
Openvino	99.32	1.00（基線）

見解：

• JAX使用最多的CPU（約130％ ），比OpenVino高31％。
• TensorFlow的含量約為112％ ，超過Pytorch/Onnx/OpenVino，但仍低於JAX。
• Pytorch，ONNX和OpenVino的CPU使用量〜99-100％ 。

內存使用

框架	內存（MB）	相對內存使用（與Pytorch）
Pytorch	〜959.69	1.0（基線）
張量	〜969.72	〜1.01×
JAX	〜1033.63	〜1.08×
onnx	〜1033.82	〜1.08×
Openvino	〜1040.80	〜1.08–1.09×

見解：

• Pytorch和TensorFlow在〜960-970 MB附近具有相似的內存使用量
• JAX，ONNX和OpenVino的使用率約為1,030–1,040 MB ，比Pytorch高出約8–9％。

這是比較深度學習框架表現的情節：

結論

在本文中，我們提出了一個全面的基準工作流程，以評估突出的深度學習框架的推理性能 - Tensorflow，Pytorch，pytorch，Onnx，Jax和OpenVino-使用垃圾郵件分類任務作為參考。通過分析關鍵指標，例如延遲，CPU使用和記憶消耗，結果突出了框架與其對不同部署方案的適用性之間的權衡。

Pytorch表現出最平衡的性能，在低潛伏期和有效的內存使用方面表現出色，使其非常適合對潛伏期敏感的應用，例如實時預測和建議系統。 TensorFlow提供了一種中間地面解決方案，具有中等程度的資源消耗。 JAX展示了高計算吞吐量，但以增加CPU利用率為代價，這可能是資源受限環境的限制因素。同時，ONNX和OpenVino的潛伏期滯後，OpenVino的性能尤其受到硬件加速度的阻礙。

這些發現強調了將框架選擇與部署需求保持一致的重要性。無論是針對速度，資源效率還是特定的硬件進行優化，理解權衡取捨對於在現實世界中的有效模型部署至關重要。

關鍵要點

• 深度學習的CPU基準為CPU性能提供了重要的見解，可幫助為AI任務選擇最佳硬件。
• 利用深度學習CPU基準測試可通過識別高性能CPU來確保有效的模型培訓和推斷。
• 達到了最佳的延遲（1.26毫秒）並保持有效的內存使用情況，非常適合實時和資源有限的應用程序。
• 平衡延遲（6.61毫秒），使用CPU略高，適用於需要適度績效妥協的任務。
• 提供了競爭性延遲（3.15毫秒），但以過高的CPU利用為代價（ 130％ ），從而限制了其在受限設置中的效用。
• 顯示出較高的延遲（14.75毫秒），但其跨平台支持使其適用於多幀部署。

常見問題

Q1。為什麼Pytorch首選用於實時應用？

A. Pytorch的動態計算圖和有效的執行管道允許低延節推斷（1.26 ms），使其適合於推薦系統和實時預測等應用。

Q2。是什麼影響了OpenVino在這項研究中的表現？

答：OpenVino的優化是為Intel硬件設計的。沒有這種加速度，與其他框架相比，它的延遲（144.84 ms）和內存使用情況（1040.8 MB）的競爭力較低。

Q3。如何為資源受限環境選擇一個框架？

答：對於僅CPU的設置，Pytorch是最有效的。 TensorFlow是適度工作負載的強大替代方法。除非可以接受較高的CPU利用率，否則避免使用JAX之類的框架。

Q4。硬件在框架性能中起什麼作用？

答：框架性能在很大程度上取決於硬件兼容性。例如，OpenVino在Intel CPU上具有特定於硬件的優化，而Pytorch和Tensorflow則在各種設置中持續執行。

Q5。基準測試結果是否會因複雜模型或任務而有所不同嗎？

答：是的，這些結果反映了一個簡單的二進制分類任務。性能可能會隨複雜的架構（例如Resnet或NLP或其他人）等任務而變化，這些框架可能會利用專業的優化。

本文所示的媒體不由Analytics Vidhya擁有，並由作者酌情使用。

以上是深度學習CPU基準的詳細內容。更多資訊請關注PHP中文網其他相關文章！