Une brève analyse du calcul de GMAC et GFLOPS

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>

# 🎜🎜#On peut personnaliser un modèle pour voir si le résultat est correct :

<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>

Les résultats sont les suivants :

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

Pour le commodité de la démonstration, nous écrivons uniquement manuellement le code de couche entièrement connecté. Calculons GMAC. L'itération sur les paramètres de poids du modèle et le calcul de la forme du nombre d'opérations de multiplication et d'addition dépendent des paramètres de poids, qui sont la clé du calcul du GMAC. La formule de calcul du poids de couche entièrement connecté requis par GMAC est 2 x (dimension d'entrée x dimension de sortie). La valeur totale du GMAC est obtenue en multipliant et en accumulant les formes des paramètres de poids de chaque couche linéaire, un processus basé sur la structure du modèle.

<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>

Selon le modèle donné ci-dessus, le résultat du calcul du GMAC est le suivant :

<code>0.66972288</code>

Puisque le résultat du GMAC est en milliards, c'est le même que ce que nous calculé à l'aide de la bibliothèque de classes ci-dessus. Les résultats ne sont pas très différents. Enfin, calculer le GMAC de convolution est un peu compliqué. La formule est ((canal d'entrée x hauteur du noyau de convolution x largeur du noyau de convolution) x canal de sortie) x 2. Voici un code simple, qui n'est peut-être pas tout à fait correct. 🎜🎜#

<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!