<jupyter_start><jupyter_text>Mempermudah para peneliti dan dokter dalam meneliti persebaran Covid-19 di US Kelompok-1 :1. <NAME>2. <NAME>3. <NAME>  Langkah pertama kami me-import package yang di butuhkan ![image.png](attachment:image.png)<jupyter_code>#import pandas
import pandas as pd
#import numpy
import numpy as np
#import seaborn
import seaborn as sns
#import matplotlib
import matplotlib.pyplot as plt
# Import Module LinearRegression digunakan untuk memanggil algoritma Linear Regression.
from sklearn.linear_model import LinearRegression
# import Module train_test_split digunakan untuk membagi data kita menjadi training dan testing set.
from sklearn.model_selection import train_test_split
# import modul mean_absolute_error dari library sklearn
from sklearn.metrics import mean_absolute_error
#import math agar program dapat menggunakan semua fungsi yang ada pada modul math.(ex:sqrt)
import math
# me-non aktifkan peringatan pada python
import warnings 
warnings.filterwarnings('ignore')

from sklearn.cluster import KMeans<jupyter_output><empty_output><jupyter_text>Kemudian load dataset yang akan dipakai ![image-2.png](attachment:image-2.png)<jupyter_code>df_train = pd.read_csv('datacovid.csv')
df_train<jupyter_output><empty_output><jupyter_text>Kemudian kita cek shape dari dataset yang di gunakan<jupyter_code>df_train.shape<jupyter_output><empty_output><jupyter_text>Lalu kita cek ringkasan dari dataset yang di pakai count = Jumlah datamean = Rata - ratastd = Standar Deviasimin = Nilai Minimum25% = Adalah Nilai 1/4 dari data tersebut50% = Adalah Nilai 1/2 dari data tersebut75% = Adalah Nilai 3/4 dari data tersebut100% = Adalah Nilai Maksimum<jupyter_code>df_train.describe()<jupyter_output><empty_output><jupyter_text>Lalu dilakukan pengecekan apakah data tersebut ada yang kosong atau null<jupyter_code>df_train.isnull().sum()<jupyter_output><empty_output><jupyter_text>Membersihkan data yang memiliki nilai Null<jupyter_code>#dikarenakan datanya masih ada yang null maka data yang memiliki nilai NaN akan di drop
df_train.dropna(inplace = True)
df_train<jupyter_output><empty_output><jupyter_text>Kemudian kita cek tipe-tipe data yang ada pada dataset<jupyter_code>#me-cek tipe data 
df_train.info()<jupyter_output><class 'pandas.core.frame.DataFrame'>
Int64Index: 17341 entries, 1 to 39658
Data columns (total 15 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   submission_date  17341 non-null  object 
 1   state            17341 non-null  object 
 2   tot_cases        17341 non-null  int64  
 3   conf_cases       17341 non-null  float64
 4   prob_cases       17341 non-null  float64
 5   new_case         17341 non-null  int64  
 6   pnew_case        17341 non-null  float64
 7   tot_death        17341 non-null  int64  
 8   conf_death       17341 non-null  float64
 9   prob_death       17341 non-null  float64
 10  new_death        17341 non-null  int64  
 11  pnew_death       17341 non-null  float64
 12  created_at       17341 non-null  object 
 13  consent_cases    17341 non-null  object 
 14  consent_deaths   17341 non-null  object 
dtypes: float64(6), int64(4), object(5)
memory usage: 2.1+ MB<jupyter_text>Kemudian melakukan pengecekan apakah data tersebut ada yang duplikat<jupyter_code>#melihat jika ada data duplikat
df_train.duplicated().sum()<jupyter_output><empty_output><jupyter_text>Lalu data yang sudah di proses sebelumnya di buat visualisasi dengan histogram<jupyter_code>#membuat histogram
df_train.hist(figsize = (20,12))<jupyter_output><empty_output><jupyter_text>Selanjutnya kita menghapus data yang tidak di perlukan<jupyter_code>#dikarenakan kita tidak membutuhkan data pending dalam melakukan visualisasi kita, maka kolom pnew_death, pnew_case di drop
# dan kami memutuskan bahwa data prob_cases, prob_death, dan created_at di drop karena tidak ada hubungannya untuk peneliti dalam membantu meneliti penyebaran Covid
dft=df_train.drop(['pnew_death', 'pnew_case','prob_cases', 'prob_death','created_at'], axis = 1)
dft<jupyter_output><empty_output><jupyter_text>Kemudian dilakukan pengecekan data duplikat kembali setelah menghapus data yang tidak digunakan<jupyter_code>#pengecekan duplikasi setelah men-drop beberapa data
dft.duplicated().sum()<jupyter_output><empty_output><jupyter_text>Selanjutnya kita mencari korelasi pada data dengan menggunakan visualisasi Heatmap<jupyter_code>#mencari korelasi dengan menggunakan heatmap
fig , axes = plt.subplots(figsize = (14,12))
sns.heatmap(dft.corr(), annot=True)
dft.columns<jupyter_output><empty_output><jupyter_text>Pada gambar diatas data yang memiliki korelasi terbaik adalah data tot_death dengan conf_death dan tot_cases dan conf_cases Karena kami memiliki 2 nilai korelasi yang sama dan hubungan korelasinya kuat maka dari itu kami memutuskan untuk memilih salah satu korelasi sebagai data yang akan kami uji pada data tersebut yaitu data conf_cases dengan data tot_cases  Setelah mendapat data yang ingin digunakan, selanjutnya kita memeriksa apakah ada outlier (pencilan) pada data yang digunakan<jupyter_code>#mememeriksa apakah data memiliki outlier(pencilan)
q1 = df_train.iloc[:,[2,3,]].quantile(0.25)
q3 = df_train.iloc[:,[2,3]].quantile(0.75)
IQR = q3 - q1
IQR<jupyter_output><empty_output><jupyter_text>Setelah itu memeriksa data apakah ada outlier (pencilan) dengan menggunakan boxplot<jupyter_code>#memeriksa apakah data memiliki outlier(pencilan) dengan menggunakan boxplot
df = df_train.iloc[:,[2,3]]
df.columns

fig, axes = plt.subplots(ncols = 2, nrows = 1, figsize = (18,8))

for i, ax in zip(df.columns, axes.flat):
    sns.boxplot(x = df[i], ax = ax)
plt.show()<jupyter_output><empty_output><jupyter_text>Setelah data outlier (pencilan) ditemukan, kita hapus data outliernya<jupyter_code>#menghapus data ouliernya
Q1 = (df_train[['tot_cases', 'conf_cases']]).quantile(0.25)
Q3 = (df_train[['tot_cases', 'conf_cases']]).quantile(0.75)
IQR = Q3 - Q1
max = Q3 + (1.5*IQR)
min = Q1 - (1.5*IQR)

Jlebih = (df_train > max)
Jkurang = (df_train < min)
df_train = df_train.mask(Jlebih, max, axis=1)
df_train = df_train.mask(Jkurang, min, axis=1)<jupyter_output><empty_output><jupyter_text>Setelah data outlier (pencilan) nya sudah di hapus, kita cek sekali lagi untuk memastikan apakah data outlier (pencilan) masih tersisa di dalam data<jupyter_code>#memeriksa data apakah masih ada outlier setelah dilakukan penghapusan
df = df_train.iloc[:,[2,3]]
df.columns

fig, axes = plt.subplots(ncols = 2, nrows = 1, figsize = (18,8))

for i, ax in zip(df.columns, axes.flat):
    sns.boxplot(x = df[i], ax = ax)
plt.show()<jupyter_output><empty_output><jupyter_text>Setelah itu kita akan mengambil 2 data utama yang akan digunakan untuk analisis<jupyter_code>dfu=df.head(50)
dfu<jupyter_output><empty_output><jupyter_text>Selanjutnya kita visualisasikan prediksi data yang digunakan menggunakan Scatter Plot<jupyter_code>plt.scatter(dfu['conf_cases'],dfu['tot_cases'])
plt.xlabel('conf_cases')
plt.ylabel('tot_cases')
plt.title('Scatter Plot conf_cases vs tot_cases')
plt.show()
x = dfu['conf_cases'].values.reshape(-1,1)
y = dfu['tot_cases'].values.reshape(-1,1)<jupyter_output><empty_output><jupyter_text>Melihat nilai rata - rata dari Variabel X dan Y<jupyter_code>x_mean = np.mean(x)
y_mean = np.mean(y)
print('nilai mean var x: ', x_mean,'\n'
      'nilai mean var y: ', y_mean)<jupyter_output>nilai mean var x:  453307.66 
nilai mean var y:  514574.44<jupyter_text>Kemudian melihat nilai korelasi koefisien pada data<jupyter_code>atas = sum((x - x_mean)*(y - y_mean))
bawah = math.sqrt((sum((x - x_mean)**2)) * (sum((y - y_mean)**2)))
correlation = atas/bawah
print('Nilai Correlation Coefficient: ', correlation)<jupyter_output>Nilai Correlation Coefficient:  [0.99416166]<jupyter_text>Melihat Slope pada data Slope adalah tingkat kemiringan garis<jupyter_code># slope
# Slope adalah tingkat kemiringan garis, intercept 
# adalah jarak titik y pada garis dari titik 0
variance = sum((x - x_mean)**2)
covariance = sum((x - x_mean) * (y - y_mean))
theta_1 = covariance/variance
print('Nilai theta_1: ',theta_1)<jupyter_output>Nilai theta_1:  [1.10941586]<jupyter_text>Intercept adalah jarak titik y pada garis dari titik 0<jupyter_code># intercept
theta_0 = y_mean - (theta_1 * x_mean)
print('Nilai theta_0: ',theta_0)<jupyter_output>Nilai theta_0:  [11667.73160133]<jupyter_text>Melakukan manual prediksi<jupyter_code># prediction manual
y_pred = theta_0 + (theta_1 * 130)

print(y_pred)<jupyter_output>[11811.95566339]<jupyter_text>Memvisualisasikan prediksi dengan scatter plot<jupyter_code># visualisasi prediksi dengan scatter plot
y_pred = theta_0 + (theta_1 * x)

plt.scatter(x,y)
plt.plot(x, y_pred, c='r')
plt.xlabel('conf_cases')
plt.ylabel('tot_cases')
plt.title('Plot conf_cases vs tot_cases')
x_train, x_test, y_train, y_test = train_test_split(x, y, train_size = 0.8, test_size = 0.2, random_state = 0)<jupyter_output><empty_output><jupyter_text>Selanjutnya kita cek regresi koefisien dan intercepnya<jupyter_code>regressor = LinearRegression()
regressor.fit(x_train, y_train)
print(regressor.coef_)
print(regressor.intercept_)<jupyter_output>[[1.09658641]]
[15695.8934773]<jupyter_text>Mencetak score regresi untuk melihat akurasi<jupyter_code>regressor.score(x_test, y_test)<jupyter_output><empty_output><jupyter_text>Mencetak nilai korelasi dari score regresi<jupyter_code>print('Correlation: ', math.sqrt(regressor.score(x_test,y_test)))<jupyter_output>Correlation:  0.9987225295509001<jupyter_text>Memvisualisasikan regresi menggunakan data testing<jupyter_code>y_prediksi = regressor.predict(x_test)

plt.scatter(x_test, y_test)
plt.plot(x_test, y_prediksi, c='r')
plt.xlabel('conf_cases')
plt.ylabel('tot_cases')
plt.title('Plot conf_cases vs tot_cases')<jupyter_output><empty_output><jupyter_text>Memasukan dataframe ke dalam array kemudian memvisualisasikan dengan menggunakan metode Elbow<jupyter_code>#memasukkan dataframe ke dalam array 
data = np.array(df_train[["conf_cases", "tot_cases"]])
data

wcss = []
for i in range(1, 11):
    kmeans = KMeans(n_clusters = i)
    kmeans.fit(data)
    wcss.append(kmeans.inertia_)

plt.plot(range(1, 11), wcss)
plt.title('Elbow Method')
plt.xlabel('Jumlah Cluster')
plt.ylabel('WCSS')
plt.show()<jupyter_output><empty_output><jupyter_text>Dari hasil Elbow Method diatas dapat di simpulkan bahwa jumlah cluster yang paling optimal dalam melakukan K-Means adalah 2 (dua)  Kemudian menentukan jumlah cluster dan centroidnya<jupyter_code>df_cluster = df_train[["conf_cases", "tot_cases"]]

#centroid 
Centroids = (df_cluster.sample(n = 2))
plt.figure(figsize = (10, 5))
plt.scatter(df_cluster["conf_cases"], df_cluster["tot_cases"], color = 'blue')
plt.scatter(Centroids["conf_cases"], Centroids["tot_cases"], color = 'coral')
plt.xlabel('confirm cases')
plt.ylabel('total cases')  
plt.show()<jupyter_output><empty_output><jupyter_text>Pada visualiasi Centroid di atas, dapat diketahui bahwa titik centroid tersebut memiliki sifat yang masih acak (random). Oleh karena itu kita melakukan proses pengelompokan dengan menggunakan metode K-Means  Kemudian melakukan perhitungan menggunakan K-Means<jupyter_code>#K-Means
diff = 1
i = 0

while(diff!=0):
    data_new = df_cluster
    j = 1
    for index1 ,row_c in Centroids.iterrows():
        Y=[]
        for index2,row_d in data_new.iterrows():
            nd1=(row_c['conf_cases']-row_d['conf_cases'])**2
            nd2=(row_c["tot_cases"]-row_d["tot_cases"])**2
            nd=np.sqrt(nd1+nd2)
            Y.append(nd)
        df_cluster[j]=Y
        j=j+1

    hasil=[]
    for index,row in df_cluster.iterrows():
        min_dist=row[1]
        pos=1
        for j in range(2):
            if row[j+1] < min_dist:
                min_dist = row[j+1]
                pos=j+1
        hasil.append(pos)
    df_cluster["Cluster"]=hasil
    Centroids_new = df_cluster.groupby(["Cluster"]).mean()[["conf_cases", "tot_cases"]]
    if i == 0:
        diff=1
        i=i+1
    else:
        diff = (Centroids_new['conf_cases'] - Centroids['conf_cases']).sum() + (Centroids_new["tot_cases"] - Centroids["tot_cases"]).sum()
        print(diff.sum())
    Centroids = df_cluster.groupby(["Cluster"]).mean()[['conf_cases',"tot_cases"]]<jupyter_output>575919.2140289962
271925.06803870416
166897.27773183194
62414.231701318844
25435.920983209333
8376.812338868243
2869.894804758107
884.4677689888485
220.33032504811126
221.62453045746952
0.0<jupyter_text>Menentukan kelompok centroid dan memvisualisasikannya<jupyter_code>#menentukan kelompok centroid
warna=['red','green','blue']

plt.figure(figsize=(10,5))

for i in range(3):
    df_Model=df_cluster[df_cluster["Cluster"] == i + 1]
    plt.scatter(df_Model['conf_cases'], df_Model ["tot_cases"], color = warna[i])
    
plt.scatter(Centroids['conf_cases'],Centroids["tot_cases"],color='black')
plt.xlabel('confirm cases')
plt.ylabel("total cases")
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10776729073185827, 'fraction_numerical': 0.04293671669503327, 'mean_word_length': 5.694458829621958, 'pattern_counts': {'":': 0, '<': 126, '<?xml version=': 0, '>': 125, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '32', 'dir': 'jupyter-structured-clean-dedup', 'id': '9821', 'license': 'MIT', 'n_tokens_mistral': 5528, 'n_tokens_neox': 5022, 'n_words': 1081, 'path': 'app.ipynb', 'repo_name': 'jackky46/tugasakhirdatascience', 'size': '12965'}