Jika pada part I membahas mengenai eksplorasi data penjualan, pada part II akan dilakukan prediksi data penjualan pada bulan depan dengan data yang telah diolah pada part I. Pada sales data analysis ini diperlukan beberapa package dan model sebagai berikut:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression, Lasso, Ridge
from sklearn.metrics import mean_absolute_error, mean_squared_error
import pickle
from tensorflow import keras

df = pd.read_csv('../Data ML/Sales Harian 2019')
df.drop('Order Date', axis=1, inplace=True)
df.head()

df_predict = pd.read_csv('../Data ML/Harian Bulan Januari').drop('Unnamed: 0', axis=1)
df_result = pd.Series(lr.predict(df_predict), pd.date_range(start='1-1-2020', end='31-01-2020', freq='1D'))
df_result.tail()

Output:
2020-01-27    69245.403389
2020-01-28    69145.125634
2020-01-29    69044.847879
2020-01-30    68944.570123
2020-01-31    68844.292368
Freq: D, dtype: float64

Menvisualisasikan pendapatan harian tahun 2019 dan pendapatan harian bulan januari 2020

plt.figure(figsize=(10,8))
df['Price Total'].append(np.log(df_result)).plot(label='Prediksi (log)')
df['Price Total'].append(df_result).plot(label='Prediksi')
df['Price Total'].plot(label='Data Actual')
plt.title('Pendapatan Harian (2019 + Prediksi pada Januari 2020')
plt.ylabel('Pendapatan ($)')
plt.grid()
plt.legend()
plt.savefig('../Output/Pendapatan Harian dan Prediksi januari 2020')
plt.show()

Grafik diatas memberikan prediksi dan prediksi dalam bentuk logaritma pada penjualan harian di bulan januari 2020.

Sebelum dilakukan prediksi, perlu melakukan split data menjadi data training dan data testing, kemudian membentuk sebuah model yang akan digunakan untuk modeling.

def split_sequence(sequence, n_steps=3):
    sequence = list(sequence)
    X, Y = list(), list()
    for i in range(len(sequence)):
        end_ix = i + n_steps
        if end_ix > len(sequence)-1:
            break
        seq_x, seq_y = sequence[i:end_ix], sequence[end_ix]
        X.append(seq_x)
        Y.append(seq_y)
    def reshape(d):
        d = np.array(d)
        d = np.reshape(d,(d.shape[0], d.shape[1],1))
        return d
    return reshape(X), np.array(Y)

train_data = df['Price Total'].iloc[:250]
test_data = df['Price Total'].iloc[250:]

x_train, y_train = split_sequence(train_data)
x_test, y_test = split_sequence(test_data)

model = keras.Sequential([
    keras.layers.LSTM(64, input_shape=(3,1,), activation='relu', return_sequences=True),
    keras.layers.LSTM(64, activation='relu'),
    keras.layers.Dense(1)
])

model.compile(loss='mse', optimizer='adam')
model.summary()

Output:
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
lstm (LSTM)                  (None, 3, 64)             16896     
_________________________________________________________________
lstm_1 (LSTM)                (None, 64)                33024     
_________________________________________________________________
dense (Dense)                (None, 1)                 65        
=================================================================
Total params: 49,985
Trainable params: 49,985
Non-trainable params: 0
_________________________________________________________________

Melakukan modeling

stoping = keras.callbacks.EarlyStopping(monitor='loss', patience=3)
history = model.fit(x_train, y_train, epochs=100, batch_size=32, callbacks=[stoping], verbose=2)

Output:
Epoch 1/100
8/8 - 2s - loss: 7164496896.0000
Epoch 2/100
8/8 - 0s - loss: 6721865728.0000
Epoch 3/100
8/8 - 0s - loss: 6399132160.0000
Epoch 4/100
8/8 - 0s - loss: 6050901504.0000
Epoch 5/100
8/8 - 0s - loss: 5638317568.0000
Epoch 6/100
8/8 - 0s - loss: 5142379008.0000
Epoch 7/100
8/8 - 0s - loss: 4539011072.0000
Epoch 8/100
8/8 - 0s - loss: 3798559488.0000
Epoch 9/100
8/8 - 0s - loss: 2954702336.0000
Epoch 10/100
8/8 - 0s - loss: 2144060160.0000
Epoch 11/100
8/8 - 0s - loss: 1340466560.0000
Epoch 12/100
8/8 - 0s - loss: 392662464.0000
Epoch 13/100
8/8 - 0s - loss: 183184576.0000
Epoch 14/100
8/8 - 0s - loss: 114023488.0000
Epoch 15/100
8/8 - 0s - loss: 132803712.0000
Epoch 16/100
8/8 - 0s - loss: 105440448.0000
Epoch 17/100
8/8 - 0s - loss: 94067408.0000
Epoch 18/100
8/8 - 0s - loss: 97465088.0000
Epoch 19/100
8/8 - 0s - loss: 95151520.0000
Epoch 20/100
8/8 - 0s - loss: 94614400.0000

Menvisualisasikan perkembangan model

plt.plot(history.history['loss'], marker='.')
plt.title('Grafik perkembangan Model')
plt.xlabel('Epochs')
plt.ylabel('Error (MSE)')
plt.grid()
plt.savefig('../Output/Training NN Model')
plt.show()

plt.figure(figsize=(10,8))
plt.plot(model.predict(x_test), label='Prediction')
plt.plot(y_test, label='Actual')
plt.legend()
plt.grid()
plt.title('Data Prediksi vs Data Actual')
plt.xlabel('Waktu')
plt.ylabel('Pendapatan ($)')
plt.savefig('../Output/Demonstrasi Prediksi NN Model')
plt.show()

Data prediksi dengan data aktual tidak terdapat perbedaan yang sangat menonjol. Kedua tren data menunjukkan tren yang hampir sama, sehingga model dapat digunakan dengan baik untuk memprediksi penjualan yang akan datang.

def predict_future(shift_count):
    def reshape(three):
        return np.array(three).reshape(1,3,1)
    array = list(df['Price Total']) + []
    now = len(df['Price Total'])-3
    last = len(df['Price Total'])
    for _ in range(shift_count):
        converted = reshape(array[now:last])
        array.append(model.predict(converted)[0][0])
        now += 1
        last += 1
    return array

future_prediction = predict_future(30)

plt.figure(figsize=(10,5))
plt.plot(np.arange(29,60), future_prediction[-31:], '--', label='Prediksi')
plt.plot(np.arange(30), df['Price Total'][-30:], label='Data Aktual')
plt.title('Prediksi Pendapatan dalam 30 hari ke depan')
plt.grid()
plt.savefig('../Output/Prediksi Dengan NN Model')
plt.legend();

Garis biru menunjukkan prediksi penjualan 30 hari kedepan. Berdasarkan data prediksi, penjualan mengalami tren positif disetiap harinya hingga tertinggi pada hari ke-30 akhir.

Sales data analysis merupakan analisis pada data penjualan suatu perusahaan dengan mengambil nilai-nilai yang terkandung didalam hasil eksplorasi data untuk keperluan prospek bisnis kedepannya. Dengan menggunakan algoritma tertentu pada bahasa pemrograman python, kita juga dapat melakukan prediksi penjualan pada bulan berikutnya. berikut ini package yang diperlukan pada sales data analysis:

import os
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns 
from wordcloud import WordCloud

untuk membaca beberapa data dalam satu file yang sama, kita dapat menggunakan code sebagai berikut:

dataset = [f'../Data/{i}' for i in os.listdir('../Data')]

sementara untuk menggabungkan data-data penjualan yang kita miliki menjadi satu buah data agar lebih efektif untuk dilakukan analisis, dapat menggunakan code:

li = []
for data in dataset:
    df_data = pd.read_csv(data, index_col=None, header=0)
    li.append(df_data)
df = pd.concat(li, axis=0, ignore_index=True)
df.head()

df['Quantity Ordered'].unique()

Output:
array(['2', nan, '1', '3', '5', 'Quantity Ordered', '4', '7', '6', '8', '9'], dtype=object)

Data dengan nilai unik ‘Quantity Ordered’ dan nan akan menghambat dalam proses analisis dan prediksi, maka data dengan nilai unik ‘Quantity Ordered’ dan data dengan nilai nan perlu dilakukan drop, dengan code sebagai berikut:

df = df[df['Quantity Ordered'] != 'Quantity Ordered']
df = df.dropna(how='all')
df.reset_index(drop=True, inplace=True)
print(df.head())
print(df.info())

seluruh type data berupa object, hal ini akan berpotensi mengalami error saat dilakukan analisis, maka data perlu diubah menjadi tipe data yang seharusnya:

df['Order Date'] = pd.to_datetime(df['Order Date'])
col_int = ['Order ID', 'Price Each', 'Quantity Ordered']

for col in col_int:
    df[col] = pd.to_numeric(df[col])
for col in ['Product', 'Purchase Address']:
    df[col] = df[col].astype(np.str)

df.info()

selanjutnya melakukan split data pada datetime order date dan melakukan encoder pada column product dan month-year:

df['Day'] = pd.DatetimeIndex(df['Order Date']).day
df['Month'] = pd.DatetimeIndex(df['Order Date']).month
df['Year'] = pd.DatetimeIndex(df['Order Date']).year
df['Month-Year'] = df['Order Date'].apply(lambda x: x.strftime('%Y-%m'))
df['Price Total'] = df['Quantity Ordered'] * df['Price Each']
df = df.sort_values(by=['Order Date'])
df.head()

from sklearn.preprocessing import LabelEncoder

encoder = LabelEncoder()
df['Product_Encoded'] = encoder.fit_transform(df['Product'])
df['Month_Year_Encoded'] = encoder.fit_transform(df['Month-Year'])
df.head()

Untuk melihat product terjual terbanyak dapat menggunakan visualisasi wordcloud:

wordcloud = WordCloud(max_font_size=50, max_words=100, background_color='white').generate(' '.join(df['Product']))

plt.subplots(figsize=(10,8))
plt.imshow(wordcloud, interpolation='bilinear')
plt.axis('off')
plt.title('Most Product Sold (by Count)')
plt.savefig('../Output/Product Count')
plt.show()

Berdasarkan grafik wordcloud dapat terlihat bahwa Charging Cable adalah product terbanyak yang terjual. Kemudian USB C, batteries pack, C Charging, dan item-item lainnya.

Sementara untuk melihat product yang terjual dengan pendapatan tertinggi atau dapat dilihat pada kolom price total dapat menggunakan code sebagai berikut:

df_sales = df.groupby('Product').sum()[['Quantity Ordered', 'Price Total']]
df_sales.sort_values(by=['Price Total'], ascending=False).head()

berikut ini kode untuk mengetahui pendapatan per bulan secara descending dan visualisasi pada penjualan per bulan

df_month_year = df.groupby('Month-Year').sum()[['Quantity Ordered', 'Price Total']]
df_month_year = df_month_year.iloc[:-1]
print(df_month_year.sort_values(by=['Price Total'], ascending=False))

sales = df.groupby('Month-Year').sum()['Price Total'].round(2)
sales.plot(kind='line', x='Month-Year', y='Price Total', figsize=(12,8))
plt.legend()
plt.grid()

fig, ax = plt.subplots(1, 2, figsize=[15, 5])
df_month_year['Price Total'].plot.bar(ax=ax[0])
df_month_year['Price Total'].plot(ax=ax[0], color='red', marker='*')
df_month_year['Quantity Ordered'].plot.bar(ax=ax[1])
df_month_year['Quantity Ordered'].plot(ax=ax[1], color='red', marker='*')
ax[0].tick_params(labelrotation=90)
ax[1].tick_params(labelrotation=90)
ax[0].set_xlabel('Total Pendapatan')
ax[1].set_xlabel('Unit Terjual')
plt.suptitle('Penjualan per Bulan')
plt.savefig('../Output/Grafik Penjualan per Bulan')
plt.show()

df['Purchase Address City'] = df['Purchase Address'].apply(lambda x: x.split(',')[1][1:])

def cityProduct(city):
    return ' ,'.join(df['Product'][df['Purchase Address City'] == city].value_counts()[:3].index)

df_city = df.groupby('Purchase Address City').sum()[['Quantity Ordered', 'Price Total']].sort_values(by='Price Total', ascending=False)
df_city['Top 3 Product'] = list(map(cityProduct, df_city.index))
df_city.head()

Qty = df.groupby('Product').sum()['Quantity Ordered'].sort_values(ascending=False).head()
Qty = pd.DataFrame(Qty)
Qty

df_string_date = df.copy()
df_string_date['Order Date'] = df['Order Date'].dt.date.astype(np.str)
df_string_date = df_string_date.groupby('Order Date').sum().iloc[:-1]

plt.figure(figsize=(10, 8))
df_string_date['Price Total'].plot()
plt.title('Pendapatan Harian (2019)')
plt.ylabel('Pendapatan ($)')
plt.grid()
plt.savefig('../Output/Pendapatan Harian.png')
plt.show()

tahapan terakhir dalam sales data analysis yaitu menyimpan data olahan menjadi format csv agar dapat dilakukan prediksi penjualan pada bulan depan.

df_string_date["Day Order"] = pd.DatetimeIndex(df_string_date.index).day
df_string_date["Month Order"]= pd.DatetimeIndex(df_string_date.index).month
df_string_date["Year Order"] = pd.DatetimeIndex(df_string_date.index).year

df_ml = df_string_date.copy()
df_ml = df_ml[['Day Order','Month Order','Year Order','Price Total']]
df_ml.to_csv('../Data ML/Sales Harian 2019') #Digunakan untuk menyimpan data dengan format csv untuk dilakukan prediksi

Predicting Exited / Churn for Bank Customers brtujuan untuk memprediksi potensi customer berpindah ke kompetitor atau dalam hal ini ke bank lain. Data merupakan data dummy yang diperoleh dari kaggle.com, data terdiri dari informasi customer dan informasi pinjaman. pada prediksi kali ini kita akan menggunakan beberapa package dan model dari python sebagai berikut:

import numpy as np
import pandas as pd
import matplotlib.pyplot  as plt
import seaborn as sns
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import confusion_matrix, classification_report

data = pd.read_csv('C:/Users/abiza/Downloads/Project & Publikasi/Predicting Churn for Bank Customer/Churn_Modelling.csv')
print(data.head())
print(data.info())

Sebelum dilakukan modeling perlu dilakukan Exploratory Data Analysis untuk melihat sebaran data. EDA dapat dilakukan dengan membuat visualisasi pada data yang akan dieksplorasi.

import matplotlib.pyplot  as plt
fig = plt.figure()
ax= fig.add_axes([0,0,1,1])
ax.axis('equal')
labels=['no (0)','yes (1)']
churn=data.Exited.value_counts()
ax.pie(churn, labels=labels, autopct='%.0f%%')
plt.savefig('Churn.png')
plt.show()

visualisasi pie chart menunjukkan sebesar 20% customer keluar atau berpindah ke bank lain, dan sebanyak 80% masih tetap menjadi pelanggan.

num_columns = ['CreditScore','Tenure','Balance','EstimatedSalary']

fig, ax = plt.subplots(1,4,figsize=(20, 5))
data[data.Exited==0][num_columns].hist(bins=20,color='blue',alpha=0.5,ax=ax)
data[data.Exited==1][num_columns].hist(bins=20,color='purple',alpha=0.5,ax=ax)
plt.savefig('EDA.png')

sns.set(style='darkgrid')
fig, ax = plt.subplots(2,3,figsize=(14,12))
sns.countplot(data=data, x='Gender', hue='Exited', ax=ax[0][0])
sns.countplot(data=data, x='Geography', hue='Exited', ax=ax[0][1])
sns.countplot(data=data, x='NumOfProducts', hue='Exited', ax=ax[0][2])
sns.countplot(data=data, x='HasCrCard', hue='Exited', ax=ax[1][0])
sns.countplot(data=data, x='IsActiveMember', hue='Exited', ax=ax[1][1])
plt.tight_layout()
plt.savefig('EDA(1).png')
plt.show()

langkah selanjutnya, melakukan drop column yang tidak diperlukan untuk tahapan modeling

cleaned_data = data.drop(columns=['RowNumber','CustomerId','Surname'])

for i in cleaned_data.columns:
    if cleaned_data[i].dtype==np.number:
        continue
    cleaned_data[i] = LabelEncoder().fit_transform(cleaned_data[i])

X = cleaned_data.drop('Exited', axis=1)
y = cleaned_data['Exited']

x_train, x_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
print('Data Training:\n',x_train.shape)
print(y_train.value_counts(normalize=True))
print('\nData Testing: \n',x_test.shape)
print(y_test.value_counts(normalize=True))

Output:
Data Training:
 (7000, 10)
0    0.792429
1    0.207571
Name: Exited, dtype: float64

Data Testing: 
 (3000, 10)
0    0.805333
1    0.194667
Name: Exited, dtype: float64

Setelah melakukan split menjadi data training dan data test, tahapan berikutnya adalah melakukan prediksi dengan algoritma logistic regression, random forest classifier, dan gradient boosting classifier.

Logistic Regression

lr = LogisticRegression().fit(x_train, y_train)
y_train_pred = lr.predict(x_train)
print(classification_report(y_train, y_train_pred))

Output:

                 precision  recall  f1-score   support

           0       0.80      0.97      0.88      5547
           1       0.34      0.06      0.10      1453

    accuracy                           0.78      7000
   macro avg       0.57      0.51      0.49      7000
weighted avg       0.70      0.78      0.71      7000

membuat visualisasi heatmap pada confusion matrix data training

confusion_matrix_train = pd.DataFrame((confusion_matrix(y_train, y_train_pred)), ('No Exited', 'Exited'), ('No Exited', 'Exited'))

plt.figure(figsize=(6,5))
heatmaps = sns.heatmap(confusion_matrix_train, annot=True, annot_kws={'size':11}, fmt='d', cmap='YlGnBu')
heatmaps.yaxis.set_ticklabels(heatmaps.yaxis.get_ticklabels(), rotation=0, ha='right', fontsize=14)
heatmaps.xaxis.set_ticklabels(heatmaps.xaxis.get_ticklabels(), rotation=0, ha='right', fontsize=14)
plt.title('Confusion matrix for training model\n w/ Logistic regression\n', fontsize=16, color='darkblue')
plt.ylabel('True label', fontsize=14, color='darkblue')
plt.xlabel('\nPredicted Label', fontsize=14, color='darkblue')
plt.savefig('Confusion matrix for training model with Logistic regression.png')

plt.show()

Accuracy pada taining model menggunakan algoritma logistic
regression sebesar 78%. Berdasarkan confusion matrix pada
training model diperoleh hasil:
* Prediksi no exited yang sebenarnya exited sebanyak 1367
* Prediksi no exited yang benar sebanyak 5381
* Prediksi exited yang sebenarnya no exited sebanyak 166
* Prediksi exited yang benar sebanyak 86

y_test_pred = lr.predict(x_test)
print(classification_report(y_test, y_test_pred))

                precision    recall  f1-score   support

           0       0.82      0.97      0.88      2416
           1       0.41      0.09      0.15       584

    accuracy                           0.80      3000
   macro avg       0.61      0.53      0.52      3000
weighted avg       0.74      0.80      0.74      3000

membuat visualisasi heatmap pada confusion matrix data testing

confusion_matrix_test = pd.DataFrame((confusion_matrix(y_test, y_test_pred)),('No Exited', 'Exited'),('No Exited', 'Exited'))

plt.figure(figsize=(6,5))
heatmaps = sns.heatmap(confusion_matrix_test, annot=True, annot_kws={'size':11}, fmt='d', cmap='YlGnBu')
heatmaps.yaxis.set_ticklabels(heatmaps.yaxis.get_ticklabels(), rotation=0, ha='right', fontsize=14)
heatmaps.xaxis.set_ticklabels(heatmaps.xaxis.get_ticklabels(), rotation=0, ha='right', fontsize=14)
plt.title('Confusion matrix for testing model\n w/ Logistic regression\n', fontsize=16, color='darkblue')
plt.ylabel('True label', fontsize=14, color='darkblue')
plt.xlabel('\nPredicted Label', fontsize=14, color='darkblue')
plt.savefig('Confusion matrix for testing model with Logistic regression.png')

plt.show()

Accuracy pada testing model menggunakan algoritma logistic
regression sebesar 80%. Berdasarkan confusion matrix pada
testing model diperoleh hasil:
* Prediksi no exited yang sebenarnya exited sebanyak 529
* Prediksi no exited yang benar sebanyak 2336
* Prediksi exited yang sebenarnya no exited sebanyak 80
* Prediksi exited yang benar sebanyak 55

Random Forest Classifier

rfc = RandomForestClassifier().fit(x_train, y_train)
y_train_pred_rfc = rfc.predict(x_train)
print(classification_report(y_train, y_train_pred_rfc))

               precision    recall  f1-score   support

           0       1.00      1.00      1.00      5547
           1       1.00      1.00      1.00      1453

    accuracy                           1.00      7000
   macro avg       1.00      1.00      1.00      7000
weighted avg       1.00      1.00      1.00      7000

membuat visualisasi heatmap pada confusion matrix data training

confusion_matrix_train_rfc = pd.DataFrame((confusion_matrix(y_train, y_train_pred_rfc)), ('No Exited', 'Exited'), ('No Exited', 'Exited'))

plt.figure(figsize=(6,5))
heatmaps = sns.heatmap(confusion_matrix_train_rfc, annot=True, annot_kws={'size':11}, fmt='d', cmap='YlGnBu')
heatmaps.yaxis.set_ticklabels(heatmaps.yaxis.get_ticklabels(), rotation=0, ha='right', fontsize=14)
heatmaps.xaxis.set_ticklabels(heatmaps.xaxis.get_ticklabels(), rotation=0, ha='right', fontsize=14)
plt.title('Confusion matrix for training model\n w/ Random forest classifier\n', fontsize=16, color='darkblue')
plt.ylabel('True label', fontsize=14, color='darkblue')
plt.xlabel('\nPredicted Label', fontsize=14, color='darkblue')
plt.savefig('Confusion matrix for training model with Random Forest Classifier.png')

plt.show()

Accuracy pada training model menggunakan algoritma Random
Forest Classifier sebesar 100%. Berdasarkan confusion matrix
pada training model diperoleh hasil:
* Prediksi no exited yang sebenarnya exited sebanyak 0
* Prediksi no exited yang benar sebanyak 5547
* Prediksi exited yang sebenarnya no exited sebanyak 0
* Prediksi exited yang benar sebanyak 1453

y_test_pred_rfc = rfc.predict(x_test)
print(classification_report(y_test, y_test_pred_rfc))

                precision    recall  f1-score   support

           0       0.88      0.97      0.92      2416
           1       0.77      0.45      0.57       584

    accuracy                           0.87      3000
   macro avg       0.83      0.71      0.74      3000
weighted avg       0.86      0.87      0.85      3000

membuat visualisasi pada confusion matrix data testing

confusion_matrix_test_rfc = pd.DataFrame((confusion_matrix(y_test, y_test_pred_rfc)),('No Exited', 'Exited'),('No Exited', 'Exited'))

plt.figure(figsize=(6,5))
heatmaps = sns.heatmap(confusion_matrix_test_rfc, annot=True, annot_kws={'size':11}, fmt='d', cmap='YlGnBu')
heatmaps.yaxis.set_ticklabels(heatmaps.yaxis.get_ticklabels(), rotation=0, ha='right', fontsize=14)
heatmaps.xaxis.set_ticklabels(heatmaps.xaxis.get_ticklabels(), rotation=0, ha='right', fontsize=14)
plt.title('Confusion matrix for testing model\n w/ Random forest classifier\n', fontsize=16, color='darkblue')
plt.ylabel('True label', fontsize=14, color='darkblue')
plt.xlabel('\nPredicted Label', fontsize=14, color='darkblue')
plt.savefig('Confusion matrix for testing model with Random Forest Classifier.png')

plt.show()

Accuracy pada testing model menggunakan algoritma Random
Forest Classifier sebesar 87%. Berdasarkan confusion matrix
pada testing model diperoleh hasil:
* Prediksi no exited yang sebenarnya exited sebanyak 322
* Prediksi no exited yang benar sebanyak 2339
* Prediksi exited yang sebenarnya no exited sebanyak 77
* Prediksi exited yang benar sebanyak 262

Gradient Boosting Classifier

gbc = GradientBoostingClassifier().fit(x_train, y_train)
y_train_pred_gbc = gbc.predict(x_train)
print(classification_report(y_train, y_train_pred_gbc))

                precision    recall  f1-score   support

           0       0.88      0.97      0.92      5547
           1       0.81      0.48      0.61      1453

    accuracy                           0.87      7000
   macro avg       0.85      0.73      0.76      7000
weighted avg       0.86      0.87      0.86      7000

membuat visualisasi pada confusion matrix data training

confusion_matrix_train_gbc = pd.DataFrame((confusion_matrix(y_train, y_train_pred_gbc)), ('No Exited', 'Exited'), ('No Exited', 'Exited'))

plt.figure(figsize=(6,5))
heatmaps = sns.heatmap(confusion_matrix_train_gbc, annot=True, annot_kws={'size':11}, fmt='d', cmap='YlGnBu')
heatmaps.yaxis.set_ticklabels(heatmaps.yaxis.get_ticklabels(), rotation=0, ha='right', fontsize=14)
heatmaps.xaxis.set_ticklabels(heatmaps.xaxis.get_ticklabels(), rotation=0, ha='right', fontsize=14)
plt.title('Confusion matrix for training model\n w/ Gradient boosting classifier\n', fontsize=16, color='darkblue')
plt.ylabel('True label', fontsize=14, color='darkblue')
plt.xlabel('\nPredicted Label', fontsize=14, color='darkblue')
plt.savefig('Confusion matrix for training model with Gradient Boosting Classifier.png')

plt.show()

Accuracy pada training model menggunakan algoritma
Gradient Boosting Classifier sebesar 87%. Berdasarkan
confusion matrix pada training model diperoleh hasil:
* Prediksi no exited yang sebenarnya exited sebanyak 750
* Prediksi no exited yang benar sebanyak 5387
* Prediksi exited yang sebenarnya no exited sebanyak 160
* Prediksi exited yang benar sebanyak 703

y_test_pred_gbc = gbc.predict(x_test)
print(classification_report(y_test, y_test_pred_gbc))

                precision    recall  f1-score   support

           0       0.88      0.97      0.92      2416
           1       0.78      0.46      0.58       584

    accuracy                           0.87      3000
   macro avg       0.83      0.71      0.75      3000
weighted avg       0.86      0.87      0.86      3000

membuat visualisasi pada confusion matrix data testing

confusion_matrix_test_gbc = pd.DataFrame((confusion_matrix(y_test, y_test_pred_gbc)),('No Exited', 'Exited'),('No Exited', 'Exited'))

plt.figure(figsize=(6,5))
heatmaps = sns.heatmap(confusion_matrix_test_gbc, annot=True, annot_kws={'size':11}, fmt='d', cmap='YlGnBu')
heatmaps.yaxis.set_ticklabels(heatmaps.yaxis.get_ticklabels(), rotation=0, ha='right', fontsize=14)
heatmaps.xaxis.set_ticklabels(heatmaps.xaxis.get_ticklabels(), rotation=0, ha='right', fontsize=14)
plt.title('Confusion matrix for testing model\n w/ Gradient boosting classifier\n', fontsize=16, color='darkblue')
plt.ylabel('True label', fontsize=14, color='darkblue')
plt.xlabel('\nPredicted Label', fontsize=14, color='darkblue')
plt.savefig('Confusion matrix for testing model with Gradient Boosting Classifier.png')

plt.show()

Accuracy pada testing model menggunakan algoritma Gradient
Boosting Classifier sebesar 87%. Berdasarkan confusion matrix
pada testing model diperoleh hasil:
* Prediksi no exited yang sebenarnya exited sebanyak 316
* Prediksi no exited yang benar sebanyak 2342
* Prediksi exited yang sebenarnya no exited sebanyak 74
* Prediksi exited yang benar sebanyak 268

Segmentasi customer dilakukan untuk membagi atau mengelompokkan customer dengan karakteristik tertentu yang mirip. Segmentasi customer dapat dilakukan dengan cara clustering menggunakn algoritma KMeans dari bahasa pemrograman python. segmentasi customer kali ini dilakukan pada customer bank. Package yang digunakan sebagai berikut:

import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans

Dataset merupakan data dummy customer pada sebuah bank yang bersumber dari kaggle.com. Data terdiri dari informasi data customer yang bersifat umum dan informasi pinajaman.

data = data.drop(columns=['pdays'], inplace=False)

for col in data.columns:
    if data[col].dtype==np.object:
        print(col + ": \n", data[col].value_counts(), "\n")
        continue

Output:
job: 
 blue-collar      9536
management       8851
technician       7223
admin.           4810
services         4033
retired          1880
self-employed    1500
entrepreneur     1453
unemployed       1193
housemaid        1178
student           718
unknown           264
Name: job, dtype: int64

marital: 
 married     25868
single      11806
divorced     4965
Name: marital, dtype: int64

education: 
 secondary    22066
tertiary     12302
primary       6581
unknown       1690
Name: education, dtype: int64

default: 
 no     41828
yes      811
Name: default, dtype: int64

housing: 
 yes    24590
no     18049
Name: housing, dtype: int64

loan: 
 no     35554
yes     7085
Name: loan, dtype: int64

contact: 
 cellular     27218
unknown      12776
telephone     2645
Name: contact, dtype: int64

month: 
 may    13532
jul     6587
aug     5987
jun     5128
nov     3895
apr     2718
feb     2296
jan     1224
oct      518
sep      282
mar      258
dec      214
Name: month, dtype: int64

poutcome: 
 unknown    36085
failure     4271
other       1517
success      766
Name: poutcome, dtype: int64

term_deposit: 
 no     38678
yes     3961
Name: term_deposit, dtype: int64

Eksplorasi data dengan menggunakan visualisasi

plt.subplots(figsize=(15,5))
sns.countplot(x='job', data=data)
plt.title('Distribution of Job')
plt.savefig('Distribution of Job.png')

Customer dengan pekerjaan sebagai blue-collar memiliki jumlah terbanyak. Customer dengan pekerjaan sebagai management terbanyak setelah blue-collar, dan technician terbanyak ketiga setelah management. Sementara terendah adalah customer dengan status pekerjaan sebagai student

sns.countplot(x='marital', data=data)
plt.title('Distribution of Martial')
plt.savefig('Distribution of Martial.png')

Mayoritas customer bank berstatus menikah, customer dengan status single sebanyak 10.000 lebih. Sementara customer dengan status bercerai (divorced) sekitar 5000.

sns.countplot(x='education', data=data)
plt.title('Distribution of Education')
plt.savefig('Distribution of Education.png')

Bar chart pada distribusi ‘Education’ menunjukkan bahwa 20.000 lebih customer bank memiliki pendidikan ‘Secondary’

sns.countplot(x='contact', data=data)
plt.title('Distribution of Contact')
plt.savefig('Distribution of Contact.png')

Mayoritas customer bank memiliki perangkat komunikasi seluler (cellular), dan masih sebanyak 10.000 lebih customer bank dengan perangkat komunikasi yang tidak diketahui jenisnya.

data.hist('age', bins=35)
plt.title('Distribution of Age')
plt.ylabel('Count')
plt.xlabel('Age')
plt.savefig('Distribution of Age')

Histogram pada distribusi data ‘Age’ menampilkan bahwa mayoritas customer berumur 30 tahun keatas

sns.scatterplot('age', 'balance', hue='term_deposit', data=data)
plt.title('Age to Balance, Colored by Term Deposit')
plt.savefig('Age to Balance, Colored by Term Deposit.png')

Mayoritas customer bank masih tidak memiliki term deposit. Customer yang memiliki term deposit rata-rata memiliki balance dibawah 20.000.

x = data[['age','balance']]
wcss = []
for i in range(1, 11):
    km = KMeans(n_clusters = i, init = 'k-means++', random_state = 0)
    km.fit(x)
    wcss.append(km.inertia_)

plt.plot(range(1, 11), wcss, linewidth=2, color='blue', marker='8')
plt.axvline(x=5, ls='--')
plt.title('The Elbow Method')
plt.xlabel('no of clusters')
plt.ylabel('wcss')
plt.savefig('Elbow Method.png')
plt.show

Dengan menggunakan metode elbow diperoleh kesimpulan bahwa centroids atau titik tengah kelas cluster sebanyak 5 titik

model = KMeans(n_clusters=5, init='k-means++', random_state=0)
clusters = data.copy()
clusters['Cluster_Prediction'] = model.fit_predict(x)
clusters.head(10)

print('Before Clustering :\n')
sns.scatterplot('age', 'balance', data=data)
plt.title('Age to Balance')
plt.xlabel('Age')
plt.ylabel('Balance')
plt.savefig('Before Clustering.png')
plt.show()

print('After Clustering :\n')
plt.scatter(x=clusters[clusters['Cluster_Prediction']==1]['age']
           , y=clusters[clusters['Cluster_Prediction']==1]['balance'],
           s=30, edgecolor='black', linewidth=0.3, c='blue', label='Cluster 1')
plt.scatter(x=clusters[clusters['Cluster_Prediction']==2]['age']
           , y=clusters[clusters['Cluster_Prediction']==2]['balance'],
           s=30, edgecolor='black', linewidth=0.3, c='red', label='Cluster 2')
plt.scatter(x=clusters[clusters['Cluster_Prediction']==3]['age']
           , y=clusters[clusters['Cluster_Prediction']==3]['balance'],
           s=30, edgecolor='black', linewidth=0.3, c='pink', label='Cluster 3')
plt.scatter(x=clusters[clusters['Cluster_Prediction']==4]['age']
           , y=clusters[clusters['Cluster_Prediction']==4]['balance'],
           s=30, edgecolor='black', linewidth=0.3, c='deepskyblue', label='Cluster 4')
plt.scatter(x=clusters[clusters['Cluster_Prediction']==0]['age']
           , y=clusters[clusters['Cluster_Prediction']==0]['balance'],
           s=30, edgecolor='black', linewidth=0.3, c='purple', label='Cluster 5')

plt.scatter(x=model.cluster_centers_[:,0], y=model.cluster_centers_[:,1], s=30, c='grey', label='Centroids', edgecolor='black', linewidth=0.3)
plt.legend(loc='right')
plt.xlabel('Age')
plt.ylabel('Balance')
plt.title('Clusters')
plt.savefig('Clustering.png')
plt.show()

Cluster 1 = Customer rata-rata  berumur 20 - 60 dengan balance  10.000 keatas 
Cluster 2 = Cluster dengan jumlah  customer terendah, akan tetapi  memiliki balance tertinggi  
Cluster 3 = Customer berumur 20 -  85 tahun dengan balance 10.000  kebawah 
Cluster 4 = Cluster rata-rata  berumur 22 - 60 dengan balance  15.000 - 40.000 
Cluster 5 = Cluster dengan balance  terendah

Analysis of return rate stock digunakan untuk mengetahui return rate dari saham yang akan kita beli di pasar saham ataupun saham yang sudah ada di portofolio. Data yang digunakan pada analisis adalah data dari yahoo finance dan untuk mendapatkan insight menggunakan bahasa pemrograman python. Pada analisis kali ini kita menggunakan beberapa package sebagai berikut:

import re
import time
import matplotlib
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
import urllib.request as urllib2
from datetime import datetime, timedelta

def dl():
    df = pd.read_csv('C:/Users/abiza/Downloads/Project & Publikasi/Analysis of Return Rate Stock/input/^JKSE.csv', index_col='Date', parse_dates=True)
    df = df.sort_index(ascending=True)
    df = df.tail(80)
    # analysis
    macd = pd.Series(df['Adj Close']).rolling(window=12).mean()
    # bollinger bands
    movavg = pd.Series(df['Adj Close']).rolling(window=20).mean()
    movstddev = pd.Series(df['Adj Close']).rolling(window=20).std()
    upperband = movavg + 2*movstddev
    lowerband = movavg - 2*movstddev

    # plot settings
    matplotlib.rcParams.update({'font.size': 8})
    s = datetime.now()
    plt.subplots(figsize=(20, 5))

    # begin plot
    df['Adj Close'].plot(label='Close')
    macd.plot(label='macd', linestyle='--', color='r')
    upperband.plot(color='green')
    lowerband.plot(color='green')

    plt.title('Analisis Teknikal MACD dan Bollinger Bands IHSG')
    plt.legend(['Adjusted Close', 'MACD', 'Upper Bollinger', 'Lower  Bollinger'])
    plt.xlim(s - timedelta(days=130), s + timedelta(days=7))
    plt.ylabel('Adjusted Close')
    plt.xlabel('Tanggal')
    
    plt.savefig('ihsg.png')
    plt.show()
dl()

Garis MACD (Moving Average Convergence Divergence) menentukan tren harga IHSG. pada tanggal 15 Mei 2021 hingga 1 Juni 2021 tren harga IHSG mengalami penurunan, namun kembali meningkat pada 2 Juni 2021 hingga 15 Juni 2021. Selanjutnya, tren harga IHSG tidak mengalami perubahan signifikan hingga 1 Agustus 2021.

MACD juga merupakan garis tengah antara dua signal pada bollinger bands. Bollinger Bands umumnya digunakan untuk keputusan sell pada saat harga IHSG melampui garis upper bollinger, dan keputusan buy saat harga IHSG melampui lower bollinger, namun keputusan ini tidak sepenuhnya mutlak untuk berhasil mendapatkan profit karena kondisi pasar saham yang tidak menentu.

ANTM = pd.read_csv('C:/Users/abiza/Downloads/Project & Publikasi/Analysis of Return Rate Stock/input/ANTM.JK.csv')
ANTM['simple_retrate'] = (ANTM['Adj Close']/ANTM['Adj Close'].shift(1)) - 1
print('Simple Return Rate Saham ANTM.JK: \n', ANTM['simple_retrate'], '\n')

Output:
Simple Return Rate Saham ANTM.JK: 
 0           NaN
1      0.007143
2      0.063830
3      0.113333
4      0.005988
         ...   
235    0.003817
236   -0.038023
237   -0.003953
238    0.027778
239   -0.027027
Name: simple_retrate, Length: 240, dtype: float64

ANTM['simple_retrate'].plot(figsize=(20,5))
plt.title('Simple Return Rate Saham ANTM.JK', fontsize=15)
plt.savefig('Simple Return rate ANTM.png')
plt.show()

Berdasarkan Simple Return Rate Saham ANTM.JK, tren return rate tidak banyak mengalami perubahan. Tertinggi terjadi pada indeks ke-50 dengan pencapaian sebesar 25% simple return rate pada saham ANTM.JK.

ANTM['Adj Close'].plot(figsize=(20,5))
plt.title('Adj Close Saham Aneka Tambang Tbk.')
plt.savefig('Adj Close Saham ANTM.png')
plt.show()

BBCA = pd.read_csv('C:/Users/abiza/Downloads/Project & Publikasi/Analysis of Return Rate Stock/input/BBCA.JK.csv')
BBCA['Adj Close'].plot(figsize=(20,5))
plt.title('Adj Close Saham Bank BCA')
plt.savefig('Adj Close Saham BCA.png')
plt.show()

BMRI = pd.read_csv('C:/Users/abiza/Downloads/Project & Publikasi/Analysis of Return Rate Stock/input/BMRI.JK.csv')
BMRI['Adj Close'].plot(figsize=(20,5))
plt.title('Adj Close Saham Bank Mandiri')
plt.savefig('Adj Close Saham Bank Mandiri.png')
plt.show()

TLKM = pd.read_csv('C:/Users/abiza/Downloads/Project & Publikasi/Analysis of Return Rate Stock/input/TLKM.JK.csv')
TLKM['Adj Close'].plot(figsize=(20,5))
plt.title('Adj Close Saham Telkom Indonesia (Persero) Tbk.')
plt.savefig('Adj Close Saham TLKM.png')
plt.show()

agar kita dapat melihat perbedaan adj close antar saham maka kita dapat menggabungkan fluktuasi adj close keempat saham menjadi satu visualisasi.

ANTM = ANTM.rename(columns={'Adj Close':'Adj Close ANTM'})
BBCA = BBCA.rename(columns={'Adj Close':'Adj Close BBCA'})
BMRI = BMRI.rename(columns={'Adj Close':'Adj Close BMRI'})
TLKM = TLKM.rename(columns={'Adj Close':'Adj Close TLKM'})
mydata = [ANTM['Adj Close ANTM'], BBCA['Adj Close BBCA'], BMRI['Adj Close BMRI'], TLKM['Adj Close TLKM']] 
mydata = pd.DataFrame(mydata)
mydata = mydata.transpose()

(mydata / mydata.iloc[0]*100).plot(figsize=(20,5))
plt.title('Perbandingan Adj Close')
plt.savefig('Perbandingan Adj Close')
plt.show()

Perbandingan pada keempat saham perusahaan besar (ANTM.JK, BMRI.JK, BBRI.JK, TLKM.JK) terlihat harga saham pada ANTM.JK lebih unggul dari saham lainnya dengan perbedaan yang cukup besar. Tren harga saham pada BMRI.JK terbaik setelah ANTM.JK, kemudian disusul oleh saham TLKM.JK, dan BBRI.JK. perbedaan dari ketiga saham dibawah ANTM.JK tidak terlalu jauh.

# membandingkan fluktuasi 'ANTM.JK' dengan indeks market
JKSE = pd.read_csv('C:/Users/abiza/Downloads/Project & Publikasi/Analysis of Return Rate Stock/input/^JKSE.csv')
LQ45 = pd.read_csv('C:/Users/abiza/Downloads/Project & Publikasi/Analysis of Return Rate Stock/input/^JKLQ45.csv')
JKSE = JKSE.rename(columns={'Adj Close':'Adj Close JKSE'})
LQ45 = LQ45.rename(columns={'Adj Close':'Adj Close LQ45'})
mydata = [ANTM['Adj Close ANTM'], TLKM['Adj Close TLKM'], JKSE['Adj Close JKSE'], LQ45['Adj Close LQ45']] 
mydata = pd.DataFrame(mydata)
mydata = mydata.transpose()
print(mydata.head(), '\n')
print(mydata.describe(), '\n')

(mydata / mydata.iloc[0]*100).plot(figsize=(20,5))
plt.savefig('Perbandingan Saham dan Indeks')
plt.show()

Saham ANTM.JK lebih tinggi dibandingkan indeks pada pasar saham (JKSE & LQ45), namun TLKM.JK masih berada dikisaran indeks pada pasar saham. Hal ini membuktikan bahwa saham ANTM.JK berkontribusi besar pada pasar saham dan IHSG ataupun indeks sejenis.

# menghitung return rate tahunan
mydata = [BBCA['Adj Close BBCA'], BMRI['Adj Close BMRI'], ANTM['Adj Close ANTM']] 
mydata = pd.DataFrame(mydata)
mydata = mydata.transpose()
    
saham_ret = np.log(mydata / mydata.shift(1))
# corelasi antar saham
corr_matrix = saham_ret.corr()
print(corr_matrix)
sns.heatmap(corr_matrix, annot=True)
plt.savefig('Heatmap Saham')

Heatmap (korelasi) pada saham ANTM.JK, BMRI.JK, BBCA.JK:

● Saham BMRI.JK dengan BBCA.JK berkorelasi sebesar 59%

● Saham BMRI.JK dengan ANTM.JK berkorelasi sebesar 33%

● Saham BBCA.JK dengan ANTM.JK berkorelasi sebesar 23%

Analisis regresi linear berganda digunakan untuk melihat hubungan antara variabel independent dan dependent secara signifikan. Salah satu metode sederhana yang sering digunakan pada analisis regresi linear berganda adalah Ordinary Least Square (OLS). Persamaan pada analisis regresi linear berganda sebagai berikut:

y = c + b1x1 + b2x2 + e

Analisis kali ini akan melihat hubungan antara Nilai tukar rupiah terhadap dolar amerika (IDR/USD), Indeks harga saham gabungan (IHSG), Dow jones industrial average (DJIA) serta pengaruhnya terhadap harga konversi bitcoin ke rupiah (y1) dan harga emas berjangka (y2). Analisis menggunakan bahasa pemrograman python, tahapan awal yaitu melakukan import package dan model yang akan digunakan:

import numpy as np
import pandas as pd
import seaborn as sns
import statsmodels
import patsy
import statsmodels.api as sm
import matplotlib.pyplot as plt

!pip install hidrokit
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn import metrics

Selanjutnya, upload data dan baca data yang akan dianalisis, berikut ini tampilan data yang digunakan pada analisis ini:

<class 'pandas.core.frame.DataFrame'> 
Index: 27 entries, Jan '19 to Mar '21 
Data columns (total 5 columns):
  
#   Column               Non-Null Count  Dtype   
--- ------               --------------  -----    
0   IDX Composite          27 non-null  float64  
1   USD/IDR                27 non-null   int64    
2   Dow Jones Industrial   27 non-null  float64  
3   BTC/IDR                27 non-null   int64    
4   Emas Berjangka         27 non-null  float64
 
dtypes: float64(3), int64(2) memory usage: 1.3+ KB

Suatu data perlu dilakukan exploratory data analysis, EDA dapat menggunakan visualisasi untuk menegtahui fluktuasi dan hubungan data yang digunakan dalam sebuah analisis. Berikut adalah visualisasi EDA dari data yang digunakan:

Berdasarkan pada visualisasi EDA diatas: Y1 dengan variabel lain berkorelasi positif. Y2 dengan variabel y1, x3, dan x2 berkorelasi positif, sementara dengan x1 berkorelasi negatif.

IHSG mengalami penurunan tajam, Nilai tukar rupiah melemah hingga menyentuh 16.000 / US dollar, dan Indeks DJIA juga mengalami penurunan tajam dari periode sebelumnya. Namun disisi lain, bitcoin tidak terdampak dan memberikan sinyal positif, emas berjangka juga cenderung stagnan pada periode April 2020.

Keterangan:

X1 = IDX Composite / IHSG ;

X2 = USD/IDR (Nilai Tukar) ;

X3 = Dow Jones Industrial Average ;

Y1 = BTC/IDR (Harga Konversi Bitcoin) ;

Y2 = Emas Berjangka

Tahapan analisis berikutnya yaitu menentukan variabel independent dan variabel dependet. variabel dependent dalam analisis ini adalah harga konversi bitcoin ke rupiah dan harga emas berjangka, sementara variabel independent adalah:

dataset = dataset.rename(columns={'IDX Composite' : 'x1', 'USD/IDR' : 'x2', 'Dow Jones Industrial': 'x3', 'BTC/IDR' : 'y1', 'Emas Berjangka' : 'y2'})
independent=['x1', 'x2', 'x3']

x = dataset[independent]
y1 = dataset['y1']
print("Variabel Independent:\n", x.head())
print("\nVariabel Dependent:\n", y1.head())

menentukan data train dan data test:

x_train, x_test, y_train, y_test = train_test_split(x, y1, random_state=1)

Linreg = LinearRegression()
Linreg.fit(x_train,y_train)
y_pred = Linreg.predict(x_test)
print('Prediksi pada Data Pengujian:\n', y_pred)
print('RMSE:\n', np.sqrt(metrics.mean_squared_error(y_test,y_pred)))

x = sm.add_constant(x)
model=sm.OLS(y1,x).fit()
model.summary()

Interpretasi Output:

y1 = -4.895 + 2.899 x1 + 1.925 x2 + 7.988 x3 + e

1. apabila nilai x1, x2, dan x3 adalah 0 maka nilai y1 sebesar -4.895

2. setiap perubahan kenaikan x2 atau Indeks Harga Saham Gabungan (IDX Composite) sebesar satu satuan maka akan menyebabkan perubahan kenaikan y1 atau harga konversi bitcoin ke rupiah sebesar 1.925

3. setiap perubahan kenaikan x3 atau Dow Jones Industrial Average sebesar satu satuan maka akan menyebabkan perubahan kenaikan y1 atau harga konversi bitcoin ke rupiah sebesar 7.988

4. nilai R-Squared sebesar 0.779 menjelaskan variabel independent dalam pengujian mempengaruhi variabel dependent sebesar 78%, sementara 22% lainnya dipengaruhi oleh variabel lain diluar model pengujian.

Kemudian, melakukan tahapan yang sama pada variabel y2 atau harga emas berjangka.

independent=['x1', 'x2', 'x3']
x = dataset[independent]
y2 = dataset['y2']

x_train, x_test, y_train, y_test = train_test_split(x, y2, random_state=1)

Linreg = LinearRegression()
Linreg.fit(x_train,y_train)
y_pred = Linreg.predict(x_test)
print('Prediksi pada Data Pengujian:\n', y_pred)
print('RMSE:\n', np.sqrt(metrics.mean_squared_error(y_test,y_pred)))

x = sm.add_constant(x)
model=sm.OLS(y2,x).fit()
model.summary()

Interpretasi Output:

y1 = 3324.0061–0.3170 x1–0.0838 x2 + 0.0498 x3 + e

1. apabila nilai x1, x2, dan x3 adalah 0 maka nilai y2 sebesar 3324.0061

2. setiap perubahan kenaikan x1 atau nilai tukar rupiah ke dolar (IDR/USD) sebesar satu satuan maka akan menyebabkan perubahan penurunan y2 atau harga emas sebesar 0.3170

3. setiap perubahan kenaikan x3 atau Dow Jones Industrial Average sebesar satu satuan maka akan menyebabkan perubahan kenaikan y2 atau harga emas sebesar 0.0498

4. nilai R-Squared sebesar 0.802 menjelaskan variabel independent dalam pengujian mempengaruhi variabel dependent sebesar 80%, sementara 20% lainnya dipengaruhi oleh variabel lain diluar model pengujian.

Untuk melihat korelasi pada variabel independent dapat menggunakan visualisasi heatmap, tujuan melihat korelasi pada variabel independent adalah untuk mendeteksi adanya multikolonieritas. Apabila antar variabel independent memiliki korelasi diatas 0.8 maka dapat dikatakan bahwa terdapat multikolonieritas pada data pengujian.

ind = dataset.drop(columns=['y1', 'y2'])
cor = ind.corr(method='pearson')
print('\nCorelasi Pearson:\n', cor)
sns.heatmap(cor, annot=True)
plt.show()