Python으로 빈도표 만들기 (Pandas Crosstab)

파이썬에서 빈도표(Frequency Table)를 만드는 방법은 여러가지가 있지만, 그 중 하나가 pandas의 crosstab 함수를 이용하는 방법이다. 아래처럼 dataframe의 컬럼(Series 데이터타입)을 파라미터로 넘겨주면 빈도표를 만들어준다.

import pandas as pd

raw_data = {'regiment': ['Nighthawks', 'Nighthawks', 'Nighthawks', 'Nighthawks', 'Dragoons', 'Dragoons', 'Dragoons', 'Dragoons', 'Scouts', 'Scouts', 'Scouts', 'Scouts'], 
        'company': ['infantry', 'infantry', 'cavalry', 'cavalry', 'infantry', 'infantry', 'cavalry', 'cavalry','infantry', 'infantry', 'cavalry', 'cavalry'], 
        'experience': ['veteran', 'rookie', 'veteran', 'rookie', 'veteran', 'rookie', 'veteran', 'rookie','veteran', 'rookie', 'veteran', 'rookie'],
        'name': ['Miller', 'Jacobson', 'Ali', 'Milner', 'Cooze', 'Jacon', 'Ryaner', 'Sone', 'Sloan', 'Piger', 'Riani', 'Ali'], 
        'preTestScore': [4, 24, 31, 2, 3, 4, 24, 31, 2, 3, 2, 3],
        'postTestScore': [25, 94, 57, 62, 70, 25, 94, 57, 62, 70, 62, 70]}
df = pd.DataFrame(raw_data, columns = ['regiment', 'company', 'experience', 'name', 'preTestScore', 'postTestScore'])
df

2x2 테이블

regiment를 기준으로 하여 company의 빈도를 구한다.

pd.crosstab(df.regiment, df.company, margins=True)

변수 3개 테이블

company, experience를 기준으로하여 regiment의 빈도를 구한다.

pd.crosstab([df.company, df.experience], df.regiment,  margins=True)

만들어진 crosstab에 접근하는법

crosstab을 통해 생성한 객체는 dataframe 타입이고, regiment를 제외한 company와 experience는 multi index로 지정되어있다. 따라서 인덱스 값으로 해당 인덱스의 원소값을 얻는 loc 함수를 통해 crosstab 원소에 접근할 수 있다.

cross_tab = pd.crosstab([df.company, df.experience], df.regiment,  margins=True)
cross_tab.loc[[('cavalry', 'rookie')]]

참고

https://chrisalbon.com/python/pandas_crosstabs.html

R 언어의 중요한 기초 개념 정리 

Vectorization

d <- 1:5

d.r <- c(2,1,4,5,3)

d-d.r # -1 1 -1 -1 2 (element-wise operation)

d-mean(d) # -2 -1 0 1 2 (평균인 3이 5개인 vector를 알아서 만들어서 element-wise operation을 수행한다.)

x <- c(2,3,5,7,11)

var(x) # 12.8

* 분산을 구하는 코드를 작성할 때, 일반적인 프로그래밍이라면 벡터안에 있는 원소의 수 만큼 for문을 돌면서 평균을 구하고 분산을 구한다. 하지만 R의 경우 일반적인 프로그래밍처럼 구하지 않는다. 우선, R에서 for문을 사용하는것은 좋지 않다. R은 C로 구현되었는데 for문으로 계속 연산을 실행하면 이 연산 실행하는 수만큼 C 컴파일러와 정보를 주고받는다.

xbar = mean(x)

numer = sum((x-xbar)^2)

n=length(x)

variance = numer/(n-1)

따라서 위와같이 벡터단위로 함수를 실행하여 구하는 게 일반적이고, 효율적인 방법이다.

HELP

객체의 정보를 알아보기 위해 help 함수를 활용하자.

help("mean")

help.search("mean")

apropos("mean") # mean이 포함된 함수를 모두 출력

데이터 구조와 접근법 개요

Series

1:10 # 1 2 3 ... 10

Arithmetic Series

seq(1,9,by=2) # 1,3,5,7,9

seq(1,9,length=5) # 1,3,5,7,9 (1,9를 처음과 끝으로 하여 5개의 수를 만든다.)

Repeated Vector

rep(1,10) # 1 1 1 1 1.... 1

rep(1:3, 3) # 1 2 3 1 2 3 1 2 3

rep(1:3, each=3) # 1 1 1 2 2 2 3 3 3

Assessing data with index (만든 데이터의 원소를 어떻게 불러오나)

d <- 1:5

d[2] # 2

d[1:3] # 1 2 3

d[c(1,3,5)] # 1 3 5

Negaive Index

d[-1] # 2 3 4 5

d[-c(4:5)] # 1 2 3

Replace data

d[1] <- 10

d # 10 2 3 4 5

d[1:3] <- c(10,20,30)

d # 10 20 30 4 5

Get data from logical value

d <- c(1,2,3,4,5)

d > 3.5 # FALSE FALSE FALSE TRUE TRUE

which(d>3.5) # 4 5

d[c>3.5] # 4 5 (TRUE인 원소만 값을 불러온다.)

NA

a <- c(0,1,0,NA,0,0)

a > 0 # FALSE TRUE FALSE NA FALSE FALSE (NA는 어떤 수학적인 연산을 할 수 없다.)

is.na(a) # FALSE FALSE FALSE TRUE FALSE FALSE

mean(a) # NA

mean(a, na.rm=TRUE) # 0.2

Data Type

vector, matrix, array, data.frame, list 5개가 있다.

* matrix와 vector는 비슷하다.

x <- 1:10

attr(x, 'dim') <- c(2,5)

attributes(x) # $dim [1] 2 5

x # 2x5 matrix가 된다.

class(x) # matrix

dim(x) # 2 5

* 따라서 matrix는 vector에 dimension이 추가된 것으로 볼 수 있다.

* 또한 vector는 원소의 타입이 다 같아야한다. 이는 matrix와 array도 마찬가지이다.

* dataframe와 list는 "데이터를 폴더형태로 모아놓은 환경" 이라고 볼 수 있다. 근데 차이는 dataframe은 데이터들의 길이가 같아야하고 list는 데이터의 길이에서 자유롭다. 

* R에서 $는 무엇인가? 서로 다른 환경에 접근할 때 $라는 기호를 사용한다. 예를 들어 datat$var 과 같이 data라는 dataframe 내의 var라는 환경에 접근할 수 있다. 이는 list도 마찬가지이다.

x <- data.frame(a=1:10)

x$b <- 11:20 # 해당 컬럼에 값 할당

x$c <- rep(c('a','b'),5)) 

x$c <- as.factor(x$c) # 이렇게하면 factor로 변경된다.

* 처음 dataframe을 생성하고 변수값을 초기화할 때 string vector를 지정하면 그 string들은 자동으로 factor로 변환된다. 이 때, stringAsFactors=F로해야지 자동으로 factor로 변하지 않고 string으로 저장된다.

class(x) <- NULL

class(x) # list

으로 만들면, x의 class는 list가 된다.

Attach

search()

현재 존재하는 모든 공간을 나타내준다.

attach(x)

이러고 만약 x가 데이터프레임이고 a라는 컬럼이 있다면, 커맨드에 a만쳐도 a 컬럼에 있는 데이터에 접근할 수 있다. 만약 매번 x$a로 접근하는 것이 불편하다면 attach(x)를 통해 서치 공간에 a 컬럼을 추가할 수 있다.

detach(x)

서치공간에서 x를 제거한다.

Data Export

write.table(data, 'x.txt', sep='\t', quote=F, col.names=F, row.names=F) # quote는 문자열에 기본적으로 "를 넣을 것인가? col.names와 row.names는 각각 컬럼 이름과 로우 이름을 출력할지 말지를 나타낸다. 저장되는 위치는 getwd를 통해 알 수 있으며, setwd를 통해 현재 작업디렉토리를 변경할 수 있다.

Data Import

scan(file='a.txt') # (권장하지 않음)

read.table('a.txt', header=TRUE) # 일반적으로 이렇게 읽으며, 데이터프레임으로 읽는다. 또한, 문자열은 자동으로 factor로 변환한다.

만약 데이터를 임포트할 때, 경로를 찾기가 귀찮다면, file.choose()를 이용한다. 그러면 파일 탐색기 창이 뜨고 여기서 파일을 클릭하면 자동으로 해당 경로가 문자열로 나타나게 된다.

함수

f <- function(x, y) {

return(x+y)

}

R의 함수의 기본 문법은 위와 같다. 함수의 종류에도 여러개가 있는데 그 중 하나가 제네릭 함수이다. 예를 들어, summary(f)를 하면 그 함수에 대한 설명이 나온다. 반면, summary(c(1,2,3,4,5))를 하면, 해당 벡터를 연속형 변수로 치고 분포 관련 정보를 보여주게된다. 이는 methods(summary)를 통해 알 수 있다.

> methods(summary)
 [1] summary.aov                    summary.aovlist*             
 [3] summary.aspell*                summary.check_packages_in_dir*
 [5] summary.connection             summary.data.frame           
 [7] summary.Date                   summary.default              
 [9] summary.ecdf*                  summary.factor               
[11] summary.glm                    summary.infl*                
[13] summary.lm                     summary.loess*               
[15] summary.manova                 summary.matrix               
[17] summary.mlm*                   summary.nls*                 
[19] summary.packageStatus*         summary.PDF_Dictionary*      
[21] summary.PDF_Stream*            summary.POSIXct              
[23] summary.POSIXlt                summary.ppr*                 
[25] summary.prcomp*                summary.princomp*            
[27] summary.proc_time              summary.srcfile              
[29] summary.srcref                 summary.stepfun              
[31] summary.stl*                   summary.table                
[33] summary.tukeysmooth*         

이렇게 입력 클래스로 무엇이 들어오느냐에 따라 다른 실행을 한다. lm 클래스가 들어오면, 회귀분석 결과에 관한 요약을 해주고, aov가 들어오면 분산분석 결과에 관한 요약을 해준다.

히스토그램 그리기

x <- rnorm(5000, 1, 5000) # 임의 데이터 생성

> dd <- hist(x)
> class(dd)
[1] "histogram"
 
class(dd) <- NULL # 클래스를 NULL로 바꾸면 dd가 list가 된다.
dd # 이 dd 안에는 histogram을 그리기 위한 정보들이 들어있다.

$breaks
 [1] -18000 -16000 -14000 -12000 -10000  -8000  -6000  -4000  -2000      0
[11]   2000   4000   6000   8000  10000  12000  14000  16000  18000  20000

$counts
 [1]   4   9  33  75 155 269 512 665 763 803 619 526 292 156  79  29   8   2
[19]   1

$density
 [1] 4.00e-07 9.00e-07 3.30e-06 7.50e-06 1.55e-05 2.69e-05 5.12e-05 6.65e-05
 [9] 7.63e-05 8.03e-05 6.19e-05 5.26e-05 2.92e-05 1.56e-05 7.90e-06 2.90e-06
[17] 8.00e-07 2.00e-07 1.00e-07

$mids
 [1] -17000 -15000 -13000 -11000  -9000  -7000  -5000  -3000  -1000   1000
[11]   3000   5000   7000   9000  11000  13000  15000  17000  19000

$xname
[1] "x"

$equidist
[1] TRUE

SAS - 산점도와 히스토그램

descriptive analysis에서 변수별로 기본적으로 해보는 것이 바로 산점도와 히스토그램이라고 할 수 있습니다. 산점도는 두 변수의 관계를 파악할 때 쓰이며, 히스토그램은 한 변수의 분포를 알아보기 위해 쓰입니다. 이번 포스팅에서는 SAS로 산점도와 히스토그램을 그리는 법을 정리해보았습니다.

기본 산점도

proc gplot data=data;
    plot var1*var2;
run;

• 기본 산점도는 위와 같이 간단하게 구할 수 있습니다. 근데 분석을 하다보면, 산점도를 그려도 두 변수의 관계가 확실히 보이지 않을 때가 있습니다. 이 경우에는 선형 회귀 선을 함께 그림으로써 그 경향성을 더욱 잘 파악할 수 있는데요. 링크 에는 산점도와 함께 선형회귀선을 그리는 코드를 보여주고 있습니다.
  

산점도 with 선형회귀선

ods graphics off;
proc reg data=data;
   model y= x;
   ods output ParameterEstimates=PE;
run;

data _null_;
   set PE;
   if _n_ = 1 then call symput('Int', put(estimate, BEST6.));   
   else            call symput('Slope', put(estimate, BEST6.)); 
run;

title 'y*x';
proc sgplot data=data noautolegend;
   reg y=y x=x;
   inset "Intercept = &Int" "Slope = &Slope" /
         border title="Parameter Estimates" position=topleft;
run;

• 코드를 정리하면 위와 같은데요. 선형회귀분석의 결과로 나온 파라미터들을 임시 데이터셋에 저장해놓고 이를 매크로변수에 저장하여 산점도를 그릴 때 불러오는 방식입니다. 만약 추정된 파라미터 값이 굳이 필요없으면 마지막 proc sgplot 만 실행하면 되고, reg y=y x=x; 라인만 추가하면 선형회귀선이 산점도에 나타나게 됩니다.
  

히스토그램 및 밀도함수(density plot)

• 히스토그램과 밀도함수는 아래의 코드로 그릴 수 있습니다. histogram statement와 함께 density statement를 추가하며 적당한 밀도함수를 그려주게 되며, 정규분포 밀도함수를 함께 그려주어 해당 데이터가 정규분포와 얼마나 유사한지를 보여줄 수 있습니다.
  

proc sgplot data=data;
  histogram var_name ;
  density var_name / type=normal legendlabel='Normal' lineattrs=(pattern=solid);
  density var_name   / type=kernel legendlabel='Kernel' lineattrs=(pattern=solid);
  keylegend / location=inside position=topright across=1;
  xaxis display=(nolabel);
 run;

SAS Proc report 옵션들

/* 2017.9.20 by. 3months */

SAS Base programming 자격증 공부하다가 proc report 관련 정리를 하였습니다. proc report는 데이터셋을 통해 무언가를 report할 때 쓰이는 SAS의 프로시져입니다.

데이터 정의

data a;
 input a$ b;
 cards;
 a 1
 a 2
 a 3
 a 4
 c 5
 c 6
 b 7
 b 8
 b 9
 b 10
 ;
run;

proc report 프로시져

proc report data=a;
   column a; * 이 컬럼에 대한 리포트를 하겠다;
   define a/group; * 중복값을 제외하고 group으로 묶겠다 ;
run;

proc report data=a;
 column a;
 define a/across; * across 옵션은 갯수를 센다;
run;

proc report data=a;
 column b;
 define b/analysis; * b 컬럼 분석 sum을 낸다. ;
run;

proc report data=a;
 column b;
 define b/display; * 그냥 그대로 보여준다.;
run;

차례 대로 각각의 proc report에 대한 결과

출처

http://blog.naver.com/sonobono88/220271045853

강화학습 Q-learning on non-deterministic worlds

출처

• https://github.com/fabulousjeong/OPENML-Deep-Reinforcement-Learning/blob/master/ipython/Lab5_Q-learning%20in%20non-deterministic%20world.ipynb
• http://hunkim.github.io/ml/
  

Frozen Lake 게임이 non-deterministic인 경우 Q를 어떻게 학습하는지 알아보겠습니다. 이 포스팅은 Frozen Lake 게임과 강화학습의 기본 개념을 안다는 전제로 김성훈 교수님의 강화학습 강의를 제 나름대로 정리한 포스팅입니다. 우선 non-deterministic이 무슨 의미인지부터 살펴보면 non-deterministic 이라는 것은 원하는대로 되지 않는다는 의미입니다. (stochastic이라고도 합니다.) 이런 경우에는 무조건 Q가 가라는 대로 가는 것보다는 "기존의 믿음" 을 차근 차근 업데이트 해나가는 것이 Q 학습이 더 잘 된다고 합니다. 이는 현실 세계와도 많이 닮아있습니다. 이를 멘토에 비교해볼 수 있는데, 무조건 멘토가 하라는 대로 하기보다는 결국 무언가를 하기 위해서는 타인의 조언 보다는 자기 자신의 신념이 더 중요하다고 할 수 있습니다.

이를 식으로 표현하면 기존 알고리즘은  

Q(state, action) = R + λmax(Q(new state)) (λ < 1)

이었는데

Q(state, action) = (1-a)Q(state, action) + a(R+λmax(Q(new state)) (a = learning rate)

을 사용하게 됩니다. learning rate 개념을 통해 Q를 한 번에 업데이트 하지 않고, 기존에 믿음을 토대로 조금씩 업데이트 해나가는 것입니다. 이를 구현하는 코드를 보겠습니다. 기존 코드에서 Q 업데이트 하는 부분만 달라지기 때문에 크게 다르지는 않습니다.

라이브러리 로드

import gym
import numpy as np
import matplotlib.pyplot as plt 
from gym.envs.registration import register
import random as pr

environment 생성 및 하이퍼 파라미터 초기화

env = gym.make('FrozenLake-v0')
# Q-table 초기화
Q = np.zeros([env.observation_space.n, env.action_space.n])

# Learning Rate
learning_rate = 0.85

# discount factor
dis = .99
    
# learning 횟수
num_episodes = 2000

# 학습 시 reward 저장
rList = []

Q-learning 알고리즘

for i in range(num_episodes):
    
    # env 리셋
    state = env.reset()
    rAll = 0
    done = False
    
    #decaying E-greedy
    e = 1./((i//100)+1)
    
    # Q-table Learning algorithm
    while not done:
        
        # Choose an action by e greedy
        '''
        if np.random.rand(1) < e:
            action = env.action_space.sample()
        else:
            action = np.argmax(Q[state, :])
        '''
        
        # add Random noise
        action = np.argmax(Q[state, :]+ np.random.randn(1, env.action_space.n)/(i + 1))
        
        # new_state, reward 업데이트 
        new_state, reward, done, _ = env.step(action)
        
        # update Q-table
        Q[state, action] = (1-learning_rate) * Q[state, action] + learning_rate*(reward + dis*np.max(Q[new_state, :]))
        
        rAll += reward
        state = new_state

    rList.append(rAll)

action을 선택하는 부분에서 e-greedy 방법을 사용하는 방법과 random noise를 사용하는 방법이 있는데 둘 다 exploit & exploration을 구현한 것으로 둘 중 하나를 사용하면 됩니다. 밑에 #update Q-table 부분에 Q를 업데이트하는 코드를 볼 수 있습니다. learning rate를 통해 기존의 믿음을 얼마나 받아들일지, Q의 판단을 얼마나 받아들일지를 조정합니다.

print('success rate: ', str(sum(rList)/num_episodes))
print('Final Q-table values')
print(Q)
plt.bar(range(len(rList)), rList, color = 'blue')
plt.show()

('success rate: ', '0.4135')
Final Q-table values
[[  6.05216575e-01   4.77802714e-03   7.66890982e-03   1.14402756e-02]
 [  1.89070559e-04   2.71412272e-05   2.94641678e-03   6.06539650e-01]
 [  6.20782244e-03   3.96037865e-03   2.02160738e-03   5.88158391e-01]
 [  1.38851811e-04   1.81853506e-04   1.08700028e-03   3.36662917e-01]
 [  5.63057417e-01   1.35053120e-03   4.64530097e-04   1.81633578e-03]
 [  0.00000000e+00   0.00000000e+00   0.00000000e+00   0.00000000e+00]
 [  8.64124213e-05   2.51760080e-04   7.21585211e-02   3.41902605e-05]
 [  0.00000000e+00   0.00000000e+00   0.00000000e+00   0.00000000e+00]
 [  3.70706358e-05   1.37044981e-03   2.40643636e-04   7.95889822e-01]
 [  1.09162680e-04   5.60870413e-01   9.16914837e-04   2.64997619e-04]
 [  9.20012820e-01   5.54630225e-05   7.32392792e-05   0.00000000e+00]
 [  0.00000000e+00   0.00000000e+00   0.00000000e+00   0.00000000e+00]
 [  0.00000000e+00   0.00000000e+00   0.00000000e+00   0.00000000e+00]
 [  4.37606936e-04   4.03103644e-04   9.16837079e-01   3.65822303e-04]
 [  0.00000000e+00   0.00000000e+00   2.34205607e-03   9.98477546e-01]
 [  0.00000000e+00   0.00000000e+00   0.00000000e+00   0.00000000e+00]]

success rate는 0.4135인데, 이는 0.4135의 확률로 Goal에 도착한다는 것입니다. non-deterministic world 에서는 상당히 높은 성공률입니다. 또 이 부분에서 중요한 점은 이 non-deterministic world에서의 강화학습 알고리즘의 성공률은 사람의 성공률 보다 높을 수 있다는 것입니다. 왜냐하면 deterministic world에서는 사람이 한 눈에 게임의 rule을 알 수 있고, 매우 쉽게 Goal을 찾을 수 있는 반면, non-deterministic world에서는 사람에게는 Goal을 찾아가는 것이 쉽지 않습니다. 하지만 non-deterministic world에서도 확률적으로 패턴이 존재하고, 이 사람이 이해하기 힘든 패턴속에서 강화학습 알고리즘은 에러를 최소화할 최적의 경로를 찾는다는 것입니다. 이 부분이 진정한 강화학습의 강점이 아닐까 생각해보았습니다.

강화학습 Q-Learning 기초 실습

Q-Learning을 통해 Frozen Lake 문제를 해결하는 방법에 대한 포스팅입니다. 실습 코드의 내용 및 출처는 김성훈 교수님의 강화학습강의( https://www.youtube.com/watch?v=VYOq-He90bE&feature=youtu.be) 입니다.

이 코드를 이해하기 위해서는 강화학습에 대한 기본적인 내용과 Frozen Lake 문제에 대하여 알아야합니다. Frozen Lake 문제는 간단히 말하면 위와 같은 상황에서 state를 이동하여 H(Hall)에 빠지지 않고 G(Goal)로 이동하는 문제입니다. 이 포스팅에서 강화학습에 대한 기본 내용들은 다루지 않겠고, 코드만 정리하여 포스팅 하려고 합니다.

환경 세팅

실습에서 사용하는 환경은 gym 패키지 환경인데, 이 환경에서 강화학습으로 해결할만한 여러 toy example들을 로드할 수 있습니다.

gym이 설치되지 않은 경우 pip install gym 으로 설치하시면 됩니다.

import gym
import numpy as np
import matplotlib.pyplot as plt
from gym.envs.registration import register

register(
    id='FrozenLake-v3',
    entry_point = 'gym.envs.toy_text:FrozenLakeEnv',
    kwargs={'map_name':'4x4',
           'is_slippery':False}
)

env = gym.make('FrozenLake-v3')

위와 같이 FrozenLake 게임을 로드할 수 있습니다.

Q-Table 초기화 및 하이퍼 파라미터 초기화

# Q Table을 모두 0으로 초기화 한다. : 2차원 (number of state, action space) = (16,4)
Q = np.zeros([env.observation_space.n, env.action_space.n])

# discount 정의 => 미래의 reward를 현재의 reward 보다 조금 낮게 본다.
dis = 0.99

# 몇 번 시도를 할 것인가 (에피소드)
num_episodes = 2000

# 에피소드마다 총 리워드의 합을 저장하는 리스트
rList = []

Q-learning은 결국 Q 를 배우는 것입니다. Q는 주어진 state에서 어떤 action을 취할 것인가에 대한 길잡이입니다. 이 문제에서 Q라는 2차원 배열에는 현재 state에서 action을 취할 때 얻을 수 있는 reward를 저장하고 있습니다. 이 Q 2차원 배열에서 argmax 함수를 이용하면 어떤 action을 취할지를 얻어낼 수 있는 것이죠. 이 문제에서 state는 16, action은 4입니다. (4x4 Frozen Lake 그리고 action은 위, 아래, 왼쪽, 오른쪽 4개)

Q-learning 알고리즘에서 Q를 업데이트하는 것

Q(state, action) = R + max(Q(new state)) 로 업데이트하게 됩니다. R은 reward로 게임 내부에서 지정되는 값입니다. 현재 state에서의 어떤 action을 취할 때의 Q 값은 그 action을 통해 얻어지는 reward와 action으로 변화된 state에서 얻을 수 있는 reward의 최댓값을 더한 것입니다. 즉 의미는 현재 리워드와 미래에 가능한 리워드의 최대치를 더하는 것입니다.

근데 이 때, Q(state, action) = R + discount * max(Q(new state)) 로 미래 가능한 리워드에 1 미만의 discount factor를 곱해주어(이 실습에서는 0.99) 미래 리워드에 약간의 패널티를 주기도 하는데 이런 방식을 통해 Q가 조금 더 optimal한 방법으로 learning 될 수 있습니다. 이 때 discount는 하이퍼 파라미터(hyperparameter)로 여러번 시도하면서 좋은 값을 찾을 수 있습니다.

Q-learning 알고리즘에서 Action을 고르는 것

강화학습에서 action 을 고르는 것은 이슈중 하나입니다. 이 실습에서는 두 가지 방법을 쓰는데 첫 번째, random noise 방식, 두 번째, E-Greedy 방식입니다. 둘 다 exploit & exporation 방법을 구현한 것으로 볼 수 있는데 약간의 차이가 있습니다. 둘의 공통적인 아이디어는 '무조건 Q 가 시키는대로만 가지말고 새로운 길로도 가보자는 것' 입니다. 왜냐하면 Q가 시키는 것이 optimal한 것이 아닐 수 있기 때문입니다.

1. random noise 방식

random noise 방식이란 현재 state에서 가능한 action에 따른 Q값(총 4가지)에 random noise를 주어서, 이 것이 최대값이 되는 action을 action으로 선택하게 됩니다. 그러면 무조건 최대 Q 값만 따르지 않고 가끔은 다른 action을 취하기도 합니다. random noise를 (i+1)로 나누는 것은 여러번 해보면서 어느 정도 Q 값이 optimal하게 될 것이기 때문에 exploration을 줄이고 exploit 위주로 한다는 것입니다.

for i in range(num_episodes) : 
    state = env.reset()
    rAll = 0
    done = False
    
    # Q learning 알고리즘
    while not done : 
        # Action 중에 가장 R(Reward)이 큰 Action을 고른다. 
        # 이 때, random noise 방식으로 decaying Exploit & Exploration 구현 
        action = np.argmax(Q[state, :] + np.random.randn(1, env.action_space.n) / (i+1))
        
        # 해당 Action을 했을 때 environment가 변하고, 새로운 state, reward, done 여부를 반환 받음
        new_state, reward, done, _ = env.step(action)
        
        # Q = R + Q 
        Q[state, action] = reward + dis * np.max(Q[new_state, :])
        
        rAll += reward
        state = new_state
        
    rList.append(rAll)

2. E-greedy 방식

E-Greedy 방식은 어떠한 확률값 e를 주어, e의 확률로 exploration한다는 것입니다. 예를 들어 e=0.99 이면 99%의 확률로 exploration 하고, 1%의 확률로 exploit해서 새로운 길을 찾게 됩니다. 이 값을 (i/100) 으로 나눈 것은 위 1번과 마찬가지로 여러버 해보면서 Q 값이 optimal 해질 것이기 때문에 exploration을 줄이면서 exploit 위주로 한다는 뜻입니다.

for i in range(num_episodes) : 
    state = env.reset()
    rAll = 0
    done = False
    
    # exploration의 확률 (decaying)
    e = 1./((i / 100) + 1)
    
    # Q learning 알고리즘
    while not done : 
        
        # E-Greedy 알고리즘으로 action 고르기
        if np.random.rand(1) < e :
            action = env.action_space.sample()
        else : 
            action = np.argmax(Q[state, :])
        
        # 해당 Action을 했을 때 environment가 변하고, 새로운 state, reward, done 여부를 반환 받음
        new_state, reward, done, _ = env.step(action)
        
        # Q = R + Q 
        Q[state, action] = reward + dis * np.max(Q[new_state, :])
        
        rAll += reward
        state = new_state
        
    rList.append(rAll)

최종 결과

Success rate는 Goal까지 실패 안하고 갈 확률입니다. 그래프를 보면 초반에만 실패하고 나중에는 다 성공하도록 Q 가 학습되어 나간다는 것을 볼 수 있습니다.

print("Success rate : "+str(sum(rList) / num_episodes))
print("Final Q-Table Values")
print(Q)

plt.bar(range(len(rList)), rList, color="blue")
plt.show()

Success rate : 0.807
Final Q-Table Values
[[ 0.94148015  0.95099005  0.95099005  0.94148015]
 [ 0.94148015  0.          0.96059601  0.95099005]
 [ 0.95099005  0.970299    0.95099005  0.96059601]
 [ 0.96059601  0.          0.95099005  0.        ]
 [ 0.95099005  0.96059601  0.          0.94148015]
 [ 0.          0.          0.          0.        ]
 [ 0.          0.9801      0.          0.96059601]
 [ 0.          0.          0.          0.        ]
 [ 0.96059601  0.          0.970299    0.95099005]
 [ 0.96059601  0.9801      0.9801      0.        ]
 [ 0.970299    0.99        0.          0.970299  ]
 [ 0.          0.          0.          0.        ]
 [ 0.          0.          0.          0.        ]
 [ 0.          0.9801      0.99        0.970299  ]
 [ 0.9801      0.99        1.          0.9801    ]
 [ 0.          0.          0.          0.        ]]

Keras를 통한 LSTM 구현

/* 2017.8.29 by. 3months */

- LSTM에 대한 개념 학습

http://blog.naver.com/kmkim1222/221069000196

https://www.youtube.com/watch?v=6niqTuYFZLQ&list=PL3FW7Lu3i5JvHM8ljYj-zLfQRF3EO8sYv

- 코드 및 데이터 출처  -https://github.com/Dataweekends/zero_to_deep_learning_udemy

LSTM 개념

LSTM은 기존 vanilla RNN을 개선한 모델로써 데이터의 long-term dependency를 학습하는데 효과적인 모델입니다. 또한 내부적으로 구성요소간에 additive, elementwise interaction을 통해 backpropagation 할 때, gradient explosion, vanishing 문제를 기존 RNN에 비해 매우 줄인 것이 중요한 개선점입니다.

코드 실습을 통해 LSTM을 학습하기 위해서는 어떠한 데이터 구조가 필요한지, 즉, INPUT은 어떤 모양이어야 하고, OUTPUT이 어떻게 생성되며, 네트워크 구조를 코드 상으로 어떻게 정의하는지 알아보겠습니다.

사용할 데이터

cansim-0800020-eng-6674700030567901031.csv

데이터 임포트

데이터를 임포트합니다. 데이터는 날짜별로 특정한 값이 있는 데이터입니다. Unadjusted이 Raw 값이고, Seaonally adjusted는 Season의 효과를 보정한 값입니다. 보통 주식과 같은 시계열 데이터는 Season에 의한 효과가 있는데, Seasonally adjusted는 이 Season에 의한 효과를 보정하여 전체적인 추세만 보고자할 때 사용하는 변수입니다. 우리가 학습할 변수는 Season에 의한 효과를 보정하지 않은 Unadjusted입니다.

import pandas as pd
import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt

df = pd.read_csv('data/cansim-0800020-eng-6674700030567901031.csv',
                 skiprows=6, skipfooter=9,
                 engine='python')
df.head()

전처리

from pandas.tseries.offsets import MonthEnd

df['Adjustments'] = pd.to_datetime(df['Adjustments']) + MonthEnd(1)
df = df.set_index('Adjustments')
print(df.head())
df.plot()

우선 문자열로된 Adjustments 변수를 datetime 객체로 만들어주고, MonthEnd(1)을 더하면 해당 월의 맨 끝 날짜가 지정되게 됩니다. 그리고 이 날짜를 index로 만들어줍니다. 이후에 plot을 하면 날짜를 index로 해서 Unadjusted와 Seasonally adjusted 변수의 그래프를 그릴 수 있습니다.

인덱스가 0,1,2,3 ... 에서 날짜로 변했음을 알 수 있습니다. (가장 왼쪽열. 또한 index의 이름이 Adjustements가 되었음을 알 수 있음.)

우리가 학습할 변수는 파란색 선 Unadjusted 입니다.

트레이닝셋 테스트셋 SPLIT

2011/1/1 을 기준으로 트레이닝셋과 테스트셋으로 구분합니다. 그리고 학습과 테스트에 사용할 Unadjusted 변수만 남겨놓습니다.

split_date = pd.Timestamp('01-01-2011')
# 2011/1/1 까지의 데이터를 트레이닝셋.
# 그 이후 데이터를 테스트셋으로 한다.

train = df.loc[:split_date, ['Unadjusted']]
test = df.loc[split_date:, ['Unadjusted']]
# Feature는 Unadjusted 한 개

ax = train.plot()
test.plot(ax=ax)
plt.legend(['train', 'test'])

변수 Scaling

MinMax Scaling을 통해 변수를 Scaling합니다. MinMax Scaling : http://3months.tistory.com/167

그러면 아래와 같이 Scaling 된 것을 볼 수 있고, scaling의 결과는 2차원의 numpy ndarray 타입으로 변환이 되게 됩니다.

from sklearn.preprocessing import MinMaxScaler

sc = MinMaxScaler()

train_sc = sc.fit_transform(train)
test_sc = sc.transform(test)

train_sc

(240, 1)
[[ 0.01402033]
 [ 0.        ]
 [ 0.0704258 ]
 [ 0.09531795]
 [ 0.16362761]
 [ 0.13514108]
 [ 0.12395846]
 [ 0.12617398] 
......

Pandas Dataframe으로 변환

이를 다시 pandas dataframe 데이터 타입으로 변환해봅시다. Dataframe에서 작업을 해야지 Window를 만들기 유용하기 때문입니다. Window는 RNN을 트레이닝 하기위한 단위로 Window size는 Timestep과 같다고 생각하시면 됩니다.

train_sc_df = pd.DataFrame(train_sc, columns=['Scaled'], index=train.index)
test_sc_df = pd.DataFrame(test_sc, columns=['Scaled'], index=test.index)
train_sc_df.head()

pandas shift를 통해 Window 만들기

shift는 이전 정보 다음 row에서 다시 쓰기 위한 pandas의 함수입니다. 이를 통해 아래와 같이 과거의 값들을 shift_s 와 같은 형태로 저장할 수 있습니다. 과거값은 총 12개를 저장하며, timestep은 12개가 됩니다. 우리의 목적은 과거값 shift1~12를 통해 현재값 Scaled를 예측하는 것입니다.

for s in range(1, 13):
    train_sc_df['shift_{}'.format(s)] = train_sc_df['Scaled'].shift(s)
    test_sc_df['shift_{}'.format(s)] = test_sc_df['Scaled'].shift(s)

train_sc_df.head(13)

트레이닝셋과 테스트셋 만들기

dropna를 통해 NaN이 있는 데이터를 제거하고, shift_1 ~ shift_12는 X로 Scaled는 Y로 지정을 합니다.

X_train = train_sc_df.dropna().drop('Scaled', axis=1)
y_train = train_sc_df.dropna()[['Scaled']]

X_test = test_sc_df.dropna().drop('Scaled', axis=1)
y_test = test_sc_df.dropna()[['Scaled']]

최종 트레이닝셋과 테스트셋의 모양은 아래와 같습니다.

X_train.head()

y_train.head()

다시 ndarray로 변환하기

데이터구조를 다시 ndarray로 변환시켜줍니다. 실제 deep learning 모델의 트레이닝과 테스트로 사용되는 데이터는 일반적으로 numpy의 ndarray입니다. 아래와 같이 .values를 통해 ndarray 값을 얻을 수 있습니다. 트레이닝 데이터는 timestep=12, size = 228 입니다.

X_train = X_train.values
X_test= X_test.values

y_train = y_train.values
y_test = y_test.values

print(X_train.shape)
print(X_train)
print(y_train_shape)
print(y_train)

(228, 12)
[[ 0.20091289  0.13173822  0.11139526 ...,  0.0704258   0.          0.01402033]
 [ 0.03002688  0.20091289  0.13173822 ...,  0.09531795  0.0704258   0.        ]
 [ 0.01999285  0.03002688  0.20091289 ...,  0.16362761  0.09531795
   0.0704258 ]
 ..., 
 [ 0.79916654  0.81439355  0.86398323 ...,  0.92972161  0.71629034
   0.77368724]
 [ 0.80210057  0.79916654  0.81439355 ...,  0.59734863  0.92972161
   0.71629034]
 [ 0.81482896  0.80210057  0.79916654 ...,  0.53166512  0.59734863
   0.92972161]]
(228, 1)
[[ 0.03002688]
 [ 0.01999285]
 [ 0.06596369]
 [ 0.10983126]
 [ 0.14912986]
....

최종 트레이닝셋과 테스트셋의 X 만들기

이부분이 중요한데, keras에서는 RNN 계열의 모델을 트레이닝할 대 요구되는 데이터의 형식이 있습니다. 바로 3차원 데이터여야하며 각각의 차원은 (size, timestep, feature) 을 순서대로 나타내주어야하는 것입니다. 따라서 이 형태로 데이터를 reshape 해주어야합니다. 일반적인 MLP 모델에서는 size와 feature만 있기 때문에 2차원이지만, RNN에서는 "시간" 이라는 개념이 있기 때문에 차원이 한 차원 늘어나게 된 것입니다. 합리적인 데이터 구조라고 볼 수 있습니다.

아래 코드를 통해 Training set과 Test set의 X를 RNN 학습에 맞는 형태로 reshape 해줍니다.

X_train_t = X_train.reshape(X_train.shape[0], 12, 1)
X_test_t = X_test.reshape(X_test.shape[0], 12, 1)

print("최종 DATA")
print(X_train_t.shape)
print(X_train_t)
print(y_train)

최종 DATA
(228, 12, 1)
[[[ 0.20091289]
  [ 0.13173822]
  [ 0.11139526]
  ..., 
  [ 0.0704258 ]
  [ 0.        ]
  [ 0.01402033]]

 [[ 0.03002688]
  [ 0.20091289]
  [ 0.13173822]
  ..., 
  [ 0.09531795]
  [ 0.0704258 ]
  [ 0.        ]]

LSTM 모델 만들기

아래와 같이 keras를 통해 LSTM 모델을 만들 수 있습니다. input_shape=(timestep, feature)으로 만들어줍니다. size는 모델 설계시에는 중요하지 않으므로, feature, timestep만 모델에 알려주면 됩니다. 또 예측하고자하는 target의 갯수가 1이므로 마지막에 Dense(1)을 하나 추가해줍니다. 또한 실제 연속적인 값을 예측하는 것이기 때문에 loss function은 mean squared error가 됩니다. 또한 일반적으로 optimizer는 adam을 자주 사용합니다.

from keras.layers import LSTM
from keras.models import Sequential
from keras.layers import Dense
import keras.backend as K
from keras.callbacks import EarlyStopping

K.clear_session()
model = Sequential() # Sequeatial Model
model.add(LSTM(20, input_shape=(12, 1))) # (timestep, feature)
model.add(Dense(1)) # output = 1
model.compile(loss='mean_squared_error', optimizer='adam')

model.summary()

모델 Fitting

모델을 Fitting한다는 것은 Training data set으로 optimization 과정을 통해 모델의 weight를 찾는 것입니다. early stopping 객체를 이용해 epoch마다 early stopping을 체크합니다. 아래와 같은 결과를 내면서 트레이닝이 잘 되는 것을 확인할 수 있습니다.

early_stop = EarlyStopping(monitor='loss', patience=1, verbose=1)

model.fit(X_train_t, y_train, epochs=100,
          batch_size=30, verbose=1, callbacks=[early_stop])

Epoch 1/100
228/228 [==============================] - 0s - loss: 0.3396     
Epoch 2/100
228/228 [==============================] - 0s - loss: 0.2958     
Epoch 3/100
228/228 [==============================] - 0s - loss: 0.2551     
Epoch 4/100
228/228 [==============================] - 0s - loss: 0.2175   
...

학습된 모델을 통해 테스트셋 Test 하기

테스트셋은 2011/1/1 이후의 데이터를 나타냅니다. 트레이닝에는 1991년~ 2010년 까지 데이터가 이용되었기 때문에, 이 실습은 1991년~2010년 데이터를 통해 2011년 이후의 데이터를 예측하는 것으로 볼 수 있습니다.

테스트셋의 모양은 아래와 같이 생겼습니다. 당연한 이야기지만 트레이닝셋과 구조가 같습니다.

print(X_test_t)

[[[ 1.06265011]
  [ 0.87180554]
  [ 0.84048091]
  [ 0.86220767]
  [ 0.88363094]
  [ 0.89302107]
  [ 0.92552046]
  [ 0.89993326]
  [ 0.83505683]
  [ 0.77259579]
  [ 0.56926634]
  [ 0.61423187]]


....

model.predict를 통해 테스트셋의 X에 대한 예측값 y_hat을 얻을 수 있습니다.

y_pred = model.predict(X_test_t)
print(y_pred)

[[ 0.82410765]
 [ 0.85221326]
 [ 0.88795143]
 [ 0.90008551]
 [ 0.90281236]
 [ 0.90063977]
 [ 0.89379823]
 [ 0.88957471]
 [ 0.88779473]

...

Python Scaling 방법 정리

/* 2017.8.27 by. 3months */

머신러닝에서 데이터를 모델에 트레이닝할 때, 일반적으로 데이터를 Scaling 해서 사용한다. Scaling을 통해 데이터의 Scale을 맞추면 Weight의 scale도 일관성 있도록 맞출 수 있을 것이다.

MinMax Scaling은 최댓값 = 1, 최솟값 = 0으로 하여, 그 사에 값들이 있도록 하는 방법이다.

즉 데이터 X의 scaling된 값 Xscale은 아래와 같다.

Xscale = (X-Xmin) / (Xmax-Xmin)

from sklearn.preprocessing import MinMaxScaler
a = [[10], [9], [8], [6], [2]]
scaler = MinMaxScaler(feature_range=(0,1))
a = scaler.fit_transform(a)
print(a)

결과

[[ 1.   ]
 [ 0.875]
 [ 0.75 ]
 [ 0.5  ]
 [ 0.   ]]

StandardScaling은 평균=0과 표준편차=1이 되도록 Scaling 하는 방법이다. 이는 표준화라고도 부른다.

Xscale = (X-X_mean) / Xstd

from sklearn.preprocessing import StandardScaler
a = [[10], [9], [8], [6], [2]]
scaler = StandardScaler()
a = scaler.fit_transform(a)
print(a)
print(a.mean())
print(a.std())

결과

[[ 1.06066017]
 [ 0.70710678]
 [ 0.35355339]
 [-0.35355339]
 [-1.76776695]]
0.0
1.0

아나콘다에서 제공하는 IDE인 Spyder를 아나콘다 virtual environment 위에서 실행하기 위해서는 Spyder를 virtual environment 안에도 설치를 해야한다.

conda install -n myenv spyder

myenv는 직접 지정한 virtual environment 이름이다. 위 명령어를 통해 virtual environment 상에 spyder를 설치하게 되고, 그 환경에서 spyder를 실행할 수 있다.

설치 후,

윈도우의 경우

activate myenv
spyder

명령어를 통해 해당 virtual environment 안에서 spyder를 실행할 수 있다.

(MAC은 activate 대신에 source activate)

Keras 모델 저장하고 불러오기

/* by 3months. 2017.7.19 */

keras를 통해 MLP, CNN 등의 딥러닝 모델을 만들고, 이를 학습시켜서 모델의 weights를 생성하고 나면 이를 저장하고 싶을 때가 있습니다. 특히 weights 같은 경우는 파일 형태로 저장해놓는 것이 유용한데, 파이썬 커널을 내리는 순간 애써 만든 weights 가 모두 메모리에서 날라가 버리기 때문입니다. keras에서는 모델과 weights의 재사용을 위해 이를 파일형태로 저장하는 라이브러리를 제공하며, 이를 통해 모델과 weights를 파일 형태로 저장하고 불러올 수가 있습니다.

Keras에서 만든 모델을 저장할 때는 다음과 같은 룰을 따릅니다.

• 모델은 JSON 파일 또는 YAML 파일로 저장한다.
  
• Weight는 H5 파일로 저장한다.

아래는 모델을 저장하고 불러오는 실습 코드입니다.

라이브러리 임포트

from keras.models import Sequential
from keras.layers import Dense
from keras.callbacks import ModelCheckpoint
import matplotlib.pyplot as plt
import numpy
import pandas as pd

데이터 로드

url = "https://archive.ics.uci.edu/ml/machine-learning-databases/pima-indians-diabetes/pima-indians-diabetes.data"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']

dataframe = pd.read_csv(url, names=names)
array = dataframe.values

X = array[:,0:8]
Y = array[:,8]

모델 생성

# create model
model = Sequential()
model.add(Dense(12, input_dim=8, kernel_initializer='uniform', activation='relu'))
model.add(Dense(8, kernel_initializer='uniform', activation='relu'))
model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))

# Compile model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

모델을 JSON 파일 형식으로 만들어 저장하기

model_json = model.to_json()
with open("model.json", "w") as json_file : 
    json_file.write(model_json)

Weight를 h5 파일 포맷으로 만들어 저장하기

model.save_weights("model.h5")
print("Saved model to disk")

저장된 JSON 파일로 부터 모델 로드하기

from keras.models import model_from_json
json_file = open("model.json", "r")
loaded_model_json = json_file.read()
json_file.close()
loaded_model = model_from_json(loaded_model_json)

로드한 모델에 Weight 로드하기

loaded_model.load_weights("model.h5")
print("Loaded model from disk")

모델 컴파일 후 Evaluation

loaded_model.compile(loss="binary_crossentropy", optimizer="rmsprop", metrics=['accuracy'])

# model evaluation
score = loaded_model.evaluate(X,Y,verbose=0)

print("%s : %.2f%%" % (loaded_model.metrics_names[1], score[1]*100))