Tugas 4

TUGAS 03
Untuk dataset berikut ini, buat program di python untuk mengcluster data-data tersebut.
Lampirkan source code python dan hasil pengelompokkan nya.
Terima kasih.
NIM : 202420040
Name : Istiarso Budi Yuwono
================================
Tugas 03 – Clustering
1. Tampilkan data dari dataset
2. Tampilkan informasi setiap variable
3. Hilangkan Variable yang tidak perlu, dalam hal ini digunakan variable X dan Y
4. Tentukan Variable yang akan di Klusterkan yaitu variable X dan Variable Y

5. Tampilkan Penyebaran datanya
6. Ubah Variable dari data Frame menjadi Array
7. Menstandarkan ukuran variable array
8. Menetukan dan konfigurasi K-Means dengan mengelompokan data atau menentukan nilai K
menjadi 5 Cluster
9. Menampilkan pusat Cluster
10. Tampilkan Hasil Cluster dan tambahkan kolom Cluster kedalam data frame
11. Visualisasi Hasil Cluster

Object X Y Z
OB-1 1 4 1
OB-2 1 2 2
OB-3 1 4 2
OB-4 2 1 2
OB-5 1 1 1
OB-6 2 4 2
OB-7 1 1 2
OB-8 2 1 1
Kasus berisi 8 objek dengan koordinat X, Y, dan Z-nya. kelompok objek-objek ini
terbagi menjadi dua cluster. Jadi, algoritma bekerja dengan:
Mengambil dua sentroid atau titik data (saat Anda mengambil 2 sebagai K maka jumlah
sentroid juga 2) di akunnya pada awalnya.
Setelah memilih sentroid, (katakanlah C1 dan C2) titik data (koordinat di sini) ditetapkan ke
salah satu Cluster (untuk saat ini, ambil sentroid = cluster) tergantung pada jarak antara
mereka dan sentroid.
Asumsikan bahwa algoritma memilih OB-2 (1,2,2) dan OB-6 (2,4,2) sebagai sentroid dan
juga cluster 1 dan cluster 2.
Untuk mengukur jarak, menggunakan fungsi pengukuran jarak berikut (juga disebut sebagai
fungsi pengukuran kesamaan):
$ d = | x2 - x1 | + | y2 - y1 | + | z2 - z1 | $
Ini juga dikenal sebagai jarak Taxicab atau jarak Manhattan , di mana d adalah pengukuran
jarak antara dua objek, (x1, y1, z1) dan (x2, y2, z2) adalah koordinat X, Y, dan Z dari dua
objek yang diambil untuk pengukuran jarak.
Bisa juga menggunakan fungsi pengukuran jarak lainnya seperti Euclidean Distance, Cosine
Distance, dll.
Tabel berikut menunjukkan penghitungan jarak (menggunakan fungsi pengukuran jarak di
atas) antara objek dan sentroid (OB-2 dan OB-6):
Objek X Y Z Jarak dari Jarak dari
C1 (1,2,2) C2 (2,4,2)
OB-1 1 4 1 3 2
OB-2 1 2 2 0 3
OB-3 1 4 2 2 1
OB-4 2 1 2 2 3
OB-5 1 1 1 2 5
OB-6 2 4 2 3 0
OB-7 1 1 2 1 4
OB-8 2 1 1 3 4
Objek-objek tersebut dikelompokkan berdasarkan jarak antar sentroid. Sebuah objek
yang memiliki jarak yang lebih pendek antara sentroid (katakanlah C1) daripada sentroid
lainnya (katakanlah C2) akan masuk ke dalam gugus C1. Setelah pengelompokan awal, objek
yang dikelompokkan akan terlihat seperti berikut:
Cluster 1 Cluster 2
OB-2 OB-1
OB-4 OB-3
OB-5 OB-6
OB-7
OB-8
Sekarang algoritma akan terus memperbarui pusat-pusat cluster (yaitu koordinat) sampai
mereka tidak dapat diperbarui lagi (lebih lanjut tentang ketika tidak dapat diperbarui nanti).
Pembaruan berlangsung dengan cara berikut:
(di mana n = jumlah objek yang termasuk dalam kluster tertentu)
Jadi, mengikuti aturan ini cluster 1 yang diperbarui akan menjadi ((1 + 2 + 1 + 1 + 2) / 5, (2 +
1 + 1 + 1 + 1) / 5, (2 + 2 + 1 + 2 + 1 ) / 5) = (1.4,1.2,1.6). Dan untuk cluster 2 adalah ((1 + 1 +
2) / 3, (4 + 4 + 4) / 3, (1 + 2 + 2) / 3) = (1.33, 4, 1.66).
Setelah ini, algoritma kembali mulai mencari jarak antara titik data dan sentroid klaster yang
baru diturunkan. Jadi jarak barunya akan seperti berikut:
Objek X Y Z Jarak dari Jarak dari
C1 C2 (1.33, 4,
(1.4,1.2,1.6) 1.66)
OB-1 1 4 1 3.8 1
OB-2 1 2 2 1.6 2.66
OB-3 1 4 2 3.6 0.66
OB-4 2 1 2 1.2 4
OB-5 1 1 1 1.2 4
OB-6 2 4 2 3.8 1
OB-7 1 1 2 1 3.66
OB-8 2 1 1 1.4 4.33
Tugas baru dari objek yang terkait dengan cluster yang diperbarui adalah:
cluster1 cluster2
OB-2 OB-1
OB-4 OB-3
OB-5 OB-6
OB-7
OB-8
Di sinilah algoritma tidak lagi memperbarui sentroid. Karena tidak ada perubahan
pada formasi cluster saat ini, maka sama dengan formasi sebelumnya.
Sekarang ketika, Anda telah selesai dengan pembentukan klaster dengan K-Means, Anda
dapat menerapkannya ke beberapa data yang belum pernah dilihat algoritma sebelumnya
(yang Anda sebut set Uji). Mari kita buat itu:
Objek X Y Z
OB-1 2 4 1
OB-2 2 2 2
OB-3 1 2 1
OB-4 2 2 1
Setelah menerapkan K-means pada dataset di atas, cluster terakhir adalah:

cluster 1 cluster 2
OB-2 OB-1
OB-3
OB-4
Penerapan algoritma apa pun tidak lengkap jika tidak yakin dengan kinerjanya. Sekarang,
untuk mengetahui seberapa baik performa algoritma K-Means, ada beberapa metrik yang
perlu dipertimbangkan. Beberapa metrik ini adalah:
Indeks rand yang disesuaikan
Pemberian skor berbasis informasi bersama
Homogenitas, kelengkapan, dan ukuran-v
Sekarang setelah terbiasa dengan mekanisme bagian dalam K-Means, mari kita lihat K-
Means secara langsung.
Studi kasus sederhana K-Means dengan Python:
Ini memiliki 12 fitur menangkap informasi tentang kelas penumpang, port_of_Embarkation,
passenger_faredll Label dataset adalah survival yang menunjukkan status survivial dari
penumpang tertentu. Tugasnya adalah mengelompokkan catatan menjadi dua yaitu orang
yang selamat dan yang tidak.
# Dependencies
import pandas as pd
import numpy as np
from sklearn.cluster import KMeans
from sklearn.preprocessing import LabelEncoder
from sklearn.preprocessing import MinMaxScaler
import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline
# Load the train and test datasets to create two DataFrames
train_url =
"http://s3.amazonaws.com/assets.datacamp.com/course/Kaggle/train.csv"
train = pd.read_csv(train_url)
test_url =
"http://s3.amazonaws.com/assets.datacamp.com/course/Kaggle/test.csv"
test = pd.read_csv(test_url)
Mari kita pratinjau jenis data yang akan Anda kerjakan dengan mencetak beberapa sampel
dari melatih dan menguji DataFrames.
print("***** Train_Set *****")

print(train.head())
print("\n")
print("***** Test_Set *****")
print(test.head())
***** Train_Set *****
PassengerId Survived Pclass \
0 1 0 3
1 2 1 1
2 3 1 3
3 4 1 1
4 5 0 3
Name Sex Age SibSp

\
0 Braund, Mr. Owen Harris male 22.0 1
1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0 1
2 Heikkinen, Miss. Laina female 26.0 0
3 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0 1
4 Allen, Mr. William Henry male 35.0 0
Parch Ticket Fare Cabin Embarked

0 0 A/5 21171 7.2500 NaN S
1 0 PC 17599 71.2833 C85 C
2 0 STON/O2. 3101282 7.9250 NaN S
3 0 113803 53.1000 C123 S
4 0 373450 8.0500 NaN S
***** Test_Set *****

PassengerId Pclass Name
Sex \
0 892 3 Kelly, Mr. James
male
1 893 3 Wilkes, Mrs. James (Ellen Needs)
female
2 894 2 Myles, Mr. Thomas Francis
male
3 895 3 Wirz, Mr. Albert
male
4 896 3 Hirvonen, Mrs. Alexander (Helga E Lindqvist)
female
Age SibSp Parch Ticket Fare Cabin Embarked

0 34.5 0 0 330911 7.8292 NaN Q
1 47.0 1 0 363272 7.0000 NaN S
2 62.0 0 0 240276 9.6875 NaN Q
3 27.0 0 0 315154 8.6625 NaN S
4 22.0 1 1 3101298 12.2875 NaN S
kita bisa mendapatkan beberapa statistik awal untuk melatih dan menguji DataFrames
menggunakan describe()metode pandas .
print(train.describe())
print("\n")
print(test.describe())
***** Train_Set *****
PassengerId Survived Pclass Age SibSp \
count 891.000000 891.000000 891.000000 714.000000 891.000000
mean 446.000000 0.383838 2.308642 29.699118 0.523008
std 257.353842 0.486592 0.836071 14.526497 1.102743
min 1.000000 0.000000 1.000000 0.420000 0.000000
25% 223.500000 0.000000 2.000000 20.125000 0.000000
50% 446.000000 0.000000 3.000000 28.000000 0.000000
75% 668.500000 1.000000 3.000000 38.000000 1.000000
max 891.000000 1.000000 3.000000 80.000000 8.000000
Parch Fare
count 891.000000 891.000000
mean 0.381594 32.204208
std 0.806057 49.693429
min 0.000000 0.000000
25% 0.000000 7.910400
50% 0.000000 14.454200
75% 0.000000 31.000000
max 6.000000 512.329200
***** Test_Set *****

PassengerId Pclass Age SibSp Parch
Fare
count 418.000000 418.000000 332.000000 418.000000 418.000000
417.000000
mean 1100.500000 2.265550 30.272590 0.447368 0.392344
35.627188
std 120.810458 0.841838 14.181209 0.896760 0.981429
55.907576
min 892.000000 1.000000 0.170000 0.000000 0.000000
0.000000
25% 996.250000 1.000000 21.000000 0.000000 0.000000
7.895800
50% 1100.500000 3.000000 27.000000 0.000000 0.000000
14.454200
75% 1204.750000 3.000000 39.000000 1.000000 0.000000
31.500000
max 1309.000000 3.000000 76.000000 8.000000 9.000000
512.329200
Jadi, dari keluaran di atas kita bisa mengetahui tentang fitur-fitur kumpulan data dan
beberapa statistik dasarnya.
print(train.columns.values)
['PassengerId' 'Survived' 'Pclass' 'Name' 'Sex' 'Age' 'SibSp' 'Parch'
'Ticket' 'Fare' 'Cabin' 'Embarked']
tidak semua algoritma pembelajaran mesin mendukung nilai yang hilang dalam data yang
Anda berikan kepada mereka. K-Means menjadi salah satunya. Jadi kita perlu menangani
nilai yang hilang yang ada dalam data. Pertama mari kita lihat di mana nilai-nilai yang hilang:
# For the train set

train.isna().head()
Mari kita dapatkan jumlah total nilai yang hilang di kedua set data.
print("*****In the train set*****")

print(train.isna().sum())
print("\n")
print("*****In the test set*****")
print(test.isna().sum())
*****In the train set*****
PassengerId 0
Survived 0
Pclass 0
Name 0
Sex 0
Age 177
SibSp 0
Parch 0
Ticket 0
Fare 0
Cabin 687
Embarked 2
dtype: int64
*****In the test set*****

PassengerId 0
Pclass 0
Name 0
Sex 0
Age 86
SibSp 0
Parch 0
Ticket 0
Fare 1
Cabin 327
Embarked 0
dtype: int64
di kolom Age, Cabin and Embarked, ada nilai yang hilang dan di set pengujian, kolom Age
dan Cabin berisi nilai yang hilang.
Ada beberapa cara untuk menangani nilai yang hilang:
 Hapus baris dengan nilai yang hilang
 Tunjukkan nilai-nilai yang hilang
Saya lebih suka yang terakhir karena jika Anda menghapus baris dengan nilai yang hilang, ini
dapat menyebabkan ketidakcukupan data yang pada gilirannya menghasilkan model
pembelajaran mesin yang tidak efisien.
Sekarang, ada beberapa cara untuk melakukan imputasi:
Nilai konstanta yang memiliki arti dalam domain, seperti 0, berbeda dari semua nilai lainnya.
Nilai dari rekaman lain yang dipilih secara acak.
Nilai rata-rata, median, atau mode untuk kolom.
Nilai yang diperkirakan oleh model pembelajaran mesin lain.
Setiap imputasi yang dilakukan pada set kereta harus dilakukan pada data pengujian di masa
mendatang saat prediksi diperlukan dari model pembelajaran mesin akhir. Ini perlu
dipertimbangkan ketika memilih bagaimana menghubungkan nilai-nilai yang hilang.
Panda menyediakan fillna()fungsi untuk mengganti nilai yang hilang dengan nilai tertentu.
Mari terapkan itu dengan Mean Imputation .
# Fill missing values with mean column values in the train set
train.fillna(train.mean(), inplace=True)
# Fill missing values with mean column values in the test set
test.fillna(test.mean(), inplace=True)
Sekarang setelah kita hitungkan nilai yang hilang dalam kumpulan data, sekarang saatnya
untuk melihat apakah kumpulan data masih memiliki nilai yang hilang.
PassengerId 0
Survived 0
Pclass 0
Name 0
Sex 0
Age 0
SibSp 0
Parch 0
Ticket 0
Fare 0
Cabin 687
Embarked 2
dtype: int64
Mari kita lihat apakah memiliki nilai yang hilang di set pengujian.
PassengerId 0
Pclass 0
Name 0
Sex 0
Age 0
SibSp 0
Parch 0
Ticket 0
Fare 0
Cabin 327
Embarked 0
dtype: int64
kita dapat melihat masih ada beberapa nilai yang hilang di kolom Kabin dan Memulai. Ini
karena nilai-nilai ini non-numerik. Untuk melakukan imputasi, nilai harus dalam bentuk
numerik. Ada cara untuk mengubah nilai non-numerik menjadi numerik. Lebih lanjut tentang
ini nanti.
Mari lakukan lebih banyak analisis untuk memahami data dengan lebih baik. Pemahaman
benar-benar diperlukan untuk melakukan tugas Machine Learning apa pun. Mari kita mulai
dengan mencari tahu fitur mana yang kategoris dan mana yang numerik.
Categorical: Survived, Sex, and Embarked. Ordinal: Pclass.

Berkelanjutan: Usia, Tarif. Diskrit: SibSp, Parch.
Ada dua fitur yang tidak tercantum di atas di salah satu kategori. Ya, Anda menebaknya
dengan benar, Tiket dan Kabin . Tiket adalah campuran tipe data numerik dan alfanumerik.
Kabin adalah alfanumerik. Mari kita lihat beberapa contoh nilai.
train['Ticket'].head()
0 A/5 21171
1 PC 17599
2 STON/O2. 3101282
3 113803
4 373450
Name: Ticket, dtype: object
train['Cabin'].head()
0 NaN
1 C85
2 NaN
3 C123
4 NaN
Name: Cabin, dtype: object
Jumlah penumpang yang selamat sehubungan dengan fitur-fitur berikut:
• Pclass
• Seks
• SibSp
• Parch
lakukan itu satu per satu:
Jumlah kelangsungan hidup sehubungan dengan Pclass:
train[['Pclass', 'Survived']].groupby(['Pclass'],
as_index=False).mean().sort_values(by='Survived', ascending=False)
Pclass Selamat
0 1 0,629630
1 2 0.472826
2 3 0,242363
Jumlah kelangsungan hidup sehubungan dengan Seks:
train[["Sex", "Survived"]].groupby(['Sex'],
Seks Selamat
0 Perempuan 0.742038
1 pria 0,188908
Anda bisa melihat tingkat kelangsungan hidup penumpang wanita jauh lebih
tinggi untuk pria.
Jumlah kelangsungan hidup sehubungan dengan SibSp:
train[["SibSp", "Survived"]].groupby(['SibSp'],
SibSp Selamat
1 1 0,535885
2 2 0.464286
0 0 0,345395
3 3 0.250000
4 4 0.166667
5 5 0.000000
6 8 0.000000
Sekarang saatnya untuk merencanakan secara cepat. Pertama-tama, mari kita
gambarkan grafik "Age vs. Survived":
g = sns.FacetGrid(train, col='Survived')
g.map(plt.hist, 'Age', bins=20)
<seaborn.axisgrid.FacetGrid at 0x7fa990f87080>
Saatnya untuk melihat bagaimana fitur Pclass dan Survived terkait satu sama
lain dengan grafik:
grid = sns.FacetGrid(train, col='Survived', row='Pclass', size=2.2,

aspect=1.6)
grid.map(plt.hist, 'Age', alpha=.5, bins=20)
grid.add_legend();
Cukup visualisasi dan analitik untuk saat ini! Mari kita buat model K-Means dengan set
pelatihan. Tetapi sebelum itu Anda juga membutuhkan beberapa pemrosesan data. Anda
dapat melihat bahwa tidak semua nilai fitur memiliki tipe yang sama. Beberapa di antaranya
numerik dan beberapa tidak. Untuk memudahkan penghitungan, Anda akan memasukkan
semua data numerik ke model. Mari kita lihat tipe data dari berbagai fitur yang Anda miliki:
train.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 12 columns):
PassengerId 891 non-null int64
Survived 891 non-null int64
Pclass 891 non-null int64
Name 891 non-null object
Sex 891 non-null object
Age 891 non-null float64
SibSp 891 non-null int64
Parch 891 non-null int64
Ticket 891 non-null object
Fare 891 non-null float64
Cabin 204 non-null object
Embarked 889 non-null object
dtypes: float64(2), int64(5), object(5)
memory usage: 83.6+ KB
fitur-fitur berikut ini non-numerik:
• Name
• Seks
• Tiket
• Kabin
• Embarked
Sebelum mengubahnya menjadi numerik, ada baiknya Anda melakukan beberapa rekayasa
fitur, yaitu fitur-fitur seperti Nama, Tiket, Kabin dan Embarked tidak berdampak pada status
kelangsungan hidup penumpang. Seringkali, lebih baik melatih model Anda hanya dengan
fitur yang signifikan daripada melatihnya dengan semua fitur, termasuk yang tidak perlu. Ini
tidak hanya membantu dalam pemodelan yang efisien, tetapi juga pelatihan model dapat
terjadi dalam waktu yang jauh lebih singkat. Meskipun, rekayasa fitur adalah bidang studi itu
sendiri, saya akan mendorong Anda untuk menggalinya lebih jauh. Tetapi untuk tutorial ini,
ketahuilah bahwa fitur Name, Ticket, Cabin dan Embarked dapat dihilangkan dan tidak akan
berdampak signifikan pada pelatihan model K-Means.
train = train.drop(['Name','Ticket', 'Cabin','Embarked'], axis=1)

test = test.drop(['Name','Ticket', 'Cabin','Embarked'], axis=1)
Sekarang setelah bagian menjatuhkan selesai, mari kita ubah fitur 'Sex' menjadi numerik
(hanya 'Sex' yang tersisa sekarang yang merupakan fitur non-numerik). Anda akan
melakukan ini menggunakan teknik yang disebut Label Encoding .
labelEncoder = LabelEncoder()
labelEncoder.fit(train['Sex'])
labelEncoder.fit(test['Sex'])
train['Sex'] = labelEncoder.transform(train['Sex'])
test['Sex'] = labelEncoder.transform(test['Sex'])
# Let's investigate if you have non-numeric data left
train.info()
Sex 891 non-null int64
dtypes: float64(2), int64(6)
memory usage: 55.8 KB
Perhatikan bahwa set pengujian tidak memiliki fitur Survived.
test.info()
Kolom Survival dapat dijatuhkan dari data dengan drop()fungsi tersebut.
X = np.array(train.drop(['Survived'], 1).astype(float))
y = np.array(train['Survived'])
Anda dapat meninjau semua fitur yang akan Anda masukkan ke algoritma
train.info().
train.info()
Sekarang mari kita buat model K-Means.
kmeans = KMeans(n_clusters=2) # You want cluster the passenger records into

2: Survived or Not survived
kmeans.fit(X)
KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=300,
n_clusters=2, n_init=10, n_jobs=1, precompute_distances='auto',
random_state=None, tol=0.0001, verbose=0)
Anda dapat melihat semua parameter lain dari model selain n_clusters. Mari kita lihat
seberapa baik model tersebut bekerja dengan melihat persentase catatan penumpang yang
dikelompokkan dengan benar.
correct = 0
for i in range(len(X)):
predict_me = np.array(X[i].astype(float))
predict_me = predict_me.reshape(-1, len(predict_me))
prediction = kmeans.predict(predict_me)
if prediction[0] == y[i]:
correct += 1
print(correct/len(X))
0.5084175084175084
Model ini dapat mengelompokkan dengan benar dengan 50% (akurasi model Anda). Tetapi
untuk meningkatkan kinerja model, Anda dapat mengubah beberapa parameter model itu
sendiri. Saya akan membuat daftar beberapa parameter ini yang disediakan oleh implementasi
scikit-learn dari K-Means:
• algoritma
• maks_iter
• n_jobs
Mari kita sesuaikan nilai parameter ini dan lihat apakah ada perubahan pada hasilnya.
Dalam dokumentasi scikit-learn , Anda akan menemukan informasi yang solid tentang
parameter ini yang harus Anda gali lebih jauh.
kmeans = kmeans = KMeans(n_clusters=2, max_iter=600, algorithm = 'auto')

kmeans.fit(X)
correct = 0
correct += 1
0.49158249158249157
Anda dapat melihat penurunan skor. Salah satu alasannya adalah Anda belum menskalakan
nilai dari berbagai fitur yang Anda masukkan ke model. Fitur dalam kumpulan data berisi
rentang nilai yang berbeda. Jadi, yang terjadi adalah perubahan kecil pada suatu fitur tidak
mempengaruhi fitur lainnya. Jadi, penting juga untuk menskalakan nilai fitur ke rentang yang
sama.
Mari lakukan itu sekarang dan untuk percobaan ini Anda akan menggunakan 0 - 1 sebagai
rentang nilai seragam di semua fitur.
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
kmeans.fit(X_scaled)
correct = 0
correct += 1
0.6262626262626263
peningkatan skor instan sebesar 12%.
Sekarang, mari kita bahas batasan K-Means.
Kekurangan K-Means
Sekarang Anda memiliki ide yang cukup bagus tentang bagaimana algoritma K-Means
bekerja, mari kita bahas beberapa kelemahannya.
Kerugian terbesarnya adalah K-Means mengharuskan Anda untuk menentukan jumlah cluster
(k). Namun, untuk kumpulan data Titanic, Anda memiliki beberapa pengetahuan domain
yang tersedia yang memberi tahu Anda jumlah orang yang selamat di bangkai kapal. Ini
mungkin tidak selalu terjadi pada kumpulan data dunia nyata. Pengelompokan hierarki
merupakan pendekatan alternatif yang tidak memerlukan pilihan klaster tertentu. Kerugian
tambahan dari k-means adalah peka terhadap pencilan dan hasil yang berbeda dapat terjadi
jika Anda mengubah urutan data.
K-Means adalah pelajar yang malas di mana generalisasi data pelatihan ditunda hingga kueri
dibuat ke sistem. Ini berarti K-Means mulai bekerja hanya saat Anda memicunya, sehingga
metode pembelajaran yang lambat dapat membuat perkiraan atau hasil yang berbeda ke
fungsi target untuk setiap kueri yang ditemukan. Ini adalah metode yang baik untuk
pembelajaran online, tetapi memerlukan kemungkinan memori yang besar untuk menyimpan
data, dan setiap permintaan melibatkan memulai identifikasi model lokal dari awal.
Kesimpulan
Jadi, dalam tutorial ini Anda telah membahas permukaan salah satu teknik pengelompokan
paling populer - K-Means. Anda mempelajari tentang mekanisme dalamnya,
mengimplementasikannya menggunakan Set Data Titanic dengan Python, dan Anda juga
mendapat gambaran yang adil tentang kerugiannya. Jika Anda ingin mempelajari lebih lanjut
tentang teknik pengelompokan ini, saya sangat menyarankan Anda untuk melihat kursus
Pembelajaran Tanpa Pengawasan dengan Python kami .
Nama : Nanda Tri Haryati
NIM /Kelas : 202420016/ MTI-REG A
TUGAS 03
Terima kasih.
Source Code
import numpy as np
import pandas as pd
from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram, linkage
from sklearn.metrics import silhouette_score
from sklearn.preprocessing import StandardScaler

from sklearn.decomposition import PCA
from sklearn.metrics.pairwise import cosine_similarity
import matplotlib.pyplot as pltfrom
#import datasheet
from google.colab import drive
drive.mount('/content/drive')
data_path = r'drive/My Drive/Colab Notebooks/tempat_data.csv'
tempatdata = pd.read_csv (data_path,encoding = 'utf-8',
index_col = ['object'])
# print first rows of datasheet

print(tempatdata.head())
# from sklearn.cluster import KMeans

clusters = 3
kmeans = KMeans(n_clusters = clusters)
kmeans.fit(tempatdata)
print(kmeans.labels_)
# from sklearn.decomposition import PCA - EDA ANALISIS
pca = PCA(3)
pca.fit(tempatdata)
pca_data = pd.DataFrame(pca.transform(tempatdata))
print(pca_data.head())
#membuat 3D
from matplotlib import colors as mcolors
import math
''' Generating different colors in ascending order

of their hsv values '''
colors = list(zip(*sorted((
tuple(mcolors.rgb_to_hsv(
mcolors.to_rgba(color)[:3])), name)
for name, color in dict(
mcolors.BASE_COLORS, **mcolors.CSS
4_COLORS
).items(
))))[1]
# number of steps to taken generate n(clusters) colors

skips = math.floor(len(colors[5 : -5])/clusters)
cluster_colors = colors[5 : -5 : skips]
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = fig.add_subplot(111, projection = '3d')
ax.scatter(pca_data[0], pca_data[1], pca_data[2],
c = list(map(lambda label : cluster_colors[label],
kmeans.labels_)))
str_labels = list(map(lambda label:'% s' % label, kmeans.label

s_))
list(map(lambda data1, data2, data3, str_label:

ax.text(data1, data2, data3, s = str_label, size = 16.
5,
zorder = 20, color = 'k'), pca_data[0], pca_data[1],
pca_data[2], str_labels))
plt.show()
#SEABORN
# generating correlation heatmap

sns.heatmap(tempatdata.corr(), annot = True)
# posting correlation heatmap to output console

plt.show()
#matplotlib
from matplotlib import cm
# generating correlation data

df = tempatdata.corr()
df.index = range(0, len(df))
df.rename(columns = dict(zip(df.columns, df.index)), inplace =
True)
df = df.astype(object)
''' Generating coordinates with

corresponding correlation values '''
for i in range(0, len(df)):
for j in range(0, len(df)):
if i != j:
df.iloc[i, j] = (i, j, df.iloc[i, j])
else :
df.iloc[i, j] = (i, j, 0)
df_list = []
# flattening dataframe values

for sub_list in df.values:
df_list.extend(sub_list)
# converting list of tuples into trivariate dataframe
plot_df = pd.DataFrame(df_list)
fig = plt.figure()
ax = Axes3D(fig)
# plotting 3D trisurface plot

ax.plot_trisurf(plot_df[0], plot_df[1], plot_df[2],
cmap = cm.jet, linewidth = 0.2)
plt.show()
Hasil Pengelompokkan dan tampilannya

TUGAS 03
NAMA : OMAN ARROHMAN
NIM : 202420042
KELAS : REGULAR A
Untuk dataset berikut ini, buat program di python untuk mengcluster data-data tersebut. Lampirkan
source code python dan hasil pengelompokkan nya.
Jawab :
Tugas 03
# -*- coding: utf-8 -*-
"""K-Means.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1RcaAfAiD0mon17jWXcVM6xqnX7QK9rME
"""
import numpy as np
import random
from collections import Counter
from mpl_toolkits.mplot3d import axes3d
# 3-dimensional plot showing clusters
def plot(file_input,file_output):
fig = plt.figure()
X,Y,Z = [],[],[]
for line in file_input:

[x,y,z] = map(float,line.strip().split())
X.append(x)
Y.append(y)
Z.append(z)
A,B,C = [],[],[]
for line in file_output:
[a,b,c] = map(float,line.strip().split())
A.append(a)
B.append(b)
C.append(c)
ax.scatter(X,Y,Z, c='b', marker ='o')
ax.scatter(A,B,C, c='r', marker ='x')
plt.show()
from google.colab import files
points = files.upload()
file_name = "points.txt"
points[file_name].decode("utf-8")
#points[file_name].decode("utf-8").split("\r\n")
# Inputs from points.txt
points = {}
with open('points.txt','r') as f:
obj = list(enumerate(f))
for point in obj:
points[point[0]] = map(float,point[1].strip().split())
centroids = {}
def initialize_centroid(K):
for i in range(K):
arr = []
for k in range(3):
arr.append(round(random.uniform(1,10),1))
centroids[i] = arr
C = {}
def assign_centroids():
for p1,p2 in points.items():
min_dist = float('inf')
for c1,c2 in centroids.items():
vector = [a_i - b_i for a_i,b_i in zip(p2,c2)]
# print (p1,p2,c1,c2,(np.linalg.norm(vector)))
if(min_dist != min(np.linalg.norm(vector),min_dist)):
min_dist = np.linalg.norm(vector)
C[p1]=c1
def update_centroids():
for key in centroids.keys():
arr = [0,0,0]
for p,c in C.items():
if(c == key):
arr = [a+b for a,b in zip(arr,points[p])]
try:
centroids[key] = [x/count[key] for x in arr]
except:
print("Zero division error: Reinitializing")
initialize_centroid(1)
# Initializing and iterating through cluster assignment and update
centroids_prev = {}
#while cmp(centroids_prev,centroids)!=0:
# assign_centroids()
# count = Counter(values for values in C.values())
# centroids_prev = dict(centroids)
# update_centroids()
# Output to clusters.txt
f = open('clusters.txt','w')
for key,value in centroids.items():

centroids[key] = [ round(elem, 2) for elem in value ]
f.write(' '.join(str(v) for v in centroids[key])+"\n")
f.close()
# Plotting the results
f_out = open('clusters.txt','r')
f_in = open('points.txt','r')
plot(f_in,f_out)
f_out.close()
f_in.close()
{
"nbformat": 4,
"nbformat_minor": 0,
"metadata": {
"colab": {
"name": "K-Means.ipynb",
"provenance": []
},
"kernelspec": {
"name": "python3",
"display_name": "Python 3"
},
"cells": [
"cell_type": "code",
"metadata": {
"id": "LbeDTcjYq4l5"
},
"source": [
"import numpy as np\n",
"import random\n",
"from collections import Counter\n",
"from mpl_toolkits.mplot3d import Axes3D\n",
"from mpl_toolkits.mplot3d import axes3d\n",

"import matplotlib.pyplot as plt"
],
"execution_count": 105,
"outputs": []
},
"metadata": {
"id": "PizufLCqq-Bt"
},
"source": [
"# 3-dimensional plot showing clusters\n",
"def plot(file_input,file_output):\n",
"\tfig = plt.figure()\n",
"\tax = fig.add_subplot(111, projection = '3d')\n",
"\tX,Y,Z = [],[],[]\n",
"\tfor line in file_input:\n",
"\t\t[x,y,z] = map(float,line.strip().split())\n",
"\t\tX.append(x)\n",
"\t\tY.append(y)\n",
"\t\tZ.append(z)\n",
"\n",
"\tA,B,C = [],[],[]\n",
"\tfor line in file_output:\n",
"\t\t[a,b,c] = map(float,line.strip().split())\n",
"\t\tA.append(a)\n",
"\t\tB.append(b)\n",
"\t\tC.append(c)\n",
"\n",
"\tax.scatter(X,Y,Z, c='b', marker ='o')\n",
"\tax.scatter(A,B,C, c='r', marker ='x')\n",
"\n",
"\tplt.show()"
],
"outputs": []
},
"metadata": {
"id": "3c5qgtcJvUUu",
"outputId": "6c20f741-0e50-49d8-f7ea-6b601663bb0e",
"colab": {
"resources": {
"http://localhost:8080/nbextensions/google.colab/files.js": {
"data": " "ok": true,
"headers": [
"content-type",
"application/javascript"
]
],
"status": 200,
"status_text": "OK"
},
"base_uri": "https://localhost:8080/",
"height": 75
},
"source": [
"from google.colab import files\n",
"points = files.upload()"
],
"outputs": [
"output_type": "display_data",
"data": {
"text/html": [
"\n",
" <input type=\"file\" id=\"files-418daf38-d6f7-4923-aaf3-8fe8774fb985\" name=\"files[]\"

multiple disabled\n",
" style=\"border:none\" />\n",
" <output id=\"result-418daf38-d6f7-4923-aaf3-8fe8774fb985\">\n",
" Upload widget is only available when the cell has been executed in the\n",
" current browser session. Please rerun this cell to enable.\n",
" </output>\n",
" <script src=\"/nbextensions/google.colab/files.js\"></script> "
],
"text/plain": [
"<IPython.core.display.HTML object>"
},
"metadata": {
"tags": []
},
"output_type": "stream",
"text": [
"Saving points.txt to points (13).txt\n"
],
"name": "stdout"
},
"metadata": {
"id": "jc9u0uPPv55x",
"outputId": "c0350ef5-267b-4e13-b4b2-cc01936abbd1",
"colab": {
"height": 36
},
"source": [
"file_name = \"points.txt\"\n",
"points[file_name].decode(\"utf-8\")"
],
"outputs": [
"output_type": "execute_result",
"data": {
"application/vnd.google.colaboratory.intrinsic+json": {
"type": "string"
},
"text/plain": [
"'1.0 4.0 1.0\\n1.0 2.0 2.0\\n1.0 4.0 2.0\\n2.0 1.0 2.0\\n1.0 1.0 1.0\\n2.0 4.0 2.0\\n1.0 1.0
2.0\\n2.0 1.0 1.0'"
},
"metadata": {
"tags": []
},
"execution_count": 108
},
"metadata": {
"id": "ghOhsU26v88t"
},
"source": [
"#points[file_name].decode(\"utf-8\").split(\"\\r\\n\")"
],
"outputs": []
},
"metadata": {
"id": "DPb6j_wIrBiQ"
},
"source": [
"# Inputs from points.txt\n",
"points = {}\n",
"with open('points.txt','r') as f:\n",
"\tobj = list(enumerate(f))\n",
"\tfor point in obj:\n",
"\t\tpoints[point[0]] = map(float,point[1].strip().split())\n",
"\n",
"centroids = {}\n",
"def initialize_centroid(K):\n",
"\tfor i in range(K):\n",
"\t\tarr = []\n",
"\t\tfor k in range(3):\n",
"\t\t\tarr.append(round(random.uniform(1,10),1))\n",
"\t\tcentroids[i] = arr\n",
"\n",
"C = {}\n",
"def assign_centroids():\n",
"\tfor p1,p2 in points.items():\n",
"\t\tmin_dist = float('inf')\n",
"\t\tfor c1,c2 in centroids.items():\n",
"\t\t\tvector = [a_i - b_i for a_i,b_i in zip(p2,c2)]\n",
"\t\t\t# print (p1,p2,c1,c2,(np.linalg.norm(vector)))\n",
"\t\t\tif(min_dist != min(np.linalg.norm(vector),min_dist)):\n",
"\t\t\t\tmin_dist = np.linalg.norm(vector)\n",
"\t\t\t\tC[p1]=c1\n",
"\n",
"def update_centroids():\n",
"\tfor key in centroids.keys():\n",
"\t\tarr = [0,0,0]\n",
"\t\tfor p,c in C.items():\n",
"\t\t\tif(c == key):\n",
"\t\t\t\tarr = [a+b for a,b in zip(arr,points[p])]\n",
"\t\ttry:\n",
"\t\t\tcentroids[key] = [x/count[key] for x in arr]\n",
"\t\texcept:\n",
"\t\t\tprint(\"Zero division error: Reinitializing\")\n",
"\t\t\tinitialize_centroid(1)\n",
"\n",
"# Initializing and iterating through cluster assignment and update\n",
"initialize_centroid(1)\n",
"centroids_prev = {}\n",
"#while cmp(centroids_prev,centroids)!=0:\n",
"#\tassign_centroids()\n",
"#\tcount = Counter(values for values in C.values())\n",
"#\tcentroids_prev = dict(centroids)\n",
"#\tupdate_centroids()"
],
"outputs": []
},
"metadata": {
"id": "mcDx54QHroIj",
"outputId": "e0b63216-9ebd-4ce4-b6cf-347f72d02238",
"colab": {
"height": 248
},
"source": [
"# Output to clusters.txt\t\n",
"f = open('clusters.txt','w')\n",
"for key,value in centroids.items():\n",
"\tcentroids[key] = [ round(elem, 2) for elem in value ]\n",
"\tf.write(' '.join(str(v) for v in centroids[key])+\"\\n\")\n",
"f.close()\n",
"\n",
"# Plotting the results\n",
"f_out = open('clusters.txt','r')\n",
"f_in = open('points.txt','r')\n",
"plot(f_in,f_out)\n",
"f_out.close()\n",
"f_in.close()"
],
"outputs": [
"output_type": "display_data",
"data": {
"metadata": {
"tags": [],
"needs_background": "light"
}
1.0 4.0 1.0
1.0 2.0 2.0
1.0 4.0 2.0
2.0 1.0 2.0
1.0 1.0 1.0
2.0 4.0 2.0
1.0 1.0 2.0
2.0 1.0 1.0

Nama : Robby Prabowo
NIM : 202420001
Kelas : MTIA1
import numpy as np
import random

fig = plt.figure()
X,Y,Z = [],[],[]
X.append(x)
Y.append(y)
Z.append(z)
A,B,C = [],[],[]
A.append(a)
B.append(b)
C.append(c)

plt.show()

points = {}
for point in obj:
centroids = {}
for i in range(K):
arr = []
for k in range(3):
centroids[i] = arr
C = {}
C[p1]=c1
arr = [0,0,0]
if(c == key):
try:
except:

centroids_prev = {}
f.close()

plot(f_in,f_out)
f_out.close()
f_in.close()
Gambar hasil pengolahan melalui aplikasi phyton.

TUGAS 03
Terima kasih.
Source Code :
import numpy as np
#%matplotlib inline
from sklearn.cluster import DBSCAN
data = np.array([[1, 4 , 1],

[1, 2, 2],
[1, 4, 2],
[2, 1, 2],
[1, 1, 1],
[2, 4, 2],
[1, 1, 2],
[2, 1, 1],])
fig = plt.figure()
ax = Axes3D(fig)
ax.scatter(data[:,0], data[:,1], data[:,2], s=300)
ax.view_init(azim=200)
plt.show()
model = DBSCAN(eps=1, min_samples=2)
model.fit_predict(data)
pred = model.fit_predict(data)
fig = plt.figure()
ax = Axes3D(fig)
ax.scatter(data[:,0], data[:,1], data[:,2], c=model.labels_, s=300)
plt.show()
print("number of cluster found: {}".format(len(set(model.labels_))))

print('cluster for each point: ', model.labels_)
output :
sebelum clustering
Setelah clustering
number of cluster found: 2

cluster for each point: [0 1 0 1 1 0 1 1]
NIM : 202420041
Name : Wahyu Putra Adi Wibowo
1. Menampilkan data dari dataset
2. Menampilkan hasil data dari setiap variable
3. Menghilangkan variable yang tidak perlu, dalam hal ini digunakan variable X dan Y
4. Menentukan entukan Variable yang akan di Klusterkan yaitu variable X dan Variable Y
5. Tampilkan Penyebaran datanya

menjadi 5 Cluster

NAMA : WIDIA ASTUTI
NIM : 202420021
MATA KULIAH : ADVANCED DATABASE
TUGAS 3 :
Untuk dataset berikut ini, buat program di python untuk mengcluster data-data
tersebut. Lampirkan source code python dan hasil pengelompokkan nya.
Terima kasih.
# import library
File phyton
https://drive.google.com/drive/folders/1zK855_GUzeV9fujKOZD2a1k2c54NStGx?usp=s
haring
----
import numpy as np
import pandas as pd
#import datasheet
data_path = r'drive/My Drive/Colab Notebooks/data_tugas.csv'



clusters = 3
pca = PCA(3)
pca.fit(tempatdata)
#membuat 3D
import math

of their hsv
values '''
mcolors.to_rgba(color)[:3])
), name)
mcolors.BASE_COLORS, *
*mcolors.CSS4_COLORS
).items())))[1]

fig = plt.figure()
kmeans.labels_)))
str_labels = list(map(lambda label:'% s' % label, kmeans.labels_))

ax.text(data1, data2, data3, s = str_label, size = 16.5
,
plt.show()
Output Phyton
Output

clusters = 3
pca = PCA(3)
pca.fit(tempatdata)
Output
#membuat 3D - Scatter x y z
import math
of their hsv
values '''
), name)
).items())))[1]

fig = plt.figure()
kmeans.labels_)))

,
plt.show()
Output
TUGAS CLUSTERING IN PHYTON
Dibuat Oleh
Aan Novrianto
Dosen Pengampu
TRI BASUKI KURNIAWAN, S.Kom, M.Eng, Ph.D
Program Pasca Sarjana

Universitas Binadarma Palembang
2020/2021
# import library
File phyton
https://drive.google.com/drive/folders/1zK855_GUzeV9fujKOZD2a1k2c54NStG
x?usp=sharing
----
import numpy as np
import pandas as pd
#import datasheet
data_path = r'drive/My Drive/Colab Notebooks/tes.csv'



clusters = 3
pca = PCA(3)
pca.fit(tempatdata)
#membuat 3D
import math

mcolors.BASE_COLORS, **mcolors.CSS4_COLORS
).items())))[1]

fig = plt.figure()
kmeans.labels_)))

ax.text(data1, data2, data3, s = str_label, size = 16.5,
plt.show()
#SEABORN


plt.show()
#matplotlib

df.rename(columns = dict(zip(df.columns, df.index)), inplace = True)
if i != j:
else :
df_list = []


fig = plt.figure()
ax = Axes3D(fig)

plt.show()
Output Phyton

Output

clusters = 3
pca = PCA(3)
pca.fit(tempatdata)
Output
import math

mcolors.BASE_COLORS, **mcolors.CSS4_COLORS
).items())))[1]

fig = plt.figure()
kmeans.labels_)))

ax.text(data1, data2, data3, s = str_label, size = 16.5,
plt.show()
Output
#SEABORN


plt.show()
Output
#matplotlib

df.rename(columns = dict(zip(df.columns, df.index)), inplace = True)

if i != j:
else :
df_list = []

fig = plt.figure()
ax = Axes3D(fig)

plt.show()
Object X Y Z
OB-1 1 4 1
OB-2 1 2 2
OB-3 1 4 2
OB-4 2 1 2
OB-5 1 1 1
OB-6 2 4 2
OB-7 1 1 2
OB-8 2 1 1
Kasus berisi 8 objek dengan koordinat X, Y, dan Z-nya. kelompok objek-objek ini terbagi menjadi dua
cluster.
Jadi, algoritme bekerja dengan:
Mengambil dua sentroid atau titik data (saat Anda mengambil 2 sebagai K maka jumlah sentroid juga
2) di akunnya pada awalnya.
Setelah memilih sentroid, (katakanlah C1 dan C2) titik data (koordinat di sini) ditetapkan ke salah
satu Cluster (untuk saat ini, ambil sentroid = cluster) tergantung pada jarak antara mereka dan
sentroid.
Asumsikan bahwa algoritma memilih OB-2 (1,2,2) dan OB-6 (2,4,2) sebagai sentroid dan juga cluster
1 dan cluster 2.
Untuk mengukur jarak, menggunakan fungsi pengukuran jarak berikut (juga disebut sebagai fungsi
pengukuran kesamaan):
$ d = | x2 - x1 | + | y2 - y1 | + | z2 - z1 | $
Ini juga dikenal sebagai jarak Taxicab atau jarak Manhattan , di mana d adalah pengukuran jarak
antara dua objek, (x1, y1, z1) dan (x2, y2, z2) adalah koordinat X, Y, dan Z dari dua objek yang diambil
untuk pengukuran jarak.
Bisa juga menggunakan fungsi pengukuran jarak lainnya seperti Euclidean Distance, Cosine Distance,
dll.
Tabel berikut menunjukkan penghitungan jarak (menggunakan fungsi pengukuran jarak di atas)
antara objek dan sentroid (OB-2 dan OB-6):
Objek X Y Z Jarak dari C1 Jarak dari C2

(1,2,2) (2,4,2)
OB-1 1 4 1 3 2
OB-2 1 2 2 0 3
OB-3 1 4 2 2 1
OB-4 2 1 2 2 3
OB-5 1 1 1 2 5
OB-6 2 4 2 3 0
OB-7 1 1 2 1 4
OB-8 2 1 1 3 4
Objek-objek tersebut dikelompokkan berdasarkan jarak antar sentroid. Sebuah objek yang memiliki
jarak yang lebih pendek antara sentroid (katakanlah C1) daripada sentroid lainnya (katakanlah C2)
akan masuk ke dalam gugus C1. Setelah pengelompokan awal, objek yang dikelompokkan akan
terlihat seperti berikut:
Cluster 1 Cluster 2
OB-2 OB-1
OB-4 OB-3
OB-5 OB-6
OB-7
OB-8
Sekarang algoritme akan terus memperbarui pusat-pusat cluster (yaitu koordinat) sampai mereka
tidak dapat diperbarui lagi (lebih lanjut tentang ketika tidak dapat diperbarui nanti). Pembaruan
berlangsung dengan cara berikut:
(di mana n = jumlah objek yang termasuk dalam kluster tertentu)
Jadi, mengikuti aturan ini cluster 1 yang diperbarui akan menjadi ((1 + 2 + 1 + 1 + 2) / 5, (2 + 1 + 1 + 1
+ 1) / 5, (2 + 2 + 1 + 2 + 1 ) / 5) = (1.4,1.2,1.6). Dan untuk cluster 2 adalah ((1 + 1 + 2) / 3, (4 + 4 + 4) /
3, (1 + 2 + 2) / 3) = (1.33, 4, 1.66).
Setelah ini, algoritme kembali mulai mencari jarak antara titik data dan sentroid klaster yang baru
diturunkan. Jadi jarak barunya akan seperti berikut:
Objek X Y Z Jarak dari C1 Jarak dari C2

(1.4,1.2,1.6) (1.33, 4, 1.66)
OB-1 1 4 1 3.8 1
OB-2 1 2 2 1.6 2.66
OB-3 1 4 2 3.6 0.66
OB-4 2 1 2 1.2 4
OB-5 1 1 1 1.2 4
OB-6 2 4 2 3.8 1
OB-7 1 1 2 1 3.66
OB-8 2 1 1 1.4 4.33
Tugas baru dari objek yang terkait dengan cluster yang diperbarui adalah:
cluster1 cluster2
OB-2 OB-1
OB-4 OB-3
OB-5 OB-6
OB-7
OB-8
Di sinilah algoritme tidak lagi memperbarui sentroid. Karena tidak ada perubahan pada formasi
cluster saat ini, maka sama dengan formasi sebelumnya.
Sekarang ketika, Anda telah selesai dengan pembentukan klaster dengan K-Means, Anda dapat
menerapkannya ke beberapa data yang belum pernah dilihat algoritme sebelumnya (yang Anda
sebut set Uji). Mari kita buat itu:
Objek X Y Z
OB-1 2 4 1
OB-2 2 2 2
OB-3 1 2 1
OB-4 2 2 1
Setelah menerapkan K-means pada dataset di atas, cluster terakhir adalah:
cluster 1 cluster 2
OB-2 OB-1
OB-3
OB-4
Penerapan algoritme apa pun tidak lengkap jika tidak yakin dengan kinerjanya. Sekarang, untuk
mengetahui seberapa baik performa algoritma K-Means, ada beberapa metrik yang perlu
dipertimbangkan. Beberapa metrik ini adalah:
Indeks rand yang disesuaikan
Pemberian skor berbasis informasi bersama
Homogenitas, kelengkapan, dan ukuran-v
Sekarang setelah terbiasa dengan mekanisme bagian dalam K-Means, mari kita lihat K-Means secara
langsung.
Studi kasus sederhana K-Means dengan Python:
Ini memiliki 12 fitur menangkap informasi tentang kelas penumpang, port_of_Embarkation,

passenger_faredll Label dataset adalah survival yang menunjukkan status survivial dari penumpang
tertentu. Tugasnya adalah mengelompokkan catatan menjadi dua yaitu orang yang selamat dan
yang tidak.
# Dependencies
import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder
%matplotlib inline
# Load the train and test datasets to create two DataFrames
train_url =
"http://s3.amazonaws.com/assets.datacamp.com/course/Kaggle/train.csv
"
train = pd.read_csv(train_url)
test_url =
"http://s3.amazonaws.com/assets.datacamp.com/course/Kaggle/test.csv"
test = pd.read_csv(test_url)
Mari kita pratinjau jenis data yang akan Anda kerjakan dengan mencetak beberapa sampel dari
melatih dan menguji DataFrames.

print(train.head())
print("\n")
print(test.head())
***** Train_Set *****
PassengerId Survived Pclass \
0 1 0 3
1 2 1 1
2 3 1 3
3 4 1 1
4 5 0 3
Name Sex Age
SibSp \
0 Braund, Mr. Owen Harris male 22.0
1
1 Cumings, Mrs. John Bradley (Florence Briggs Th... female 38.0
1
2 Heikkinen, Miss. Laina female 26.0
0
3 Futrelle, Mrs. Jacques Heath (Lily May Peel) female 35.0
1
4 Allen, Mr. William Henry male 35.0
0
Parch Ticket Fare Cabin Embarked

0 0 A/5 21171 7.2500 NaN S
1 0 PC 17599 71.2833 C85 C
2 0 STON/O2. 3101282 7.9250 NaN S
3 0 113803 53.1000 C123 S
4 0 373450 8.0500 NaN S
***** Test_Set *****

PassengerId Pclass Name
Sex \
0 892 3 Kelly, Mr. James
male
1 893 3 Wilkes, Mrs. James (Ellen Needs)
female
2 894 2 Myles, Mr. Thomas Francis
male
3 895 3 Wirz, Mr. Albert
male
4 896 3 Hirvonen, Mrs. Alexander (Helga E Lindqvist)
female
Age SibSp Parch Ticket Fare Cabin Embarked

0 34.5 0 0 330911 7.8292 NaN Q
1 47.0 1 0 363272 7.0000 NaN S
2 62.0 0 0 240276 9.6875 NaN Q
3 27.0 0 0 315154 8.6625 NaN S
4 22.0 1 1 3101298 12.2875 NaN S
kita bisa mendapatkan beberapa statistik awal untuk melatih dan menguji DataFrames
menggunakan describe()metode pandas .
print(train.describe())
print("\n")
print(test.describe())
***** Train_Set *****
PassengerId Survived Pclass Age SibSp
\
count 891.000000 891.000000 891.000000 714.000000 891.000000
mean 446.000000 0.383838 2.308642 29.699118 0.523008
std 257.353842 0.486592 0.836071 14.526497 1.102743
min 1.000000 0.000000 1.000000 0.420000 0.000000
25% 223.500000 0.000000 2.000000 20.125000 0.000000
50% 446.000000 0.000000 3.000000 28.000000 0.000000
75% 668.500000 1.000000 3.000000 38.000000 1.000000
max 891.000000 1.000000 3.000000 80.000000 8.000000
Parch Fare
count 891.000000 891.000000
mean 0.381594 32.204208
std 0.806057 49.693429
min 0.000000 0.000000
25% 0.000000 7.910400
50% 0.000000 14.454200
75% 0.000000 31.000000
max 6.000000 512.329200
***** Test_Set *****
PassengerId Pclass Age SibSp Parch Fare
count 418.000000 418.000000 332.000000 418.000000 418.000000 417.000000
mean 1100.500000 2.265550 30.272590 0.447368 0.392344 35.627188
std 120.810458 0.841838 14.181209 0.896760 0.981429 55.907576
min 892.000000 1.000000 0.170000 0.000000 0.000000 0.000000
25% 996.250000 1.000000 21.000000 0.000000 0.000000 7.895800
50% 1100.500000 3.000000 27.000000 0.000000 0.000000 14.454200
75% 1204.750000 3.000000 39.000000 1.000000 0.000000 31.500000
max 1309.000000 3.000000 76.000000 8.000000 9.000000 512.329200
Jadi, dari keluaran di atas kita bisa mengetahui tentang fitur-fitur kumpulan data dan beberapa
statistik dasarnya.
print(train.columns.values)
['PassengerId' 'Survived' 'Pclass' 'Name' 'Sex' 'Age' 'SibSp'
'Parch'
'Ticket' 'Fare' 'Cabin' 'Embarked']
tidak semua algoritma pembelajaran mesin mendukung nilai yang hilang dalam data yang Anda
berikan kepada mereka. K-Means menjadi salah satunya. Jadi kita perlu menangani nilai yang hilang
yang ada dalam data. Pertama mari kita lihat di mana nilai-nilai yang hilang:
# For the train set

train.isna().head()
Mari kita dapatkan jumlah total nilai yang hilang di kedua set data.
print("*****In the train set*****")

print("\n")
print("*****In the test set*****")
*****In the train set*****
PassengerId 0
Survived 0
Pclass 0
Name 0
Sex 0
Age 177
SibSp 0
Parch 0
Ticket 0
Fare 0
Cabin 687
Embarked 2
dtype: int64
*****In the test set*****

PassengerId 0
Pclass 0
Name 0
Sex 0
Age 86
SibSp 0
Parch 0
Ticket 0
Fare 1
Cabin 327
Embarked 0
dtype: int64
di kolom Age, Cabin and Embarked, ada nilai yang hilang dan di set pengujian, kolom Age dan Cabin
berisi nilai yang hilang.
Ada beberapa cara untuk menangani nilai yang hilang:
 Hapus baris dengan nilai yang hilang

 Tunjukkan nilai-nilai yang hilang
Saya lebih suka yang terakhir karena jika Anda menghapus baris dengan nilai yang hilang, ini dapat
menyebabkan ketidakcukupan data yang pada gilirannya menghasilkan model pembelajaran mesin
yang tidak efisien.
Sekarang, ada beberapa cara untuk melakukan imputasi:
Nilai konstanta yang memiliki arti dalam domain, seperti 0, berbeda dari semua nilai lainnya.
Nilai dari rekaman lain yang dipilih secara acak.
Nilai rata-rata, median, atau mode untuk kolom.
Nilai yang diperkirakan oleh model pembelajaran mesin lain.
Setiap imputasi yang dilakukan pada set kereta harus dilakukan pada data pengujian di masa
mendatang saat prediksi diperlukan dari model pembelajaran mesin akhir. Ini perlu dipertimbangkan
ketika memilih bagaimana menghubungkan nilai-nilai yang hilang.
Panda menyediakan fillna()fungsi untuk mengganti nilai yang hilang dengan nilai tertentu. Mari
terapkan itu dengan Mean Imputation .
# Fill missing values with mean column values in the train set
train.fillna(train.mean(), inplace=True)
# Fill missing values with mean column values in the test set
test.fillna(test.mean(), inplace=True)
Sekarang setelah kita hitungkan nilai yang hilang dalam kumpulan data, sekarang saatnya untuk
melihat apakah kumpulan data masih memiliki nilai yang hilang.
PassengerId 0
Survived 0
Pclass 0
Name 0
Sex 0
Age 0
SibSp 0
Parch 0
Ticket 0
Fare 0
Cabin 687
Embarked 2
dtype: int64
Mari kita lihat apakah memiliki nilai yang hilang di set pengujian.
PassengerId 0
Pclass 0
Name 0
Sex 0
Age 0
SibSp 0
Parch 0
Ticket 0
Fare 0
Cabin 327
Embarked 0
dtype: int64
kita dapat melihat masih ada beberapa nilai yang hilang di kolom Kabin dan Memulai. Ini karena
nilai-nilai ini non-numerik. Untuk melakukan imputasi, nilai harus dalam bentuk numerik. Ada cara
untuk mengubah nilai non-numerik menjadi numerik. Lebih lanjut tentang ini nanti.
Mari lakukan lebih banyak analisis untuk memahami data dengan lebih baik. Pemahaman benar-
benar diperlukan untuk melakukan tugas Machine Learning apa pun. Mari kita mulai dengan mencari
tahu fitur mana yang kategoris dan mana yang numerik.
Categorical: Survived, Sex, and Embarked. Ordinal: Pclass.
Berkelanjutan: Usia, Tarif. Diskrit: SibSp, Parch.
Ada dua fitur yang tidak tercantum di atas di salah satu kategori. Ya, Anda menebaknya dengan
benar, Tiket dan Kabin . Tiket adalah campuran tipe data numerik dan alfanumerik. Kabin adalah
alfanumerik. Mari kita lihat beberapa contoh nilai.
train['Ticket'].head()
0 A/5 21171
1 PC 17599
2 STON/O2. 3101282
3 113803
4 373450
Name: Ticket, dtype: object
train['Cabin'].head()
0 NaN
1 C85
2 NaN
3 C123
4 NaN
Name: Cabin, dtype: object
Jumlah penumpang yang selamat sehubungan dengan fitur-fitur berikut:
• Pclass
• Seks
• SibSp
• Parch
lakukan itu satu per satu:
Jumlah kelangsungan hidup sehubungan dengan Pclass:
train[['Pclass', 'Survived']].groupby(['Pclass'],
Pclass Selamat
0 1 0,629630
1 2 0.472826
2 3 0,242363
Jumlah kelangsungan hidup sehubungan dengan Seks:
train[["Sex", "Survived"]].groupby(['Sex'],
Seks Selamat
0 Perempuan 0.742038
1 pria 0,188908
Anda bisa melihat tingkat kelangsungan hidup penumpang wanita jauh lebih tinggi untuk pria.
Jumlah kelangsungan hidup sehubungan dengan SibSp:

train[["SibSp", "Survived"]].groupby(['SibSp'],
SibSp Selamat
1 1 0,535885
2 2 0.464286
0 0 0,345395
3 3 0.250000
4 4 0.166667
5 5 0.000000
6 8 0.000000
Sekarang saatnya untuk merencanakan secara cepat. Pertama-tama, mari kita gambarkan grafik
"Age vs. Survived":
g = sns.FacetGrid(train, col='Survived')
g.map(plt.hist, 'Age', bins=20)
<seaborn.axisgrid.FacetGrid at 0x7fa990f87080>
Saatnya untuk melihat bagaimana fitur Pclass dan Survived terkait satu sama lain dengan grafik:
grid = sns.FacetGrid(train, col='Survived', row='Pclass', size=2.2,

aspect=1.6)
grid.map(plt.hist, 'Age', alpha=.5, bins=20)
grid.add_legend();
Cukup visualisasi dan analitik untuk saat ini! Mari kita buat model K-Means dengan set pelatihan.
Tetapi sebelum itu Anda juga membutuhkan beberapa pemrosesan data. Anda dapat melihat bahwa
tidak semua nilai fitur memiliki tipe yang sama. Beberapa di antaranya numerik dan beberapa tidak.
Untuk memudahkan penghitungan, Anda akan memasukkan semua data numerik ke model. Mari
kita lihat tipe data dari berbagai fitur yang Anda miliki:
train.info()
Name 891 non-null object
Sex 891 non-null object
Ticket 891 non-null object
Cabin 204 non-null object
Embarked 889 non-null object
dtypes: float64(2), int64(5), object(5)
memory usage: 83.6+ KB
fitur-fitur berikut ini non-numerik:
• Name
• Seks
• Tiket
• Kabin
• Embarked
Sebelum mengubahnya menjadi numerik, ada baiknya Anda melakukan beberapa rekayasa fitur,
yaitu fitur-fitur seperti Nama, Tiket, Kabin dan Embarked tidak berdampak pada status kelangsungan
hidup penumpang. Seringkali, lebih baik melatih model Anda hanya dengan fitur yang signifikan
daripada melatihnya dengan semua fitur, termasuk yang tidak perlu. Ini tidak hanya membantu
dalam pemodelan yang efisien, tetapi juga pelatihan model dapat terjadi dalam waktu yang jauh
lebih singkat. Meskipun, rekayasa fitur adalah bidang studi itu sendiri, saya akan mendorong Anda
untuk menggalinya lebih jauh. Tetapi untuk tutorial ini, ketahuilah bahwa fitur Name, Ticket, Cabin
dan Embarked dapat dihilangkan dan tidak akan berdampak signifikan pada pelatihan model K-
Means.
train = train.drop(['Name','Ticket', 'Cabin','Embarked'], axis=1)

test = test.drop(['Name','Ticket', 'Cabin','Embarked'], axis=1)
Sekarang setelah bagian menjatuhkan selesai, mari kita ubah fitur 'Sex' menjadi numerik (hanya 'Sex'
yang tersisa sekarang yang merupakan fitur non-numerik). Anda akan melakukan ini menggunakan
teknik yang disebut Label Encoding .
labelEncoder = LabelEncoder()
labelEncoder.fit(train['Sex'])
labelEncoder.fit(test['Sex'])
train['Sex'] = labelEncoder.transform(train['Sex'])
test['Sex'] = labelEncoder.transform(test['Sex'])
# Let's investigate if you have non-numeric data left
train.info()
Perhatikan bahwa set pengujian tidak memiliki fitur Survived.

test.info()
Kolom Survival dapat dijatuhkan dari data dengan drop()fungsi tersebut.
X = np.array(train.drop(['Survived'], 1).astype(float))
y = np.array(train['Survived'])
Anda dapat meninjau semua fitur yang akan Anda masukkan ke algoritme train.info().
train.info()
Sekarang mari kita buat model K-Means.
kmeans = KMeans(n_clusters=2) # You want cluster the passenger

records into 2: Survived or Not survived
kmeans.fit(X)
KMeans(algorithm='auto', copy_x=True, init='k-means++',
max_iter=300,
Anda dapat melihat semua parameter lain dari model selain n_clusters. Mari kita lihat seberapa baik
model tersebut bekerja dengan melihat persentase catatan penumpang yang dikelompokkan
dengan benar.
correct = 0
correct += 1
0.5084175084175084
Model ini dapat mengelompokkan dengan benar dengan 50% (akurasi model Anda). Tetapi untuk
meningkatkan kinerja model, Anda dapat mengubah beberapa parameter model itu sendiri. Saya
akan membuat daftar beberapa parameter ini yang disediakan oleh implementasi scikit-learn dari K-
Means:
• algoritma
• maks_iter
• n_jobs
Mari kita sesuaikan nilai parameter ini dan lihat apakah ada perubahan pada hasilnya.
Dalam dokumentasi scikit-learn , Anda akan menemukan informasi yang solid tentang parameter ini
yang harus Anda gali lebih jauh.
kmeans = kmeans = KMeans(n_clusters=2, max_iter=600, algorithm =

'auto')
kmeans.fit(X)
max_iter=600,
correct = 0
correct += 1
0.49158249158249157
Anda dapat melihat penurunan skor. Salah satu alasannya adalah Anda belum menskalakan nilai dari
berbagai fitur yang Anda masukkan ke model. Fitur dalam kumpulan data berisi rentang nilai yang
berbeda. Jadi, yang terjadi adalah perubahan kecil pada suatu fitur tidak mempengaruhi fitur
lainnya. Jadi, penting juga untuk menskalakan nilai fitur ke rentang yang sama.
Mari lakukan itu sekarang dan untuk percobaan ini Anda akan menggunakan 0 - 1 sebagai rentang
nilai seragam di semua fitur.
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
kmeans.fit(X_scaled)
max_iter=600,
correct = 0
correct += 1
0.6262626262626263
peningkatan skor instan sebesar 12%.
Sekarang, mari kita bahas batasan K-Means.
Kekurangan K-Means
Sekarang Anda memiliki ide yang cukup bagus tentang bagaimana algoritma K-Means bekerja, mari
kita bahas beberapa kelemahannya.
Kerugian terbesarnya adalah K-Means mengharuskan Anda untuk menentukan jumlah cluster (k).
Namun, untuk kumpulan data Titanic, Anda memiliki beberapa pengetahuan domain yang tersedia
yang memberi tahu Anda jumlah orang yang selamat di bangkai kapal. Ini mungkin tidak selalu
terjadi pada kumpulan data dunia nyata. Pengelompokan hierarki merupakan pendekatan alternatif
yang tidak memerlukan pilihan klaster tertentu. Kerugian tambahan dari k-means adalah peka
terhadap pencilan dan hasil yang berbeda dapat terjadi jika Anda mengubah urutan data.
K-Means adalah pelajar yang malas di mana generalisasi data pelatihan ditunda hingga kueri dibuat
ke sistem. Ini berarti K-Means mulai bekerja hanya saat Anda memicunya, sehingga metode
pembelajaran yang lambat dapat membuat perkiraan atau hasil yang berbeda ke fungsi target untuk
setiap kueri yang ditemukan. Ini adalah metode yang baik untuk pembelajaran online, tetapi
memerlukan kemungkinan memori yang besar untuk menyimpan data, dan setiap permintaan
melibatkan memulai identifikasi model lokal dari awal.
Kesimpulan
Jadi, dalam tutorial ini Anda telah membahas permukaan salah satu teknik pengelompokan paling
populer - K-Means. Anda mempelajari tentang mekanisme dalamnya, mengimplementasikannya
menggunakan Set Data Titanic dengan Python, dan Anda juga mendapat gambaran yang adil tentang
kerugiannya. Jika Anda ingin mempelajari lebih lanjut tentang teknik pengelompokan ini, saya sangat
menyarankan Anda untuk melihat kursus Pembelajaran Tanpa Pengawasan dengan Python kami .
Nama : Andry Meylani
NIM : 202420009
import numpy as np
import random

fig = plt.figure()
X,Y,Z = [],[],[]
X.append(x)
Y.append(y)
Z.append(z)
A,B,C = [],[],[]
A.append(a)
B.append(b)
C.append(c)

plt.show()

points = {}
for point in obj:
centroids = {}
for i in range(K):
arr = []
for k in range(3):
centroids[i] = arr
C = {}
C[p1]=c1
arr = [0,0,0]
if(c == key):
try:
except:

centroids_prev = {}
f.close()

plot(f_in,f_out)
f_out.close()
f_in.close()
TUGAS ADVANCE DATABASE
PHYTON CLUSTER PROGRAM
NAMA : ARI HARDIYANTORO SUSANTO

NIM : 202420015
# import library
----
import numpy as np
import pandas as pd
#import datasheet
data_path = r'drive/My Drive/Colab Notebooks/data_tugas.csv'


print(data_tugas.head())

clusters = 3
kmeans.fit(data_tugas)
pca = PCA(3)
pca.fit(data_tugas)
pca_data = pd.DataFrame(pca.transform(data_tugas))
#membuat 3D
import math

of their hsv
values '''
), name)
).items())))[1]

fig = plt.figure()
kmeans.labels_)))

,
plt.show()
Output Phyton

print(data_tugas.head())
Output

clusters = 3
kmeans.fit(data_tugas)
pca = PCA(3)
pca.fit(data_tugas)
pca_data = pd.DataFrame(pca.transform(data_tugas))
Output
import math
of their hsv
values '''
), name)
).items())))[1]


fig = plt.figure()
kmeans.labels_)))

,
plt.show()
Output
Tugas 03 – Clustering
1. Tampilkan data dari dataset
2. Tampilkan informasi setiap variable
3. Hilangkan Variable yang tidak perlu, dalam hal ini digunakan variable X dan Y
4. Tentukan Variable yang akan di Klusterkan yaitu variable X dan Variable Y
5. Tampilkan Penybaran datanya

menjadi 5 Cluster
KMeans(n_clusters=5, random_state=123)
Nama : Bhijanta Wyasa WM
NIM : 202420019
Kelas : MTI 23
Mata Kuliah : ADVANCED DATABASE (MTIK112)
Dosen : Tri Basuki Kurniawan , S.Kom., M.Eng. Ph.D
TUGAS 03
Terima kasih.
Source Code :
import numpy as np
#%matplotlib inline
from sklearn.cluster import DBSCAN
data = np.array([[1, 4, 1],

[1, 2, 2],
[1, 4, 2],
[2, 1, 2],
[1, 1, 1],
[2, 4, 2],
[1, 1, 2],
[2, 1, 1]])
NIM : 202420019
Kelas : MTI 23
fig = plt.figure()
ax = Axes3D(fig)
ax.scatter(data[:,0], data[:,1], data[:,2], s=300)
plt.show()
model = DBSCAN(eps=2.5, min_samples=2)

model.fit_predict(data)
pred = model.fit_predict(data)
fig = plt.figure()
ax = Axes3D(fig)
ax.scatter(data[:,0], data[:,1], data[:,2], c=model.labels_, s=300)
plt.show()
print("number of cluster found: {}".format(len(set(model.labels_))))

print('cluster for each point: ', model.labels_)
PS C:\Users\bhijanta.wijayamukti> & python "d:/3DClustering (1).py"

number of cluster found: 1
cluster for each point: [0 0 0 0 0 0 0 0]
PS C:\Users\bhijanta.wijayamukti> & python "d:/3DClustering (1).py"
Jumlah Cluster = 1
NIM : 202420019
Kelas : MTI 23
BEFORE CLUSTERING
AFTER CLUSTERING
TUGAS 03
NAMA : CORNELIA TRI WAHYUNI
NIM : 202420044
KELAS : REGULAR A
Untuk dataset berikut ini, buat program di python untuk mengcluster data-data tersebut. Lampirkan
source code python dan hasil pengelompokkan nya.
Jawab :
Nama : Cynthia Anisa Agatha
NIM : 202420022
Tugas 3 membuat sebuah program python dengan data set dibawah ini untuk mengcluster data
tersebut.
Object X Y Z
OB-1 1 4 1
OB-2 1 2 2
OB-3 1 4 2
OB-4 2 1 2
OB-5 1 1 1
OB-6 2 4 2
OB-7 1 1 2
OB-8 2 1 1
import csv
file = open('data.csv','r')
reader = csv.reader(file)
for data in reader:
print(data)
import numpy as np

from sklearn import csv
np.random.seed(5)
iris = csv.load_iris()
X = iris.data
y = iris.target
estimators = [('k_means_iris_3', KMeans(n_clusters=3))]
fignum = 1
titles = ['3 clusters']
for name, est in estimators:
fig = plt.figure(fignum, figsize=(4, 3))
ax = Axes3D(fig, rect=[0, 0, .95, 1], elev=48, azim=134)
est.fit(X)
est.fit(Y)
est.fit(Z)
labels = est.labels_
ax.scatter(X[:, 3], X[:, 0], X[:, 2],

c=labels.astype(np.float), edgecolor='k')
ax.w_xaxis.set_ticklabels([])
ax.w_yaxis.set_ticklabels([])
ax.w_zaxis.set_ticklabels([])
ax.set_xlabel('Petal width')
ax.set_ylabel('Sepal length')
ax.set_zlabel('Petal length')
ax.set_title(titles[fignum - 1])
ax.dist = 12
fignum = fignum + 1
fig = plt.figure(fignum, figsize=(4, 3))

ax = Axes3D(fig, rect=[0, 0, .95, 1], elev=48, azim=134)
for name, label in [('Biru', 0),

('Kuning', 1),
('Hijau', 2)]:
ax.text3D(X[y == label, 3].mean(),
X[y == label, 0].mean(),
X[y == label, 2].mean() + 2, name,
horizontalalignment='center',
bbox=dict(alpha=.2, edgecolor='w', facecolor='w'))
y = np.choose(y, [1, 2, 0]).astype(np.float)
ax.scatter(X[:, 3], X[:, 0], X[:, 2], c=y, edgecolor='k')
ax.w_xaxis.set_ticklabels([])
ax.w_yaxis.set_ticklabels([])
ax.w_zaxis.set_ticklabels([])
ax.set_xlabel('Petal width')
ax.set_ylabel('Sepal length')
ax.set_zlabel('Petal length')
ax.set_title('Ground Truth')
ax.dist = 12
fig.show()
GATOT ARIFIANTO
NIM : 202420029
TUGAS 03
MENGKLUSTER DATASET DENGAN PYTHON
1. Mengkluster tugasdataset
2. hasil pengelompokan setelah diterapkan cluster K-Mean pada dataset

diatas, klaster akhir menjadi 2 klaster, yaitu :
1
GATOT ARIFIANTO
NIM : 202420029
3. Source code Python :

a. Memanggil dan Membuat objek :
b. K-Means Clustering code :
# Mengimpor library
import numpy as np
import pandas as pd
# Mengimpor dataset
dataset = pd.read_csv('Dataset.csv')
X = dataset.iloc[:, [2, 3, 4]].values
# Menggunakan metode elbow untuk menentukan angka cluster yang tepat

wcss = []
for i in range(1, 9):
kmeans = KMeans(n_clusters = i, init = 'k-means++', random_state = 8)
kmeans.fit(X)
wcss.append(kmeans.inertia_)
plt.plot(range(1, 8), wcss)
plt.title('Metode Elbow')
plt.xlabel('Jumlah clusters')
plt.ylabel('WCSS')
plt.show()
# Menjalankan K-Means Clustering ke dataset

kmeans = KMeans(n_clusters = 2, init = 'k-means++', random_state = 8)
y_kmeans = kmeans.fit_predict(X)
# Visualisasi hasil clusters

plt.scatter(X[y_kmeans == 0, 0], X[y_kmeans == 0, 1], s = 8, c = 'brown', label
= 'Cluster 1')
2
GATOT ARIFIANTO
NIM : 202420029
plt.scatter(X[y_kmeans == 1, 0], X[y_kmeans == 1, 1], s = 8, c = 'camel', label

= 'Cluster 2')
plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1], s = 8,
c = 'cream', label = 'Centroids')
plt.title('Clusters object')
plt.xlabel('x')
plt.ylabel('y')
plt.ylabel('z')
plt.legend()
plt.show()
c. Baca data csv :
#file: baca csv.py
import csv
with open('obj.csv', 'r') as filecsv:

datafile = csv.reader(filecsv)
for data in datafile:
print(data)
SELESAI

Tugas 4

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Tugas 4

Diunggah oleh

Hak Cipta:

Format Tersedia

TUGAS 03

Name : Istiarso Budi Yuwono

1. Tampilkan data dari dataset

2. Tampilkan informasi setiap variable

4. Tentukan Variable yang akan di Klusterkan yaitu variable X dan Variable Y

6. Ubah Variable dari data Frame menjadi Array

7. Menstandarkan ukuran variable array

11. Visualisasi Hasil Cluster

Setelah menerapkan K-means pada dataset di atas, cluster terakhir adalah:

# Load the train and test datasets to create two DataFrames

print("***** Train_Set *****")

Name Sex Age SibSp

Parch Ticket Fare Cabin Embarked

***** Test_Set *****

Age SibSp Parch Ticket Fare Cabin Embarked

***** Test_Set *****

# For the train set

print("*****In the train set*****")

*****In the test set*****

Sekarang, ada beberapa cara untuk melakukan imputasi:

Categorical: Survived, Sex, and Embarked. Ordinal: Pclass.

Jumlah kelangsungan hidup sehubungan dengan SibSp:

grid = sns.FacetGrid(train, col='Survived', row='Pclass', size=2.2,

train = train.drop(['Name','Ticket', 'Cabin','Embarked'], axis=1)

Kolom Survival dapat dijatuhkan dari data dengan drop()fungsi tersebut.

kmeans = KMeans(n_clusters=2) # You want cluster the passenger records into

kmeans = kmeans = KMeans(n_clusters=2, max_iter=600, algorithm = 'auto')

KMeans(algorithm='auto', copy_x=True, init='k-means++', max_iter=600,

n_clusters=2, n_init=10, n_jobs=1, precompute_distances='auto',

random_state=None, tol=0.0001, verbose=0)

predict_me = predict_me.reshape(-1, len(predict_me))

from sklearn.preprocessing import StandardScaler

# print first rows of datasheet

# from sklearn.cluster import KMeans

# from sklearn.decomposition import PCA - EDA ANALISIS

''' Generating different colors in ascending order

# number of steps to taken generate n(clusters) colors

str_labels = list(map(lambda label:'% s' % label, kmeans.label

list(map(lambda data1, data2, data3, str_label:

# generating correlation heatmap

# posting correlation heatmap to output console

# generating correlation data

''' Generating coordinates with

# flattening dataframe values

# plotting 3D trisurface plot

Hasil Pengelompokkan dan tampilannya

NAMA : OMAN ARROHMAN

# -*- coding: utf-8 -*-

Automatically generated by Colaboratory.

Original file is located at

from collections import Counter

from mpl_toolkits.mplot3d import Axes3D

from mpl_toolkits.mplot3d import axes3d

import matplotlib.pyplot as plt

# 3-dimensional plot showing clusters

ax = fig.add_subplot(111, projection = '3d')

for line in file_input:

for line in file_output:

ax.scatter(X,Y,Z, c='b', marker ='o')

ax.scatter(A,B,C, c='r', marker ='x')

from google.colab import files

for point in obj:

for p1,p2 in points.items():

print("* Train_Set *")

* Test_Set *

* Test_Set *

print("In the train set")

In the test set

# -- coding: utf-8 --