의사결정트리

■ 결정트리

의사결정트리 알고리즘은 데이터 사이에 존재하는 패턴을 예측 가능한

규칙들의 조합으로 나타내는 알고리즘입니다.

 학습내용

1. 트리와 규칙이 데이터를 관심 있는 세그먼트로 '탐욕스럽게 greedily' 분할하는

방법

 

2. C5.10,  1R,  RIPPER 알고리즘을 포함하는 가장 보편적인 의사결정 트리와

분류 규칙 학습자

 

3. 위험 은행 대출과 독버섯 실별과 같은 실제 분류 작업을 수행하기 위한

알고리즘 사용 방법

*사용용도

신용평가모델	신청자 거절 기준이 명확히 문서화되고 편향되지 않음
마케팅 연구	경영진 또는 광고 대행사와 공유될 고객 만족이나 고객 이탈과 같은 고객 행동 연구
진단	실험실 측정, 증상, 질병 진행률을 기반으로 하는 질병 진단

예를 들면 질문을 던져서 대상을 좁혀나가는 스무고개 놀이와 비슷한 개념.

 

 

 

 

그 질문의 우선순위를 정할 때 필요한것이 엔트로피entropy 입니다.

 

※ 엔트로피: 불순도, 불확실성 정도를 말합니다.

 

 

 

 

 

0 : 가난한 사람

1: 부자

 

그 가운데 봉긋 솟은 그래프에는

외제차를 갖고있지만 고시원에 살고 있는, 확실하게 정의 내리기 어려운

경우의 사람을 뜻한다.

그런 경우를 엔트로피가 높다고 표시한다.

 

이렇게 분할 했을때, 잘못된 영역으로 간 공이 적을 수록

선택 컬럼이 정확도가 높다는 것을 증명한다.

(ex: 화장품을 사는 고객 -> 선택컬럼: 직업)

 

 

그 정도를 구하려면 '정보 획득량' 을 구해야 하는데

공식이

분할 전 엔트로피 - 분할 후 엔트로피

 

 

엔트로피란 무질서도를 정량화해서 표현한 값입니다.

어떤 집합의 엔트로피가 높을 수록 그 집단의 특징을 찾는 것이

어렵다는 것을 의미합니다.

따라서 의사결정트리의 잎 노드들의 엔트로피가 최소가 되는 방향으로

분류해 나가는 것이 최적의 방법으로 분류한 것이라고 할 수 있습니다.

 

분할 후 엔트로피 값이 작을 수록 좋은 값이다.

정보 획득량( 분할전 엔. - 분할후엔. )이 클 수록 컬럼을 잘 선택한 것이다.

 

 

 

 

 

■ 5장. 의사결정 트리와 규칙 기반 분류

의사결정트리란?

의학에서 질병에 대한 진행 과정을 바탕으로 올바른 처방을 위해

결정해야하는 경우나 은행에서 대출을 해줄지 말지의 여부를

기업데이터를 보고 결정해야 하는 경우등에 사용하는

지도학습 머신러닝 알고리즘

 

 

 

■  엔트로피와 정보 획득량

 

결정트리를 만들 때 가장 먼저 해야할 일이 무엇인가?

↓

중요한 컬럼(변수)를 찾는 것이다

↓

정보 획득량이 높은 변수

↓

엔트로피 함수를 사용

 

 

 

■ 엔트로피 entropy 함수

"데이터의 불확실성이 얼마나 되는가?"

엔트로피 지수가 높다는 것은 불확실성이 높다는 것

 

정보획득량 =  분할전 엔트로피 - 분할후 엔트로피

 

 "정보획득량"이 높을수록 좋은 값

 

문제201.

구매여부 데이터의 변수들 중에 정보획득량이 가장 높은게

무엇인지 알아내시오(buy2.csv)

 

buy<-read.csv("buy2.csv", header=T)

install.packages("FSelector")

library(FSelector)

 

weights<-information.gain(buy_yn~., buy)

# buy_yn 빼고 다 가져와라.

weights

 

  attr_importance

X                  0.00000000
cust_name          0.50040242
card_yn            0.50040242
review_yn          0.22314355
before_buy_yn      0.05053431

 

※ 설명:

buy.yn 이라는 컬럼에 영향을 미치는 정보획득량을 보여준다.

 

 

 

문제202.

백화점 화장품 고객 데이터(skin.csv)를 R로 로드하고

skin 데이터셋 변수들의 정보 획득량을 구하시오

 

skin<-read.csv("skin.csv", header=T)

head(skin)

 cust_no gender age job marry car cupon_react
1       1   male  30  NO   YES  NO          NO
2       2 female  20 YES   YES YES          NO
3       3 female  20 YES   YES  NO          NO
4       4 female  40  NO    NO  NO          NO
5       5 female  30  NO   YES  NO          NO
6       6 female  30  NO    NO YES          NO

 

cupon_react 는 쿠폰 발행여부

 

weights<-information.gain(cupon_react~., skin)
> print(weights)
        attr_importance
cust_no     0.000000000  # <- 필요없는거. skin[, -1] 로 빼버리고 봐도 됨
gender      0.080610238
age         0.000000000
job         0.013737789
marry       0.224337222
car         0.006023806

 

 

 

문제203.

skin 데이터를 의사 결정 트리로 시각화 하시오

 

install.packages('rpart')

library(rpart)

 

tree1 <- rpart(cupon_react~. , data=skin[, -1],

               control=rpart.control(minsplit=2))

plot(tree1, compress=T, uniform=T, margin=0.1)

# compress = 트리를 조밀하게

# margin =  여백

 

text(tree1, use.n=T, col='blue')

 

 

 

 

 

문제204.

지방간 환자들 데이터의 정보획득량을 구해서

지방간을 일으키는데 가장 영향력이 큰 변수가

무엇인지 알아내시오

 

fatliver<-read.csv("fatliver2.csv", header=T)

library(FSelector)

head(fatliver)

weights<-information.gain(FATLIVER~. , fatliver)

 

attr_importance
AGE         0.022358781
GENDER      0.019859086
DRINK       0.008449112
SMOKING     0.006801213

 

가장 큰 정보획득량은 AGE 다.

 

library(rpart)

 

tree1 <- rpart(FATLIVER~. , data=fatliver,

               control=rpart.control(minsplit=2))

plot(tree1, compress=T, uniform=T, margin=0.1)

text(tree1, use.n=T, col='blue')

 

 

 

 

 

 

문제205.

심장질환 데이터를 내려받고 심장질환에 있어서 가장 영향력이 큰

변수가 무엇인지 정보 획득량을 구해서 알아내시오

 

http://cafe.daum.net/oracleoracle/SRv4/131

의학용어 상세설명 들어가있음

 

heart<-read.csv("Heart.csv", header=T)

library(FSelector)

head(heart)

weights<-information.gain(Thal~. , heart) #지중해성 심장질환

print(weights)

 

 attr_importance
X             0.000000000
Age           0.000000000
Sex           0.082469461
ChestPain     0.068591630
RestBP        0.000000000
Chol          0.000000000
Fbs           0.000000000
RestECG       0.000000000
MaxHR         0.076863872
ExAng         0.054980178
Oldpeak       0.056356642
Slope         0.060052397
Ca            0.001030304
AHD           0.145137695

※ 가장큰 정보획득량을 갖는 컬럼명은 AHD 다.

 

 

 

문제206.(오늘의 마지막 문제)

기업이 부도가 나는데 가장 크게 영향을 미치는 요소가 무엇인지

부도예측 데이터의 정보획득량을 구해서 알아내시오

 

bankrupt<-read.csv("부도예측데이터3.csv", header=F)

#컬럼명 V로 쓰려고 header=F 시킴!

# 컬럼명이 없으면 V로 매겨짐

library(FSelector)

head(bankrupt)

dim(bankrupt)

colnames(bankrupt)

 

weights<-information.gain(V1~. , bankrupt)

print(weights)

V6        0.6891261   <- 제일 큰 값

 

 

bankrupt <- read.csv("부도예측데이터3.csv", header = F)

weights <- information.gain(V1~., bankrupt)

which(weights$attr_importance==max(weights))

[1] 5

 

 

 

 

■ 의사결정트리 개념 정리

머신러닝의 종류 3가지

1. 지도학습 -> 라벨이 있다

-knn : 데이터간의 거리를 이용해서 분류

-naive bayes : 확률을 이용해서 분류

-decision tree : 정보 획득량으로 분류

    (분할전 엔트로피 - 분할후 엔트로피)

정보획득량으로 가장 먼저 질문해야 할

변수들을 알아내고 분류를 하는 것이다.

 

2. 비지도 학습 -> 라벨이 없다

3. 강화 학습 -> 환경을 스스로 agent 가 학습해 나가는 방법

 

 

■ C5.0 패키지를 이용해서 분류 모델 생성

p.196

C5.0 , C4.5, J48(RWeka에 포함) 은 차이가 아주 작기 때문에

세 알고리즘은 동의어로 간주돼야 한다.

 

C5.0 알고리즘은 대부분의 문제 유형을 바로 잘 처리하기 때문에

의사결정 트리를 생성하기 위한 산업표준이 됐다.

장점	단점
대부분의 문제에 잘 실행되는 범용 분류기다	의사결정 트리 모델이 레벨 수가 많은 특징의 분할로 편향 될 수 있다
수치특징, 명목특징, 누락데이터를 다룰 수 있는 고도로 자동화된 학습 과정이다	모델이 과적합 또는 과소적합되기 쉽다
중요하지 않은 특징은 제외한다	축-평행 분할에 의존하기 때문에 어떤 관계는 모델링이 어려울 수 있다
작은 데이터셋과 큰 데이터셋에 모두 사용될 수 있다	훈련 데이터에서 작은 변화가 결정 로직에 큰 변화를 초래할 수 있다
(상대적으로 작은 트리에 대해) 수학적 배경없이 해석될 수 있는 모델을 만든다	큰 트리는 해석이 어렵고 트리가 만든 결정은 직관적이지 않아 보일 수 있다

"백화점 화장품 고객중에 구매가 예상이 되는 고객이 누구인가?"

"은행 대출 채무를 불이행 할 것 같은 고객이 누구인가?"

 

 

■ 백화점 화장품 고객 중에 구매가 예상이 되는 고객이 누구인가?

1. 의사결정 패키지인 C50 패키지를 설치한다

install.packages("C50")

library(C50)

 

2. 백화점 화장품 고객 데이터를 로드하고 shuffle 한다

skin <- read.csv("skin.csv", header=T)

nrow(skin) # 30

skin_real_test_cust<-skin[30,]   <-테스트

skin2<-skin[1:29,]                        <-트레인

nrow(skin2)

skin2<-skin2[,-1] #고객번호를 제외시킨

skin2

set.seed(11)

skin2_shuffle<-skin2[sample(nrow(skin2)),]

skin2_shuffle

 

 

3. 화장품 고객 데이터를 7대3으로 train과 test로 나눈다.

train_num <- round(0.7*nrow(skin2_shuffle), 0 )

train_num

skin2_train<-skin2_shuffle[1:train_num,]

skin2_test<-skin2_shuffle[(train_num+1):nrow(skin2_shuffle),]

nrow(skin2_train)

nrow(skin2_test)

 

 

4. C50 패키지를 이용해서 분류 모델을 생성한다

skin_model<-C5.0(skin2_train[, -6], skin2_train$cupon_react)

                                          ↑                                   ↑

               라벨을 뺀 train 전체 data         train 데이터의 라벨

cupon react가 라벨!

skin_model

 

 

5. 위에서 만든 skin_model 을 이용해서 테스터 데이터의 라벨을 예측하시오

skin2_result<-predict(skin_model, skin2_test[,-6])

                                                                       ↑

라벨을 뺀 테스트 데이터 전체

 

6. 이원 교차표로 결과를 확인하시오

library(gmodels)

CrossTable(skin2_test[,6], skin2_result)

 

 

     | skin2_result
skin2_test[, 6] |        NO |       YES | Row Total |
----------------|-----------|-----------|-----------|
             NO |         6 |         0 |         6 |
                |     0.381 |     1.333 |           |
                |     1.000 |     0.000 |     0.667 |
                |     0.857 |     0.000 |           |
                |     0.667 |     0.000 |           |
----------------|-----------|-----------|-----------|
            YES |         1 |         2 |         3 |
                |     0.762 |     2.667 |           |
                |     0.333 |     0.667 |     0.333 |
                |     0.143 |     1.000 |           |
                |     0.111 |     0.222 |           |
----------------|-----------|-----------|-----------|
   Column Total |         7 |         2 |         9 |
                |     0.778 |     0.222 |           |
----------------|-----------|-----------|-----------|

 

 

 

 

 

문제207.

위의 의사결정트리의 성능을 높이시오

 

library(C50)

skin_models2<-C5.0(skin2_train[,-6], skin2_train$cupon_react, trials=6)

skin2_result2<-predict(skin_models2, skin2_test[, -6])

library(gmodels)

CrossTable(skin2_test[,6], skin2_result2)

 

            | skin2_result2
skin2_test[, 6] |        NO |       YES | Row Total |
----------------|-----------|-----------|-----------|
             NO |         6 |         0 |         6 |
                |     1.000 |     2.000 |           |
                |     1.000 |     0.000 |     0.667 |
                |     1.000 |     0.000 |           |
                |     0.667 |     0.000 |           |
----------------|-----------|-----------|-----------|
            YES |         0 |         3 |         3 |
                |     2.000 |     4.000 |           |
                |     0.000 |     1.000 |     0.333 |
                |     0.000 |     1.000 |           |
                |     0.000 |     0.333 |           |
----------------|-----------|-----------|-----------|
   Column Total |         6 |         3 |         9 |
                |     0.667 |     0.333 |           |
----------------|-----------|-----------|-----------|

 

※ trials 를 쓰니 (성능 높이기) FT 가 0가 되었다!!

 

책214

C4.5 알고리즘을 개선하여 만든 C5.0의 방법 중 하나는 적응형 부스팅을 추가한 것이다.

간단하게 소개하자면

여러개의 의사결정 트리를 만들어서 각 예시에 대해 최고 클래스를 투표하게 만드는 과정이다.

의사결정 트리의 정확도 향상:

적응형 부스팅 adaptive boosting(Ada boost)

여러개의 의사결정 트리를 만들어서 각 예시에 대해 최고 클래스를

투표하게 만드는 과정이다

ex: trials = 6 : 결정트리 6개

참고: https://swalloow.github.io/bagging-boosting

Bagging

Bagging은 샘플을 여러 번 뽑아 각 모델을 학습시켜 결과를 집계(Aggregating) 하는 방법입니다. 아래의 그림을 통해 자세히 알아보겠습니다.

먼저 대상 데이터로부터 복원 랜덤 샘플링을 합니다. 

이렇게 추출한 데이터가 일종의 표본 집단이 됩니다. 

이제 여기에 동일한 모델을 학습시킵니다. 

그리고 학습된 모델의 예측변수들을 집계하여 그 결과로 모델을 생성해냅니다.

이러한 방식을 Bootstrap Aggregating 이라고 부릅니다.

이렇게 하는 이유는 “알고리즘의 안정성과 정확성을 향상시키기 위해서” 입니다. 

 Boosting

Bagging이 일반적인 모델을 만드는데 집중되어있다면, 

Boosting은 맞추기 어려운 문제를 맞추는데 초점이 맞춰져 있습니다.

수학문제를 푸는데 9번 문제가 엄청 어려워서 계속 틀렸다고 가정해보겠다.

boosting 방식은 9번 문제에 가중치를 부여해서 9번 문제를 잘 맞춘 모델을

최종 모델로 선정합니다.

다시 정리하자면,

bagging이 일반적인 모델을 만드는데 집중되어 있다면,

boosting은 맞추기 어려운 문제를 맞추는데 초점이 맞춰져 있습니다.

 

배깅bagging 은 병렬학습

부스팅boosting은 순차적 학습

학습이 끝나면 결과에 따라 가중치 재분배 

출처: https://swalloow.github.io/bagging-boosting

 

 

 

문제208.

아까 위에서 1건 뺸 고객데이터(skin_real_test_cust)가 쿠폰반응이 있는

고객인지 아닌지 잘 맞추는지 확인하시오

 

skin_real_test_cust<-skin[30,]

skin2_result3<-predict(skin_models2, skin_real_test_cust[-7])

 

yes 나온거 보고 마무리

 

*표본이 한개라서 이원교차표가 안나온다.

 

 

 

■ "은행 대출 채무를 불이행 할 것 같은 고객이 누구인가?"

데이터: crdit.csv (독일 은행의 고객 데이터)

 

1. 데이터를 로드한다

credit<-read.csv("credit.csv", header=T)

head(credit)

 

2. 데이터에 각 컬럼들을 이해한다

라벨컬럼: default ---> yes : 대출금 상환 안 함

        no  : 대출금 상환

 

prop.table(table(credit$default))

no yes
0.7 0.3

 

계좌소개: checking_balance ---> 예금계좌

saving_balance -------->   적금계좌

amount   : 대출 금액 250 마르크 ~ 18424 마르크

        (100 마르크가 우리나라돈 6~7만원)

summary(credit$amount)
   Min.    1st Qu.  Median    Mean  3rd Qu.    Max.
    250    1366      2320      3271    3972      18424

 

은행의 목표:

과거의 데이터를 분석해보니 대출금 상환 불이행자가

30% 나 되어서 앞으로는 30% 이내로 떨어뜨리게끔 하는게

은행의 목표라서 거기 맞는 model 을 생성해야 한다.

 

 

3. 데이터가 명목형 데이터인지 확인해본다.

str(credit)

 

 

4. 데이터를 shuffle 시킨다

set.seed(31)

credit_shuffle<-credit[sample(nrow(credit)),]

train_num<-round(nrow(credit_shuffle)*0.9)

credit_train<-credit_shuffle[1:train_num,]

credit_test<-credit_shuffle[train_num+1:nrow(credit_shuffle), ]

 

 

 

5. C5.0 패키지와 훈련 데이터를 이용해서 모델을 생성한다.

library(C50)

credit_model<-C5.0(credit_train[, -17], credit_train[, 17])

# c5.0 으로 훈련시켜서 모델생성!

# 17번이 default 인데 default 맞추는걸로 훈련시키는 거다.

 

 

6. 위에서 만든 모델을 이용해서 테스트 데이터의 라벨을 예측한다

credit_result<-predict(credit_model, credit_test[,-17])

 

7. 이원 교차표로 결과를 확인하시오

CrossTable(credit_test[,17],credit_result)

                  | credit_result
credit_test[, 17] |        no |       yes | Row Total |
------------------|-----------|-----------|-----------|
               no |        64 |        11 |        75 |
                  |     0.517 |     1.833 |           |
                  |     0.853 |     0.147 |     0.750 |
                  |     0.821 |     0.500 |           |
                  |     0.640 |     0.110 |           |
------------------|-----------|-----------|-----------|
              yes |        14 |        11 |        25 |
                  |     1.551 |     5.500 |           |
                  |     0.560 |     0.440 |     0.250 |
                  |     0.179 |     0.500 |           |
                  |     0.140 |     0.110 |           |
------------------|-----------|-----------|-----------|
     Column Total |        78 |        22 |       100 |
                  |     0.780 |     0.220 |           |
------------------|-----------|-----------|-----------|

정확도 78%

 

 

 

문제209.

부스팅 기법을 이용해서 위의 의사결정트리 모델의 정확도를 올리시오

책 215

credit_model2<-C5.0(credit_train[,-17], credit_train[,17], trials=55)

               # credit_train$default 라고 해도 노상관

credit_result<-predict(credit_model2, credit_test[,-17])

CrossTable(credit_test[,17],credit_result)

 

 

문제210(점심시간문제)

샤이니에 의사결정트리(디시젼)를 추가하시오

<<knn_나이브_디시젼_까지 완성한 샤이니 코드_20190226.txt>>

 

 

 

 

문제211.

근무하고 있는 사원중에 퇴사가 예상되는 사원이 누구인지

알아내는 의사결정트리 모델을 생성하시오!

샤이니로 확인하기.

라벨: 퇴사여부

 

※ 샤이니 코드에서 라벨이 팩터여야 C5.0 이 돌아간다

 

 

| result
  test_label |         0 |         1 | Row Total |
-------------|-----------|-----------|-----------|
           0 |      1131 |         4 |      1135 |
             |    78.708 |   257.650 |           |
             |     0.996 |     0.004 |     0.757 |
             |     0.984 |     0.011 |           |
             |     0.754 |     0.003 |           |
-------------|-----------|-----------|-----------|
           1 |        18 |       347 |       365 |
             |   244.749 |   801.186 |           |
             |     0.049 |     0.951 |     0.243 |
             |     0.016 |     0.989 |           |
             |     0.012 |     0.231 |           |
-------------|-----------|-----------|-----------|
Column Total |      1149 |       351 |      1500 |
             |     0.766 |     0.234 |           |
-------------|-----------|-----------|-----------|

※ 1 이 퇴사

 

 

 

 

■ 규칙기반 알고리즘

1. oneR 알고리즘 (책 223p)

1R 알고리즘(One Rule 또는 OneR)은 하나의 규칙을 선택하는 방식으로

zeroR을 개선했다.

이 방법은 너무 단순한 것처럼 보이지만,

예상보다 훨씬 잘 실행되는 경향이 있다.

장점	단점
이해하기 쉽고 사람이 읽을 수 있는 하나의 경험적 규칙을 생성한다	하나의 특징만을 사용한다
가끔 놀랄 만큼 잘 실행된다	아마도 너무 단순하다
좀 더 복잡한 알고리즘의 기준점으로 제공될 수 있다.

예: 가슴통증의 유무에 따라 심장질환이 있는지 분류

가슴통증 하나만 보고 심장질환이 있다고 분류하기에는 오류가 많아진다.

왜냐하면 식도염, 폐질환도 가슴통증이 있기 때문이다.

 

2. Riper 알고리즘(책 226p)

Repeated Incremental Pruning to Produce Error Reduction

"복수개의 사실(조건)을 가지고 분류하는 알고리즘"

장점	단점
이해하기 쉽고 사람이 읽을 수 있는 규칙을 생성한다	상식이나 전문가 지식에 위배되는 것처럼 보이는 규칙이 생길 수 있다
크고 잡음이 있는 데이터셋에 효율적 이다	수치 데이터 작업에 적합하지 않다
일반적으로 비교 가능한 의사결정트리 보다 좀 더 간단한 모델을 생성한다	좀 더 복잡한 모델만큼 잘 수행되지 않을 수 있다.

예: 하늘을 날고 털이 있다면 그것은 포유류이다.

땅을 걷고 털이 있다면 그것은 포유류이다.

 

 

■ 규칙기반 분류 알고리즘(oneR 실습)

"독버섯 데이터"

나이브 베이즈와 비교해보기 위해서 나이브 베이즈로 독버섯과

일반 버섯을 분류한 이원교차표를 샤이니로 확인하시오

 

mushrooms.csv  ,   laplace = 0.0001   ,   seed = 1

 

1. 버섯 데이터를 R로 로드한다

mushroom<-read.csv("mushrooms.csv", stringsAsFactors = TRUE)

 

2. mushroom 데이터를 훈련 데이터와 테스트 데이터로 나눈다

(훈련데이터 75%, 테스트데이터 25%)

 

set.seed(11)
> dim(mushroom)
[1] 8124   23

 

mushroom<-read.csv("mushrooms.csv", stringsAsFactors = TRUE)

set.seed(11)

dim(mushroom)

train_cnt<-round(0.75*nrow(mushroom))

train_cnt

train_index<-sample(1:nrow(mushroom), train_cnt, replace=F)

train_index

 

mushroom_train<-mushroom[train_index,]

mushroom_test<-mushroom[-train_index,]

 

 

3. 규칙기반 알고리즘은 oneR 을 이용해서 독버섯과 일반버섯을

분류하는 모델을 생성한다

 

 

install.packages("OneR")

library(OneR)

 

model1<-OneR(type~. , data=mushroom_train)

model1

summary(model1)

 

 

4. 위에서 생성한 모델을 가지고 테스트 데이터로 결과를 확인한다

 

result1<-predict(model1, mushroom_test[,-1])

library(gmodels)

CrossTable(mushroom_test[,1], result1)

 

                | result1
mushroom_test[, 1] |    edible | poisonous | Row Total |
-------------------|-----------|-----------|-----------|
            edible |      1028 |         0 |      1028 |
                   |   446.170 |   489.958 |           |
                   |     1.000 |     0.000 |     0.506 |
                   |     0.967 |     0.000 |           |
                   |     0.506 |     0.000 |           |
-------------------|-----------|-----------|-----------|
         poisonous |        35 |       968 |      1003 |
                   |   457.291 |   502.170 |           |
                   |     0.035 |     0.965 |     0.494 |
                   |     0.033 |     1.000 |           |
                   |     0.017 |     0.477 |           |
-------------------|-----------|-----------|-----------|
      Column Total |      1063 |       968 |      2031 |
                   |     0.523 |     0.477 |           |
-------------------|-----------|-----------|-----------|

 

OneR 은 한가지 규칙기반 가지고 분류하기 때문에

결과가 썩 좋지 못하다

 

 

 

■ 규칙기반 분류 알고리즘(JRip 실습)

 

install.packages("RWeka")

library(RWeka)

model2<-JRip(type~., data=mushroom_train)

model2

summary(model2)

 

작은 이원교차표 하나 보임

> summary(model2)

=== Summary ===

Correctly Classified Instances        6093              100      %
Incorrectly Classified Instances         0                0      %
Kappa statistic                          1    
Mean absolute error                      0    
Root mean squared error                  0    
Relative absolute error                  0      %
Root relative squared error              0      %
Total Number of Instances             6093    

=== Confusion Matrix ===

a    b   <-- classified as
 3180    0 |    a = edible
    0 2913 |    b = poisonous

 

 

result2<-predict(model2, mushroom_test[, -1])

library(gmodels)

CrossTable(mushroom_test[,1], result2)

 

 

| result2
mushroom_test[, 1] |    edible | poisonous | Row Total |
-------------------|-----------|-----------|-----------|
            edible |      1028 |         0 |      1028 |
                   |   495.327 |   507.673 |           |
                   |     1.000 |     0.000 |     0.506 |
                   |     1.000 |     0.000 |           |
                   |     0.506 |     0.000 |           |
-------------------|-----------|-----------|-----------|
         poisonous |         0 |      1003 |      1003 |
                   |   507.673 |   520.327 |           |
                   |     0.000 |     1.000 |     0.494 |
                   |     0.000 |     1.000 |           |
                   |     0.000 |     0.494 |           |
-------------------|-----------|-----------|-----------|
      Column Total |      1028 |      1003 |      2031 |
                   |     0.506 |     0.494 |           |
-------------------|-----------|-----------|-----------|

 

※ 전부 0 이다. JRiper는 매우 강력한 분류법임.

 

 

※아래 내용은 JRipper가 분류를 위해 규칙을 만든 내용이다

(책 241)

model2
JRIP rules:
===========  *pungent 악취가 나는

(odor = foul) => type=poisonous (1601.0/0.0)
(gill_size = narrow) and (gill_color = buff) => type=poisonous (858.0/0.0)
(gill_size = narrow) and (odor = pungent) => type=poisonous (203.0/0.0)
(odor = creosote) => type=poisonous (140.0/0.0)
(spore_print_color = green) => type=poisonous (51.0/0.0)
(stalk_surface_below_ring = scaly) and (stalk_surface_above_ring = silky) => type=poisonous (47.0/0.0)
(habitat = leaves) and (gill_attachment = free) and (population = clustered) => type=poisonous (13.0/0.0)
 => type=edible (3180.0/0.0)

Number of Rules : 8

 

 

 

 

문제212.

JRip 알고리즘을 R샤이니에 새로운 탭으로 추가하시오

<<JRipper추가 샤이니코드.txt>>

길어서 생략

■ 의사결정트리 정리

특징값에 따라 데이터를 분할하는 소위 '탐욕greedy' 알고리즘을

사용하는 두 개의 분류 방법을 다루었다.

 

의사결정트리는 분할정복전략을 사용해 플로차트와 같은

구조를 생성하는 반면,

규칙 학습자는 논리적인 if-else 규칙을

식별해 데이터를 분리하고 정복한다.

 

두 방법은 통계적 배경 없이도 해석이 될 수 있는 모델을 생성한다.

 

인기있고 구성능력이 뛰어난 의사결정 트리 알고리즘 중 하나가

 C5.0 이다.

대출 신청자가 채무불이행 할지 여부를 예측하는 트리를 생성하기 위해

C5.0 알고리즘을 사용했다.

부스팅과 비용에 민감한 오류를 위한 옵션을 사용해 정확도를 향상시키고,

은행이 돈을 더 지불하게 될 위험한 대출을 피할 수 있었다.