Dalam dunia pasar keuangan yang dinamis, prediksi harga saham menjadi salah satu hal yang menarik perhatian banyak pihak. Dalam artikel ini, kita akan menjelajahi penerapan teknologi Machine Learning dengan Python untuk memprediksi harga saham Amazon, salah satu perusahaan terbesar dan paling berpengaruh di dunia.

Amazon, didirikan oleh Jeff Bezos pada tahun 1994, telah tumbuh menjadi salah satu perusahaan e-commerce terbesar di dunia. Dikenal sebagai “Everything Store” (Toko Segala Sesuatu), Amazon menawarkan berbagai produk dan layanan, termasuk e-commerce, cloud computing, media digital, dan kecerdasan buatan. Amazon telah merevolusi cara orang berbelanja dan berbisnis, mengubah lanskap pasar secara drastis.

Mengingat pentingnya harga saham Amazon bagi para investor, melakukan prediksi harga saham menjadi tantangan yang menarik dan berpotensi menguntungkan. Di sinilah Machine Learning, cabang kecerdasan buatan yang fokus pada pembuatan model dari data, dapat memberikan kontribusi besar. Dengan memanfaatkan algoritma Machine Learning dan Python sebagai bahasa pemrograman yang andal, kita dapat membangun model prediksi harga saham Amazon yang akurat dan berdaya guna.

Dalam artikel ini, kita akan belajar tentang dasar-dasar Machine Learning dan Python yang diperlukan untuk memahami dan menerapkan model prediksi harga saham. Selain itu, akan diuraikan langkah-langkah praktis dalam mengumpulkan data historis harga saham Amazon, mempersiapkan data untuk pelatihan model, dan mengimplementasikan beberapa teknik Machine Learning yang populer. Semoga artikel ini dapat memberikan wawasan yang berharga dan membantu Anda memahami bagaimana Machine Learning dapat digunakan untuk meramalkan harga saham Amazon dengan lebih percaya diri. Selamat membaca!

Importing Libraries

Berikut merupakan library yang digunakan

• Pandas — Library ini membantu memuat bingkai data dalam format susunan 2D dan memiliki beberapa fungsi untuk melakukan tugas analisis sekaligus.
• Numpy — Array Numpy sangat cepat dan dapat melakukan komputasi besar dalam waktu yang sangat singkat.
• Matplotlib/Seaborn — Library ini digunakan untuk menggambar visualisasi.
• Sklearn — Modul ini berisi beberapa library yang memiliki fungsi yang telah diimplementasikan sebelumnya untuk melakukan tugas-tugas mulai dari prapemrosesan data hingga pengembangan dan evaluasi model.
• XGBoost — Modul ini berisi algoritma pembelajaran mesin eXtreme Gradient Boosting yang merupakan salah satu algoritma yang membantu kita untuk mencapai akurasi yang tinggi dalam prediksi.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sb
 
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from xgboost import XGBClassifier
from sklearn import metrics
 
import warnings
warnings.filterwarnings('ignore')

Importing Dataset

Dataset yang akan kami gunakan di sini untuk melakukan analisis dan membangun model prediktif adalah data Harga Saham Amazon. Kami akan menggunakan data OHLC (‘Open’, ‘High’, ‘Low’, ‘Close’) dari tanggal 15 Mei 1997 hingga 27 Oktober 2021 selama 24 tahun untuk saham Amazon.

Anda dapat mengunduhnya pada laman berikut. (Anda harus mengganti “-” pada tanggal dengan “/”).

Pertama, kita lakukan mounting terlebih dahulu sebagai berikut.

from google.colab import drive
drive.mount('/content/drive')

Setelah itu, akan dilakukan inputasi data sebagai berikut.

df = pd.read_csv('/content/drive/MyDrive/SEMESTER 6/MPML/Amazon.csv', sep=";")
df.head()

Akan menghasilkan output sebagai berikut:

Dari lima baris pertama, kita dapat melihat bahwa data untuk beberapa tanggal tidak ada, alasannya adalah karena pada akhir pekan dan hari libur, Pasar Saham tutup sehingga tidak ada perdagangan yang terjadi pada hari-hari tersebut.

Untuk melihat dimensi data, kita menggunakan sintaks sebagai berikut.

df.shape

Output:

Dari sini, kami mengetahui bahwa ada 6155 baris data yang tersedia dan untuk setiap baris, kami memiliki 7 fitur atau kolom yang berbeda.

Untuk melihat statistika deskriptif, dapat menggunakan perintah sebagai berikut.

df.describe()

Output:

Lalu, untuk meliat informasi dari data, dapat menggunakan perintah sebagai berikut.

df.info()

Output:

Exploratory Data Analysis

EDA adalah pendekatan untuk menganalisis data dengan menggunakan teknik visual. Ini digunakan untuk menemukan tren, dan pola, atau untuk memeriksa asumsi dengan bantuan ringkasan statistik dan representasi grafis.

Saat melakukan EDA pada data Harga Saham Amazon, kami akan menganalisis bagaimana harga saham bergerak selama periode waktu tertentu dan bagaimana akhir kuartal memengaruhi harga saham.

Pertama, kita akan membuat plot mengenai pergerakan dari saham Amazon dari tahun 1997 hingga 2021.

plt.figure(figsize=(15,5))
plt.plot(df['Close'])
plt.title('Amazon Close price.', fontsize=15)
plt.ylabel('Price in dollars.')
plt.show()

Output:

Harga saham Amazon menunjukkan tren kenaikan seperti yang digambarkan oleh plot harga penutupan saham.

Selanjutnya, akan ditampilkan 5 data teratas dengan menggunakan perintah sebagai berikut.

df.head()

Output:

Jika kita amati dengan seksama, kita dapat melihat bahwa data pada kolom ‘Close’ dan yang tersedia pada kolom ‘Adj Close’ adalah sama, mari kita periksa apakah hal ini terjadi pada setiap baris atau tidak.

df[df['Close'] == df['Adj Close']].shape

Output:

Dari sini kita dapat menyimpulkan bahwa semua baris dari kolom ‘Close’ dan ‘Adj Close’ memiliki data yang sama. Jadi, memiliki data yang berlebihan di dalam kumpulan data tidak akan membantu, jadi kita akan menghapus kolom ini sebelum melakukan analisis lebih lanjut.

df = df.drop(['Adj Close'], axis=1)

Sekarang mari kita menggambar plot distribusi untuk fitur kontinu yang diberikan dalam kumpulan data.

Sebelum melangkah lebih jauh, mari kita periksa nilai nol jika ada yang ada di dalam bingkai data.

df.isnull().sum()

Output:

Hal ini mengimplikasikan bahwa tidak ada nilai nol dalam kumpulan data yang disediakan.

features = ['Open', 'High', 'Low', 'Close', 'Volume']
 
plt.subplots(figsize=(20,10))
 
for i, col in enumerate(features):
  plt.subplot(2,3,i+1)
  sb.distplot(df[col])
plt.show()

Output:

Pada plot distribusi data OHLC, kita dapat melihat dua puncak yang berarti data telah bervariasi secara signifikan di dua wilayah. Dan data Volume miring ke kiri. Selanjutnya, akan membuat boxplot sebagai berikut.

plt.subplots(figsize=(20,10))
for i, col in enumerate(features):
  plt.subplot(2,3,i+1)
  sb.boxplot(df[col])
plt.show()

Dari boxplot di atas, kita dapat menyimpulkan bahwa semua data mengandung pencilan di dalamnya.

Feature Engineering

Feature Engineering membantu untuk mendapatkan beberapa fitur berharga dari fitur yang sudah ada. Fitur-fitur tambahan ini terkadang membantu meningkatkan kinerja model secara signifikan dan tentu saja membantu mendapatkan wawasan yang lebih dalam ke dalam data.

splitted = df['Date'].str.split('/', expand=True)

df['day'] = splitted[1].astype('int')
df['month'] = splitted[0].astype('int')
df['year'] = splitted[2].astype('int')

df.head()

Output:

Sekarang kita memiliki tiga kolom lagi yaitu ‘hari’, ‘bulan’ dan ‘tahun’, ketiganya berasal dari kolom ‘Date’ yang pada awalnya disediakan dalam data.

df['is_quarter_end'] = np.where(df['month']%3==0,1,0)
df.head()

Output:

Kuartal didefinisikan sebagai kelompok yang terdiri dari tiga bulan. Setiap perusahaan menyiapkan hasil kuartalannya dan mempublikasikannya kepada publik sehingga orang dapat menganalisis kinerja perusahaan. Hasil kuartalan ini sangat memengaruhi harga saham, itulah sebabnya kami menambahkan fitur ini karena dapat menjadi fitur yang berguna untuk model pembelajaran.

data_grouped = df.groupby('year').mean()
plt.subplots(figsize=(20,10))
 
for i, col in enumerate(['Open', 'High', 'Low', 'Close']):
  plt.subplot(2,2,i+1)
  data_grouped[col].plot.bar()
plt.show()

Output:

Dari grafik batang di atas, dapat terlihat bahwa saham cenderung mengalami kenaikan di tiap tahunnya.

df.groupby('is_quarter_end').mean()

Output:

Berikut adalah beberapa pengamatan penting dari data yang dikelompokkan di atas:

• Harga lebih tinggi pada bulan-bulan di akhir kuartal dibandingkan dengan bulan-bulan di luar akhir kuartal.
• Volume perdagangan lebih rendah pada bulan-bulan di akhir kuartal.

df['open-close'] = df['Open'] - df['Close']
df['low-high'] = df['Low'] - df['High']
df['target'] = np.where(df['Close'].shift(-1) > df['Close'], 1, 0)

Di atas kita telah menambahkan beberapa kolom lagi yang akan membantu dalam pelatihan model kita. Kita telah menambahkan fitur target yang merupakan sinyal untuk membeli atau tidak, dan kita akan melatih model kita untuk memprediksi hal ini saja. Namun sebelum melanjutkan, mari kita periksa apakah targetnya seimbang atau tidak menggunakan diagram lingkaran.

plt.pie(df['target'].value_counts().values,
        labels=[0, 1], autopct='%1.1f%%')
plt.show()

Output:

Ketika kita menambahkan fitur ke dataset kita, kita harus memastikan bahwa tidak ada fitur yang berkorelasi tinggi karena fitur-fitur tersebut tidak membantu dalam proses pembelajaran algoritme.

plt.figure(figsize=(10, 10))
 
# As our concern is with the highly
# correlated features only so, we will visualize
# our heatmap as per that criteria only.
sb.heatmap(df.corr() > 0.9, annot=True, cbar=False)
plt.show()

Output:

Dari heatmap di atas, kita dapat mengatakan bahwa ada korelasi yang tinggi antara OHLC yang cukup jelas, dan fitur-fitur yang ditambahkan tidak terlalu berkorelasi satu sama lain atau dengan fitur-fitur yang telah disediakan sebelumnya, yang berarti bahwa kita siap untuk membangun model kita.

Data Splitting and Normalization

features = df[['open-close', 'low-high', 'is_quarter_end']]
target = df['target']

scaler = StandardScaler()
features = scaler.fit_transform(features)

X_train, X_valid, Y_train, Y_valid = train_test_split(
 features, target, test_size=0.2, random_state=2022)
print(X_train.shape, X_valid.shape)

Output:

Setelah memilih fitur yang akan digunakan untuk melatih model, kita harus menormalkan data karena data yang ternormalisasi akan menghasilkan pelatihan model yang stabil dan cepat. Setelah itu, seluruh data dibagi menjadi dua bagian dengan rasio 80/20, sehingga kita dapat mengevaluasi kinerja model kita pada data yang tidak terlihat.

Model Development and Evaluation

Sekarang adalah waktunya untuk melatih beberapa model pembelajaran mesin yang canggih (Regresi Logistik, Support Vector Machine, XGBClassifier), dan kemudian berdasarkan kinerjanya pada data pelatihan dan validasi, kami akan memilih model ML mana yang melayani tujuan yang lebih baik.

Untuk metrik evaluasi, kita akan menggunakan kurva ROC-AUC, tetapi mengapa demikian karena alih-alih memprediksi probabilitas keras yang bernilai 0 atau 1, kita ingin memprediksi probabilitas lunak yang bernilai kontinu antara 0 hingga 1. Dan dengan probabilitas lunak, kurva ROC-AUC umumnya digunakan untuk mengukur keakuratan prediksi.

models = [LogisticRegression(), SVC(
  kernel='poly', probability=True), XGBClassifier()]
 
for i in range(3):
  models[i].fit(X_train, Y_train)
 
  print(f'{models[i]} : ')
  print('Training Accuracy : ', metrics.roc_auc_score(
    Y_train, models[i].predict_proba(X_train)[:,1]))
  print('Validation Accuracy : ', metrics.roc_auc_score(
    Y_valid, models[i].predict_proba(X_valid)[:,1]))
  print()

Untuk melihat hasil dari beberapa model, dapat diganti pada bagian “for i in range(…)”

1 -> untuk regresi logistik

2 -> model Support Vector Machine (SVM)

3 -> model XGBClassifier

Output:

Di antara ketiga model tersebut, XGBClassifier yang kami latih memiliki kinerja tertinggi tetapi dipangkas menjadi overfitting karena perbedaan antara akurasi pelatihan dan validasi terlalu tinggi.

Conclusion:

Kita dapat mengamati bahwa akurasi yang dicapai oleh model ML yang canggih tidak lebih baik daripada sekadar menebak dengan probabilitas 50%. Alasan yang mungkin untuk hal ini adalah kurangnya data atau menggunakan model yang sangat sederhana untuk melakukan tugas yang kompleks seperti prediksi Pasar Saham.

Reference:

1. https://www.geeksforgeeks.org/stock-price-prediction-using-machine-learning-in-python/
2. https://www.kaggle.com/datasets/kannan1314/amazon-stock-price-all-time

Menghitung dan melacak jumlah objek dalam suatu gambar atau video dapat menjadi tugas yang memakan waktu dan rumit. Namun, dengan perkembangan kecerdasan buatan, telah muncul solusi yang efisien dan akurat untuk mengatasi tantangan ini. Artificial Intelligence (AI) dalam bentuk Object Counter memberikan kemampuan untuk mengenali dan menghitung objek dalam waktu nyaris instan.

Dalam kesempatan kali ini, kita akan menjelajahi konsep dan manfaat dari Object Counter, serta melihat bagaimana teknologi ini dapat diterapkan dalam berbagai bidang, mulai dari pemantauan keamanan hingga analisis data. Siap untuk menjelajahi keajaiban Object Counter? Mari kita mulai!

Anda dapat menggunakan video mengenai suatu objek dengan jelas, jika belum mempunyai, dapat mengunduh pada laman Youtube sebagai berikut.

Kemudian, unduh video pertama tersebut lalu simpan dengan nama ’highway.mp4’ (disimpan dalam ekstensi mp4) dalam satu folder baru yang anda buat, misal c:/hitungmobil. Lalu, ikuti langkah selanjutnya sebagai berikut.

Pertama, membuat script untuk mengambil gambar/video yang akan dihitung objeknya.

import numpy as np
import cv2cap = cv2.VideoCapture('highway.mp4')while(cap.isOpened()):
 ret, frame = cap.read()
 try :
  cv2.imshow('Frame',frame)
 except:
  print('EOF')
  break
 k = cv2.waitKey(30)& 0xff
 if k == 27:
  breakcap.release()
cv2.destroyAllWindows()

Lalu, salin kode tersebut dan anda dapat menyimpannya pada Notepad atau Notepad++ dengan nama “pertama.py” (disimpan dalam ekstensi .py) dalam folder c:/hitungmobil, sehingga dalam folder tersebut telah ada dua file, yaitu “highway.mp4” dan “pertama.py”

Untuk menjalankan kode tersebut, bukalah command prompt lalu ketikan perintah sesuai dengan direktori penyimpanan anda sebagai berikut.

c:/hitungmobil/python pertama.py

Maka, diperoleh hasil sebagai berikut.

Dari program tersebut, akan ditangkap gambar per frame dalam tiap detik (frame per second/fps). Untuk mendapatkan fps dari video, menggunakan script berikut.

import cv2
vidcap = cv2.VideoCapture('highway.mp4')
success,image = vidcap.read()
fps = vidcap.get(cv2.CAP_PROP_FPS)
totalframes = vidcap.get(cv2.CAP_PROP_FRAME_COUNT)
frame2skip = 5  # num of frames to skip when extracting
outputframe = int(totalframes / frame2skip)
print('Video FPS rate is {}'.format(fps))
print('You will get {} frames in total'.format(outputframe))
while success:
    frameId = int(round(vidcap.get(1)))
    success, image = vidcap.read()
if frameId % frame2skip == 0:
        cv2.imwrite('frame_%d.jpg' % frameId, image)
        print('Export frame {}: '.format(frameId), success)
vidcap.release()
print ('Extraction completed!')

Simpan kode di atas dengan nama “cobafps.py”. Lalu, jalankan dengan perintah pada command prompt sebagai berikut.

c:/hitungmobil/python cobafps.py

Maka, dihasilkan ekspor berbenruk gambar sebagai berikut

Selanjutnya, dapat dipahami bahwa sistem mengubah setiap gambar menjadi matriks angka-angka, yang mewakili setiap pixel dalam gambar. Matriks ini kemudian digunakan oleh sistem untuk analisis lebih lanjut.

import cv2, time
video=cv2.VideoCapture("highway.mp4")
a=0
while True:
 a=a+1
 check, frame = video.read()
print(frame)
cv2.imshow("capturing", frame)
 key=cv2.waitKey(1)
 
 if key == ord('q'):
  break
video.release()
cv2.destroyAllWindows()

Simpanlah dengan nama “matriks.py”, lalu panggil dan jalankan pada command prompt.

c:/hitungmobil/python matriks.py

Maka, diperoleh hasil sebagai berikut.

Untuk menghentikan koding tersebut, anda dapat mengeklik “CTRL+C” pada command prompt. Di samping itu, tiap gambar diwakili oleh warna dasar RGB (Red Green Blue) yang bernilai 0–255. Untuk melihatnya, dapat menggunakan script sebagai berikut.

import cv2
import numpy as np
 
def split_to_RGB(mirror=False): #mirror digunakan untuk camera laptop
 
    cap = cv2.VideoCapture("highway.mp4")
    cv2.namedWindow('Split RGB',cv2.WINDOW_NORMAL)
    zeros = None
    while True:
        ret, frame = cap.read()
 
        if ret == True:
          
            height, width, layers = frame.shape
            matrix0 = np.zeros((height, width), dtype="uint8")
 
          
            (B, G, R) = cv2.split(frame)
 
          
            B = cv2.merge([B, matrix0, matrix0])
            G = cv2.merge([matrix0, G, matrix0])
            R = cv2.merge([matrix0, matrix0, R])
          
            final = np.zeros((height * 2, width * 2, 3), dtype="uint8")
 
            final[0:height, 0:width] = frame 
            final[0:height, width:width * 2] = B 
            final[height:height * 2, 0:width] = G  
            final[height:height * 2, width:width * 2] = R  
 
            cv2.imshow('Split RGB', final)
        else:
            break
 
        if cv2.waitKey(1) & 0xFF == ord('q'):  
            break
    cap.release()
    cv2.destroyAllWindows()
 
def main():
    split_to_RGB(mirror=True)
 
if __name__ == '__main__':
    main()

Simpan script tersebut dengan nama “splitRGB.py” masih dalam folder c:/hitungmobil. Lalu, jalankan perintah pada command prompt sebagai berikut.

c:/hitungmobil/python splitRGB.py

Maka, akan terlihat hasilnya sebagai berikut.

Selanjutnya, akan dibuat garis pembatas. Pembuatan garis ini menggunakan script yang sama seperti “pertama.py”, namun akan disipkan beberapa koding sebagai berikut.

import numpy as np
import cv2
cap = cv2.VideoCapture('highway.mp4')
while(cap.isOpened()):
 ret, frame = cap.read()
 try :
  cv2.imshow('Frame',frame)
  frame2 = frame
 except:
  print('EOF')
  break
 
 line1 = np.array([[200,400],[700,400],[1000,400]],np.int32).reshape((-1,1,2))
 line2 = np.array([[50,500],[1200,500]],np.int32).reshape((-1,1,2))
 frame2 = cv2.polylines(frame2,[line1],False,(255,0,0),thickness=2)
 frame2 = cv2.polylines(frame2,[line2],False,(0,0,255),thickness=2)
 cv2.imshow('Frame 2',frame2)
 
 k = cv2.waitKey(30)& 0xff
 if k == 27:
  break
cap.release()
cv2.destroyAllWindows()

Lalu, panggil lagi menggunakan command prompt.

c:/hitungmobil/python pertama.py

Dihasilkan gambar sebagai berikut.

Dapat terlihat dua garis berwarna merah dan biru.

Metode background substractor digunakan dalam menghitung onjek yang ada di video dengan menggunakan script sebagai berikut.

import numpy as np
import cv2cap = cv2.VideoCapture('highway.mp4')
fgbg = cv2.createBackgroundSubtractorMOG2(detectShadows = True)while(cap.isOpened()):
 ret, frame = cap.read()
 fgmask = fgbg.apply(frame)
 try :
  cv2.imshow('Frame',frame)
  cv2.imshow('Background Subtraction',fgmask)
  frame2 = frame
 except:
  print('EOF')
  break
 
 line1 = np.array([[200,400],[700,400],[1000,400]],np.int32).reshape((-1,1,2))
 line2 = np.array([[50,400],[1200,500]],np.int32).reshape((-1,1,2))
 frame2 = cv2.polylines(frame2,[line1],False,(255,0,0),thickness=2)
 frame2 = cv2.polylines(frame2,[line2],False,(0,0,255),thickness=2)
 cv2.imshow('Frame 2',frame2)
 
 k = cv2.waitKey(30)& 0xff
 if k == 27:
  breakcap.release()
cv2.destroyAllWindows()

Simpanlah koding tersebut dengan nama “kedua.py” dalam folder c:/hitungmobil lalu dijalankan dengan menggunakan perintah berikut.

c:/hitungmobil/python kedua.py

Maka, akan terlihat tampilan sebagai berikut.

Cara kerja background subtractor adalah frame pada saat k+1, f(k+1) dikurangi dengan frame pada saat k, f(k). Frame pada saat k dianggap sebagai frame dasar atau frame tetap, sehingga perbedaan posisi gambar pada saat k+1 (diwakili oleh nilai-nilai setiap pixel dalam matriks) akan dikurangkan dengan posisi gambar pada saat k (diwakili oleh nilai-nilai setiap pixel dalam matriks).

Sebagai contoh pada gambar berikut.

Metode ini menggunakan transformasi morfologi untuk memperjelas bentuk objek dengan mempertahankan piksel berwarna putih menjadi putih dan piksel berwarna hitam menjadi hitam. Berikut adalah script untuk melakukan operasi morfologi pada video.

import cv2
import numpy as np
def nothing(x):
    pass
cap = cv2.VideoCapture("highway.mp4")
cv2.namedWindow("Trackbars")
cv2.createTrackbar("L - H", "Trackbars", 0, 179, nothing)
cv2.createTrackbar("L - S", "Trackbars", 0, 255, nothing)
cv2.createTrackbar("L - V", "Trackbars", 0, 255, nothing)
cv2.createTrackbar("U - H", "Trackbars", 179, 179, nothing)
cv2.createTrackbar("U - S", "Trackbars", 255, 255, nothing)
cv2.createTrackbar("U - V", "Trackbars", 255, 255, nothing)
while True:
    _, frame = cap.read()
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    l_h = cv2.getTrackbarPos("L - H", "Trackbars")
    l_s = cv2.getTrackbarPos("L - S", "Trackbars")
    l_v = cv2.getTrackbarPos("L - V", "Trackbars")
    u_h = cv2.getTrackbarPos("U - H", "Trackbars")
    u_s = cv2.getTrackbarPos("U - S", "Trackbars")
    u_v = cv2.getTrackbarPos("U - V", "Trackbars")
    lower_blue = np.array([l_h, l_s, l_v])
    upper_blue = np.array([u_h, u_s, u_v])
    mask = cv2.inRange(hsv, lower_blue, upper_blue)
    kernel = np.ones((5, 5), np.uint8)
    erosion = cv2.erode(mask, kernel)
    dilation = cv2.dilate(mask, kernel)
    opening = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel, iterations=2)
    closing = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
    result = cv2.bitwise_and(frame, frame, mask=mask)
    cv2.imshow("frame", frame)
    cv2.imshow("mask", mask)
    cv2.imshow("erosion", erosion)
    cv2.imshow("dilation", dilation)
    cv2.imshow("Opening", opening)
    cv2.imshow("Closing", closing)
    key = cv2.waitKey(1)
    if key == 27:
        break
cap.release()
cv2.destroyAllWindows()

Simpanlah kode di atas dengan nama “morfomobil.py” dalam folder “c:/hitungmobil”. Kemudian, jalankan perintah berikut melalui command prompt:

c:/hitungmobil/python morfomobil.py

Berikut adalah hasilnya:

Tampilan yang akan muncul nantinya akan mengeluarkan banyak jendela, anda dapat mengatur warna trackbars dengan menggeserkan anak panahnya.

Pada trackbar, kita dapat mengubah nilai-nilai HSV, yang digunakan sebagai patokan, bukan RGB. Dengan menggunakan proses dilasi, erosi, opening, dan closing pada gambar yang telah mengalami transformasi morfologi, kita akan memperjelas mobil (objek) yang menjadi perhatian kita.

Selanjutnya, setelah objek telah diidentifikasi dengan benar, kita akan membuat kontur untuk setiap objek tersebut. Berikut adalah kode untuk melakukannya:

import numpy as np
import cv2
cap = cv2.VideoCapture('highway.mp4')
fgbg = cv2.createBackgroundSubtractorMOG2(detectShadows = True)
kernelOp = np.ones((3,3),np.uint8)
kernelCl = np.ones((11,11),np.uint8)
while(cap.isOpened()):
 ret, frame = cap.read()
 fgmask = fgbg.apply(frame)
 try:
  ret,imBin = cv2.threshold(fgmask,200,255,cv2.THRESH_BINARY)
  mask = cv2.morphologyEx(imBin, cv2.MORPH_OPEN,kernelOp)
  mask = cv2.morphologyEx(mask,cv2.MORPH_CLOSE,kernelCl)
 except:
  print('EOF')
  break
 contours, hierarchy =cv2.findContours(mask,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
 for cnt in contours:
  cv2.drawContours(frame,cnt,-1,(0,255,0),2,5)
  cv2.imshow('Frame',frame)
 k = cv2.waitKey(30) & 0xff
 if k == 27:
  break
cap .release()
cv2.destroyAllWindows()

Simpan koding tersebut dengan nama “mobilkontur.py” dan simpan dalam folder c:/hitungmobil, lalu jalankan perintah berikut pada command prompt.

c:/hitungmobil/python mobilkontur.py 

Maka menghasilkan gambar sebagai berikut.

Lalu, objek tersebut akan dilakukan tracking dengan membuat kotak pada tiap kontur. Dalam metode ini, kita menggunakan pendekatan untuk menentukan posisi terbesar secara horizontal (samping kiri dan kanan) dan vertikal (atas dan bawah). Berikut adalah kode untuk melakukan hal tersebut:

import numpy as np
import cv2
cap = cv2.VideoCapture('highway.mp4')
fgbg = cv2.createBackgroundSubtractorMOG2(detectShadows = True)
kernelOp = np.ones((6,6),np.uint8)
kernelCl = np.ones((11,11),np.uint8)
areaTH = 600
while(cap.isOpened()):
 ret, frame = cap.read()
 fgmask = fgbg.apply(frame)
 try:
  ret,imBin = cv2.threshold(fgmask,200,255,cv2.THRESH_BINARY)
  mask = cv2.morphologyEx(imBin, cv2.MORPH_OPEN,kernelOp)
  mask = cv2.morphologyEx(mask,cv2.MORPH_CLOSE,kernelCl)
 except:
  print('EOF')
  break
 contours, hierarchy =cv2.findContours(mask,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
 for cnt in contours:
  cv2.drawContours(frame,cnt,-1,(0,255,0),2,5)
  area = cv2.contourArea(cnt)
  print(area)
  if area>areaTH:
   M=cv2.moments(cnt)
   cx=int(M['m10']/M['m00'])
   cy=int(M['m01']/M['m00'])
   x,y,w,h=cv2.boundingRect(cnt)
   cv2.circle(frame,(cx,cy),5,(0,0,255),-1)
   img=cv2.rectangle(frame,(x,y),(x+w,y+h),(0,255,0),5)
  cv2.imshow('Frame',frame)
 k = cv2.waitKey(30) & 0xff
 if k == 27:
  break
cap .release()
cv2.destroyAllWindows()

Simpanlah script tersebut dengan nama “mobilkotak.py”, lalu dengan cara yang sama, jalankan pada command promt, diperoleh hasil sebagai berikut.

Pada setiap kotak, nilai rata-rata lebar dan tinggi dihitung untuk menemukan pusat kotak. Dengan informasi ini, dilakukan pelacakan (“tracking”) untuk setiap objek menggunakan kode berikut,

import numpy as np
import cv2
import Cars
import time
cap = cv2.VideoCapture('highway.mp4')
fgbg = cv2.createBackgroundSubtractorMOG2(detectShadows = True)
kernelOp = np.ones((6,6),np.uint8)
kernelCl = np.ones((11,11),np.uint8)
font=cv2.FONT_HERSHEY_SIMPLEX
persons=[]
max_p_age=5
pid=1
areaTH = 600
while(cap.isOpened()):
 ret, frame = cap.read()
 fgmask = fgbg.apply(frame)
 try:
  ret,imBin = cv2.threshold(fgmask,240,255,cv2.THRESH_BINARY)
  mask = cv2.morphologyEx(imBin, cv2.MORPH_OPEN,kernelOp)
  mask = cv2.morphologyEx(mask,cv2.MORPH_CLOSE,kernelCl)
 except:
  print('EOF')
  break
 contours, hierarchy =cv2.findContours(mask,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
 for cnt in contours:
  cv2.drawContours(frame,cnt,-1,(0,255,0),3,5)
  area = cv2.contourArea(cnt)
  print(area)
  if area>areaTH:
   M=cv2.moments(cnt)
   cx=int(M['m10']/M['m00'])
   cy=int(M['m01']/M['m00'])
   x,y,w,h=cv2.boundingRect(cnt)
   new = True
   for i in persons:
    if abs(x-i.getX())<=w and abs(y-i.getY())<=h:
     new = False
     i.updateCoords(cx,cy)
     break
  if new == True :
   p = Cars.MyCar(pid,cx,cy,max_p_age)
   cars.append(p)
   pid+=1
   cv2.circle(frame,(cx,cy),5,(0,0,255),-1)
   img=cv2.rectangle(frame,(x,y),(x+w,y+h),(0,255,0),3)
   cv2.drawContours(frame,cnt,-1,(0,255,0),3)
   
   for i in cars:
    if len(i.getTracks())>=2:
     pts=np.array(i.getTracks(),np.int32)
     pts=pts.reshape((-1,1,2))
     frame=cv2.polylines(frame,[pts],False,i.getRGB())
    if i.getId() == 9:
     print(str(i.getX()),',',str(i.getY()))
     #cv2.putText(frame,str(i.getId()),(i.getX(),i.getY()),font,0.3,i.getRGB(),1,cv2.LINE_AA)
     cv2.putText(frame, str(i.getId()),(i.getX(),i.getY()),font,0.3,i.getRGB(),1,cv2.LINE_AA)
     cv2.imshow('Frame',frame)
 k = cv2.waitKey(30) & 0xff
 if k == 27:
  break
cap .release()
cv2.destroyAllWindows()

Simpan koding tersebut dengan nama “mobiltrack.py” lalu jalankan dengan perintah

c:/hitungmobil/python mobiltrack.py

Dan mendapatkan hasil sebagai berikut

Sehingga setiap mobil sudah memiliki pelacakan (“tracking”) yang akan digunakan sebagai dasar untuk menghitung ketika mobil tersebut telah melewati batas garis yang telah ditentukan. Berikut adalah kode terakhir yang akan diberi nama “itungmobil.py”.

import numpy as np
import cv2
import Cars
import time
#mendefinisikan input dan output
cnt_up   = 0
cnt_down = 0
#Membuka video
cap = cv2.VideoCapture('highway.mp4')
#Dimensi (properti) video
##cap.set(3,160) #Width
##cap.set(4,120) #Height
#Meletakkan properti video ke setiap frame di video
for i in range(19):
    print(i), cap.get(i)
w = cap.get(3)
h = cap.get(4)
frameArea = h*w
areaTH = frameArea/500
print ('Area Threshold'), areaTH
#Garis masuk dan keluar
line_up = int(1.85*(h/3))
line_down   = int(3*(h/4))
up_limit =   int(2.65*(h/5))
down_limit = int(3.5*(h/4))
print ("Red line y:"),str(line_down)
print ("Blue line y:"), str(line_up)
line_down_color = (255,0,0)
line_up_color = (0,0,255)
pt1 =  [0, line_down];
pt2 =  [w, line_down];
pts_L1 = np.array([pt1,pt2], np.int32)
pts_L1 = pts_L1.reshape((-1,1,2))
pt3 =  [0, line_up];
pt4 =  [w, line_up];
pts_L2 = np.array([pt3,pt4], np.int32)
pts_L2 = pts_L2.reshape((-1,1,2))
pt5 =  [0, up_limit];
pt6 =  [w, up_limit];
pts_L3 = np.array([pt5,pt6], np.int32)
pts_L3 = pts_L3.reshape((-1,1,2))
pt7 =  [0, down_limit];
pt8 =  [w, down_limit];
pts_L4 = np.array([pt7,pt8], np.int32)
pts_L4 = pts_L4.reshape((-1,1,2))
#Background subtractor
fgbg = cv2.createBackgroundSubtractorMOG2(detectShadows = True)
#Elemen struktural untuk filter morfologi
kernelOp = np.ones((3,3),np.uint8)
kernelOp2 = np.ones((5,5),np.uint8)
kernelCl = np.ones((11,11),np.uint8)
#Variabel-variabel
font = cv2.FONT_HERSHEY_SIMPLEX
cars = []
max_p_age = 5
pid = 1
while(cap.isOpened()):
#Membaca gambar dari aliran video
    ret, frame = cap.read()
for i in cars:
        i.age_one() #tandai setiap mobil sebagai satu object
#Tahap Pra-pengolahan    
    #Penerapan background subtractor
    fgmask = fgbg.apply(frame)
    fgmask2 = fgbg.apply(frame)
#Menggunakan metode binarisasi untuk menghilangkan bayangan (color ke grey)
    try:
        ret,imBin= cv2.threshold(fgmask,200,255,cv2.THRESH_BINARY)
        ret,imBin2 = cv2.threshold(fgmask2,200,255,cv2.THRESH_BINARY)
  
        #Proses Opening (erosi->dilasi) untuk menghilangkan noise
        mask = cv2.morphologyEx(imBin, cv2.MORPH_OPEN, kernelOp)
        mask2 = cv2.morphologyEx(imBin2, cv2.MORPH_OPEN, kernelOp)
  
        #Proses Closing (dilasi -> erosi) untuk menghilangkan pixel ke putih
        mask =  cv2.morphologyEx(mask , cv2.MORPH_CLOSE, kernelCl)
        mask2 = cv2.morphologyEx(mask2, cv2.MORPH_CLOSE, kernelCl)
    except:
        print('EOF')
        print ('UP:'),cnt_up
        print ('DOWN:'),cnt_down
        break
    
#Pembuatan Kontur    
     
    contours, hierarchy = cv2.findContours(mask2,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
    for cnt in contours:
        area = cv2.contourArea(cnt)
        if area > areaTH:
    
            #   TRACKING 
            #Pengaturan untuk kondisi mobil yang jamak
   
            M = cv2.moments(cnt)
            cx = int(M['m10']/M['m00'])
            cy = int(M['m01']/M['m00'])
            x,y,w,h = cv2.boundingRect(cnt)
new = True
            if cy in range(up_limit,down_limit):
                for i in cars:
                    if abs(cx-i.getX()) <= w and abs(cy-i.getY()) <= h:
                        
      #object dekat dengan object yang telah terdeteksi sebelumnya
                        new = False
                        i.updateCoords(cx,cy)   
      #perbaharui koordinat dalam object dalam atur ulang usia (awal penandaan)
                        if i.going_UP(line_down,line_up) == True:
                            cnt_up += 1;
                            print ("ID:"),i.getId(),'crossed going up at',time.strftime("%c")
                        elif i.going_DOWN(line_down,line_up) == True:
                            cnt_down += 1;
                            print ("ID:"),i.getId(),'crossed going down at',time.strftime("%c")
                        break
                    if i.getState() == '1':
                        if i.getDir() == 'down' and i.getY() > down_limit:
                            i.setDone()
                        elif i.getDir() == 'up' and i.getY() < up_limit:
                            i.setDone()
                    if i.timedOut():
      #hapus object (mobil) dari daftar
                        index = cars.index(i)
                        cars.pop(index)
                        del i     #hapus dari memori
                if new == True:
                    p = Cars.MyCars(pid,cx,cy, max_p_age)
                    cars.append(p)
                    pid += 1     
            
            #Gambar
            
            cv2.circle(frame,(cx,cy), 5, (0,0,255), -1)
            img = cv2.rectangle(frame,(x,y),(x+w,y+h),(0,255,0),2)            
            #cv2.drawContours(frame, cnt, -1, (0,255,0), 3)
            
    #Akhir cnt dalam kontur
 
    
    # Trayektori Gambar 
    
    for i in cars:
        cv2.putText(frame, str(i.getId()),(i.getX(),i.getY()),font,0.3,i.getRGB(),1,cv2.LINE_AA)
str_up = 'Keluar: '+ str(cnt_up)
    str_down = 'Masuk: '+ str(cnt_down)
    frame = cv2.polylines(frame,[pts_L1],False,line_down_color,thickness=2)
    frame = cv2.polylines(frame,[pts_L2],False,line_up_color,thickness=2)
    frame = cv2.polylines(frame,[pts_L3],False,(255,255,255),thickness=1)
    frame = cv2.polylines(frame,[pts_L4],False,(255,255,255),thickness=1)
    cv2.putText(frame, str_up ,(15,40),font,0.5,(200,200,200),2,cv2.LINE_AA)
    cv2.putText(frame, str_up ,(15,40),font,0.5,(0,200,0),1,cv2.LINE_AA)
    cv2.putText(frame, str_down ,(15,60),font,0.5,(200,200,200),2,cv2.LINE_AA)
    cv2.putText(frame, str_down ,(15,60),font,0.5,(0,0,200),1,cv2.LINE_AA)
cv2.imshow('Frame',frame)
    #cv2.imshow('Mask',mask)    
    
    #klik ESC untuk keluar
    k = cv2.waitKey(30) & 0xff
    if k == 27:
        break
#Akhir untuk while(cap.isOpened())
    
#bersihkan layar
cap.release()
cv2.destroyAllWindows()

Setelah tersimpan, lalu salinlah koding yang dibutuhkan sebagai berikut.

from random import randint
import time
class MyCars:
 tracks = []
 def __init__(self, i, xi, yi, max_age):
   self.i = i
   self.x = xi
   self.y = yi
   self.tracks = []
   self.R = randint(0,255)
   self.G = randint(0,255)
   self.B = randint(0,255)
   self.done = False
   self.state = '0'
   self.age = 0
   self.max_age = max_age
   self.dir = None
 def getRGB(self):
  return (self.R,self.G,self.B)
 def getTracks(self):
  return self.tracks
 def getId(self):
  return self.i
 def getState(self):
  return self.state
 def getDir(self):
  return self.dir
 def getX(self):
  return self.x
 def getY(self):
  return self.y
 def updateCoords(self, xn, yn):
  self.age = 0
  self.tracks.append([self.x,self.y])
  self.x = xn
  self.y = yn
 def setDone(self):
  self.done = True
 def timedOut(self):
  return self.done
 def going_UP(self,mid_start,mid_end):
  if len(self.tracks) >= 2:
   if self.state == '0':
    if self.tracks[-1][1] < mid_end and self.tracks[-2][1] >= mid_end: #melalui batas
     state = '1'
     self.dir = 'up'
     return True
   else:
    return False
  else:
   return False
 def going_DOWN(self,mid_start,mid_end):
  if len(self.tracks) >= 2:
   if self.state == '0':
    if self.tracks[-1][1] > mid_start and self.tracks[-2][1] <= mid_start: #melalui batas
     state = '1'
     self.dir = 'down'
     return True
   else:
    return False
  else:
   return False
 def age_one(self):
  self.age += 1
  if self.age > self.max_age:
   self.done = True
  return True
class MultiCars:
    def __init__(self, cars, xi, yi):
        self.cars = cars
        self.x = xi
        self.y = yi
        self.tracks = []
        self.R = randint(0,255)
        self.G = randint(0,255)
        self.B = randint(0,255)
        self.done = False

Lalu, simpan dengan nama “hitungmobil.py” masih dalam satu folder yang sama, lalu dipanggil sepertib biasa dengan menggunakan command prompt sebagai berikut.

c:/hitungmobil/python hitungmobil.py

Maka, dapat menghasilkan gambar sebagai berikut.

Dengan begitu, kita dapat menyimpulkan bahwa penggunaan kecerdasan buatan dalam perangkat penghitung objek telah membuka pintu bagi kemajuan luar biasa dalam mengatasi tantangan pemantauan lalu lintas di jalan raya. Kemampuannya untuk menghitung dengan akurat jumlah mobil yang masuk dan keluar dari jalan raya telah membantu meningkatkan keamanan dan efisiensi lalu lintas. Dengan teknologi yang semakin maju, kita dapat berharap bahwa penggunaan kecerdasan buatan akan terus meningkatkan sistem penghitung objek, dan menjadikan lalu lintas di jalan raya menjadi lebih aman dan lancar.

Referensi

https://medium.com/@986110101/object-counter-823c0fd84cfb

Halo!

Pada kesempatan kali ini, saya akan sedikit memaparkan materi mengenai aplikasi decision tree dengan menggunakan salah satu dataset sangat populer di kalangan data enthusiast, yaitu Iris dataset.

Pengertian

Decision Tree adalah suatu diagram alir yang memiliki bentuk mirip struktur pohon, di mana setiap nod internal mewakili pengujian terhadap suatu atribut, setiap cabang menggambarkan hasil dari pengujian tersebut, dan nod daun mewakili kelas-kelas atau distribusi kelas. Nod teratas disebut sebagai nod akar atau nod utama. Nod akar memiliki beberapa cabang keluar tetapi tidak memiliki cabang masuk, nod internal memiliki satu cabang masuk dan beberapa cabang keluar, sementara nod daun hanya memiliki satu cabang masuk tanpa cabang keluar (Qadrini et al., 2021).

Kegunaan

Decision Tree digunakan untuk mengategorikan suatu sampel data yang tidak diketahui kelasnya ke dalam kelas-kelas yang sudah ada (Qadrini et al., 2021).

Studi Kasus

Langsung saja, anda dapat melakukan pemasangan paket ”party”, jika sudah panggil dengan menggunakan perintah library() sebagai berikut.

install.packages("party")
library(party)
search()

Maka, akan muncul tampilan sebagai berikut

Dapat terlihat, library() ini telah terlihat terpasang di urutan kedua.

Untuk melihat fungsi yang terdapat pada library ini, kita dapat menggunakan perintah ls(2).

ls(2)

Terlihat pada nomor 6 terdapat fungsi ctree() yang akan digunakan dalam melakukan decision tree kali ini.

Kemudian, untuk memanggil dataset iris, dapat dipanggil saja Iris, dan dapat dilihat 6 data teratas dengan menggunakan fungsi head().

head(iris)

Dapat terlihat bahwa data iris memiliki 5 variabel, dengan variabel species sebagai data kategorik.

Selanjutnya, akan dilakukan suatu decision tree dengan menggunakan fungsi ctree() dengan variabel species sebagai variabel respons, dan yang lainnya sebagai prediktor. Hasil dari decision tree tersebut dapat ditampilkan dengan menggunakan fungsi plot().

hasiltree <- ctree(Species ~ Petal.Length +Petal.Width+ 
                     Sepal.Width+ Sepal.Length,
                   data = iris)
plot(hasiltree)

Berikut merupakan hasil dari plot decision tree tersebut.

Berdasarkan Gambar 5, jika diketahui:

Terdapat satu bunga iris baru dengan sepal length = 7.3 sepal width = 4.3 petal length = 3.8 dan petal width 1.2 maka dengan decision tree, termasuk spesies apakah bunga iris tersebut?

Jawab:

Berdasarkan grafik, jika diikuti alurnya, maka spesies bunga tersebut termasuk bunga Versicolor. Untuk melihat lebih yakin, dapat digunakan fungsi predict() dengan memasukkan data baru tersebut.

Sebelum itu, anda dapat membuat objek baru berisi mengenai data yang ada pada soal, sebagai berikut.

data_baru <- data.frame(Sepal.Length = 7.3,
                        Sepal.Width = 4.3,
                        Petal.Length = 3.8,
                        Petal.Width = 1.2)

Setelah itu, dilanjutkan dengan menggunakan fungsi predict() seperti yang sudah dibilang sebelumnya.

prediksi <- predict(hasiltree, newdata = data_baru, type = "response")
prediksi

Maka, akan diperoleh hasil sebagai berikut.

Berdasarkan Gambar 6, dapat dilihat bahwa hasil prediksi menunjukkan hasil yang sama, yaitu pada bunga dengan spesies versicolor. Jadi, dapat disimpulkan bahwa bunga tersebut merupakan spesies versicolor.

Nah, jadi begitu kira-kira contoh sederhana penggunaan decision tree dengan menggunakan dataset Iris. Bagaimana? mudah bukan? selamat mencoba ya! data tersebut dapat diganti menjadi data yang anda inginkan.

Sekian dari saya, kurang lebihnya mohon maaf karena saya juga masih belajar, hehe

Terima kasih, see u on the next medium!

Referensi

1. https://medium.com/@986110101/decision-tree-2-4dd56891ad16
2. Qadrini, L., Seppewali, A., & Aina, A. (2021). Decision Tree dan ADABOOST pada Klasifikasi Penerima Program Bantuan Sosial. Jurnal Inovasi Penelitian, 2(7).

“Suatu masyarakat disebut miskin apabila memiliki pendapatan jauh lebih rendah dari rata-rata pendapatan sehingga tidak banyak memiliki kesempatan untuk mensejahterakan dirinya (Suryawati, 2004).”

Halo semuanya, salam kenal! 🙌

Pada kesempatan perdana kali ini, saya akan coba membahas salah satu implementasi dari klustering hirarki mengenai data pengukuran tingkat kemiskinan dan ketimpangan ekonomi yang ada di Kabupaten/Kota Jawa Timur dengan menggunakan software R. Indikator tersebut dapat digunakan untuk memahami kondisi sosial-ekonomi penduduk suatu wilayah, termasuk tingkat kemiskinan, ketimpangan, dan tingkat kesejahteraan.

Data dapat diunduh pada laman berikut:

Data Jatim 2.csv

Variabel yang digunakan

Berikut merupakan penjelasan mengenai variabel yang digunakan:

1. Kab : Kabupaten/Kota yang ada di Jawa Timur
2. Density : Kepadatan penduduk
3. PddkKota : Persentase penduduk perkotaan
4. Depend : Rasio ketergantungan
5. Gini : Gini ratio
6. Miskin : Persentase penduduk miskin
7. KapitaNMkn : Persentase pengeluaran per kapita untuk konsumsi bukan makanan sebulan

Okey, mari kita mulai!

Langkah pertama, kalian dapat membuka software R kalian terlebih dahulu. Setelah itu, data akan diinput dengan menggunakan sintaks sebagai berikut. Untuk tempat atau directory dapat disesuaikan dengan tempat masing-masing.

data = read.csv(".....//Data Jatim 2.csv", 
                 header = T, sep =";")
head(data)

Setelah data tersebut dimasukkan, maka akan muncul tampilan sebagai berikut.

Gambar 1 menunjukkan enam data teratas dari data yang telah diinputkan. Terdapat tujuh variabel dengan masing-masing nilainya. Mulai dari Kabupaten Pacitan hingga Kabupaten Kediri. Kemudian, untuk pengecekan struktur data dari tiap variabel, praktikan menggunakan perintah str() dan didapatkan hasil sebagai berikut.

str(data)

Untuk bentuk atau struktur data tersebut merupakan suatu data frame yang terdiri dari tujuh variabel sebanyak 38 baris. Tipe data untuk variabel Kab adalah chr atau character, variabel density adalah int atau integer, dan sisanya berbentuk numerik.

Lalu, untuk melihat ringkasan data dari variabel, kalian dapat menggunakan perintah summary() dan diperoleh hasil sebagai berikut.

summary(data)

Berdasarkan Gambar 3, dapat diketahui hasil statistik deskriptif yang terdiri dari nilai minimum, 1st Quartile, Median, Mean, 3rd Quartile, dan nilai maksimum dari setiap variabel. Akan tetapi, untuk variabel Kab hanya memiliki informasi mengenai length, class, dan mode dikarenakan memiliki tipe data karakter.

Setelah itu, akan dilakukan uji multikolinieritas. Pengujian ini dilakukan untuk mengetahui ada penyimpangan atau tidak asumsi multikolinearitas yang merupakan hubungan linear antar variabel independen pada model. Salah satu syarat yang harus terpenuhi adalah tidak adanya multikolinearitas yang dapat dilihat dari nilai VIF-nya.

### Uji Multikolinearitas ###
install.packages("car")
library(car)
attach(data)

## Multiko dengan nilai VIF
# VIF Density dengan variabel lainnya
multiko.1 = vif(lm(Density~PddkKOta+Depend+Gini+Miskin+KapitaNMkn))
multiko.1

# VIF PddkKOta dengan variabel lainnya 
multiko.2 = vif(lm(PddkKOta~Density+Depend+Gini+Miskin+KapitaNMkn))
multiko.2

# VIF Depend dengan variabel lainnya 
multiko.3 = vif(lm(Depend~PddkKOta+Density+Gini+Miskin+KapitaNMkn))
multiko.3

# VIF Gini dengan variabel lainnya 
multiko.4 = vif(lm(Gini~PddkKOta+Density+Depend+Miskin+KapitaNMkn))
multiko.4

# VIF Miskin dengan variabel lainnya 
multiko.5= vif(lm(Miskin~PddkKOta+Depend+Gini+Density+KapitaNMkn))
multiko.5

#VIF KapitaNMkn dengan variabel lainnya
multiko.6 = vif(lm(KapitaNMkn~PddkKOta+Depend+Gini+Miskin+Density))
multiko.6

Pengujian dilakukan dengan melakukan pemasangan package “car” terlebih dahulu, lalu memanggilnya dengan perintah library(). Setelah itu, dilakukan dengan meng-attach atau menampilkan dataset yang sebelumnya sudah dibuat. Kemudian dilanjutkan dengan pengujian multikolinieritas dengan menggunakan fungsi vif() untuk masing-masing variabel, didapatkan hasil sebagai berikut.

Berdasarkan Gambar 4 di atas, diperoleh hasil analisis sebagai berikut:

Lalu, anda dapat melihat plot korelasi multikolinieritas dengan memasang dan memanggil package ”PerformanceAnalytics” terlebih dahulu kemudian menggunakan fungsi chart.correlation() untuk menampilkan plotnya sebagai berikut.

## Multiko dengan correlation plot
install.packages("PerformanceAnalytics")
library(PerformanceAnalytics)
chart.Correlation(data[,2:7])

Berdasarkan script di atas, pada fungsi chart.Correlation(data[,2:7]) memiliki arti bahwa akan dibuat plot korelasi dengan menggunakan semua baris, namun hanya pada kolom 2–7 karena berbentuk numerik, diperoleh hasil sebagai berikut.

Berdasarkan Gambar 5, dapat terlihat mengenai korelasi antar variabel dan juga plot distribusi masing-masing variabel. Selain itu, anda juga dapat melihat nilai korelasi dengan perintah berikut.

korelasi = cor(data[,2:7])
View(korelasi)

Untuk melihat korelasi antar variabel numerik, hanya menggunakan kolom 2–7 menggunakan fungsi cor() dan diperoleh hasil sebagai berikut.

Nilai korelasi yang baik berada di atas nilai 0,8 yaitu korelasi positif antara variabel PddkKota dengan Density. Selanjutnya, anda dapat memulai analisis hierarki dengan membuat data objek baru yang berisikan data numerik saja dengan menggunakan perintah sebagai berikut. Untuk nama objek dapat disesuaikan masing-masing.

##Analisis Kluster Hirarki
uts_mpml=data[,2:7]

Lalu, dilakukan analisis kelompok hirarki. Anda dapat melakukan analisis kluster hirarki dengan membuatnya dalam bentuk dendogram menggunakan beberapa metode di antaranya sebagai berikut.

#Average Linkage
metode_al<-hclust(dist(scale(uts_mpml)),method="ave")
plot(metode_al)

#single Linkage
metode_sl<-hclust(dist(scale(uts_mpml)), method = "single")
plot(metode_sl)

#Complete Linkage
metode_cl<-hclust(dist(scale(uts_mpml)), method="complete")
plot(metode_cl)

#Ward
metode_ward<-hclust(dist(scale(uts_mpml)),method="ward.D")
plot(metode_ward)

1. Average Linkage

Analisis yang dilakukan pertama adalah dengan menggunakan metode average linkage. Pengelompokan dengan metode ini yang dibentuk berdasarkan nilai rata — rata jarak individu dalam satu kelompok dengan rata -rata seluruh dan kelompok lainnya. Maka, ditampilkan output seperti pada Gambar 7 berikut.

Untuk metode ini, terdapat tiga cluster besar dan satu cluster kecil dengan jumlah yang terlihat kurang tersebar merata.

2. Single Linkage

Metode single linkage merupakan metode pengelompokan agglomerative yang didasarkan pada jarak minimum atau jarak terdekat antar objek, diperoleh hasil sebagai berikut.

3. Complete Linkage

Complete linkage merupakan metode pengelompokan agglomerative yang didasarkan pada jarak maksimum atau jarak terjauh antar objek. Maka, ditampilkan output seperti pada Gambar 9 berikut.

4. Wards Method

Wards method merupakan pengelompokan mengunakan jumlah kuadrat antar dua cluster untuk seluruh variabel. Maka, ditampilkan output seperti pada Gambar 10 berikut.

Menentukan Banyaknya Kluster
Kluster yang baik adalah kluster yang memiliki kedekatan jarak di dalam kelompoknya dan memiliki jarak yang jauh antar kelompok, hal ini dapat dilihat dari dendogram metode ward’s memberikan hasil yang baik. Dari beberapa hasil klustering di atas, yang memiliki hasil yang baik adalah metode Wards dengan jumlah kluster sebanyak 4 kelompok.

Berikut merupakan sintaks untuk membuat garis bantu dalam menentukan empat kelompok tersebut. Terdapat beberapa cara untuk mengukur akurasi banyaknya jumlah kelompok yang dibentuk, pada kali ini contohnya menggunakan stability measure.

install.packages("clValid")
library(clValid)

#Stabilitas measure
stability <- clValid(uts_mpml, nClust = 3:4,
                     clMethods = "agnes",
                     validation = "internal",
                     metric = "euclidean",
                     method = "complete")
#Hanya menampilkan skor optimal
optimalScores(stability)

Maka, diperoleh hasil sebagai berikut.

Berdasarkan Gambar 11, penentuan kluster dapat dilakukan dengan 3 atau 4 kelompok dengan mayoritas di 4 bagian kelompok. Untuk memudahkan pembagian, dapat dilakukan dengan memberikan garis merah pada kluster dendogram sebagai berikut.

rect.hclust(metode_ward,4)

Lalu, diperoleh hasil pembagian kelompok sebagai berikut.

Berdasarkan Gambar 12, dapat terlihat bahwa adanya garis merah mempermudah dalam bayangan untuk membagi kelompok. Selanjutnya, akan dilakukan pengelompokkan ke dalam data frame dengan menggunakan sintaks sebagai berikut.

#Mengelompokkan data dalam format data frame
anggota <- cutree(metode_ward,4)
tabel <- data.frame(data,anggota)
tabel

Maka, diperoleh hasil sebagai berikut.

Untuk melakukan profilisasi, anda dapat mengimport data frame tersebut ke dalam bentuk .csv dengan menggunakan sintaks sebagai berikut.

write.csv(tabel, "...// Output Profilisasi Data Jatim 2.csv")

Profilisasi dilakukan dengan cara mengurutkan nilai anggota, biasanya menggunakan filter sorts dari terkecil ke terbesar. Kemudian, mencari perhitungan rata — rata berdasarkan tiap variabel dengan menggunakan MS. Excel. Hasilnya dapat dilihat sebagai berikut.

Berdasarkan Gambar 14, dapat diketahui terdapat empat kelompok atau klaster. Untuk masing-masing variabel, terdapat nilai tertinggi hingga terendah yang dilabeli dengan warna dari yang tua hingga muda, menunjukkan urutan nilai dari yang terbesar hingga terkecil.

Untuk variabel density, kelompok yang memiliki nilai tertinggi di antara kelompok yang lain yaitu kluster 3. Untuk variabel PddkKota, yang memiliki nilai tertinggi pertama dipegang oleh kelompok 3, begitu pula dengan variabel lain dan urutan yang sesuai dengan warna yang telah tertera.

Beberapa Kabupaten/Kota yang berada pada masing-masing kelompok dapat dilihat hasilnya di sini.

Kesimpulan

Hasil pengelompokkan dan pengkategorian untuk kabupaten/kota di Jawa Timur bisa menjadi saran bagi pemerintah agar lebih memperhatikan Kabupaten/Kota yang memiliki hasil pengukuran tingkat kemiskinan dan ketimpangan ekonomi yang tinggi sehingga dapat perhatian lebih mengenai pemerataan fasilitas pada tiap daerah untuk membangun provinsi yang baik dan membangun bangsa yang lebih baik.

Sekian ulasan singkat mengenai salah satu implementasi analisis kluster hirarki. Beberapa teori mungkin dapat dikembangkan dan di asah lebih lanjut hingga menghasilkan hasil yang lebih akurat.

Kritik dan saran sangat diperlukan untuk berkembangnya tulisan ini, terima kasih, See you on the next post!

I will be glad if you use references and include the address of this website in your research — writer

Referensi

Muhammad Muhajir, S. M. (2021). MODUL PRAKTIKUM STATISTIKA MULTIVARIAT TERAPAN. Yogyakarta: UII.

Statistik Inferensial, “Hierarchical Clustering (Agglomerative Clustering) dengan Metode Complete Linkage”, https://youtu.be/e0R8BGJLRb0, retrivied at 4 May 2023

Suryawati, Chriswardani, 2004, “Memahami Kemiskinan Secara Multidimensional”, Jurnal Manajemen Pembangunan dan Kebijakan, Volume 08, №03, Edisi September (121–129).