딥러닝 머신 그리고 TensorFlow R word2vec 코드 구현/모델링

TensorFlow Life

최근 TensorFlow를 팀에서 주로 사용하면서 이런저런 내부 프로젝트를 진행하고 있고, 과거에 보지 못했던 성과도 볼 수 있었으며, 이런 도구 사용과 경험을 통해 무엇보다 1년 전과는 문제를 바라보는 관점이 달라졌다는 것을 깊히 실감할 수 있었다. 이 때문에 거의 매일매일 새로운 경험을 하는 셈인데 그러면서 알고리즘에 대한 더 깊은 이해를 하게 되는거 같다.

과거 모든 속성에 대해서 뭔가의 가정을 기반으로 데이터를 준비해서 모델링을 했다면, 딥러닝의 경우 속성에 대해서는 머신에게 최대한 자유를 주고 더 많은 데이터와 복잡한 아키텍처와 많은 학습을 기반으로 기존 모형보다 더 좋은 성능을 꾀하는 것에 방점을 두고 있다. 필자도 과거 오해를 하고 딥러닝을 바라봤으나 결국 어떠한 문제이든 많은 데이터가 준비되어 있으면 기존 모델링 방법보다 좋은 성능을 보장한다는걸 경험적으로 알게 되었다. 그러나 이런 결과를 보기 위해서는 도구에 대한 확실한 이해와 알고리즘에 대한 이해를 담보하고 있다. 만일 그렇지 않고 사용하게 되면 큰 성능은 커녕 실망만 하게 된다.

성능 이외에 느낄 수 있는 딥러닝의 좋은 장점은 역시나 온라인 러닝에 있다고 생각한다. 이 부분은 학술 연구를 하는 분들에게는 중요하지 않을 수 있으나, 나와 같이 실무 모델링을 하는 사람에게는 매우 큰 장점으로 다가오고 모델 운영의 묘미를 느끼게 하는 중요한 부분이다. 어떻게 모형을 Fresh하게 유지할 수 있느냐의 문제는 딥러닝에서는 다소 어렵지 않은 문제이다.

매우 안타까운 이야기지만, TensorFlow로 이런 저런 실전 모델링 및 실전 차원 축소를 해본 결과 텐서플로와 같은 딥러닝 프레임웍은 개발자(여기서 개발자라 칭함은 개발 경험이 충분히 있는 부류를 의미한다.)들이 더 유리한 접근을 할 수 있다라는 생각에 다시한번 확신이 들게 된다. 일단 대용량,고차원 데이터 핸들링 경험이 없으면 실전에서 딥러닝 모델링을 할 수 있는 문턱에도 갈 수 없으며, 이를 넘었다 하더라도 API 레벨을 원활히 검증하면서 흡사 개발과 같은 과정을 거쳐야 제대로 돌려볼 수 있다. 다소 머신러닝 알고리즘에 대해서 패키지 레벨로만 접근해서 돌려봤던 분석가 및 데이터 과학자들은 매우 어려운 도구이나, 직접 머신러닝을 구현해본 개발자들에게 확실히 유리한 도구다라는 생각을 해본다.

물론 keras같은 하이레벨 wrapper를 쓰면 어느정도 쉽게 접근이 가능하나, 실전문제에서는 그보다 더 큰 데이터와 차원을 다뤄야 되어서 결국 로 레벨 API를 써야 된다. 이때 개발자적인 경험/능력이 매우 큰 도움이 된다.

하지만 개발자들이 항상 유리한건 아니다. 뭔가 모델이 잘 못 돌고 있을때 개발자들은 데이터 자체를 리뷰하거나 중간 결과에 대한 EDA를 잘 하지 않는 경향이 있고, 그냥 바로 API 수정이나 하이퍼파라메터를 추가/제거 하고 돌리는 것을 반복하곤 한다. 데이터의 특징을 파악하고 입력이든 중간 데이터 변환이든 목적에 맞는 통계적 데이터 변환 방법은 무수히 많은데, 이를 잘 할 수 있는 사람들은 전통적인 통계 기반의 사람들이다. 하지만 통계기반의 사람들이 그러한 문제점을 파악하고 조언하는 역할만 할 것인가이다. 현실적으로 조언만 해서는 자신이 한 성과라 할 수 없다. 결국 상호의 영역에 대한 공부를 하고 경험을 쌓아야 풀스텍 딥러닝 모델러가 될 수 있는것이다.

딥러닝 같은거 쓰지 않고서라도 데이터 과학자 역할을 할 수 있으나, 일반적인 모델링 패키지를 사용하면 성능의 편차가 개인마다 크지 않아 고수든 하수든 별다른 경험적 차별점을 도모하기 쉽지 않으나, 딥러닝의 경우 프레임웍에 익숙해지고 경험이 많을수록 성능을 짧은 시간에 극한으로 끌어올릴 수 있는 가능성이 매우 커진다. 물론 큰 데이터를 손쉽게 핸들링하고 이를 적합한 딥러닝 구조에 녹여 돌릴 수 있는 경험적인 부분과 이론적인 부분에 대한 밸런스를 반드시 이뤄야 된다.

무엇보다, 누구에게 어렵거나 쉬운것에 상관없이, 누구든 데이터로 밥먹고 산다면 반드시 한번정도는 충분히 경험해보고 넘어가야 되는 방법론이고 프레임웍이다라는 생각은 하면 할수록 확신이 든다.

딥러닝 머신 구축

작년에 개인적인 프로젝트를 수행하면서 개인 리서치에 쓸 수 있는 자금이 생겼는데, 이 자금으로 개인 딥러닝 머신을 조립했다. 뭔가 올해 들어서 딥러닝에 대한 경험과 학습에 대한 의지의 표현이라 보면 된다. ㅋ

  • 보드 : ASUS PRIME Z270-A
  • 메모리 : SD4 16GB x 4
  • CPU : I7-7700K
  • SSD : 삼성 500GB
  • HDD : WD 2TB
  • 파워 : 정격 850W
  • GPU : GTX 1080 x 2
  • 모니터 : LG 27인치 IPS

사실 GTX 1080 2개까지 설치할 생각은 없었는데, 용산 조립 대행 업체에 방문한날 그 자리에서 성급하게 한장 더 넣어달라고 했다. 당시 가격으로 80만원 정도가 더 나갔는데, 후회는 없다. ㅋ

'딥러닝 머신'

신형 보드라 우분투를 설치하는데 애를 좀 먹었지만 현재 아주 환경이 잘 설정되었다. 두개의 GPU를 엮어 사용하는 SLI의 경우 현재 CUDA에서 이 부분에 대한 지원이 없어서 활용은 못하고 있지만 큰 가중치 매트릭스 몇개를 두개의 GPU에 적절히 나눠 계산할 수 있어서 핸들링 할 수 있는 문제 크기는 1개일 때보다 커졌다(예를 들어 autoencoder encoder를 1번 GPU에 올리고 decoder를 2번 GPU에 올려서 사용할 수 있을 것이다). 물론 게임할때는 1.5배 이상의 퍼포먼스를 가져온다. ㅎㅎ

딥러닝 학습

일반적인 정형 데이터를 학습하기 위해 딥러닝을 사용하는건 비정형 데이터를 사용해 모델링 하는것 보다 훨씬 쉬운 문제라고 생각한다. 그럼에도 불구하고 정형 기반 모델링을 하더라도 데이터를 어떻게 모형에 입력하는지에 따라 매우 큰 퍼포먼스 차이를 불러온다. 그리고 텐서플로는 이에 대한 다양한 수단을 제공하고 있어서 그것들 사이에 어떻게 최적의 방법을 찾는지가 빠른 모델링을 하기 위한 큰 장애물이다. 따라서 아래에서 제공하는 코드는 필자가 현재 테스트를 수행중인 개인 프로젝트이며 최적의 솔루션은 아니라는 점을 밝힌다.

개인적인 생각은 주어진 데이터를 기반으로 모델링 학습 코드를 수행하는건 딥러닝을 이해하는데 충분한 도구가 되지 않는다고 생각한다. 왜냐면 입력 데이터 포맷이나 형태와 그에 적합한 아키텍처가 절묘하게 결합될때 원하는 성능이 나오기 때문이다. 따라서 이들에 대한 테스트와 실패를 통해서 감을 찾아가는게 딥러닝 실무를 하는데 매우 중요한 부분이라 생각한다. 따라서 예제만 돌려보기 보다는 직접 문제를 적용하고 모델링하는 시행착오가 꼭 필요한 영역이다.

Word2Vec with R

아래부터 설명할 내용은 Word2Vector를 R로 구현한 구현체이다. 물론 핵심이 되는 부분은 tensorflow 패키지이며, TensorFlow v1.0을 기준으로 작성되었다.

멀티코어 프로세싱 명사 추출 – 데이터 전처리

대상이 되는 데이터는 나무위키 데이터이며, https://github.com/hyeon0145/namu-wiki-extractor를 이용해 json파일을 문장 단위의 텍스트 파일로 만들었다. 결국 이후에 할 작업은 문장에서 명사만을 추출해 명사 주변의 단어를 기반으로 학습 데이터를 만드는 것이다.

아래 코드는 문장 단위의 데이터를 기반으로 KoNLP를 활용해 명사를 추출하는 작업이다. 나무위키에서 추출된 문장단위 데이터의 크기는 3GB정도 되며 필자의 경우 편의를 위해 이를 namus.RData파일로 저장해 두었다.

#문장 단위로 추출된 문장 벡터(3GB) 
load('namus.RData')

library(parallel)
no_cores <- detectCores() - 1

cl <- makeCluster(no_cores)

pids <- clusterApply(cl, seq(along=cl), function(id) WORKER.ID <<- id)

pidds     <- unlist(pids)
timesleep <- seq(0, 40, length.out = 7)

cnt <- 0

clusterExport(cl, c('pidds', 'timesleep', 'cnt'))
clusterEvalQ(cl, {print(WORKER.ID)})

clusterEvalQ(cl, {
  sink(sprintf("%d.log", WORKER.ID))
  print(sprintf('workder %d', WORKER.ID))
  flush.console()
               })

## Initiate cluster
clusterEvalQ(cl, {
  library(KoNLP)
  Sys.sleep(timesleep[which(WORKER.ID %in% pidds)])
  buildDictionary(ext_dic = c('woorimalsam'))
})

#테스트
clusterEvalQ(cl, {
  extractNoun('롯데마트는 좋은 음식을 판매하기 위해 노력하고 있다.')
  })

system.time({
  namu_nouns <- clusterApply(cl, namus,function(sent){
    cnt <<- cnt + 1
    if(cnt %% 5000 == 0){
      print(sprintf('%s , worker id : %s, cnt : %d', date(), WORKER.ID, cnt))
      flush.console()
    }
    extractNoun(sent)
    })
})

clusterEvalQ(cl, {sink()})


stopCluster(cl)

위 코드는 KoNLP의 명사추출 함수를 멀티코어로 수행하기 위한 코드이다. 코드를 보면 알겠지만 사전 적용 시간을 워커마다 다르게 줬다는 걸 알 수 있는데, 이는 멀티코어 용으로 개발되지 않은 KoNLP의 오작동을 방지하기 위한 방어로직 부분이다. 나머지 부분들은 일반적인 명사 추출 로직이다. 3GB 텍스트에서 명사를 모두 추출하는데 필자의 머신으로 약 3시간 정도 소요되었다(필자 머신의 코어수는 8개다).

학습셋 만들기 – 데이터 전처리

각 단어마다 인덱스를 부여하고 이 인덱스 숫자를 기반으로 학습셋을 구축하는 코드이다. skip range는 3으로 두고 작업했다.

library(hashmap)

build_dataset <- function(words){
  uniq_words <- unique(unlist(words))
  uniq_words <- Filter(function(x){nchar(x) <= 10 & nchar(x) >= 1}, uniq_words)
  voca <- hashmap(keys=uniq_words, values=seq(0, length(uniq_words) -1))
  voca_rev <- hashmap(keys=seq(0, length(uniq_words) - 1), values=uniq_words)
  return(list(voca, voca_rev))
}
#이전 코드에서 만들어둔 문장별 명사 리스트 
load('namu_wiki_nouns.RData')

voca<- build_dataset(namu_nouns)
voca_dic <- voca[[1]]
voca_revdic <- voca[[2]]
voca_dic_raw <- voca_dic$data()

#일단 저장 
save(voca_dic_raw, file='voca_dic_raw.RData')



#voca$keys()[1:100]
library(data.table)
library(parallel)

no_cores <- detectCores()  + 20


cl <- makeCluster(no_cores,type = 'FORK')


pids <- clusterApply(cl, seq(along=cl), function(id) WORKER.ID <<- id)

cnt <- 0

#문장 처리수 로깅을 위함 
clusterExport(cl, c('cnt'))

clusterEvalQ(cl, {
  head(voca_dic$data())
  print(cnt)
  })


clusterEvalQ(cl, {
  sink(sprintf("%d_cooccr.log", WORKER.ID))
  print(sprintf('workder %d', WORKER.ID))
  flush.console()
})


## 실제 학습 데이터를 생성하는 단계 
## 최종적으로 word, label 컬럼을 가지고 있는 큰 data.table이 생성된다. 
system.time({
  word_labels <- clusterApply(cl, namu_nouns, function(sent, n=3){
    cnt <<- cnt + 1
    if(cnt %% 5000 == 0){
      print(sprintf('%s , worker id : %s, cnt : %d', date(), WORKER.ID, cnt))
      flush.console()
    }
    labels.dt <- list()
    sent <- Filter(function(x){nchar(x) <= 10 & nchar(x) >= 1}, sent)
    i <- 1
    for(w_idx in 1:length(sent)){
      w <- voca_dic[[sent[w_idx]]]
      pr <- n
      if(w_idx + pr > length(sent)){
        pr <- length(sent) - w_idx
      }
      if(pr >= 1){
        sibr <- voca_dic[[sent[(w_idx + 1):(w_idx+pr)]]]
        labels.dt[[i]] <- data.table(word=w,label=sibr)
        i <- i + 1
      }
      pl <- n
      if(w_idx - pl <= 0){
        pl <- w_idx - 1
      }

      if(pl >= 1){
        sibl <- voca_dic[[sent[(w_idx-pl):(w_idx - 1)]]]
        labels.dt[[i]] <- data.table(word=w,label=sibl)
        i <- i + 1
      }
    }
    rbindlist(labels.dt)
  })
})

clusterEvalQ(cl, {sink()})

stopCluster(cl)

word_labels_dt <- rbindlist(word_labels)

word2vector TensorFlow 학습

아래 코드는 TensorFlow R기반 코드이며, 시중에 있는 코드와 크게 다를 부분은 없으니, 관련된 부가적 설명은 인터넷 자료를 참고하기 바란다.

학습중 GPU 사용량은 대략적으로 아래와 같다. 첫번째 GPU는 모형 평가쪽 코드가 구동되며, 두번째 GPU에서는 전반적인 학습이 수행되게 했다.

''

library(tensorflow)
library(hashmap)
library(data.table)

load("voca_dic_raw.RData")

voca_dic <- hashmap(names(voca_dic_raw), values = as.integer(voca_dic_raw))
voca_revdic <- hashmap( as.integer(voca_dic_raw), values=names(voca_dic_raw))


load("word_labels_dt.RData")


### tensorflow code 
vocabulary_size <- as.integer(voca_dic$size())

batch_size <- 500L
num_batch <- nrow(word_labels_dt)/batch_size

embedding_size = 300L 
valid_examples <- as.integer(c(voca_dic[[c('한국', '사랑', '사과')]]))
valid_size = length(valid_examples) ## Random set of words to evaluate similarity on.
num_sampled = 250L ## Number of negative examples to sample.


tf$reset_default_graph()
w2v_graph <- tf$Graph()

with(w2v_graph$as_default(),{
  with(tf$device('/gpu:1'), {
    ## Input data.
    train_dataset <- tf$placeholder(tf$int32, shape=c(NULL))
    train_labels <- tf$placeholder(tf$int32, shape=c(NULL))
    valid_dataset <- tf$constant(valid_examples, dtype=tf$int32)

    ## Variables.
    embeddings <- tf$get_variable(name='embedding',shape = c(vocabulary_size, embedding_size), 
                    initializer=tf$contrib$layers$xavier_initializer())
    softmax_weights <- tf$Variable(
      tf$truncated_normal(c(vocabulary_size, embedding_size),
                          stddev=1.0 / sqrt(embedding_size)))
    softmax_biases <- tf$Variable(tf$zeros(c(vocabulary_size)))

    ## Model.
    embed <- tf$nn$embedding_lookup(embeddings, train_dataset)
    ## Compute the softmax loss, using a sample of the negative labels each time.
    loss <- tf$reduce_mean(
      tf$nn$nce_loss(weights=softmax_weights, biases=softmax_biases, inputs=embed,
                     labels=tf$to_float(train_labels), num_sampled=num_sampled, num_classes=vocabulary_size))

    optimizer <- tf$train$AdagradOptimizer(0.8)$minimize(loss)
  })
  with(tf$device('/gpu:0'), {
    norm <- tf$sqrt(tf$reduce_sum(tf$square(embeddings), 1L, keep_dims=TRUE))
    normalized_embeddings <- embeddings / norm
    valid_embeddings <- tf$nn$embedding_lookup(
      normalized_embeddings, valid_dataset)
    similarity <- tf$matmul(valid_embeddings, tf$transpose(normalized_embeddings))
  })
  saver <- tf$train$Saver(max_to_keep=0L)
})


num_epoc <- 1000
config_proto <- tf$ConfigProto(allow_soft_placement=T,log_device_placement=T) 



with(tf$Session(graph=w2v_graph, config=config_proto) %as% sess, {
  tf$global_variables_initializer()$run()
  print('Initialized')
  average_loss <- 0

  for(epoc in 1:num_epoc){
    trainingIndices <- sample(1:num_batch, nrow(word_labels_dt), replace = TRUE)  
    word_labels_dt[,idx:=trainingIndices]
    split_word_labels_dt <- split(word_labels_dt,by='idx')
    print('starting batch!')
    bat_cnt <- 0 
    for(i in 1:num_batch){
      batch_x <- split_word_labels_dt[[i]][,word]
      batch_y <- as.matrix(split_word_labels_dt[[i]][,label])
      bat_cnt <- bat_cnt + 1
      if(bat_cnt %% 1000 == 0)
        print(sprintf("batch progress %f", bat_cnt/num_batch))
      loss_eval <- sess$run(list(optimizer, loss), feed_dict=dict(train_dataset=batch_x, train_labels=batch_y))

      average_loss <- average_loss + loss_eval[[2]]
    }
    save_path <- saver$save(sess=sess, save_path = sprintf("tf_model/model_%s.chkp", epoc), global_step =1L)

    average_loss <- average_loss/batch_size
    cat("\n\n")
    print(sprintf('Average loss at epoc %d: %f' , epoc, average_loss))
    average_loss <- 0

    sim <- similarity$eval()
    for(j in 1:valid_size){
      valid_word <- voca_revdic[[valid_examples[j]]]
      top_k <- 8 ## number of nearest neighbors
      nearest <- voca_revdic[[order(-sim[j,])[1:top_k]]]
      print(sprintf("%s nearest words %s/n", valid_word, paste0(nearest,collapse = ",")))
    }
  }
})

아래는 1 epoc 수행한 결과이다. 1 epoc 그러니까 셋의 전체(약 4천만건)를 한번 학습하는데 약 2분이 소요된 것을 알 수 있다. 필자가 이를 CPU에서 수행했을때는 이보다 6배 정도 시간이 더 소요 되었는데, 그나마 이정도 차이는 TensorFlow 컴파일 최적화의 덕택이라 판단된다(필자의 경우 직접 TensorFlow를 컴파일해 CPU최적화가 되어 있는 상황이었다. 이 때문에 Blas(행렬연산라이브러리) 최적화도 되었을 것이다.).

위 이미지에 따르면 쓸만한 정도의 word2vector 그래프를 얻기위해 갈길이 좀 멀것이라는 예상이 된다. 이런 저런 전처리와 수많은 재학습이 예상되는데 이에 적합한 머신은 많은 시간과 노력을 줄여줄 거라는건 자명한거 같다.


필자가 딥러닝 그리고 텐서플로를 R 기반으로 사용해본 결과 텐서플로를 위해서 Python을 해야될 필요를 전혀 느끼지 못했다. 그 정도로 패키지가 잘 구현되어 있다는 건데, 덕분에 팀 프로젝트에서 이를 기반으로 활발하게 모델링을 하고 있다.
RStudio github에 들어가 보면 거의 rmarkdown 정도의 별수를 기록하는 있는 것으로 보아 RStudio에서 내부적으로도 관심있게 개발하고 있는 패키지일 거라 예상한다. 이 패키지 덕분에 R의 데이터 전처리, 시각화 쪽의 간결함과 파워를 그대로 텐서플로에 활용할 수 있어서 너무 편리하다.

R, Python을 떠나서 텐서플로를 위시한 딥러닝 기술은 데이터 사이언스에 몸담고 있는 사람이라면 반드시 경험해야 될 필수 코스가 되었다고 생각한다. 그러니 시간과 장비 투자에 인색하지 말길 바란다.

CC BY-NC 4.0 딥러닝 머신 그리고 TensorFlow R word2vec 코드 구현/모델링 by from __future__ import dream is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License.

This entry was posted in Machine Learning, 데이터분석