# clear-up the environment
rm(list = ls())

# chunk options
knitr::opts_chunk$set(
  message = FALSE,
  warning = FALSE,
  fig.align = "center",
  comment = "#>"
)

options(scipen = 123)

library(tidyverse)
library(keras)
library(plotly)
library(MLmetrics)
library(caret)
library(GGally)

1 Introduction

Selamat pagi/siang/sore/malam kepada para pembaca report LBB ini. dalam report ini, saya akan memproses dataset concrete yang kita dapat dari kaggle.

Dalam report ini kita akan membentuk model regresi dengan Deep learning. target dari model Deep learning adalah menentukan kekuatan beton.

2 Import data set

concrete <- read.csv("concrete_data.csv")

glimpse(concrete)

#> Rows: 1,030
#> Columns: 9
#> $ Cement             <dbl> 540.0, 540.0, 332.5, 332.5, 198.6, 266.0, 380.0, 38~
#> $ Blast.Furnace.Slag <dbl> 0.0, 0.0, 142.5, 142.5, 132.4, 114.0, 95.0, 95.0, 1~
#> $ Fly.Ash            <dbl> 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, ~
#> $ Water              <dbl> 162, 162, 228, 228, 192, 228, 228, 228, 228, 228, 1~
#> $ Superplasticizer   <dbl> 2.5, 2.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0~
#> $ Coarse.Aggregate   <dbl> 1040.0, 1055.0, 932.0, 932.0, 978.4, 932.0, 932.0, ~
#> $ Fine.Aggregate     <dbl> 676.0, 676.0, 594.0, 594.0, 825.5, 670.0, 594.0, 59~
#> $ Age                <dbl> 28, 28, 270, 365, 360, 90, 365, 28, 28, 28, 90, 28,~
#> $ Strength           <dbl> 79.99, 61.89, 40.27, 41.05, 44.30, 47.03, 43.70, 36~

dim(concrete)

#> [1] 1030    9

Dalam dataset ini mengandung 1030 observasi dan 8 variable prediktor dan 1 target. Semua tipe data dalam dataset adalah numeric.

3 Data Cleansing

kita melihat kalau data sudah dalam bentuk numerik. sekarang kita akan melihat apakah ada data outlier dalam dataset.

boxplot(concrete)

kita melihat adanya outlier walaupun tidak banyak. kita akan tetap menghapusnya.

outliers <- function(x) {

  Q1 <- quantile(x, probs=.25)
  Q3 <- quantile(x, probs=.75)
  iqr = Q3-Q1

 upper_limit = Q3 + (iqr*1.5)
 lower_limit = Q1 - (iqr*1.5)

 x > upper_limit | x < lower_limit
}

remove_outliers <- function(df, cols = names(df)) {
  for (col in cols) {
    df <- df[!outliers(df[[col]]),]
  }
  df
}

concrete_clean <- remove_outliers(concrete, c('Blast.Furnace.Slag', 'Water', 'Superplasticizer', 'Fine.Aggregate', 'Age'))

boxplot(concrete_clean)

data outlier sudah dibuang, sekarang kita akan melihat apakah ada missing value pada data

colSums(is.na(concrete_clean))

#>             Cement Blast.Furnace.Slag            Fly.Ash              Water 
#>                  0                  0                  0                  0 
#>   Superplasticizer   Coarse.Aggregate     Fine.Aggregate                Age 
#>                  0                  0                  0                  0 
#>           Strength 
#>                  0

data tidak memiliki outlier. sehingga kita bisa membagi data untuk pembuatan model.

4 Data Correlation

Terlebih dahulu kita akan melihat korelasi antar variable.

ggcorr(concrete_clean, label = TRUE, label_size = 2.9, hjust = 1, layout.exp = 2)

kita bisa melihat kalau Strenght (kekuatan beton) memiliki korelasi yang baik dengan Cement.

5 Data train dan Data test

sekarang kita akan membagi data menjadi 2 bagian yaitu data train yang mengandung 80% jumlah data dan data test yang memiliki 20% jumlah data.

set.seed(100)
idx <- sample(nrow(concrete_clean), nrow(concrete_clean)*0.8)
data_train <- concrete_clean[idx,]
data_test <- concrete_clean[-idx,]

6 Data pre-processing

Sebelum membuat model dengan Keras, ada beberapa hal yang perlu dilakukan untuk mempersiapkan data:

Memisahkan prediktor dengan target variabel
Scalling data
Mengubah format data menjadi array. Dari matrix -> array

6.1 Memisahkan Prediktor Dengan Target

pada tahapan ini. kita akan memisahkan prediktor dengan variable sekaligus melakukan scaling pada variable prediktor.

#prediktor
train_x <- data_train %>% 
  select(-Strength ) %>%
  as.matrix() %>%
  scale()

test_x <- data_test %>% 
  select(-Strength ) %>%
  as.matrix() %>%
  scale()

#target
train_y <- data_train %>% 
  select(Strength) %>%
  as.matrix()

test_y <- data_test %>% 
  select(Strength) %>%
  as.matrix()

boxplot(test_x)

boxplot(train_x)

proses pemisahan dan scaling pada data train dan data test yang hanya mengandung prediktor sudah berhasil.

6.1.0.1 Processing prediktor: Mengubah matrix menjadi array

Framework keras menerima data dalam bentuk array. Sehingga data prediktor dalam bentuk matrix perlu diubah ke dalam bentuk array menggunakan array_reshape().

# prediktor
train_x_keras <- train_x %>% 
                 array_reshape(dim = dim(train_x))

test_x_keras <- test_x %>% 
                 array_reshape(dim = dim(test_x))

7 Model Linear Regressi

sebelum membuat model Deep learning, kita akan terlebih dahulu membentuk model Linear regressi sebagai acuan target hasil model Deep learning. kita akan menggunakan semua prediktor.

model_lm <- lm(Strength ~., data = data_train)

summary(model_lm)

#> 
#> Call:
#> lm(formula = Strength ~ ., data = data_train)
#> 
#> Residuals:
#>     Min      1Q  Median      3Q     Max 
#> -24.665  -4.770  -0.132   4.839  34.069 
#> 
#> Coefficients:
#>                     Estimate Std. Error t value             Pr(>|t|)    
#> (Intercept)        41.570043  25.660135   1.620               0.1057    
#> Cement              0.106902   0.008100  13.197 < 0.0000000000000002 ***
#> Blast.Furnace.Slag  0.079825   0.009698   8.231 0.000000000000000843 ***
#> Fly.Ash             0.051460   0.012052   4.270 0.000022134569349970 ***
#> Water              -0.252777   0.039301  -6.432 0.000000000227113326 ***
#> Superplasticizer    0.214785   0.094527   2.272               0.0234 *  
#> Coarse.Aggregate   -0.007102   0.008953  -0.793               0.4279    
#> Fine.Aggregate     -0.005587   0.010362  -0.539               0.5900    
#> Age                 0.324086   0.010646  30.443 < 0.0000000000000002 ***
#> ---
#> Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
#> 
#> Residual standard error: 8.139 on 735 degrees of freedom
#> Multiple R-squared:  0.7778, Adjusted R-squared:  0.7754 
#> F-statistic: 321.7 on 8 and 735 DF,  p-value: < 0.00000000000000022

kita tidak akan memakai adj.R-squared sebagai acuan melainkan nilai MAE dari model.

MAE(model_lm$fitted.values, data_train$Strength)

#> [1] 6.193281

kita memakai MAE sebagai acuan karena model Deep learning tidak memiliki metrics R-squared. MAE dari model linear regressi adalah 6.19.

pred_lm <- predict(model_lm, head(data_test,10))

MAE(pred_lm,
     data_test[1:10, "Strength"])

#> [1] 14.8775

dari hasil prediksi, kita mendapatkan kalau nilai error pada prediksi lebih besar daripada data train. walauapun tidak melebihi 10% kita tetap menyimpulkan kalau model mengalami overfitt.

8 Model Deep Learning

semua persiapan sudah selesai. sekarang kita akan membuat model Deep learning.

target variable adalah 1. sehingga output layer hanya ada 1.
kita akan menggunakan 3 hidden layer. (hidden layer yang baik berjumlah 2-3)
kita akan menggunkan 8 node pada hidden layer pertama dan 4 di hidden layer kedua dan 2 node pada hidden layer ketiga. (untuk jumlah nodes, kita akan memakai 2/3 dari total prediktor)

# keras initialization
model <- keras_model_sequential()

tensorflow::tf$random$set_seed(100)

model %>% 
  layer_dense(input_shape = ncol(train_x_keras),
              units = 6, 
              activation = "relu") %>%
  layer_dense(units = 4,
              activation = "relu") %>% 
  layer_dense(units = 2,
              activation = "relu") %>%
  layer_dense(units = 1,
              activation = "linear")

model %>% 
  compile(loss = "mse", 
          optimizer = optimizer_adam(learning_rate = 0.001),
      metrics = list("mean_absolute_error"))

history <- fit(model, 
  train_x_keras,
  train_y,
  batch_size = 3, 
  epoch = 15
)

nilai error yang didapat adalah 6.3367. kita akan melihat apakah hasil prediksi mengalami overfit atau tidak.

plot(history)

# Predict Model Deep learning

result <- model %>% evaluate(test_x_keras, test_y)
result

#> $loss
#> [1] 64.8451
#> 
#> $mean_absolute_error
#> [1] 6.166116

kita mendapatkan hasil error evaluasi model pada data test sebesar 6.16.

9 Conclusion

Model Deep learning tidak mengalami overfit dimana hasil data train = 6.3 dan data test = 6.16.
Hal ini tidak terjadi pada model regressi yang mengalami overfit pada data test
Model Deep learning bisa digunakan sebagai alternatif jika model linear regressi tidak menghasilkan hasil yang bagus.
Model Deep Learning masih harus melakukan trial dan error secara manual agar bisa menghasilkan hasil yang optimal.

sekian report LBB saya dalam Deep learning. Deep learning sangat powerfull dan bisa digunakan hampir untuk semua kasus. karena Deep learning cukup kompleks. diperlukan waktu untuk mengeskplore semua potensi yang ada pada Deep learning. thank you sudah membaca report ini.

LBB Deep Learning Regression

Michael Deng

October 14, 2021