<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>pytorch Archives - Structilmy</title>
	<atom:link href="https://structilmy.com/blog/tag/pytorch/feed/" rel="self" type="application/rss+xml" />
	<link>https://structilmy.com/tag/pytorch/</link>
	<description>Tutorial, Catatan, Dokumentasi</description>
	<lastBuildDate>Wed, 18 Jan 2023 19:30:36 +0000</lastBuildDate>
	<language>en-US</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=7.1.4</generator>

<image>
	<url>https://i0.wp.com/structilmy.com/wp-content/uploads/2019/01/cropped-favs.png?fit=32%2C32&#038;ssl=1</url>
	<title>pytorch Archives - Structilmy</title>
	<link>https://structilmy.com/tag/pytorch/</link>
	<width>32</width>
	<height>32</height>
</image> 
<site xmlns="com-wordpress:feed-additions:1">165056026</site>	<item>
		<title>Belajar Ragam Strategi Deep Learning dengan CIFAR10 Dataset</title>
		<link>https://structilmy.com/blog/2023/01/19/belajar-ragam-strategi-deep-learning-dengan-cifar10-dataset/</link>
					<comments>https://structilmy.com/blog/2023/01/19/belajar-ragam-strategi-deep-learning-dengan-cifar10-dataset/#comments</comments>
		
		<dc:creator><![CDATA[Rian Adam]]></dc:creator>
		<pubDate>Wed, 18 Jan 2023 23:28:00 +0000</pubDate>
				<category><![CDATA[Computer Vision]]></category>
		<category><![CDATA[Deep Learning]]></category>
		<category><![CDATA[Tutorial]]></category>
		<category><![CDATA[pytorch]]></category>
		<guid isPermaLink="false">https://structilmy.com/?p=3944</guid>

					<description><![CDATA[Semester lalu di salah satu tugas kuliah Computer Vision, kita diminta untuk membuat model CNN dengan dataset CIFAR10. Awalnya ngira ini kayak MNIST dataset yang satset train nggak sampai 10 epoch dapet akurasi >90%. Ternyata dataset ini lebih kompleks. Menariknya, dari satu tugas sederhana ini, Pak Dosen mengenalkan para mahasiswa tentang beragam strategi di deep [&#8230;]]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">Semester lalu di salah satu tugas kuliah Computer Vision, kita diminta untuk membuat model CNN dengan dataset CIFAR10. Awalnya ngira ini kayak MNIST dataset yang <em>satset </em>train nggak sampai 10 epoch dapet akurasi >90%. Ternyata dataset ini lebih kompleks. Menariknya, dari satu tugas sederhana ini, Pak Dosen mengenalkan para mahasiswa tentang beragam strategi di deep learning.</p>



<p class="wp-block-paragraph">Di tutorial ini kita akan coba membuat model machine learning untuk dataset CIFAR10. Kita akan buat modelnya dari <em>scratch </em>menggunakan PyTorch dan tidak menggunakan pre-trained model agar kita bisa lebih dalam memahami apa yang terjadi. Kita juga akan menarget (sebagai tantangan) untuk mendapatkan akurasi >85% dalam 40 epoch.</p>



<p class="wp-block-paragraph"><strong>Source code tutorial ini tersedia</strong> dalam <a href="https://colab.research.google.com/drive/1zTeZMv5760tZPAthpXGjsha72g_fzUTx?usp=sharing">bentuk Google Colab di sini</a> (akan terus dilengkapi komentar dan catatan pada notebook tersebut)</p>



<p class="wp-block-paragraph"><strong>Catatan</strong>: Artikel ini <strong>tidak </strong>membahas dasar-dasar deep learning menggunakan PyTorch. Bagi yang ingin tahu dasar deep learning atau dasar PyTorch bisa mengunjungi artikel terkait di blog ini:</p>



<ul class="wp-block-list">
<li><a href="https://structilmy.com/blog/2019/09/02/sekilas-tentang-jaringan-saraf-tiruan-dan-deep-learning/" target="_blank" rel="noreferrer noopener">Jaringan Saraf Tiruan dan Deep Learning</a></li>



<li><a href="https://structilmy.com/blog/2019/07/11/tutorial-dasar-pytorch-tensor-dan-autograd/">Tutorial dasar Pytorch</a></li>



<li><a href="https://structilmy.com/blog/2020/02/04/implementasi-jaringan-saraf-tiruan-menggunakan-pytorch/" target="_blank" rel="noreferrer noopener">Jaringan Saraf Tiruan menggunakan Pytorch</a></li>



<li><a href="https://structilmy.com/blog/2019/07/17/convolutional-neural-network-cnn-menggunakan-pytorch/">CNN menggunakan Pytorch</a></li>
</ul>



<h2 class="wp-block-heading">CIFAR10 Dataset</h2>



<p class="wp-block-paragraph"><a href="https://www.cs.toronto.edu/~kriz/cifar.html" rel="nofollow">Dataset CIFAR10</a> adalah dataset citra berukuran 32&#215;32 pixel berwarna. Sesuai namanya, CIFAR10 terdiri dari 10 kelas (kucing, burung, &#8230;, kapal). Jelas dataset ini berbeda dari MNIST yang hanya hitam putih. Selain itu jika dilihat di paper-paper, rata-rata akurasi yang diperoleh untuk CIFAR10 adalah sekitar 92% (dibanding MNIST yang bisa sampai &gt;98%). Meskipun begitu, dataset ini masih tergolong mudah dan cocok untuk buat latihan klasifikasi citra. Dataset CIFAR10 bisa didownload langsung menggunakan perintah dari PyTorch.</p>



<figure class="wp-block-embed is-type-rich is-provider-twitter wp-block-embed-twitter"><div class="wp-block-embed__wrapper">
<blockquote class="twitter-tweet" data-width="550" data-dnt="true"><p lang="en" dir="ltr">The &quot;Hello World&quot;s of machine learning:<br><br>2015: RandomForestClassifier on Iris<br>2017: MLP on MNIST<br>2019: AlexNet on Cifar-10<br>2022: DistilBERT on IMDb movie reviews</p>&mdash; Sebastian Raschka (@rasbt) <a href="https://twitter.com/rasbt/status/1607465797240201223?ref_src=twsrc%5Etfw">December 26, 2022</a></blockquote><script async src="https://platform.twitter.com/widgets.js" charset="utf-8"></script>
</div><figcaption class="wp-element-caption">Sebastian Raschka, machine learning researcher yang bukunya cukup populer, juga berpendapat CIFAR10 termasuk salah satu dataset yang cocok untuk latihan.</figcaption></figure>



<span id="more-3944"></span>



<h2 class="wp-block-heading">1. Arsitektur Dasar</h2>



<p class="wp-block-paragraph">Untuk arsitektur dasar, kita akan membuat CNN sederhana yang terdiri dari 3 layer konvolusi dan 2 fully connected layer. Tapi sebelumnya, langkah pertama kita adalah download dan normalisasi dataset terlebih dahulu.</p>



<h3 class="wp-block-heading">Data Preparation</h3>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group=""># dataset transform functions
train_transform = transforms.Compose(
    [transforms.ToTensor(), # convert image to tensor
     transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))]) # normalization
    
test_transform = transforms.Compose(
    [transforms.ToTensor(), # convert image to tensor
     transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))]) # normalization

# download dataset
train_set = datasets.CIFAR10("cifar10", train=True, download=True, transform=train_transform)
test_set = datasets.CIFAR10("cifar10", train=False, download=True, transform=test_transform)

# create pytorch data loader
# we set 256 images for a single batch
train_loader = torch.utils.data.DataLoader(train_set, batch_size=256, shuffle=True) 
test_loader = torch.utils.data.DataLoader(test_set, batch_size=256, shuffle=True)  </pre>



<p class="wp-block-paragraph">Karena dataset ini berukuran tidak terlalu besar, kita akan menggunakan batch size yang cukup besar, yakni 256 gambar, dalam sekali training, harapannya model bisa lebih cepet optimal. Kita juga normalisasi data CIFAR10 menggunakan <a href="https://github.com/kuangliu/pytorch-cifar/issues/19" target="_blank" rel="noreferrer noopener nofollow">rekomendasi yang ada di sini.</a></p>



<h3 class="wp-block-heading">Arsitektur</h3>



<p class="wp-block-paragraph">Arsitektur dasar yang kita buat kira-kira seperti ini jika dituliskan dalam kode Pytorch:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 128, kernel_size=3, stride=1, padding=1) 
        self.conv2 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)
        self.conv3 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1) 
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.do = nn.Dropout() # dropout layer
        self.fc1 = nn.Linear(4096, 1024) 
        self.fco = nn.Linear(1024, 10)  
    
    def forward(self, x): # forward propagation
        batch_size = x.shape[0]
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = self.pool(torch.relu(self.conv3(x)))
        x = x.reshape(batch_size, -1)       
        x = self.do(torch.relu(self.fc1(x))) # dropout layer
        x = self.fco(x) 
        return x</pre>



<p class="wp-block-paragraph">Atau seperti ini jika <a href="http://alexlenail.me/NN-SVG/AlexNet.html">divisualisasikan</a>:</p>


<div class="wp-block-image">
<figure class="aligncenter size-large is-resized"><img data-recalc-dims="1" fetchpriority="high" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/image-3.png?resize=552%2C173&#038;ssl=1" alt="" class="wp-image-3972" width="552" height="173" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/image-3.png?resize=1024%2C323&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/image-3.png?resize=300%2C95&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/image-3.png?resize=768%2C242&amp;ssl=1 768w, https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/image-3.png?w=1182&amp;ssl=1 1182w" sizes="(max-width: 552px) 100vw, 552px" /></figure>
</div>


<p class="wp-block-paragraph">Jika diperhatikan, ada beberapa catatan pada arsitektur tersebut:</p>



<ol class="wp-block-list">
<li><strong>Jumlah feature map yang kita gunakan cukup besar</strong>, yakni 128 pada konvolusi pertama dan 256 pada konvolusi kedua dan ketiga. Hal ini mengingat CIFAR10 dataset yang lebih kompleks dibanding MNIST dan kita menarget untuk mendapat akurasi &gt;85% dalam waktu singkat, karenanya walau arsitektur dasar, tapi akan kita buat cukup besar.</li>



<li><strong>Terdapat layer dropout</strong> pada salah satu fully-connected layer, hal ini bertujuan untuk mengurangi overfitting model deep learning.</li>
</ol>



<h3 class="wp-block-heading">Optimizer</h3>



<p class="wp-block-paragraph">Selanjutnya kita train model tersebut selama 40 epoch menggunakan Stochastic Gradient Descent (SGD) dengan learning rate 0.01, lalu kita tambahkan momentum 0.9, weight decay 0.0005 dan juga menggunakan learning rate scheduler, Cosine Annealing. Apa maksud setiap pengaturan itu? kita bahas satu-satu</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">epoch = 40 
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=0.0005) 
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epoch)</pre>



<h5 class="wp-block-heading">Momentum</h5>



<p class="wp-block-paragraph">Penggunaan momentum pada SGD seperti memberi &#8220;dorongan&#8221; agar model optimal lebih cepat. <a href="https://pytorch.org/docs/stable/generated/torch.optim.SGD.html" target="_blank" rel="noreferrer noopener nofollow">Pada Pytorch</a>, rumus SGD akan berubah menjadi seperti ini jika menggunakan momentum:</p>



<p class="wp-block-paragraph">$$ \theta_t = \theta_{t-1} &#8211; \alpha (\mu g_{t-1} + g_t) $$</p>



<p class="wp-block-paragraph">$\theta$ adalah parameter (bobot / bias model), $\alpha$ adalah learning rate, $g_t$ adalah nilai turunan eror terhadap parameter, dan $\mu$ adalah nilai momentum. Bayangkan kita sedang menuruni gunung, ketika kemiringan tanahnya curam, maka kita akan turun lebih cepat dibanding di tanah landai, kan? Dengan memperhatikan nilai turunan eror pada iterasi sebelumnya ($g_{t-1}$), optimizer akan memperhatikan kecuraman eror yang bisa mengantarkan kita ke titik optimal lebih cepat.</p>



<h5 class="wp-block-heading">Weight decay</h5>



<p class="wp-block-paragraph">Weight decay bermanfaat sebagai pencegah overfitting. Weight decay menambahkan syarat, selain meminimalkan eror, optimizer juga harus meminimalkan nilai parameter modelnya (nilai bobot/biasnya, $\theta$). Rumus SGD akan menjadi seperti ini, dengan $\lambda$ adalah nilai parameter weight decay:</p>



<p class="wp-block-paragraph">$$ \theta_t = \theta_{t-1} &#8211; \alpha (\mu g_{t-1} + g_t + \lambda \theta_{t-1}) $$</p>



<p class="wp-block-paragraph">Dengan memiliki nilai bobot yang kecil, harapannya model akan menjadi tidak terlalu kompleks.</p>



<h5 class="wp-block-heading">Learning rate scheduler</h5>



<p class="wp-block-paragraph">LR scheduler berfungsi untuk mengubah-ubah nilai learning rate pada saat proses training. Pada tutorial ini kita menggunakan metode Cosine Annealing yang membuat proses pengubahan learning rate layaknya fungsi cosine (bisa naik-turun). Pada kode di atas, untuk menginisiasi scheduler kita perlu menambahkan dua parameter, yakni optimizer mana yang akan diupdate learning ratenya, dan juga T_max, yakni seberapa lama learning rate akan naik/turun sebelum dia akhirnya berubah arahnya (Dari turun jadi naik, dan sebaliknya). Tutorial ini menggunakan T_max=epoch, yakni 40, sehingga learning rate akan terus turun hingga akhir pelatihan. <a href="https://www.kaggle.com/code/isbhargav/guide-to-pytorch-learning-rate-scheduling#6.-CosineAnnealingLR" target="_blank" rel="noreferrer noopener nofollow">Kalian bisa cek bacaan menarik tentang LR Scheduler di sini</a>. </p>


<div class="wp-block-image">
<figure class="aligncenter size-full is-resized"><img data-recalc-dims="1" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/image.png?resize=326%2C238&#038;ssl=1" alt="" class="wp-image-3960" width="326" height="238" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/image.png?w=565&amp;ssl=1 565w, https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/image.png?resize=300%2C219&amp;ssl=1 300w" sizes="(max-width: 326px) 100vw, 326px" /><figcaption class="wp-element-caption">Perubahan learning rate dari epoch ke 0 hingga 40. Dari nilai awal 0.01 menjadi 0.</figcaption></figure>
</div>


<h3 class="wp-block-heading">Hasil = 80.89%</h3>



<p class="wp-block-paragraph">Setelah kita train selama 40 epoch (source code training standard bisa cek di colab), akurasi 80.89% saya peroleh untuk model basic ini untuk data test. Not bad!</p>



<h2 class="wp-block-heading">2. Batch Normalization</h2>



<p class="wp-block-paragraph">Optimasi yang pertama akan kita lakukan adalah kita akan menambahkan batch normalization pada model. Apa itu batch normalization?</p>



<p class="wp-block-paragraph">Kita mungkin tahu normalization (normalisasi) adalah teknik untuk mengubah nilai atau skala pada data tanpa menghilangkan informasi antardatanya. Normalisasi biasanya kita lakukan di awal, sebelum data masuk ke model machine learning dengan tujuan memudahkan model untuk menemukan pola pada data. Nah, Batch normalization itu konsepnya sama seperti normalisasi biasanya hanya saja kita lakukan pada tengah-tengah layer. Detail penjelasannya bisa agak panjang, <a href="https://towardsdatascience.com/batch-norm-explained-visually-how-it-works-and-why-neural-networks-need-it-b18919692739" target="_blank" rel="noreferrer noopener nofollow">blog menarik untuk dibaca tentang batch norm ada di sini</a>.</p>



<h3 class="wp-block-heading">Penambahan</h3>



<p class="wp-block-paragraph">Penambahan terdapat pada arsitektur model sehingga tertulis seperti di bawah ini. Karena kita menggunakan CNN, kita gunakan BatchNorm2D yang akan menormalisasi pada setiap channel/feature map. Karenanya, untuk setiap inisiasi kita tambahkan parameter jumlah feature map yang diterima batch norm.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 128, kernel_size=3, stride=1, padding=1) 
        self.conv2 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)
        self.conv3 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2) 
        self.do = nn.Dropout() 

        self.conv1_bn = nn.BatchNorm2d(128) # initiating batch norm
        self.conv2_bn = nn.BatchNorm2d(256) # initiating batch norm
        self.conv3_bn = nn.BatchNorm2d(256) # initiating batch norm
        
        self.fc1 = nn.Linear(4096, 1024) 
        self.fco = nn.Linear(1024, 10) 
    
    def forward(self, x): 
        batch_size = x.shape[0]
        x = self.pool(torch.relu(self.conv1_bn(self.conv1(x)))) # batch norm
        x = self.pool(torch.relu(self.conv2_bn(self.conv2(x)))) # batch norm
        x = self.pool(torch.relu(self.conv3_bn(self.conv3(x)))) # batch norm
        x = x.reshape(batch_size, -1)        
        x = self.do(torch.relu(self.fc1(x))) 
        x = self.fco(x) 
        return x</pre>



<p class="wp-block-paragraph">Sama seperti normalisasi yang dilakukan di awal, biasanya kita mengubah rentang nilai data sehingga memiliki rata-rata 0 dan standar deviasi 1. Pada batch norm, setial layer batch norm akan menormalisasi sehingga memiliki rata-rata dan standar deviasi tertentu. Nilai ini ditentukan selama proses training. Karenanya perlu diingat:</p>



<ol class="wp-block-list">
<li>Batch norm tiap layer harus diinisasi sendiri-sendiri</li>



<li>Pastikan gunakan mode <code data-enlighter-language="generic" class="EnlighterJSRAW">.train()</code> dan <code data-enlighter-language="generic" class="EnlighterJSRAW">.eval()</code> agar batch norm tahu kita sedang training atau testing. (cek kode)</li>
</ol>



<h3 class="wp-block-heading">Hasil = 83.63%</h3>



<p class="wp-block-paragraph">Naik 3%! yey!</p>



<h2 class="wp-block-heading">3. Residual Connection</h2>



<p class="wp-block-paragraph">Salah satu pengubahan arsitektur yang cukup sederhana adalah dengan menambahkan residual connection. Residual connection ini diusulkan dan menjadi dasar dari model yang cukup populer yakni ResNet. Idenya dengan &#8220;menghubungkan&#8221; output suatu layer dengan output dari beberapa layer sebelumnya. Proses &#8220;menghubungkan&#8221; ini biasanya dilakukan hanya dengan menggunakan penjumlahan kedua tensor. </p>


<div class="wp-block-image">
<figure class="aligncenter size-large is-resized"><a href="https://paperswithcode.com/method/residual-connection" target="_blank" rel="noreferrer noopener"><img data-recalc-dims="1" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/image-1.png?resize=354%2C195&#038;ssl=1" alt="" class="wp-image-3969" width="354" height="195" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/image-1.png?resize=1024%2C568&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/image-1.png?resize=768%2C426&amp;ssl=1 768w, https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/image-1.png?zoom=2&amp;resize=354%2C195&amp;ssl=1 708w" sizes="(max-width: 354px) 100vw, 354px" /></a><figcaption class="wp-element-caption">Ilustrasi residual connection (credits to <a href="https://paperswithcode.com/method/residual-connection" target="_blank" rel="noreferrer noopener nofollow">pwc</a>)</figcaption></figure>
</div>


<p class="wp-block-paragraph">Tujuan dari residual connection adalah untuk memudahkan ketika proses update model / backpropagatoin. Gradient yang dihitung saat backpropagation akan bisa melewati atau menskip beberapa layer. Sehingga bisa terhindar dari vanishing atau exploding gradient.</p>



<h3 class="wp-block-heading">Penambahan</h3>



<p class="wp-block-paragraph">penambahan terdapat pada arsitektur model sehingga tertulis seperti ini:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 128, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)
        self.conv3 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2) 
        self.do = nn.Dropout() 

        self.conv1_bn = nn.BatchNorm2d(128) 
        self.conv2_bn = nn.BatchNorm2d(256) 
        self.conv3_bn = nn.BatchNorm2d(256) 
        
        self.fc1 = nn.Linear(4096, 1024) 
        self.fco = nn.Linear(1024, 10)  
    
    def forward(self, x):
        batch_size = x.shape[0]
        x = self.pool(torch.relu(self.conv1_bn(self.conv1(x)))) 
        x = self.pool(torch.relu(self.conv2_bn(self.conv2(x))))
        x = self.pool(x + torch.relu(self.conv3_bn(self.conv3(x)))) # residual connection
        x = x.reshape(batch_size, -1)        
        x = self.do(torch.relu(self.fc1(x)))
        x = self.fco(x)
        return x</pre>



<p class="wp-block-paragraph">residual connection hanya bisa dilakukan (setidaknya dengan mudah) pada layer yang memiliki output ukluran yang sama. Sehingga kita hanya gunakan pada satu layer, yakni pada proses konvolusi pada layer <code data-enlighter-language="generic" class="EnlighterJSRAW">conv3</code> dengan menambahkan input sebelum proses konvolusi sebagai residual.</p>



<h3 class="wp-block-heading">Hasil = 83.38%</h3>



<p class="wp-block-paragraph">Hmm, kok turun sedikit? bisa jadi memang tidak ngefek? tapi kalau kita cek akurasi pada data train, akurasi data train menurut agak banyak jadi sekitar 97% (sebelumnya 99%), kalau ini berarti model kita jadi &#8220;sedikit&#8221; tidak overfitting sepertinya ini pertanda bagus, kita lanjutkan dulu.</p>



<h2 class="wp-block-heading">4. Data Augmentation</h2>



<p class="wp-block-paragraph">Data augmentation adalah trik yang digunakan dengan cara membuat data latih yang lebih variatif. Kita akan memodifikasi data latih CIFAR10 dan harapannya bisa membuat model lebih memahami pola pada gambar. Metode ini sering digunakan khususnya ketika dataset yang kita miliki jumlahnya sedikit atau kurang variatif.</p>



<h3 class="wp-block-heading">Penambahan</h3>



<p class="wp-block-paragraph">penambahan terdapat pada proses transormasi data sehingga tertulis seperti ini:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">train_transform = transforms.Compose(
    [transforms.RandomCrop(32, padding=4), # data augmentation
     transforms.RandomHorizontalFlip(),    # data augmentation
     transforms.ToTensor(),
     transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))]) # normalization</pre>



<p class="wp-block-paragraph">Kita hanya menambahkan augmentasi pada saat train, jadi yang kita ubah hanya <code data-enlighter-language="generic" class="EnlighterJSRAW">train_transform</code>. Pada kode di atas kita menambahkan dua metode augmentasi. Yang pertama, adalah random crop dengan padding, ini seperti kita tambahkan bingkai 4 pixel mengelilingi gambar lalu secara acak kita akan buat kotak berukuran 32&#215;32 untuk dicrop. Hasilnya nanti gambar akan seakan tergeser (cek ilustrasi di bawah). Metode augmentasi yang kedua adalah secara acak beberapa gambar akan di flip horizontal.</p>


<div class="wp-block-image">
<figure class="aligncenter size-full is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/g426-3.png?resize=310%2C76&#038;ssl=1" alt="CIFAR10 random crop" class="wp-image-3965" width="310" height="76" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/g426-3.png?w=513&amp;ssl=1 513w, https://i0.wp.com/structilmy.com/wp-content/uploads/2023/01/g426-3.png?resize=300%2C74&amp;ssl=1 300w" sizes="auto, (max-width: 310px) 100vw, 310px" /><figcaption class="wp-element-caption">di-<em>padding </em>(biru) lalu di random crop</figcaption></figure>
</div>


<h3 class="wp-block-heading">Hasil = 83.8%</h3>



<p class="wp-block-paragraph">Akurasinya sudah agak naik sedikit, dan akurasi data train turun banyak jadi sekitar 82% ini berarti model kita jadi &#8220;lebih&#8221; tidak overfitting lagi. Ini pertanda bagus <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" /></p>



<h2 class="wp-block-heading">5. Tambah Layer</h2>



<p class="wp-block-paragraph">Terakhir, kita akan coba menambah kedalaman model kita dengan menambah satu layer konvolusi. FYI, model-model besar seperti ResNet, AlexNet, dkk yang paling sederhana biasanya terdiri dari &gt;10 layer (bahkan hingga ratusan layer). Sejauh ini, model kita cuma terdiri dari 5 layer (atau 8 jika menghitung layer pooling), jadi tidak ada salahnya kita coba.</p>



<h3 class="wp-block-heading">Penambahan</h3>



<p class="wp-block-paragraph">Penambahan terdapat pada arsitektur model, sehingga berakhir tertulis seperti di bawah ini. Karena penambahan layer tersebut, kita bisa menambah proses residual connection juga.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 128, kernel_size=3, stride=1, padding=1) 
        self.conv2 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1) 
        self.conv3 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
        self.conv4 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1) # added layer
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2) 
        self.do = nn.Dropout() 

        self.conv1_bn = nn.BatchNorm2d(128) 
        self.conv2_bn = nn.BatchNorm2d(256) 
        self.conv3_bn = nn.BatchNorm2d(256) 
        self.conv4_bn = nn.BatchNorm2d(256) 
        
        self.fc1 = nn.Linear(1024, 1024)
        self.fco = nn.Linear(1024, 10) 
    
    def forward(self, x): 
        batch_size = x.shape[0]
        x = self.pool(torch.relu(self.conv1_bn(self.conv1(x)))) 
        x = self.pool(torch.relu(self.conv2_bn(self.conv2(x))))
        x = self.pool(x + torch.relu(self.conv3_bn(self.conv3(x)))) 
        x = self.pool(x + torch.relu(self.conv4_bn(self.conv4(x)))) # new residual connection
        x = x.reshape(batch_size, -1)        
        x = self.do(torch.relu(self.fc1(x))) 
        x = self.fco(x)
        return x</pre>



<h3 class="wp-block-heading">Hasil = 86.48%</h3>



<p class="wp-block-paragraph"><strong>Yeah, mission complete!</strong></p>



<h2 class="wp-block-heading">Rangkuman Hasil Akhir</h2>



<p class="wp-block-paragraph">Dari menggabungkan percobaan-percobaan di atas, kita berhasil memperoleh akurasi &gt;85% dengan kurang dari 40 epoch di CIFAR10. Ini hasil yang cukup bagus dan kita jadi bisa belajar banyak beragam strategi dalam meningkatkan akurasi deep learning pada dataset CIFAR10.</p>



<p class="wp-block-paragraph">By the way, menggunakan bentuk terakhir, jika kita tambahkan waktu train hingga 200 epoch, kita bisa mencapai akurasi pada CIFAR10 hingga &gt;90% loh! Tantangan lain yang kita juga bisa coba adalah menggunakan dataset yang mirip tapi agak lebih besar, yakni CIFAR100. Selamat mencoba!</p>



<p class="wp-block-paragraph"><strong>Source code tutorial ini tersedia</strong> dalam <a href="https://colab.research.google.com/drive/1zTeZMv5760tZPAthpXGjsha72g_fzUTx?usp=sharing">bentuk Google Colab di sini</a> (akan terus dilengkapi komentar dan catatan pada notebook tersebut)</p>
]]></content:encoded>
					
					<wfw:commentRss>https://structilmy.com/blog/2023/01/19/belajar-ragam-strategi-deep-learning-dengan-cifar10-dataset/feed/</wfw:commentRss>
			<slash:comments>2</slash:comments>
		
		
		<post-id xmlns="com-wordpress:feed-additions:1">3944</post-id>	</item>
		<item>
		<title>Catat Eksperimen Machine Learning dengan Weights and Biases</title>
		<link>https://structilmy.com/blog/2022/01/05/catat-eksperimen-machine-learning-dengan-weights-and-biases/</link>
					<comments>https://structilmy.com/blog/2022/01/05/catat-eksperimen-machine-learning-dengan-weights-and-biases/#respond</comments>
		
		<dc:creator><![CDATA[Rian Adam]]></dc:creator>
		<pubDate>Wed, 05 Jan 2022 01:05:00 +0000</pubDate>
				<category><![CDATA[Artificial Intelligence]]></category>
		<category><![CDATA[Machine Learning]]></category>
		<category><![CDATA[Tutorial]]></category>
		<category><![CDATA[Python]]></category>
		<category><![CDATA[pytorch]]></category>
		<category><![CDATA[Tips and Tricks]]></category>
		<guid isPermaLink="false">https://structilmy.com/?p=2794</guid>

					<description><![CDATA[Setelah banyak eksperimen di bidang machine learning, saya masih merasa mencatat keluaran eksperimen itu bagian yang tidak mudah. Rasanya hampir semua eksperimen machine learning yang saya lakukan, saya catat dengan cara dan gaya yang berubah-ubah. Ada yang saya input manual ke excel, atau log ke csv, atau sekadar di notepad. Belum lagi ketika prosesnya, eksperimen [&#8230;]]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">Setelah banyak eksperimen di bidang machine learning, saya masih merasa mencatat keluaran eksperimen itu bagian yang tidak mudah. Rasanya hampir semua eksperimen machine learning yang saya lakukan, saya catat dengan cara dan gaya yang berubah-ubah. Ada yang saya input manual ke excel, atau log ke csv, atau sekadar di notepad. Belum lagi ketika prosesnya, eksperimen kadang harus berubah, gagal, tidak sesuai harpaan&#8230; (&gt;,&lt;) dan akhirnya bikin mood mencatat rapi itu makin hilang di tengah-tengah.</p>



<p class="wp-block-paragraph">Alhamdulillah akhir 2021 lalu nemu tools menarik untuk mencatat hasil eksperimen dengan rapi dan lengkap dan mudah, yakni dengan <a href="https://wandb.ai/" target="_blank" rel="noreferrer noopener">Weights and Biases</a>. </p>



<figure class="wp-block-image size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/raw.githubusercontent.com/wandb/client/master/.github/wb-logo-lightbg.png?resize=306%2C45&#038;ssl=1" alt="Weights and Biases logo" width="306" height="45"/></figure>



<p class="wp-block-paragraph"><strong>Weights and Biases</strong> (atau kadang ditulis <strong>W&amp;B</strong> atau kadang juga <strong>wandb</strong>) adalah suatu tools yang memudahkan pencatatan eksperimen machine learning. Yang menarik dari weights and biases, sesuai dengan taglinenya &#8220;Log (Almost) Anything&#8221;, dia mampu mencatat hampir semua hal yang terjadi pada saat eksperimen dengan mudah. Beberapa data yang saya ingat bisa dicatat saat setiap run adalah:</p>



<ul class="wp-block-list"><li>Nilai loss atau akurasi atau nilai-nilai lain yang berubah-ubah saat training</li><li>Pemakaian CPU/GPU </li><li>Media-media yang dihasilkan selama eksperimen (audio/citra/video)</li><li>Perubahan bobot dan bias pada model</li><li>Spesifikasi hardware, software, serta versi package python yang terinstall</li><li>Parameter-parameter model, seperti learning rate, batch size, dsb.</li></ul>



<p class="wp-block-paragraph">Semua data itu dicatat secara rapi di server saat setiap kali melakukan &#8220;run&#8221; eksperimen. Jadi ketika kita melakukan beberapa run kita juga bisa membandingkan grafik-grafik data-data tersebut, dan hal ini akan sangat bermanfaat untuk mengukur performa model atau debugging seiring berjalannya waktu.</p>



<div class="wp-block-image"><figure class="aligncenter size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/WB-Chart-1_2_2022-7-50-03-AM.png?resize=505%2C265&#038;ssl=1" alt="" class="wp-image-2808" width="505" height="265" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/WB-Chart-1_2_2022-7-50-03-AM.png?resize=1024%2C538&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/WB-Chart-1_2_2022-7-50-03-AM.png?resize=300%2C158&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/WB-Chart-1_2_2022-7-50-03-AM.png?resize=768%2C403&amp;ssl=1 768w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/WB-Chart-1_2_2022-7-50-03-AM.png?resize=1536%2C807&amp;ssl=1 1536w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/WB-Chart-1_2_2022-7-50-03-AM.png?resize=2048%2C1076&amp;ssl=1 2048w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/WB-Chart-1_2_2022-7-50-03-AM.png?w=2180&amp;ssl=1 2180w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/WB-Chart-1_2_2022-7-50-03-AM.png?w=3270&amp;ssl=1 3270w" sizes="auto, (max-width: 505px) 100vw, 505px" /></figure></div>



<h2 class="wp-block-heading">Weights and Biases Tutorial</h2>



<p class="wp-block-paragraph">Weights and Biases sendiri sebenarnya bisa berjalan hampir di semua framework machine learning seperi Tensorflow, Pytorch, Scikit-learn, dll. Pada tutorial ini kita akan menggunakan kode yang kita gunakan untuk <a href="https://structilmy.com/2019/07/convolutional-neural-network-cnn-menggunakan-pytorch/">klasifikasi citra menggunakan CNN dan Pytorch</a>.</p>



<p class="wp-block-paragraph">Secara umum, ada lima langkah utama untuk melakukan pencatatan menggunakan weights and biases:</p>



<ol class="wp-block-list"><li><code><code data-enlighter-language="r" class="EnlighterJSRAW">wandb.login()</code></code>: Untuk menghubungkan projek kita dengan akun W&amp;B yang kita miliki. <a href="https://docs.wandb.ai/guides/technical-faq#can-i-run-wandb-offline" target="_blank" rel="noreferrer noopener nofollow">Secara <em>default </em>W&amp;B membutuhkan koneksi internet untuk menyimpan hasil eksperimen ke server</a>.</li><li><code><code data-enlighter-language="python" class="EnlighterJSRAW">wandb.init()</code></code>: Digunakan untuk mendefinisikan projek apa yang sedang kita jalankan. Pada bagian ini kita juga mendefinisikan parameter apa yang akan dicatat dalam sebuah config.</li><li><code><code data-enlighter-language="python" class="EnlighterJSRAW">wandb.watch()</code></code>: Digunakan untuk memperhatikan (mencatat) kondisi model dari waktu ke waktu</li><li><code data-enlighter-language="python" class="EnlighterJSRAW">wandb.log()</code>: Digunakan untuk mencatat variabel-variabel lain yang dibutuhkan untuk di catat.</li><li><code><code data-enlighter-language="python" class="EnlighterJSRAW">wandb.finish()</code></code>: Menandai akhir proses pencatatan, jika kita ingin memulai proses pencatatan yang lain.</li></ol>



<p class="wp-block-paragraph">Kode lengkap berupa Notebook disertai penjelasan (Bahasa Inggris) bisa diakses di sini: <strong><a href="https://www.kaggle.com/rianadam/pytorch-image-classification-weights-and-biases">Pytorch Image Classification + Weights and Biases</a></strong>.</p>



<p class="wp-block-paragraph">Pada kode tersebut tampak lima poin di atas bisa dilakukan hanya dalam 5 baris saja (masing-masing perintah satu baris). Menggunakan notebook di atas, saya coba bereksperimen dengan mengubah-ubah nilai learning rate dan banyaknya batch saat training. Hasilnya, tampilan ringkasan pencatatan di dashboard Weights and Biases untuk tutorial di atas seperti berikut:</p>



<div class="wp-block-image"><figure class="aligncenter size-large"><img data-recalc-dims="1" loading="lazy" decoding="async" width="1024" height="318" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image.png?resize=1024%2C318&#038;ssl=1" alt="" class="wp-image-2813" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image.png?resize=1024%2C318&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image.png?resize=300%2C93&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image.png?resize=768%2C238&amp;ssl=1 768w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image.png?resize=1536%2C477&amp;ssl=1 1536w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image.png?w=1884&amp;ssl=1 1884w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /><figcaption><sub>Saya melakukan empat kali run. dengan mengubah-ubah parameter learning rate dan batch size</sub></figcaption></figure></div>



<p class="wp-block-paragraph">Nama-nama seperti &#8220;autumn-cloud-5&#8221; dan sebagainya, adalah nama yang secara otomatis diberikan W&amp;B untuk membedakan setiap run eksperimen yang kita lakukan. Kita bisa mengubah-ubahnya semau kita jika itu dirasa memudahkan. Untuk detail setiap run bisa dilihat dengan klik setiap namanya, atau mengubah tampilan dalam bentuk tabel seperti di bawah ini:</p>



<div class="wp-block-image"><figure class="aligncenter size-large"><img data-recalc-dims="1" loading="lazy" decoding="async" width="1024" height="252" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image-1.png?resize=1024%2C252&#038;ssl=1" alt="" class="wp-image-2814" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image-1.png?resize=1024%2C252&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image-1.png?resize=300%2C74&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image-1.png?resize=768%2C189&amp;ssl=1 768w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image-1.png?resize=1536%2C378&amp;ssl=1 1536w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image-1.png?w=1826&amp;ssl=1 1826w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /><figcaption><sub>Tersedia juga catatan dalam bentuk tabel untuk membandingkan pengaturan parameternya</sub></figcaption></figure></div>



<h2 class="wp-block-heading">W&amp;B Sweeps</h2>



<p class="wp-block-paragraph">W&amp;B juga menyediakan fitur untuk melakukan hyperparameter optimization. Dengan fitur ini, secara otomatis weights and biases akan mencari nilai-nilai untuk setiap parameter yang memberikan hasil terbaik untuk kasus kita. Hasil akhirnya, kita bisa melihat hubungan nilai parameter dengan loss yang diperoleh.</p>



<div class="wp-block-image"><figure class="aligncenter size-large"><img data-recalc-dims="1" loading="lazy" decoding="async" width="1024" height="402" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/s_5D8914551A6C0AABCD5718091305DD3B64FFBA192205DD7B3C90EC93F4002090_1579066494222_image-e1641312647435-1024x402.png?resize=1024%2C402&#038;ssl=1" alt="" class="wp-image-2815" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/s_5D8914551A6C0AABCD5718091305DD3B64FFBA192205DD7B3C90EC93F4002090_1579066494222_image-e1641312647435.png?resize=1024%2C402&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/s_5D8914551A6C0AABCD5718091305DD3B64FFBA192205DD7B3C90EC93F4002090_1579066494222_image-e1641312647435.png?resize=300%2C118&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/s_5D8914551A6C0AABCD5718091305DD3B64FFBA192205DD7B3C90EC93F4002090_1579066494222_image-e1641312647435.png?resize=768%2C301&amp;ssl=1 768w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/s_5D8914551A6C0AABCD5718091305DD3B64FFBA192205DD7B3C90EC93F4002090_1579066494222_image-e1641312647435.png?resize=1536%2C603&amp;ssl=1 1536w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/s_5D8914551A6C0AABCD5718091305DD3B64FFBA192205DD7B3C90EC93F4002090_1579066494222_image-e1641312647435.png?resize=2048%2C804&amp;ssl=1 2048w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/s_5D8914551A6C0AABCD5718091305DD3B64FFBA192205DD7B3C90EC93F4002090_1579066494222_image-e1641312647435.png?w=2180&amp;ssl=1 2180w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/s_5D8914551A6C0AABCD5718091305DD3B64FFBA192205DD7B3C90EC93F4002090_1579066494222_image-e1641312647435.png?w=3270&amp;ssl=1 3270w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /><figcaption><sub>Saya ambil dari dokumentasi W&amp;B, tutorial menyusul insyaAllah</sub></figcaption></figure></div>



<h2 class="wp-block-heading">Komunitas Weights and Biases</h2>



<p class="wp-block-paragraph">Yang menarik lagi tentang W&amp;B ini bukan hanya tools yang disediakan namun juga <a href="https://community.wandb.ai/c/community-events/5" target="_blank" rel="noreferrer noopener">komunitasnya</a>. Saya bahkan lebih dulu mengikuti kegiatan-kegiatan di komunitas W&amp;B sebelum saya mencoba toolsnya. W&amp;B secara aktif mengadakan mini workshop, paper dan book reading group, seminar, Q&amp;A session, dan masih banyak lagi, di mana kita bisa belajar banyak hal seputar machine learning secara umum tidak hanya seputar W&amp;B. </p>



<figure class="wp-block-image size-large"><img data-recalc-dims="1" loading="lazy" decoding="async" width="1024" height="507" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image-3.png?resize=1024%2C507&#038;ssl=1" alt="" class="wp-image-2817" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image-3.png?resize=1024%2C507&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image-3.png?resize=300%2C148&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image-3.png?resize=768%2C380&amp;ssl=1 768w, https://i0.wp.com/structilmy.com/wp-content/uploads/2022/01/image-3.png?w=1495&amp;ssl=1 1495w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /></figure>



<p class="wp-block-paragraph">Kalian bisa cek <a href="https://www.youtube.com/c/WeightsBiases">youtube channelnya</a> untuk melihat beberapa rekaman yang tersedia, atau follow <a href="https://twitter.com/weights_biases">akun twitternya</a> untuk bisa update kegiatan-kegiatan terbarunya.</p>



<p class="wp-block-paragraph"><em>Sekian, Semoga bermanfaat!</em></p>
]]></content:encoded>
					
					<wfw:commentRss>https://structilmy.com/blog/2022/01/05/catat-eksperimen-machine-learning-dengan-weights-and-biases/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
		<post-id xmlns="com-wordpress:feed-additions:1">2794</post-id>	</item>
		<item>
		<title>Siamese Network: Neural network untuk menguji kemiripan</title>
		<link>https://structilmy.com/blog/2021/06/29/siamese-network-neural-network-untuk-menguji-kemiripan/</link>
					<comments>https://structilmy.com/blog/2021/06/29/siamese-network-neural-network-untuk-menguji-kemiripan/#respond</comments>
		
		<dc:creator><![CDATA[Rian Adam]]></dc:creator>
		<pubDate>Tue, 29 Jun 2021 02:28:45 +0000</pubDate>
				<category><![CDATA[Artificial Intelligence]]></category>
		<category><![CDATA[Machine Learning]]></category>
		<category><![CDATA[neural network]]></category>
		<category><![CDATA[pytorch]]></category>
		<guid isPermaLink="false">https://structilmy.com/?p=2345</guid>

					<description><![CDATA[Bayangkan kita diminta membuat model machine learning yang akan digunakan untuk presensi mahasiswa menggunakan foto wajah. Universitas yang meminta dibuatkan model tersebut memiliki 10,000 mahasiswa. Jika kita mengasumsikan ini adalah permasalahan klasifikasi, apakah itu berarti ini adalah klasifikasi citra dengan jumlah kelas 10,000? Itu jauh lebih banyak daripada data benchmark yang biasa digunakan klasifikasi citra, [&#8230;]]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">Bayangkan kita diminta membuat model machine learning yang akan  digunakan untuk presensi mahasiswa menggunakan foto wajah. Universitas yang meminta dibuatkan model tersebut memiliki 10,000 mahasiswa. Jika kita mengasumsikan ini adalah permasalahan klasifikasi, apakah itu berarti ini adalah <strong>klasifikasi citra dengan jumlah kelas 10,000?</strong></p>



<div class="wp-block-image"><figure class="aligncenter size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-3.png?resize=438%2C193&#038;ssl=1" alt="" class="wp-image-2379" width="438" height="193" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-3.png?w=831&amp;ssl=1 831w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-3.png?resize=300%2C132&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-3.png?resize=768%2C338&amp;ssl=1 768w" sizes="auto, (max-width: 438px) 100vw, 438px" /><figcaption><sup>Klasifikasi dengan 10,000 class??</sup></figcaption></figure></div>



<p class="wp-block-paragraph">Itu jauh lebih banyak daripada data benchmark yang biasa digunakan klasifikasi citra, <a href="https://www.image-net.org/" target="_blank" rel="noreferrer noopener nofollow">Imagenet</a>, yang hanya 1000 kelas! Selain itu, tidak mudah juga untuk mendapatkan data per kelasnya. Apakah setiap mahasiswa harus difoto ratusan kali agar dapat data latih yang representatif? lalu bagaimana jika ada mahasiswa baru? nah, di sinilah Siamese Network bisa jadi salah satu solusinya.</p>



<h2 class="wp-block-heading">Siamese Network</h2>



<p class="wp-block-paragraph">Siamese network adalah jenis arsitektur neural network di mana <strong>menerima dua input</strong>, yang masing-masingnya masuk ke subnetwork <strong>yang sama</strong> lalu <strong>digabungkan </strong>untuk dihitung kemiripan antara dua input tersebut.</p>



<div class="wp-block-image"><figure class="aligncenter size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image.png?resize=463%2C203&#038;ssl=1" alt="Siamese network" class="wp-image-2351" width="463" height="203" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image.png?resize=1024%2C451&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image.png?resize=300%2C132&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image.png?resize=768%2C338&amp;ssl=1 768w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image.png?w=1094&amp;ssl=1 1094w" sizes="auto, (max-width: 463px) 100vw, 463px" /><figcaption><sup>Siamese Network untuk identifikasi wajah</sup></figcaption></figure></div>



<p class="wp-block-paragraph">Siamese network digunakan untuk menghitung kemiripan dua data. Kemiripan antara dua data di sini tergantung pada kasusnya, misal kemiripan wajah dari orang yang sama namun memiliki dua foto yang berbeda, atau kemiripan gaya berpakaian dari dua orang yang berbeda, dll. Model dilatih dengan menerima input pasangan data, dengan output yang dihasilkan bisa berupa biner (sama atau tidak) atau sebuah real value yang merepresentasikan tingkat tingkat kemiripan.</p>



<p class="wp-block-paragraph">Siamese network <strong>tidak menspesifikkan</strong> arsitektur pada bagian subnetwork, asalkan dua arsitektur yang digunakan adalah sama (bentuk dan bobotnya).  Kita bisa memakai konsep ini untuk beragam jenis data. Misalnya kita ingin mengecek kemiripan pertanyaan maka kita bisa menggunakan subnetwork berupa LSTM network, jika ingin mengecek kemiripan foto kita bisa gunakan CNN sebagai subnetworknya. Output dari subnetwork ini adalah vektor, dengan ukuran bebas (sebagai hyperparameter yang kita tentukan sendiri)</p>



<p class="wp-block-paragraph">Ada banyak metode yang bisa dilakukan di bagian penggabungan (Merge) hasil dari dua subnetwork. Beberapa yang pernah saya tahu:</p>



<ul class="wp-block-list"><li>Hitung selisih absolut antar vektor output subnetwork lalu masukkan vektor selisihnya ke sebuah neural net, </li><li>Concat atau gabungkan kedua output lalu masukkan vektor gabungannya ke sebuah neural net, </li></ul>



<div class="wp-block-image"><figure class="aligncenter size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-4.png?resize=738%2C188&#038;ssl=1" alt="" class="wp-image-2391" width="738" height="188" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-4.png?resize=1024%2C261&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-4.png?resize=300%2C76&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-4.png?resize=768%2C195&amp;ssl=1 768w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-4.png?resize=1536%2C391&amp;ssl=1 1536w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-4.png?w=1863&amp;ssl=1 1863w" sizes="auto, (max-width: 738px) 100vw, 738px" /></figure></div>



<span id="more-2345"></span>



<h2 class="wp-block-heading">Contoh Kasus </h2>



<p class="wp-block-paragraph">Siamese network cocok digunakan jika dataset memiliki banyak sekali class, tapi sampel tiap class sangat sedikit. Misalnya jika kita akan membuat sistem verifikasi wajah untuk presensi.</p>



<p class="wp-block-paragraph">Langkah pertama yang perlu kita lakukan adalah dengan membuat pasangan-pasangan dari data yang kita miliki. Sebagai ilustrasi anggap kita memiliki foto wajah 5 orang {A, B, C, D, E} dan masing-masing orang memiliki 3 foto {A1, A2, A3, B1, B2, &#8230;, E3} maka kita bisa buat pasangan seperti di bawah, dan memberi label &#8220;1&#8221; untuk yang artinya kedua foto menunjukkan orang yang sama, dan &#8220;0&#8221; untuk sebaliknya.</p>



<div class="wp-block-image"><figure class="aligncenter size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-7.png?resize=549%2C206&#038;ssl=1" alt="" class="wp-image-2394" width="549" height="206" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-7.png?resize=1024%2C386&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-7.png?resize=300%2C113&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-7.png?resize=768%2C289&amp;ssl=1 768w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-7.png?w=1197&amp;ssl=1 1197w" sizes="auto, (max-width: 549px) 100vw, 549px" /><figcaption><sup>Setiap sample di dataset terdiri dari dua citra wajah, lalu label bernilai 1 jika itu foto orang yang sama, dan 0 jika sebaliknya</sup></figcaption></figure></div>



<p class="wp-block-paragraph">Setelah itu model dilatih dengan data tersebut. Inputnya adalah sepasang foto dan outputnya akan diukur menggunakan label yang ada. </p>



<div class="wp-block-image"><figure class="aligncenter size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-8.png?resize=614%2C250&#038;ssl=1" alt="" class="wp-image-2395" width="614" height="250" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-8.png?resize=1024%2C417&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-8.png?resize=300%2C122&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-8.png?resize=768%2C313&amp;ssl=1 768w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-8.png?resize=1536%2C626&amp;ssl=1 1536w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/06/image-8.png?w=1650&amp;ssl=1 1650w" sizes="auto, (max-width: 614px) 100vw, 614px" /></figure></div>



<p class="wp-block-paragraph">Setelah model terlatih, proses verifikasi foto ketika presensi bisa dilakukan dengan mencocokkan sampel yang baru ke foto yang ada di database kita. Jika model memberi output True, maka orang tersebut berhasil teridentifikasi.</p>



<h2 class="wp-block-heading">Implementasi di PyTorch</h2>



<p class="wp-block-paragraph">Implementasi arsitektur Siamese Network di <a href="https://structilmy.com/2020/02/implementasi-jaringan-saraf-tiruan-menggunakan-pytorch/">PyTorch </a>tidak terlalu sulit, tergantung seperti apa subnetwork yang digunakan dan cara penggabungan yang dipilih. </p>



<p class="wp-block-paragraph">Di bawah ini adalah contoh implementasi Class SiameseNetwork di PyTorch yang sederhana dengan linear layer biasa. Proses merge dilakukan dengan menghitung selisih absolut, lalu memasukkan ke neural net sederhana yang memberi output biner (True / False).</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">class SiameseNetwork(nn.Module):
    def __init__(self, h, input_size):
        super(SiameseNetwork, self).__init__()
        self.subnet = nn.Linear(input_size, h)
        self.mergenet = nn.Linear(h, 2)
    
    def forward(self, x1, x2):
        output1 = F.relu(self.subnet(x1))
        output2 = F.relu(self.subnet(x2))
        diff = torch.abs(output1 - output2)
        output = self.mergnet(diff)
        return output</pre>



<h2 class="wp-block-heading">Penutup</h2>



<p class="wp-block-paragraph">Sederhananya konsep siamese network di atas bukan berarti model ini adalah model yang &#8220;selalu sederhana&#8221;. Dalam implementasi ada beberapa hal yang kadang perlu ditambahkan untuk memperbaiki hasil Siamese Network. Salah satunya adalah pemakaian <a href="https://stats.stackexchange.com/questions/485124/why-contrastive-loss-for-siamese-network" target="_blank" rel="noreferrer noopener nofollow">Contrastive Loss</a>. Selain itu, di luar sana juga banyak cara berbeda implementasi proses Merge yang bisa dicoba. Artikel ini hanyalah pengantar Siamese Network.</p>



<p class="wp-block-paragraph">Selamat bereksplorasi, semoga bermanfaat!</p>



<hr class="wp-block-separator"/>



<p class="wp-block-paragraph"><sup>Photo by <a href="https://unsplash.com/@skyler_tv?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Skyler Smith</a> on <a href="https://unsplash.com/s/photos/symmetric?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></sup></p>
]]></content:encoded>
					
					<wfw:commentRss>https://structilmy.com/blog/2021/06/29/siamese-network-neural-network-untuk-menguji-kemiripan/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
		<post-id xmlns="com-wordpress:feed-additions:1">2345</post-id>	</item>
		<item>
		<title>Deep Learning dalam 6 Baris dengan Fastai dan Pytorch</title>
		<link>https://structilmy.com/blog/2021/02/17/deep-learning-dalam-6-baris-dengan-fastai-dan-pytorch/</link>
					<comments>https://structilmy.com/blog/2021/02/17/deep-learning-dalam-6-baris-dengan-fastai-dan-pytorch/#respond</comments>
		
		<dc:creator><![CDATA[Rian Adam]]></dc:creator>
		<pubDate>Wed, 17 Feb 2021 12:09:43 +0000</pubDate>
				<category><![CDATA[Deep Learning]]></category>
		<category><![CDATA[Tutorial]]></category>
		<category><![CDATA[convolutional-neural-network]]></category>
		<category><![CDATA[pytorch]]></category>
		<guid isPermaLink="false">https://structilmy.com/?p=2254</guid>

					<description><![CDATA[Sebelumnya maaf semisal judulnya agak &#8220;heboh&#8221; dan terkesan click-bait 😀 tapi di artikel ini beneran saya ingin menunjukkan bahwa deep learning, khususnya image classification dengan CNN sebenarnya dapat dengan mudah dilakukan hanya dengan 6 baris kode berikut menggunakan library Fastai dan Pytorch: Artikel ini berfokus pada pengenalan singkat tentang fastai dan juga penjelasan tentang kode [&#8230;]]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">Sebelumnya maaf semisal judulnya agak &#8220;heboh&#8221; dan terkesan click-bait <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f600.png" alt="😀" class="wp-smiley" style="height: 1em; max-height: 1em;" /> tapi di artikel ini beneran saya ingin menunjukkan bahwa deep learning, khususnya image classification dengan CNN sebenarnya dapat dengan mudah dilakukan hanya dengan 6 baris kode berikut menggunakan library Fastai dan Pytorch:</p>



<figure class="wp-block-image size-large"><img data-recalc-dims="1" loading="lazy" decoding="async" width="1024" height="295" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/carbon-2.png?resize=1024%2C295&#038;ssl=1" alt="" class="wp-image-2276" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/carbon-2.png?resize=1024%2C295&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/carbon-2.png?resize=300%2C86&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/carbon-2.png?resize=768%2C221&amp;ssl=1 768w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/carbon-2.png?resize=1536%2C443&amp;ssl=1 1536w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/carbon-2.png?w=1658&amp;ssl=1 1658w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /><figcaption><sub>dibuat menggunakan <a href="https://carbon.now.sh" target="_blank" rel="noreferrer noopener">https://carbon.now.sh</a>, versi raw ada di bawah</sub></figcaption></figure>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p>Artikel ini berfokus pada pengenalan singkat tentang fastai dan juga penjelasan tentang kode di atas. Tutorial lebih detail dan mendalam tentang fastai insyaAllah akan kami coba buat di artikel lain.</p></blockquote>



<h2 class="wp-block-heading">Berawal dari Pytorch vs Tensorflow</h2>



<p class="wp-block-paragraph">Sebelum kita masuk lebih dalam tentang Fastai, kita akan me-<em>refresh</em> singkat tentang library atau framework di deep learning. Bagi yang belum tahu, ada dua library besar yang saat ini cukup sering digunakan, yakni <a href="http://pytorch.org" target="_blank" rel="noreferrer noopener nofollow">Pytorch </a>dan <a href="http://tensorflow.org" target="_blank" rel="noreferrer noopener">Tensorflow</a>. Pytorch dibuat oleh Facebook sedangkan Tensorflow oleh Google. Keduanya memiliki beragam fitur yang mendukung deep learning, salah satunya<a href="https://structilmy.com/2019/07/tutorial-dasar-pytorch-tensor-dan-autograd/"> Autograd yang pernah saya bahas di artikel ini</a>. Nah, sering kali bagi yang baru belajar deep learning akan bertanya:</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p>P<strong>ilih pakai Pytorch atau Tensorflow?</strong></p></blockquote>



<h5 class="wp-block-heading"><strong>Jawaban salah</strong></h5>



<p class="wp-block-paragraph"><em>Tensorflow itu lebih mudah dipelajari dan digunakan daripada Pytorch</em>. Itu jawaban yang sering saya dengar. Kenapa salah? karena saya yakin kebanyakan orang yang jawab itu dia <strong>bukan sedang membandingkan Tensorflow yang murni</strong>, melainkan library tambahan yang berada di atas Tensorflow, yakni <a href="http://keras.io" target="_blank" rel="noreferrer noopener nofollow">Keras</a>. Tensorflow yang murni bisa dibilang lumayan ribet juga loh untuk dipelajari dan digunakan (apalagi pas masih versi 1.x di tahun 2019)</p>



<p class="wp-block-paragraph">Jadi sekilas sejarah, dulu library deep learning itu memang susah-susah pemakaiannya (<em>low-level</em>). Library generasi awal, Theano, bahkan ngodingnya harus &#8220;jungkir balik&#8221; alur mikirnya. Karenanya, dibutuhkan library lagi di atasnya yang <em>high-level</em> (mudah dipahami dan digunakan) namun tetap terintegrasi dengan library yang <em>low-level</em>, lahirlah salah satunya Keras. Sekarang Keras sudah sangat terintegerasi dengan Tensorflow bahkan tidak perlu di-install terpisah. Tutorial <a href="https://structilmy.com/2021/01/image-classification-dengan-cnn-dan-tensorflow/" target="_blank" rel="noreferrer noopener">Tensorflow-Keras pernah saya tuliskan di sini</a>.</p>



<h5 class="wp-block-heading"><strong>Jawaban benar</strong></h5>



<figure class="wp-block-image size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/image-1.png?resize=525%2C326&#038;ssl=1" alt="" class="wp-image-2266" width="525" height="326" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/image-1.png?w=907&amp;ssl=1 907w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/image-1.png?resize=300%2C186&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/image-1.png?resize=768%2C477&amp;ssl=1 768w" sizes="auto, (max-width: 525px) 100vw, 525px" /><figcaption><sub>dari salah satu developer utama Pytorch</sub></figcaption></figure>



<p class="wp-block-paragraph">Saat ini bisa dibilang Pytorch dan Tensorflow (khususnya versi 2) sangat mirip. Keduanya sama-sama <em>smoothly</em> bisa digunakan untuk hampir kebanyakan kebutuhan riset dan sehari-hari. Jadi apapun librarynya silakan pilih saja, dan yang terpenting, <strong>kuasai dulu sebelum coba library lain</strong>.</p>



<p class="wp-block-paragraph">Kembali ke Jawaban yang salah di atas, ketika kita membandingkan Keras dengan Pytorch maka bisa dibilang kurang <em>apple-to-apple</em>. Karena Keras pada dasarnya adalah <em>high-level</em> library sedangkan Pytorch adalah <em>low-level</em> library, jadi jelas Keras terlihat lebih mudah pemakaiannya. Nah, di artikel ini saya akan jelaskan salah satu <em>high-level </em>library paling populer untuk Pytorch, yakni <a href="http://docs.fast.ai" target="_blank" rel="noreferrer noopener nofollow">Fastai</a>.</p>



<span id="more-2254"></span>



<h2 class="wp-block-heading">Apa itu Fastai</h2>



<p class="wp-block-paragraph"><a href="http://fast.ai" target="_blank" rel="noreferrer noopener">Fast.ai</a> sebenarnya lebih cocok jika dibilang sebagai nama organisasi riset deep learning. Saya pertama kali dengar nama Fast.ai dari course yang mereka <a href="http://course.fast.ai" target="_blank" rel="noreferrer noopener nofollow">sediakan di sini</a> dengan motto khasnya &#8220;<em>Making neural nets uncool again</em>&#8220;. Btw, course deep learning yang mereka sediakan sangat bagus, detail, mendalam, namun tetap mudah diikuti jadi wajib dicoba baik untuk pemula ataupun yang sudah berpengalaman.</p>



<p class="wp-block-paragraph">Nah, selain course, fast.ai juga membuat sebuah <a href="http://docs.fast.ai" target="_blank" rel="noreferrer noopener nofollow">library <code>fastai</code></a> yang dibangun di atas Pytorch. Secara ringkas, library fastai memiliki tujuan yang mirip dengan Keras, yakni menyediakan high-level API untuk pembuatan deep learning di atas library / framework yang telah ada (Pytorch dan Tensorflow). Library ini yang saya gunakan di artikel ini. Seperti yang telah saya tunjukkan di atas, dengan fastai kita bisa mengimplementasikan CNN untuk klasifikasi citra hanya dalam 6 baris kode.</p>



<h2 class="wp-block-heading">Penjelasan Kode</h2>



<p class="wp-block-paragraph">Oke, kita masuk ke kodenya:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">from fastai.vision.all import *
trainloader = ImageDataLoaders.from_folder("train/", valid_pct=0.2, item_tfms=Resize(224))
testloader = trainloader.test_dl(get_image_files("test/"), with_labels=True)
learn = cnn_learner(trainloader, resnet18, metrics=error_rate) 
learn.fine_tune(3) 
print(accuracy(*learn.get_preds(dl=testloader)))</pre>



<p class="wp-block-paragraph">Kode di atas adalah kode yang memang minimalis, menggunakan banyak parameter defaultnya, karena saya hanya menunjukkan betapa simpelnya fastai. Tetapi dengan 6 baris kode tersebut akurasi model yang dihasilkan sangatlah baik.  Bisa jadi ada beberapa pengaturan atau sintaks yang mungkin perlu ditambahkan nantinya. </p>



<p class="wp-block-paragraph">Oke pertama-tama kita akan import library-nya:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">from fastai.vision.all import *</pre>



<p class="wp-block-paragraph">Di fastai, fungsi-fungsi dikelompokkan tergantung domain apa yang akan dikerjakan. Ada 4 domain utama yang disediakan fastai saat ini, yakni vision, text, tabular, dan colaborative filtering (untuk sistem rekomendasi). Karena kita ingin membuat proyek deep learning untuk citra, kita cukup import semua yang ada di <code>vision.all</code>. Walaupun dikelompokkan untuk pada 4 kasus di atas, fastai juga tetap punya fungsi-fungsi umum yang bisa digunakan di beragam kasus.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">trainloader = ImageDataLoaders.from_folder("train/", valid_pct=0.2, item_tfms=Resize(224))
testloader = trainloader.test_dl(get_image_files("test/"), with_labels=True)</pre>



<p class="wp-block-paragraph">Langkah selanjutnya adalah membuat objek DataLoader. Konsep data loader adalah konsep yang umum digunakan di Pytorch. Intinya sebuah objek yang menghandle hampir semua keperluan data, seperti splitting train-validasi, preprocess, pembagian mana fitur mana label, dsb. </p>



<p class="wp-block-paragraph">Jika format dataset citra kita sudah &#8220;standar&#8221; dalam folder dengan struktur seperti ini:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">train/
  kelas_1/
     citra_103.png
     citra_22.png
     ...
  kelas_2/
     citra_123.png
     citra_324.png
     ...
  ...</pre>



<p class="wp-block-paragraph">Maka kita bisa menggunakan fungsi `ImageDataLoaders.from_folder` untuk secara otomatis me-load data. Perlu dicatat, fastai bisa dibilang hampir mewajibkan untuk penggunaan data validasi, ketika tidak kita sediakan maka fastai yang akan otomatis melakukan split dataset. Pada contoh di atas ada parameter <code>valid_pct=0.2</code> yang artinya 20% data akan dipilih secara random untuk validation. Sedangkan parameter <code>item_tfms</code> digunakan untuk proses transformasi data. Pada kode diatas, kita beri nilai <code>Resize(224)</code> yang artinya setiap citra akan di-resize ukurannya menjadi 224&#215;224. </p>



<p class="wp-block-paragraph">Pada baris kedua kita membuat data loader lagi kali ini untuk data test atau data pengujian. Di sini saya meng-&#8220;copy&#8221; proses yang terjadi pada trainloader tapi untuk kebutuhan test menggunakan fungsi <code>trainloader.test_dl()</code>dan menginfokan untuk menggunakan <code>get_image_files()</code> untuk me-load data citra. Kita juga menggunakan parameter <code>with_labels=True</code> untuk memberi tahu agar testloader menyimpan info label dari data test untuk menghitung akurasi.</p>



<p class="wp-block-paragraph"><strong>Khusus untuk pengguna windows</strong>! sampai tulisan ini dibuat, <a href="https://github.com/fastai/fastai/projects/1#card-53140160" target="_blank" rel="noreferrer noopener nofollow">ada bug</a> yang membuat kita perlu menambahkan parameter <code>num_workers=0</code> di kedua fungsi loader di atas, sehingga akan tampak seperti berikut:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">trainloader = ImageDataLoaders.from_folder("train/", valid_pct=0.2, item_tfms=Resize(224), num_workers=0)
testloader = trainloader.test_dl(get_image_files("test/"), with_labels=True, num_workers=0)</pre>



<p class="wp-block-paragraph">Langkah selanjutnya kita akan membuat model  CNN kita. Mungkin tepatnya bukan membuat, melainkan kita akan menggunakan <a href="https://structilmy.com/2021/01/transfer-learning-solusi-deep-learning-dengan-data-sedikit/">pretrained model CNN yang sudah tersedia alias kita akan melakukan transfer learning</a>:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">learn = cnn_learner(trainloader, resnet18, metrics=error_rate) </pre>



<p class="wp-block-paragraph">Pada kode di atas kita membuat objek <code>learner</code> yang menggunakan pretrained model ResNet18 dengan data train dari <code>trainloader</code>. Kita juga menginfokan pada learner untuk menampilkan <code>error_rate</code> di log nantinya.</p>



<p class="wp-block-paragraph">Setelah itu kita cukup jalankan perintah berikut untuk memulai proses pelatihan dengan fine tuning sebanyak 3 epoch (dalam pengaturan <em>default</em>, tepatnya 1 epoch dalam keadaan freeze, dan 3 epoch dalam keadaan semua layer unfreeze):</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">learn.fine_tune(3) </pre>



<p class="wp-block-paragraph">Salah satu yang saya suka dari fastai juga adalah ketika proses training berjalan, progress barnya menarik (baca: info yang ditampilkan lengkap dan cukup untuk jadi log)</p>



<figure class="wp-block-image size-large"><img data-recalc-dims="1" loading="lazy" decoding="async" width="784" height="181" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/Screenshot-2021-02-17-181844.png?resize=784%2C181&#038;ssl=1" alt="" class="wp-image-2278" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/Screenshot-2021-02-17-181844.png?w=784&amp;ssl=1 784w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/Screenshot-2021-02-17-181844.png?resize=300%2C69&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2021/02/Screenshot-2021-02-17-181844.png?resize=768%2C177&amp;ssl=1 768w" sizes="auto, (max-width: 784px) 100vw, 784px" /><figcaption><sub>Kalau pakai jupyter lebih bagus lagi</sub></figcaption></figure>



<p class="wp-block-paragraph">Dan dilanjut dengan menampilkan akurasi ke data test menggunakan fungsi <code>get_preds()</code>. Fungsi tersebut akan mengoutputkan dua nilai dalam bentuk <em>tuple</em>, yakni prediksi dan target/label seharusnya. Sedangkan fungsi <code>accuracy</code> juga bawaan dari fastai untuk menampilkan akurasi diketahui nilai prediksi dan target.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">print(accuracy(*model.get_preds(dl=testloader)))</pre>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow"><p>Tanda * digunakan untuk &#8220;memecah&#8221; elemen-elemen tuple untuk <a href="https://note.nkmk.me/en/python-argument-expand/" target="_blank" rel="noreferrer noopener nofollow">menjadi parameter di sebuah fungsi</a>.</p></blockquote>



<h2 class="wp-block-heading">Hasilnya?</h2>



<p class="wp-block-paragraph">Saya menggunakan data yang sama pada <a href="https://structilmy.com/2019/07/convolutional-neural-network-cnn-menggunakan-pytorch/">tutorial CNN menggunakan Pytorch</a>. Hanya dengan 3 epoch dan 6 baris kode akurasi model dari datatest mencapai 89.17%! Padahal di artikel sebelumnya kita hanya dapat di sekitar 70% <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f600.png" alt="😀" class="wp-smiley" style="height: 1em; max-height: 1em;" /></p>



<h2 class="wp-block-heading">Tutorial Lebih Lanjut</h2>



<p class="wp-block-paragraph">Bagi teman-teman yang tertarik dengan fastai, bisa banget untuk langsung lanjut memperdalam library ini. InsyaAllah kami berencana untuk membuat artikel lain yang membahas fastai lebih lanjut, tapi tidak tahu juga kapan akan publish <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f600.png" alt="😀" class="wp-smiley" style="height: 1em; max-height: 1em;" /> jadi bisa mulai belajar mandiri dari sumber belajar berikut:</p>



<ul class="wp-block-list"><li><a href="http://course.fast.ai" target="_blank" rel="noreferrer noopener nofollow">Course fastai</a> : saya rekomendasikan tonton 2-3 video dulu agar terbayang gambaran umumnya. Sebagai catatan, course ini tidak hanya membahas teknis tetapi juga banyak sisi teorinya, menarik!</li><li><a href="https://docs.fast.ai/tutorial.html" target="_blank" rel="noreferrer noopener">Offi</a><a href="https://docs.fast.ai/tutorial.html" target="_blank" rel="noreferrer noopener nofollow">c</a><a href="https://docs.fast.ai/tutorial.html" target="_blank" rel="noreferrer noopener">ial Tutorial fastai</a>: tapi sejujurnya saya kurang merekomendasikan, dulu belajar dari sini ngerasa agak kesulitan memahami &#8220;kenapa-kenapa&#8221; nya <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f641.png" alt="🙁" class="wp-smiley" style="height: 1em; max-height: 1em;" /></li><li><a href="https://walkwithfastai.com/" target="_blank" rel="noreferrer noopener nofollow">Walk With Fastai</a>: dibuat oleh Zach Mueller (bukan official fastai), berisi course-course yang cocok untuk temen-temen yang ingin fokus ke sisi praktiknya. Saya sangat terbantu dengan walk with fastai, sangat melengkapi course dan tutorial resmi dari fastai <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f600.png" alt="😀" class="wp-smiley" style="height: 1em; max-height: 1em;" /></li></ul>



<p class="wp-block-paragraph">Sekian, semoga bermanfaat! jadi mau pakai library apa untuk proyek deep learning selanjutnya?</p>



<hr class="wp-block-separator"/>



<p class="wp-block-paragraph"><sub>Cover Photo by <a href="https://unsplash.com/@condorito1953?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Arie Wubben</a> on <a href="https://unsplash.com/s/photos/airplane?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></sub></p>
]]></content:encoded>
					
					<wfw:commentRss>https://structilmy.com/blog/2021/02/17/deep-learning-dalam-6-baris-dengan-fastai-dan-pytorch/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
		<post-id xmlns="com-wordpress:feed-additions:1">2254</post-id>	</item>
		<item>
		<title>Object Detection dengan PyTorch Detectron 2 dan Colab</title>
		<link>https://structilmy.com/blog/2020/10/01/object-detection-dengan-pytorch-detectron-2-dan-colab/</link>
					<comments>https://structilmy.com/blog/2020/10/01/object-detection-dengan-pytorch-detectron-2-dan-colab/#comments</comments>
		
		<dc:creator><![CDATA[Rian Adam]]></dc:creator>
		<pubDate>Wed, 30 Sep 2020 17:26:00 +0000</pubDate>
				<category><![CDATA[Computer Vision]]></category>
		<category><![CDATA[Deep Learning]]></category>
		<category><![CDATA[Tutorial]]></category>
		<category><![CDATA[Machine Learning]]></category>
		<category><![CDATA[Object Detection]]></category>
		<category><![CDATA[pytorch]]></category>
		<guid isPermaLink="false">http://structilmy.com/?p=1700</guid>

					<description><![CDATA[Pada tutorial ini kita akan coba membuat object detection model dengan custom dataset kita sendiri menggunakan PyTorch Detectron 2. Facebook Detectron 2 adalah salah satu python framework yang dapat digunakan untuk kasus object detection. Detectron dikembangkan oleh Facebook dengan menggunakan basis PyTorch sebagai deep learning frameworknya. Bagi yang belum tahu tentang PyTorch, bisa cek website [&#8230;]]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">Pada tutorial ini kita akan coba membuat object detection model dengan custom dataset kita sendiri menggunakan <a href="https://github.com/facebookresearch/detectron2/" target="_blank" rel="noreferrer noopener">PyTorch Detectron 2</a>.</p>



<p class="wp-block-paragraph"><a href="https://github.com/facebookresearch/detectron2/" target="_blank" rel="noreferrer noopener">Facebook Detectron 2</a> adalah salah satu python framework yang dapat digunakan untuk kasus object detection.  Detectron dikembangkan oleh Facebook dengan menggunakan basis PyTorch sebagai deep learning frameworknya. Bagi yang belum tahu tentang PyTorch, bisa cek <a href="https://pytorch.org/" target="_blank" rel="noreferrer noopener">website resminya</a> atau kunjungi tutorial kami <a href="https://structilmy.com/2019/07/convolutional-neural-network-cnn-menggunakan-pytorch/" target="_blank" rel="noreferrer noopener">sebelumnya di sini</a>.</p>



<p class="wp-block-paragraph">Framework lain untuk deteksi objek yang cukup populer adalah <a href="https://github.com/tensorflow/models/tree/master/research/object_detection" target="_blank" rel="noreferrer noopener">Tensorflow object-detection API</a> (TFOD) yang dikembangkan oleh Google. Keduanya hampir memiliki fitur utama yang sama, salah satunya mereka menyediakan Model Zoo, di mana kita bisa mulai proses training menggunakan model yang sudah ada (pretrained model).</p>



<p class="has-text-align-center wp-block-paragraph"><strong> Artikel telah di update 16 Januari 2020 pada perubahan instalasi Detectron 2 versi 0.3</strong></p>



<h2 class="wp-block-heading">Detectron 2 Tutorial</h2>



<p class="wp-block-paragraph">Pada tutorial ini kita akan menggunakan <a href="https://structilmy.com/2019/05/mengenal-google-colab/">Google Colab</a>. Contoh code yang akan dibahas pada artikel ini <a href="https://colab.research.google.com/drive/1XvYUqBzSxwULia2ecu5FCfIFmtlGPMjD?usp=sharing" target="_blank" rel="noreferrer noopener"><strong>tersedia di sini</strong>.</a></p>



<div class="wp-block-image"><figure class="alignright size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/09/Screenshot-from-2020-09-29-10-37-01.png?resize=166%2C125&#038;ssl=1" alt="" class="wp-image-2030" width="166" height="125"/><figcaption>Detectron 2 Logo</figcaption></figure></div>



<ol class="wp-block-list"><li><a href="#dataset">Dataset</a></li><li><a href="#instalasi">Instalasi</a></li><li><a href="#datasetcatalog">Menyiapkan DatasetCatalog</a></li><li><a href="#training">Training Model</a></li><li><a href="#save">Save and Load Model</a></li></ol>



<h3 class="wp-block-heading" id="dataset">1. Dataset</h3>



<p class="wp-block-paragraph">Dataset yang akan kita gunakan sama dengan dataset dari tutorial sebelumnya. Kita akan mendeteksi pada suatu citra apakah ada kangguru atau rakun. Penjelasan detail format data dan bagaimana memprosesnya dapat dilihat pada <a href="https://structilmy.com/2020/06/object-detection-dengan-tensorflow-dan-google-colab-1/">artikel sebelumnya</a>. Tapi, karena artikel sebelumnya digunakan untuk object detection dengan Tensorflow sedangkan kita di sini akan menggunakan PyTorch Detectron, maka kita tidak perlu memproses data sampai membuat file tfrecord, cukup sampai bagian <a href="https://structilmy.com/2020/06/object-detection-dengan-tensorflow-dan-google-colab-1/#membuat-file-csv">membuat file csv.</a></p>



<p class="wp-block-paragraph">Dataset latihan dapat didownload melalui github dengan menuliskan perintah berikut di google colab. Detail dataset dapat dibaca di file Readme:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">! git clone https://github.com/rianrajagede/object-detection.git</pre>



<span id="more-1700"></span>



<h3 class="wp-block-heading" id="instalasi">2. Instalasi Detectron 2</h3>



<p class="wp-block-paragraph">Sebelum menginstall detectron kita perlu menginstall PyTorch, pyyaml, dan pycocotools dengan versi yang sesuai. Di Google Colab PyTorch sudah otomatis terinstall, kita cukup menginstall 2 package sisanya melalui Google Colab:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="powershell" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">! pip install pyyaml==5.1 pycocotools==2.0.1</pre>



<p class="wp-block-paragraph">Kita juga perlu memperhatikan versi PyTorch yang tersedia dan versi Cuda. Hal ini bisa dilakukan dengan menjalankan perintah berikut di Colab:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">import torch
print(torch.__version__)</pre>



<p class="wp-block-paragraph">Pada saat tutorial ini ditulis, output dari perintah di atas adalah <code>1.6.0+cu101</code> yang artinya terinstall PyTorch versi 1.6.0 dengan Cuda versi 10.1. Selanjutnya kita cukup install Detectron berdasarkan versi yang sesuai, petunjukknya dapat dibaca di link berikut.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="powershell" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">! python -m pip install detectron2 -f  https://dl.fbaipublicfiles.com/detectron2/wheels/cu101/torch1.7/index.html</pre>



<h3 class="wp-block-heading" id="datasetcatalog">3. Menyiapkan DatasetCatalog</h3>



<p class="wp-block-paragraph">Detectron menyimpan dataset pada sebuah object bernama DatasetCatalog. Sebelum memulai training, kita perlu mengconvert dataset kita yang awalnya berbentuk XML ke DatasetCatalog.</p>



<p class="wp-block-paragraph">DatasetCatalog adalah sebuah list of dictionary dengan setiap elemennya berformat sebagai berikut:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">{'annotations':
    [{'bbox': [LIST KOORDINAT BOUNDING BOX 1],
       'bbox_mode': &lt;FORMAT BOUNDING BOX 1>,
       'category_id': LABEL INDEX OBJECT 1},
     {'bbox': [LIST KOORDINAT BOUNDING BOX 2],
       'bbox_mode': &lt;FORMAT BOUNDING BOX 2>,
       'category_id': LABEL INDEX OBJECT 2},
       .... ],
 'file_name': 'PATH KE FILE JPG',
 'height': TINGGI GAMBAR,
 'width': LEBAR GAMBAR,
 'image_id': ID GAMBAR,
}</pre>



<p class="wp-block-paragraph">Code yang diperlukan untuk mengconvert dari CSV dataset kita sebagai berikut (penjelasan dalam bentuk komentar):</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group=""># Buat dictionary berisikan nama label dan indexnya
labelmap = {
    "kangaroo" : 0,
    "raccoon" : 1
}

# Buat fungsi get_dicts() untuk mengconvert XML ke DatasetCatalog.
# Parameter settype digunakan untuk membedakan file dataset,
# Karena data test dan data train diperlakukan sama, maka saya
# memilih untuk menggunakan satu fungsi untuk memproses dua 
# DatasetCatalog, yaitu untuk train dan untuk test
def get_dicts(settype):
    if settype=="test":
        csvpath = main_path+"/test_labels.csv"
    else:
        csvpath = main_path+"/train_labels.csv"

    df = pd.read_csv(csvpath).values # load dataset

    dataset_dicts = []
    done = []
    for idx in range(len(df)):
        record = {}
        filename = df[idx, 0]
        record["image_id"] = idx
        record["file_name"] =  main_path+"/"+settype+"/"+filename
        record["width"] = df[idx, 1]
        record["height"] = df[idx, 2]

        if filename in done: # untuk menghindari duplikat
            continue
        done.append(filename)

        objs = []
        for row in df[df[:,0]==filename]: # simpan semua objek
            objs.append({
                    "bbox": [ row[4], row[5], row[6], row[7]],
                    "bbox_mode": BoxMode.XYXY_ABS,
                    "category_id": labelmap[row[3]],
            })
        record["annotations"] = objs
        dataset_dicts.append(record)

    return dataset_dicts</pre>



<p class="wp-block-paragraph">Selanjutnya kita cukup menggunanakan perintah berikut untuk membuat DatasetCatalog dengan nama <code>rk_train</code> dan <code>rk_test</code>. Sekaligus kita juga membuat MetadataCatalog untuk menyimpan informasi objeknya.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">DatasetCatalog.register("rk_train", lambda t="train":get_dicts(t))
DatasetCatalog.register("rk_test", lambda t="test":get_dicts(t))
MetadataCatalog.get("rk_train").set(thing_classes=["kangaroo", "raccoon"])
MetadataCatalog.get("rk_test").set(thing_classes=["kangaroo", "raccoon"])</pre>



<h3 class="wp-block-heading" id="training">4. Training Model</h3>



<p class="wp-block-paragraph">Dengan menggunakan pretrained model, yang perlu kita lakukan adalah mendownload model dari Model Zoo lalu melakukan sedikit config atau pengaturan. Detail penjelasan pengaturan ini dapat dilihat di dokumentasi resmi Detectron 2.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">from detectron2.engine import DefaultTrainer
from detectron2.config import get_cfg

cfg = get_cfg()
pre_mod = "COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml"

# pilih dan download model
cfg.merge_from_file(model_zoo.get_config_file(pre_mod))
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(pre_mod)

# atur data train dan test
cfg.DATASETS.TRAIN = ("rk_train",)
cfg.DATASETS.TEST = ()

# atur pelatihan
cfg.DATALOADER.NUM_WORKERS = 2
cfg.SOLVER.IMS_PER_BATCH = 2
cfg.SOLVER.BASE_LR = 0.005  # learning rate
cfg.SOLVER.MAX_ITER = 100  # banyak iterasi
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 48
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 2</pre>



<p class="wp-block-paragraph">Setelah pengaturan di atas, proses training cukup menjalankan perintah berikut:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group=""># membuat direktori output pelatihan
os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)

trainer = DefaultTrainer(cfg) 
 # resume=False artinya pelatihan baru bukan melanjutkan
trainer.resume_or_load(resume=False)
trainer.train()</pre>



<p class="wp-block-paragraph">Hasil dari proses pelatihan ini akan muncul di folder <code>output</code>. Model akhir bernama <code>model_final.pth</code></p>



<div class="wp-block-image"><figure class="aligncenter size-large"><img data-recalc-dims="1" loading="lazy" decoding="async" width="990" height="235" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/09/Screenshot-from-2020-09-29-14-48-37.png?resize=990%2C235&#038;ssl=1" alt="" class="wp-image-2035" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/09/Screenshot-from-2020-09-29-14-48-37.png?w=990&amp;ssl=1 990w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/09/Screenshot-from-2020-09-29-14-48-37.png?resize=300%2C71&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/09/Screenshot-from-2020-09-29-14-48-37.png?resize=768%2C182&amp;ssl=1 768w" sizes="auto, (max-width: 990px) 100vw, 990px" /><figcaption>Tampilan proses pelatihan</figcaption></figure></div>



<h3 class="wp-block-heading" id="save">5. Load Model</h3>



<p class="wp-block-paragraph">Kita bisa gunakan model akhir tersebut untuk mendeteksi citra dengan langkah berikut. Pertama-tama kita load terlebih dahulu model dan beri sedikit pengaturan treshold.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">cfg.MODEL.WEIGHTS = os.path.join("output/", "model_final.pth")
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.8  
predictor = DefaultPredictor(cfg)</pre>



<p class="wp-block-paragraph"><code>predictor</code> adalah objek model kita. Untuk melakukan deteksi kita cukup menuliskan perintah berikut:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">from detectron2.utils.visualizer import ColorMode

im = cv2.imread("/content/TestImage.png") # load image
outputs = predictor(im) # predict
v = Visualizer(im[:, :, ::-1], metadata=metadata, scale=0.8) # visualisasi
out = v.draw_instance_predictions(outputs["instances"].to("cpu"))
cv2_imshow(out.get_image()[:, :, ::-1])</pre>



<p class="wp-block-paragraph">Variabel <code>outputs</code> yang dihasilkan menyimpan data-data seperti koordinat bounding box, score, dan class object pada gambar sehingga mudah diolah. Untuk visualisasi kita bisa memanfaatkan fungsi <code>Visualizer</code> bawaan Detectron yang dapat langsung menampilkan gambar disertai bounding boxnya seperti di bawah ini:</p>



<figure class="wp-block-image size-large"><img data-recalc-dims="1" loading="lazy" decoding="async" width="345" height="261" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/09/index.png?resize=345%2C261&#038;ssl=1" alt="" class="wp-image-2036" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/09/index.png?w=345&amp;ssl=1 345w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/09/index.png?resize=300%2C227&amp;ssl=1 300w" sizes="auto, (max-width: 345px) 100vw, 345px" /></figure>



<p class="wp-block-paragraph">Sekian tutorialnya, semoga bermanfaat! kode yang kami bahas di artikel ini <a href="https://colab.research.google.com/drive/1XvYUqBzSxwULia2ecu5FCfIFmtlGPMjD?usp=sharing" target="_blank" rel="noreferrer noopener"><strong>tersedia di sini</strong>.</a></p>
]]></content:encoded>
					
					<wfw:commentRss>https://structilmy.com/blog/2020/10/01/object-detection-dengan-pytorch-detectron-2-dan-colab/feed/</wfw:commentRss>
			<slash:comments>11</slash:comments>
		
		
		<post-id xmlns="com-wordpress:feed-additions:1">1700</post-id>	</item>
		<item>
		<title>Pengenalan Autoencoder : neural network untuk kompresi data</title>
		<link>https://structilmy.com/blog/2020/03/17/pengenalan-autoencoder-neural-network-untuk-kompresi-data/</link>
					<comments>https://structilmy.com/blog/2020/03/17/pengenalan-autoencoder-neural-network-untuk-kompresi-data/#comments</comments>
		
		<dc:creator><![CDATA[Rian Adam]]></dc:creator>
		<pubDate>Mon, 16 Mar 2020 23:28:54 +0000</pubDate>
				<category><![CDATA[Deep Learning]]></category>
		<category><![CDATA[feature extraction]]></category>
		<category><![CDATA[neural network]]></category>
		<category><![CDATA[Python]]></category>
		<category><![CDATA[pytorch]]></category>
		<guid isPermaLink="false">http://structilmy.com/?p=1522</guid>

					<description><![CDATA[Autoencoder Autoencoder adalah salah satu varian dari jaringan saraf tiruan (JST) yang secara umum digunakan untuk meng-&#8220;encode&#8221; suatu data. Berbeda dengan arsitektur JST pada umumnya yang dilatih untuk mengklasifikasi atau menghitung nilai regresi dari masukan, autoencoder dilatih untuk dapat menghasilkan output yang sama dengan inputnya. Autoencoder termasuk pada kategori Unsupervised Learning karena dilatih dengan menerima [&#8230;]]]></description>
										<content:encoded><![CDATA[
<h2 class="wp-block-heading">Autoencoder</h2>



<p class="wp-block-paragraph"><a href="https://en.wikipedia.org/wiki/Autoencoder">Autoencoder</a> adalah salah satu varian dari <a href="https://structilmy.com/2019/09/sekilas-tentang-jaringan-saraf-tiruan-dan-deep-learning/">jaringan saraf tiruan (JST)</a> yang secara umum digunakan untuk meng-&#8220;encode&#8221; suatu data. Berbeda dengan arsitektur JST pada umumnya yang dilatih untuk mengklasifikasi atau menghitung nilai regresi dari masukan, autoencoder dilatih untuk dapat menghasilkan output yang sama dengan inputnya. Autoencoder termasuk pada kategori Unsupervised Learning karena dilatih dengan menerima data tanpa label.</p>



<div class="wp-block-image"><figure class="aligncenter size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn-ae-1.png?resize=417%2C294&#038;ssl=1" alt="" class="wp-image-1529" width="417" height="294" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn-ae-1.png?w=1024&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn-ae-1.png?resize=300%2C212&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn-ae-1.png?resize=768%2C542&amp;ssl=1 768w" sizes="auto, (max-width: 417px) 100vw, 417px" /><figcaption>Traditional Neural Network vs Autoencoder</figcaption></figure></div>



<p class="wp-block-paragraph">Pada ilustrasi tersebut, arsitektur di bagian atas adalah arsiktektur JST yang digunakan untuk mengklasifikasi citra bahan makanan di supermarket. Pada bagian bawah merupakan arsitektur autoencoder.</p>



<p class="wp-block-paragraph"><em>Lalu apa tujuannya sebuah model dilatih untuk menghasilkan citra yang sama?</em></p>



<p class="wp-block-paragraph">Jika diperhatikan pada ilustrasi di atas, bagian yang menarik adalah bagian tengah autoencoder yang berupa sebuah vektor kumpulan neuron (ditandai dengan kotak warna kuning). Bagian tengah ini biasanya memiliki jumlah neuron yang lebih kecil dibanding layer di kanan atau kirinya (termasuk layer input dan outputnya). Sehingga jika model dapat dilatih dengan baik, bisa dikatakan bagian tengah ini merupakan<strong> representasi sederhana dari citra yang menjadi input</strong>. <em>Apa maksud representasi sederhana</em>? Karena vektor ini diperoleh dari citra input melalui arsitektur jaringan saraf tiruan (Encode), lalu dari vektor <em>yang kecil </em>ini bisa dibuat kembali citra yang serupa dengan inputnya (Decode).</p>



<span id="more-1522"></span>



<h2 class="wp-block-heading">Arsitektur</h2>



<div class="wp-block-image"><figure class="aligncenter size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/linear-ae.png?resize=472%2C136&#038;ssl=1" alt="" class="wp-image-1531" width="472" height="136" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/linear-ae.png?w=1024&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/linear-ae.png?resize=300%2C86&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/linear-ae.png?resize=768%2C221&amp;ssl=1 768w" sizes="auto, (max-width: 472px) 100vw, 472px" /><figcaption>Linear Autoencoder</figcaption></figure></div>



<p class="wp-block-paragraph">Pada ilustrasi di atas tampak arsitektur Auto encoder sebenarnya cukup sederhana. Kita bisa membagi arsitektur keseluruhan menjadi dua bagian, Encoder dan Decoder. JST pada bagian kiri mengubah dari citra menjadi feature vector, JST ini disebut dengan Encoder. Sedangkan JST pada bagian kanan mengubah dari Feature Vector kembali ke Citra, sehingga disebut dengan Decoder.</p>



<p class="wp-block-paragraph">Alur pelatihan pun sama seperti proses pelatihan JST pada umumnya. Forward Propagation dilakukan hingga citra berhasil di rekonstruksi oleh decoder, lalu eror dihitung dengan menghitung selisih (menggunakan Mean Square Error) perbedaan nilai antara citra yang dihasilkan dengan citra aslinya. Perbaikan bobot menggunakan algoritma optimasi semisal Stochastic Gradient Descent.</p>



<p class="wp-block-paragraph">Mungkin yang perlu diperhatikan dalam pembuatan Autoencoder adalah pada bagian fungsi aktivasi. Karena fungsi aktivasi menentukan nilai akhir dari masing-masing model. Misalnya pada Decoder, sebaiknya kita menggunakan fungsi aktivasi Sigmoid atau Tanh pada layer terakhirnya. Kenapa? karena kedua fungsi tersebut memetakan output ke  suatu rentang nilai yang pasti (misalnya antara 0..1 untuk Sigmoid), sehingga dari rentangna tersebut kita bisa merekonstruksi citra (misalnya 0 menjadi hitam 1 menjadi putih untuk sigmoid)</p>



<h2 class="wp-block-heading">Convolutional Autoencoder</h2>



<figure class="wp-block-image size-large"><img data-recalc-dims="1" loading="lazy" decoding="async" width="1024" height="287" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn-ae-e1583555311588-1024x287.png?resize=1024%2C287" alt="" class="wp-image-1528" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn-ae-e1583555311588.png?resize=1024%2C287&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn-ae-e1583555311588.png?resize=300%2C84&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn-ae-e1583555311588.png?resize=768%2C215&amp;ssl=1 768w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn-ae-e1583555311588.png?w=1443&amp;ssl=1 1443w" sizes="auto, (max-width: 1024px) 100vw, 1024px" /><figcaption>Convolutional Autoencoder</figcaption></figure>



<p class="wp-block-paragraph">Pada Jenis Convolutional Autoencoder, Model JST Encoder dan Decodernya menggunakan jenis <a href="https://structilmy.com/2019/07/convolutional-neural-network-cnn-menggunakan-pytorch/">Convolutional Neural Network (CNN)</a>. Secara umum, alur yang terjadi sama seperti Autoencoder biasa. Misalnya pada bagian encoder proses pembentukan feature vector sama seperti model CNN biasa. Bagian akhir layer konvolusi nantinya tinggal di flatten untuk menghasilkan feature vector.</p>



<p class="wp-block-paragraph">Namun, pada bagian decoder ada sedikit yang berbeda. Setelah feature vector disusun ulang menjadi 2D, kita tidak bisa langsung melakukan proses konvolusi untuk mendapatkan nilai di layer selanjutnya. Hal ini karena CNN tidak secara alami digunakan untuk menghasilkan citra yang berukuran lebih besar (Deconvolution). Untuk itu terdapat beberapa trik atau teknik untuk melakukannya.</p>



<p class="wp-block-paragraph"><strong>1. Menggunakan upsampling</strong>. Salah satu metode yan dapat digunakan adalah interpolasi, yakni dengan cara menduplikat nilai-nilai pada suatu pixel. </p>



<div class="wp-block-image"><figure class="aligncenter size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/upsampling.png?resize=250%2C129&#038;ssl=1" alt="" class="wp-image-1541" width="250" height="129" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/upsampling.png?w=621&amp;ssl=1 621w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/upsampling.png?resize=300%2C156&amp;ssl=1 300w" sizes="auto, (max-width: 250px) 100vw, 250px" /></figure></div>



<p class="wp-block-paragraph">Hasil dari upsampling adalah matrix yang lebih besar ukurannya. Setelah memperoleh hasil matrix yang lebih besar barulah dikalikan menggunakan kernel yang menghasilkan matrix dengan ukuran sama (misal menggunakan kernel 3&#215;3, padding 1 dan stride 1).</p>



<div class="wp-block-image"><figure class="aligncenter size-large is-resized"><img loading="lazy" decoding="async" src="https://i2.wp.com/structilmy.com/wp-content/uploads/2020/03/upsampling2.png?fit=1024%2C548&amp;ssl=1" alt="" class="wp-image-1545" width="364" height="194" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/upsampling2.png?w=1087&amp;ssl=1 1087w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/upsampling2.png?resize=300%2C161&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/upsampling2.png?resize=1024%2C548&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/upsampling2.png?resize=768%2C411&amp;ssl=1 768w" sizes="auto, (max-width: 364px) 100vw, 364px" /></figure></div>



<p class="wp-block-paragraph"><strong>2. Cara kedua adalah menggunakan Transpose Convolution.</strong>  Metode ini menggunakan sebuah kernel konvolusi tanpa menjumlah nilai hasil perkalian dengan kernelnya. Biasanya ukuran kernel ini disesuaikan dengan akhir yang diinginkan. Misal untuk memperoleh ukuran matriks dua kali lipatnya, biasanya menggunakan kernel ukuran 2&#215;2 dengan stride 2.</p>



<div class="wp-block-image"><figure class="aligncenter size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/transconv.png?resize=322%2C149&#038;ssl=1" alt="" class="wp-image-1542" width="322" height="149" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/transconv.png?w=750&amp;ssl=1 750w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/transconv.png?resize=300%2C140&amp;ssl=1 300w" sizes="auto, (max-width: 322px) 100vw, 322px" /></figure></div>



<p class="wp-block-paragraph">Sekian penjelasan singkat tentang Autoencoder sederhana yang banyak dimanfaatkan untuk denoising citra, kompresi citra, meningkatkan resolusi dan banyak lagi. Sebenarnya model ini juga telah memiliki banyak pengembangan yang beragam, salah satunya adalah Variational Autoencoder (VAE) yang memungkinkan untuk meng-generate suatu citra.</p>



<p class="wp-block-paragraph"> Semoga bermanfaat.</p>
]]></content:encoded>
					
					<wfw:commentRss>https://structilmy.com/blog/2020/03/17/pengenalan-autoencoder-neural-network-untuk-kompresi-data/feed/</wfw:commentRss>
			<slash:comments>2</slash:comments>
		
		
		<post-id xmlns="com-wordpress:feed-additions:1">1522</post-id>	</item>
		<item>
		<title>Implementasi Jaringan Saraf Tiruan menggunakan PyTorch</title>
		<link>https://structilmy.com/blog/2020/02/04/implementasi-jaringan-saraf-tiruan-menggunakan-pytorch/</link>
					<comments>https://structilmy.com/blog/2020/02/04/implementasi-jaringan-saraf-tiruan-menggunakan-pytorch/#respond</comments>
		
		<dc:creator><![CDATA[Rian Adam]]></dc:creator>
		<pubDate>Tue, 04 Feb 2020 08:28:14 +0000</pubDate>
				<category><![CDATA[Machine Learning]]></category>
		<category><![CDATA[Tutorial]]></category>
		<category><![CDATA[Jaringan saraf tiruan]]></category>
		<category><![CDATA[Python]]></category>
		<category><![CDATA[pytorch]]></category>
		<guid isPermaLink="false">http://structilmy.com/?p=1222</guid>

					<description><![CDATA[Pada artikel ini kita akan coba melakukan implementasi Jaringan Saraf Tiruan / JST / Artificial Neural Network untuk kasus klasifikasi menggunakan PyTorch. Bagi yang belum tahu PyTorch bisa membaca artikel sebelumnya di sini atau bagi yang mau memahami bagaimana JST bekerja bisa buka artikel berikut. Dataset Kita akan menggunakan dataset Iris yang sudah cukup populer. [&#8230;]]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">Pada artikel ini kita akan coba melakukan implementasi Jaringan Saraf Tiruan / JST / Artificial Neural Network untuk kasus klasifikasi menggunakan PyTorch. Bagi yang belum tahu PyTorch bisa membaca <a href="https://structilmy.com/2019/07/tutorial-dasar-pytorch-tensor-dan-autograd/">artikel sebelumnya di sini</a> atau bagi yang mau memahami bagaimana <a href="https://structilmy.com/2019/09/sekilas-tentang-jaringan-saraf-tiruan-dan-deep-learning/">JST bekerja bisa buka artikel berikut</a>.</p>



<h2 class="wp-block-heading">Dataset</h2>



<p class="wp-block-paragraph">Kita akan menggunakan dataset Iris yang sudah cukup populer. Dataset ini berisi data dari 150 Bunga Iris yang berasa dari 3 spesies berbeda. Diberikan  4 buah fitur / ciri, yakni panjang kelopak (sepal length), lebar kelopak (sepal width), panjang mahkota (petal length), dan lebar mahkota (petal width), lalu kita akan mencoba untuk mengklasifikasikan bunga tersebut adalah spesies apa.</p>



<figure class="wp-block-image"><img data-recalc-dims="1" loading="lazy" decoding="async" width="863" height="288" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2019/10/Screenshot-from-2019-10-27-06-27-01.png?resize=863%2C288&#038;ssl=1" alt="iris set" class="wp-image-1437" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2019/10/Screenshot-from-2019-10-27-06-27-01.png?w=863&amp;ssl=1 863w, https://i0.wp.com/structilmy.com/wp-content/uploads/2019/10/Screenshot-from-2019-10-27-06-27-01.png?resize=300%2C100&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2019/10/Screenshot-from-2019-10-27-06-27-01.png?resize=768%2C256&amp;ssl=1 768w" sizes="auto, (max-width: 863px) 100vw, 863px" /></figure>



<p class="wp-block-paragraph">Saya telah memisahkan dataset aslinya menjadi dua file, satu untuk training, dan satu untuk testing. File csv dataset tersebut dapat di download di sini: <a href="https://raw.githubusercontent.com/rianrajagede/iris-python/master/Datasets/iris/iris_train.csv">training set</a> dan <a href="https://raw.githubusercontent.com/rianrajagede/iris-python/master/Datasets/iris/iris_test.csv">test set</a>.</p>



<h2 class="wp-block-heading">Implementasi Jaringan Saraf Tiruan</h2>



<h4 class="wp-block-heading">Arsitektur</h4>



<p class="wp-block-paragraph">Melihat dataset yang ada, dapat kita simpulkan untuk  arsitektur jaringan saraf tiruan kita membutuhkan 4 buah neuron input (fitur) dan 3 buah neuron output (spesies). Kita akan coba menggunakan sebuah hidden layer dengan jumlah neuron hidden layer sebanyak 3. Ilustrasinya tampak sebagai berikut:</p>



<div class="wp-block-image"><figure class="aligncenter size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/02/iris-1.png?resize=312%2C274&#038;ssl=1" alt="" class="wp-image-1481" width="312" height="274" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/02/iris-1.png?w=503&amp;ssl=1 503w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/02/iris-1.png?resize=300%2C263&amp;ssl=1 300w" sizes="auto, (max-width: 312px) 100vw, 312px" /></figure></div>



<span id="more-1222"></span>



<h4 class="wp-block-heading">Pre-Processing</h4>



<p class="wp-block-paragraph">Pelatihan dilakukan menggunakan data latih iris_train.csv. Ada sebuah tahapan  yang perlu dilakukan sebelum memulai tahapan pelatihan. Tahapan ini disebut pre-processing. Ada banyak hal yang bisa dilakukan pada tahapan ini, tetapi pada tutorual ini saya hanya akan melakukan pre-processing berupa mengubah nilai yang masih string menjadi integer.</p>



<p class="wp-block-paragraph">Contohnya pada kolom species, kita ubah &#8220;Iris-setosa&#8221; menjadi 0, &#8220;Iris-versicolor&#8221; menjadi 1, dan &#8220;Iris-virginica&#8221; menjadi 2. Kita lakukang ini menggunakan Pandas:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">import pandas as pd

# load data train
datatrain = pd.read_csv('../Datasets/iris/iris_train.csv')

# mengubah nilai string menjadi angka dengan pandas
datatrain.loc[datatrain['species']=='Iris-setosa', 'species']=0
datatrain.loc[datatrain['species']=='Iris-versicolor', 'species']=1
datatrain.loc[datatrain['species']=='Iris-virginica', 'species']=2
datatrain = datatrain.apply(pd.to_numeric) # memastikan semuanya numeric</pre>



<p class="wp-block-paragraph">Selain itu, untuk memudahkan diubah juga tipe dari penyimpanan data train tersebut. Yang awalnya adalah Dataframe (karena di-load menggunakan pandas) diubah menjadi Numpy array.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group=""># mengubah tipe dataframe pandas menjadi numpy array
datatrain_array = datatrain.values</pre>



<p class="wp-block-paragraph">Selanjutnya kita pisahkan data tersebut menjadi dua array. Array pertama adalah array fitur, berupa matrix berukuran 120&#215;4 (120 data dengan masing-masing 4 fitur) sedangkan array kedua adalah label, berupa sebuah array 1 dimensi berukuran 120&#215;1 (120 data dengan masing-masing 1 label bernilai antara 0, 1, atau 2)</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group=""># memisahkan array fitur dan array label
xtrain = datatrain_array[:,:4]
ytrain = datatrain_array[:,4]</pre>



<h4 class="wp-block-heading">PyTorch Package</h4>



<p class="wp-block-paragraph">Sebelum mulai menggunakan PyTorch, pastikan import semua package yang dibutuhkan. Atur juga seed random agar nilai random tetap sama setiap run-nya.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">import torch
import torch.nn as nn
import torch.nn.functional as F
torch.manual_seed(1234)</pre>



<h4 class="wp-block-heading">Membuat Model</h4>



<p class="wp-block-paragraph">Setelah data siap, langkah selanjutnya dalam proses implementasi Jaringan Saraf Tiruan adalah membuat arsitektur/model JST nya. Jika menggunakan PyTorch langkah ini dilakukan dengan cara membuat sebuah class.</p>



<p class="wp-block-paragraph">Contoh di bawah adalah sebuah class bernama <code>Net</code> yang merupakan sebuah arsitektur JST dengan 4 neuron pada layer input, 3 neuron pada hidden layer, dan 3 neuron pada layer output. </p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">class Net(nn.Module):

    def __init__(self):
        super(Net, self).__init__()
        self.fc1 = nn.Linear(4, 3) # bobot antara input-hidden
        self.fc2 = nn.Linear(3, 3) # bobot antara hidden-output

    def forward(self, x):
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x
        
modelkita = Net() # menginisalisasi objek</pre>



<p class="wp-block-paragraph">Pada bagian <code>__init__</code> kita perlu mendefinisikan layer apa saja yang akan digunakan. Pada kasus ini kita hanya akan menggunakan layer Linear / Fully-Connected Layer.</p>



<p class="wp-block-paragraph">Perlu diperhatikan, bahwa fungsi <code>Linear</code> di sini sebenarnya bukan mewakili sebuah layer, melainkan sebuah matrix bobot yang berada pada antar layer (proses hitungan antar layer). Misalnya, fungsi <code>nn.Linear(4,3)</code> berarti kita mendefinisikan ada sebuah bobot yang memetakan layer dengan neuron sebanyak 4 ke layer dengan neuron sebanyak 3. Jika diilustrasikan maka fungsi tersebut menggambarkan bagian yang ditandai berikut:</p>



<div class="wp-block-image"><figure class="aligncenter size-large is-resized"><img data-recalc-dims="1" loading="lazy" decoding="async" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/02/iris-2.png?resize=285%2C250&#038;ssl=1" alt="" class="wp-image-1483" width="285" height="250" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/02/iris-2.png?w=503&amp;ssl=1 503w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/02/iris-2.png?resize=300%2C263&amp;ssl=1 300w" sizes="auto, (max-width: 285px) 100vw, 285px" /></figure></div>



<p class="wp-block-paragraph">Pada fungsi <code>forward</code>, kita definisikan proses forward propagation arsitektur kita. Dari kode di atas, tampak sebuah input <code>x</code> akan dikenai perkalian bobot oleh <code>fc1</code>, lalu dikenai fungsi aktivasi ReLU, lalu dikenai lagi perkalian bobot oleh <code>fc2</code>.</p>



<h4 class="wp-block-heading">Mendefinisikan Algoritma Optimasi dan Loss Function</h4>



<p class="wp-block-paragraph">Kita tentukan algoritma optimasi apa yang akan kita gunakan pada JST kita. Algoritma optimasi adalah istilah yang digunakan untuk merujuk algoritma yang digunakan untuk memperbaiki eror pada JST. Ada banyak algoritma di PyTorch yang bisa digunakan. Kali ini, kita akan gunakan Stochastic Gradient Descent (SGD) dengan learning rate sebesar 0.01.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">optimizer = torch.optim.SGD(modelkita.parameters(), lr=0.01)</pre>



<p class="wp-block-paragraph">Tentukan juga metode untuk menghitung eror yang akan kita gunakan. Untuk kasus ini kita akan menggunakan metode Cross-Entropy.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">criterion = nn.CrossEntropyLoss()</pre>



<h4 class="wp-block-heading">Alur Pelatihan</h4>



<p class="wp-block-paragraph">Kita sudah menyiapkan data, membuat model, dan menentukan algoritma-algoritma yang akan kita gunakan. Sekarang saatnya melatih model. Kita latih model dengan data <code>xtrain</code>. Untuk setiap epoch, ada beberapa langkah utama dalam proses pelatihan menggunakan PyTorch:</p>



<ol class="wp-block-list"><li>Ubah semua variabel yang digunakan sudah bertipe Tensor</li><li>Inputkan data ke model untuk mendapatkan output model</li><li>Hitung eror antara output dengan label</li><li>Bersihkan riwayat gradient sebelumnya menggunakan <code>zero_grad()</code></li><li>Hitung gradient eror dengan <code>backward()</code></li><li>Update bobot menggunakan algoritma optimasi</li></ol>



<p class="wp-block-paragraph">Jika dikodekan maka akan tampak sebagai berikut (dengan contoh menggunakan 50 epoch):</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">for epoch in range(50):
    # 1.
    X = torch.Tensor(xtrain).float()
    Y = torch.Tensor(ytrain).long()

    out = modelkita(X)              # 2.
    loss = criterion(out, Y)  # 3.
    optimizer.zero_grad()     # 4.
    loss.backward()           # 5.
    optimizer.step()          # 6.

    print ('Epoch [%d/%d] Loss: %.4f' %(epoch+1, 
        num_epoch, loss.item()))
</pre>



<p class="wp-block-paragraph">Output yang dihasilkan adalah nilai loss atau eror tiap epoch, seperti di bawah:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">Epoch [1/50] Loss: 1.1583
Epoch [2/50] Loss: 1.1536
...
Epoch [49/50] Loss: 1.0022
Epoch [50/50] Loss: 1.0000</pre>



<p class="wp-block-paragraph">Jika diperhatikan proses training kita bisa dibilang berhasil karena setelah 50 epoch nilai loss berhasil turun.</p>



<p class="wp-block-paragraph">Kita bisa mengecek berapa akurasi model terhadap data train dengan menambahkan kode berikut:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group=""># ambil nilai terbesar setiap kelasnya sebagai prediksi
prediksi = torch.max(out.data, 1)[1] 
# bandingkan dengan label, hitung rata-rata persentase
akurasi = 100 * torch.sum(Y==prediksi).double() / len(Y)
print(akurasi)</pre>



<p class="wp-block-paragraph">Ketika program ini saya run di laptop saya dengan versi PyTorch 1.1 diperoleh akurasi pada data train adalah 70.4762%</p>



<h4 class="wp-block-heading">Alur Pengujian</h4>



<p class="wp-block-paragraph">Untuk memastikan seberapa baik model kita, maka kita perlu menguji model kita menggunakan data yang berbeda dengan data latih. Kita lakukan pengujian menggunakan iris_test.csv. Potongan kode berikut sama dengan kode-kode di atas sebelumnya, hanya saja kita menggunakan data tes.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group=""># load data tes
datatest = pd.read_csv('../Datasets/iris/iris_test.csv')

# mengubah nilai string menjadi angka dengan pandas
datatest.loc[datatest['species']=='Iris-setosa', 'species']=0
datatest.loc[datatest['species']=='Iris-versicolor', 'species']=1
datatest.loc[datatest['species']=='Iris-virginica', 'species']=2
datatest = datatest.apply(pd.to_numeric)

# mengubah tipe dataframe pandas menjadi numpy array
datatest_array = datatest.values

# memisahkan array fitur dan array label
xtest = datatest_array[:,:4]
ytest = datatest_array[:,4]

# mendapatkan nilai prediksi
X = torch.Tensor(xtest).float()
Y = torch.Tensor(ytest).long()
out = modelkita(X)
prediksi = torch.max(out.data, 1)[1]

# hitung akurasi
akurasi = 100 * torch.sum(Y==prediksi).double() / len(Y)
print('Accuracy of the network %.4f %%' % akurasi)</pre>



<p class="wp-block-paragraph">Di komputer saya, hasil akurasi data tes adalah sebesar 68.88%, sedikit lebih kecil dari pada akurasi data train. Hal ini wajar karena model JST hanya melihat data train saat dilatih.</p>



<p class="wp-block-paragraph">Apakah akurasi ini masih bisa ditingkatkan? insyaAllah.. silakan coba  ganti-ganti arsitektur dan parameter untuk mendapatkan akurasi yang  lebih baik (disebut Tuning Parameter). Misalnya dengan mengubah  algoritma, jumlah neuron, atau banyak epoch. Beberapa eksperimen harus  dilakukan untuk menjadikan akurasi kita benar-benar baik dan valid.</p>



<p class="wp-block-paragraph">Sekian, semoga bermanfaat, <a href="https://github.com/rianrajagede/iris-python">kode lengkap dapat dilihat di sini</a></p>
]]></content:encoded>
					
					<wfw:commentRss>https://structilmy.com/blog/2020/02/04/implementasi-jaringan-saraf-tiruan-menggunakan-pytorch/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
		<post-id xmlns="com-wordpress:feed-additions:1">1222</post-id>	</item>
		<item>
		<title>Convolutional Neural Network (CNN) menggunakan PyTorch</title>
		<link>https://structilmy.com/blog/2019/07/17/convolutional-neural-network-cnn-menggunakan-pytorch/</link>
					<comments>https://structilmy.com/blog/2019/07/17/convolutional-neural-network-cnn-menggunakan-pytorch/#comments</comments>
		
		<dc:creator><![CDATA[Rian Adam]]></dc:creator>
		<pubDate>Tue, 16 Jul 2019 20:46:25 +0000</pubDate>
				<category><![CDATA[Computer Vision]]></category>
		<category><![CDATA[Deep Learning]]></category>
		<category><![CDATA[Tutorial]]></category>
		<category><![CDATA[convolutional-neural-network]]></category>
		<category><![CDATA[Python]]></category>
		<category><![CDATA[pytorch]]></category>
		<guid isPermaLink="false">http://structilmy.com/?p=1174</guid>

					<description><![CDATA[Artikel ini akan langsung berfokus pada implementasi Convolutional Neural Network (CNN) menggunakan PyTorch untuk Image Classification. Bagi yang ingin memperdalam teori dibalik CNN terlebih dahulu bisa baca pada link artikel sebelumnya yang berisi kumpulan sumber belajar CNN dan jika ingin memperdalam PyTorch, juga bisa baca artikel sebelumnya tentang PyTorch. Jika teman-teman ada yang ingin mengimplementasi [&#8230;]]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">Artikel ini akan langsung berfokus pada implementasi Convolutional Neural Network (CNN) menggunakan <a href="http://pytorch.org/" target="_blank" rel="noreferrer noopener">PyTorch</a> untuk Image Classification. Bagi yang ingin memperdalam teori dibalik CNN terlebih dahulu bisa baca pada link artikel <a aria-label="sebelumnya yang berisi kumpulan sumber belajar CNN (opens in a new tab)" href="https://structilmy.com/2018/12/how-do-i-learn-neural-network-and-deep-learning/" target="_blank" rel="noreferrer noopener">sebelumnya yang berisi kumpulan sumber belajar CNN</a> dan jika ingin memperdalam PyTorch, juga bisa <a aria-label="baca artikel sebelumnya tentang PyTorch (opens in a new tab)" href="https://structilmy.com/2019/07/tutorial-dasar-pytorch-tensor-dan-autograd/" target="_blank" rel="noreferrer noopener">baca artikel sebelumnya tentang PyTorch</a>. Jika teman-teman ada yang ingin mengimplementasi menggunakan Tensorflow, silakan <a href="https://structilmy.com/2021/01/image-classification-dengan-cnn-dan-tensorflow/">baca artikel ini</a>.</p>



<h2 class="wp-block-heading">Dataset</h2>



<p class="wp-block-paragraph">Kita akan menggunakan Convolutional Neural Network untuk mengklasifikasi citra barang-barang yang ada di sebuah toko (Freiburg Groceries Dataset). Dataset dan code bisa didownload di <a rel="noreferrer noopener" aria-label="repository berikut (opens in a new tab)" href="https://github.com/rianrajagede/groceries_classification" target="_blank">repository berikut</a>. </p>



<p class="wp-block-paragraph">Dataset yang digunakan jumlahnya akan lebih sedikit dari dataset asli agar mempercepat proses pelatihan. Dataset pada repo yang kita gunakan hanya terdiri dari 5 kelas, yakni citra produk Susu (MILK), Air mineral (WATER), soda (SODA), jus (JUICE), dan cuka (VINEGAR), dengan sekitar 900-an gambar untuk pelatihan dan 120 gambar untuk pengujian. Semua citra berukuran sama, yakni 256&#215;256 pixel.</p>


<div class="wp-block-image">
<figure class="aligncenter"><img data-recalc-dims="1" loading="lazy" decoding="async" width="256" height="256" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2019/07/MILK0152.png?resize=256%2C256&#038;ssl=1" alt="Convolutional Neural Network Data" class="wp-image-1185" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2019/07/MILK0152.png?w=256&amp;ssl=1 256w, https://i0.wp.com/structilmy.com/wp-content/uploads/2019/07/MILK0152.png?resize=150%2C150&amp;ssl=1 150w" sizes="auto, (max-width: 256px) 100vw, 256px" /><figcaption>salah satu citra dengan kelas &#8220;MILK&#8221;</figcaption></figure>
</div>


<p class="wp-block-paragraph">Kita akan menggunakan dataset yang ada pada folder &#8220;train&#8221; untuk pelatihan dan yang ada pada folder &#8220;test&#8221; untuk pengujian. Pada tutorial ini kita masih belum menggunakan teknik validasi seperti menggunakan data validasi atau cross-validation.</p>



<h2 class="wp-block-heading">Pengolahan Dataset di PyTorch</h2>



<p class="wp-block-paragraph">Untuk pengolahan citra ada dua package dari python yang bisa kita gunakan, yakni `torchvision.datasets` dan `torchvision.transforms`</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">from torchvision import transforms, datasets</pre>



<span id="more-1174"></span>



<h4 class="wp-block-heading">Datasets dan Transforms</h4>



<p class="wp-block-paragraph">Kita gunakan `datasets` untuk memudahkan proses pembacaan data. Dengan struktur folder seperti yang ada di repo (terkelompok untuk setiap kelas) maka dengan datasets kita bisa menyimpan data beserta label dengan mudah. Sedangkan `transforms` kita gunakan untuk pengolahan awal dataset. </p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">train_dir = "train/"
test_dir = "test/"

train_transform = transforms.Compose([
    transforms.CenterCrop(150),
    transforms.RandomRotation(5), 
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
test_transform = transforms.Compose([
    transforms.CenterCrop(150),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])

train_img = datasets.ImageFolder(train_dir, transform=train_transform)
test_img = datasets.ImageFolder(test_dir, transform=test_transform)</pre>



<p class="wp-block-paragraph">Pada contoh di atas, saya baca dataset pada folder train dan test menggunakan `datasets.ImageFolder()` lalu masing-masingnya kita beri pengolahan yang telah saya definisikan. Misalnya pada data train, pengolahan yang saya lakukan menggunakan `train_transform`:</p>



<ol class="wp-block-list"><li>crop citra menjadi ukuran 150&#215;150</li><li>lalu secara random beberapa data saya rotasi 5 derajat</li><li>beberapa data juga secara random saya cerminkan secara horizontal</li><li>saya ubah citra menjadi tensor 3D (3 x 150 x 150)</li><li>saya normalisasi masing-masing channel sehingga rata-rata dan standar deviasinya bernilai 0.5</li></ol>



<p class="wp-block-paragraph">Setelah terbaca menggunakan `datasets` maka citra-citra kita akan ter-load sebagai objek `torch.datasets` yang mirip dengan list of tuple. Setiap tuple bagian pertama adalah tensor citra, dan bagian kedua adalah label citra tersebut.</p>



<p class="wp-block-paragraph">Kita bisa print informasi dari dataset kita dengan perintah berikut:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">print("train_img type   :",type(train_img)) # objek datasets
print("train_img length :",len(train_img)) # 940 data train
print("test_img length :",len(test_img)) # 120 data test
print("train_img classes:",train_img.classes) # nama kelas
print("train_img[0] type:",type(train_img[0])) # tuple
print("train_img[0][0] s:",train_img[0][0].size()) # tensor citra
print("train_img[0][1]  :",train_img[0][1]) # label</pre>



<p class="wp-block-paragraph">Objek datasets tersebut, kita ubah bentuknya menjadi `DataLoader` yang akan memudahkan proses batch ketika pelatihan nantinya.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">trainloaders = torch.utils.data.DataLoader(train_img, batch_size=64, shuffle=True)
testloaders = torch.utils.data.DataLoader(test_img, batch_size=32, shuffle=True)</pre>



<h2 class="wp-block-heading">Implementasi Convolutional Neural Network</h2>



<p class="wp-block-paragraph">Ada 3 bagian utama dalam implementasi CNN menggunakan PyTorch:</p>



<ol class="wp-block-list"><li>Class Model / Arsitektur CNN</li><li>Alur pelatihan</li><li>Alur pengujian</li></ol>



<h4 class="wp-block-heading">Arsitektur CNN (Teori)</h4>


<div class="wp-block-image">
<figure class="aligncenter size-large is-resized"><img loading="lazy" decoding="async" src="https://i2.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn1.png?fit=1024%2C328&amp;ssl=1" alt="" class="wp-image-1526" width="582" height="185" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn1.png?w=1103&amp;ssl=1 1103w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn1.png?resize=300%2C96&amp;ssl=1 300w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn1.png?resize=1024%2C328&amp;ssl=1 1024w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/03/cnn1.png?resize=768%2C246&amp;ssl=1 768w" sizes="auto, (max-width: 582px) 100vw, 582px" /><figcaption>Ilustrasi CNN untuk klasifikasi citra ke 3 kelas (hanya contoh, berbeda dengan arsitektur yang akan digunakan pada artikel ini)</figcaption></figure>
</div>


<p class="wp-block-paragraph">Pada tutorial ini, kita akan menggunakan model CNN dengan dua convolutional layer dan sebuah fully connected layer. Dengan detail parameter setiap layer sebagai berikut:</p>



<figure class="wp-block-image size-large"><img data-recalc-dims="1" loading="lazy" decoding="async" width="677" height="550" src="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/06/convdiagram-2.png?resize=677%2C550&#038;ssl=1" alt="" class="wp-image-1670" srcset="https://i0.wp.com/structilmy.com/wp-content/uploads/2020/06/convdiagram-2.png?w=677&amp;ssl=1 677w, https://i0.wp.com/structilmy.com/wp-content/uploads/2020/06/convdiagram-2.png?resize=300%2C244&amp;ssl=1 300w" sizes="auto, (max-width: 677px) 100vw, 677px" /><figcaption><em>W = window size, S = stride, P = padding, FM = feature map, N = jumlah neuron</em></figcaption></figure>



<p class="wp-block-paragraph">Pada proses konvolusi atau pooling, parameter window size, pooling size, stride, dan padding akan menentukan perubahan ukuran data setelahnya.  Ukuran data setelah proses konvolusi atau pooling  dapat dihitung dengan menggunakan rumus berikut:</p>



<p class="wp-block-paragraph">$$ UkuranAkhir  =\frac{UkuranAwal &#8211; W + 2P}{S} + 1 $$</p>



<p class="wp-block-paragraph">Rumus tersebut dihitung untuk setiap sisi citra. Sebagai contoh di atas, citra memiliki ukuran panjang x lebar (150 x 150). Pada layer Conv1 ukuran awal sisi panjang citra adalah 150. Dikarenakan nilai sisi panjang W = 3, lalu nilai  P = 0, dan S = 1, diperoleh sisi panjang citra setelah proses adalah 148. Karena citra input memiliki sisi lebar yang sama, yakni 150, maka sisi lebar citra dihitung dengan cara dan diperoleh Conv1 adalah 148. Sehingga diperoleh hasil proses konvolusi berukuran 148 x 148 x 32 (dari 32 feature maps). Proses ini juga dilakukan di layer Pool1, Conv2, dan Pool2 dengan UkuranAwal adalah UkuranAkhir dari layer sebelumnya.</p>



<h4 class="wp-block-heading">Arsitektur CNN (Praktik)</h4>



<p class="wp-block-paragraph">Pembuatan model pada PyTorch dilakukan dengan menyusun urutan layer dan perhitungan yang akan terjadi. Model yang digunakan biasanya dalam bentuk Class dengan sebuah fungsi `forward(x)` untuk menghitung proses forward propagation</p>



<p class="wp-block-paragraph">Sebelum mendefinsikan model beberapa library perlu yang diimport untuk pembentukan model, yakni:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">import torch
import torch.nn as nn
import torch.nn.functional as F</pre>



<p class="wp-block-paragraph">Lalu untuk membuat modelnya kita buat dengan mendefinisikan class berikut:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">class Net(nn.Module):
   
    def __init__(self):
        super(Net, self).__init__()

        self.conv1 = nn.Conv2d(3, 16, kernel_size=4, stride=1, padding=0)
        self.pool = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=0)
        self.fc1 = nn.Linear(39200, 512)
        self.fc2 = nn.Linear(512, 5)
        self.do = nn.Dropout()
    
    def forward(self, x):
        ## Define forward behavior
        x = self.pool(F.relu(self.conv1(x))) # (A)
        x = self.pool(F.relu(self.conv2(x))) # (B)
        x = x.reshape(x.shape[0], -1) # (C)
        x = self.do(F.relu(self.fc1(x))) # (D)
        x = self.fc2(x) # (E)
        return x</pre>



<p class="wp-block-paragraph">Bisa dilihat pada class tersebut, terdapat dua komponen utama. Pada bagian `__init__` kita mendefinisikan layer-layer yang akan digunakan. Sedangkan pada bagian `forward` kita definisikan bagaimana struktur dan alur forward propagation neural networknya dengan input suatu data `x`.</p>



<p class="wp-block-paragraph">Jadi keliatan, pada bagian (A) awalnya `x` masuk layer `conv1`, lalu kena fungsi aktivasi ReLU, lalu pooling. Lalu dilanjut juga pada bagian (B) juga sama. Pada bagian (C) dilakukan proses flattening atau perataan input yang berbentuk array multi dimensi menjadi satu dimentsi. Pada bagian (D) model masuk ke hidden layer dan bagian (E) adalah output layer</p>



<p class="wp-block-paragraph">Setelah class tersebut jadi, untuk membuat model kita cukup membuat sebuah objek baru dari class tersebut</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">model = Net()</pre>



<h4 class="wp-block-heading">Alur Pelatihan</h4>



<p class="wp-block-paragraph">Kita mulai dengan definisikan terlebih dahulu algoritma dan parameter pelatihan:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">criterion = nn.CrossEntropyLoss() # loss function
optimizer = torch.optim.Adam(model.parameters()) # algoritma backprop
epoch = 20 # iterasi pelatihan</pre>



<p class="wp-block-paragraph">Karena kita akan menggunakan GPU, maka jangan lupa juga pindahkan model kita ke GPU dengan cara berikut:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">model = model.to("cuda")</pre>



<p class="wp-block-paragraph">Mengikuti stylenya Alfredo Canziani, profesor di NYU, untuk implementasi pelatihan di PyTorch ada<a href="https://www.youtube.com/watch?v=OMDn66kM9Qc&amp;t=532s" target="_blank" rel="noreferrer noopener"> 5 langkah besar pada prosesnya</a>:</p>



<ol class="wp-block-list"><li>Forward Propagation</li><li>Hitung error</li><li>Bersihkan gradient</li><li>Backpropagation error / Menghitung gradient</li><li>Update bobot </li></ol>



<p class="wp-block-paragraph">Kelima langkah tersebut diimplemetnasikan menggunakan kode di bawah. Dapat diperhatikan ada dua iterasi besar yang terjadi, iterasi pertama untuk banyak epoch sedangkan iterasi kedua menunjukkan berapa kali terjadinya backpropagation yang dilakukan setiap mini-batch dari data training (`trainloaders`).</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">model.train()
for i in range(epoch):
    total_loss = 0
    total_sample = 0
    total_correct = 0

    for image, label in trainloaders: # data tiap batch (64 citra)
        # image adalah tensor berukuran 64 x 3 x 150 x 150
        # label adalah tensor berukuran 64 x 1

        image = image.to('cuda') # pindahkan image ke GPU
        label = label.to('cuda') # pindahkan label ke GPU

        out = model(image) # LANGKAH 1: forward propagation
        loss = criterion(out, label) # LANGKAH 2: hitung error
        optimizer.zero_grad() # LANGKAH 3: bersihkan nilai gradient sisa komputasi
        loss.backward() # LANGKAH 4: backpropagation
        optimizer.step() # LANGKAH 5: update bobot berdasar algoritma optimizer

        total_loss += loss.item() # untuk merata2 eror
        total_sample += len(label) # untuk merata2 eror dan akurasi
        total_correct += torch.sum(torch.max(out,1)[1]==label).item()*1.0 # untuk merata2 eror akurasi

    print("epoch", i, total_loss/total_sample, total_correct/total_sample) # menampilkan rata2 eror dan akurasi tiap epoch</pre>



<p class="wp-block-paragraph">Jika tidak terjadi masalah maka akan tampak nilai rata-rata eror akan terus menurun dan rata-rata akurasi akan terus meningkat. Saya melakukan pelatihan di laptop saya ASUS A455L dengan GPU Nvidia 920m, lama pelatihan untuk 20 iterasi tidak sampai setengah jam.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="generic" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">epoch 0 0.03158918555746687 0.30638297872340425
epoch 1 0.021654276264474748 0.39787234042553193
epoch 2 0.01974692699757028 0.46702127659574466
...
epoch 18 0.004239923189929191 0.8978723404255319
epoch 19 0.0036402822967539442 0.9287234042553192</pre>



<h4 class="wp-block-heading">Alur Pengujian</h4>



<p class="wp-block-paragraph">Setelah model selesai dilatih, maka kita akan uji dengan data test. Data test yang belum kita gunakan ini saya pilih secara acak dari masing-masing kelas dan tidak ada di data train.</p>



<p class="wp-block-paragraph">Proses pengujian tidak beda banyak dengan pelatihan, kita cukup memastikan tidak terjadi backpropagation ataupun update bobot pada saat pengujian. Hal ini dilakukan dengan mengubah status model menjadi `eval()` dan menghapus bagian backprop.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">model.eval()
total_loss = 0
total_sample = 0    
total_correct = 0

for image, label in testloaders:
    image = image.to("cuda")
    label = label.to("cuda")
    
    out = model(image)
    loss = criterion(out, label)

    total_loss += loss.item()
    total_sample += len(label)
    total_correct += torch.sum(torch.max(out, 1)[1] == label).item()*1.0

print("test loss", total_loss/total_sample)
print("test accuracy", total_correct/total_sample)</pre>



<p class="wp-block-paragraph">Jika kode di atas dijalankan akan menampilkan akurasi model kita. Di laptop saya akurasi yang muncul adalah sekitar 70%. Akurasi ini sudah lebih &#8220;cerdas&#8221; daripada sekadar menebak kelas secara random. Akurasi ini sudah cukup bagus menurut saya mengingat data yang cukup sulit dan model yang sangat simpel. </p>



<p class="wp-block-paragraph">Apakah akurasi ini masih bisa ditingkatkan? insyaAllah.. silakan coba ganti-ganti arsitektur dan parameter untuk mendapatkan akurasi yang lebih baik (disebut Tuning Parameter). Misalnya dengan mengubah algoritma, jumlah neuron, atau banyak epoch. Beberapa eksperimen harus dilakukan untuk menjadikan akurasi kita benar-benar baik dan valid.</p>



<p class="wp-block-paragraph">Kita akan coba meningkatkan akurasi model kita dengan beberapa teknik di artikel selanjutnya <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" /></p>



<p class="wp-block-paragraph"><sub>Featured image: Photo by <a href="https://unsplash.com/@birminghammuseumstrust?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Birmingham Museums Trust</a> on <a href="https://unsplash.com/?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></sub></p>
]]></content:encoded>
					
					<wfw:commentRss>https://structilmy.com/blog/2019/07/17/convolutional-neural-network-cnn-menggunakan-pytorch/feed/</wfw:commentRss>
			<slash:comments>2</slash:comments>
		
		
		<post-id xmlns="com-wordpress:feed-additions:1">1174</post-id>	</item>
		<item>
		<title>Tutorial Dasar PyTorch : Tensor dan Autograd</title>
		<link>https://structilmy.com/blog/2019/07/11/tutorial-dasar-pytorch-tensor-dan-autograd/</link>
					<comments>https://structilmy.com/blog/2019/07/11/tutorial-dasar-pytorch-tensor-dan-autograd/#respond</comments>
		
		<dc:creator><![CDATA[Rian Adam]]></dc:creator>
		<pubDate>Wed, 10 Jul 2019 21:14:50 +0000</pubDate>
				<category><![CDATA[Machine Learning]]></category>
		<category><![CDATA[Tutorial]]></category>
		<category><![CDATA[Python]]></category>
		<category><![CDATA[pytorch]]></category>
		<guid isPermaLink="false">http://structilmy.com/?p=1175</guid>

					<description><![CDATA[Saya mulai menggunakan PyTorch semenjak mengerjakan Tesis di tahun 2017 akhir. PyTorch merupakan pengembangan dari Torch Framework yang dikembangkan oleh Facebook dan difokuskan sebagai framework berbahasa Python untuk proses komputasi Machine Learning, sehingga bisa disandingkan dengan framework sejenis seperti Tensorflow (dikembangkan oleh Google), Keras, Theano (sudah tidak dikembangkan), Caffe2, dan lainnya. Menurut saya salah satu [&#8230;]]]></description>
										<content:encoded><![CDATA[
<p class="wp-block-paragraph">Saya mulai menggunakan <a href="https://pytorch.org/">PyTorch</a> semenjak mengerjakan Tesis di tahun 2017 akhir. PyTorch merupakan pengembangan dari Torch Framework yang  dikembangkan oleh Facebook dan difokuskan sebagai framework berbahasa Python untuk proses komputasi Machine Learning, sehingga bisa disandingkan dengan framework sejenis seperti Tensorflow (dikembangkan oleh Google), Keras, Theano (sudah tidak dikembangkan), Caffe2, dan lainnya.</p>



<p class="wp-block-paragraph">Menurut saya salah satu keunggulan PyTorch dibanding framework lain adalah sintaks yang digunakan tidak terlalu beda dengan fungsi-fungsi pada Numpy, bahkan rasanya dia memiliki sintaks yang lebih rapi dan sederhana</p>



<p class="wp-block-paragraph">Untuk memulai belajar PyTorch, menurut saya ada dua komponen utama yang perlu dipahami terlebih dahulu, yakni Tensor dan Autograd. </p>



<h2 class="wp-block-heading">PyTorch Tensor</h2>



<p class="wp-block-paragraph">Tensor adalah sebuah tipe data atau class yang merepresentasikan sebuah array, atau tepatnya ndimensional array karena tidak terbatas pada dimensi-dimensi tertentu. Pada contoh di bawah adalah tensor dengan dimensi 1 bernilai [1,2,3]</p>



<span id="more-1175"></span>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">import torch
t = torch.tensor([1,2,3])
print(t)</pre>



<p class="wp-block-paragraph">Sebuah tensor pada PyTorch dapat dibuat dengan tiga cara:</p>



<ol class="wp-block-list"><li>Diberi langsung nilai arraynya</li><li>Generate dengan fungsi bawaan (misalnya random)</li><li>Diconvert dari Numpy array</li></ol>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">t = torch.tensor([1,2,3]) # cara 1
print(t)
t = torch.rand(3,4) # cara 2
print(t)
x = numpy.array([[2.5, 3.2],[1.0,1.9]]) # cara 3
t = torch.from_numpy(x)
print(t)</pre>



<p class="wp-block-paragraph">Class Tensor dapat dikenali dari tipenya. Jika digunakan fungsi bawaan Python `type(x)` maka akan diberitahu bahwa x adalah class tensor dari PyTorch. Namun, itu hanya sebatas menginfokan bahwa x adalah tensor, tetapi tidak menampilkan tipe dari elemen yang terkandung di dalamnya. Untuk menampilkan tipe data dari elemennya gunakan `.type()` bawaan dari PyTorch:</p>





<p class="wp-block-paragraph">Untuk mengubah tipe, gunakan parameter `dtype`</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">t = torch.tensor([1,2,3], dtype=torch.float32)
print(t.type())
# output : torch.FloatTensor</pre>



<p class="wp-block-paragraph">Class Tensor yang merupakan bawaan PyTorch tentu masih terbatas dan tidak bisa disamakan dengan Numpy array atau Python list. Untuk itu jika terdapat fungsi yang belum ada pada PyTorch yang kita butuhkan, proses konversi bisa dilakukan (fungsi tambahan `clone()` diperlukan untuk menghindari <em>pass by reference</em>).</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">t = torch.tensor([1,2,3], dtype=torch.float32)

n = t.clone().numpy()   # dari tensor ke numpy
print(type(n))

new_t = torch.tensor(n).clone() # dari numpy ke tensor
print(type(new_t))</pre>



<h3 class="wp-block-heading">Tensor Operation</h3>



<p class="wp-block-paragraph">Operasi yang dapat dilakukan pada Numpy hampir semua sudah bisa dilakukan di Tensor, meskipun beberapa memiliki penulisan sintaks yang berbeda. Berikut beberapa operasi sederhana pada tensor</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">t = torch.tensor([[1,2,3],[4,5,6],[7,8,9]])
print(t)

# variasi operasi dasar: penjumlahan
t += 1
print(t)
t.add_(2)
print(t)
new_t = t + 2
print(new_t)
new_t = torch.add(t,2)
print(new_t)

# slicing
print(t[0,1:]) # baris pertama, kolom kedua sampai habis
print(t[:,[1,2]]) # semua baris, kolom index 1 dan 2
print(t[[0,2],1:]) # baris index 0 dan 2, kolom kedua sampai habis

# dua tensor
s = torch.tensor([[1,2],[3,4],[5,6]])
print(torch.mm(t,s)) # perkalian dua matriks
s = torch.ones((3,3), dtype=torch.long)
print(s + t) # penjumlahan dua matriks

# fungsi lain-lain
print(t.view(9)) # resize dari 3x3 menjadi 1x9 (satu dimensi)
print(t.view(3,1,3)) # resize menjadi 3x1x3 (tiga dimensi)
print(t.sum()) # menjumlahkan semua elemennya
print(t.sum(dim=0)) # menjumlahkan per kolom</pre>



<p class="wp-block-paragraph">Terdapat lebih dari 100 operasi yang bisa dilakukan Tensor, untuk info lebih lengkap silakan kujungi halaman dokumentasi resmi Tensor: <a href="https://pytorch.org/docs/stable/tensors.html">https://pytorch.org/docs/stable/tensors.html</a></p>



<h2 class="wp-block-heading">Autograd</h2>



<p class="wp-block-paragraph">Autograd adalah sebuah package yang memudahkan dalam melakukan perhitungan turunan (diferensial). Turunan adalah bagian penting pada Machine Learning khususnya Neural Network, contohnya untuk Backpropagation (<a href="https://structilmy.com/2019/07/contoh-perhitungan-algoritma-backpropagation/">contoh perhitungan backpropagation bisa dilihat di artikel ini</a>).</p>



<p class="wp-block-paragraph">Tensor memiliki sebuah attribut `.requires_grad` yang secara default bernilai `False`. Jika `.requires_grad` diberi nilai `True` maka operasi-operasi yang terjadi pada tensor tersebut akan dicatat, sehingga memungkinkan untuk dilakukan operasi turunan yang berantai.</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">t = torch.tensor([1,2,3], dtype=torch.float32)
print(t.requires_grad)
# output : False</pre>



<p class="wp-block-paragraph">Berikut ini kita coba gunakan autograd untuk menghitung turunan. Misalnya kita punya persamaan berikut:</p>



<p class="wp-block-paragraph">$$ z = 2x^2 + y^3 $$</p>



<p class="wp-block-paragraph">Sehingga misal nilai x awalnya adalah 2 dan y adalah 3, maka dapat kita hitung turunan untuk masing-masing variabel adalah:</p>



<p class="wp-block-paragraph">$$ \frac{dz}{dx} = 4x + 0 = 4(2) = 8$$</p>



<p class="wp-block-paragraph">$$ \frac{dz}{dy} = 0 + 3y^2 = 3(3)^2 = 27 $$</p>



<p class="wp-block-paragraph">jika proses ini dilakukan menggunakan kode:</p>



<pre class="EnlighterJSRAW" data-enlighter-language="python" data-enlighter-theme="" data-enlighter-highlight="" data-enlighter-linenumbers="" data-enlighter-lineoffset="" data-enlighter-title="" data-enlighter-group="">x = torch.tensor(2, dtype=torch.float32, requires_grad=True)
y = torch.tensor(3, dtype=torch.float32, requires_grad=True)
z = 2*x**2 + y**3
z.backward()   # proses diferensial/autograd
print(x.grad)  # hasil dz/dx = 8
print(y.grad)  # hasil dz/dy = 27</pre>



<p class="wp-block-paragraph">Sekian tutorial singkat PyTorch Tensor dan Autograd, semoga bermanfaat <img src="https://s.w.org/images/core/emoji/17.0.2/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" /></p>



<p class="has-small-font-size wp-block-paragraph">sumber gambar: flickr</p>
]]></content:encoded>
					
					<wfw:commentRss>https://structilmy.com/blog/2019/07/11/tutorial-dasar-pytorch-tensor-dan-autograd/feed/</wfw:commentRss>
			<slash:comments>0</slash:comments>
		
		
		<post-id xmlns="com-wordpress:feed-additions:1">1175</post-id>	</item>
	</channel>
</rss>

<!--
Performance optimized by W3 Total Cache. Learn more: https://www.boldgrid.com/w3-total-cache/?utm_source=w3tc&utm_medium=footer_comment&utm_campaign=free_plugin

Object Caching 0/237 objects using Memcache
Page Caching using Disk: Enhanced 
Database Caching using Redis (Request-wide modification query)

Served from: structilmy.com @ 2026-11-17 06:56:54 by W3 Total Cache
-->