Qurilma va tezlik

Shu paytgacha kod CPU da ishladi. Katta modellarda esa GPU 10-50 barobar tezlik beradi. Yaxshi xabar shundaki, PyTorch da bunga o'tish uchun kodni qayta yozish shart emas.

Qurilmani tekshirish #

import torch

print("PyTorch:", torch.__version__)
print("CUDA mavjud:", torch.cuda.is_available())

qurilma = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("tanlangan qurilma:", qurilma)
print("oqimlar soni:", torch.get_num_threads())

PyTorch: 2.14.0+cpu
CUDA mavjud: False
tanlangan qurilma: cpu
oqimlar soni: 4

Bu darslik CPU li mashinada yozilgan, shuning uchun False chiqdi. Muhimi shundaki, kod ikkala holatda ham ishlaydi.

qurilma = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(qurilma)

Ko'chirish #

x = torch.randn(3, 3)
print("tenzor qurilmasi:", x.device)

x = x.to(qurilma)
print("ko'chirilgandan keyin:", x.device)

import torch.nn as nn
model = nn.Linear(3, 1).to(qurilma)
print("model parametri:", next(model.parameters()).device)

tenzor qurilmasi: cpu
ko'chirilgandan keyin: cpu
model parametri: cpu

for xb, yb in oquv_dl:
    xb, yb = xb.to(qurilma), yb.to(qurilma)
    ...

GPU qachon foyda beradi #

Tezlikni o'lchash #

Taxmin qilish o'rniga o'lchang:

import time

a = torch.randn(2000, 2000)
b = torch.randn(2000, 2000)

a @ b  # birinchi chaqiruv - isitish uchun

t = time.perf_counter()
for _ in range(5):
    c = a @ b
print(f"2000x2000 matritsa ko'paytmasi: {(time.perf_counter()-t)/5*1000:.1f} ms")

2000x2000 matritsa ko'paytmasi: 54.8 ms

CPU oqimlari #

CPU da PyTorch bir nechta yadrodan foydalanadi:

for n in [1, 2, 4]:
    torch.set_num_threads(n)
    a @ b
    t = time.perf_counter()
    for _ in range(3):
        c = a @ b
    print(f"  {n} oqim: {(time.perf_counter()-t)/3*1000:7.1f} ms")

  1 oqim:   141.6 ms
  2 oqim:    68.8 ms
  4 oqim:    52.9 ms

1 dan 2 oqimga o'tganda tezlik deyarli ikki barobar oshdi. 2 dan 4 ga o'tganda esa foyda kamaydi - bu odatiy hol, chunki yadrolar xotira kanalini baham ko'radi.

float32 va float64 #

X = torch.randn(4096, 512)
W = torch.randn(512, 512)

for nom, dt in [("float32", torch.float32), ("float64", torch.float64)]:
    xa, wa = X.to(dt), W.to(dt)
    xa @ wa
    t = time.perf_counter()
    for _ in range(3):
        xa @ wa
    print(f"  {nom}: {(time.perf_counter()-t)/3*1000:7.1f} ms   xotira = {xa.element_size()*xa.nelement()/1048576:.1f} MB")

  float32:     8.3 ms   xotira = 8.0 MB
  float64:    12.1 ms   xotira = 16.0 MB

float64 ikki barobar xotira oldi va sekinroq ishladi - hech qanday foyda bermasdan.

RuntimeError: expected scalar type Double but found Float

Xulosa #

• torch.cuda.is_available() GPU bor-yo'qligini aytadi.
• Device-agnostik kod yozing: torch.device("cuda" if ... else "cpu").
• .cuda() ni to'g'ridan-to'g'ri yozmang - GPU yo'q mashinada yiqiladi.
• Tenzor uchun x = x.to(qurilma) - natijani saqlang, u joyida o'zgarmaydi.
• Model va har bir paket bir xil qurilmada bo'lishi shart.
• «Expected all tensors to be on the same device» - eng ko'p uchraydigan GPU xatosi.
• GPU ning foydasi katta modellarda ko'rinadi; kichik modelda ko'chirish xarajati yutuqni yeydi.
• Tezlikni o'lchashda birinchi «isitish» chaqiruvini hisobga olmang.
• CPU da set_num_threads tezlikka sezilarli ta'sir qiladi.
• Chuqur o'rganishda float32 standart; float64 faqat xotira va vaqt yeydi.

Keyingi bo'limda o'qitilgan modelni saqlash va qaytadan yuklashni ko'ramiz.