Eine kurze Analyse der Berechnung von GMAC und GFLOPS

GMAC steht für „Giga Multiply-Add Operations per Second“ und ist ein Indikator zur Messung der Recheneffizienz von Deep-Learning-Modellen. Diese Metrik stellt die Rechengeschwindigkeit des Modells in Form von einer Milliarde Multiplikations- und Additionsoperationen pro Sekunde dar.

Die Multiply-Accumulate (MAC)-Operation ist eine grundlegende Operation in vielen mathematischen Berechnungen, einschließlich Matrixmultiplikation, Faltung und anderen Tensoren, die üblicherweise in der Tiefe verwendet werden Lernbetrieb. Bei jeder MAC-Operation werden zwei Zahlen multipliziert und das Ergebnis einem Akkumulator hinzugefügt.

Die GMAC-Metrik kann mit der folgenden Formel berechnet werden:

<code>GMAC =（乘法累加运算次数）/（10⁹）</code>

Die Anzahl der Multiplikations-Add-Operationen wird normalerweise durch Analyse der Netzwerkarchitektur und der Dimensionen der Modellparameter bestimmt , wie Gewichte und Verzerrungen.

Mit der GMAC-Metrik können Forscher und Praktiker fundierte Entscheidungen über Modellauswahl, Hardwareanforderungen und Optimierungsstrategien für effiziente und effektive Deep-Learning-Berechnungen treffen.

GFLOPS ist ein Maß für die Rechenleistung eines Computersystems oder einer bestimmten Operation und repräsentiert eine Milliarde Floats pro Zweitens. Punktoperationen. Dabei handelt es sich um die Anzahl der Gleitkommaoperationen pro Sekunde, ausgedrückt in Milliarden (Giga).

Gleitkommaarithmetik bezieht sich auf die Durchführung arithmetischer Berechnungen für reelle Zahlen, die im Gleitkommaformat IEEE 754 dargestellt werden. Zu diesen Operationen gehören typischerweise Addition, Subtraktion, Multiplikation, Division und andere mathematische Operationen.

GFLOPS wird häufig im Hochleistungsrechnen (HPC) und Benchmarking verwendet, insbesondere in Bereichen, die schwere Rechenaufgaben erfordern, wie wissenschaftliche Simulationen, Datenanalyse und Deep Learning.

Die Formel zur Berechnung von GFLOPS lautet wie folgt:

<code>GFLOPS =（浮点运算次数）/（以秒为单位的运行时间）/ (10⁹)</code>

GFLOPS ist ein effektives Maß für die Rechenleistung verschiedener Computersysteme, Prozessoren oder bestimmter Vorgänge. Es hilft bei der Bewertung der Geschwindigkeit und Effizienz von Hardware oder Algorithmen, die Gleitkommaberechnungen durchführen. GFLOPS ist ein Maß für die theoretische Spitzenleistung und spiegelt möglicherweise nicht die tatsächlich in realen Szenarien erzielte Leistung wider, da Faktoren wie Speicherzugriff, Parallelisierung und andere Systembeschränkungen nicht berücksichtigt werden.

Die Beziehung zwischen GMAC und GFLOPS

<code>1 GFLOP = 2 GMAC</code>

Wenn wir diese beiden Indikatoren berechnen möchten, ist es schwieriger, den Code manuell zu schreiben, aber Python hat bereits einen fertigen Code Bibliotheken für uns Verwenden Sie:

ptflops-Bibliothek zur Berechnung von GMAC und GFLOPs

<code>pip install ptflops</code>

Es ist auch sehr einfach zu verwenden:

<code>import torchvision.models as models import torch from ptflops import get_model_complexity_info import re  #Model thats already available net = models.densenet161() macs, params = get_model_complexity_info(net, (3, 224, 224), as_strings=True, print_per_layer_stat=True, verbose=True) # Extract the numerical value flops = eval(re.findall(r'([\d.]+)', macs)[0])*2 # Extract the unit flops_unit = re.findall(r'([A-Za-z]+)', macs)[0][0]  print('Computational complexity: {:</code>

Die Ergebnisse sind wie folgt folgt:

<code>Computational complexity: 7.82 GMac Computational complexity: 15.64 GFlops Number of parameters: 28.68 M</code>

# 🎜🎜#Wir können ein Modell anpassen, um zu sehen, ob das Ergebnis korrekt ist:

<code>import os import torch from torch import nn  class NeuralNetwork(nn.Module): def __init__(self): super().__init__() self.flatten = nn.Flatten() self.linear_relu_stack = nn.Sequential( nn.Linear(28*28, 512), nn.ReLU(), nn.Linear(512, 512), nn.ReLU(), nn.Linear(512, 10),)  def forward(self, x): x = self.flatten(x) logits = self.linear_relu_stack(x) return logits  custom_net = NeuralNetwork()  macs, params = get_model_complexity_info(custom_net, (28, 28), as_strings=True, print_per_layer_stat=True, verbose=True) # Extract the numerical value flops = eval(re.findall(r'([\d.]+)', macs)[0])*2  # Extract the unit flops_unit = re.findall(r'([A-Za-z]+)', macs)[0][0] print('Computational complexity: {:</code>

Das Ergebnis ist wie folgt:

<code>Computational complexity: 670.73 KMac Computational complexity: 1341.46 KFlops Number of parameters: 669.71 k</code>

Für die Zur Vereinfachung der Demonstration schreiben wir den Code der vollständig verbundenen Schicht nur manuell und berechnen GMAC. Die Iteration über die Gewichtungsparameter des Modells und die Berechnung der Form der Anzahl der Multiplikations- und Additionsoperationen hängt von den Gewichtungsparametern ab, die der Schlüssel zur Berechnung des GMAC sind. Die Formel zur Berechnung des von GMAC geforderten vollständig verbundenen Schichtgewichts lautet 2 x (Eingabedimension x Ausgabedimension). Der Gesamt-GMAC-Wert wird durch Multiplikation und Akkumulation der Formen der Gewichtsparameter jeder linearen Schicht ermittelt, ein Prozess, der auf der Struktur des Modells basiert.

<code>import torch import torch.nn as nn  def compute_gmac(model): gmac_count = 0 for param in model.parameters(): shape = param.shape if len(shape) == 2:# 全连接层的权重 gmac_count += shape[0] * shape[1] * 2 gmac_count = gmac_count / 1e9# 转换为十亿为单位 return gmac_count</code>

Nach dem oben angegebenen Modell ist das Ergebnis der Berechnung des GMAC wie folgt:

<code>0.66972288</code>

Da das Ergebnis des GMAC in Milliarden angegeben ist, ist es dasselbe wie das, was wir haben Berechnet mit der oben genannten Klassenbibliothek. Die Ergebnisse unterscheiden sich nicht wesentlich. Schließlich ist die Berechnung des GMAC der Faltung etwas kompliziert. Die Formel lautet ((Eingabekanal x Höhe des Faltungskerns) x Ausgabekanal) x 2. Hier ist ein einfacher Code, der möglicherweise nicht ganz korrekt ist. 🎜🎜#

<code>def compute_gmac(model): gmac_count = 0 for param in model.parameters(): shape = param.shape if len(shape) == 2:# 全连接层的权重 gmac_count += shape[0] * shape[1] * 2 elif len(shape) == 4:# 卷积层的权重 gmac_count += shape[0] * shape[1] * shape[2] * shape[3] * 2 gmac_count = gmac_count / 1e9# 转换为十亿为单位 return gmac_count</code>

Das obige ist der detaillierte Inhalt vonEine kurze Analyse der Berechnung von GMAC und GFLOPS. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!