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
- membuat scaler yaitu memastikan input mempunyai rentang 0 sampai 1
- membuat dataset yang berfungsi sebagai persiapan dataset dan loader nya termasuk pengaturan jumlah batch dan mekanisme yang lain
- membuat model yang berisi fungsi-fungsi Linear dan operasi aktifasi
- 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!
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.
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
- Untuk Pytorch banyak dilengkapi dengan class yang bisa kita gunakan seperti persiapan dataset, membuat model, serta proses pelatihannya menggunakan looping diatur secara manual
- 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.