Analisis ringkas pengiraan GMAC dan GFLOPS

GMAC bermaksud "Giga Multiply-Add Operations per Second" dan merupakan penunjuk yang digunakan untuk mengukur kecekapan pengiraan model pembelajaran mendalam. Metrik ini mewakili kelajuan pengiraan model dari segi satu bilion operasi pendaraban dan penambahan sesaat.

Operasi darab-akumulasi (MAC) ialah operasi asas dalam banyak pengiraan matematik, termasuk pendaraban matriks, lilitan dan operasi tensor lain yang biasa digunakan dalam pembelajaran mendalam. Setiap operasi MAC melibatkan pendaraban dua nombor dan menambah hasilnya kepada penumpuk.

Metrik GMAC boleh dikira menggunakan formula berikut:

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

Bilangan operasi tambah darab biasanya ditentukan dengan menganalisis seni bina rangkaian dan dimensi parameter model, seperti berat dan berat sebelah.

Dengan metrik GMAC, penyelidik dan pengamal boleh membuat keputusan termaklum tentang pemilihan model, keperluan perkakasan dan strategi pengoptimuman untuk pengiraan pembelajaran mendalam yang cekap dan berkesan.

GFLOPS ialah ukuran prestasi pengkomputeran sistem komputer atau operasi tertentu, mewakili satu bilion operasi titik terapung sesaat. Ia ialah bilangan operasi titik terapung sesaat, dinyatakan dalam berbilion (giga).

Aritmetik titik terapung merujuk kepada melakukan pengiraan aritmetik pada nombor nyata yang diwakili dalam format titik terapung IEEE 754. Operasi ini biasanya termasuk operasi tambah, tolak, darab, bahagi dan operasi matematik lain.

GFLOPS biasanya digunakan dalam pengkomputeran berprestasi tinggi (HPC) dan penanda aras, terutamanya dalam bidang yang memerlukan tugas pengiraan yang berat, seperti simulasi saintifik, analisis data dan pembelajaran mendalam.

Formula untuk mengira GFLOPS adalah seperti berikut:

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

GFLOPS ialah ukuran berkesan kuasa pengkomputeran sistem komputer, pemproses atau operasi tertentu yang berbeza. Ia membantu menilai kelajuan dan kecekapan perkakasan atau algoritma yang melakukan pengiraan titik terapung. GFLOPS ialah ukuran prestasi puncak teori dan mungkin tidak mencerminkan prestasi sebenar yang dicapai dalam senario dunia sebenar kerana ia tidak mengambil kira faktor seperti akses memori, selari dan had sistem lain.

Hubungan antara GMAC dan GFLOPS

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

Jika kita ingin mengira kedua-dua penunjuk ini, ia akan menjadi lebih menyusahkan untuk menulis kod secara manual, tetapi Python sudah mempunyai perpustakaan sedia untuk kita untuk digunakan:

Pustaka ptflops boleh mengira GMAC dan GFLOP

<code>pip install ptflops</code>

Ia juga sangat mudah untuk digunakan:

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

Hasilnya adalah seperti berikut:

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

Kami boleh menyesuaikan model untuk melihat Adakah hasilnya betul:

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

Hasilnya adalah seperti berikut:

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

Untuk kemudahan demonstrasi, kami hanya menulis kod lapisan yang disambungkan sepenuhnya untuk mengira GMAC secara manual. Mengulangi parameter berat model dan mengira bentuk bilangan operasi pendaraban dan penambahan bergantung pada parameter berat, yang merupakan kunci untuk mengira GMAC. Formula untuk mengira berat lapisan bersambung sepenuhnya yang diperlukan oleh GMAC ialah 2 x (dimensi input x dimensi output). Jumlah nilai GMAC diperoleh dengan mendarab dan mengumpul bentuk parameter berat setiap lapisan linear, satu proses berdasarkan struktur model.

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

Mengikut model yang diberikan di atas, hasil pengiraan GMAC adalah seperti berikut:

<code>0.66972288</code>

Memandangkan keputusan GMAC adalah dalam berbilion-bilion, ia tidak jauh berbeza dengan hasil yang kami kira menggunakan perpustakaan kelas di atas. Akhir sekali, mengira GMAC lilitan adalah sedikit rumit Rumusnya ialah ((saluran input x tinggi kernel lilitan x lebar kernel lilitan) x saluran keluaran) x 2. Berikut ialah kod mudah, yang mungkin tidak betul sepenuhnya 🎜>rreeee

Atas ialah kandungan terperinci Analisis ringkas pengiraan GMAC dan GFLOPS. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!