GMAC signifie « Giga Multiply-Add Operations per Second » et est un indicateur utilisé pour mesurer l'efficacité informatique des modèles d'apprentissage profond. Cette métrique représente la vitesse de calcul du modèle en termes d'un milliard d'opérations de multiplication et d'addition par seconde.
L'opération multiplier-accumuler (MAC) est une opération fondamentale dans de nombreux calculs mathématiques, notamment la multiplication matricielle, la convolution et d'autres tenseurs couramment utilisés en profondeur. Opération d’apprentissage. Chaque opération MAC consiste à multiplier deux nombres et à ajouter le résultat à un accumulateur.
La métrique GMAC peut être calculée à l'aide de la formule suivante :
<code>GMAC =(乘法累加运算次数)/(10⁹)</code>
Le nombre d'opérations de multiplication-ajout est généralement déterminé en analysant l'architecture du réseau et les dimensions des paramètres du modèle , comme les pondérations et les biais.
Grâce à la métrique GMAC, les chercheurs et les praticiens peuvent prendre des décisions éclairées concernant la sélection de modèles, les exigences matérielles et les stratégies d'optimisation pour des calculs d'apprentissage en profondeur efficaces et efficients.
GFLOPS est une mesure des performances informatiques d'un système informatique ou d'une opération spécifique, représentant un milliard de flottants par deuxièmement. C'est le nombre d'opérations en virgule flottante par seconde, exprimé en milliards (giga).
L'arithmétique à virgule flottante fait référence à l'exécution de calculs arithmétiques sur des nombres réels représentés au format à virgule flottante IEEE 754. Ces opérations incluent généralement l'addition, la soustraction, la multiplication, la division et d'autres opérations mathématiques.
GFLOPS est couramment utilisé dans le calcul haute performance (HPC) et l'analyse comparative, en particulier dans les domaines qui nécessitent des tâches de calcul lourdes, telles que les simulations scientifiques, l'analyse de données et l'apprentissage profond.
La formule de calcul du GFLOPS est la suivante :
<code>GFLOPS =(浮点运算次数)/(以秒为单位的运行时间)/ (10⁹)</code>
GFLOPS est une mesure efficace de la puissance de calcul de différents systèmes informatiques, processeurs ou opérations spécifiques. Il permet d'évaluer la vitesse et l'efficacité du matériel ou des algorithmes qui effectuent des calculs en virgule flottante. GFLOPS est une mesure des performances théoriques maximales et peut ne pas refléter les performances réelles obtenues dans des scénarios réels, car elle ne prend pas en compte des facteurs tels que l'accès à la mémoire, la parallélisation et d'autres limitations du système.
La relation entre GMAC et GFLOPS
<code>1 GFLOP = 2 GMAC</code>
Si on veut calculer ces deux indicateurs, il sera plus compliqué d'écrire le code manuellement, mais Python a déjà du prêt à l'emploi bibliothèques pour nous Utiliser :
bibliothèque ptflops pour calculer GMAC et GFLOPs
<code>pip install ptflops</code>
C'est aussi très simple à utiliser :
<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>
Les résultats sont aussi suit :
<code>Computational complexity: 7.82 GMac Computational complexity: 15.64 GFlops Number of parameters: 28.68 M</code>
<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>
<code>Computational complexity: 670.73 KMac Computational complexity: 1341.46 KFlops Number of parameters: 669.71 k</code>
<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>
<code>0.66972288</code>
<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>
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!