Memilih Tensorflow atau Pytorch untuk Framework Deep Learning

By | November 4, 2023
Print Friendly, PDF & Email
626 Views

Memilih Tensorflow atau Pytorch merupakan pilihan yang sulit karena keduanya banyak digunakan untuk kalangan akademis dan industri. TensorFlow merupakan library open source untuk menghitung komputasi numerik secara mudah dan cepat. TensorFlow dirancang untuk penelitian dan pengembangan sistem produksi. Dengan library TensorFlow, programmer dapat membuat grafik dari data terstruktur yang mendeskripsikan bagaimana data bergerak melalui grafik, atau serangkaian node pemrosesan. Setiap node dalam grafik mewakili operasi matematika, dan setiap koneksi atau tepi antar node adalah baris data multidimensi atau disebut  tensor.

PyTorch merupakan library open source yang digunakan untuk mengembangkan dan melatih neural network. Berbeda dengan TensorFlow yang menggunakan grafik komputasi statis, PyTorch menggunakan komputasi dinamis sehingga lebih fleksibel untuk data yang lebih kompleks. Library yang dirilis pada tahun 2016 ini dirancang sedemikian rupa sehingga programmer tidak perlu mengkategorikan data menjadi “int”, “short”, atau “double”.

Secara umum menggunakan tensorflow tanpa library Keras akan cukup rumit bagi orang awam/newbie, hal ini berbeda dengan Pytorch lebih mudah dipahami. Nah dibawah ini kita akan kita bandingkan Pytorch yang menggunakan class yang telah disediakan dibandingkan dengan tensorflow / Keras.

Model MLP dengan Pytorch

Untuk membuat MLP – Multi Layer Perceptron di Pytorch, kita bisa menggunakan langkah-langkah yang direkomendasikan oleh Pytorch yaitu mulai dari

  1. membuat scaler yaitu memastikan input mempunyai rentang 0 sampai 1
  2. membuat dataset yang berfungsi sebagai persiapan dataset dan loader nya termasuk pengaturan jumlah batch dan mekanisme yang lain
  3. membuat model yang berisi fungsi-fungsi Linear dan operasi aktifasi
  4. melakukan pelatihan

Pertama-tama kita akan melakukan loading dataset iris

from sklearn import datasets
import torch
import torch.nn as nn
from torch.utils.data import Dataset,DataLoader
from sklearn.preprocessing import StandardScaler

iris = datasets.load_iris()
X = iris.data
y = iris.target

dataset iris tersebut diatas masih dalam bentuk mentah sehingga perlu dilakukan operasi normalisasi dan mengubah menjadi. tensor. Data iris tersebut mempunyai 3 kelas target ya!

See also  Penjelasan Algoritma RNN dan Contoh Kasus

melakukan operasi normalisasi

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

selanjutnya mengubah nya menjadi tensor dengan 2 type data yaitu float dan long

#dibuat tensor
X = torch.tensor(X_scaled).float()
y = torch.tensor(y).long()

Agar lebih bagus, kita akan memanfaatkan class Dataset untuk mempermudah pengaturan batch. Baca lebih lanjut Pytorch Membuat Dataset untuk Training Deep Learning

class DatasetKu(Dataset):
    def __init__(self,X,y):
        self.X = X
        self.y = y
    def __len__(self):
        return len(self.X)
    
    def __getitem__(self,index):
        inputs = self.X[index,:]
        targets = self.y[index]
        return inputs,targets

Kita memasukan pengaturan shufle dan batch nya

dataset_train = DatasetKu(X,y)
loader_train = DataLoader(dataset_train,batch_size = 32,shuffle= True)

Selanjutnya kita buat model MLP nya  semuanya menggunakan fungsi aktifasi ReLU()

class ModelKu(nn.Module):
    def __init__(self,ciri_fitur=4,jumlah_kelas=3):
        super().__init__()
        self.layer1 = nn.Linear(ciri_fitur,128)
        self.layer2 = nn.Linear(128,64)
        self.layer3 = nn.Linear(64,jumlah_kelas)
        self.act = nn.ReLU()
    def forward(self,x):
        x = self.act(self.layer1(x))
        x = self.act(self.layer2(x))
        x = self.act(self.layer3(x))
        return x

Mengingat ini mempunyai target multi class maka gunakan cross entropy loss. Baca lebih lanjut Pytorch  loss function Cross-entropy loss

criterion = nn.CrossEntropyLoss()

Selanjutnya kita setting parameter pelatihan dan panggil model

model = ModelKu(ciri_fitur=4,jumlah_kelas=3)
optimizer = torch.optim.Adam(model.parameters(),lr=0.01)

Selanjutnya kita akan melakukan pelatihan

total_loss = 0
for epoch in range(1,10000):
    for batch in loader_train:
        inputs,targets = batch
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs,targets)
        loss.backward()
        optimizer.step()
    total_loss = total_loss+loss.item()
    current_loss = total_loss/epoch
    if epoch%100==0:
        print("epoch: "+str(epoch)," loss: "+str(current_loss))

setelah proses pelatihan selesai.

epoch: 8700  loss: 0.022024127172432566
epoch: 8800  loss: 0.021773872919863983
epoch: 8900  loss: 0.02152923556856934
epoch: 9000  loss: 0.021290033545729756
epoch: 9100  loss: 0.021056085617573234
epoch: 9200  loss: 0.020827222006209022
epoch: 9300  loss: 0.020603278569141372
epoch: 9400  loss: 0.020384098717043258
epoch: 9500  loss: 0.020169531897703808
epoch: 9600  loss: 0.01995943424114384
epoch: 9700  loss: 0.019753668260410143
epoch: 9800  loss: 0.01955210142837839
epoch: 9900  loss: 0.019354606656843777

Lakukan evaluasi dengan cara berikut

model.eval()
prediksi = model(X)
prediksi = torch.argmax(prediksi,dim=1)
jumlah_benar = (y==prediksi).sum().item()
print("akurasi: "+str((jumlah_benar/len(prediksi))*100)+" %")

hasilnya

akurasi: 100.0 %

MLP dengan TensorFlow

Untuk MLP dengan tensorflow malahan lebih simple saja, nggak ribet. Tapi agak sedikit perbedaan yang mencolok mengenai loss functionya. Untuk tensorflow menggunakan categorical_crossentropy sehingga butuh one hot encoding. Baca Yuk Belajar membuat desain neural network dengan Tensorflow serta fungsi aktifasi berupa soft_max diakhir layer nya.

See also  Install Torch di Mac M1

Seperti biasa kita loading dataset nya

from sklearn import datasets
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
import tensorflow as tf
from tensorflow import keras

iris = datasets.load_iris()
X = iris.data
y = iris.target

Membuat skala 0 sampai 1 alias normalisasi

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

Membuat target menjadi one hot encoding

lbl_clf = LabelEncoder()
y_encoded = lbl_clf.fit_transform(y)
y_final = tf.keras.utils.to_categorical(y_encoded)

Misalkan target

  • 0 menjadi [1,0,0]
  • 1 menjadi [0,1,0], dan
  • 2 menjadi [0,0,1]

Membuat model berupa sequential, perhatikan fungsi Linear pada Pytorch merupakan padanan dari Dense. Hal menarik disini yaitu Dense tidak memerlukan informasi in_features cukup out_features sehingga lebih simple tidak dipusingkan lagi dengan layer layer sebelumnya. Kalau di Pytorch kita harus tahu berapa ciri feature pada layer sebelumnya.

model = keras.models.Sequential([
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(64, activation='relu'),
    keras.layers.Dense(3, activation='softmax')
])

setting fungsi pelatihan dan loss function nya

model.compile(loss = 'categorical_crossentropy',
             optimizer = 'adam',
             metrics=['accuracy'])

Lakukan pelatihan hanya dengan memanggil function fit() saja! Berbeda dengan Pytorch  yang masih menggunakan Looping dan operasi backward didalamnya.

history = model.fit(X_scaled, y_final, epochs=5000,batch_size=32,shuffle=True, steps_per_epoch=500)

hasilnya

Epoch 48/5000
500/500 [==============================] - 0s 920us/step - loss: 8.2652e-10 - accuracy: 1.0000
Epoch 49/5000
500/500 [==============================] - 0s 919us/step - loss: 7.7883e-10 - accuracy: 1.0000
Epoch 50/5000
500/500 [==============================] - 0s 920us/step - loss: 4.3710e-10 - accuracy: 1.0000
Epoch 51/5000

Untuk mendapatkan nilai loss tiap epoch, bisa gunakan history.history[‘loss’]

lakukan evaluasi pada tensorflow

prediksi = np.argmax(model.predict(X_scaled),axis=1)
jumlah_benar = (y==prediksi).sum()
print("akurasi: "+str((jumlah_benar/len(prediksi))*100)+" %")

Kesimpulan

  1. Untuk Pytorch banyak dilengkapi dengan class yang bisa kita gunakan seperti persiapan dataset, membuat model, serta proses pelatihannya menggunakan looping diatur secara manual
  2. Untuk tensorflow sudah sangat simple sekali dan mudah digunakan hal ini dikarenakana adanya library Keras yang memudahkan implementasi tensorflow. Bila tidak menggunakan Keras akan sangat ruwet lebih susah daripada PyTorch

Kalau penulis saat ini lebih suka menggunakan pytorch karena lebih tertata dengan baik apalagi class Dataset yang didalamnya bisa kita lakukan beragam pre processing seperti agumentation bila kita pakai data gambar dan banyak lainnya.

See also  Akhirnya Torch versi R telah tersedia - Framework Machine Learning

Leave a Reply