Deep Learning GPU -Benchmarks hat die Art und Weise, wie wir komplexe Probleme lösen, von der Bilderkennung bis zur Verarbeitung natürlicher Sprache revolutioniert. Während das Training dieser Modelle häufig auf Hochleistungs-GPUs beruht, stellen sie effektiv in ressourcenbezogenen Umgebungen wie Edge-Geräten oder Systemen mit begrenzten Hardware ein. CPUs, das weit verbreitet und kostengünstig ist, dient häufig als Rückgrat für die Schlussfolgerung in solchen Szenarien. Aber wie stellen wir sicher, dass die auf CPUs bereitgestellten Modelle eine optimale Leistung bieten, ohne die Genauigkeit zu beeinträchtigen?
Dieser Artikel taucht in das Benchmarking von Deep Learning Model -Inferenz auf CPUs ein und konzentriert sich auf drei kritische Metriken: Latenz, CPU -Nutzung und Speicherauslastung. Mit einem Spam -Klassifizierungsbeispiel untersuchen wir, wie beliebte Frameworks wie Pytorch, TensorFlow, JAX und ONNX -Laufzeit -Griff -Inferenz -Workloads. Am Ende haben Sie ein klares Verständnis für die Messung der Leistung, die Optimierung der Bereitstellungen und die Auswahl der richtigen Tools und Frameworks für CPU-basierte Inferenz in ressourcenbeschränkten Umgebungen.
Auswirkung: Eine optimale Ausführung von Inferenz kann einen erheblichen Geldbetrag einsparen und Ressourcen für andere Workloads freilegen.
Dieser Artikel wurde als Teil des Data Science -Blogathons veröffentlicht.
Inferenzgeschwindigkeit ist für die Benutzererfahrung und die Betriebseffizienz in maschinellen Lernanwendungen von wesentlicher Bedeutung. Die Laufzeitoptimierung spielt eine Schlüsselrolle bei der Verbesserung dieser Durchführung der Ausführung. Die Verwendung von Bibliotheken mit Hardware-Beschleunigungsbibliotheken wie Onnx-Laufzeit nutzt Optimierungen, die auf bestimmte Architekturen zugeschnitten sind und die Latenz verringern (Zeit pro Inferenz).
Darüber hinaus minimieren leichte Modellformate wie ONNX den Overhead und ermöglichen eine schnellere Belastung und Ausführung. Optimierte Laufzeiten nutzen die parallele Verarbeitung, um die Berechnung über verfügbare CPU -Kerne auf und verbessert das Speichermanagement zu verbessern, um eine bessere Leistung zu gewährleisten, insbesondere bei Systemen mit begrenzten Ressourcen. Dieser Ansatz macht die Modelle schneller und effizienter, während die Genauigkeit aufrechterhalten wird.
Um die Leistung unserer Modelle zu bewerten, konzentrieren wir uns auf drei Schlüsselmetrik:
Um diese Benchmarking -Studie fokussiert und praktisch zu halten, haben wir die folgenden Annahmen getroffen und einige Grenzen festgelegt:
Diese Annahmen stellen sicher, dass die Benchmarks für Entwickler und Teams, die mit ressourcenbeschränkten Hardware arbeiten oder die vorhersehbare Leistung benötigen, ohne die zusätzliche Komplexität der verteilten Systeme relevant bleiben.
Wir werden die wesentlichen Tools und Frameworks untersuchen, die zum Benchmark und Optimieren von Deep-Learning-Modell-Inferenz für CPUs verwendet werden, und geben Einblicke in ihre Funktionen für eine effiziente Ausführung in ressourcenbezogenen Umgebungen.
Wir verwenden Github -Codesspace (virtuelle Maschine) mit der folgenden Konfiguration:
Die Versionen der verwendeten Pakete sind wie folgt und in dieser Primärin gehören fünf Deep Learning Inference -Bibliotheken: TensorFlow, Pytorch, Onnx -Laufzeit, Jax und OpenVino:
! PIP Installieren Sie Numpy == 1.26.4 ! PIP Installieren Sie Taschenlampe == 2.2.2 ! PIP Installieren Sie TensorFlow == 2.16.2 ! PIP Installation Onnx == 1.17.0 ! PIP Installieren Sie OnnxRuntime == 1.17.0! ! PIP Installieren Sie JAXLIB == 0.4.30 ! PIP Installieren Sie OpenVino == 2024.6.0 ! PIP Installieren Sie Matplotlib == 3.9.3 ! PIP Installieren Sie Matplotlib: 3.4.3 ! Pip -Kissen installieren: 8.3.2 ! PIP Installieren Sie PSUTIL: 5.8.0
Da Modellinferenz darin besteht, einige Matrixoperationen zwischen Netzwerkgewichten und Eingabedaten auszuführen, erfordert kein Modelltraining oder Datensätze. Für unser Beispiel als Benchmarking -Prozess simuliert wir einen Standard -Klassifizierungs -Anwendungsfall. Dies simuliert gemeinsame Binärklassifizierungsaufgaben wie Spam -Erkennung und Darlehensantragsentscheidungen (Genehmigung oder Ablehnung). Die binäre Natur dieser Probleme macht sie ideal, um die Modellleistung über verschiedene Frameworks hinweg zu vergleichen. Dieses Setup spiegelt reale Systeme wider, ermöglicht es uns jedoch, uns auf die Inferenzleistung über Frameworks hinweg zu konzentrieren, ohne große Datensätze oder vorgebrachte Modelle zu benötigen.
Die Stichprobenaufgabe umfasst die Vorhersage, ob eine bestimmte Stichprobe Spam ist oder nicht (Kreditgenehmigung oder Ablehnung), basierend auf einer Reihe von Eingabefunktionen. Dieses Binärklassifizierungsproblem ist rechnerisch effizient und ermöglicht eine fokussierte Analyse der Inferenzleistung ohne die Komplexität von Klassifizierungsaufgaben mit mehreren Klassen.
Um reale E-Mail-Daten zu simulieren, haben wir zufällig Eingaben generiert. Diese Einbettungen imitieren die Art der Daten, die möglicherweise von Spam -Filtern verarbeitet werden könnten, aber die Notwendigkeit externer Datensätze vermeiden. Diese simulierten Eingabedaten ermöglichen das Benchmarking, ohne sich auf bestimmte externe Datensätze zu verlassen, sodass es ideal zum Testen von Modellinferenzzeiten, Speicherverbrauch und CPU -Leistung. Alternativ können Sie Bildklassifizierung, NLP -Aufgabe oder andere Deep -Lern -Aufgaben verwenden, um diesen Benchmarking -Prozess auszuführen.
Die Modellauswahl ist ein kritischer Schritt beim Benchmarking, da sie die Inferenzleistung und die Erkenntnisse, die aus dem Profilerstellungsprozess gewonnen wurden, direkt beeinflusst. Wie im vorherigen Abschnitt erwähnt, haben wir für diese Benchmarking -Studie einen Standard -Klassifizierungs -Anwendungsfall ausgewählt, der feststellt, ob eine bestimmte E -Mail Spam ist oder nicht. Diese Aufgabe ist ein unkompliziertes Problem der Zweiklasse-Klassifizierung, das rechnerisch effizient ist und dennoch aussagekräftige Ergebnisse für den Vergleich über Rahmenbedingungen liefert.
Das Modell für die Klassifizierungsaufgabe ist ein Feedforward Neural Network (FNN) für binäre Klassifizierung (Spam vs. nicht Spam). Es besteht aus den folgenden Schichten:
self.fc1 = fackel.nn.linear (200,128)
self.fc2 = fackel.nn.linear (128, 64) self.fc3 = fackel.nn.linear (64, 32) self.fc4 = fackel.nn.linear (32, 16) self.fc5 = fackel.nn.linear (16, 8) self.fc6 = fackel.nn.linear (8, 1)
self.sigmoid = t Torch.nn.Sigmoid ())
Das Modell ist einfach und dennoch effektiv für die Klassifizierungsaufgabe.
Das für das Benchmarking in unserem Anwendungsfall verwendete Modellarchitekturdiagramm ist unten dargestellt:
Dieser Workflow zielt darauf ab, die Inferenzleistung mehrerer Deep -Learning -Frameworks (Tensorflow, Pytorch, ONNX, JAX und OpenVino) mit der Klassifizierungsaufgabe zu vergleichen. Die Aufgabe umfasst die Verwendung von zufällig generierten Eingabedaten und das Benchmarking jedes Frameworks, um die durchschnittliche Zeit für eine Vorhersage zu messen.
Um mit Benchmarking Deep Learning -Modellen zu beginnen, müssen wir zunächst die essentiellen Python -Pakete importieren, die eine nahtlose Integration und Leistungsbewertung ermöglichen.
Importzeit OS importieren Numph als NP importieren Taschenlampe importieren Tensorflow als TF importieren Aus TensorFlow.keras Import -Eingabe onnxruntime als ORT importieren matplotlib.pyplot als pLT importieren vom PIL -Importbild psutil importieren Jax importieren Importieren Sie Jax.numpy als JNP vom OpenVino.Runtime Import Core CSV importieren
OS.Environ ["CUDA_VISIBLE_DEVICES"] = "-1" # GPU deaktivieren OS.Environ ["tf_cpp_min_log_level"] = "3" #Suppress TensorFlow -Protokoll
In diesem Schritt generieren wir zufällig Eingabedaten für die SPAM -Klassifizierung:
Wir generieren Randome -Daten mithilfe von Numpy, um als Eingabefunktionen für die Modelle zu dienen.
#Generieren Dummy -Daten input_data = np.random.rand (1000, 200) .Astype (np.float32)
In diesem Schritt definieren wir die Netwrok -Architektur oder richten das Modell aus jedem Deep Learning -Framework (Tensorflow, Pytorch, ONNX, JAX und OpenVino) ein. Jedes Framework erfordert spezielle Methoden zum Laden von Modellen und zum Einrichten von Inferenz.
Klasse Pytorchmodel (Torch.nn.Module):
def __init __ (selbst):
Super (Pytorchmodel, Selbst) .__ init __ ()
self.fc1 = fackel.nn.linear (200, 128)
self.fc2 = fackel.nn.linear (128, 64)
self.fc3 = fackel.nn.linear (64, 32)
self.fc4 = fackel.nn.linear (32, 16)
self.fc5 = fackel.nn.linear (16, 8)
self.fc6 = fackel.nn.linear (8, 1)
self.sigmoid = t Torch.nn.Sigmoid ())
Def Forward (Selbst, x):
x = fackel.relu (self.fc1 (x))
x = fackel.relu (self.fc2 (x))
x = fackel.relu (self.fc3 (x))
x = fackel.relu (self.fc4 (x))
x = fackel.relu (self.fc5 (x))
x = self.sigmoid (self.fc6 (x))
Rückkehr x
# Pytorch -Modell erstellen
pytorch_model = pytorchmodel () TensorFlow_Model = tf.keras.sequential ([[
Eingabe (Form = (200,)),
tf.keras.layers.dense (128, activation = '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, activation = '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.sigmaid (jnp.dot (x, jnp.ones ((8, 1))))
Rückkehr x # Konvertieren Sie das Pytorch -Modell in ONNX
Dummy_input = Torch.randn (1, 200)
onnx_model_path = "model.onnx"
fackler.onnx.export (
pytorch_model,
dummy_input,
onnx_model_path,
export_params = true,
Opset_version = 11,
input_names = ['Eingabe'],
output_names = ['output'],
Dynamic_axes = {'Eingabe': {0: 'batch_size'}, 'Ausgabe': {0: 'batch_size'}}
)
onnx_session = ort.inferenceSession (onnx_model_path)# OpenVino -Modelldefinition core = core () openvino_model = core.read_model (model = "model.onnx") compiled_model = core.compile_model (OpenVino_Model, Device_name = "CPU"))
Diese Funktion führt Benchmarking -Tests in verschiedenen Frameworks durch, indem Sie drei Argumente vornehmen: Predict_function, input_data und num_runs. Standardmäßig wird es 1.000 Mal ausgeführt, kann jedoch gemäß den Anforderungen erhöht werden.
Def Benchmark_Model (Predict_function, input_data, num_runs = 1000):
start_time = time.time ()
process = psutil.process (os.getPid ())
cpu_usage = []
memory_usage = []
für _ in Bereich (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 (MEMALY_USAGE) / (1024 * 1024) # in MB konvertieren
RECHTEN SIE AVG_LATENCY, AVG_CPU, AVG_MEMORYNachdem wir die Modelle geladen haben, ist es an der Zeit, die Leistung jedes Frameworks zu bewerten. Der Benchmarking -Prozess führt zu Inferenz in den generierten Eingabedaten.
# Benchmark Pytorch -Modell
Def Pytorch_Predict (input_data):
pytorch_model (fackel.tensor (input_data))
pytorch_latency, pytorch_cpu, pytorch_memory = benchmark_model (lambda x: pytorch_prredict (x), input_data) # Benchmark TensorFlow -Modell
Def TensorFlow_Predict (input_data):
TensorFlow_Model (input_data)
TensorFlow_Latency, TensorFlow_CPU, TensorFlow_Memory = Benchmark_Model (Lambda X: TensorFlow_Predict (x), input_data) # Benchmark JAX -Modell
Def Jax_Predict (input_data):
jax_model (jnp.Array (input_data))
jax_latency, jax_cpu, jax_memory = benchmark_model (lambda x: jax_prredict (x), input_data) # Benchmark Onnx -Modell
Def Onnx_Predict (input_data):
# Prozesseingaben in Chargen
für i im Bereich (input_data.shape [0]):
Single_input = input_data [i: i 1] # einzelne Eingabe extrahieren
onnx_session.run (none, {onnx_Session.get_inputs () [0] .Name: Single_input})
onnx_latency, onnx_cpu, onnx_memory = benchmark_model (lambda x: onnx_prredict (x), input_data) # Benchmark OpenVino -Modell
Def OpenVino_Predict (input_data):
# Prozesseingaben in Chargen
für i im Bereich (input_data.shape [0]):
Single_input = input_data [i: i 1] # einzelne Eingabe extrahieren
compiled_model.infer_new_request ({0: Single_input})
OpenVino_Latency, OpenVino_CPU, OpenVino_Memory = Benchmark_Model (Lambda X: OpenVino_Predict (x), input_data)
Hier diskutieren wir die Ergebnisse des Leistungsbenchmarkings zuvor erwähnter Deep Learning -Frameworks. Wir vergleichen sie auf - Latenz, CPU -Nutzung und Speicherverbrauch. Wir haben tabellarische Daten und Diagramme zum schnellen Vergleich aufgenommen.
| Rahmen | Latenz (MS) | Relative Latenz (gegen Pytorch) |
| Pytorch | 1.26 | 1.0 (Grundlinie) |
| Tensorflow | 6.61 | ~ 5,25 × |
| Jax | 3.15 | ~ 2,50 × |
| Onnx | 14.75 | ~ 11,72 × |
| OpenVino | 144.84 | ~ 115 × |
Einsichten:
| Rahmen | CPU -Nutzung (%) | Relative CPU -Verwendung 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 (Grundlinie) |
Einsichten:
| Rahmen | Speicher (MB) | Relative Speicherverwendung (gegen Pytorch) |
| Pytorch | ~ 959.69 | 1.0 (Grundlinie) |
| Tensorflow | ~ 969.72 | ~ 1,01 × |
| Jax | ~ 1033.63 | ~ 1,08 × |
| Onnx | ~ 1033.82 | ~ 1,08 × |
| OpenVino | ~ 1040.80 | ~ 1,08–1,09 × |
Einsichten:
Hier ist die Handlung, in der die Leistung von Deep -Learning -Frameworks verglichen wird:
In diesem Artikel haben wir einen umfassenden Benchmarking -Workflow vorgestellt, um die Inferenzleistung von prominenten Deep -Learning -Frameworks - Tensorflow, Pytorch, Onnx, Jax und OpenVino - als Referenz zu einer Spam -Klassifizierungsaufgabe zu bewerten. Durch die Analyse von Schlüsselmetriken wie Latenz, CPU-Nutzung und Speicherverbrauch haben die Ergebnisse die Kompromisse zwischen Frameworks und ihrer Eignung für verschiedene Bereitstellungsszenarien hervorgehoben.
Pytorch zeigte die ausgewogenste Leistung, zeichnen sich bei geringer Latenz und effizienter Speicherverwendung und machte sie ideal für latenzempfindliche Anwendungen wie Echtzeitvorhersagen und Empfehlungssysteme. TensorFlow bot eine mittlere Lösung mit mäßig höherem Ressourcenverbrauch. JAX zeigte einen hohen Rechendurchsatz, aber auf Kosten einer verstärkten CPU-Nutzung, die ein begrenzender Faktor für ressourcenbezogene Umgebungen darstellt. In der Zwischenzeit blieb Onnx und OpenVino in der Latenz zurück, wobei OpenVinos Leistung besonders durch das Fehlen einer Hardwarebeschleunigung behindert wurde.
Diese Ergebnisse unterstreichen die Bedeutung der Auswahl der Framework mit den Bereitstellungsbedürfnissen. Unabhängig davon, ob die Optimierung von Geschwindigkeit, Ressourceneffizienz oder spezifischer Hardware das Verständnis der Kompromisse für die effektive Modellbereitstellung in realen Umgebungen ist.
A. Pytorchs dynamischer Berechnungsgrafik und effiziente Ausführungspipeline ermöglichen eine schlechte Inferenz (1,26 ms), was sie für Anwendungen wie Empfehlungssysteme und Echtzeitvorhersagen gut geeignet ist.
Q2. Was hat OpenVinos Leistung in dieser Studie beeinflusst?A. OpenVinos Optimierungen sind für Intel -Hardware ausgelegt. Ohne diese Beschleunigung waren seine Latenz (144,84 ms) und die Speicherverwendung (1040,8 MB) im Vergleich zu anderen Rahmenbedingungen weniger wettbewerbsfähig.
Q3. Wie wähle ich einen Rahmen für ressourcenbezogene Umgebungen aus?A. Für CPU-Setups ist Pytorch am effizientesten. TensorFlow ist eine starke Alternative für moderate Workloads. Vermeiden Sie Frameworks wie JAX, es sei denn, eine höhere CPU -Nutzung ist akzeptabel.
Q4. Welche Rolle spielt Hardware in der Framework -Leistung?A. Die Rahmenleistung hängt stark von der Hardwarekompatibilität ab. Zum Beispiel zeichnet sich OpenVino auf Intel-CPUs mit hardwarespezifischen Optimierungen aus, während Pytorch und Tensorflow konsistent über unterschiedliche Setups abschneiden.
Q5. Können sich die Ergebnisse der Benchmarking mit komplexen Modellen oder Aufgaben unterscheiden?A. Ja, diese Ergebnisse spiegeln eine einfache Binärklassifizierungsaufgabe wider. Die Leistung kann mit komplexen Architekturen wie Resnet oder Aufgaben wie NLP oder anderen variieren, bei denen diese Frameworks möglicherweise spezielle Optimierungen nutzen.
Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und werden nach Ermessen des Autors verwendet.
Das obige ist der detaillierte Inhalt vonDeep Learning CPU -Benchmarks. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Einführung in Screenshot-Tastenkombinationen in Win10
So verwenden Sie Shuffle
Linux View IP-Befehl
Empfohlene benutzerfreundliche und formelle Software-Apps für Währungsspekulationen im Jahr 2024
Aktuelles Ranking der digitalen Währungsbörsen
HTML zum Erstellen von Webseiten
Was soll ich tun, wenn mein Laufwerk C rot wird?
So stellen Sie gelöschte Dateien auf dem Computer wieder her
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
