Monday, December 31, 2018

Buku Belajar Machine Learning dengan Python- Simple Adaptive Boosting


Seiring dengan meningkatnya traffic dan kemudahan dalam mengelola content, kami mengucapkan banyak terima kasih kepada para pembaca setia pada blog www.softscients.web.id

Per 19 Maret 2020, kami sedang melakukan migrasi ke domain dan hosting yang lebih baik yaitu
Semoga dengan alamat domain dan hosting terbaru akan semakin memudahkan para pembaca dalam mencari materi/content. Migrasi dilakukan secara bertahap yang membutuhkan waktu yang cukup lama jadi jangan kuatir selama migrasi akan dilakukan secara hati-hati untuk memimalkan broken link

Bahasan mengenai apa itu adaptive boosting http://cmp.felk.cvut.cz/%7Esochmj1/adaboost_talk.pdf
Algoritma ini disesuaikan dengan persamaan umum dari adaboost yaitu


Wednesday, December 19, 2018

Buku Belajar Mudah Python dengan Package Open Source



Tempat Beli Buku

  1. https://www.bukalapak.com/p/hobi-koleksi/buku/komputer-487/wco01c-jual-belajar-mudah-python-dengan-package-open-source-mulkan-syarif-graha-ilmu
  2. https://www.tokopedia.com/bukukuliahan/belajar-mudah-python-dengan-package-open-source-mulkan-syarif
  3. https://togamas.com/detail-buku-8585=Belajar_Mudah_Python_dengan_Package_Open_Source_
  4. https://petramas.co.id/product/belajar-mudah-python-dengan-package-open-source-a8c4  



Kemarin banyak yang nanya2 mengenai ulasan singkatan, Buku  ini saya buat berdasarkan pengalaman menangani beragam project yang meliputi topik bahasan seperti machine learning, computer vision yang biasanya menggunakan Matlab. Dengan berkembangnya Python sebagai bahasa yang familiar untuk machine learning, maka saya sarankan menggunakan Python karena kelengkapan library nya.

Pembahasan mulai dari instalasi menggunakan Anaconda Navigator (pada buku-buku terbitan lain tidak membahas mengenai Anaconda Navigator) padahal dengan Anaconda Navigator sudah tersedia banyak sekali package-package untuk komputasi teknis, olah data, serta grafik!

Dengan membaca ini, kalian cukup menggunakan Spyder yang merupakan Editor canggih saat ini untuk menulis kode di Python. Kalian tidak perlu menggunakan Visual Code, JetBrain, Netbeans untuk mencoba menulis kode Python.

Pada bab selanjutnya dikenalkan Numpy, Pandas, Matlotlib, Scipy, serta OpenCV. Itu adalah package yang sering menjadi topik dasar pada saat ini yaitu AI, Machine Learning, serta Deep Learning kalau anda menginginkan topik diatas.

Jadi kalian tidak perlu menggunakan PIP Package Manager atau repot-repot melakukan install package tersendiri lho!

Jadi buku kecil ini menjadi semakin menarik dan bermanfaat untuk anda beli dan koleksi!!

Penulis menerbitkan buku belajar dasar-dasar python di penerbit Graha Ilmu (www.grahailmu.id) yang merupakan penerbit yang sudah dikenal dengan terbitan buku-buku yang bermutu yang bekerjsama dengan thesimplybook

Cek Katalog di www.GrahaIlmu.id
http://grahailmu.id/Katalog-GrahaIlmu.xls
per 23 November 2018



Bukalapak:
https://www.bukalapak.com/p/hobi-koleksi/buku/komputer-487/wco01c-jual-belajar-mudah-python-dengan-package-open-source-mulkan-syarif-graha-ilmu

Toga mas:
  1. https://togamas.com/detail-buku-8585=Belajar_Mudah_Python_dengan_Package_Open_Source_
  2. https://petramas.co.id/product/belajar-mudah-python-dengan-package-open-source-a8c4
  3. Buku Belajar Mudah Python dengan Package Open Source



ISBN : 978-602-5759-74-1

Sinopis

Python merupakan bahasa intrepreter yang banyak digunakan untuk kepentingan akademis, riset, bahkan para praktisi umum dikarenakan tersedianya package-package yang siap pakai mulai dari untuk komputasi numerik, array, olah grafik, sinyal, machine learning, dan computer vision. Kemudahan managemen instalasi package tersebut dikarenakan adanya Anaconda Navigator yang mampu mengintegrasikan semua package dengan lebih mudah bagi pemula sekalipun.

Buku ini memfokuskan diri tidak hanya membahas dasar-dasar bahasa Python tapi lebih luas lagi yaitu mengajak pembaca menggunakan package-package yang sudah default terinstal di Anaconda Navigator dan beberapa package tambahan terpisah yaitu
  1. Python
  2. IDE Spyder sebagai Editor
  3. Package Numpy untuk perhitungan array
  4. Package Matplolib untuk visualisasi grafis
  5. Package Pandas untuk pengolahan data terstruktur
  6. Package Scipy untuk pengolahan data statistika
  7. Package OpenCV (instal tersendiri)

https://www.bukalapak.com/p/hobi-koleksi/buku/komputer-487/wco01c-jual-belajar-mudah-python-dengan-package-open-source-mulkan-syarif-graha-ilmu

Daftar Isi

BAB 1 ANACONDA 1

1.1 Pengenalan Anaconda 1
1.2 Instalasi Anaconda 4
1.3 Environment Anaconda Navigator 7

BAB 2 PYTHON DAN EDITOR SPYDER 9

2.1 PengenalanInterpreter Python 9
2.2 Pengenalan Bahasa Python 14
2.3 Tipe Data Terstruktur 17
2.4 Control Flow 24
2.5 Pengenalan Function 27
2.6 Pengenalan Class 28
2.7 Manajemen Modul/Package 31

BAB 3 NUMPY 35

3.1 Import package 35
3.2 Membuat Array 35
3.3 Pengenalan Operasi Array 39
3.4 Contoh Kasus Penggunaan Array 50

BAB 4 MATPLOTLIB 57

4.1 Line Plot 58
4.2 Bar Plot 64
4.3 Line Area 67
4.4 Scatter 68
4.5 Scatter 3D 69
4.6 Contour 71
4.7 Contour Surface 71
4.8 Surface 73

BAB 5 PANDAS 75

5.1 Struktur Data Pandas 75
5.2 Pengenalan Data Frame 77
5.3 Operasi Masking 82

BAB 6 SCIPY 89

6.1 Analisis Korelasi Sederhana 90
6.2 Analisis Regresi Linear 92
6.3 Klustering dan Klasifikasi 94

BAB 7 OPENCV 107

7.1 Cara Install 108
7.2 Membaca dan Menyimpan File Gambar 110
7.3 Integrasi OpenCV dengan Matplotlib 111
7.4 Akses dan Modifikasi Nilai Pixel Gambar 113
7.5 Operasi Transformasi Geometrik 117
7.6 Operasi Segmentasi Gambar 118
7.7 Operasi Filtering Gambar 123
7.8 Operasi Morfologi Gambar 124
7.9 Operasi Pencarian Contour Gambar 129
7.10 Membaca File Video 132

Selain daftar isi buku diatas, kalian juga belajar lagi beberapa tambahan materi/topik dibawah ini

Suplemen

  1. Cleaning Currency Dataset dengan Pandas
  2. Linear Programming dan Simplex
  3. Setup Figure Matplotlib 
  4. Cleanign Dataset dengan Pandas 
  5. PIP manager
  6. Pengacakan Dataset 
  7. Menghitung Confussion Matrix 
  8. Append Array di Numpy 
  9. Serialisasi dan Deserialisasi Object di Python



Tuesday, December 18, 2018

Python-Editor Ringan - Eric


Setelah sekian lama menggunakan Spyder untuk menulis kode Python. Penulis mencoba menggunakan https://python-projects.org/

Monday, December 17, 2018

Python-Arti If __name___


Bagi pengguna awam python, biasanya akan melihat kode seperti berikut
if __name__ == '__main__':
      print('your....')

Apa artinya?

Friday, December 14, 2018

Buku Pengolahan Citra Digital dengan Python dan OpenCV - Merging Binary Object


Seiring dengan meningkatnya traffic dan kemudahan dalam mengelola content, kami mengucapkan banyak terima kasih kepada para pembaca setia pada blog www.softscients.web.id

Per 19 Maret 2020, kami sedang melakukan migrasi ke domain dan hosting yang lebih baik yaitu
Semoga dengan alamat domain dan hosting terbaru akan semakin memudahkan para pembaca dalam mencari materi/content. Migrasi dilakukan secara bertahap yang membutuhkan waktu yang cukup lama jadi jangan kuatir selama migrasi akan dilakukan secara hati-hati untuk memimalkan broken link


kalian bisa lanjut baca lagi di  http://softscients.com/2020/03/30/buku-pengolahan-citra-digital-dengan-python-dan-opencv-merging-binary-object/



Sinopsis

Pengolahan citra digital untuk pada operasi morflogi sangat dibutuhkan sebagai alat bantu pengenalan sebuah pola, misalkan pada mesin OCR (optical character recognition) terutama untuk mengenal karakater/simbol huruf kecil/ huruf kanji/ ataupun huruf dengan simbol yang secara umum 1 huruf terdiri dari 1 objek, misalkan saja huruf kanji/huruf arab yang setiap hurufnya terkadang dibuat beberapa simbol. Operasi ini melibatkan operasi blob, kalian bisa baca link berikut
http://www.softscients.web.id/2016/09/mengenal-contour-retrieval-mode.html

Berikut gambar yang akan digunakan yang merupakan sebuah simbol yang utuh, bila kalian perhatikan ada 2 objek yang tidak saling terhubung. Bila kalian menggunakan operasi Blob, maka akan ada 2 objek yang dikenali (bukan 1 objek)

Buku Pengolahan Citra Digital dengan Python dan OpenCV - Merging Binary Object
Bila dibuat negasi image nya, akan tampil seperti berikut
Buku Pengolahan Citra Digital dengan Python dan OpenCV - Merging Binary Object
Langkah mudahnya yaitu menggunakan teknik rectangle.
Buku Pengolahan Citra Digital dengan Python dan OpenCV - Merging Binary Object
Kalian bisa melihat akan terdeteksi menjadi satu objek secara utuh.
Buku Pengolahan Citra Digital dengan Python dan OpenCV - Merging Binary Object
Kalian bisa menggunakan kode seperti berikut:

import cv2
import numpy as np
from matplotlib import pyplot as plt

plt.close('all')    
img = cv2.imread('D:/5. Project/python-intersection/gambar.png', cv2.IMREAD_GRAYSCALE);
img2 = img.copy()
img3 = img.copy()
cv2.bitwise_not(img,img2)
cv2.bitwise_not(img,img3)
plt.figure()
plt.imshow(img2,cmap='gray')


font = cv2.FONT_HERSHEY_SIMPLEX
ret,thresh = cv2.threshold(img2,127,255,0)
image, contours, _ = cv2.findContours(thresh,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
##################################
#DIGABUNGKAN VIA RECTANGLE
##################################
for contour in contours:
    [x,y,w,h] = cv2.boundingRect(contour)      
    if w > 10 and h>10:
        cv2.rectangle(img2,(x,y),(x+w,y+h),(255,255,0),2)
plt.figure()
plt.imshow(img2,cmap='gray')


##################################
#HASIL AKHIR
##################################

image, contours, _ = cv2.findContours(img2,cv2.RETR_EXTERNAL,cv2.CHAIN_APPROX_SIMPLE)
for contour in contours:
    [x,y,w,h] = cv2.boundingRect(contour)      
    if w > 10 and h>10:
        cv2.rectangle(img3,(x,y),(x+w,y+h),(255,255,0),2)

plt.figure()
plt.imshow(img3,cmap='gray')
plt.show()

ref:
https://www.iwillteachyoualanguage.com

Tuesday, December 11, 2018

Python-Hierarchical Data Format

Bila anda yang menangani big data, pasti akan berkutat pada data yang sangat besar, bagaimana menyimpan data tersebut agar efektif? Yaitu format HDF (Hierarchical Data Format) yang sekarang sudah mencapai versi ke 5 yaitu HDF5 yang mempunyai perbedaan yang cukup signifikan dari sebelumnya.
Struktur HDF5 terdiri 2 tipe utama yaitu
Dataset yaitu multidimensional array
Group yaitu berisi data yang terstruktur
https://en.wikipedia.org/wiki/Hierarchical_Data_Format
Beberapa benefit penggunaan HDF5  https://www.hdfgroup.org/
  1. Heterogeneous Data
  2. Easy Sharing
  3. Cross Platform
  4. Fast I/O
  5. Big Data
  6. Keep Metadata with Data
Nah Python mempunyai interfacing yaitu http://www.h5py.org/, untuk dokumentasinya http://docs.h5py.org/en/stable/index.html
Format h5py tersebut sangat efektif sekali daripada menggunakan format JSON dan YAML

Friday, December 7, 2018

Buku Pengolahan Citra Digital dengan Python dan OpenCV- Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network


Seiring dengan meningkatnya traffic dan kemudahan dalam mengelola content, kami mengucapkan banyak terima kasih kepada para pembaca setia pada blog www.softscients.web.id

Per 19 Maret 2020, kami sedang melakukan migrasi ke domain dan hosting yang lebih baik yaitu
Semoga dengan alamat domain dan hosting terbaru akan semakin memudahkan para pembaca dalam mencari materi/content. Migrasi dilakukan secara bertahap yang membutuhkan waktu yang cukup lama jadi jangan kuatir selama migrasi akan dilakukan secara hati-hati untuk memimalkan broken link


kalian bisa lanjut baca lagi di http://softscients.com/2020/03/30/buku-pengolahan-citra-digital-dengan-python-dan-opencv-pengenalan-angka-tulisan-tangan-dengan-deep-learning-convolutional-network/


Buku Pengolahan Citra Digital dengan Python dan OpenCV- Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network


Sinopsis

Sangat menarik sekali topik pembahasan machine learning yang dikombinasikan penggunaan algoritma computer vision yaitu sesuai dengan judul diatas Pengenalan Angka Tulisan Tangan dengan convolutional network, yups. Kalian akan belajar secara sekilas penerapannya, untuk itu kalian harus install dulu tensorflow  dan keras. Pada tulisan ini dibuat menggunakan versi  
    1. Python -3.6.3 Anaconda
    2. Spyder-3.2.4
    3. tensorflow-1.8.0
    4. keras-2.1.6
    5. OpenCV-4.1.0
    6. Numpy-1.17.4
    7. Matplotlib-3.1.1
    8. PIL-6.1.0 
    Untuk repo anaconda yaitu : https://repo.continuum.io/archive/ kalian pilih yang Anaconda3-5.0.1-Windows-x86_64.exe

        Koq jadi banyak sekali ya modulnya, tapi tenang saja untuk kalian yang belum tahu cara instal dan setup Python bisa kalian beli buku saya disini, Untuk cara install menggunakan PIP bisa ke link disini


        Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network yang dibuat kali ini menggunakan deep learning dengan library tensorflow dan keras yang sudah banyak dibahas hanya saja ditulisan ini dikembangkan dengan menerima input dari mouse agar lebih mudah digunakan sesuai dengan ilustrasi diatas.

        Adapun dataset terdiri dari angka 0-9 dari MNIST berupa tulisan tangan, tenang  saja kalau kalian sudah install Keras sudah ada koq tinggal di load saja (pastikan kalian punya koneksi internet ya). Sebelum membaca postingan ini, sebaiknya anda perlu tahu dasar-dasar python terlebih dahulu. Secara umum tahapan aplikasi ini disingkat saja menjadi 3 tahap yaitu
        1. Persiapan Dataset
        2. Kompilasi Model
        3. Testing

        Persiapan Dataset

        Dataset diambil dari MNIST yang berisi tulisan tangan 0 s.d 9 dengan 60 ribu data training dan 10 ribu data testing dengan ukuran 28x28, untuk cara download datanya di load menggunakan kode berikut

        import keras
        from keras.datasets import mnist
        #load mnist dataset
        (X_train, y_train), (X_test, y_test) = mnist.load_data()

        Alangkah lebih bagusnya disimpan saja dalam format *.npy via spyder

        Buku Pengolahan Citra Digital dengan Python dan OpenCV- Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network


        Kompilasi Model

        Berikut kode lengkapnya mengenai kompilasi model
        1. X merupakan input berupa array 28x28
        2. Y merupakan target dengan format kelas kategori/target kelas misalkan untuk kelas 3 dibuat menjadi vektor  [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]
        Buku Pengolahan Citra Digital dengan Python dan OpenCV- Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network


          # -*- coding: utf-8 -*-
          """
          Created on Sat May 26 22:04:42 2018
          
          """
          
          import keras
          from keras.layers.convolutional import Conv2D
          from keras.layers.convolutional import MaxPooling2D
          from keras.layers import Dense
          from keras.layers import Dropout
          from keras.layers import Flatten
          from keras.layers import Activation
          import numpy as np
          from keras.models import Sequential
          
          
          X_train = np.load('X_train.npy') #database untuk training
          y_train = np.load('y_train.npy')
          
          X_test = np.load('X_test.npy') #database untuk testing
          y_test = np.load('y_test.npy')
          
          img_cols = 28 #ukuran gambar
          img_rows = 28
          
          X_train = X_train.reshape(X_train.shape[0], img_rows, img_cols, 1) #diubah menjadi 4 dimensi
          X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1) #idem
          input_shape = (img_rows, img_cols, 1) 
          
          X_train = X_train.astype('float32')
          X_test = X_test.astype('float32')
          X_train /= 255
          X_test /= 255
          
          num_category = 10
          # convert class vectors to binary class matrices
          y_train = keras.utils.to_categorical(y_train, num_category)
          y_test = keras.utils.to_categorical(y_test, num_category)
          
          model = Sequential()
          #convolutional layer with rectified linear unit activation
          model.add(Conv2D(32, kernel_size=(3, 3),
                           activation='relu',
                           input_shape=input_shape))
          
          model.add(Conv2D(64, (3, 3), activation='relu'))
          
          
          model.add(MaxPooling2D(pool_size=(2, 2)))
          #randomly turn neurons on and off to improve convergence
          model.add(Dropout(0.25))
          #flatten since too many dimensions, we only want a classification output
          model.add(Flatten())
          #fully connected to get all relevant data
          model.add(Dense(128, activation='relu'))
          #one more dropout for convergence' sake :) 
          model.add(Dropout(0.5))
          #output a softmax to squash the matrix into output probabilities
          model.add(Dense(num_category, activation='softmax'))
          
          model.compile(loss=keras.losses.categorical_crossentropy,
                        optimizer=keras.optimizers.Adadelta(),
                        metrics=['accuracy'])
          
          batch_size = 128
          num_epoch = 5
          #model training
          model_log = model.fit(X_train, y_train,
                    batch_size=batch_size,
                    epochs=num_epoch,
                    verbose=1,
                    validation_data=(X_test, y_test))
          
          score = model.evaluate(X_test, y_test, verbose=0)
          print('Test loss:', score[0]) #Test loss: 0.0296396646054
          print('Test accuracy:', score[1]) #Test accuracy: 0.9904
          
          
          #Save the model
          # serialize model to JSON
          model_digit_json = model.to_json()
          with open("model_digit.json", "w") as json_file:
              json_file.write(model_digit_json)
          # serialize weights to HDF5
          model.save_weights("model_digit.h5")
          print("Saved model to disk")
          
          
          print ('done')

          Kalian run dengan Spyder, waktu yang digunakan cukup lama pada sesi pelatihan ini yaitu hampir 10 menit untuk 5 epoch saja! Boros RAM dan prosesor. Biasanya sih saya pakai  Google Colab biar lebih cepat karena komputasi Cloud nya udah pakai VGA Titan yang harga per 1 biji nya saat ini cukup buat beli mobil 1 biji yaitu cuman 100 jutaan saja!


          Hal ini wajar saja karena loading data berupa 60.000 data x 28 baris x 28 kolom jika masing-masing menggunakan type data float32 (8bit) maka dibutuhkan 60.000 x 28 x 28 = 47.040.000 float32 yang cukup menguras sumber daya RAM

          Buku Pengolahan Citra Digital dengan Python dan OpenCV- Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network


          Berikut hasil pelatihan, kalian melihat informasi waktu dan akurasinya dengan tiap epoch akan naik akurasinya!

          Train on 60000 samples, validate on 10000 samples
          Epoch 1/5
          60000/60000 [==============================] - 231s 4ms/step - loss: 0.2731 - acc: 0.9168 - val_loss: 0.0647 - val_acc: 0.9782
          Epoch 2/5
          60000/60000 [==============================] - 220s 4ms/step - loss: 0.0953 - acc: 0.9715 - val_loss: 0.0442 - val_acc: 0.9853
          Epoch 3/5
          60000/60000 [==============================] - 202s 3ms/step - loss: 0.0705 - acc: 0.9788 - val_loss: 0.0343 - val_acc: 0.9876
          Epoch 4/5
          60000/60000 [==============================] - 203s 3ms/step - loss: 0.0566 - acc: 0.9832 - val_loss: 0.0368 - val_acc: 0.9879
          Epoch 5/5
          60000/60000 [==============================] - 197s 3ms/step - loss: 0.0494 - acc: 0.9846 - val_loss: 0.0298 - val_acc: 0.9896
          Test loss: 0.029829543634658784
          Test accuracy: 0.9896
          Saved model to disk
          done

          Kalian bisa melihat hasil pelatihannya berupa 2 file yaitu model_digit.json dan model_digit.h5. Kalau kalian buka *.json akan berisi keterangan deep learning model seperti berikut

          {"class_name": "Sequential", 
          "config": [{"class_name": "Conv2D", 
          "config": {"name": "conv2d_5", "trainable": true, "batch_input_shape": [null, 28, 28, 1], 
          "dtype": "float32", "filters": 32, 
          "kernel_size": [3, 3], "strides": [1, 1], 
          "padding": "valid", "data_format": "channels_last", "dilation_rate": [1, 1], 
          "activation": "relu", "use_bias": true, 
          "kernel_initializer": {"class_name": "VarianceScaling",
           "config": {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, 
           "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, 
           "bias_regularizer": null, "activity_regularizer": null, 
           "kernel_constraint": null, "bias_constraint": null}}, 
           {"class_name": "Conv2D", "config": 
           {"name": "conv2d_6", "trainable": true, "filters": 64, "kernel_size": [3, 3],
           "strides": [1, 1], "padding": "valid", "data_format": "channels_last", "dilation_rate": [1, 1],
           "activation": "relu", "use_bias": true, "kernel_initializer": {"class_name": "VarianceScaling", "config": 
           {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, "bias_initializer": {"class_name": "Zeros", "config": {}}, 
           "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, 
           {"class_name": "MaxPooling2D", "config": {"name": "max_pooling2d_3", "trainable": true, "pool_size": [2, 2], 
           "padding": "valid", "strides": [2, 2], "data_format": "channels_last"}}, 
           {"class_name": "Dropout", "config": {"name": "dropout_5", "trainable": true, "rate": 0.25, "noise_shape": null, "seed": null}}, 
           {"class_name": "Flatten", "config": {"name": "flatten_3", "trainable": true}}, {"class_name": "Dense", 
           "config": {"name": "dense_5", "trainable": true, "units": 128, "activation": "relu", "use_bias": true, 
           "kernel_initializer": {"class_name": "VarianceScaling", "config": {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, 
           "bias_initializer": {"class_name": "Zeros", "config": {}}, 
           "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, 
           {"class_name": "Dropout", "config": {"name": "dropout_6", "trainable": true, "rate": 0.5, "noise_shape": null, "seed": null}},
           {"class_name": "Dense", "config": {"name": "dense_6", "trainable": true, "units": 10, "activation": "softmax", "use_bias": true, 
           "kernel_initializer": {"class_name": "VarianceScaling", "config": {"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, 
           "bias_initializer": {"class_name": "Zeros", "config": {}}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, 
           "kernel_constraint": null, "bias_constraint": null}}], "keras_version": "2.1.5", "backend": "tensorflow"}

          Sedangkan model_digit.h5 berisi angka bobot dan bias yang ukurannya sangat besar sekali yaitu 4.7 MB, kalau kalian tertarik deep learning cnn (convolutional network) bisa dipelajari di http://cs231n.github.io/convolutional-networks/

          Testing

          Kalian tentu ingin segera mencobanya untuk dataset asing, nah kalian bisa coba dengan kode berikut

          from matplotlib import pyplot as plt
          from keras.models import model_from_json
          import numpy as np
          
          X_test = np.load('X_test.npy')
          y_test = np.load('y_test.npy')
          
          
          img_cols = 28
          img_rows = 28
          
          
          
          X_test = X_test.reshape(X_test.shape[0], img_rows, img_cols, 1)
          input_shape = (img_rows, img_cols, 1)
          X_test = X_test.astype('float32')
          X_test /= 255
          
          
          # Model reconstruction from JSON file
          with open('model_digit.json', 'r') as f:
              model = model_from_json(f.read())
          
          # Load weights into the new model
          model.load_weights('model_digit.h5')
          
          no_sample  = 15
          #membuat input 4 dimensi
          n2=np.full([1,img_rows,img_cols,1],X_test[no_sample])
          hasil = model.predict(n2)
          plt.imshow(X_test[no_sample,:,:,0],cmap='gray')
          #mencari nilai maksimalnya
          plt.title('Prediksi Angka : '+str(np.argmax(hasil)))
          

          Hasil akan ditampilkanya menggunakan Matplotlib

          Buku Pengolahan Citra Digital dengan Python dan OpenCV- Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network

          Wow cukup berhasil bukan bahwa Pengenalan Angka Tulisan Tangan dengan convolutional network sudah kalian lakukan dengan baik! Mari kalian coba dengan gambar lainnya

          Buku Pengolahan Citra Digital dengan Python dan OpenCV- Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network


          Pembuatan Painter

          Tentu aplikasi diatas yang berbasis CLI (cuman kode doank) tidak menarik, harus kalian kembangkan menjadi sebuah aplikasi yang bagus, Contohnya kalian bisa membuat aplikasi painter seperti berikut ini

          Buku Pengolahan Citra Digital dengan Python dan OpenCV- Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network



          Aplikasi diatas bisa kalian namakan dengan Painter yang menggunakan mouse untuk menggambar di Canvas TKinter, kode lengkap sebagai berikut

          from tkinter import *
          from tkinter.colorchooser import askcolor
          
          
          class Paint(object):
              DEFAULT_PEN_SIZE = 5.0
              DEFAULT_COLOR = 'black'
              def __init__(self):
                  self.root = Tk()
          
                  self.pen_button = Button(self.root, text='pen', command=self.use_pen)
                  self.pen_button.grid(row=0, column=0)
          
                  self.brush_button = Button(self.root, text='brush', command=self.use_brush)
                  self.brush_button.grid(row=0, column=1)
          
                  self.color_button = Button(self.root, text='color', command=self.choose_color)
                  self.color_button.grid(row=0, column=2)
          
                  self.eraser_button = Button(self.root, text='eraser', command=self.use_eraser)
                  self.eraser_button.grid(row=0, column=3)
          
                  self.choose_size_button = Scale(self.root, from_=1, to=10, orient=HORIZONTAL)
                  self.choose_size_button.grid(row=0, column=4)
          
                  self.c = Canvas(self.root, bg='white', width=600, height=600)
                  self.c.grid(row=1, columnspan=5)
          
                  self.setup()
                  self.root.mainloop()
          
              def setup(self):
                  self.old_x = None
                  self.old_y = None
                  self.line_width = self.choose_size_button.get()
                  self.color = self.DEFAULT_COLOR
                  self.eraser_on = False
                  self.active_button = self.pen_button
                  self.c.bind('<B1-Motion>', self.paint)
                  self.c.bind('<ButtonRelease-1>', self.reset)
          
              def use_pen(self):
                  self.activate_button(self.pen_button)
          
              def use_brush(self):
                  self.activate_button(self.brush_button)
          
              def choose_color(self):
                  self.eraser_on = False
                  self.color = askcolor(color=self.color)[1]
          
              def use_eraser(self):
                  #self.activate_button(self.eraser_button, eraser_mode=True)
                  #self.c.config(fg='white')
                  #self.c = Canvas(self.root, bg='white', width=600, height=600)
                  self.c.create_rectangle(0,0, 600,600,outline="#fb0", fill="white")
          
              def activate_button(self, some_button, eraser_mode=False):
                  self.active_button.config(relief=RAISED)
                  some_button.config(relief=SUNKEN)
                  self.active_button = some_button
                  self.eraser_on = eraser_mode
          
              def paint(self, event):
                  self.line_width = self.choose_size_button.get()
                  paint_color = 'white' if self.eraser_on else self.color
                  if self.old_x and self.old_y:
                      self.c.create_line(self.old_x, self.old_y, event.x, event.y,
                                         width=self.line_width, fill=paint_color,
                                         capstyle=ROUND, smooth=TRUE, splinesteps=36)
                  self.old_x = event.x
                  self.old_y = event.y
          
              def reset(self, event):
                  self.old_x, self.old_y = None, None
          
          
          if __name__ == '__main__':
              Paint()
          

          Pembuatan Painter dengan Pengenalan Tulisan Angka

          Sekarang kalian akan sedikit mengubah Painter diatas menjadi lebih cerdas yang mampu mengenali tulisan angka tangan secara baik menggunakan algoritma deep learning lebih tepatnya Pengenalan Angka Tulisan Tangan dengan convolutional network yang telah dilatih, sehingga Painter tersebut pada saat loading akan meload model dan bobot terlebih dahulu sebelum digunakan. Selain itu kalian akan mengubah Canvas menjadi sebuah file gambar berbentuk *.jpg didalam disk sebelum dibaca oleh Machine Learning.  Beginilah tampilkan aplikasi Painter yang sudah 'pinter'

          Buku Pengolahan Citra Digital dengan Python dan OpenCV- Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network

          Buku Pengolahan Citra Digital dengan Python dan OpenCV- Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network

          Buku Pengolahan Citra Digital dengan Python dan OpenCV- Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network

          Buku Pengolahan Citra Digital dengan Python dan OpenCV- Pengenalan Angka Tulisan Tangan dengan Deep Learning convolutional network

          Menarik bukan? Kalian bisa mendapatkan kode lengkap dengan cara subcribe dan follow blog ini terlebih dahulu agar makin banyak content yang menarik buat kalian semuanya, kalau sudah subcribe dan follow kirim saja email kesini.

          ref:
          https://towardsdatascience.com

          Tuesday, November 27, 2018

          BAB 4 - WinForm

          Selain kita menggunakan CLI dalam demo framework Aforge dan Accord net, sesekali menggunakan WINFORM untuk menghasilkan efek secara langsung, dengan memanfaatkan slider sebagai pengganti nilai brightness dari -100 s.d +100

          Sunday, November 11, 2018

          Buku Cara Cepat Pengolahan Citra Digital dengan C# Sharp



          Postingan ini adalah  telah ditulis ulang dari e-book yang telah kami terbitkan di slideshare yaitu
          https://www.slideshare.net/aktis/buku-cara-cepat-pengolahan-citra-dengan-c-sharp-35888454
          Silahkan untuk membaca...di blog ini

          Sinopsis

          Topik pembahasan olah citra semakin banyak diminati dan berkembang luas, baik dari segi penerapannya dan algoritmanya. Bahasa C# dengan Framework AForge.Net dan Accord.Net serta  IDE Sharp Develop menjadikan pengembangan aplikasi dan algoritma menjadi mudah dikarenakan banyak sekali modul-modul dasar yang telah ditulis oleh framework tersebut yang siap digunakan oleh pengguna bahkan untuk pengguna pemula sekalipun.

          Inti dari buku ini adalah mengenalkan Framework AForge.Net dan Accord.Net sebagai framework untuk olah citra dan sekaligus mengenalkan dasar olah citra
          1. Konsep Olah Citra : mengenal dasar olah citra secara umum
          2. IDE Sharp Develop 4.1: mengenal solution, library, component, debug, build application (diganti dengan Visual Studio 2017)
          3. Framework AForge.Net- Accord.Net: mengenal modul-modul untuk olah citra
          4. Operasi Dasar Olah Citra: mengenal operasi dasar olah citra yaitu
          5. Konvolusi untuk membuat efek blur, sharpening, edge detection
          6. Thresholding menggunakan metode Otsu untuk melakukan operasi Black-White;  Morphologi yaitu dilation, erotion, opening, closing;  Blob yaitu labelling, center of gravity, moment invariant;  Analisis Tekstur: mengenal konsep analisis tektur dengan metode gray level co-occurance sebagai metode standar dalam analisis tekstur;  PCA (Principal Component Analyst): mengenal face recognition dengan metode PCA dan konsep serialisasi data biner
          7. Interfacing Webcam: melakukan koneksi (interfacing) menggunakan webcam baik single maupun multiple connection

          Topik diatas dilengkapi dengan source code serta langkah demi langkah contoh perhitungannya sehingga pemahaman pembaca akan menjadi lebih baik

          Daftar Isi

          1.  Dasar-dasar Citra Digital
          2. Visual Studio
          3. Framework AForge dan Accord
          4. Operasi Dasar Citra Digital
          5. Image Matrix
          6. Analisis Tekstur GLCM
          7. Moment Invariant 
          8. WinForm

          Saturday, November 10, 2018

          Buku Pemrograman Python-Install PIP Package Manager


          Bagi kamu yang suka menggunakan Python untuk kebutuhan teknis sehari-hari baik untuk kerjaan freelace, komputasi teknis. Sebelum penulis mengenal Anaconda, maka penulis akan melakukan instalasi package secara tersendiri yaitu menggunakan get-pip.py

          https://bootstrap.pypa.io/get-pip.py

          download file diatas, kemudian tempatkan di folder favoritmu, misalkan di D:/get-pip.py
          gunakan command prompt, pastikan sudah di folder diatas D:/get-pip.py, gunakan perintah



          python get-pip.py install 

          Lebih lanjut ke

          https://www.slideshare.net/aktis/cara-install-modul-di-python

          http://www.softscients.web.id/2015/02/install-modul-di-python.html

          http://www.softscients.web.id/2018/05/install-tensorflow-di-windows-dengan.html

          Beberapa perintah penting pip


          pip install <package>
          pip search <package>
          pip list
          pip show <package>
          pip donwload <package>