Source Code Jupyter Notebook

00. Pengantar¶

Pada bagian ini kamu diharapkan mampu:

• Memahami esensi deep learning
• Memahami PyTorch dan alasan menggunakannya
• Membuat variabel tensor dan operasi tensor sederhana
• Menjalankan operasi tensor menggunakan GPU

Apa itu PyTorch¶

Sekilas Tentang PyTorch¶

PyTorch adalah sebuah library Python yang digunakan untuk melakukan komputasi numerik dengan menggunakan GPU. PyTorch merupakan salah satu library yang paling populer untuk melakukan deep learning. PyTorch memiliki beberapa kelebihan dibandingkan dengan library deep learning lainnya, diantaranya:

• PyTorch memiliki API yang sangat mudah digunakan dan mudah dipelajari
• PyTorch memiliki dokumentasi yang lengkap dan mudah diakses
• PyTorch memiliki komunitas yang sangat besar dan aktif
• PyTorch memiliki dukungan dari perusahaan besar seperti Facebook, Uber, dan Google

Juga terdapat beberapa framework deep learning lainnya seperti TensorFlow, Keras, dan Caffe. Namun, pada tutorial ini kita akan menggunakan PyTorch sebagai framework utama untuk melakukan deep learning.

Mana yeng lebih baik, PyTorch atau Tensorflow. Cari tahu jawabannya pada tautan berikut ini

Siapa saja yang menggunakan PyTorch¶

• Facebook / MetaAI
• Uber
• Tesla
• Microsoft
• dan masih banyak lagi

Mulai menggunakan pytorch¶

Untuk mulai menggunakannya pastikan anda sudah melakukan instalasi sesuai dengan petunjuk berikut ini atau yang ada pada website official PyTorch

Mengimpor PyTorch¶

Setelah itu kamu dapat melakukan import library PyTorch dengan cara berikut:

In [1]:

import torch
print(torch.__version__)
print(f"Python version: {sys.version}")

import torch print(torch.__version__) print(f"Python version: {sys.version}")

1.13.0
Python version: 3.8.15 (default, Nov 24 2022, 15:19:38) 
[GCC 11.2.0]

Dalam tutorial ini, saya menggunakan PyTorch versi 1.13.0 dan Python versi 3.8.15. Versi kamu mungkin saja berbeda, namun itu tidak jadi masalah asalkan versi yang kamu gunakan adalah versi yang terbaru.

Membuat Tensor¶

Apa itu tensor?

Tensor adalah sebuah array multidimensi yang dapat digunakan untuk melakukan operasi matematika. Tensor dapat digunakan untuk melakukan operasi matematika seperti perkalian matriks, konvolusi, dan lain-lain. Tensor juga dapat digunakan untuk melakukan operasi matematika pada data-data yang memiliki dimensi lebih dari 2.

Sumber: Analytics Vidhya

Mengapa operasi deep learning dilakukan pada tipe data tensor?

Deep learning dilakukan pada tipe data tensor karena tensor memiliki struktur yang sesuai dengan cara kerja neural network. NN terdiri dari banyak node yang terhubung dengan satu sama lain, dan tensor dapat dengan mudah menyimulasikan hubungan antar node ini. Selain itu, tensor dibutuhkan ketika melakukan backpropagation, dimana kita perlu menghitung turunan dari fungsi loss terhadap parameter-parameter yang ada pada NN.

Catatan: Jikalau sampai di tahap ini kamu bingung dengan penjelasannya, jangan khawatir. Kita akan membahasnya lebih dalam pada bagian selanjutnya. Biasanya setelah mencoba langsung, kamu akan lebih mudah memahami konsepnya.

Sekarang kita akan mencoba membuat tensor

In [2]:

# Tensor berbentuk skalar
scalar = torch.tensor(5)
print(scalar)

# Tensor berbentuk skalar scalar = torch.tensor(5) print(scalar)

tensor(5)

Dalam hal ini, skalar maksudnya adalah sebuah bilangan tunggal, bukan sebuah array.

Kemudian, kita mencoba untuk membuat vektor, yaitu tensor dengan dimensi 1 yang memiliki beberapa elemen.

In [3]:

# vector
vector = torch.tensor([1, 2, 3, 4, 5])
print(vector)
print(vector.ndim)
print(vector.shape)

# vector vector = torch.tensor([1, 2, 3, 4, 5]) print(vector) print(vector.ndim) print(vector.shape)

tensor([1, 2, 3, 4, 5])
1
torch.Size([5])

Penjelasan

• torch.tensor() digunakan untuk membuat tensor
• print(vector.ndim) digunakan untuk menampilkan dimensi dari tensor yang mana dimensi dari vektor adalah 1
• print(vector.shape) digunakan untuk menampilkan ukuran dari tensor yang mana ukuran dari vektor adalah 5, yang artinya vektor tersebut memiliki 5 elemen pada dimensi pertama

Mari lihat contoh lainnya:

In [4]:

# vector 2 dimensi
vector2 = torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print(vector2)
print(vector2.ndim)
print(vector2.shape)

# vector 2 dimensi vector2 = torch.tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]) print(vector2) print(vector2.ndim) print(vector2.shape)

tensor([[ 1,  2,  3,  4,  5],
        [ 6,  7,  8,  9, 10]])
2
torch.Size([2, 5])

In [5]:

# vector 3 dimensi
vector3 = torch.tensor([[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]])
print(vector3)
print(vector3.ndim)
print(vector3.shape)

# vector 3 dimensi vector3 = torch.tensor([[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], [[11, 12, 13, 14, 15], [16, 17, 18, 19, 20]]]) print(vector3) print(vector3.ndim) print(vector3.shape)

tensor([[[ 1,  2,  3,  4,  5],
         [ 6,  7,  8,  9, 10]],

        [[11, 12, 13, 14, 15],
         [16, 17, 18, 19, 20]]])
3
torch.Size([2, 2, 5])

Dalam contoh vektor 3 dimensi, ukuran dari tensor adalah (2, 2, 5) yang artinya tensor tersebut memiliki 2 elemen pada dimensi pertama, 2 elemen pada dimensi kedua, dan 5 elemen pada dimensi ketiga.

Gambar berikut mungkin dapat memberikan gambaran yang lebih jelas tentang dimensi dan ukuran dari tensor.

Sumber: Mrdbourke's Github

Membuat Random Tensor¶

Kita juga dapat membuat tensor dengan nilai random. Kita dapat melakukan hal ini dengan menggunakan fungsi torch.rand(). Fungsi ini akan menghasilkan nilai random dengan distribusi uniform.

Misalnya:

In [6]:

# Random Tensor Dengan Ukuran (4,5)
randomtensor = torch.rand(4, 5)
print(randomtensor)
print(randomtensor.ndim)
print(randomtensor.shape)

# Random Tensor Dengan Ukuran (4,5) randomtensor = torch.rand(4, 5) print(randomtensor) print(randomtensor.ndim) print(randomtensor.shape)

tensor([[0.5075, 0.2941, 0.3851, 0.0887, 0.0684],
        [0.2800, 0.3506, 0.2737, 0.6716, 0.8840],
        [0.6578, 0.8523, 0.4888, 0.2552, 0.1581],
        [0.7552, 0.5331, 0.3123, 0.8760, 0.2568]])
2
torch.Size([4, 5])

contoh lainnya:

In [7]:

# Random Tensor dengan ukuran (2,3,4)
randomtensor2 = torch.rand(2, 3, 4)
print(randomtensor2)
print(randomtensor2.ndim)
print(randomtensor2.shape)

# Random Tensor dengan ukuran (2,3,4) randomtensor2 = torch.rand(2, 3, 4) print(randomtensor2) print(randomtensor2.ndim) print(randomtensor2.shape)

tensor([[[0.3678, 0.8739, 0.6830, 0.9904],
         [0.8405, 0.4270, 0.3718, 0.7958],
         [0.9563, 0.4414, 0.1324, 0.1710]],

        [[0.5309, 0.5812, 0.9179, 0.9428],
         [0.4143, 0.2184, 0.0627, 0.6450],
         [0.4203, 0.0951, 0.3181, 0.3720]]])
3
torch.Size([2, 3, 4])

Membuat Range Tensor¶

Kita juga dapat membuat tensor dengan nilai range. Kita dapat melakukan hal ini dengan menggunakan fungsi torch.arange(). Fungsi ini akan menghasilkan nilai range dengan interval yang ditentukan.

Contohnya:

In [8]:

# Range Tensor
rangetensor = torch.arange(0, 10)
print(rangetensor)
print(rangetensor.ndim)
print(rangetensor.shape)

# Range Tensor rangetensor = torch.arange(0, 10) print(rangetensor) print(rangetensor.ndim) print(rangetensor.shape)

tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
1
torch.Size([10])

Penjelasan

• torch.arange() digunakan untuk membuat tensor dengan nilai range
• Argumen pertama dari fungsi torch.arange() adalah nilai awal dari range, yaitu 0
• Argumen kedua dari fungsi torch.arange() adalah nilai akhir dari range, yaitu 10

In [9]:

# Contoh lain range tensor
rangetensor2 = torch.arange(0, 10, 2)
print(rangetensor2)
print(rangetensor2.ndim)
print(rangetensor2.shape)

# Contoh lain range tensor rangetensor2 = torch.arange(0, 10, 2) print(rangetensor2) print(rangetensor2.ndim) print(rangetensor2.shape)

tensor([0, 2, 4, 6, 8])
1
torch.Size([5])

Penjelasan

• Argumen ketiga dari fungsi torch.arange() adalah interval dari range, yaitu 2
• Dalam hal ini, kita akan mendapatkan nilai range dari 0 sampai 10 dengan interval 2

In [10]:

# Contoh lain range tensor
rangetensor3 = torch.arange(0, 10, 0.5)
print(rangetensor3)
print(rangetensor3.ndim)
print(rangetensor3.shape)

# Contoh lain range tensor rangetensor3 = torch.arange(0, 10, 0.5) print(rangetensor3) print(rangetensor3.ndim) print(rangetensor3.shape)

tensor([0.0000, 0.5000, 1.0000, 1.5000, 2.0000, 2.5000, 3.0000, 3.5000, 4.0000,
        4.5000, 5.0000, 5.5000, 6.0000, 6.5000, 7.0000, 7.5000, 8.0000, 8.5000,
        9.0000, 9.5000])
1
torch.Size([20])

Tensor Zeros dan Ones¶

Zeros adalah tensor yang berisi semua nilai 0, sedangkan ones adalah tensor yang berisi semua nilai 1. Kita dapat membuat tensor zeros dan ones dengan menggunakan fungsi torch.zeros() dan torch.ones().

Contohnya:

In [11]:

# Tensor dengan nilai 1
tensor1 = torch.ones(4, 5)
print(tensor1)
print(tensor1.ndim)
print(tensor1.shape)

# Tensor dengan nilai 1 tensor1 = torch.ones(4, 5) print(tensor1) print(tensor1.ndim) print(tensor1.shape)

tensor([[1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.],
        [1., 1., 1., 1., 1.]])
2
torch.Size([4, 5])

In [12]:

# Tensor dengan nilai 0
tensor0 = torch.zeros(4, 5)
print(tensor0)
print(tensor0.ndim)
print(tensor0.shape)

# Tensor dengan nilai 0 tensor0 = torch.zeros(4, 5) print(tensor0) print(tensor0.ndim) print(tensor0.shape)

tensor([[0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.]])
2
torch.Size([4, 5])

Mengecek dan Mengubah Tipe Data Tensor¶

Untuk mengecek tipe data dari tensor, kita dapat menggunakan fungsi dtype dari tensor tersebut. Untuk mengubah tipe data dari tensor, kita dapat menggunakan fungsi to() dari tensor tersebut. Contohnya sebagai berikut:

In [13]:

tensor_x = torch.arange(0, 5)
print(tensor_x)
print(tensor_x.ndim)
print(tensor_x.shape)
print(tensor_x.dtype)

tensor_x = torch.arange(0, 5) print(tensor_x) print(tensor_x.ndim) print(tensor_x.shape) print(tensor_x.dtype)

tensor([0, 1, 2, 3, 4])
1
torch.Size([5])
torch.int64

Dalam contoh di atas, kita menggunakan fungsi dtype untuk mengecek tipe data dari tensor x. Kemudian, kita menggunakan fungsi to() untuk mengubah tipe data dari tensor x menjadi float32 pada contoh berikut ini:

In [14]:

# konversi tensor_x menjadi float32
tensor_x = tensor_x.float()
print(tensor_x.dtype)

# konversi tensor_x menjadi float32 tensor_x = tensor_x.float() print(tensor_x.dtype)

torch.float32

Kita juga dapat mendefinisikan tipe data dari tensor di awal ketika kita membuat tensor tersebut. Contohnya sebagai berikut:

In [15]:

tensor_x = torch.arange(0, 5).float()
print(tensor_x.dtype)

tensor_x = torch.arange(0, 5).float() print(tensor_x.dtype)

torch.float32

Terdapat banyak tipe data pada PyTorch. Pada umumnya, kita akan menggunakan float32 atau torch.float. Ini mengacu pada bilangan real dengan presisi 32-bit. Untuk melihat daftar lengkap dari tipe data yang tersedia, kamu dapat membuka dokumentasi PyTorch disini.

Apa itu Presisi 32-bit?

Presisi 32-bit adalah jumlah bit yang digunakan untuk menyimpan bilangan real. Semakin banyak bit yang digunakan, semakin presisi bilangan real yang dapat disimpan. Semakin presisi bilangan real yang dapat disimpan, semakin besar ukuran dari bilangan real tersebut.

Apakah bisa menggunakan tipe data lain?

Tentu saja bisa. Terdapat istilah half-precision dan double-precision. Half-precision adalah tipe data dengan presisi 16-bit, sedangkan double-precision adalah tipe data dengan presisi 64-bit.

Mengapa Menggunakan Float dan Bukan Integer?

Karena kita akan melakukan operasi matematika pada tensor, maka kita membutuhkan tipe data yang dapat menyimpan bilangan real. Operasi matematika ini akan menghasilkan bilangan real, bukan bilangan bulat. Semakin presisi bilangan real yang dapat disimpan, semakin presisi hasil dari operasi matematika tersebut. Namun, semakin presisi bilangan real yang dapat disimpan, semakin besar ukuran dari bilangan real tersebut.

Sumber: Nvidia Blog

Operasi dan Manipulasi Tensor¶

Data direpresentasikan dalam bentuk tensor untuk kemudian diproses. Setiap tensor yang ada dapat dioperasikan dan dimanipulasi. Kita dapat melakukan hal ini dengan menggunakan fungsi-fungsi yang tersedia pada PyTorch.

Operasi Dasar Aritmatika¶

Operasi-operasi aritmatika dasar yang dapat dilakukan pada tensor adalah sebagai berikut:

In [16]:

x = torch.tensor([1, 2, 3, 4, 5])
y = torch.tensor([6, 7, 8, 9, 10])

# operasi penjumlahan
z = x + y
print(z)

x = torch.tensor([1, 2, 3, 4, 5]) y = torch.tensor([6, 7, 8, 9, 10]) # operasi penjumlahan z = x + y print(z)

tensor([ 7,  9, 11, 13, 15])

In [17]:

# operasi pengurangan
z = y - x
print(z)

# operasi pengurangan z = y - x print(z)

tensor([5, 5, 5, 5, 5])

In [18]:

# contoh operasi penjumlahan dan pengurangan lain
z = z + 10
print(f"Nilai Z setelah penjumlahan 10: {z}")
z = z - 2
print(f"Nilai Z setelah pengurangan 2: {z}")

# contoh operasi penjumlahan dan pengurangan lain z = z + 10 print(f"Nilai Z setelah penjumlahan 10: {z}") z = z - 2 print(f"Nilai Z setelah pengurangan 2: {z}")

Nilai Z setelah penjumlahan 10: tensor([15, 15, 15, 15, 15])
Nilai Z setelah pengurangan 2: tensor([13, 13, 13, 13, 13])

In [19]:

# perkalian
z = x * y
print(z)

# pembagian
z2 = y / x
print(z2)

# perkalian z = x * y print(z) # pembagian z2 = y / x print(z2)

tensor([ 6, 14, 24, 36, 50])
tensor([6.0000, 3.5000, 2.6667, 2.2500, 2.0000])

Juga terdapat fungsi yang disediakan PyTorch untuk melakukan perhitungan, sebagai contoh:

In [20]:

# torch add
z = torch.add(x, y)
print(f"Hasil penjumlahan: {z}")

# torch sub
z = torch.sub(y, x)
print(f"Hasil pengurangan: {z}")

# torch mul
z = torch.mul(x, y)
print(f"Hasil perkalian: {z}")

# torch div
z2 = torch.div(y, x)
print(f"Hasil pembagian: {z2}")

# torch sqrt
z3 = torch.sqrt(x)
print(f"Hasil akar kuadrat: {z3}")

# torch exp
z4 = torch.exp(x)
print(f"Hasil eksponen: {z4}")

# torch add z = torch.add(x, y) print(f"Hasil penjumlahan: {z}") # torch sub z = torch.sub(y, x) print(f"Hasil pengurangan: {z}") # torch mul z = torch.mul(x, y) print(f"Hasil perkalian: {z}") # torch div z2 = torch.div(y, x) print(f"Hasil pembagian: {z2}") # torch sqrt z3 = torch.sqrt(x) print(f"Hasil akar kuadrat: {z3}") # torch exp z4 = torch.exp(x) print(f"Hasil eksponen: {z4}")

Hasil penjumlahan: tensor([ 7,  9, 11, 13, 15])
Hasil pengurangan: tensor([5, 5, 5, 5, 5])
Hasil perkalian: tensor([ 6, 14, 24, 36, 50])
Hasil pembagian: tensor([6.0000, 3.5000, 2.6667, 2.2500, 2.0000])
Hasil akar kuadrat: tensor([1.0000, 1.4142, 1.7321, 2.0000, 2.2361])
Hasil eksponen: tensor([  2.7183,   7.3891,  20.0855,  54.5981, 148.4132])

Perkalian Matrix¶

Operasi yang akan sangat sering ditemui ketika kita melakukan operasi tensor adalah perkalian matrix. Kita dapat melakukan perkalian matrix dengan menggunakan fungsi torch.matmul().

In [21]:

# Contoh perkalian matrix
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
y = torch.tensor([[7, 8], [9, 10], [11, 12]])
z = torch.matmul(x, y)
print(f"Hasil perkalian matrix:\n{z}")

# Contoh perkalian matrix x = torch.tensor([[1, 2, 3], [4, 5, 6]]) y = torch.tensor([[7, 8], [9, 10], [11, 12]]) z = torch.matmul(x, y) print(f"Hasil perkalian matrix:\n{z}")

Hasil perkalian matrix:
tensor([[ 58,  64],
        [139, 154]])

aturan untuk perkalian matrix adalah sebagai berikut:

• Jumlah kolom pada matrix pertama harus sama dengan jumlah baris pada matrix kedua
• Jumlah baris pada matrix pertama harus sama dengan jumlah kolom pada matrix kedua

Apabila perkalian matrix tidak memenuhi ketentuan diatas, maka dapat dilihat seperti contoh di bawah ini:

x = torch.tensor([[1, 2, 3], [4, 5, 6]])
y = torch.tensor([[1, 2], [3, 4], [5, 6]])
z = torch.matmul(x, y)

Perlu diperhatikan bahwa terdapat perbedaan antara element-wise multiplication dan matrix multiplication. Element-wise multiplication dilakukan dengan menggunakan operator * atau fungsi torch.mul(). Sedangkan matrix multiplication dilakukan dengan menggunakan fungsi torch.matmul().

Element-wise multiplication adalah perkalian antara masing-masing elemen pada tensor. Sementara itu matrix multiplication adalah perkalian antara masing-masing baris pada matrix pertama dengan masing-masing kolom pada matrix kedua. Perhatikan contoh berikut ini:

Catatan Lain hasilnya dengan Dot Product. Dot product adalah istilah yang kerap digunakan pada deep learning. Dot product adalah operasi yang dilakukan pada dua buah vektor. Hasil dari dot product adalah sebuah bilangan real. Dot product dapat dilakukan dengan menggunakan fungsi torch.dot().

In [22]:

# contoh element wise multiplication
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
y = torch.tensor([[7, 8, 9], [10, 11, 12]])

z = x * y
print(f"Hasil perkalian element wise:\n{z}")

# contoh matrix multiplication
x = torch.tensor([[1, 2, 3], [4, 5, 6]])
y = torch.tensor([[7, 8], [9, 10], [11, 12]])
z = torch.matmul(x, y)
print(f"Hasil perkalian matrix:\n{z}")

# contoh dot product
x = torch.tensor([1, 2, 3])
y = torch.tensor([4, 5, 6])
z = torch.dot(x, y)
print(f"Hasil dot product:\n{z}")

# contoh element wise multiplication x = torch.tensor([[1, 2, 3], [4, 5, 6]]) y = torch.tensor([[7, 8, 9], [10, 11, 12]]) z = x * y print(f"Hasil perkalian element wise:\n{z}") # contoh matrix multiplication x = torch.tensor([[1, 2, 3], [4, 5, 6]]) y = torch.tensor([[7, 8], [9, 10], [11, 12]]) z = torch.matmul(x, y) print(f"Hasil perkalian matrix:\n{z}") # contoh dot product x = torch.tensor([1, 2, 3]) y = torch.tensor([4, 5, 6]) z = torch.dot(x, y) print(f"Hasil dot product:\n{z}")

Hasil perkalian element wise:
tensor([[ 7, 16, 27],
        [40, 55, 72]])
Hasil perkalian matrix:
tensor([[ 58,  64],
        [139, 154]])
Hasil dot product:
32

Apa yang terjadi jika perkalian matrix dilakukan terhadap dua buah tensor yang memiliki jumlah baris dan kolom yang sama? Lihat contoh error di bawah ini:

In [23]:

tensor_X = torch.tensor([[1, 2, 3], [4, 5, 6]])
tensor_Y = torch.tensor([[7, 8, 9], [10, 11, 12]])

print(f"Tensor X:\n{tensor_X}")
print(f"Tensor Y:\n{tensor_Y}")
print(f"Kedua tensor memiliki ukuran: {tensor_X.shape}")

tensor_X = torch.tensor([[1, 2, 3], [4, 5, 6]]) tensor_Y = torch.tensor([[7, 8, 9], [10, 11, 12]]) print(f"Tensor X:\n{tensor_X}") print(f"Tensor Y:\n{tensor_Y}") print(f"Kedua tensor memiliki ukuran: {tensor_X.shape}")

Tensor X:
tensor([[1, 2, 3],
        [4, 5, 6]])
Tensor Y:
tensor([[ 7,  8,  9],
        [10, 11, 12]])
Kedua tensor memiliki ukuran: torch.Size([2, 3])

In [24]:

# mencoba mengalikan tensor_X dengan tensor_Y
try:
    tensor_Z = torch.matmul(tensor_X, tensor_Y)
except Exception as e:
    print(f"Error: {e}")

# mencoba mengalikan tensor_X dengan tensor_Y try: tensor_Z = torch.matmul(tensor_X, tensor_Y) except Exception as e: print(f"Error: {e}")

Error: mat1 and mat2 shapes cannot be multiplied (2x3 and 2x3)

Untuk mengatasi error di atas, dapat dilakukan operasi transpose terhadap salah satu tensor

Operasi Transpose¶

Operasi transpose pada tensor dapat dilakukan dengan menggunakan fungsi torch.t().

In [25]:

# transpose tensor X
print(f"Tensor X sebelum di transpose:\n{tensor_X}")
tensor_X = torch.transpose(tensor_X, 0, 1)
print(f"Tensor X setelah di transpose:\n{tensor_X}")

# perkalian tensor_X dengan tensor_Y
tensor_Z = torch.matmul(tensor_X, tensor_Y)
print(f"Hasil perkalian tensor_X dengan tensor_Y:\n{tensor_Z}")

# transpose tensor X print(f"Tensor X sebelum di transpose:\n{tensor_X}") tensor_X = torch.transpose(tensor_X, 0, 1) print(f"Tensor X setelah di transpose:\n{tensor_X}") # perkalian tensor_X dengan tensor_Y tensor_Z = torch.matmul(tensor_X, tensor_Y) print(f"Hasil perkalian tensor_X dengan tensor_Y:\n{tensor_Z}")

Tensor X sebelum di transpose:
tensor([[1, 2, 3],
        [4, 5, 6]])
Tensor X setelah di transpose:
tensor([[1, 4],
        [2, 5],
        [3, 6]])
Hasil perkalian tensor_X dengan tensor_Y:
tensor([[47, 52, 57],
        [64, 71, 78],
        [81, 90, 99]])

In [26]:

# torch.matmul() juga dapat disingkat menjadi torch.mm()
tensor_Z = torch.mm(tensor_X, tensor_Y)
print(f"Hasil perkalian tensor_X dengan tensor_Y:\n{tensor_Z}")

# torch.matmul() juga dapat disingkat menjadi torch.mm() tensor_Z = torch.mm(tensor_X, tensor_Y) print(f"Hasil perkalian tensor_X dengan tensor_Y:\n{tensor_Z}")

Hasil perkalian tensor_X dengan tensor_Y:
tensor([[47, 52, 57],
        [64, 71, 78],
        [81, 90, 99]])

Ilustrasi secara visual dapat dilihat pada gambar di bawah ini:

Sumber: Mrdbourke Github

Min Max Mean Sum dan kawan-kawan¶

PyTorch juga menyediakan fungsi-fungsi untuk melakukan operasi min, max, mean, dan sum pada tensor. Fungsi-fungsi tersebut dapat dilihat pada contoh di bawah ini:

In [27]:

tensor_X = torch.tensor([[1, 2, 3], [4, 5, 6]]).float()

# contoh min
contoh_min = torch.min(tensor_X)
print(f"Nilai minimum dari tensor_X: {contoh_min}")

# contoh max
contoh_max = torch.max(tensor_X)
print(f"Nilai maksimum dari tensor_X: {contoh_max}")

# contoh mean
contoh_mean = torch.mean(tensor_X)
print(f"Nilai rata-rata dari tensor_X: {contoh_mean}")

# contoh sum
contoh_sum = torch.sum(tensor_X)
print(f"Nilai total dari tensor_X: {contoh_sum}")

# contoh argmin
contoh_argmin = torch.argmin(tensor_X)
print(f"Nilai index minimum dari tensor_X: {contoh_argmin}")

# contoh argmax
contoh_argmax = torch.argmax(tensor_X)
print(f"Nilai index maksimum dari tensor_X: {contoh_argmax}")

# contoh abs
contoh_abs = torch.abs(torch.tensor([-1, -2, 3, 4]))
print(f"Nilai absolut dari tensor_X: {contoh_abs}")

# contoh prod
contoh_prod = torch.prod(tensor_X)
print(f"Nilai total perkalian dari tensor_X: {contoh_prod}")

# contoh sqrt
contoh_sqrt = torch.sqrt(torch.tensor([1, 4, 9, 16, 25]))
print(f"Nilai akar kuadrat dari tensor_X: {contoh_sqrt}")

# contoh exp
contoh_exp = torch.exp(torch.tensor([1, 2, 3]))
print(f"Nilai eksponen dari tensor_X: {contoh_exp}")

# contoh log
contoh_log = torch.log(torch.tensor([1, 2.7183, 7.3891]))
print(f"Nilai logaritma dari tensor_X: {contoh_log}")

tensor_X = torch.tensor([[1, 2, 3], [4, 5, 6]]).float() # contoh min contoh_min = torch.min(tensor_X) print(f"Nilai minimum dari tensor_X: {contoh_min}") # contoh max contoh_max = torch.max(tensor_X) print(f"Nilai maksimum dari tensor_X: {contoh_max}") # contoh mean contoh_mean = torch.mean(tensor_X) print(f"Nilai rata-rata dari tensor_X: {contoh_mean}") # contoh sum contoh_sum = torch.sum(tensor_X) print(f"Nilai total dari tensor_X: {contoh_sum}") # contoh argmin contoh_argmin = torch.argmin(tensor_X) print(f"Nilai index minimum dari tensor_X: {contoh_argmin}") # contoh argmax contoh_argmax = torch.argmax(tensor_X) print(f"Nilai index maksimum dari tensor_X: {contoh_argmax}") # contoh abs contoh_abs = torch.abs(torch.tensor([-1, -2, 3, 4])) print(f"Nilai absolut dari tensor_X: {contoh_abs}") # contoh prod contoh_prod = torch.prod(tensor_X) print(f"Nilai total perkalian dari tensor_X: {contoh_prod}") # contoh sqrt contoh_sqrt = torch.sqrt(torch.tensor([1, 4, 9, 16, 25])) print(f"Nilai akar kuadrat dari tensor_X: {contoh_sqrt}") # contoh exp contoh_exp = torch.exp(torch.tensor([1, 2, 3])) print(f"Nilai eksponen dari tensor_X: {contoh_exp}") # contoh log contoh_log = torch.log(torch.tensor([1, 2.7183, 7.3891])) print(f"Nilai logaritma dari tensor_X: {contoh_log}")

Nilai minimum dari tensor_X: 1.0
Nilai maksimum dari tensor_X: 6.0
Nilai rata-rata dari tensor_X: 3.5
Nilai total dari tensor_X: 21.0
Nilai index minimum dari tensor_X: 0
Nilai index maksimum dari tensor_X: 5
Nilai absolut dari tensor_X: tensor([1, 2, 3, 4])
Nilai total perkalian dari tensor_X: 720.0
Nilai akar kuadrat dari tensor_X: tensor([1., 2., 3., 4., 5.])
Nilai eksponen dari tensor_X: tensor([ 2.7183,  7.3891, 20.0855])
Nilai logaritma dari tensor_X: tensor([0.0000, 1.0000, 2.0000])

Mengubah bentuk dan dimensi tensor¶

Operasi mengubah dimensi ini akan sangat sering kita temui ketika kita melakukan operasi pada tensor. Beberapa fungsi yang kerap digunakan antara lain sebagai berikut

Reshape¶

In [28]:

# contoh penggunaan reshape
tensor_X = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(f"Tensor X sebelum di reshape:\n{tensor_X} | Shape: {tensor_X.shape}")
tensor_X = tensor_X.reshape(3, 2)
print(f"Tensor X setelah di reshape:\n{tensor_X} | Shape: {tensor_X.shape}")

# contoh penggunaan reshape tensor_X = torch.tensor([[1, 2, 3], [4, 5, 6]]) print(f"Tensor X sebelum di reshape:\n{tensor_X} | Shape: {tensor_X.shape}") tensor_X = tensor_X.reshape(3, 2) print(f"Tensor X setelah di reshape:\n{tensor_X} | Shape: {tensor_X.shape}")

Tensor X sebelum di reshape:
tensor([[1, 2, 3],
        [4, 5, 6]]) | Shape: torch.Size([2, 3])
Tensor X setelah di reshape:
tensor([[1, 2],
        [3, 4],
        [5, 6]]) | Shape: torch.Size([3, 2])

Penjelasan:

Fungsi torch.reshape() digunakan untuk mengubah bentuk dari tensor. Bentuk dari tensor dapat diubah dengan memasukkan nilai baru untuk parameter shape pada fungsi torch.reshape(). Parameter shape merupakan tuple yang berisi nilai untuk dimensi baru dari tensor.

Dalam contoh di atas pada awalnya tensor x memiliki bentuk (2, 3). Setelah dilakukan reshape, tensor x memiliki bentuk (3, 2).

Tensor.View¶

Tensor.view() adalah fungsi yang mirip dengan fungsi torch.reshape(). Perbedaannya adalah fungsi torch.view() hanya mengubah tampilan dari tensor dengan tetap mempertahankan bentuk dari tensor pada memori. Sedangkan fungsi torch.reshape() mengubah bentuk dari tensor.

In [29]:

# contoh penggunaan Tensor.view()
tensor_X = torch.tensor([[1, 2, 3], [4, 5, 6]])
print(f"Tensor X sebelum di reshape:\n{tensor_X} | Shape: {tensor_X.shape}")
tensor_X = tensor_X.view(3, 2)
print(f"Tensor X setelah di reshape:\n{tensor_X} | Shape: {tensor_X.shape}")

# contoh penggunaan Tensor.view() tensor_X = torch.tensor([[1, 2, 3], [4, 5, 6]]) print(f"Tensor X sebelum di reshape:\n{tensor_X} | Shape: {tensor_X.shape}") tensor_X = tensor_X.view(3, 2) print(f"Tensor X setelah di reshape:\n{tensor_X} | Shape: {tensor_X.shape}")

Tensor X sebelum di reshape:
tensor([[1, 2, 3],
        [4, 5, 6]]) | Shape: torch.Size([2, 3])
Tensor X setelah di reshape:
tensor([[1, 2],
        [3, 4],
        [5, 6]]) | Shape: torch.Size([3, 2])

Stack¶

Fungsi torch.stack() digunakan untuk menggabungkan dua buah tensor. Fungsi ini akan menggabungkan dua buah tensor dengan dimensi yang sama. Fungsi ini akan menambahkan dimensi baru pada tensor yang akan digabungkan. Fungsi ini akan menghasilkan tensor baru dengan dimensi yang lebih tinggi.

In [30]:

# contoh stack
tensor_X = torch.tensor([1, 4])
tensor_Y = torch.tensor([2, 5])
tensor_Z = torch.tensor([3, 6])

tensor_3D = torch.stack((tensor_X, tensor_Y, tensor_Z))
print(f"Hasil stack:\n{tensor_3D} | Shape: {tensor_3D.shape}")

# contoh stack tensor_X = torch.tensor([1, 4]) tensor_Y = torch.tensor([2, 5]) tensor_Z = torch.tensor([3, 6]) tensor_3D = torch.stack((tensor_X, tensor_Y, tensor_Z)) print(f"Hasil stack:\n{tensor_3D} | Shape: {tensor_3D.shape}")

Hasil stack:
tensor([[1, 4],
        [2, 5],
        [3, 6]]) | Shape: torch.Size([3, 2])

Squeeze¶

Fungsi torch.squeeze() digunakan untuk menghilangkan dimensi yang memiliki nilai 1 pada tensor. Fungsi ini akan menghasilkan tensor baru dengan dimensi yang lebih rendah.

In [31]:

# Contoh penggunaan squeeze
tensor_X = torch.tensor([[[0,1], [1,2], [2,3]]])
print(f"Tensor X sebelum di squeeze:\n{tensor_X} | Shape: {tensor_X.shape}")
tensor_X = torch.squeeze(tensor_X)
print(f"Tensor X setelah di squeeze:\n{tensor_X} | Shape: {tensor_X.shape}")

# Contoh penggunaan squeeze tensor_X = torch.tensor([[[0,1], [1,2], [2,3]]]) print(f"Tensor X sebelum di squeeze:\n{tensor_X} | Shape: {tensor_X.shape}") tensor_X = torch.squeeze(tensor_X) print(f"Tensor X setelah di squeeze:\n{tensor_X} | Shape: {tensor_X.shape}")

Tensor X sebelum di squeeze:
tensor([[[0, 1],
         [1, 2],
         [2, 3]]]) | Shape: torch.Size([1, 3, 2])
Tensor X setelah di squeeze:
tensor([[0, 1],
        [1, 2],
        [2, 3]]) | Shape: torch.Size([3, 2])

Unsqueeze¶

Adalah kebalikan dari fungsi torch.squeeze(). Fungsi torch.unsqueeze() digunakan untuk menambahkan dimensi baru pada tensor. Fungsi ini akan menghasilkan tensor baru dengan dimensi yang lebih tinggi.

In [32]:

print(f"Tensor X sebelum di unsqueeze:\n{tensor_X} | Shape: {tensor_X.shape}")
tensor_X = torch.unsqueeze(tensor_X, 0)
print(f"Tensor X setelah di unsqueeze:\n{tensor_X} | Shape: {tensor_X.shape}")

print(f"Tensor X sebelum di unsqueeze:\n{tensor_X} | Shape: {tensor_X.shape}") tensor_X = torch.unsqueeze(tensor_X, 0) print(f"Tensor X setelah di unsqueeze:\n{tensor_X} | Shape: {tensor_X.shape}")

Tensor X sebelum di unsqueeze:
tensor([[0, 1],
        [1, 2],
        [2, 3]]) | Shape: torch.Size([3, 2])
Tensor X setelah di unsqueeze:
tensor([[[0, 1],
         [1, 2],
         [2, 3]]]) | Shape: torch.Size([1, 3, 2])

Permute¶

Fungsi torch.permute() digunakan untuk mengubah dimensi dari tensor. Fungsi ini akan mengubah dimensi dari tensor dengan memasukkan nilai baru untuk parameter dims pada fungsi torch.permute(). Parameter dims merupakan tuple yang berisi nilai untuk dimensi baru dari tensor.

In [33]:

# contoh penggunaan permute
tensor_X = torch.tensor([[[0,1], [1,2], [2,3]]])
print(f"Tensor X sebelum di permute:\n{tensor_X} | Shape: {tensor_X.shape}")
tensor_X = tensor_X.permute(2, 0, 1)
print(f"Tensor X setelah di permute:\n{tensor_X} | Shape: {tensor_X.shape}")

# contoh penggunaan permute tensor_X = torch.tensor([[[0,1], [1,2], [2,3]]]) print(f"Tensor X sebelum di permute:\n{tensor_X} | Shape: {tensor_X.shape}") tensor_X = tensor_X.permute(2, 0, 1) print(f"Tensor X setelah di permute:\n{tensor_X} | Shape: {tensor_X.shape}")

Tensor X sebelum di permute:
tensor([[[0, 1],
         [1, 2],
         [2, 3]]]) | Shape: torch.Size([1, 3, 2])
Tensor X setelah di permute:
tensor([[[0, 1, 2]],

        [[1, 2, 3]]]) | Shape: torch.Size([2, 1, 3])

Penjelasan:

Argumen pada permute() adalah dimensi baru dari tensor. Argumen dimensi baru harus berjumlah sama dengan jumlah dimensi pada tensor. Argumen dimensi baru harus berisi semua dimensi pada tensor.

Pada contoh diatas awalnya tensor memiliki dimensi (1, 3, 2). Kemudian, argumen yang diberikan pada operasi permute adalah (2, 0, 1). Artinya, dimensi pertama (indeks ke-0) dari tensor yang baru adalah dimensi ketiga (indeks ke-2) dari tensor yang lama. Dimensi kedua (indeks ke-1) dari tensor yang baru adalah dimensi pertama (indeks ke-0) dari tensor yang lama. Dimensi ketiga (indeks ke-2) dari tensor yang baru adalah dimensi kedua (indeks ke-1) dari tensor yang lama.

Konversi dari dan ke Numpy¶

PyTorch menyediakan fungsi untuk melakukan konversi dari dan ke Numpy. Numpy adalah library yang sering digunakan untuk melakukan operasi pada data numerik. Fungsi-fungsi yang digunakan untuk melakukan konversi antara PyTorch dan Numpy adalah sebagai berikut:

From Numpy¶

In [34]:

import numpy as np

# contoh penggunaan torch.from_numpy()
numpy_array = np.array([1, 2, 3])
print(f"Array numpy: {numpy_array} | Type: {type(numpy_array)}")

tensor_X = torch.from_numpy(numpy_array)
print(f"Tensor X: {tensor_X} | Type: {type(tensor_X)}")

import numpy as np # contoh penggunaan torch.from_numpy() numpy_array = np.array([1, 2, 3]) print(f"Array numpy: {numpy_array} | Type: {type(numpy_array)}") tensor_X = torch.from_numpy(numpy_array) print(f"Tensor X: {tensor_X} | Type: {type(tensor_X)}")

Array numpy: [1 2 3] | Type: <class 'numpy.ndarray'>
Tensor X: tensor([1, 2, 3]) | Type: <class 'torch.Tensor'>

Numpy to Tensor¶

In [35]:

# contoh penggunaan tensor.numpy()

tensor_X = torch.tensor([1, 2, 3])
print(f"Tensor X: {tensor_X} | Type: {type(tensor_X)}")

numpy_array = tensor_X.numpy()
print(f"Array numpy: {numpy_array} | Type: {type(numpy_array)}")

# contoh penggunaan tensor.numpy() tensor_X = torch.tensor([1, 2, 3]) print(f"Tensor X: {tensor_X} | Type: {type(tensor_X)}") numpy_array = tensor_X.numpy() print(f"Array numpy: {numpy_array} | Type: {type(numpy_array)}")

Tensor X: tensor([1, 2, 3]) | Type: <class 'torch.Tensor'>
Array numpy: [1 2 3] | Type: <class 'numpy.ndarray'>

Reproducibility¶

Seperti yang kamu ketahui, ketika kita melakukan operasi pada tensor, maka hasil dari operasi tersebut akan berbeda setiap kali kita menjalankan kode tersebut. Hal ini disebabkan karena PyTorch menggunakan fungsi-fungsi yang memiliki nilai acak.

Perhatikan contoh kode di bawah ini:

In [36]:

# contoh random
tensor_X = torch.rand(3, 3)
print(f"Tensor X:\n{tensor_X}")

# contoh random tensor_X = torch.rand(3, 3) print(f"Tensor X:\n{tensor_X}")

Tensor X:
tensor([[0.0569, 0.0166, 0.4266],
        [0.9171, 0.6317, 0.0874],
        [0.4841, 0.3089, 0.9260]])

Coba jalankan kembali kode di atas. Hasilnya akan berbeda setiap kali kita menjalankan kode tersebut. Hal ini disebabkan karena fungsi torch.rand() menghasilkan nilai acak.

Lalu bagaimana cara agar hasil dari operasi tersebut tetap sama setiap kali kita menjalankan kode tersebut?

Perhatikan contoh kode di bawah ini:

In [37]:

# contoh seed
torch.manual_seed(1234)
tensor_X = torch.rand(3, 3)
print(f"Tensor X:\n{tensor_X}")

# contoh seed torch.manual_seed(1234) tensor_X = torch.rand(3, 3) print(f"Tensor X:\n{tensor_X}")

Tensor X:
tensor([[0.0290, 0.4019, 0.2598],
        [0.3666, 0.0583, 0.7006],
        [0.0518, 0.4681, 0.6738]])

Sekarang, coba jalankan kemudian kode di atas. Hasilnya akan sama setiap kali kita menjalankan kode tersebut. Hal ini disebabkan karena kita telah menetapkan nilai acak yang digunakan oleh fungsi torch.rand() dengan menggunakan fungsi torch.manual_seed().

Kamu dapat menetapkan nilai acak yang digunakan dengan memasukkan nilai integer pada fungsi torch.manual_seed(). Nilai integer yang digunakan harus sama setiap kali kita menjalankan kode tersebut.

Menggunakan GPU¶

PyTorch dapat digunakan untuk melakukan operasi pada GPU. Dengan menggunakan GPU kita dapat melakukan operasi dengan lebih cepat. Untuk menggunakan GPU, kita harus menginstall PyTorch dengan GPU support. Untuk menginstall PyTorch dengan GPU support, kamu dapat mengikuti langkah-langkah pada link ini.

Setelah itu pastikan bahwa kamu telah menginstall CUDA dan CUDNN. Untuk menginstall CUDA dan CUDNN, kamu dapat mengikuti langkah-langkah pada link ini.

Untuk memastikan bahwa kamu telah memiliki GPU dan sudah menginstall CUDA dan CUDNN, kamu dapat menjalankan kode di bawah ini:

In [38]:

!nvidia-smi

!nvidia-smi

Thu Dec  8 15:24:16 2022       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 515.43.04    Driver Version: 515.43.04    CUDA Version: 11.7     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  NVIDIA GeForce ...  On   | 00000000:01:00.0  On |                  N/A |
| 56%   65C    P2   186W / 200W |   7210MiB / 11264MiB |     89%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+
                                                                               
+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
|    0   N/A  N/A      2755      G   /usr/lib/xorg/Xorg                210MiB |
|    0   N/A  N/A      2930      G   /usr/bin/gnome-shell               61MiB |
|    0   N/A  N/A     70730      G   ...RendererForSitePerProcess       19MiB |
|    0   N/A  N/A    905395      G   ...167311246520674684,131072      273MiB |
|    0   N/A  N/A    906009      G   ...RendererForSitePerProcess       67MiB |
|    0   N/A  N/A    909102      G   ...AAAAAAAAA= --shared-files       25MiB |
|    0   N/A  N/A   1010460      C   python                           6545MiB |
+-----------------------------------------------------------------------------+

Jika kode tersebut berhasil dijalankan maka kamu telah memiliki GPU dan sudah menginstall CUDA dan CUDNN.

Catatan: Jika kamu menggunakan Google Colab, Kaggle, atau Paperspace, pastikan kamu telah mengaktifkan GPU pada notebook tersebut.

Untuk menggunakan GPU pada PyTorch, kamu dapat melihatnya pada contoh di bawah ini:

In [39]:

# contoh penggunaan GPU
import torch
if torch.cuda.is_available():
    device = torch.device("cuda")
    print("Tersedia GPU")
elif torch.backends.mps.is_available():
    device = torch.device("mps")
    print("Tersedia MPS Apple Silicon")
else:
    device = torch.device("cpu")
    print("Tersedia CPU")

# contoh penggunaan GPU import torch if torch.cuda.is_available(): device = torch.device("cuda") print("Tersedia GPU") elif torch.backends.mps.is_available(): device = torch.device("mps") print("Tersedia MPS Apple Silicon") else: device = torch.device("cpu") print("Tersedia CPU")

Tersedia GPU

Penjelasan:

• torch.device digunakan untuk mendefinisikan device yang akan digunakan. Pada contoh di atas, kita menggunakan torch.device("cuda") untuk menggunakan GPU.
• Namun pada program diatas, saya memberikan alternatif lain apabila kamu tidak memiliki GPU NVIDIA. Misalnya kamu menggunakan Apple Silicon (Apple M1 atau M2), maka kamu dapat menggunakan torch.device("mps").
• Kalau kamu menggunakan CPU, maka kamu dapat menggunakan torch.device("cpu").

Kamu juga dapat mengecek berapa banyak GPU yang kamu miliki dengan menggunakan kode di bawah ini:

In [40]:

torch.cuda.device_count()

torch.cuda.device_count()

Out[40]:

1

Memindahkan Tensor ke GPU¶

Kamu dapat memindahkan tensor ke memori GPU dengan menggunakan kode di bawah ini sehingga perhitungan dan proses dapat dilakukan lebih cepat.

In [41]:

tensor = torch.tensor([1, 2, 3, 4, 5])
print(f"Tensor: {tensor} | Tensor Device: {tensor.device}")

tensor = torch.tensor([1, 2, 3, 4, 5]) print(f"Tensor: {tensor} | Tensor Device: {tensor.device}")

Tensor: tensor([1, 2, 3, 4, 5]) | Tensor Device: cpu

In [42]:

# memindahkan tensor ke GPU
tensor = tensor.to(device)
print(f"Tensor: {tensor} | Tensor Device: {tensor.device}")

# memindahkan tensor ke GPU tensor = tensor.to(device) print(f"Tensor: {tensor} | Tensor Device: {tensor.device}")

Tensor: tensor([1, 2, 3, 4, 5], device='cuda:0') | Tensor Device: cuda:0

Memindahkan Tensor ke CPU kembali¶

Kamu dapat memindahkan tensor dari memori GPU ke memori CPU dengan menggunakan kode di bawah ini.

In [43]:

# memindahkan tensor ke CPU
tensor = tensor.cpu()
print(f"Tensor: {tensor} | Tensor Device: {tensor.device}")

# memindahkan tensor ke CPU tensor = tensor.cpu() print(f"Tensor: {tensor} | Tensor Device: {tensor.device}")

Tensor: tensor([1, 2, 3, 4, 5]) | Tensor Device: cpu

---

Latihan Modul 00. Pengantar¶

1. Buatlah sebuah tensor bernama tensor_x dengan menggunakan fungsi torch.rand() dengan ukuran 3x3. Kemudian cetak nilai dari tensor_x beserta tipe datanya dan dimensinya.

2. Buatlah sebuah tensor bernama tensor_y dengan menggunakan fungsi torch.rand() dengan ukuran 3x3. Kemudian cetak nilai dari tensor_y beserta nilai maksimum dan minimumnya.

3. Lakukanlah operasi penjumlahan dan pengurangan antara tensor_x dan tensor_y. Simpan hasilnya pada variabel tensor_sum dan tensor_sub.

4. Lakukan operasi perkalian matrix antara tensor_x dan tensor_y. Simpan hasilnya pada variabel tensor_mul. Lalu lakukan operasi transpose pada tensor_mul. Simpan hasilnya pada variabel tensor_transpose.

5. Ubah dimensi dari tensor_transpose menjadi 1x9 menggunakan reshape. Simpan hasilnya pada variabel tensor_reshape.

6. Buat sebuah tensor random dengan random seed 42 bernama tensor_random dengan ukuran 3x3. Kemudian cetak nilai dari tensor_random beserta nilai maksimum dan minimumnya.

7. Pindahkan tensor_random ke device GPU. Simpan hasilnya pada variabel tensor_gpu. Abaikan bagian ini jika anda tidak memiliki GPU

Anda dapat mengerjakan tugas ini dan melihat jawabannya pada tautan berikut ini

Jika anda mengalami kesulitan dalam pengerjaan, silahkan tanyakan melalui forum diskusi berikut ini, kami akan segera menjawabnya.

Sumber Belajar Tambahan¶

1. Learn The Basic, PyTorch