34.통계데이터분석 - 일반선형모델 - 다항 로지스틱회귀분석.Rmd
0.02MB

 

34.일반선형모델---페널티-로지스틱회귀분석.html
1.40MB

 

https://www.youtube.com/watch?v=4ibxb0OpgWA&list=PLY0OaF78qqGAxKX91WuRigHpwBU0C2SB_&index=35

  • 목표: 다항 로지스틱회귀분석 이해

1. 다항 로지스틱회귀분석 개요

  • 다항 로지스틱회귀분석은 예측변수로부터 3개 이상의 사건, 즉 3개 이상의 범주를 갖는 결과변수의 사건발생확률을 예측함
  • 결과변수가 기업의 신용등급을 나타내고 신용등급은 a, b, c일3개 범주를 갖는다고 했을 때, 예측변수를 바탕으로 신용등급이 a일 확률, b일 확률, c일 확률을 예측함
  • 이렇게 계산된 사건발생확률은 새로운 케이스의 소속범주를 예측하는데 활용할 수 있음
    • 신용등급이 a일 확률, b일 확률, c일 확률을 각각 비교해 가장 큰 확률값을 갖는 범주로 기업신용등급을 예측함

2. 다항 로지스틱회귀모델

  • g개의 가능한 범주가 있을 때 다항로지스틱회귀모델은 아래와 같은 수식으로 표현할 수 있음
    • 결과변수 y는 g개의 가능한 값을 가짐. 즉, g개의 가능한 사건/범주를 가짐
    • k를 사건이라 할 때, \(p_k\)는 사건발생 확률을 나타냄
      • 즉, 결과변수 y가 사건 k일[범주 k에 속할] 확률 (\(p[y=k]\))을 뜻함
    • \(p_1\)은 기준 범주인 사건1 발생확률을 나타냄
      • 즉, 결과변수 y가 사건 1일[범주 1에 속할] 확률 (\(p[y=1]\))을 뜻함
    • 기준 범주는 일반적으로 첫 번째, 마지막, 또는 가장 많은 빈도를 갖는 범주가 사용됨
      • 이 경우는 첫 번째 범주가 기준범주로 사용됨
  • \[ \ln\left ( \frac{p_k}{p_1} \right ) = \beta_{0k} + \beta_{1k}x_{1} + \beta_{2k}x_{2} + \cdots + \beta_{mk}x_{m}\quad(k=2,3,\dots,g) \]
  • g개 범주가 있을 때 g-1개의 다항 로지스틱회귀모델이 생성됨
    • 이 회귀식에서 k는 2부터 g까지의 값을 가짐
    • 따라서 이 수식은 g-1개의 회귀식을 나타냄
    • 여기서 기준 범주로 사용되고 있는 첫 번째 범주를 제외한 나머지 각 범주당 하나씩 기준 범주에 대한 로그오즈 를 설명하는 회귀모델로 정의됨
      • 예로 결과변수가 신용등급이고 그 신용등급의 범주가 a, b, c일 때 다항 로지스틱회귀분석을 수행하면 2개의 회귀식이 생성됨. 기준 범주를 신용등급 a라고 했을 때,
      • 신용등급 b대 신용등급 a를 로그오즈(\(\ln\left ( \frac{p_k}{p_1} \right )\))로 하는 종속변수로하는 회귀식이 1개 생성되고,
      • 신용등급 c대 신용등급 a를 로그오즈(\(\ln\left ( \frac{p_k}{p_1} \right )\))로 하는 종속변수로하는 회귀식이 1개 생성됨
  • 이러한 다항 로지스틱회귀모델 양변에 지수함수를 취해 p에 대해서 정리하면 아래와 같은 각 범주별 사건발생 확률을 구할 수 있음

\[ p_k = P[y=k] = \frac{e^{z_h}}{1+\sum_{h=2}^{g}e^{z_h}}\quad(k=2,3,\dots,g) \]

\[여기에서,\; z_k = \beta_{0k} + \beta_{1k}x_{1} + \beta_{2k}x_{2} + \cdots + \beta_{mk}x_{m}\quad(k=2,3,\dots,g) \]

  • 기준범주 발생확률은 아래와 같다.

\[ p_1 = P[y=1] = \frac{e^{z_h}}{1+\sum_{h=2}^{g}e^{z_h}} \]

  • 이렇게 계산된 확률값은 새로운 케이스의 소속범주를 예측하는데 활용할 수 있음
  • 새로운 케이스에 대해 각 범주별 발생확률을 예측한 후 가장 큰 확률을 나타내는 범주로 분류함

3. 다항 로지스틱회귀분석 수행절차

3-1. 활용데이터 분석

  • EffectStars패키지에 PID데이터셋 설명
    • 미국의 유권자 944명의 정치성향 데이터로 모두 6개 변수를 포함하고 있음
    • 6개 변수 중 PID변수는 유권자 정치성향을 나타내는 변수로 다항 로지스틱회귀모델 구축 시 결과변수로 사용할 예정임
library(EffectStars)
data(PID)
str(PID)
## 'data.frame':    944 obs. of  6 variables:
##  $ TVnews    : int  7 1 7 4 7 3 7 1 7 0 ...
##  $ PID       : Factor w/ 3 levels "Democrat","Independent",..: 3 1 1 1 1 1 1 2 2 1 ...
##  $ Income    : num  1.5 1.5 1.5 1.5 1.5 1.5 1.5 1.5 1.5 1.5 ...
##  $ Education : Factor w/ 2 levels "low","high": 1 2 2 2 2 2 2 2 2 1 ...
##  $ Age       : int  36 20 24 28 68 21 77 21 31 39 ...
##  $ Population: int  0 190 31 83 640 110 100 31 180 2800 ...
  • PID변수 범주
    • 유권자의 정치 성향은 “Democrat” “Independent” “Republican”로 구분돼 있음
    • 나머지 5개 변수는 유권자 특성 변수로
      • TVnews: 유권자가 지난 일주일간 tv뉴스를 시청한 일수를 나타냄
      • Income: 소득을 나타냄
      • Education: 교육수준을 나타내며, “low”,“high”두 가지 범주로 구분돼 있음
      • Age: 유권자의 나이를 나타냄
      • Population: 유권자가 살고 있는 지역의 인구가 기록돼 있음
  • 이 5가지 유권자 특성으로 유권자가 특정정치성향을 가질 확률을 예측할 것임
levels(PID$PID)
## [1] "Democrat"    "Independent" "Republican"
  • 여기서는 VGAM패키지 vglm()으로 다항 로지스틱회귀분석을 수행함

3-2. 예측모델 생성 - vglm(결과변수 ~ ., family=multinomial())

  • vglm() 인수설명
    • 1st: 결과변수와 예측변수를 포뮬러 형식으로 지정함
    • family: 결과변수의 확률분포를 나타내는 함수를 지정함. 여기서 결과변수는 다항분포를 따르고 있기 때문에 다항분포를 의미하는 multinomial을 지정함
    • data: 예측모델을 생성할 때 사용할 데이터셋을 지정함. 여기서 훈련/테스트데이터 별도 구분없이 전체 데이터셋을 모두 예측모델을 생성하는데 사용함
library(VGAM)
pid.mlogit <- vglm(PID ~ ., family=multinomial(), 
                   data=PID)
summary(pid.mlogit)
## 
## Call:
## vglm(formula = PID ~ ., family = multinomial(), data = PID)
## 
## Coefficients: 
##                   Estimate Std. Error z value Pr(>|z|)    
## (Intercept):1    1.2296119  0.3031106   4.057 4.98e-05 ***
## (Intercept):2    0.1275830  0.3405777   0.375  0.70795    
## TVnews:1         0.0440935  0.0321897   1.370  0.17075    
## TVnews:2         0.0247123  0.0350497   0.705  0.48077    
## Income:1        -0.0165464  0.0027760  -5.960 2.51e-09 ***
## Income:2        -0.0002418  0.0027864  -0.087  0.93085    
## Educationhigh:1 -0.2886055  0.1759813  -1.640  0.10101    
## Educationhigh:2 -0.3530642  0.1971199  -1.791  0.07328 .  
## Age:1           -0.0077751  0.0052743  -1.474  0.14044    
## Age:2           -0.0066722  0.0059864  -1.115  0.26503    
## Population:1     0.0002592  0.0000984   2.634  0.00844 ** 
## Population:2     0.0002052  0.0001053   1.949  0.05135 .  
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Names of linear predictors: log(mu[,1]/mu[,3]), log(mu[,2]/mu[,3])
## 
## Residual deviance: 1969.38 on 1876 degrees of freedom
## 
## Log-likelihood: -984.6901 on 1876 degrees of freedom
## 
## Number of Fisher scoring iterations: 4 
## 
## No Hauck-Donner effect found in any of the estimates
## 
## 
## Reference group is level  3  of the response
  • 결과해석
    • 다항 로지스틱회귀분석은 결과변수가 g개의 범주를 가질 경우, g-1개의 모델을 추정함
    • 결과변수인 정치성향 변수인 PID는 3개의 범주를 포함하기 때문에 회귀모델 2개가 생성됨
    • 2개의 절편과 각 변수당 2개씩의 회귀계수가 출력됨
    • 여기서 교육수준 변수인 Education은 범주형 변수이기 때문에 모델 내에서 더미변수로 자동변환돼 low는 기준범주로써 0, high는 1로 코딩되고 원래 변수명에 1로 코딩된 범주명 high가 붙여져 Eudcationhigh로 만들어졌음
    • vglm()은 결과변수의 마지막 범주를 기준범주로 사용함. 그래서 PID변수의 마지막 범주 Republican이 기준범주로 사용됨
  • Republican이 기준범주이므로 추정된 2개의 회귀모델은 Republican에 대한 나머지 두 범주의 로그오즈를 각 예측변수의 회귀계수의 선형결합으로 표현할 수 있음

\[ \displaystyle \begin{align*} & \ln\left ( \frac{P(PID = Democrat)}{P(PID = Republican)} \right ) = \\ & 1.230 + 0.044 × TVnews - 0.017 × Income \\ & - 0.289 × Educationhigh - 0.008 × Age + 0.0003 × Population & \end{align*} \]

\[ \displaystyle \begin{align*} & \ln\left ( \frac{P(PID = Independent)}{P(PID = Republican)} \right ) = \\ & 0.128 + 0.025 × TVnews - 0.0002 × Income \\ & - 0.356 × Educationhigh - 0.007 × Age + 0.0002 × Population & \end{align*} \]

  • 각 예측변수의 회귀계수는 다른 독립변수들이 일정하다는 가정 하에 해당 예측변수의 1단위증가가 가져오는 로그오즈의 변화량을 나타냄
    • \(\ln\left ( \frac{P(PID = Democrat)}{P(PID = Republican)} \right )\)회귀모델에서
    • 뉴스시청일수 1일 증가에 로그오즈 0.044만큼 증가
    • 교육수준 1단위 증가(low > high로 변화를 의미)에 로그오즈 0.289만큼 감소
    • 소득 1단위 증가에 로그오즈는 0.017만큼 감소
  • 하지만 로그오즈는 그 자체로 해석상의 어려움이 있기 때문에 다항 로지스틱회귀모델 양변에 지수함수를 취해 결과변수를 로그오즈가 아닌 오즈로 변환함
    • 결과변수가 오즈인 회귀모델에서는 새롭게 계산된 회귀계수로 예측변수 1단위 증가에 따른 오즈의 변화비율을 살펴볼 수 있음
    • 오즈의 변화비율 즉 오즈비는 다른 예측변수가 동일하다는 가정하에 예측변수 1단위 증가시 어떤 한 범주에 속할 확률이, 기준범주에 속할 확률 대비 몇 배나 큰 지 혹은 작은지를 의미함

3-3. 회귀계수 추출 및 지수함수 변환 - exp(coef())

  • 회귀모델의 회귀계수를 지수함수값으로 변환하기 위해 먼저 coef()로 회귀모델로부터 회귀계수를 추출한 다항 회귀계수에 exp함수를 적용함
summary(pid.mlogit)
## 
## Call:
## vglm(formula = PID ~ ., family = multinomial(), data = PID)
## 
## Coefficients: 
##                   Estimate Std. Error z value Pr(>|z|)    
## (Intercept):1    1.2296119  0.3031106   4.057 4.98e-05 ***
## (Intercept):2    0.1275830  0.3405777   0.375  0.70795    
## TVnews:1         0.0440935  0.0321897   1.370  0.17075    
## TVnews:2         0.0247123  0.0350497   0.705  0.48077    
## Income:1        -0.0165464  0.0027760  -5.960 2.51e-09 ***
## Income:2        -0.0002418  0.0027864  -0.087  0.93085    
## Educationhigh:1 -0.2886055  0.1759813  -1.640  0.10101    
## Educationhigh:2 -0.3530642  0.1971199  -1.791  0.07328 .  
## Age:1           -0.0077751  0.0052743  -1.474  0.14044    
## Age:2           -0.0066722  0.0059864  -1.115  0.26503    
## Population:1     0.0002592  0.0000984   2.634  0.00844 ** 
## Population:2     0.0002052  0.0001053   1.949  0.05135 .  
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Names of linear predictors: log(mu[,1]/mu[,3]), log(mu[,2]/mu[,3])
## 
## Residual deviance: 1969.38 on 1876 degrees of freedom
## 
## Log-likelihood: -984.6901 on 1876 degrees of freedom
## 
## Number of Fisher scoring iterations: 4 
## 
## No Hauck-Donner effect found in any of the estimates
## 
## 
## Reference group is level  3  of the response
exp(coef(pid.mlogit))
##   (Intercept):1   (Intercept):2        TVnews:1        TVnews:2        Income:1 
##       3.4199020       1.1360792       1.0450800       1.0250202       0.9835898 
##        Income:2 Educationhigh:1 Educationhigh:2           Age:1           Age:2 
##       0.9997582       0.7493078       0.7025321       0.9922550       0.9933500 
##    Population:1    Population:2 
##       1.0002592       1.0002052
  • 결과해석
    • 숫자 1은 “Democrat” 대 “Republican” 회귀모델이며, 숫자 2는 “Independent” 대 “Republican” 회귀모델임
    • 오즈비는
      • TVnews: 1.0450800, 뉴스시청일이 1일 늘어날 때 Democrat일 가능성이 Republican일 가능성에 비해 4.5% 증가함
      • Education: 0.7493078, 교육수준 1단위 증가는 Democrat일 가능성이 Republican일 가능성에 비해 25.1% 감소함. 즉, 교육수준이 low->high로 바뀌면 Democrat일 가능성이 Republican일 가능성에 비해 25.1% 작아짐
        • 그런데 TVnews와 Education변수 회귀계수의 p값이 각각 0.17075과 0.10101로 통계적으로 유의하지 않아 이러한 비율은 해석할 때 주의가 필요함
      • Income: 0.9835898, 소득 1단위 증가는 Democrat일 가능성이 Republican일 가능성에 비해 1.6% 감소하며 통계적으로도 유의하므로 소득 변화는 Democrat일 가능성과 Republican일 가능성에 유의한 영향을 미침

3-4. 각 범주별 예측확률 산출 - fitted()

  • 다항 로지스틱회귀모델에 의한 각 범주별 예측 확률은 fitted()로 구할 수 있음
pid.mlogit.pred <- fitted(pid.mlogit)
head(pid.mlogit.pred)
##    Democrat Independent Republican
## 1 0.6247928   0.1932306  0.1819766
## 2 0.5739020   0.1817883  0.2443097
## 3 0.6109039   0.1745194  0.2145766
## 4 0.5843473   0.1772105  0.2384421
## 5 0.5839453   0.1694467  0.2466080
## 6 0.5856824   0.1794368  0.2348808
  • 결과해석: 각 케이스 별 Democrat, Independent, Republican로 분류할 확률이 추정됨

3-5. 새로운 데이터셋에 대한 사건발생확률 추정 - predict()

  • fitted()로 추정한 확률은 예측모델 생성을 위해 사용한 데이터셋에 포함된 각 케이스별 사건발생확률을 의미함
  • 새로운 데이터셋에 대한 사건발생확률을 추정하기 위해서는 predict() 사용
    • 1st: 다항 로지스틱회귀모델 지정
    • newdata: 사건발생확률을 추정할 새로운 데이터셋을 지정함
    • type: 결과를 확률로 출력하기 위해 “response” 를 입력함
  • newdata의 데이터셋 생성 - data.frame()
    • predict()를 실행하면 newdata인수에 지정된 데이터셋의 각 케이스별 사건발생확률을 얻을 수 있으나 현재 모든 데이터를 예측모델 생성에 사용하여 새 데이터셋을 가지고 있지 않음
    • 그래서 먼저 새 데이터셋을 하나 생성해 예측변수 수준에 따라 사건발생확률이 어떻게 변화하는지 확인할 것임
    • 데이터셋 생성방법: 한 예측변수 값은 변화시키고 나머지 예측변수는 평균으로 고정한 가상의 데이터셋 생성

1) 교육수준이 정치성향에 미치는 영향 확인

  • 교육수준이 정치성향에 미치는 영향을 보기 위해
    • 다른 수준은 고정한 채 Education을 low, high 두 가지 수준으로 변화시키고
    • 동시에 나머지 예측변수값은 평균으로 고정한 가상의 데이터셋을 생성함
testdata <- data.frame(Education=c("low", "high"),
                       TVnews=mean(PID$TVnews),
                       Income=mean(PID$Income),
                       Age=mean(PID$Age),
                       Population=mean(PID$Population))
testdata
##   Education   TVnews   Income      Age Population
## 1       low 3.727754 46.57574 47.04343   306.3814
## 2      high 3.727754 46.57574 47.04343   306.3814
  • 결과해석: 생성된 데이터셋에서 교육수준은 low와 high 두개의 값을 갖는 반면에 나머지 예측변수들은 모두 동일값으로 고정되어 있음
  • 이렇게 만들어진 testdata를 predict()의 newdata인수에 지정하고, 추정될 확률을 원래의 testdata와 함께 출력함
pid.mlogit.pred <- predict(pid.mlogit, newdata=testdata, type="response")
cbind(testdata, pid.mlogit.pred)
##   Education   TVnews   Income      Age Population  Democrat Independent
## 1       low 3.727754 46.57574 47.04343   306.3814 0.4169951   0.2852971
## 2      high 3.727754 46.57574 47.04343   306.3814 0.3854667   0.2472630
##   Republican
## 1  0.2977078
## 2  0.3672703
  • 결과해석
    • 교육수준이 증가하면, 즉 교육수준이 low->high로 변화하면
      • Democrat일 확률은 41.7%에서 38.5%로 감소함
      • Republican일 확률은 29.8% 에서 36.7%로 증가함
      • 그래서 교육수준과 정치성향 간에는 관련성이 있어 보임
    • 교육수준 증가가 Democrat일 확률을 감소시키고 Republican일 확률을 증가시키긴 했지만, 교육수준이 높건 낮건 관계없이 결과적으로 Democrat으로 불릴 확률이 가장 높기 때문에 교육수준과 정치성향 간의 명확한 영향관계를 확인하기는 어려움
    • 이는 앞서 교육수준 회귀계수가 통계적으로 유의하지 않은 것과 같은 맥락에서 해석가능

2) 소득수준이 정치성향에 미치는 영향 확인

  • 소득수준이 정치성향에 미치는 영향을 확인하기 위해
    • 다른 변수들은 고정한 채
    • Income을 20~100에 범위 내에서 20씩 변화시키는데
    • Education변수는 모두 low수준으로 고정시키고
    • 나머지 변수들은 모두 평균값으로 고정함
testdata <- data.frame(Education=rep("low", 5),
                       TVnews=mean(PID$TVnews),
                       Income=seq(20, 100, 20),
                       Age=mean(PID$Age),
                       Population=mean(PID$Population))
testdata
##   Education   TVnews Income      Age Population
## 1       low 3.727754     20 47.04343   306.3814
## 2       low 3.727754     40 47.04343   306.3814
## 3       low 3.727754     60 47.04343   306.3814
## 4       low 3.727754     80 47.04343   306.3814
## 5       low 3.727754    100 47.04343   306.3814
  • 결과해석
    • 생성된 새로운 가상의 데이터를 보면 소득은 20에서 100까지 20의 간격으로 변화함
    • 그리고 나머지 변수들은 모두 같은 값으로 고정돼 있음

3) 다시 predict()로 사건발생확률을 추정하고, 데이터셋과 함께 사건발생확률을 출력함

pid.mlogit.pred <- predict(pid.mlogit, newdata=testdata, type="response")
cbind(testdata, pid.mlogit.pred)
##   Education   TVnews Income      Age Population  Democrat Independent
## 1       low 3.727754     20 47.04343   306.3814 0.5253435   0.2330383
## 2       low 3.727754     40 47.04343   306.3814 0.4434690   0.2725630
## 3       low 3.727754     60 47.04343   306.3814 0.3645531   0.3104445
## 4       low 3.727754     80 47.04343   306.3814 0.2923033   0.3448868
## 5       low 3.727754    100 47.04343   306.3814 0.2292065   0.3747050
##   Republican
## 1  0.2416182
## 2  0.2839680
## 3  0.3250024
## 4  0.3628100
## 5  0.3960885
  • 결과해석
    • 소득이 20에서 100으로 변함에 따라,
      • Democrat로 분류될 확률은 52.5%에서 22.9%로 감소함
      • Republican로 분류될 확률은 24.2%에서 39.6%로 증가함
    • 정치성향별 예측확률을 소득군별로 보면
      • 소득이 20~40인 저소득층은 Democrat로 분류될 확률이 가장 높고
      • 소득이 80~100인 고소득층은 Republican로 예측될 가장 큼
    • 따라서 소득과 정치성향 간에는 밀접한 관계가 있는 것으로 보임. 소득이 증가할수록 Republican 성향의 유권자일 가능성이 높다는 것을 알 수 있음

4. 다항 로지스틱회귀분석을 활용한 예

4-1. 활용데이터 분석

  • MASS패키지 fgl데이터셋을 사용한 다항 로지스틱회귀분석 예시
  • fgl데이터셋 설명
    • 214개 의 유리조각에 대한 성분 데이터임. 모두 10개 변수를 포함하고 있음
    • 10개 변수가운데 마지막에 있는 type변수는 유리조각의 유리유형을 나타내는 결과변수임
library(MASS)
str(fgl)
## 'data.frame':    214 obs. of  10 variables:
##  $ RI  : num  3.01 -0.39 -1.82 -0.34 -0.58 ...
##  $ Na  : num  13.6 13.9 13.5 13.2 13.3 ...
##  $ Mg  : num  4.49 3.6 3.55 3.69 3.62 3.61 3.6 3.61 3.58 3.6 ...
##  $ Al  : num  1.1 1.36 1.54 1.29 1.24 1.62 1.14 1.05 1.37 1.36 ...
##  $ Si  : num  71.8 72.7 73 72.6 73.1 ...
##  $ K   : num  0.06 0.48 0.39 0.57 0.55 0.64 0.58 0.57 0.56 0.57 ...
##  $ Ca  : num  8.75 7.83 7.78 8.22 8.07 8.07 8.17 8.24 8.3 8.4 ...
##  $ Ba  : num  0 0 0 0 0 0 0 0 0 0 ...
##  $ Fe  : num  0 0 0 0 0 0.26 0 0 0 0.11 ...
##  $ type: Factor w/ 6 levels "WinF","WinNF",..: 1 1 1 1 1 1 1 1 1 1 ...
  • type변수는 모두 6개의 범주를 갖고 있음. 유리조각은 이 6개의 유형으로 분류됨
  • 나머지 9개 변수는 유리조각에 대한 성분을 표현해주는 변수임
levels(fgl$type)
## [1] "WinF"  "WinNF" "Veh"   "Con"   "Tabl"  "Head"
head(fgl)
##      RI    Na   Mg   Al    Si    K   Ca Ba   Fe type
## 1  3.01 13.64 4.49 1.10 71.78 0.06 8.75  0 0.00 WinF
## 2 -0.39 13.89 3.60 1.36 72.73 0.48 7.83  0 0.00 WinF
## 3 -1.82 13.53 3.55 1.54 72.99 0.39 7.78  0 0.00 WinF
## 4 -0.34 13.21 3.69 1.29 72.61 0.57 8.22  0 0.00 WinF
## 5 -0.58 13.27 3.62 1.24 73.08 0.55 8.07  0 0.00 WinF
## 6 -2.04 12.79 3.61 1.62 72.97 0.64 8.07  0 0.26 WinF

4-2. 데이터 전처리 <예측변수 표준화, 훈련·테스트데이터 분할> - scale()

  • 이 9개의 성분데이터로 유리조각에 유리유형을 예측하는 다항 로지스틱회귀모델을 생성하기 전 예측변수인 9개의 성분데이터의 특성을 살펴봐야 함
  • 9개의 성분데이터(예측변수) 특성
    • 변수값의 범위가 다양해 소수점 이하나, 10단위 값을 갖고 있는 변수도 있음
    • 이렇게 예측변수 범위가 다양할 때, 예측정확도에 좋지 않은 영향을 미칠 수 있음
    • 그래서 예측모델 생성 전 예측변수를 표준화 작업을 거치는 것이 바람직함
  • 예측변수를 표준화 해 새로운 데이터셋으로 저장함
    • 처음 9개의 변수까지가 예측변수이기 때문에 9개 열만 scale()로 표준화 함
    • 10번째 결과변수를 표준화 데이터 옆에 열로 붙여 원래 데이터셋과 같은 구조로 생성함
fgl.scaled <- cbind(scale(fgl[,1:9]), fgl[10])
head(fgl.scaled)
##           RI         Na        Mg         Al          Si           K         Ca
## 1  0.8708258  0.2842867 1.2517037 -0.6908222 -1.12444556 -0.67013422 -0.1454254
## 2 -0.2487502  0.5904328 0.6346799 -0.1700615  0.10207972 -0.02615193 -0.7918771
## 3 -0.7196308  0.1495824 0.6000157  0.1904651  0.43776033 -0.16414813 -0.8270103
## 4 -0.2322859 -0.2422846 0.6970756 -0.3102663 -0.05284979  0.11184428 -0.5178378
## 5 -0.3113148 -0.1688095 0.6485456 -0.4104126  0.55395746  0.08117845 -0.6232375
## 6 -0.7920739 -0.7566101 0.6416128  0.3506992  0.41193874  0.21917466 -0.6232375
##           Ba         Fe type
## 1 -0.3520514 -0.5850791 WinF
## 2 -0.3520514 -0.5850791 WinF
## 3 -0.3520514 -0.5850791 WinF
## 4 -0.3520514 -0.5850791 WinF
## 5 -0.3520514 -0.5850791 WinF
## 6 -0.3520514  2.0832652 WinF
  • 그 다음 데이터셋을 예측모델 생성과 모델 예측정확도 검증을 위한 훈련·테스트데이터로 분할
    • 여기서는 훈련데이터와 테스트데이터를 7대 3 비율로 분할
    • sample()로 전체 데이터셋으로부터 70%에 해당되는 행의 인덱스 추출
    • 이 인덱스로 전체 데이터셋으로부터 70%에 해당되는 데이터 추출 후 훈련데이터로 만듦
    • 그리고 나머지 30%는 테스트데이터로 만듦
set.seed(123)
train <- sample(nrow(fgl), 0.7*nrow(fgl)) # 70%에 해당되는 행의 인덱스 추출
fgl.train <- fgl.scaled[train,] # 70%에 해당되는 데이터로 훈련데이터 생성
fgl.test <- fgl.scaled[-train,] # 30%에 해당되는 데이터로 테스트데이터 생성
  • 훈련데이터와 테스트데이터에 포함되어 있는 관측값 개수를 계산하고 범주별 빈도 산출
table(fgl.train$type)
## 
##  WinF WinNF   Veh   Con  Tabl  Head 
##    48    54    10    11     5    21
sum(table(fgl.train$type))
## [1] 149
table(fgl.test$type)
## 
##  WinF WinNF   Veh   Con  Tabl  Head 
##    22    22     7     2     4     8
sum(table(fgl.test$type))
## [1] 65
  • 결과: 훈련데이터로 149개의 표본이 선정됐고, 테스트데이터로 65개의 표본이 포함됨

4-3. 예측모델 생성 및 모델 성능 평가 - multinom()

  • 데이터전처리 완료했기 때문에 이 데이터셋으로 여기서는 nnet패키지 multinom()으로 다항 로지스틱회귀모델을 생성하고 회귀모델의 성능을 평가함

1) 예측모델 생성

  • multinom() 인수설명
    • 1st: 결과변수와 예측변수를 포뮬러 형식으로 지정
    • data: 훈련데이터 지정
library(nnet)
fgl.mlogit <- multinom(type ~ ., data=fgl.train)
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 104.572261
## iter  20 value 87.097706
## iter  30 value 79.938775
## iter  40 value 75.064271
## iter  50 value 73.957695
## iter  60 value 72.716878
## iter  70 value 72.340849
## iter  80 value 72.294902
## iter  90 value 72.124134
## iter 100 value 70.138206
## final  value 70.138206 
## stopped after 100 iterations
summary(fgl.mlogit)
## Call:
## multinom(formula = type ~ ., data = fgl.train)
## 
## Coefficients:
##         (Intercept)           RI           Na           Mg           Al
## WinNF  9.355295e-02   -0.8953382    -4.063962    -9.048398   -0.5114149
## Veh   -1.133317e+03   -8.6962954    -5.829434    -7.471188   -3.8837185
## Con   -1.775676e+03  809.3073013 -1498.700238 -5267.689193 2633.0124575
## Tabl  -5.707417e+03 1503.0305115  3453.631581   402.083873 4796.9312859
## Head  -3.440740e+03 3973.2180791  2766.948335  -567.865018 6106.0668565
##                Si            K           Ca           Ba            Fe
## WinNF   -4.762664    -5.224543    -7.036873    -6.887587     0.3130040
## Veh     -9.568647    -8.386972    -2.916572 -3210.962579     0.2369889
## Con    411.127578 -2096.906954 -3215.489971  3890.713662 -1142.1918822
## Tabl  2213.126387 -5318.320088   850.190516   356.705594 -4547.5583901
## Head  5085.219765   463.552739  -641.047022  4867.920520 -1662.5175395
## 
## Std. Errors:
##       (Intercept)        RI       Na        Mg        Al        Si         K
## WinNF    2.250252  1.199627 2.399749  4.300370  1.600933  2.240364  2.512023
## Veh      1.639861  2.688003 3.037652  5.870651  2.192671  3.194121  3.509944
## Con     13.950757 10.090718 4.104262 13.278437 15.332909  3.331481 62.182580
## Tabl     0.000000  0.000000 0.000000  0.000000  0.000000  0.000000  0.000000
## Head     5.158491  8.757124 2.576395  9.600709 16.273983 12.993265 45.186352
##              Ca         Ba        Fe
## WinNF  4.440853  6.3418754 0.2713187
## Veh    5.911691  0.5773154 0.4929929
## Con   12.352283 16.6950553 7.2049922
## Tabl   0.000000  0.0000000 0.0000000
## Head   7.347112  1.8160539 3.0181253
## 
## Residual Deviance: 140.2764 
## AIC: 240.2764
  • 결과:
    • multinom()은 1st범주를 기준 범주로 사용하고, WinF가 1st범주이므로 기준범주로 사용됨
    • 결과변수로 6개 범주가 있기 때문에 5개 절편과 각 예측변수 별 5개 회귀계수가 계산됨
    • multinom()은 회귀계수에 대한 유의확률을 제공하지 않으므로 회귀계수에 대한 유의성 검정을 위해 별도로 유의확률을 계산해야 함

2) 회귀계수의 유의성 검정 - z-value, pnorm()

  • 회귀계수를 표준오차로 나눠 z값을 구하고 z값을 pnorm()에 적용해 유의확률 산출
z <- summary(fgl.mlogit)$coefficients/summary(fgl.mlogit)$standard.errors
  • 유의확률은 표준 정규분포 상의 양쪽 꼬리부분 면적을 계산하면 됨
    • pnorm()로 z값에 절대값 취한 후,
    • 표준 정규분포 상에서 z값까지의 누적 확률을 계산함
    • 1에서 이 누적확률을 빼면 오른쪽 꼬리부분이 먼저 계산되고
    • 그 값을 2배하면 양쪽 꼬리 부분의 면적을 계산할 수 있음
    • 이렇게 계산 된 p는 각 회귀계수에 대한 유의확룰이 됨
p <- (1-pnorm(abs(z), 0, 1))*2
print(p, digits=3)
##       (Intercept)      RI     Na     Mg     Al      Si      K    Ca    Ba    Fe
## WinNF       0.967 0.45546 0.0904 0.0354 0.7494 0.03352 0.0375 0.113 0.277 0.249
## Veh         0.000 0.00122 0.0550 0.2031 0.0765 0.00274 0.0169 0.622 0.000 0.631
## Con         0.000 0.00000 0.0000 0.0000 0.0000 0.00000 0.0000 0.000 0.000 0.000
## Tabl        0.000 0.00000 0.0000 0.0000 0.0000 0.00000 0.0000 0.000 0.000 0.000
## Head        0.000 0.00000 0.0000 0.0000 0.0000 0.00000 0.0000 0.000 0.000 0.000

3) 예측모델로 새 데이터에 대한 예측확률 추정 - predict()

  • predict()로 생성한 예측모델을 바탕으로 새로운 데이터에 대한 예측확률 추정 가능
  • predict() 인수설명
    • 1st: 다항 로지스틱회귀모델 지정
    • newdata: 예측 대상 데이터를 지정. 여기서는 테스트데이터를 지정함
    • type: 예측 유형을 지정함. “probs”를 지정해 회귀모델에 의해 추정된 확률을 얻을 수 있음
fgl.mlogit.pred <- predict(fgl.mlogit, newdata=fgl.test, type="probs")
head(fgl.mlogit.pred)
##         WinF     WinNF          Veh Con Tabl Head
## 2  0.5678865 0.4315058 0.0006076739   0    0    0
## 3  0.1905724 0.8021744 0.0072532302   0    0    0
## 10 0.6469285 0.3506427 0.0024288411   0    0    0
## 11 0.1330417 0.8502778 0.0166805273   0    0    0
## 12 0.8038316 0.1918443 0.0043241395   0    0    0
## 15 0.7941149 0.2050818 0.0008032298   0    0    0
  • 각 유리유형별로 추정된 예측확률 옆에 실제 유리유형을 추가해 예측확률과 실제 범주 간 관계를 확인함
cbind(round(fgl.mlogit.pred, 3), fgl.test["type"])
##      WinF WinNF   Veh   Con  Tabl Head  type
## 2   0.568 0.432 0.001 0.000 0.000    0  WinF
## 3   0.191 0.802 0.007 0.000 0.000    0  WinF
## 10  0.647 0.351 0.002 0.000 0.000    0  WinF
## 11  0.133 0.850 0.017 0.000 0.000    0  WinF
## 12  0.804 0.192 0.004 0.000 0.000    0  WinF
## 15  0.794 0.205 0.001 0.000 0.000    0  WinF
## 18  0.554 0.356 0.089 0.000 0.000    0  WinF
## 19  0.254 0.409 0.337 0.000 0.000    0  WinF
## 28  0.448 0.541 0.012 0.000 0.000    0  WinF
## 29  0.514 0.484 0.002 0.000 0.000    0  WinF
## 31  0.688 0.307 0.005 0.000 0.000    0  WinF
## 33  0.715 0.285 0.000 0.000 0.000    0  WinF
## 44  0.882 0.062 0.056 0.000 0.000    0  WinF
## 45  0.356 0.621 0.022 0.000 0.000    0  WinF
## 47  0.637 0.359 0.004 0.000 0.000    0  WinF
## 49  0.839 0.092 0.068 0.000 0.000    0  WinF
## 57  0.000 0.000 1.000 0.000 0.000    0  WinF
## 58  0.459 0.539 0.002 0.000 0.000    0  WinF
## 59  0.914 0.086 0.000 0.000 0.000    0  WinF
## 61  0.599 0.383 0.019 0.000 0.000    0  WinF
## 65  0.813 0.164 0.023 0.000 0.000    0  WinF
## 66  0.436 0.496 0.068 0.000 0.000    0  WinF
## 73  0.423 0.573 0.005 0.000 0.000    0 WinNF
## 82  0.404 0.591 0.005 0.000 0.000    0 WinNF
## 88  0.247 0.731 0.022 0.000 0.000    0 WinNF
## 95  0.349 0.646 0.005 0.000 0.000    0 WinNF
## 96  0.126 0.851 0.023 0.000 0.000    0 WinNF
## 100 0.661 0.339 0.000 0.000 0.000    0 WinNF
## 101 0.325 0.675 0.000 0.000 0.000    0 WinNF
## 102 0.038 0.921 0.041 0.000 0.000    0 WinNF
## 107 0.000 0.000 0.000 1.000 0.000    0 WinNF
## 111 0.373 0.622 0.005 0.000 0.000    0 WinNF
## 113 0.181 0.800 0.018 0.000 0.000    0 WinNF
## 120 0.162 0.774 0.064 0.000 0.000    0 WinNF
## 124 0.154 0.843 0.003 0.000 0.000    0 WinNF
## 125 0.914 0.086 0.000 0.000 0.000    0 WinNF
## 126 0.274 0.724 0.002 0.000 0.000    0 WinNF
## 129 0.299 0.701 0.000 0.000 0.000    0 WinNF
## 131 0.000 0.000 0.000 0.000 1.000    0 WinNF
## 138 0.338 0.660 0.002 0.000 0.000    0 WinNF
## 139 0.472 0.528 0.000 0.000 0.000    0 WinNF
## 142 0.870 0.130 0.000 0.000 0.000    0 WinNF
## 144 0.172 0.827 0.002 0.000 0.000    0 WinNF
## 145 0.223 0.558 0.220 0.000 0.000    0 WinNF
## 147 0.479 0.350 0.170 0.000 0.000    0   Veh
## 151 0.061 0.890 0.048 0.000 0.000    0   Veh
## 156 0.452 0.409 0.139 0.000 0.000    0   Veh
## 157 0.304 0.306 0.390 0.000 0.000    0   Veh
## 160 0.071 0.756 0.173 0.000 0.000    0   Veh
## 161 0.246 0.668 0.086 0.000 0.000    0   Veh
## 162 0.884 0.116 0.000 0.000 0.000    0   Veh
## 171 0.000 0.000 0.000 0.419 0.581    0   Con
## 172 0.000 0.000 0.000 1.000 0.000    0   Con
## 177 0.000 0.000 0.000 0.000 1.000    0  Tabl
## 178 0.000 0.000 0.000 0.000 1.000    0  Tabl
## 180 0.000 0.000 0.000 0.000 1.000    0  Tabl
## 182 0.000 0.000 0.000 0.000 1.000    0  Tabl
## 186 0.000 0.000 0.000 1.000 0.000    0  Head
## 187 0.000 0.000 0.000 0.000 0.000    1  Head
## 188 0.840 0.160 0.000 0.000 0.000    0  Head
## 189 0.000 0.000 0.000 0.000 1.000    0  Head
## 191 0.000 0.000 0.000 1.000 0.000    0  Head
## 205 0.000 0.000 0.000 0.000 0.000    1  Head
## 210 0.000 0.000 0.000 0.000 0.000    1  Head
## 214 0.000 0.000 0.000 0.000 0.000    1  Head
  • 결과
    • 일반적으로 가장 높은 예측확률을 갖는 범주가 예측범주로 선택되기 때문에 이를 통해 각 케이스 별로 예측성공 여부를 확인할 수 있음
    • 케이스1에서 WinF의 확률이 가장 크기 때문에 WinF로 분류될 것임. 그런데 실제 유리유형도 Winf 이기 때문에 케이스1 같은 경우 예측모델에 의한 예측결과와 실제결과가 일치함

4-4. 테스트데이터에 대한 예측정확도 산출

  • 가장 높은 예측확률을 갖는 범주를 예측범주로 선택하는데, max.col()로 가장 높은 예측확률을 갖는 열의 인덱스를 추출할 수 있음
 max.col(fgl.mlogit.pred)
##  [1] 1 2 1 2 1 1 1 2 2 1 1 1 1 2 1 1 3 2 1 1 1 2 2 2 2 2 2 1 2 2 4 2 2 2 2 1 2 2
## [39] 5 2 2 1 2 2 1 2 1 3 2 2 1 5 4 5 5 5 5 4 6 1 5 4 6 6 6
  • 추출한 열의 인덱스에 대응되는 열이름을 선택하면 그 열이름이 예측범주가 됨
  • 이렇게 선택된 예측범주를 예측확률이 저장된 변수와 동일한 이름으로 저장함
  • 그러면 이 변수에는 더 이상 예측한 유의확률이 아니라 실제 예측범주가 저장됨
colnames(fgl.mlogit.pred)
## [1] "WinF"  "WinNF" "Veh"   "Con"   "Tabl"  "Head"
colnames(fgl.mlogit.pred)[max.col(fgl.mlogit.pred)]
##  [1] "WinF"  "WinNF" "WinF"  "WinNF" "WinF"  "WinF"  "WinF"  "WinNF" "WinNF"
## [10] "WinF"  "WinF"  "WinF"  "WinF"  "WinNF" "WinF"  "WinF"  "Veh"   "WinNF"
## [19] "WinF"  "WinF"  "WinF"  "WinNF" "WinNF" "WinNF" "WinNF" "WinNF" "WinNF"
## [28] "WinF"  "WinNF" "WinNF" "Con"   "WinNF" "WinNF" "WinNF" "WinNF" "WinF" 
## [37] "WinNF" "WinNF" "Tabl"  "WinNF" "WinNF" "WinF"  "WinNF" "WinNF" "WinF" 
## [46] "WinNF" "WinF"  "Veh"   "WinNF" "WinNF" "WinF"  "Tabl"  "Con"   "Tabl" 
## [55] "Tabl"  "Tabl"  "Tabl"  "Con"   "Head"  "WinF"  "Tabl"  "Con"   "Head" 
## [64] "Head"  "Head"
fgl.mlogit.pred <- colnames(fgl.mlogit.pred)[max.col(fgl.mlogit.pred)]
head(fgl.mlogit.pred)
## [1] "WinF"  "WinNF" "WinF"  "WinNF" "WinF"  "WinF"
  • 실제 유형과 예측유형 간의 혼동행렬 생성
table(fgl.test$type, 
      fgl.mlogit.pred, 
      dnn=c("Actual", "Predicted"))
##        Predicted
## Actual  Con Head Tabl Veh WinF WinNF
##   WinF    0    0    0   1   14     7
##   WinNF   1    0    1   0    3    17
##   Veh     0    0    0   1    3     3
##   Con     1    0    1   0    0     0
##   Tabl    0    0    4   0    0     0
##   Head    2    4    1   0    1     0
  • 결과: 생성된 혼동행렬이 부자연스러운 이유는 실제 유형 범주순서와 예측유형 범주순서가 서로 일치하지 않기 때문임. 출력된 범주순서를 동일하게 만들어야 함
  • factor()범주 출력 순서를 조정해 범주순서를 동일하게 만들어야 함
    • levels와 lables인수에 순서를 일치시키고자 하는 테스트데이터셋의 범주레벨을 지정함
table(fgl.test$type, 
      factor(fgl.mlogit.pred,
             levels=levels(fgl.test$type),
             labels=levels(fgl.test$type)),
      dnn=c("Actual", "Predicted"))
##        Predicted
## Actual  WinF WinNF Veh Con Tabl Head
##   WinF    14     7   1   0    0    0
##   WinNF    3    17   0   1    1    0
##   Veh      3     3   1   0    0    0
##   Con      0     0   0   1    1    0
##   Tabl     0     0   0   0    4    0
##   Head     1     0   0   2    1    4
  • 결과
    • 혼동행렬이 잘 생성되고, 실제 유형과 예측유형년간의 범주출력순서가 일치함
    • 혼돈행렬의 대각선 수치는 예측모델 위해서 정확히 예측된 빈도를 나타냄
  • 예측정확도 계산
mean(fgl.test$type == fgl.mlogit.pred)
## [1] 0.6307692
  • 결과: 예측정확도는 63.1% 정도로 계산됨
  • 교차검증
    • 좀 더 안정적인 성능평가를 위해 100개의 표본을 생성해 교차검증을 수행
    • 앞서와 마찬가지로 100개의 표본각각은 70% 훈련데이터와 30% 테스트데이터로 구성함
    • 먼저 교차검증 결과를 저장할 빈 숫자 벡터를 생성함
    • 100번의 루프를 돌며 훈련/테스트데이터 생성->모델생성->예측->예측정확도 계산작업을 수행함
      • 먼저 훈련데이터와 테스트데이터를 생성함
      • 그리고 모델을 생성함
      • 생성한 모델을 바탕으로 예측확률을 계산함
      • 그리고 예측확률을 예측범주로 변환함
      • 끝으로 예측정확도를 계산해 숫자벡터에 저장함
    • 100번의 루프를 돌리는 작업 수행
fgl.mlogit.cv <- numeric()
for (i in 1:100) {
  train <- sample(nrow(fgl), 0.7*nrow(fgl))
  fgl.train <- fgl.scaled[train,]
  fgl.test <- fgl.scaled[-train,]
  fgl.mlogit <- multinom(type ~ ., data=fgl.train)
  fgl.mlogit.pred <- predict(fgl.mlogit, newdata=fgl.test, type="probs")
  fgl.mlogit.pred <- colnames(fgl.mlogit.pred)[max.col(fgl.mlogit.pred)]
  fgl.mlogit.cv[i] <-  mean(fgl.test$type == fgl.mlogit.pred)
}
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 106.237110
## iter  20 value 85.497156
## iter  30 value 75.534881
## iter  40 value 72.682834
## iter  50 value 71.650532
## iter  60 value 70.869539
## iter  70 value 70.328520
## iter  80 value 69.752320
## iter  90 value 69.708451
## iter 100 value 69.706191
## final  value 69.706191 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 102.868859
## iter  20 value 79.253817
## iter  30 value 69.045282
## iter  40 value 65.342147
## iter  50 value 63.767411
## iter  60 value 63.574195
## iter  70 value 63.325357
## iter  80 value 63.254133
## iter  90 value 63.208271
## iter 100 value 63.205361
## final  value 63.205361 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 117.414490
## iter  20 value 91.202816
## iter  30 value 77.635322
## iter  40 value 75.433440
## iter  50 value 74.118263
## iter  60 value 74.032203
## iter  70 value 73.953516
## iter  80 value 73.946065
## final  value 73.946032 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 111.901539
## iter  20 value 93.994155
## iter  30 value 80.604880
## iter  40 value 79.201634
## iter  50 value 78.842195
## iter  60 value 78.762202
## iter  70 value 78.708928
## iter  80 value 78.693639
## iter  90 value 78.677426
## iter 100 value 78.676985
## final  value 78.676985 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 111.743373
## iter  20 value 86.891546
## iter  30 value 77.019286
## iter  40 value 74.786776
## iter  50 value 72.672161
## iter  60 value 71.952992
## iter  70 value 71.147763
## iter  80 value 70.634597
## iter  90 value 70.630140
## final  value 70.630109 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 110.674874
## iter  20 value 89.401936
## iter  30 value 79.144977
## iter  40 value 74.264362
## iter  50 value 73.501085
## iter  60 value 72.873874
## iter  70 value 72.625541
## iter  80 value 72.619157
## final  value 72.619049 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 109.127285
## iter  20 value 92.114248
## iter  30 value 81.013154
## iter  40 value 77.931815
## iter  50 value 76.242122
## iter  60 value 74.438350
## iter  70 value 74.369305
## iter  80 value 74.368027
## final  value 74.368022 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 111.578517
## iter  20 value 89.473280
## iter  30 value 76.850980
## iter  40 value 74.597902
## iter  50 value 73.193743
## iter  60 value 73.073692
## iter  70 value 72.946882
## iter  80 value 72.732922
## iter  90 value 72.724004
## iter 100 value 72.714157
## final  value 72.714157 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 113.810985
## iter  20 value 97.067567
## iter  30 value 86.296931
## iter  40 value 82.387621
## iter  50 value 76.979678
## iter  60 value 75.950893
## iter  70 value 75.836666
## iter  80 value 75.833604
## final  value 75.833448 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 118.614313
## iter  20 value 99.037969
## iter  30 value 88.442385
## iter  40 value 85.901997
## iter  50 value 84.615346
## iter  60 value 84.284708
## iter  70 value 83.834522
## iter  80 value 83.820641
## iter  90 value 83.819719
## iter  90 value 83.819718
## iter  90 value 83.819718
## final  value 83.819718 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 103.306683
## iter  20 value 85.362137
## iter  30 value 72.812560
## iter  40 value 66.753417
## iter  50 value 62.515994
## iter  60 value 61.673339
## iter  70 value 61.553732
## iter  80 value 61.430823
## iter  90 value 61.327296
## iter 100 value 61.219989
## final  value 61.219989 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 101.308686
## iter  20 value 76.649241
## iter  30 value 66.170107
## iter  40 value 62.490560
## iter  50 value 60.879452
## iter  60 value 60.495073
## iter  70 value 60.166753
## iter  80 value 60.154926
## final  value 60.154814 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 112.547208
## iter  20 value 93.621249
## iter  30 value 81.611336
## iter  40 value 78.487199
## iter  50 value 77.891136
## iter  60 value 77.358815
## iter  70 value 77.283807
## iter  80 value 77.281928
## final  value 77.281778 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 113.640417
## iter  20 value 98.226435
## iter  30 value 86.724317
## iter  40 value 84.710433
## iter  50 value 83.798148
## iter  60 value 83.417610
## iter  70 value 83.260109
## iter  80 value 83.160066
## iter  90 value 83.148930
## iter 100 value 83.100565
## final  value 83.100565 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 102.588010
## iter  20 value 82.207397
## iter  30 value 72.386681
## iter  40 value 68.273604
## iter  50 value 67.476262
## iter  60 value 66.954568
## iter  70 value 66.755371
## iter  80 value 66.748071
## iter  90 value 66.742875
## final  value 66.742842 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 118.135220
## iter  20 value 96.943434
## iter  30 value 83.217643
## iter  40 value 78.964215
## iter  50 value 77.041394
## iter  60 value 76.692134
## iter  70 value 76.367802
## iter  80 value 76.353407
## iter  90 value 76.352507
## final  value 76.352505 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 115.897497
## iter  20 value 98.462069
## iter  30 value 85.913820
## iter  40 value 83.256125
## iter  50 value 81.724191
## iter  60 value 80.877594
## iter  70 value 80.865256
## final  value 80.865201 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 111.616015
## iter  20 value 86.948870
## iter  30 value 79.167250
## iter  40 value 77.609382
## iter  50 value 77.366747
## iter  60 value 77.226234
## iter  70 value 77.221066
## iter  80 value 77.220864
## final  value 77.220710 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 99.988782
## iter  20 value 87.634528
## iter  30 value 80.073063
## iter  40 value 78.683497
## iter  50 value 78.503654
## iter  60 value 78.312467
## iter  70 value 78.276494
## iter  80 value 78.274429
## final  value 78.274413 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 112.553161
## iter  20 value 92.116991
## iter  30 value 81.423505
## iter  40 value 76.034775
## iter  50 value 74.846347
## iter  60 value 73.333724
## iter  70 value 72.804174
## iter  80 value 72.757048
## iter  90 value 72.756118
## final  value 72.756105 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 113.183003
## iter  20 value 92.041749
## iter  30 value 80.847200
## iter  40 value 78.770177
## iter  50 value 78.359424
## iter  60 value 78.274072
## iter  70 value 78.205875
## iter  80 value 78.185761
## iter  90 value 78.182349
## iter 100 value 78.179891
## final  value 78.179891 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 102.771624
## iter  20 value 91.445780
## iter  30 value 81.641386
## iter  40 value 78.974000
## iter  50 value 78.358258
## iter  60 value 78.100503
## iter  70 value 78.092235
## final  value 78.092186 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 119.204066
## iter  20 value 99.652341
## iter  30 value 87.940129
## iter  40 value 85.437046
## iter  50 value 84.160610
## iter  60 value 83.960860
## iter  70 value 83.955755
## final  value 83.955734 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 106.796917
## iter  20 value 88.056196
## iter  30 value 79.849540
## iter  40 value 76.834296
## iter  50 value 75.977136
## iter  60 value 75.768326
## iter  70 value 75.101550
## iter  80 value 73.251089
## iter  90 value 71.920955
## iter 100 value 71.575443
## final  value 71.575443 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 108.310401
## iter  20 value 91.631989
## iter  30 value 79.167128
## iter  40 value 77.318197
## iter  50 value 75.277259
## iter  60 value 75.107321
## iter  70 value 75.035181
## iter  80 value 74.926718
## iter  90 value 74.875500
## iter 100 value 74.831161
## final  value 74.831161 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 114.421331
## iter  20 value 90.900451
## iter  30 value 79.245566
## iter  40 value 77.463844
## iter  50 value 77.260272
## iter  60 value 77.019632
## iter  70 value 76.978880
## iter  80 value 76.978008
## final  value 76.978005 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 109.529868
## iter  20 value 82.397728
## iter  30 value 66.963717
## iter  40 value 61.411228
## iter  50 value 60.143826
## iter  60 value 59.792654
## iter  70 value 59.289475
## iter  80 value 59.248774
## iter  90 value 59.247251
## final  value 59.247245 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 109.184004
## iter  20 value 83.974556
## iter  30 value 74.866070
## iter  40 value 72.657805
## iter  50 value 71.285836
## iter  60 value 71.055374
## iter  70 value 70.801675
## iter  80 value 70.244520
## iter  90 value 69.785649
## iter 100 value 68.281023
## final  value 68.281023 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 113.427278
## iter  20 value 96.760211
## iter  30 value 84.673153
## iter  40 value 79.713791
## iter  50 value 78.073882
## iter  60 value 75.335634
## iter  70 value 72.577591
## iter  80 value 71.903272
## iter  90 value 71.740030
## iter 100 value 71.738477
## final  value 71.738477 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 99.870630
## iter  20 value 88.942047
## iter  30 value 82.833074
## iter  40 value 81.666392
## iter  50 value 81.070264
## iter  60 value 80.971103
## iter  70 value 80.715113
## iter  80 value 79.751923
## iter  90 value 76.276205
## iter 100 value 76.191704
## final  value 76.191704 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 114.652009
## iter  20 value 89.897796
## iter  30 value 75.885188
## iter  40 value 72.828934
## iter  50 value 72.050696
## iter  60 value 71.613134
## iter  70 value 71.418778
## iter  80 value 71.413821
## final  value 71.413798 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 110.895233
## iter  20 value 83.637523
## iter  30 value 72.002443
## iter  40 value 69.213639
## iter  50 value 68.442980
## iter  60 value 68.021717
## iter  70 value 67.970072
## iter  80 value 67.967799
## final  value 67.967775 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 110.129881
## iter  20 value 84.845108
## iter  30 value 73.625308
## iter  40 value 72.376437
## iter  50 value 71.628884
## iter  60 value 71.574012
## iter  70 value 71.537064
## iter  80 value 71.441317
## iter  90 value 71.414599
## iter 100 value 71.411586
## final  value 71.411586 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 118.978974
## iter  20 value 99.434471
## iter  30 value 86.967202
## iter  40 value 84.539363
## iter  50 value 84.081714
## iter  60 value 84.034512
## iter  70 value 84.015332
## iter  80 value 84.011916
## final  value 84.011842 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 119.013694
## iter  20 value 103.794042
## iter  30 value 95.711253
## iter  40 value 92.587051
## iter  50 value 92.053272
## iter  60 value 91.608057
## iter  70 value 91.558155
## iter  80 value 91.548294
## iter  90 value 91.532656
## iter 100 value 91.520833
## final  value 91.520833 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 108.209431
## iter  20 value 91.229786
## iter  30 value 82.124884
## iter  40 value 79.026342
## iter  50 value 78.533532
## iter  60 value 78.177283
## iter  70 value 77.985251
## iter  80 value 77.956354
## iter  90 value 77.913266
## iter 100 value 77.888900
## final  value 77.888900 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 117.094361
## iter  20 value 102.898834
## iter  30 value 89.431945
## iter  40 value 85.252013
## iter  50 value 84.050231
## iter  60 value 81.950144
## iter  70 value 81.884836
## iter  80 value 81.883347
## final  value 81.883338 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 114.232837
## iter  20 value 97.783895
## iter  30 value 86.176279
## iter  40 value 82.608968
## iter  50 value 82.149487
## iter  60 value 81.482343
## iter  70 value 80.570496
## iter  80 value 80.442556
## iter  90 value 80.437315
## final  value 80.437232 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 106.056848
## iter  20 value 85.207085
## iter  30 value 74.804852
## iter  40 value 69.603075
## iter  50 value 66.784677
## iter  60 value 64.807193
## iter  70 value 64.137868
## iter  80 value 63.742802
## iter  90 value 63.708671
## iter 100 value 63.708346
## final  value 63.708346 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 109.877096
## iter  20 value 92.720626
## iter  30 value 83.053829
## iter  40 value 81.172325
## iter  50 value 80.998294
## iter  60 value 80.822298
## iter  70 value 80.813127
## final  value 80.813041 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 114.502649
## iter  20 value 92.378423
## iter  30 value 83.685318
## iter  40 value 79.729853
## iter  50 value 79.325187
## iter  60 value 79.112083
## iter  70 value 78.971652
## iter  80 value 78.940456
## iter  90 value 78.932338
## iter 100 value 78.918429
## final  value 78.918429 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 109.559294
## iter  20 value 93.464582
## iter  30 value 81.772361
## iter  40 value 79.365624
## iter  50 value 78.727980
## iter  60 value 78.452809
## iter  70 value 78.393804
## iter  80 value 78.392962
## final  value 78.392959 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 109.241181
## iter  20 value 84.712616
## iter  30 value 67.794646
## iter  40 value 65.099258
## iter  50 value 61.875353
## iter  60 value 61.800640
## iter  70 value 61.793104
## iter  80 value 61.791492
## iter  90 value 61.789643
## iter 100 value 61.785452
## final  value 61.785452 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 100.042039
## iter  20 value 87.268700
## iter  30 value 80.094242
## iter  40 value 79.252313
## iter  50 value 78.944424
## iter  60 value 78.818228
## iter  70 value 78.793742
## iter  80 value 78.793098
## iter  80 value 78.793098
## iter  80 value 78.793098
## final  value 78.793098 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 121.760177
## iter  20 value 103.045972
## iter  30 value 93.120436
## iter  40 value 90.380214
## iter  50 value 90.188863
## iter  60 value 89.901340
## iter  70 value 89.846075
## iter  80 value 89.826163
## iter  90 value 89.807819
## iter 100 value 89.796522
## final  value 89.796522 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 114.329565
## iter  20 value 93.676258
## iter  30 value 78.731725
## iter  40 value 76.515813
## iter  50 value 75.932313
## iter  60 value 75.315832
## iter  70 value 75.175693
## iter  80 value 75.143349
## iter  90 value 75.142550
## iter 100 value 75.141194
## final  value 75.141194 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 106.555216
## iter  20 value 81.700851
## iter  30 value 70.413170
## iter  40 value 67.960654
## iter  50 value 67.170418
## iter  60 value 66.933914
## iter  70 value 66.886880
## iter  80 value 66.844538
## iter  90 value 66.821765
## iter 100 value 66.821224
## final  value 66.821224 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 106.724042
## iter  20 value 90.108723
## iter  30 value 83.402662
## iter  40 value 81.347789
## iter  50 value 80.221287
## iter  60 value 78.977814
## iter  70 value 77.017438
## iter  80 value 76.871815
## iter  90 value 76.870697
## final  value 76.870695 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 110.405304
## iter  20 value 86.418503
## iter  30 value 75.530019
## iter  40 value 73.529622
## iter  50 value 72.040646
## iter  60 value 71.843861
## iter  70 value 71.673494
## iter  80 value 71.656475
## iter  90 value 71.653153
## final  value 71.653129 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 108.427410
## iter  20 value 93.644508
## iter  30 value 83.221887
## iter  40 value 80.162580
## iter  50 value 79.522608
## iter  60 value 79.010640
## iter  70 value 78.897023
## iter  80 value 78.895888
## final  value 78.895832 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 112.243132
## iter  20 value 95.990301
## iter  30 value 86.095853
## iter  40 value 83.185089
## iter  50 value 81.152478
## iter  60 value 79.590541
## iter  70 value 77.383530
## iter  80 value 77.108649
## iter  90 value 77.103067
## final  value 77.103040 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 110.932481
## iter  20 value 92.315911
## iter  30 value 80.395344
## iter  40 value 74.678908
## iter  50 value 74.050540
## iter  60 value 73.468600
## iter  70 value 72.938078
## iter  80 value 72.781476
## iter  90 value 72.654109
## iter 100 value 72.459978
## final  value 72.459978 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 108.553377
## iter  20 value 90.217498
## iter  30 value 78.410126
## iter  40 value 77.262527
## iter  50 value 76.639272
## iter  60 value 76.569500
## iter  70 value 76.563915
## iter  80 value 76.562730
## final  value 76.562686 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 113.007482
## iter  20 value 96.736013
## iter  30 value 89.591419
## iter  40 value 88.188009
## iter  50 value 87.804005
## iter  60 value 87.725147
## iter  70 value 87.683130
## iter  80 value 87.681259
## final  value 87.681256 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 108.339514
## iter  20 value 94.015326
## iter  30 value 82.000887
## iter  40 value 79.645253
## iter  50 value 78.388742
## iter  60 value 77.632267
## iter  70 value 77.620626
## iter  80 value 77.620014
## final  value 77.620012 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 103.908583
## iter  20 value 79.059743
## iter  30 value 70.600729
## iter  40 value 68.527057
## iter  50 value 68.169936
## iter  60 value 67.861157
## iter  70 value 67.734338
## iter  80 value 67.727665
## iter  90 value 67.724771
## final  value 67.724762 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 103.400377
## iter  20 value 87.048614
## iter  30 value 78.071695
## iter  40 value 76.368293
## iter  50 value 76.109063
## iter  60 value 76.032179
## iter  70 value 76.030060
## final  value 76.030049 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 113.666573
## iter  20 value 99.244302
## iter  30 value 87.420912
## iter  40 value 83.982066
## iter  50 value 82.192003
## iter  60 value 79.893702
## iter  70 value 77.786202
## iter  80 value 77.766694
## final  value 77.766633 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 98.631701
## iter  20 value 86.151327
## iter  30 value 75.634914
## iter  40 value 73.359728
## iter  50 value 72.822614
## iter  60 value 72.447694
## iter  70 value 72.431775
## iter  80 value 72.431511
## final  value 72.431509 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 106.585843
## iter  20 value 84.152198
## iter  30 value 75.886824
## iter  40 value 73.206782
## iter  50 value 71.397131
## iter  60 value 70.316145
## iter  70 value 67.175679
## iter  80 value 66.815491
## iter  90 value 66.811413
## final  value 66.811373 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 118.832533
## iter  20 value 100.154801
## iter  30 value 91.371556
## iter  40 value 85.273571
## iter  50 value 83.157001
## iter  60 value 80.703390
## iter  70 value 80.157687
## iter  80 value 80.143169
## iter  90 value 80.142891
## iter  90 value 80.142890
## iter  90 value 80.142890
## final  value 80.142890 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 103.620390
## iter  20 value 89.130483
## iter  30 value 79.906000
## iter  40 value 78.513813
## iter  50 value 77.867617
## iter  60 value 77.724417
## iter  70 value 77.676166
## iter  80 value 77.643253
## iter  90 value 77.637971
## iter 100 value 77.634407
## final  value 77.634407 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 108.166428
## iter  20 value 87.345384
## iter  30 value 74.388780
## iter  40 value 70.307100
## iter  50 value 68.818269
## iter  60 value 67.203536
## iter  70 value 65.763380
## iter  80 value 65.543446
## iter  90 value 65.520806
## iter 100 value 65.518054
## final  value 65.518054 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 113.285695
## iter  20 value 93.121365
## iter  30 value 81.875479
## iter  40 value 78.960096
## iter  50 value 77.823962
## iter  60 value 77.375683
## iter  70 value 77.341882
## iter  80 value 77.340643
## final  value 77.340624 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 110.889655
## iter  20 value 95.930510
## iter  30 value 87.281572
## iter  40 value 84.261917
## iter  50 value 82.018344
## iter  60 value 80.845191
## iter  70 value 80.829189
## final  value 80.829108 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 113.554640
## iter  20 value 94.941121
## iter  30 value 84.860261
## iter  40 value 82.472305
## iter  50 value 80.405900
## iter  60 value 79.684578
## iter  70 value 78.875035
## iter  80 value 77.357606
## iter  90 value 75.490651
## iter 100 value 75.479091
## final  value 75.479091 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 108.714221
## iter  20 value 89.434012
## iter  30 value 78.505686
## iter  40 value 73.288119
## iter  50 value 71.909485
## iter  60 value 71.700725
## iter  70 value 71.696921
## final  value 71.696750 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 103.111113
## iter  20 value 87.718548
## iter  30 value 78.046836
## iter  40 value 75.846631
## iter  50 value 75.395504
## iter  60 value 75.222799
## iter  70 value 75.220071
## final  value 75.220021 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 114.377461
## iter  20 value 95.475592
## iter  30 value 80.804003
## iter  40 value 78.846302
## iter  50 value 78.274950
## iter  60 value 78.110568
## iter  70 value 78.088038
## iter  80 value 78.086725
## final  value 78.086722 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 109.047103
## iter  20 value 95.076435
## iter  30 value 85.100136
## iter  40 value 82.573288
## iter  50 value 81.724148
## iter  60 value 80.303946
## iter  70 value 80.046455
## iter  80 value 80.037775
## final  value 80.037650 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 109.885705
## iter  20 value 97.600935
## iter  30 value 85.010133
## iter  40 value 81.740820
## iter  50 value 80.494033
## iter  60 value 80.006639
## iter  70 value 79.985036
## iter  80 value 79.984635
## iter  80 value 79.984634
## iter  80 value 79.984634
## final  value 79.984634 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 104.046864
## iter  20 value 85.448335
## iter  30 value 73.826948
## iter  40 value 71.882321
## iter  50 value 71.723566
## iter  60 value 71.546125
## iter  70 value 71.401442
## iter  80 value 71.348489
## iter  90 value 71.345972
## final  value 71.345611 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 106.421637
## iter  20 value 89.263320
## iter  30 value 80.771150
## iter  40 value 77.286711
## iter  50 value 73.932108
## iter  60 value 70.847136
## iter  70 value 69.388497
## iter  80 value 69.370474
## final  value 69.370367 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 108.276276
## iter  20 value 92.260268
## iter  30 value 82.925370
## iter  40 value 80.418213
## iter  50 value 79.949677
## iter  60 value 79.554407
## iter  70 value 79.544501
## final  value 79.544211 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 107.197444
## iter  20 value 92.725232
## iter  30 value 82.250465
## iter  40 value 78.468889
## iter  50 value 76.349944
## iter  60 value 75.023418
## iter  70 value 74.397127
## iter  80 value 74.365816
## iter  90 value 74.365214
## iter  90 value 74.365213
## iter  90 value 74.365213
## final  value 74.365213 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 114.393510
## iter  20 value 96.824011
## iter  30 value 82.956168
## iter  40 value 81.414750
## iter  50 value 80.375495
## iter  60 value 80.132843
## iter  70 value 79.964101
## iter  80 value 79.956992
## final  value 79.956945 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 111.539525
## iter  20 value 89.588201
## iter  30 value 80.121191
## iter  40 value 75.919458
## iter  50 value 75.044981
## iter  60 value 73.945793
## iter  70 value 73.388596
## iter  80 value 73.366783
## iter  90 value 73.361937
## iter 100 value 73.361277
## final  value 73.361277 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 111.659583
## iter  20 value 88.546844
## iter  30 value 77.166323
## iter  40 value 73.358533
## iter  50 value 70.440859
## iter  60 value 70.104681
## iter  70 value 69.914151
## iter  80 value 69.844705
## iter  90 value 69.841288
## final  value 69.841274 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 106.109418
## iter  20 value 88.136923
## iter  30 value 81.751362
## iter  40 value 78.908201
## iter  50 value 77.549684
## iter  60 value 75.739793
## iter  70 value 73.681045
## iter  80 value 73.644420
## iter  90 value 73.644157
## iter  90 value 73.644157
## iter  90 value 73.644157
## final  value 73.644157 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 108.834940
## iter  20 value 92.904347
## iter  30 value 78.910443
## iter  40 value 72.955136
## iter  50 value 70.300884
## iter  60 value 67.302888
## iter  70 value 67.165442
## iter  80 value 67.163892
## final  value 67.163878 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 105.898556
## iter  20 value 83.572466
## iter  30 value 72.834885
## iter  40 value 65.423939
## iter  50 value 63.355807
## iter  60 value 60.364799
## iter  70 value 60.179742
## iter  80 value 60.116301
## iter  90 value 60.113604
## final  value 60.113595 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 103.026402
## iter  20 value 84.901359
## iter  30 value 76.641830
## iter  40 value 74.293284
## iter  50 value 73.646947
## iter  60 value 73.100368
## iter  70 value 73.076410
## final  value 73.076160 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 115.050870
## iter  20 value 89.213388
## iter  30 value 79.470695
## iter  40 value 74.990960
## iter  50 value 73.233677
## iter  60 value 72.327003
## iter  70 value 71.653127
## iter  80 value 71.463471
## iter  90 value 71.314456
## iter 100 value 71.122634
## final  value 71.122634 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 108.650756
## iter  20 value 94.696403
## iter  30 value 87.466736
## iter  40 value 84.707009
## iter  50 value 83.332745
## iter  60 value 82.809508
## iter  70 value 82.758117
## iter  80 value 82.611927
## iter  90 value 82.543422
## iter 100 value 82.542280
## final  value 82.542280 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 104.863290
## iter  20 value 79.813464
## iter  30 value 70.767185
## iter  40 value 68.214571
## iter  50 value 67.913706
## iter  60 value 67.743541
## iter  70 value 67.685024
## iter  80 value 67.683153
## iter  90 value 67.682749
## final  value 67.682747 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 109.968202
## iter  20 value 91.927186
## iter  30 value 86.209894
## iter  40 value 81.847332
## iter  50 value 79.865441
## iter  60 value 78.752796
## iter  70 value 78.357098
## iter  80 value 78.236842
## iter  90 value 77.843367
## iter 100 value 77.779479
## final  value 77.779479 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 107.682854
## iter  20 value 86.790961
## iter  30 value 75.867370
## iter  40 value 73.214932
## iter  50 value 72.461292
## iter  60 value 72.283360
## iter  70 value 72.113912
## iter  80 value 72.083625
## iter  90 value 72.082603
## final  value 72.082594 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 116.921748
## iter  20 value 101.187423
## iter  30 value 87.835095
## iter  40 value 85.738123
## iter  50 value 83.031628
## iter  60 value 82.406848
## iter  70 value 80.934453
## iter  80 value 80.875106
## iter  90 value 80.873874
## final  value 80.873870 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 110.068439
## iter  20 value 87.184183
## iter  30 value 79.867598
## iter  40 value 77.589042
## iter  50 value 76.646935
## iter  60 value 76.490185
## iter  70 value 76.466830
## iter  80 value 76.415050
## iter  90 value 76.404695
## iter 100 value 76.401385
## final  value 76.401385 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 109.623554
## iter  20 value 91.060961
## iter  30 value 80.067669
## iter  40 value 77.719791
## iter  50 value 76.082790
## iter  60 value 74.725559
## iter  70 value 73.875335
## iter  80 value 72.720678
## iter  90 value 72.618708
## iter 100 value 72.617987
## final  value 72.617987 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 100.001774
## iter  20 value 76.976281
## iter  30 value 69.213245
## iter  40 value 66.822304
## iter  50 value 66.210110
## iter  60 value 65.799545
## iter  70 value 65.663015
## iter  80 value 65.655710
## final  value 65.655612 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 113.603020
## iter  20 value 92.145147
## iter  30 value 81.551488
## iter  40 value 79.272103
## iter  50 value 78.999120
## iter  60 value 78.658711
## iter  70 value 78.628566
## iter  80 value 78.627897
## final  value 78.627894 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 115.099585
## iter  20 value 99.994099
## iter  30 value 89.280915
## iter  40 value 87.746722
## iter  50 value 87.354016
## iter  60 value 87.100266
## iter  70 value 87.056230
## iter  80 value 87.012946
## iter  90 value 86.971739
## iter 100 value 86.948430
## final  value 86.948430 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 105.887167
## iter  20 value 89.587226
## iter  30 value 75.987140
## iter  40 value 71.028283
## iter  50 value 68.016737
## iter  60 value 67.821283
## iter  70 value 67.788172
## iter  80 value 67.784768
## final  value 67.784732 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 111.373241
## iter  20 value 92.412739
## iter  30 value 76.031895
## iter  40 value 72.635588
## iter  50 value 72.179988
## iter  60 value 71.391441
## iter  70 value 71.346763
## iter  80 value 71.343389
## final  value 71.343350 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 101.634569
## iter  20 value 78.435994
## iter  30 value 68.582971
## iter  40 value 67.243393
## iter  50 value 66.424862
## iter  60 value 66.312273
## iter  70 value 66.224174
## iter  80 value 66.209791
## iter  90 value 66.207192
## final  value 66.207118 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 114.649626
## iter  20 value 92.414928
## iter  30 value 82.313675
## iter  40 value 78.431277
## iter  50 value 76.640416
## iter  60 value 75.724242
## iter  70 value 74.867939
## iter  80 value 74.258564
## iter  90 value 74.111799
## iter 100 value 74.002829
## final  value 74.002829 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 119.107212
## iter  20 value 101.659353
## iter  30 value 91.150332
## iter  40 value 86.679196
## iter  50 value 86.043970
## iter  60 value 85.037744
## iter  70 value 84.681229
## iter  80 value 84.349387
## iter  90 value 84.191268
## iter 100 value 84.095293
## final  value 84.095293 
## stopped after 100 iterations
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 104.796041
## iter  20 value 85.624440
## iter  30 value 75.211443
## iter  40 value 73.502666
## iter  50 value 73.066401
## iter  60 value 72.464563
## iter  70 value 72.371453
## iter  80 value 72.364141
## final  value 72.363367 
## converged
## # weights:  66 (50 variable)
## initial  value 266.972161 
## iter  10 value 108.156434
## iter  20 value 85.381992
## iter  30 value 76.609082
## iter  40 value 74.697503
## iter  50 value 74.119854
## iter  60 value 73.941301
## iter  70 value 73.937328
## final  value 73.937305 
## converged
fgl.mlogit.cv
##   [1] 0.5846154 0.5846154 0.7076923 0.6153846 0.6153846 0.6769231 0.6000000
##   [8] 0.6000000 0.6615385 0.6461538 0.5846154 0.6153846 0.6615385 0.6153846
##  [15] 0.5846154 0.5538462 0.6307692 0.5846154 0.5384615 0.6461538 0.4307692
##  [22] 0.6769231 0.6923077 0.5846154 0.6307692 0.6153846 0.5846154 0.5538462
##  [29] 0.6000000 0.5692308 0.6461538 0.5846154 0.6769231 0.6153846 0.7538462
##  [36] 0.5692308 0.6769231 0.6153846 0.5692308 0.5538462 0.6000000 0.6307692
##  [43] 0.6153846 0.5384615 0.6307692 0.5538462 0.6000000 0.5230769 0.5846154
##  [50] 0.5230769 0.6461538 0.6615385 0.6000000 0.6923077 0.5692308 0.5538462
##  [57] 0.5846154 0.6461538 0.5692308 0.6153846 0.7384615 0.6153846 0.5538462
##  [64] 0.6000000 0.5692308 0.6307692 0.5538462 0.6461538 0.6153846 0.6000000
##  [71] 0.6153846 0.4615385 0.6769231 0.6307692 0.6000000 0.6923077 0.6307692
##  [78] 0.6153846 0.6153846 0.5538462 0.5692308 0.6615385 0.5384615 0.5846154
##  [85] 0.6000000 0.6615385 0.6153846 0.6307692 0.6769231 0.6461538 0.5538462
##  [92] 0.5384615 0.7076923 0.7076923 0.5384615 0.5692308 0.6153846 0.6769231
##  [99] 0.5076923 0.6307692
summary(fgl.mlogit.cv)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##  0.4308  0.5692  0.6154  0.6089  0.6462  0.7538
  • 결과
    • 100개의 예측 정확도가 저장됐고, 요약통계량이 산출됨
    • 최소 46.1% 에서 최대 72.3% 까지 예측정확도가 나옴
    • 평균적으로 61% 정도의 예측 정확도를 보여줌
  • 이를 그래프로 시각화함
boxplot(fgl.mlogit.cv, horizontal=TRUE, 
        col="tomato", xlab="Accuracy", 
        main="Accuracy for Forensic Glass (100 samples)")
  • 결과: 예측정확도에 분포를 상자도표로 표현함

 

 

'R programming > 통계데이터분석' 카테고리의 다른 글

[R/통계] 37.차원분석 - 주성분분석(PCA) 🔑 principal component analysis | 차원축소 | 성분 | 주성분은 변수들의 선형결합으로 표현  (0) 2022.11.06
[R/통계] 36.포아송회귀분석 🔑 Poisson regression analysis | 사건발생횟수(또는 개수) | 포아송분포 | 과산포  (0) 2022.10.22
[R/통계] 34.일반선형모델 - 페널티 로지스틱회귀분석(ridge, lasso, elasticnet) 🔑 penalized regression analysis | 라소 | 릿지  (0) 2022.10.11
[R/통계] 32.일반선형모델 - 이항 로지스틱회귀분석 🔑 binomial logistic regression analysis | 이분형 범주 | 로그오즈(log odds)  (0) 2022.10.11
[R/통계] 31.일반선형모델 - 개요 🔑 generalized linear model | 범주 횟수 | 링크함수(link function) | 로지스틱회귀분석 | 포아송회귀분석  (0) 2022.09.29

+ Recent posts

티스토리툴바