Introduction to Data Sciences

Tugas UAS PDS Kelompok

Kontak	\(\downarrow\)
Email	naftaligunawan@gmail.com
Instagram	https://www.instagram.com/nbrigittag/
RPubs	https://rpubs.com/naftalibrigitta/
Nama	Naftali Brigitta Gunawan
NIM	20214920002

Pengantar

Pada kesempatan kali ini, kami ingin memenuhi penugasan akhir di semester 2 untuk mata kuliah Pengenalan Data Sains yang dibimbing langsung oleh pak Bakti Siregar. Adapun penugasan kali ini dilakukan secara berkelompok yang terdiri dari :

1. Valensius Jimy
2. Naftali Brigitta Gunawan
3. Jeremy Heriyandi Saudi

Kiranya apa yang kami kerjakan pada penugasan akhir ini mendapatkan hasil yang maksimal dan memenuhi semua objektif penilaian.

Permasalahan Project

Pak Bakti telah memulai perusahaan selulernya sendiri. Pak Bakti ingin memperluas pasar perdagannya dan bercita-cita untuk dapat bersaing dengan besar seperti Apple, Samsung, dll. Tetapi Dia tidak tahu bagaimana memperkirakan harga ponsel yang sesuai untuk setiap produk yang dibuat perusahaannya. Oleh karena itu, perusahaan Pak Bakti bermaksud untuk melakukan analisis berdasarkan data penjualan ponsel dari berbagai perusahaan.

Pemrosesan Data

Dataset dalam kesempatan kali ini didapat langsung dari Google Classroom.

Read Data

# Input Library 

library(tidyverse)
library(tidymodels)
library(gridExtra)
library(lubridate)
library(ggplot2)
library(caret)
library(party)
library(data.table)
library(dplyr)
library(plotly)
library(randomForest)
library(emdi)
library(rpart)

# Import Data

seluler <- read.csv("C:/Users/Naftali Brigitta/Documents/Kampus/PDS/UAS/train.csv")

data.frame("total.data" = dim(seluler)[1],
           "total.variabel" = dim(seluler)[2])

Berdasarkan informasi di atas, diketahui bahwa dataset terdiri dari 2000 data dan 21 variabel. Sekarang, kami mencoba untuk melihat 5 data teratas dan 5 data terbawah untuk mengetahui bagaimana isi dataset kita secara garis besarnya dan terdapat apa saja variabel di dalamnya.

5 Data teratas

head(seluler, 5)

5 Data terbawah

tail(seluler, 5)

Deskripsi Variabel

adapun deskripsi dari setiap variabelnya, yaitu :

Variabel	Deskripsi	Keterangan
battery_power	kapasitas baterai	mAH
blue	support bluetooth	1 : Ya, 0 : Tidak
clock_speed	kecepatan microprocessor	GHz
dual_sim	support dual sim	1 : Ya, 0 : Tidak
fc	resolusi kamera depan	Megapixel
four_g	support 4G	1 : Ya, 0 : Tidak
int_memory	kapasitas memori internal	Gb
m_dep	ketebalan unit	cm
mobile_wt	berat unit	gr
n_cores	jumlah core	satuan core
pc	resolusi kamera belakang	megapixel
px_height	tinggi resolusi layar	pixel
px_width	lebar resolusi layar	pixel
ram	kapasitas RAM	megabyte
sc_h	tinggi layar	cm
sc_w	lebar layar	cm
talk_time	waktu pemakaian	hour
three_g	support 3G	1 : Ya, 0 : Tidak
touch_screen	layar sentuh	1 : Ya, 0 : Tidak
wifi	support wifi	1 : Ya, 0 : Tidak
price_range	kelas harga	0 : murah, 1 : normal, 2 : mahal, 3 : sangat mahal

Struktur Dataset

selanjutnya, kami ingin melihat struktur dari setiap variabel yang terdapat pada dataset kami.

glimpse(seluler)

## Rows: 2,000
## Columns: 21
## $ battery_power <int> 842, 1021, 563, 615, 1821, 1859, 1821, 1954, 1445, 509, ~
## $ blue          <int> 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1,~
## $ clock_speed   <dbl> 2.2, 0.5, 0.5, 2.5, 1.2, 0.5, 1.7, 0.5, 0.5, 0.6, 2.9, 2~
## $ dual_sim      <int> 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,~
## $ fc            <int> 1, 0, 2, 0, 13, 3, 4, 0, 0, 2, 0, 5, 2, 7, 13, 3, 1, 7, ~
## $ four_g        <int> 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0,~
## $ int_memory    <int> 7, 53, 41, 10, 44, 22, 10, 24, 53, 9, 9, 33, 33, 17, 52,~
## $ m_dep         <dbl> 0.6, 0.7, 0.9, 0.8, 0.6, 0.7, 0.8, 0.8, 0.7, 0.1, 0.1, 0~
## $ mobile_wt     <int> 188, 136, 145, 131, 141, 164, 139, 187, 174, 93, 182, 17~
## $ n_cores       <int> 2, 3, 5, 6, 2, 1, 8, 4, 7, 5, 5, 8, 4, 4, 1, 2, 8, 3, 5,~
## $ pc            <int> 2, 6, 6, 9, 14, 7, 10, 0, 14, 15, 1, 18, 17, 11, 17, 16,~
## $ px_height     <int> 20, 905, 1263, 1216, 1208, 1004, 381, 512, 386, 1137, 24~
## $ px_width      <int> 756, 1988, 1716, 1786, 1212, 1654, 1018, 1149, 836, 1224~
## $ ram           <int> 2549, 2631, 2603, 2769, 1411, 1067, 3220, 700, 1099, 513~
## $ sc_h          <int> 9, 17, 11, 16, 8, 17, 13, 16, 17, 19, 5, 14, 18, 7, 14, ~
## $ sc_w          <int> 7, 3, 2, 8, 2, 1, 8, 3, 1, 10, 2, 9, 0, 1, 9, 15, 9, 2, ~
## $ talk_time     <int> 19, 7, 9, 11, 15, 10, 18, 5, 20, 12, 7, 13, 2, 4, 3, 11,~
## $ three_g       <int> 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,~
## $ touch_screen  <int> 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1,~
## $ wifi          <int> 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0,~
## $ price_range   <int> 1, 2, 2, 2, 1, 1, 3, 0, 0, 0, 3, 3, 1, 2, 0, 0, 3, 3, 1,~

Missing Value

Langkah berikutnya yang tidak boleh dilewatkan dalam mengolah data adalah melihat apakah suatu data terdapat missing value atau tidak, jangan sampai sudah jalan panjang tetapi datanya terdapat missing value yang nantinya mendapat hasil tidak efektif. Maka dari itu, kami mencoba mencari tahu apakah dataset kami terdapat missing value.

colSums(is.na(seluler))

## battery_power          blue   clock_speed      dual_sim            fc 
##             0             0             0             0             0 
##        four_g    int_memory         m_dep     mobile_wt       n_cores 
##             0             0             0             0             0 
##            pc     px_height      px_width           ram          sc_h 
##             0             0             0             0             0 
##          sc_w     talk_time       three_g  touch_screen          wifi 
##             0             0             0             0             0 
##   price_range 
##             0

Hasil ini sangat membuat kami senang, karena dataset kami tidak memiliki missing value.

EDA

Kemudian, kami akan mencoba menampilkan visualisasi data yang kami miliki untuk melihat secara garis besar bagaimana hubungan dan hasilnya.

selulerr <- seluler %>%
  select(-price_range)

corr <-cor(selulerr)

library(corrplot)

## Warning: package 'corrplot' was built under R version 4.1.3

## corrplot 0.92 loaded

corrplot(corr, type = 'upper', order = 'hclust', col=rainbow(8))

Berdasarkan korelasi matriks di atas, dapat dilihat korelasi antara variabel satu dengan variabel lainnya.

ggplot(data = seluler, mapping=aes(x=as.numeric(ram), y=price_range)) +
    geom_smooth(se=FALSE, color='orange', method='gam', formula = y ~ s(x, bs = "cs")) + 
    theme(plot.title = element_text(face="bold")) + 
    labs(x = 'Ram', y='Price Range')

Berdasarkan grafik di atas terlihat dengan jelas bahwa rentang harga dengan ram sangat berpengaruh, dimana semakin besar ram yang dimiliki membuat harga juga semakin meningkat.

ggplot(data = seluler, mapping=aes(x=int_memory, y=price_range)) +
    geom_smooth(se=FALSE, color='yellow', method='gam', formula = y ~ s(x, bs = "cs")) + 
    theme(plot.title = element_text(face="bold")) + 
    labs(x = 'Internal Memory', y='Price Range')

Kami juga mencoba melihat pengaruh dari Internal memory terhadap rentang harganya, ternyata terdapat hubungan linier dan hal ini sangat jelas bahwa internal memory juga berpengaruh terhadap harga unit seluler yang tersedia untuk dijual nanti.

selulerr <- seluler %>%
  mutate(
    blue = as.factor(blue),
    dual_sim = as.factor(dual_sim),
    four_g = as.factor(four_g),
    three_g = as.factor(three_g),
    touch_screen = as.factor(touch_screen),
    wifi = as.factor(wifi),
    price_range = as.factor(price_range),
    price_range = sapply(price_range, switch, "murah", "normal", "mahal", "sangat mahal"),
    price_range = ordered(price_range, levels = c("murah", "normal", "mahal", "sangat mahal"))
  )

selulerr %>% group_by(price_range) %>% summarise(freq=n()) %>% 
ggplot( aes(x="", y=freq, fill=price_range)) + 
  geom_bar(stat="identity", width=1)+
  coord_polar("y", start=0) + 
  geom_text(aes(label = paste0(round((freq/sum(freq))*100), "%")),
            position = position_stack(vjust = 0.5),color="white")+
  scale_fill_manual(values=c(rainbow(4))) +
  labs(x = NULL, y = NULL, fill = "Keterangan Harga")+
  theme_classic() + 
  theme(axis.line = element_blank(),
        axis.text = element_blank(),
        axis.ticks = element_blank(),
        plot.title = element_text(hjust = 0.5),
        axis.title=element_text(size=9,face="bold"), 
        legend.position = "right"
        )

Berdasarkan grafik chart di atas, dapat kami simpulkan bahwa pembagian kelas harga jual unit seluler terbagi secara merata proporsinya.

Split Data

Pada dataset kali ini terdapat 2000 data, kami akan membagi menjadi dua data dengan proporsi 0.8 yang artinya 80% untuk data train yang nantinya akan digunakan untuk pemodelan dan 20% untuk data test yang akan digunakan untuk menguji seberapa baik model yang telah dirancang.

set.seed(123)
split <- initial_split(selulerr, prop = 0.8, strata = "price_range")
seluler_train <- training(split)
seluler_test <- testing(split)

df_split <- rbind(
data.frame(table(seluler_train$price_range),"type"="train"),
data.frame(table(seluler_test$price_range),"type"="test")) %>% 
  mutate(
    Var1 = as.factor(Var1),
    type = as.factor(type)
  ) 

ggplot(df_split, aes(x=Var1,y=Freq, fill=type))+
  geom_col(position = "dodge")+
  geom_text(aes(label=Freq, y=Freq+20), size=3, position = position_dodge(width = 1))+
  labs(x = "Kelas Harga", 
       y = "Frekuensi", 
       fill = "Data", 
       title = "Pembagian Data Train dan Test")+
  theme_minimal()+
  theme(
      axis.title=element_text(size=10,face="bold"),
      axis.text.x=element_text(size=12),
      axis.text.y=element_text(size=12)
      )+
   scale_fill_manual(values=c("lightblue", "orange"))

Perancangan Model

Karena Pak Bakti ingin memprediksi kelas harga, maka yang menjadi target variabelnya adalah price_range. Pada kesempatan kali ini, kami akan membuat pemodelan untuk klasifikasi seperti Regression, Decision Tree, Random Forest.

Pengaruh Setiap Variabel

Dengan menggunakan taraf signifikansi 0.05 atau dalam selang kepercayaan 95%, kami akan mencoba mencari tahu mana variabel yang paling berpengaruh secara signifikan terhadap price_range

lr <- lm(price_range ~ ., data = seluler)

summary(lr)$coef

##                    Estimate   Std. Error      t value      Pr(>|t|)
## (Intercept)   -1.5750125445 6.163763e-02 -25.55277648 1.059281e-124
## battery_power  0.0005095531 1.639990e-05  31.07050596 5.748920e-173
## blue          -0.0020320097 1.441991e-02  -0.14091695  8.879499e-01
## clock_speed   -0.0120614370 8.814187e-03  -1.36841179  1.713385e-01
## dual_sim      -0.0237093464 1.442331e-02  -1.64382156  1.003719e-01
## fc             0.0009348379 2.165571e-03   0.43168194  6.660196e-01
## four_g        -0.0014768297 1.774302e-02  -0.08323440  9.336736e-01
## int_memory     0.0008646792 3.970093e-04   2.17798186  2.952510e-02
## m_dep         -0.0099629863 2.494215e-02  -0.39944383  6.896093e-01
## mobile_wt     -0.0008801134 2.030283e-04  -4.33492867  1.531247e-05
## n_cores        0.0018210737 3.147536e-03   0.57857124  5.629444e-01
## pc             0.0001286935 1.551143e-03   0.08296687  9.338863e-01
## px_height      0.0002765358 1.890653e-05  14.62647212  4.419902e-46
## px_width       0.0002795824 1.936593e-05  14.43682265  5.394599e-45
## ram            0.0009471883 6.638186e-06 142.68781057  0.000000e+00
## sc_h           0.0011402885 1.981988e-03   0.57532575  5.651364e-01
## sc_w          -0.0003283985 1.915119e-03  -0.17147683  8.638664e-01
## talk_time      0.0003638878 1.319264e-03   0.27582637  7.827102e-01
## three_g        0.0270489126 2.078999e-02   1.30105468  1.933912e-01
## touch_screen  -0.0057103786 1.438330e-02  -0.39701455  6.913995e-01
## wifi          -0.0214461491 1.440460e-02  -1.48883998  1.366888e-01

Untuk mencari tahu variabel mana yang paling berpengaruh, maka kami akan mencari nilai p yang kurang dari nilai signifikansi. Terlihat bahwa battery_power, ram, px_height dan variabel yang lainnya memiliki pengaruh yang signifikan terhadap price_range. Dengan adanya susunan ini, memudahkan kami untuk mencari peubah bebas untuk diuji pada masing-masing model nantinya.

Regression Model

Pada model regresi ini dapat disebut juga sebagai multinomial logistic regression karena memiliki lebih dari 2 variabel peubah bebasnya. Pada pemodelan ini nantinya akan menggunakan pendekatan step-wise dan menggunakan modelnya berdasarkan nilai AIC terkecil.

library(emdi)

regresi <- nnet::multinom(price_range~.,data=seluler_train)

## # weights:  88 (63 variable)
## initial  value 2218.070978 
## iter  10 value 1731.927973
## iter  20 value 1519.560603
## iter  30 value 1469.604101
## iter  40 value 1328.767157
## iter  50 value 876.490444
## iter  60 value 528.140028
## iter  70 value 66.639615
## iter  80 value 43.659112
## iter  90 value 37.895906
## iter 100 value 34.593297
## final  value 34.593297 
## stopped after 100 iterations

regresi_model <- step(
  object = regresi,
  direction = c("both", "backward", "forward"),
  trace = FALSE
)

## trying - battery_power 
## trying - blue 
## trying - clock_speed 
## trying - dual_sim 
## trying - fc 
## trying - four_g 
## trying - int_memory 
## trying - m_dep 
## trying - mobile_wt 
## trying - n_cores 
## trying - pc 
## trying - px_height 
## trying - px_width 
## trying - ram 
## trying - sc_h 
## trying - sc_w 
## trying - talk_time 
## trying - three_g 
## trying - touch_screen 
## trying - wifi 
## # weights:  84 (60 variable)
## initial  value 2218.070978 
## iter  10 value 1731.932172
## iter  20 value 1521.181439
## iter  30 value 1475.998675
## iter  40 value 1311.932437
## iter  50 value 870.472120
## iter  60 value 358.183027
## iter  70 value 55.156403
## iter  80 value 41.721689
## iter  90 value 37.493490
## iter 100 value 35.006877
## final  value 35.006877 
## stopped after 100 iterations
## trying - battery_power 
## trying - blue 
## trying - dual_sim 
## trying - fc 
## trying - four_g 
## trying - int_memory 
## trying - m_dep 
## trying - mobile_wt 
## trying - n_cores 
## trying - pc 
## trying - px_height 
## trying - px_width 
## trying - ram 
## trying - sc_h 
## trying - sc_w 
## trying - talk_time 
## trying - three_g 
## trying - touch_screen 
## trying - wifi 
## trying + clock_speed 
## # weights:  80 (57 variable)
## initial  value 2218.070978 
## iter  10 value 1731.932590
## iter  20 value 1521.306368
## iter  30 value 1477.275342
## iter  40 value 1309.330935
## iter  50 value 881.955602
## iter  60 value 240.309683
## iter  70 value 49.873647
## iter  80 value 40.166506
## iter  90 value 37.397356
## iter 100 value 35.094575
## final  value 35.094575 
## stopped after 100 iterations
## trying - battery_power 
## trying - blue 
## trying - fc 
## trying - four_g 
## trying - int_memory 
## trying - m_dep 
## trying - mobile_wt 
## trying - n_cores 
## trying - pc 
## trying - px_height 
## trying - px_width 
## trying - ram 
## trying - sc_h 
## trying - sc_w 
## trying - talk_time 
## trying - three_g 
## trying - touch_screen 
## trying - wifi 
## trying + clock_speed 
## trying + dual_sim 
## # weights:  76 (54 variable)
## initial  value 2218.070978 
## iter  10 value 1731.983811
## iter  20 value 1526.146844
## iter  30 value 1487.450702
## iter  40 value 1085.317585
## iter  50 value 694.351673
## iter  60 value 86.887438
## iter  70 value 45.000997
## iter  80 value 40.016500
## iter  90 value 37.848667
## iter 100 value 36.809510
## final  value 36.809510 
## stopped after 100 iterations
## trying - battery_power 
## trying - blue 
## trying - fc 
## trying - four_g 
## trying - int_memory 
## trying - m_dep 
## trying - mobile_wt 
## trying - n_cores 
## trying - pc 
## trying - px_height 
## trying - px_width 
## trying - ram 
## trying - sc_h 
## trying - talk_time 
## trying - three_g 
## trying - touch_screen 
## trying - wifi 
## trying + clock_speed 
## trying + dual_sim 
## trying + sc_w 
## # weights:  72 (51 variable)
## initial  value 2218.070978 
## iter  10 value 1731.984260
## iter  20 value 1526.290941
## iter  30 value 1489.451516
## iter  40 value 1075.311882
## iter  50 value 623.656104
## iter  60 value 69.561305
## iter  70 value 45.824042
## iter  80 value 41.469716
## iter  90 value 39.393462
## iter 100 value 38.630252
## final  value 38.630252 
## stopped after 100 iterations
## trying - battery_power 
## trying - blue 
## trying - fc 
## trying - four_g 
## trying - int_memory 
## trying - mobile_wt 
## trying - n_cores 
## trying - pc 
## trying - px_height 
## trying - px_width 
## trying - ram 
## trying - sc_h 
## trying - talk_time 
## trying - three_g 
## trying - touch_screen 
## trying - wifi 
## trying + clock_speed 
## trying + dual_sim 
## trying + m_dep 
## trying + sc_w 
## # weights:  68 (48 variable)
## initial  value 2218.070978 
## iter  10 value 1731.984831
## iter  20 value 1526.591848
## iter  30 value 1492.356617
## iter  40 value 1134.515939
## iter  50 value 457.463097
## iter  60 value 57.310028
## iter  70 value 46.341503
## iter  80 value 41.655307
## iter  90 value 40.303501
## iter 100 value 40.077162
## final  value 40.077162 
## stopped after 100 iterations
## trying - battery_power 
## trying - blue 
## trying - fc 
## trying - four_g 
## trying - int_memory 
## trying - mobile_wt 
## trying - n_cores 
## trying - pc 
## trying - px_height 
## trying - px_width 
## trying - ram 
## trying - sc_h 
## trying - talk_time 
## trying - three_g 
## trying - wifi 
## trying + clock_speed 
## trying + dual_sim 
## trying + m_dep 
## trying + sc_w 
## trying + touch_screen 
## # weights:  64 (45 variable)
## initial  value 2218.070978 
## iter  10 value 1731.985050
## iter  20 value 1526.697114
## iter  30 value 1494.045873
## iter  40 value 1106.041559
## iter  50 value 300.576865
## iter  60 value 54.419987
## iter  70 value 46.876431
## iter  80 value 43.642069
## iter  90 value 42.264049
## iter 100 value 42.198425
## final  value 42.198425 
## stopped after 100 iterations
## trying - battery_power 
## trying - blue 
## trying - fc 
## trying - int_memory 
## trying - mobile_wt 
## trying - n_cores 
## trying - pc 
## trying - px_height 
## trying - px_width 
## trying - ram 
## trying - sc_h 
## trying - talk_time 
## trying - three_g 
## trying - wifi 
## trying + clock_speed 
## trying + dual_sim 
## trying + four_g 
## trying + m_dep 
## trying + sc_w 
## trying + touch_screen 
## # weights:  60 (42 variable)
## initial  value 2218.070978 
## iter  10 value 1731.986037
## iter  20 value 1527.016848
## iter  30 value 1496.606824
## iter  40 value 947.091699
## iter  50 value 129.047634
## iter  60 value 52.897033
## iter  70 value 46.119742
## iter  80 value 43.583435
## iter  90 value 43.285836
## iter 100 value 43.250820
## final  value 43.250820 
## stopped after 100 iterations
## trying - battery_power 
## trying - blue 
## trying - fc 
## trying - int_memory 
## trying - mobile_wt 
## trying - n_cores 
## trying - pc 
## trying - px_height 
## trying - px_width 
## trying - ram 
## trying - sc_h 
## trying - talk_time 
## trying - wifi 
## trying + clock_speed 
## trying + dual_sim 
## trying + four_g 
## trying + m_dep 
## trying + sc_w 
## trying + three_g 
## trying + touch_screen 
## # weights:  56 (39 variable)
## initial  value 2218.070978 
## iter  10 value 1732.024610
## iter  20 value 1518.082542
## iter  30 value 1461.149975
## iter  40 value 744.145425
## iter  50 value 72.966914
## iter  60 value 50.005478
## iter  70 value 47.138429
## iter  80 value 46.252620
## iter  90 value 46.138430
## iter 100 value 46.059783
## final  value 46.059783 
## stopped after 100 iterations
## trying - battery_power 
## trying - blue 
## trying - int_memory 
## trying - mobile_wt 
## trying - n_cores 
## trying - pc 
## trying - px_height 
## trying - px_width 
## trying - ram 
## trying - sc_h 
## trying - talk_time 
## trying - wifi 
## trying + clock_speed 
## trying + dual_sim 
## trying + fc 
## trying + four_g 
## trying + m_dep 
## trying + sc_w 
## trying + three_g 
## trying + touch_screen 
## # weights:  52 (36 variable)
## initial  value 2218.070978 
## iter  10 value 1732.280237
## iter  20 value 1531.208102
## iter  30 value 1328.817696
## iter  40 value 392.920289
## iter  50 value 62.414800
## iter  60 value 51.170828
## iter  70 value 48.804155
## iter  80 value 48.295331
## iter  90 value 48.262146
## iter 100 value 48.111747
## final  value 48.111747 
## stopped after 100 iterations
## trying - battery_power 
## trying - blue 
## trying - int_memory 
## trying - mobile_wt 
## trying - n_cores 
## trying - pc 
## trying - px_height 
## trying - px_width 
## trying - ram 
## trying - sc_h 
## trying - wifi 
## trying + clock_speed 
## trying + dual_sim 
## trying + fc 
## trying + four_g 
## trying + m_dep 
## trying + sc_w 
## trying + talk_time 
## trying + three_g 
## trying + touch_screen 
## # weights:  48 (33 variable)
## initial  value 2218.070978 
## iter  10 value 1732.280735
## iter  20 value 1531.347984
## iter  30 value 1359.715071
## iter  40 value 208.543325
## iter  50 value 57.021322
## iter  60 value 52.119589
## iter  70 value 51.108727
## iter  80 value 50.992007
## iter  90 value 50.943394
## iter 100 value 50.871930
## final  value 50.871930 
## stopped after 100 iterations
## trying - battery_power 
## trying - int_memory 
## trying - mobile_wt 
## trying - n_cores 
## trying - pc 
## trying - px_height 
## trying - px_width 
## trying - ram 
## trying - sc_h 
## trying - wifi 
## trying + blue 
## trying + clock_speed 
## trying + dual_sim 
## trying + fc 
## trying + four_g 
## trying + m_dep 
## trying + sc_w 
## trying + talk_time 
## trying + three_g 
## trying + touch_screen 
## # weights:  44 (30 variable)
## initial  value 2218.070978 
## iter  10 value 1732.529416
## iter  20 value 1550.879480
## iter  30 value 1005.384962
## iter  40 value 108.245471
## iter  50 value 57.720785
## iter  60 value 55.605549
## iter  70 value 55.332364
## iter  80 value 55.299202
## iter  90 value 55.211088
## iter 100 value 53.858730
## final  value 53.858730 
## stopped after 100 iterations
## trying - battery_power 
## trying - int_memory 
## trying - mobile_wt 
## trying - n_cores 
## trying - pc 
## trying - px_height 
## trying - px_width 
## trying - ram 
## trying - wifi 
## trying + blue 
## trying + clock_speed 
## trying + dual_sim 
## trying + fc 
## trying + four_g 
## trying + m_dep 
## trying + sc_h 
## trying + sc_w 
## trying + talk_time 
## trying + three_g 
## trying + touch_screen

summary(regresi_model)

## Call:
## nnet::multinom(formula = price_range ~ battery_power + int_memory + 
##     mobile_wt + n_cores + pc + px_height + px_width + ram + wifi, 
##     data = seluler_train)
## 
## Coefficients:
##              (Intercept) battery_power int_memory  mobile_wt   n_cores
## normal         -276.8380    0.06889856 0.06584338 -0.1633585 0.5389644
## mahal          -456.6814    0.10134218 0.11092568 -0.2216773 0.8688410
## sangat mahal   -786.7312    0.14685234 0.20144465 -0.3532515 1.1669040
##                       pc  px_height   px_width       ram     wifi1
## normal       -0.05355233 0.04039949 0.04104187 0.1144801 -2.242150
## mahal         0.10179862 0.05907302 0.05960097 0.1659432 -3.603884
## sangat mahal  0.23964881 0.08957473 0.08788835 0.2423496 -6.078527
## 
## Std. Errors:
##              (Intercept) battery_power int_memory  mobile_wt   n_cores
## normal       0.001559528   0.001410271 0.03010115 0.02118396 0.2546218
## mahal        0.002451740   0.001571300 0.03701217 0.02330226 0.2988065
## sangat mahal 0.001072950   0.001807573 0.04559247 0.02734012 0.3665154
##                     pc   px_height    px_width         ram     wifi1
## normal       0.0992810 0.001824238 0.001556091 0.001913550 0.2882374
## mahal        0.1151019 0.002217151 0.001851481 0.002024306 0.3461037
## sangat mahal 0.1408390 0.002464983 0.002187084 0.002160262 0.1013508
## 
## Residual Deviance: 107.7175 
## AIC: 167.7175

Hasil dari summary di atas, dapat kami simpulkan bahwa nilai AIC terkecil ternyata 167.7175 dengan menggunakan 9 variabel. Selanjutnya, kami akan mencoba melakukan prediksi untuk kelasnya.

mlnom_prediction_train <- predict(regresi_model, seluler_train)
mlnom_probability_train <- predict(regresi_model, seluler_train, type = "prob")

mlnom_result_train <- cbind(seluler_train, price_range_prediction=mlnom_prediction_train , 
                            round(mlnom_probability_train,3))

mlnom_result_train <- mlnom_result_train[,c(21,22,23,24,25,26)] %>% 
  setnames("price_range", "price_range_actual") %>%
  arrange(price_range_actual) %>% 
  mutate(
    no=seq(1:nrow(seluler_train))
  ) %>% 
  select(7,1,2,3,4,5,6)


mlnom_prediction <- predict(regresi_model, seluler_test)
mlnom_probability <- predict(regresi_model, seluler_test, type="prob")


mlnom_result <- cbind(seluler_test, price_range_prediction=mlnom_prediction,
                    round(mlnom_probability,3))

mlnom_result <- mlnom_result[,c(21,22,23,24,25,26)] %>% 
  setnames("price_range", "price_range_actual") %>%
  arrange(price_range_actual) %>% 
  mutate(
    no=seq(1:nrow(seluler_test))
  ) %>% 
  select(7,1,2,3,4,5,6)

mlnom_result

tabel di atas adalah hasil klasifikasi kelas harga menggunakan metode Regresi ini. Selanjutnya, kami akan mencari tahu bagaimana tingkat keakurasian dari model yang telah kami buat.

cfm_mlnom_train <- confusionMatrix(
  data = mlnom_result_train$price_range_prediction, 
  reference =mlnom_result_train$price_range_actual
)

round(cfm_mlnom_train$overall["Accuracy"],2)*100

## Accuracy 
##       99

Berdasarkan model regresi yang telah kami buat, ternyata kami mendapatkan hasil yang sangat memuaskan, yaitu sebesar 99% dengan menggunakan seluruh variabel peubah bebas pada data train. Lalu, kami ingin mencoba jika menggunakan hanya satu peubah bebasnya bagaimana

model_reg_one <- lm(price_range ~ int_memory, data = seluler)

summary(model_reg_one)$coef

##               Estimate  Std. Error   t value      Pr(>|t|)
## (Intercept) 1.41224034 0.050723048 27.842182 1.934244e-144
## int_memory  0.00273851 0.001377408  1.988162  4.693006e-02

Berdasarkan susunan summary di atas, kami menyimpulkan bahwa internal memory berpengaruh signifikan terhadap penentuan harga jual, karena nilai p valuenya dibawah 0.05 yang mana adalah taraf signifikan kami.

newdata <- data.frame(int_memory = c(0, 10))
model_reg_one %>% predict(newdata)

##        1        2 
## 1.412240 1.439625

Ternyata berdasarkan model regresi yang menggunakan 1 peubah bebas, yaitu int_memory kami dapat memprediksi harga jualnya yang mana dengan maksimal ukuran internal memory yang sebesar 10 satuan internal memory akan menambah sekitar 1.41 sampai 1.43 USD.

Decision Tree Model

Menggunakan metode Decision Tree untuk merancang suatu model nampaknya umum digunakan oleh seorang data sains karena lebih bebas dan dapat digunakan untuk variabel yang bersifat numerik dan kategorikal.

model4 <- rpart(price_range ~ .,
              data=seluler_train,
              method="class")


Predict_model4_train <- predict(model4, seluler_train, type = "class")
conMat_df <- confusionMatrix(as.factor(Predict_model4_train), as.factor(seluler_train$price_range))
conMat_df$table

##               Reference
## Prediction     murah normal mahal sangat mahal
##   murah          370     49     0            0
##   normal          30    319    49            0
##   mahal            0     32   291           36
##   sangat mahal     0      0    60          364

predict <- conMat_df$overall["Accuracy"]*100

predict

## Accuracy 
##       84

Berdasarkan model Decision Tree yang dibuat ternyata kami mendapatkan akurasi sebesar 84% yang mana cukup jauh dengan model pertama kami, yaitu regresi yang mencapai angka 99%. Selanjutnya, kami akan mencoba mengklasifikasikan kelas harga jualnya, seperti berikut ini.

dtree_prediction <- predict(model4, seluler_test)
dtree_probability <- predict(model4, seluler_test, type="prob")
dtree_probability <- data.frame(matrix(unlist(dtree_probability), 
                                       nrow=nrow(seluler_test), byrow=T),stringsAsFactors=FALSE)
colnames(dtree_probability) <- c("murah","normal","mahal","sangat mahal")


dtree_result <- cbind(seluler_test, price_range_prediction=dtree_prediction,
                    round(dtree_probability,3))

dtree_result <- dtree_result[,c(21,22,23,24,25,26)] %>% 
  setnames("price_range", "price_range_actual") %>%
  arrange(price_range_actual) %>% 
  mutate(
    no=seq(1:nrow(seluler_test))
  ) %>% 
  select(7,1,2,3,4,5,6)

dtree_result

Selanjutnya, kami ingin membandingkan bagaimana jika hanya menggunakan 2 peubah bebas dan kami memilih ram dan internal memorinya

model_simple <- rpart(price_range ~ ram + int_memory, data = seluler_train)

predict_model_simple <- predict(model_simple, seluler_train, type = "class")
conMat <- confusionMatrix(as.factor(predict_model_simple), as.factor(seluler_train$price_range))
conMat$table

##               Reference
## Prediction     murah normal mahal sangat mahal
##   murah          320     43     0            0
##   normal          80    335   128            1
##   mahal            0     22   217           67
##   sangat mahal     0      0    55          332

conMat$overall["Accuracy"]

## Accuracy 
##   0.7525

Ketika kami menggunakan dua peubah bebas pada model decision tree, ternyata akurasi dari model yang kami rancang berkurang menjadi 75% dan hal ini menjadi alasan kami lebih memilih model decisipon tree dengan seluruh peubah bebasnya.

Random Forest Model

set.seed(666)
rf_model <- randomForest(price_range ~ ., 
                                data = seluler_train, 
                                importance=TRUE, 
                                ntree = 1000)
rf_model

## 
## Call:
##  randomForest(formula = price_range ~ ., data = seluler_train,      importance = TRUE, ntree = 1000) 
##                Type of random forest: classification
##                      Number of trees: 1000
## No. of variables tried at each split: 4
## 
##         OOB estimate of  error rate: 12%
## Confusion matrix:
##              murah normal mahal sangat mahal class.error
## murah          378     22     0            0      0.0550
## normal          35    330    35            0      0.1750
## mahal            0     41   335           24      0.1625
## sangat mahal     0      0    35          365      0.0875

Pada model di atas, kami menggunakan 1000 tree dan mendapati nilai estimasi errornya sebesar 12%.

rf_origin_result_train <- cbind(seluler_train, price_range_prediction=rf_model$predicted,
                          round(rf_model$votes,3))

rf_origin_result_train <- rf_origin_result_train[,c(21,22,23,24,25,26)] %>% 
  setnames("price_range", "price_range_actual") %>%
  arrange(price_range_actual) %>% 
  mutate(
    no=seq(1:nrow(seluler_train))
  ) %>% 
  select(7,1,2,3,4,5,6)

rf_prediction <- predict(rf_model, seluler_test)
rf_probability <- predict(rf_model, seluler_test, type="prob")


rf_origin_result <- cbind(seluler_test, price_range_prediction=rf_prediction,
                    round(rf_probability,3))

rf_origin_result <- rf_origin_result[,c(21,22,23,24,25,26)] %>% 
  setnames("price_range", "price_range_actual") %>%
  arrange(price_range_actual) %>% 
  mutate(
    no=seq(1:nrow(seluler_test))
  ) %>% 
  select(7,1,2,3,4,5,6)

rf_origin_result

Di atas merupakan hasil prediksi harga jualnya menggunakan Random Forest yang menggunakan 1000 tree. Untuk mengetahui tingkat akurasi dari model Random Forest ini, maka kami melakukannya.

acc_rf <- confusionMatrix(
  data =rf_origin_result_train$price_range_prediction, 
  reference =rf_origin_result_train$price_range_actual
)

acc_rf$overall["Accuracy"]*100

## Accuracy 
##       88

Kami mendapat akurasi pada model random forest adalah sebesar 88% dan bagaimana jika kami hanya menggunakan satu atau dua peubah bebas saja pada model Random Forest ini.

model_simple_rf <- randomForest(price_range ~ ram , data = seluler_train, importance = TRUE)


model_simple_rf

## 
## Call:
##  randomForest(formula = price_range ~ ram, data = seluler_train,      importance = TRUE) 
##                Type of random forest: classification
##                      Number of trees: 500
## No. of variables tried at each split: 1
## 
##         OOB estimate of  error rate: 32.31%
## Confusion matrix:
##              murah normal mahal sangat mahal class.error
## murah          319     81     0            0      0.2025
## normal          84    227    84            5      0.4325
## mahal            1     97   219           83      0.4525
## sangat mahal     0      6    76          318      0.2050

Ternyata dengan menggunakan dua peubah bebas ini kita mendapat nilai estimasi error yang bertambah menjadi 32.19% , lalu kami mencoba untuk membuat akurasinya.

rf_predict <- predict(model_simple_rf, seluler_train)

conMatt <- confusionMatrix(rf_predict, seluler_train$price_range)

conMatt$table

##               Reference
## Prediction     murah normal mahal sangat mahal
##   murah          386     21     0            0
##   normal          14    371    26            2
##   mahal            0      7   362           11
##   sangat mahal     0      1    12          387

round(conMatt$overall["Accuracy"], 2)*100

## Accuracy 
##       94

Ternyata kami mendapat tingkat akurasi yang lebih tinggi dari model yang menggunakan semua peubah bebas, yaitu 94% dan hal yang harus diperhatikan adalah pada model ini ada estimasi error yang sangat besar juga dibandingkan dengan menggunakan seluruh peubah bebas.

Model Terbaik

Setelah kami melakukan analisa menggunakan 3 model dan menggunakan satu atau dua peubah bebas dengan seluruh peubah bebas kami telah membuat keputusan bahwa model dengan metode regresi adalah yang terbaik karena memiliki tingkat akurasi 99% dengan seluruh peubah bebasnya. Sehingga, kami akan memilih model regresi yang telah kami rancang untuk mengetahui klasifikasi harga dari setiap unit yang diproduksi.

seluler_klas <- read.csv("C:/Users/Naftali Brigitta/Documents/Kampus/PDS/UAS/test.csv")

seluler_klas

Pada dataset tersebut terdiri dari 1000 data dan 21 variabel yang artinya terdapat 1000 unit seluler yang akan diklasifikasi harganya. Sebelum itu, kami akan melihat struktur datanya dan struktur mana yang harus diubah.

glimpse(seluler_klas)

## Rows: 1,000
## Columns: 21
## $ id            <int> 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 1~
## $ battery_power <int> 1043, 841, 1807, 1546, 1434, 1464, 1718, 833, 1111, 1520~
## $ blue          <int> 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1,~
## $ clock_speed   <dbl> 1.8, 0.5, 2.8, 0.5, 1.4, 2.9, 2.4, 2.4, 2.9, 0.5, 2.2, 2~
## $ dual_sim      <int> 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1,~
## $ fc            <int> 14, 4, 1, 18, 11, 5, 1, 0, 9, 1, 2, 2, 0, 5, 8, 5, 14, 5~
## $ four_g        <int> 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1,~
## $ int_memory    <int> 5, 61, 27, 25, 49, 50, 47, 62, 25, 25, 55, 34, 30, 19, 5~
## $ m_dep         <dbl> 0.1, 0.8, 0.9, 0.5, 0.5, 0.8, 1.0, 0.8, 0.6, 0.5, 0.6, 0~
## $ mobile_wt     <int> 193, 191, 186, 96, 108, 198, 156, 111, 101, 171, 80, 171~
## $ n_cores       <int> 3, 5, 3, 8, 6, 8, 2, 1, 5, 3, 7, 3, 2, 5, 8, 8, 2, 4, 2,~
## $ pc            <int> 16, 12, 4, 20, 18, 9, 3, 2, 19, 20, 6, 6, 3, 15, 9, 7, 1~
## $ px_height     <int> 226, 746, 1270, 295, 749, 569, 1283, 1312, 556, 52, 503,~
## $ px_width      <int> 1412, 857, 1366, 1752, 810, 939, 1374, 1880, 876, 1009, ~
## $ ram           <int> 3476, 3895, 2396, 3893, 1773, 3506, 3873, 1495, 3485, 65~
## $ sc_h          <int> 12, 6, 17, 10, 15, 10, 14, 7, 11, 6, 13, 15, 6, 13, 17, ~
## $ sc_w          <int> 7, 0, 10, 0, 8, 7, 2, 2, 9, 0, 7, 8, 2, 0, 6, 5, 3, 2, 1~
## $ talk_time     <int> 2, 7, 10, 7, 7, 3, 10, 18, 10, 5, 20, 8, 20, 16, 3, 10, ~
## $ three_g       <int> 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,~
## $ touch_screen  <int> 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0,~
## $ wifi          <int> 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1,~

Ternyata, masih ada struktur data yang tidak sesuai dan kami akan mengubahnya.

id <- seluler_klas$id
seluler_klas1 <- seluler_klas %>%
  mutate(
    blue = as.factor(blue),
    dual_sim  = as.factor(dual_sim),
    four_g = as.factor(four_g),
    three_g = as.factor(three_g),
    touch_screen = as.factor(touch_screen),
    wifi = as.factor(wifi)
  ) %>% 
  select(-id)

glimpse(seluler_klas1)

## Rows: 1,000
## Columns: 20
## $ battery_power <int> 1043, 841, 1807, 1546, 1434, 1464, 1718, 833, 1111, 1520~
## $ blue          <fct> 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1,~
## $ clock_speed   <dbl> 1.8, 0.5, 2.8, 0.5, 1.4, 2.9, 2.4, 2.4, 2.9, 0.5, 2.2, 2~
## $ dual_sim      <fct> 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 1,~
## $ fc            <int> 14, 4, 1, 18, 11, 5, 1, 0, 9, 1, 2, 2, 0, 5, 8, 5, 14, 5~
## $ four_g        <fct> 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1,~
## $ int_memory    <int> 5, 61, 27, 25, 49, 50, 47, 62, 25, 25, 55, 34, 30, 19, 5~
## $ m_dep         <dbl> 0.1, 0.8, 0.9, 0.5, 0.5, 0.8, 1.0, 0.8, 0.6, 0.5, 0.6, 0~
## $ mobile_wt     <int> 193, 191, 186, 96, 108, 198, 156, 111, 101, 171, 80, 171~
## $ n_cores       <int> 3, 5, 3, 8, 6, 8, 2, 1, 5, 3, 7, 3, 2, 5, 8, 8, 2, 4, 2,~
## $ pc            <int> 16, 12, 4, 20, 18, 9, 3, 2, 19, 20, 6, 6, 3, 15, 9, 7, 1~
## $ px_height     <int> 226, 746, 1270, 295, 749, 569, 1283, 1312, 556, 52, 503,~
## $ px_width      <int> 1412, 857, 1366, 1752, 810, 939, 1374, 1880, 876, 1009, ~
## $ ram           <int> 3476, 3895, 2396, 3893, 1773, 3506, 3873, 1495, 3485, 65~
## $ sc_h          <int> 12, 6, 17, 10, 15, 10, 14, 7, 11, 6, 13, 15, 6, 13, 17, ~
## $ sc_w          <int> 7, 0, 10, 0, 8, 7, 2, 2, 9, 0, 7, 8, 2, 0, 6, 5, 3, 2, 1~
## $ talk_time     <int> 2, 7, 10, 7, 7, 3, 10, 18, 10, 5, 20, 8, 20, 16, 3, 10, ~
## $ three_g       <fct> 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1,~
## $ touch_screen  <fct> 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0,~
## $ wifi          <fct> 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1,~

colSums(is.na(seluler_klas))

##            id battery_power          blue   clock_speed      dual_sim 
##             0             0             0             0             0 
##            fc        four_g    int_memory         m_dep     mobile_wt 
##             0             0             0             0             0 
##       n_cores            pc     px_height      px_width           ram 
##             0             0             0             0             0 
##          sc_h          sc_w     talk_time       three_g  touch_screen 
##             0             0             0             0             0 
##          wifi 
##             0

Ternyata pada dataset ini tidak terdapat missing value.

seluler_klas1 <- seluler_klas1 %>%
  mutate(
    wifi = as.factor(wifi)
  )

reg_predict <- predict(regresi_model, seluler_klas1)
reg_prob <- predict(regresi_model, seluler_klas1, type="prob")


selulerklas <- cbind(seluler_klas,price_range_prediction=reg_predict,
                    round(reg_prob, 3),seluler_klas1)

selulerklas

Data di atas merupakan hasil dari klasifikasi harga jual unit seluler. Dengan adanya hasil ini perusahaan dapat menjual unit seluler dengan tepat karena adanya klasifikasi harga dengan metode regresi dengan akurasi model 99%.

Kesimpulan

Untuk kasus kali ini, kami dapat menyimpulkan bahwa model yang menggunakan metode regresi adalah yang paling efektif karena menghasilkan akurasi 99%, sehingga kami memilih model tersebut untuk mengklasifikasi harga jual unit seluler yang disediakan. Pada model random forest sebetulnya terdapat model yang bagus juga dengan tingkat akurasi 94%, tetapi model tersebut memiliki tingkat error yang tinggi, yaitu sekitar 32%.