PyTorTutorial ch

⚡ Ringkasan Cerdas

PyTorch adalah kerangka kerja pembelajaran mendalam sumber terbuka dari Meta, yang kini mendukung 85 persen makalah penelitian AI pada tahun 2026. LessMateri ini mencakup instalasi, dasar-dasar kerangka kerja, regresi sederhana, klasifikasi gambar, dan penerapan AWS SageMaker.

  • 🧠 Grafik Dinamis: Eksekusi eager berarti tensor dijalankan baris demi baris, dengan lebih mudah. Python-gaya debugging.
  • 🐍 PythonAPI ic: Mudah dibaca bagi siapa pun yang familiar dengan NumPy dan Python.
  • 📦 Ekosistem yang Kaya: Wajah Berpelukan, vLLM, DeepSpeed, dan TorchVision dibangun di atas Python.Torch.
  • ⚙️ Alur Kerja Pelatihan: Definisikan model, pilih fungsi kerugian dan pengoptimal, lalu lakukan perulangan maju, mundur, dan langkah demi langkah.
  • 📊 Dominasi Penelitian: 85 persen makalah terbaru menggunakan PyTorch versus 15 persen TensorFlow.
  • 🤖 Siap untuk LLM: Dukungan asli untuk transformer, fine-tuning LoRA, dan alur kerja kuantisasi.

PyTorTutorial ch

Apa itu Py?TorH?

PyTorch adalah sumber terbuka TorPustaka Pembelajaran Mesin berbasis ch untuk pemrosesan bahasa alami menggunakan PythonIni mirip dengan NumPy tetapi dengan dukungan GPU yang lebih kuat. Ia menawarkan Grafik Komputasi Dinamis yang dapat Anda modifikasi secara langsung dengan bantuan autograd.pyTorch juga lebih cepat daripada beberapa framework lainnya. Framework ini dikembangkan oleh Grup Riset AI Facebook pada tahun 2016.

Mengetahui apa itu PyTorch menyajikan pandangan yang seimbang mengenai kekuatan dan kelemahannya.

PyTorKeuntungan dan Kerugian

Berikut adalah kelebihan dan kekurangan Py.Torch:

Keunggulan PyTorch

  1. Perpustakaan Sederhana
    PyTorKode ch itu sederhana. Mudah dipahami, dan Anda dapat langsung menggunakan pustaka ini. Misalnya, lihat cuplikan kode di bawah ini:
class Net(torch.nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

Seperti disebutkan di atas, Anda dapat menentukan model jaringan dengan mudah, dan Anda dapat memahami kodenya dengan cepat tanpa banyak pelatihan.

  1. Grafik Komputasi Dinamis

Grafik Komputasi Dinamis

Sumber Gambar: Menjelajahi Pembelajaran Mendalam dengan PyTorch

PyTorch menawarkan Dynamic Computational Graph (DAG). Grafik komputasi adalah cara untuk mengekspresikan ekspresi matematika dalam model atau teori grafik seperti node dan edge. Node akan melakukan operasi matematika, dan edge adalah Tensor yang akan dimasukkan ke dalam node dan membawa output node dalam bentuk Tensor.

DAG adalah grafik yang bentuknya dapat berubah-ubah dan dapat melakukan operasi antar grafik input yang berbeda. Setiap iterasi, grafik baru akan dibuat. Jadi, ada kemungkinan untuk memiliki struktur grafik yang sama atau membuat grafik baru dengan operasi yang berbeda, atau kita dapat menyebutnya grafik dinamis.

  1. Performa yang lebih baik

Komunitas dan peneliti, melakukan benchmark dan membandingkan kerangka kerja untuk melihat mana yang lebih cepat. Repo GitHub Tolok Ukur Kerangka Pembelajaran Mendalam dan GPU melaporkan bahwa PyTorch lebih cepat dibandingkan kerangka kerja lainnya dalam hal jumlah gambar yang diproses per detik.

Seperti yang Anda lihat di bawah, grafik perbandingan dengan vgg16 dan resnet152

Keunggulan PyTorch

Keunggulan PyTorch

  1. Asli Python

PyTorch lebih berbasis Python. Misalnya, jika Anda ingin melatih model, Anda dapat menggunakan alur kontrol bawaan seperti loo.ping dan rekursi tanpa perlu menambahkan variabel atau sesi khusus agar dapat menjalankannya. Ini sangat membantu dalam proses pelatihan.

PyTorch juga mengimplementasikan Pemrograman Imperatif, dan jelas lebih fleksibel. Jadi, dimungkinkan untuk mencetak nilai tensor di tengah proses komputasi.

Kelemahan PyTorch

PyTorch membutuhkan aplikasi pihak ketiga untuk visualisasi. Selain itu, ch juga membutuhkan server API untuk produksi.

Selanjutnya di Py iniTorDalam tutorial ini, kita akan mempelajari perbedaan antara Py.Torch dan TensorFlow.

PyTorch vs. TensorFlow

Parameter PyTorch TensorFlow
Definisi Model Model ini didefinisikan dalam subkelas dan menawarkan paket yang mudah digunakan Model ini ditentukan oleh banyak orang, dan Anda perlu memahami sintaksisnya
Dukungan GPU Ya Ya
Tipe Grafik Dinamis Statis
Tools Tidak ada alat visualisasi Anda dapat menggunakan alat visualisasi Tensorboard
Komunitas Komunitas masih berkembang Komunitas aktif yang besar

Dengan mempertimbangkan perbandingan tersebut, langkah selanjutnya adalah mendapatkan Py.Torch berjalan secara lokal atau di cloud.

Menginstal PyTorch

Linux

Sangat mudah untuk menginstalnya di Linux. Anda dapat memilih untuk menggunakan lingkungan virtual atau menginstalnya langsung dengan akses root. Ketik perintah ini di terminal

pip3 install --upgrade torch torchvision

Pembuat Bijak AWS

Sagemaker adalah salah satu platform di Amazon Layanan web yang menawarkan mesin Machine Learning yang canggih dengan konfigurasi pembelajaran mendalam yang telah diinstal sebelumnya bagi ilmuwan data atau pengembang untuk membangun, melatih, dan menerapkan model pada skala apa pun.

Pertama Buka Amazon Pembuat Sagem konsol dan klik Buat contoh buku catatan dan isi semua detail untuk buku catatan Anda.

Pembuat Bijak AWS

Langkah Selanjutnya, Klik Buka untuk meluncurkan instance notebook Anda.

Pembuat Bijak AWS

Akhirnya, Masuk JupyterKlik Baru dan pilih conda_pytorch_p36, dan Anda siap menggunakan instance notebook Anda dengan Py.Torch terpasang.

Selanjutnya di Py iniTorDalam tutorial ini, kita akan belajar tentang Python.TorDasar-dasar kerangka kerja ch.

Setelah instalasi selesai, langkah selanjutnya adalah API itu sendiri.

PyTorDasar-dasar Kerangka Kerja ch

Mari kita pelajari konsep-konsep dasar Python.Torch sebelum kita menyelam lebih dalam. PyTorch menggunakan Tensor untuk setiap variabel, mirip dengan ndarray milik numpy, tetapi dengan dukungan komputasi GPU. Di sini kita akan menjelaskan model jaringan, fungsi kerugian, Backprop, dan Optimizer.

Model Jaringan

Jaringan dapat dibangun dengan membuat subkelas torch.nn. Ada 2 bagian utama,

  1. Bagian pertama adalah menentukan parameter dan lapisan yang akan Anda gunakan
  2. Bagian kedua adalah tugas utama yang disebut proses maju yang akan mengambil masukan dan memprediksi keluaran.
Import torch
import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
 def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(3, 20, 5)
        self.conv2 = nn.Conv2d(20, 40, 5)
self.fc1 = nn.Linear(320, 10)

def forward(self, x):
       x = F.relu(self.conv1(x))
       x = F.relu(self.conv2(x))
       x = x.view(-1, 320)
       x = F.relu(self.fc1(x))
       return F.log_softmax(x)

net = Model()

Seperti yang Anda lihat di atas, Anda membuat kelas nn.Module bernama Model. Ini berisi 2 lapisan Konv2d dan lapisan Linear. Lapisan konv2d pertama mengambil masukan sebesar 3 dan bentuk keluaran sebesar 20. Lapisan kedua akan mengambil masukan sebesar 20 dan akan menghasilkan bentuk keluaran sebesar 40. Lapisan terakhir merupakan lapisan yang terhubung penuh berbentuk 320 dan akan menghasilkan keluaran 10.

Proses penerusan akan mengambil input X dan memasukkannya ke lapisan konv1 dan menjalankan fungsi ReLU,

Demikian pula, ini juga akan memberi makan lapisan konv2. Setelah itu, x akan dibentuk kembali menjadi (-1) dan dimasukkan ke dalam lapisan FC terakhir. Sebelum Anda mengirimkan output, Anda akan menggunakan fungsi aktivasi softmax.

Proses mundur secara otomatis ditentukan oleh autograd, jadi Anda hanya perlu menentukan proses maju.

Fungsi Rugi

Fungsi kerugian digunakan untuk mengukur seberapa baik model prediksi mampu memprediksi hasil yang diharapkan. PyTorch sudah memiliki banyak fungsi kerugian standar di modul torch.nn. Misalnya, Anda dapat menggunakan Cross-Entropy Loss untuk menyelesaikan masalah multikelas PyTorMasalah klasifikasi ch. Mudah untuk mendefinisikan fungsi kerugian dan menghitung kerugiannya:

loss_fn = nn.CrossEntropyLoss()

#training process
loss = loss_fn(out, target)

Sangat mudah untuk menggunakan perhitungan fungsi kerugian Anda sendiri dengan Py.Torch.

Penopang punggung

Untuk melakukan propagasi mundur, Anda cukup memanggil los.backward(). Kesalahan akan dihitung tetapi ingat untuk menghapus gradien yang ada dengan zero_grad()

net.zero_grad() # to clear the existing gradient
loss.backward() # to perform backpropragation

Pengoptimal

torch.optim menyediakan algoritma optimasi umum. Anda dapat menentukan pengoptimal dengan langkah sederhana:

optimizer = torch.optim.SGD(net.parameters(), lr = 0.01, momentum=0.9)

Anda perlu meneruskan parameter model jaringan dan kecepatan pembelajaran sehingga pada setiap iterasi parameter akan diperbarui setelah proses backprop.

Cara paling mudah untuk mempelajari API adalah dengan contoh kecil yang lengkap.

Regresi Sederhana dengan PyTorch

Mari kita pelajari regresi sederhana dengan Python.TorContoh ch:

Langkah 1) Membuat model jaringan kita

Model jaringan kami adalah lapisan Linear sederhana dengan bentuk masukan dan keluaran 1.

from __future__ import print_function

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable

class Net(nn.Module):
   def __init__(self):
       super(Net, self).__init__()
       self.layer = torch.nn.Linear(1, 1)

   def forward(self, x):
       x = self.layer(x)      
       return x

net = Net()
print(net)

Dan keluaran jaringan harus seperti ini

Net(
  (hidden): Linear(in_features=1, out_features=1, bias=True)
)

Langkah 2) Uji Data

Sebelum Anda memulai proses pelatihan, Anda perlu mengetahui data kami. Anda membuat fungsi acak untuk menguji model kami. kamu = x3 sin(x)+ 3x+0.8 rand(100)

# Visualize our data
import matplotlib.pyplot as plt
import numpy as np

x = np.random.rand(100)
y = np.sin(x) * np.power(x,3) + 3*x + np.random.rand(100)*0.8

plt.scatter(x, y)
plt.show()

Berikut adalah plot sebar dari fungsi kita:

Diagram Sebar Regresi Sederhana dengan PyTorch

Sebelum memulai proses pelatihan, Anda perlu mengkonversi array numpy ke Variabel yang didukung oleh Torch dan autograd seperti yang ditunjukkan pada Py di ​​bawah iniTorContoh regresi ch.

# convert numpy array to tensor in shape of input size
x = torch.from_numpy(x.reshape(-1,1)).float()
y = torch.from_numpy(y.reshape(-1,1)).float()
print(x, y)

Langkah 3) Pengoptimal dan Kerugian

Selanjutnya, Anda harus menentukan Pengoptimal dan Fungsi Kerugian untuk proses pelatihan kami.

# Define Optimizer and Loss Function
optimizer = torch.optim.SGD(net.parameters(), lr=0.2)
loss_func = torch.nn.MSELoss()

Langkah 4) Pelatihan

Sekarang mari kita mulai proses pelatihan kita. Dengan epoch 250, Anda akan mengulangi data kami untuk menemukan nilai terbaik untuk hyperparameter kami.

inputs = Variable(x)
outputs = Variable(y)
for i in range(250):
   prediction = net(inputs)
   loss = loss_func(prediction, outputs) 
   optimizer.zero_grad()
   loss.backward()        
   optimizer.step()       

   if i % 10 == 0:
       # plot and show learning process
       plt.cla()
       plt.scatter(x.data.numpy(), y.data.numpy())
       plt.plot(x.data.numpy(), prediction.data.numpy(), 'r-', lw=2)
       plt.text(0.5, 0, 'Loss=%.4f' % loss.data.numpy(), fontdict={'size': 10, 'color':  'red'})
       plt.pause(0.1)

plt.show()

Langkah 5) Hasil

Seperti yang Anda lihat di bawah, Anda berhasil menjalankan Py.TorRegresi ch dengan jaringan saraf. Sebenarnya, pada setiap iterasi, garis merah pada plot akan diperbarui dan mengubah posisinya agar sesuai dengan data. Tetapi pada gambar ini, hanya menunjukkan hasil akhir seperti yang ditunjukkan pada Py di ​​bawah ini.TorContoh ch:

Scatter Plot Hasil Regresi Sederhana

Regresi adalah pemanasan; klasifikasi gambar melatih kemampuan pembelajaran mendalam dari Py.Torch.

Contoh Klasifikasi Gambar dengan PythonTorch

Salah satu metode populer untuk mempelajari dasar-dasarnya belajar mendalam adalah dengan dataset MNIST. Ini adalah “Hello World” dalam pembelajaran mendalam. Dataset berisi angka-angka tulisan tangan dari 0 – 9 dengan total 60,000 sampel pelatihan dan 10,000 sampel uji yang sudah diberi label dengan ukuran 28×28 piksel.

Klasifikasi Gambar dengan PyTorch

Langkah 1) Memproses Data terlebih dahulu

Pada langkah pertama Py iniTorContoh klasifikasi ch, Anda akan memuat dataset menggunakan modul torchvision.

Sebelum memulai proses pelatihan, Anda perlu memahami data tersebut. Torchvision akan memuat dataset dan mentransformasi gambar sesuai dengan kebutuhan jaringan, seperti bentuk dan normalisasi gambar.

import torch
import torchvision
import numpy as np
from torchvision import datasets, models, transforms

# This is used to transform the images to Tensor and normalize it
transform = transforms.Compose(
   [transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

training = torchvision.datasets.MNIST(root='./data', train=True,
                                       download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(training, batch_size=4,
                                         shuffle=True, num_workers=2)

testing = torchvision.datasets.MNIST(root='./data', train=False,
                                      download=True, transform=transform)
test_loader = torch.utils.data.DataLoader(testing, batch_size=4,
                                        shuffle=False, num_workers=2)

classes = ('0', '1', '2', '3',
          '4', '5', '6', '7', '8', '9')
         
import matplotlib.pyplot as plt
import numpy as np

#create an iterator for train_loader
# get random training images
data_iterator = iter(train_loader)
images, labels = data_iterator.next()

#plot 4 images to visualize the data
rows = 2
columns = 2
fig=plt.figure()
for i in range(4):
   fig.add_subplot(rows, columns, i+1)
   plt.title(classes[labels[i]])
   img = images[i] / 2 + 0.5     # this is for unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

Fungsi transformasi mengubah gambar menjadi tensor dan menormalkan nilainya. Fungsi torchvision.transforms.MNIST, akan mendownload dataset (jika tidak tersedia) di direktori, mengatur dataset untuk pelatihan jika diperlukan dan melakukan proses transformasi.

Untuk memvisualisasikan kumpulan data, gunakan data_iterator untuk mendapatkan kumpulan gambar dan label berikutnya. Anda menggunakan matplot untuk memplot gambar-gambar ini dan label yang sesuai. Seperti yang Anda lihat di bawah gambar kami dan labelnya.

Contoh Klasifikasi Gambar dengan PythonTorch

Langkah 2) Konfigurasi Model Jaringan

Sekarang di Py iniTorSebagai contoh, Anda akan membuat jaringan saraf sederhana untuk Python.Torklasifikasi gambar ch.

Di sini, kami memperkenalkan cara lain untuk membuat model Jaringan di Python.TorBab. Kita akan menggunakan nn.Sequential untuk membuat model urutan, bukan membuat subkelas dari nn.Module.

import torch.nn as nn

# flatten the tensor into 
class Flatten(nn.Module):
   def forward(self, input):
       return input.view(input.size(0), -1)

#sequential based model
seq_model = nn.Sequential(
           nn.Conv2d(1, 10, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           nn.Dropout2d(),
           nn.Conv2d(10, 20, kernel_size=5),
           nn.MaxPool2d(2),
           nn.ReLU(),
           Flatten(),
           nn.Linear(320, 50),
           nn.ReLU(),
           nn.Linear(50, 10),
           nn.Softmax(),
         )

net = seq_model
print(net)

Berikut adalah output dari model jaringan kami

Sequential(
  (0): Conv2d(1, 10, kernel_size=(5, 5), stride=(1, 1))
  (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (2): ReLU()
  (3): Dropout2d(p=0.5)
  (4): Conv2d(10, 20, kernel_size=(5, 5), stride=(1, 1))
  (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (6): ReLU()
  (7): Flatten()
  (8): Linear(in_features=320, out_features=50, bias=True)
  (9): ReLU()
  (10): Linear(in_features=50, out_features=10, bias=True)
  (11): Softmax()
)

Penjelasan Jaringan

  1. Urutannya layer pertama adalah layer Conv2D dengan bentuk input 1 dan bentuk output 10 dengan ukuran kernel 5
  2. Selanjutnya, Anda memiliki lapisan MaxPool2D
  3. Fungsi aktivasi ReLU
  4. lapisan Dropout untuk menghilangkan nilai probabilitas rendah.
  5. Kemudian Conv2d kedua dengan bentuk masukan 10 dari lapisan terakhir dan bentuk keluaran 20 dengan ukuran kernel 5
  6. Berikutnya lapisan MaxPool2d
  7. Fungsi aktivasi ReLU.
  8. Setelah itu, Anda akan meratakan tensornya sebelum memasukkannya ke dalam lapisan Linear
  9. Linear Layer akan memetakan output kita pada layer Linear kedua dengan fungsi aktivasi softmax

Langkah 3) Latih Modelnya

Sebelum memulai proses pelatihan, perlu menyiapkan kriteria dan fungsi pengoptimal.

Untuk kriteria, Anda akan menggunakan CrossEntropyLoss. Untuk Optimizer, Anda akan menggunakan SGD dengan learning rate 0.001 dan momentum 0.9 seperti yang ditunjukkan pada kode Py di ​​bawah ini.Torcontoh ch.

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

Proses penerusan akan mengambil bentuk masukan dan meneruskannya ke lapisan konv2d pertama. Kemudian dari sana akan dimasukkan ke maxpool2d dan terakhir dimasukkan ke dalam fungsi aktivasi ReLU. Proses yang sama akan terjadi pada lapisan konv2d kedua. Setelah itu, masukan akan dibentuk kembali menjadi (-1,320) dan dimasukkan ke dalam lapisan fc untuk memprediksi keluaran.

Sekarang, Anda akan memulai proses pelatihan. Anda akan mengulangi kumpulan data kami 2 kali atau dengan epoch 2 dan mencetak kerugian saat ini pada setiap batch 2000.

for epoch in range(2): 

#set the running loss at each epoch to zero
   running_loss = 0.0
# we will enumerate the train loader with starting index of 0
# for each iteration (i) and the data (tuple of input and labels)
   for i, data in enumerate(train_loader, 0):
       inputs, labels = data

# clear the gradient
       optimizer.zero_grad()

#feed the input and acquire the output from network
       outputs = net(inputs)

#calculating the predicted and the expected loss
       loss = criterion(outputs, labels)

#compute the gradient
       loss.backward()

#update the parameters
       optimizer.step()

       # print statistics
       running_loss += loss.item()
       if i % 1000 == 0:
           print('[%d, %5d] loss: %.3f' %
                 (epoch + 1, i + 1, running_loss / 1000))
           running_loss = 0.0

Pada setiap epoch, enumerator akan mendapatkan tupel input berikutnya dan label yang sesuai. Sebelum kita memasukkan masukan ke model jaringan kita, kita perlu menghapus gradien sebelumnya. Hal ini diperlukan karena setelah proses mundur (proses backpropagation), gradien akan diakumulasikan dan bukannya diganti. Kemudian kita akan menghitung kerugian dari output yang diprediksi dari output yang diharapkan. Setelah itu, kita akan melakukan backpropagation untuk menghitung gradien, dan terakhir, kita akan memperbarui parameternya.

Berikut output dari proses pelatihan

[1, 	1] loss: 0.002
[1,  1001] loss: 2.302
[1,  2001] loss: 2.295
[1,  3001] loss: 2.204
[1,  4001] loss: 1.930
[1,  5001] loss: 1.791
[1,  6001] loss: 1.756
[1,  7001] loss: 1.744
[1,  8001] loss: 1.696
[1,  9001] loss: 1.650
[1, 10001] loss: 1.640
[1, 11001] loss: 1.631
[1, 12001] loss: 1.631
[1, 13001] loss: 1.624
[1, 14001] loss: 1.616
[2, 	1] loss: 0.001
[2,  1001] loss: 1.604
[2,  2001] loss: 1.607
[2,  3001] loss: 1.602
[2,  4001] loss: 1.596
[2,  5001] loss: 1.608
[2,  6001] loss: 1.589
[2,  7001] loss: 1.610
[2,  8001] loss: 1.596
[2,  9001] loss: 1.598
[2, 10001] loss: 1.603
[2, 11001] loss: 1.596
[2, 12001] loss: 1.587
[2, 13001] loss: 1.596
[2, 14001] loss: 1.603

Langkah 4) Uji Modelnya

Setelah Anda melatih model kami, Anda perlu menguji atau mengevaluasi dengan kumpulan gambar lainnya.

Kita akan menggunakan iterator untuk test_loader, dan iterator akan menghasilkan sekumpulan gambar dan label yang akan diteruskan ke model yang dilatih. Output yang diprediksi akan ditampilkan dan dibandingkan dengan output yang diharapkan.

#make an iterator from test_loader
#Get a batch of training images
test_iterator = iter(test_loader)
images, labels = test_iterator.next()

results = net(images)
_, predicted = torch.max(results, 1)

print('Predicted: ', ' '.join('%5s' % classes[predicted[j]] for j in range(4)))

fig2 = plt.figure()
for i in range(4):
   fig2.add_subplot(rows, columns, i+1)
   plt.title('truth ' + classes[labels[i]] + ': predict ' + classes[predicted[i]])
   img = images[i] / 2 + 0.5     # this is to unnormalize the image
   img = torchvision.transforms.ToPILImage()(img)
   plt.imshow(img)
plt.show()

Contoh Klasifikasi Gambar dengan PythonTorch

Pertanyaan Umum Demo Slot

Ya, untuk sebagian besar pelajar. PyTorEksekusi yang penuh semangat dari ch, PythonAPI ic, dan penyelarasan Hugging Face membuatnya lebih mudah dipelajari. Survei menunjukkan 60 persen pemula memilih Py.Torch pertama.

Asisten AI seperti Copilot, Cursor, dan JetBrains AI menghasilkan PyTorHugging Face Transformers juga menyertakan loop pelatihan, menyarankan arsitektur lapisan, dan men-debug kesalahan bentuk tensor.Tormodel ch-pertama.

Ya. Alat AI menyusun kelas nn.Module, pilihan pengoptimal, dan perulangan pelatihan. Mereka juga menjelaskan kesalahan CUDA, menyarankan flag presisi campuran, dan merekomendasikan ukuran batch berdasarkan bentuk dataset.

PyTorch menggunakan grafik dinamis dan mendominasi penelitian. TensorFlow memimpin penerapan produksi di perangkat seluler dan edge melalui TensorFlow Lite. Kesenjangan kinerja telah tertutup berkat torch.compile di Py.Torbab 2.

Sekitar 85 persen makalah penelitian pembelajaran mendalam menggunakan Python.Torch pada tahun 2026. Model grafik dinamis sesuai dengan eksperimen, dan seluruh ekosistem LLM dari Hugging Face hingga vLLM dibangun di sekitar Py.Torch.

PyTorch berjalan secara native pada CPU dan GPU CUDA, mendukung ROCm pada GPU AMD, MPS pada Apple Silicon, dan TPU melalui Py.TorProyek ch XLA. Pilih perangkat yang tepat dengan panggilan .to().

Ya, sampai TorchServe, ekspor ONNX, dan Execu yang lebih baruTorch runtime. TensorFlow Lite tetap lebih matang untuk perangkat seluler, tetapi PyTorch dengan cepat mempersempit kesenjangan dalam inferensi tepi.

Para pemula dapat membangun jaringan pertama mereka dalam satu atau dua hari. Menguasai CNN, transformer, pelatihan terdistribusi, dan penerapan produksi biasanya membutuhkan waktu tiga hingga enam bulan kerja proyek yang konsisten.

Ringkaslah postingan ini dengan: