• 파이썬 이터레이터

지난 글에서는, 생산자-소비자 패턴(Producer-Consumer Pattern)의 소비자 쪽의 코드를, 함축적이면서도 자연스럽게 기술할 수 있는 방법을 제공하는 이터레이터를 살펴봤습니다. 오늘은 생산자 쪽을 들여다봅니다.

앞서 Range 라는 클래스를 통해 이터레이터를 살펴보았습니다만, 이 코드에는 불편한 부분이 있습니다. 대부분의 작업은 __next__() 메쏘드를 통해 구현되는데, 매번 예전의 상태를 복구한 후, 작업을 수행하고, 다시 상태를 저장하는 작업을 반복하게 됩니다. Range 와 같은 간단한 작업에서야 문제될 것이 없지만, 알고리즘을 기술하는 자연스러운 방식에서 벗어나 있기 때문에, 작업이 복잡해질수록 점점 문제가 됩니다. 이런 스타일의 프로그래밍은 이벤트 주도형 프로그래밍(event-driven programming)에서 자주 등장하는데, 비동기 IO(Asynchronous IO) 나 GUI 프로그래밍을 해 보셨다면 이미 익숙할 겁니다.(지금 우리가 걷고 있는 길은 이 문제들에 대한 직접적인 해결책으로 이어집니다. 하지만 아직은 갈 길이 멉니다.)

파이썬에서는 제너레이터(generator)라는 이터레이터의 확장을 제공합니다. 이터레이터가 단지 프로토콜인데 반해, 제너레이터는 yield 라는 전용의 키워드를 통해 문법적인 특별함을 더합니다. Range 를 제너레이터로 다시 구현해 보겠습니다. (되도록 이터레이터 구현과 유사하게 코드를 구성했습니다.)

>>> def Range(n):
...     c = 0
...     while c < n:
...         yield c
...         c += 1
>>> for x in Range(3):
...     print(x)
0
1
2

파이썬은 함수 정의에 yield 키워드가 등장하면 그 함수 전체를 제너레이터로 인식하고, 특별한 VM 코드를 생성해냅니다. 함수의 코드를 재구성해서 같은 일을 하는 이터레이터를 만든 다음, 원래 함수는 그 이터레이터 인스턴스를 돌려주는 함수로 바꾼다고 보시면 됩니다.

>>> Range(3)
<generator object Range at 0x1017d3370>

제너레이터는 이터레이터입니다.

>>> r = Range(3)
>>> next(r)
0
>>> next(r)
1
>>> next(r)
2
>>> next(r)
Traceback (most recent call last):
  File "<console>", line 1, in <module>
StopIteration

이터레이터 구현과 제너레이터 구현간에는 이런 문법적인 차이가 있습니다.

• 이터레이터 구현에서 __next__() 의 return 값은, 제너레이터 구현에서는 yield 값으로 대체됩니다.
• 제너레이터에서 return 문은 StopIteration 예외를 일으킵니다. 함수의 끝에 도달해도 마찬가지 입니다. 파이썬 3 에서는 return 문이 값을 포함할 수도 있지만, 오늘 다룰 범위를 벗어납니다.

제너레이터를 위해 파이썬이 만들어내는 이터레이터를 제너레이터-이터레이터(generator-iterator)라고 부르는데, 이터레이터는 프로토콜인 반면 제너레이터-이터레이터는 실제 구현이 제공되는 것이라, 일반적인 이터레이터에서 지정하지 않은 동작들이 구체적으로 정의되기도 합니다.

가령 예외의 경우, 이터레이터의 __next__() 가 StopIteration 또는 그 외의 예외를 일으킨 후에 이터레이터가 어떤 상태가 되는지는 정의되어있지 않습니다. 하지만 제너레이터의 경우는 항상 이렇게 됩니다.

• 일단 StopIteration 예외가 일어나면 그 이후에는 계속 StopIteration 예외를 일으킵니다.
• StopIteration 이외의 예외가 일어나면, 일단 caller 에게 예외가 전달됩니다. 하지만 그 이후로는 계속 StopIteration 예외를 일으킵니다.

재진입(Reentrancy) 문제도 이터레이터에서는 정의되어있지 않습니다. 가령 __next__() 메쏘드 내에서 직접적이던 간접적이던 next(self)를 호출했을 때 어떤 일이 일어나야 할지 지정되어 있지 않다는 것입니다. 그러니 재귀적인 구현도 생각해볼 수 있습니다. 하지만 제너레이터에서는 재진입이 허락되지 않습니다.

>>> this = (lambda: (yield next(this)))()
>>> next(this)
Traceback (most recent call last):
  File "<console>", line 1, in <module>
  File "<console>", line 1, in <lambda>
ValueError: generator already executing

그런데 이 예에서 볼 수 있듯이 lambda 로 제너레이터를 만들어도 문제가 되지는 않습니다. 그런데 lambda 의 바디에는 문장(statement)이 아니라 표현식(expression) 이 온다는 것을 기억하십니까? yield 를 둘러싼 괄호가 yield 가 표현식임을 알려줍니다. 예 지금까지 저희는 yield 를 문장처럼 사용해 왔습니다만, 사실 yield 는 표현식입니다. 그러면 그 값은 뭘까요?

지금까지의 예 에서 yield 표현식(yield expression)의 값은 None 입니다.

>>> def G():
    while True:
        input = yield 'output'
        print(repr(input))
>>> g = G()
>>> next(g)
'output'
>>> next(g)
None
'output'

처음 인쇄된 'output' 은 next(g) 의 반환 값이고, 다음 next(g) 호출의 처음에 인쇄된 None 이 yield 표현식의 결과값입니다. 순서를 잘 기억하세요, 첫 번째 next() 에서 yield 로 값을 전달한 후에, 다음 next() 가 호출될 때야 비로소 yield 표현식이 값을 전달합니다.

caller 가 제너레이터로 값을 전달해 준다면 yield 표현식은 None 이외의 값을 가질 수 있습니다. 이를 위해 제너레이터에는 send() 라는 메쏘드가 제공됩니다.

>>> g = G()
>>> next(g)
'output'
>>> g.send('input')
'input'
'output'

None 이 send() 가 전달한 'input'으로 대체된 것을 확인하실 수 있습니다. 주의할 부분은 첫 번째 next(g) 대신 g.send('input') 을 사용할 수 없다는 것입니다.

>>> g = G()
>>> g.send('input')
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: can't send non-None value to a just-started generator

이유는 앞에서 주의를 부탁한 실행 순서 때문입니다. 첫 번째 yield 표현식은 최초의 yield 가 일어난 후에 전달됩니다. 즉 send() 메쏘드는 yield 로 값을 전달한 후에, caller 가 next() 나 send() 를 호출해주기를 기다리고 있는 제너레이터에만 사용될 수 있습니다. 꼭 send()를 사용해야 한다면 None 을 전달할 수 있습니다.

>>> g = G()
>>> g.send(None)
'output'

next(g) 는 g.send(None) 과 같은 의미로 해석됩니다.

제너레이터에는 send() 외에도 throw() 와 close() 라는 메쏘드가 더 제공됩니다. 이 메쏘드들은 나중에 다룰 기회가 있을 겁니다만, 제너레이터에 이런 기능들이 들어간 목적이 무엇일까요? 그 것은 바로 다음에 다룰 코루틴(coroutine) 때문입니다.

http://www.flowdas.com/blog/iterators-in-python/

대부분의 파이썬 튜토리얼들과는 달리 파이썬 3.3을 중심으로 기술하고 파이썬 2를 포함한 하위 버전에서 차이를 보이면 따로 설명합니다.

파이썬의 시퀀스는 for 루프로 탐색할 수 있습니다.

>>> for e in [1,2,3]: # 리스트
...     print(e)
1
2
3
>>> for e in (1,2,3): # 튜플
...     print(e)
1
2
3
>>> for e in 'abc': # 문자열
...     print(e)
a
b
c

for 루프는 시퀀스가 아닌 딕셔너리(dictionary)에서도 가능합니다.

>>> for k in {'a':1, 'b':2, 'c':3}: # 딕셔너리
...     print(k)
b
c
a

이 경우 딕셔너리의 키를 탐색하게 되는데, 키가 전달되는 순서는 정해지지 않았습니다. 때문에 여러분이 직접 실행할 경우, 위의 예와는 다른 순서로 키가 인쇄될 수 있습니다. 이터레이터(iterator)를 제공한다면 시퀀스가 아닌 타입도 for 루프로 탐색할 수 있습니다. 이터레이터는 내장 함수 iter() 를 사용해서 얻습니다.

>>> iter({})
<dict_keyiterator object at 0x108f7afc8>

이렇게 얻은 이터레이터를 탐색하려면 내장 함수 next() 를 사용하면 됩니다.

>>> it = iter({'a':1, 'b':2, 'c':3})
>>> print(next(it))
b
>>> print(next(it))
c
>>> print(next(it))
a
>>> next(it)
Traceback (most recent call last):
  File "<console>", line 1, in <module>
StopIteration

next() 를 사용해 한 번에 하나씩 탐색해 나가다가, StopIteration 예외가 발생하면 끝냅니다. 이러한 탐색 법에 대한 약속을 이터레이터 프로토콜(Iterator Protocol)이라고 부르는데, for 루프는 간결한 문법을 제공합니다.

>>> for e in container:
...     print(e)

는 다음과 같은 while 루프와 동일한 결과를 줍니다.

>>> it = iter(container)
>>> while True:
...     try:
...         e = next(it)
...         print(e)
...     except StopIteration:
...         break

사용자가 정의한 클래스가 이터레이터를 지원하려면 __iter__() 메쏘드를 정의하면 됩니다. iter() 는 객체의 __iter__() 메쏘드가 돌려주는 값을 이터레이터로 사용합니다. next() 에 이터레이터를 전달하면 이터레이터의 __next__() 메쏘드를 호출합니다. 때문에 최소한의 이터레이터는 이렇게 구성할 수 있습니다.

>>> class Range:
...     def __init__(self, n):
...         self.n = n
...         self.c = 0
...     def __iter__(self):
...         return self # 이터레이터인 경우는 자신을 돌려주면 됩니다.
...     def __next__(self):
...         if self.c < self.n:
...             v = self.c
...             self.c += 1
...             return v
...         else:
...             raise StopIteration
...     next = __next__ # 파이썬 2 에서는 __next__ 대신 next 를 사용합니다.
>>> for x in Range(3):
...     print(x)
0
1
2

Range 클래스는 이터레이터 외의 용도가 없습니다. 하지만 딕셔너리는 별도의 용도가 있고, 사실 딕셔너리는 이터레이터가 아닙니다.

>>> next({})
Traceback (most recent call last):
  File "<console>", line 1, in <module>
TypeError: 'dict' object is not an iterator

딕셔너리를 for 루프에 직접 사용할 수 있는 이유는 딕셔너리 역시 __iter__() 메쏘드를 제공하고 있기 때문입니다. 비슷한 방법으로 RangeFactory 라는 클래스를 만들어보면:

>>> class RangeFactory:
...     def __init__(self, n):
...         self.n = n
...     def __iter__(self):
...         return Range(self.n)
>>> for x in RangeFactory(3):
...     print(x)
0
1
2

__next__() 메쏘드를 제공하고 있지 않기 때문에 RangeFactory 의 인스턴스는 이터레이터가 아닙니다만, __iter__() 메쏘드를 통해 이터레이터(이 경우에는 Range 인스턴스)를 제공하고 있기 때문에 for 루프에서 사용될 수 있습니다. 사실은 이 용법 때문에 이터레이터에도 큰 의미 없는 __iter__() 메쏘드를 만들어주도록 요구하고 있습니다.

이렇게 for 루프에 이터레이터를 직접 요구하지 않고, 이터레이터를 만드는 객체를 요구함으로써, 많은 경우에 for 루프가 깔끔해지기는 하지만, 간혹 혼란을 야기할 수 있는 경우도 발생할 수 있습니다.

>>> r = Range(3)
>>> for x in r:
...     print(x)
...     if x == 1:
...         break
0
1
>>> for x in r:
...     print(x)
2

두 개의 for 루프는 동일한 Range 인스턴스를 사용하고 있습니다. 반면에 RangeFactory 를 사용하는 경우는:

>>> r = RangeFactory(3)
>>> for x in r:
...     print(x)
...     if x == 1:
...         break
0
1
>>> for x in r:
...     print(x)
0
1
2

이 경우는 for 루프를 시작할 때마다 새로운 이터레이터(Range 인스턴스)가 만들어집니다. 때문에 매번 새로운 루프가 시작되는 것이지요. for 루프가 이터레이터를 재사용하는 것으로 보일 때는, 인스턴스가 이터레이터인지 이터레이터를 제공하는 객체인지를 확인하는 것이 중요할 수 있습니다.

프로그래밍을 하다 보면 한쪽에서 생산하고(produce), 다른 쪽에서 소비(consume) 하는 상황을 자주 만납니다. 이를 생산자-소비자 패턴(Producer-Consumer Pattern)이라고 하는데, 이터레이터는 소비자 쪽의 코드를 함축적이면서도 자연스럽게 기술할 수 있는 방법을 제공합니다. 이제 필요한 것은 생산자 쪽의 코드를 자연스럽게 구성할 수 있는 방법입니다. 다음에 다룰 제너레이터(Generator) 가 파이썬의 대답입니다.

• 파이썬 제너레이터

import pymongo

con = pymongo.Connection('localhost', port=27017)

tweets = con.db.tweets

import requests, json

url = 'http://search.twitter.com/search.json?q=python%20pandas'

data = json.loads(requests.get(url).text)

for tweet in data['results']:

    tweets.save(tweet)

cursor = tweets.find({'from_user' : 'wesmckinn'})

tweet_fields = ['created_at', 'from_user', 'id', 'text']

result = pd.DataFrame(list(cursor), columns=tweet_fields)

지난번에 다룬 keras를 활용해서 LSTM(Long Short-Term Memory)을 이용한 감성 분석을 해보겠습니다.

데이터는 이전과 마찬가지로 train/test 각각 2천개 씩 배정해서 모델을 학습하고, test set에 대한 accuracy를 구하는 과정으로 진행됩니다.

Keras에는 imdb 데이터가 이미 전처리되어 저장되어있기 때문에 그대로 불러옵니다. 이때 상위 5000개의 단어만 활용하겠습니다.

train/test 데이터를 알맞은 형태로 바꿔주고

lstm을 이용해서 모델을 만들어줍니다. 모델에 대한 설명은 다른 포스팅을 통해 다루겠습니다.

위와 같은 옵션으로 컴파일링을 하고 fitting을 시킨 다음 test data를 학습합니다.

0.76의 accuracy가 나왔습니다.

지금까지 여러가지 statistical methods를 통해 분석을 해보았습니다. 그 결과 2000개의 train data에 대해서

SentiWordnet : 71%

Naive Bayes : 82%

Doc2Vec : 91.8%

LSTM : 76%

의 정확도를 보였습니다.

물론 가장 기본적인 모형만 만들었기 때문에 parameter를 튜닝하거나 모델을 변형해서 더 나은 accuracy를 만들수 있을 것입니다.

저번 시간의 Naive Bayes Classifier에 이어서 Doc2Vec에 대해 알아보겠습니다.

Doc2Vec은 벡터 공간 모형의 일종으로 간단한 신경망 모형을 통해 만들어지는 모델입니다.

Word2Vec과 유사하지만 단어가 아닌 문장, 문단, 문서를 통해 벡터를 만들기 때문에 단어간의 유사성 뿐만 아니라 문서의 구성요소간의 유사성을 정의하고 계산할 수 있습니다.

즉, 문맥을 고려한 분석이 가능하다는 것이 가장 큰 장점입니다.

Doc2Vec을 활용한 감성 분석을 하기 위해 먼저 gensim 외 필요한 패키지를 불러옵니다.

Doc2Vec 모델 생성을 위한 gensim 패키지!

Text preprocessing 을 위한 nltk패키지

Naive Bayes와 같은 방식을 통해 전처리와 train/test data셋을 생성합니다.

리뷰 리스트와 레이블 리스트를 합쳐서 LabeledLineSentence 객체를 생성합니다.

그 다음 Doc2Vec모델을 다음과 같이 학습시킵니다.

size 는 feature 벡터의 차원입니다.

window는 문서의 내에서의 예측을 위한 예측된 단어와 문맥의 단어들 사이의 최대 거리입니다.

dm은 트레이닝 알고리즘으로 distributed memory가 default 값입니다.

alpha값은 초기 학습률(learning rate)이고 min_alpha는 alpha값이 학습과정에서 선형으로 줄어들어서 도달하는 최소 값입니다.

min_count 이하의 total frequency를 가진 단어들은 모두 무시됩니다.

workers는 cpu의 코어 수에 따라 multi-threads를 지원해서 병렬처리하는 옵션입니다.

그 밖의 옵션에 대한 설명은 https://radimrehurek.com/gensim/models/doc2vec.html을 참고해 주세요.

이제 생성된 모델을 통해서 앞서 NBC와 같이 train 셋에 대해 감성 분석을 시행하겠습니다.

logistic regression classifier를 이용해서 긍, 부정으로 분류하였습니다.

test 셋에서 출력해본 결과 약 91.65%의 정확도를 보였습니다. NBC보다 높은 정확도를 보였지만 전체데이터(25000)를 대상으로 한 경우 정확도가 79%대로 떨어지는 모습을 보였습니다.

특정 분석법이 절대 우위에 있는 것이 아니라 다양한 분석방법을 시행해보고 결과를 비교해 보는 것이 좋은 방법 같습니다.

다음 시간에는 감성 분석의 마지막 시간으로 인공신경망(ANN)을 활용한 감성분석을 해보도록 하겠습니다.

저번 포스팅에서는 Sentiment Analysis(SA)의 방법 중 하나인 knowledge based technique에 대해서 살펴봤습니다.

이번에는 Statistical methods을 통해서 감성 분석을 해보겠습니다.

1. Naive Bayes classifier

나이브 베이즈 분류기를 다루기 전에 먼저 TF-IDF(Term Frequency – Inverse Document Frequency)와 같은 벡터 공간 모형에 대해서 알아보겠습니다.

TF_IDF는 이와 같은 형태로 문장에서 해당하는 단어의 등장 여부에 따라서 다음과 같이 나타냅니다. 이 때 단어의 등장여부를 T/F로 보는 boolean model, 단어의 등장 횟수로 보는 frequency model 둘다 가능합니다.

여기서 자주 등장하는 단어를 통해 하나하나의 dimension을 생성하는 것이 벡터 공간 모형의 기초적인 형태입니다. 그리고 이러한 feature에 기계학습 알고리즘을 통해서 train을 진행합니다.

먼저 긍정 학습 데이터에서의 모든 토큰을 words라는 리스트에 저장합니다.  이때  Stopwords도 함께 제거해줍니다

같은 방식으로 부정 학습 데이터에서 Stopwords 를 제거하고 words리스트에 붙여 넣습니다.

words리스트를 이용해서 3000 dimension의 word feature를 생성합니다.

word feature를 통해서 분석할 데이터의 feature를 생성하는 함수도 만들어 줍니다.

이제 첫번째 리뷰 데이터의 문장들을 이용해서 feature를 생성해보겠습니다.

첫 번째 리뷰 데이터의 feature생성 결과입니다.

같은 방법으로 1000개의 리뷰 데이터에 대해 feature set을 생성해서 리스트에 저장합니다.

본격적으로 나이브 베이즈 분류기(Naive Bayes Classifier)를 통해 감성분석을 시작하겠습니다. 분류기는 nltk에 내장되어 있기 때문에 따로 설치할 것은 없습니다.

가장 먼저 2000개의 영화 리뷰를 긍/부정으로 분류해보겠습니다.

training,test set을 위한 feature set을 만들어준다음

순서대로 앞의 2000 set은 training 나머지는 test set으로 분류합니다

그 다음 nltk의 나이브 베이즈 분류기를 실행해주면 됩니다. 전처리에 비해 정말 간단합니다…

분류기를 training한 뒤에는 test set에서 얼마나 잘 작동하는지 살펴봅니다.

82%의 분류율이 나옵니다. 샘플 데이터라서 그런지 생각보다 높은 분류율을 보여주는 것 같네요. 같은 방법으로 전체 데이터(train 25000, test 25000)으로 한 결과 82.756의 정확도로 2000개의 train 데이터의 경우와 비교해 크게 향상되진 않았습니다.

다음 포스팅에서는 나머지 감성 분석 방법들에 대해 알아보겠습니다.

책, 영화등과 같은 매체를 보고나면 그에 대한 피드백이 발생합니다. 어떤 사람들은 주위 지인들에게 평가를 공유하기도 하고 어떤 사람들은 어떤 인상을 받았는지 인터넷 상에 글을 남깁니다. 이번 포스팅에서는 이러한 리뷰들의 단어에 긍/부정을 평가하여 그 리뷰, 더나아가 그 영화에 대한 감정이 긍정적인지 부정적인지 살펴보려고 합니다.

Sentiment Analysis(SA) 에는 크게 세 가지 방식이 있습니다.

• knowledge-based techniques
• statistical methods
• hybrid approaches

먼저 knowledge-based technique은 단어들의 감정의 정도를 평가하는 사전을 만들고 이를 활용해서 단어 또는 글의 감정 상태를 평가하는 방법입니다.

예를 들어 SentiWordnet은 단어 마다의 긍/부정 척도를 더한 대표적인 db로 Python의 nltk에 포함되어 있습니다.

다음으로 statistical method는 SVM(support vector machine)이나 ‘bag of words’등 다양한 ML 방법론을 활용해서 단어의 감정을 분류하는 방법입니다. Python의 nltk 패키지에 naive bayes classifier도 통계적 방법 중 하나입니다.

마지막으로 hybrid approaches의 경우 두 방법을 적절하게 혼합하여 활용하는 방법입니다.

SA에서 가장 힘든 부분 중 하나는 비정형인 자연어의 노이즈들이 많다는 점입니다. 인간의 경우 다양한 문맥에 따라서 흐름을 쉽게 파악할 수 있지만 기계는 어렵습니다.

예를 들어 ‘내가 치킨을 싫어하는 것은 아니야.’ 라는 문장을 보았을 때 사람들은 이 문장이 postive 또는  neutral 하다고 쉽게 판단하지만 긍/부정 단어에 점수를 매기는 knowledge-based technique에서는 negative 문장으로 해석될 수 있습니다. 이처럼 이중 부정문을 다루거나 비속어, 은유, 비유 또는 풍자 등과 같은 skill을 학습하기 힘들기 때문에 현재까지는 한계점이 뚜렸하다고 생각합니다.

네이버 평점 9점대에 빛나는 바로 그 영화! – sarcastic review의 대표적인 사례

이제 본격적으로 샘플 데이터를 활용해서 SA를 해보겠습니다.

http://ai.stanford.edu/~amaas/data/sentiment/

에서 데이터셋을 받습니다. 이 데이터는 IMDb라는 미국 영화 사이트의 리뷰를 50,000개 수집하여 리뷰마다 각각 긍/부정 분류로 나눈 데이터 셋입니다.

os 패키지는 operating system의 약자로 운영체제에서 쓰는 여러 기능들을 python에서도 쓸수 있게 해주는 패키지입니다.

먼저 긍정 리뷰중 하나를 review에 담았습니다.

제대로 리뷰가 담긴것을 확인하시면 for문을 이용해서 전체 긍정 리뷰를 pos_train_list에 저장합니다.

train positive 리뷰를 모두 저장했다면 이제 knowledge-based techniques 중 하나인 SentiWordNet에 대해 알아보겠습니다.

[SentiSynset(‘hate.n.01’), SentiSynset(‘hate.v.01’)]

sentiwordnet을 쓰기 위해 nltk 패키지를 import하고 ‘hate’라는 단어를 불러왔습니다. filter object 타입을 list로 바꾸면 n, v로 각각 명사 동사의 유의어가 나온것을 볼 수 있습니다.

0.0

0.75

hate라는 동사의 긍/부정 스코어를 확인하면 각각 0, 0.75점 입니다.

단어마다 여러 유의어가 존재하는 경우가 있습니다. 그래서 편의를 위해 특정 단어의 모든 유의어의 긍/부정 스코어를 각각 평균한 것으로 쓰기 위해 함수를 정의합니다.

(0.625, 0.03125)

love의 동사 유의어 점수 평균은 0.625이다.

2.5/4=0.625이므로 잘 동작하는 것을 알 수 있습니다.

원리를 그대로 사용해서 for문을 이용하면 문장에서의 긍/부정 지수도 쉽게 구할 수 있습니다.

이제 본격적으로 아까 다운받은 영화 리뷰 자료에서 postive train 리뷰 10가지와 negative train 리뷰 10가지를 불러와 SA를 해보겠습니다.

긍정적 리뷰와 부정적 리뷰를 순서대로 10개씩 불러왔기 때문에 actual에는 1(긍정)을 10번 반복하고 0(부정)을 10번 반복했습니다. 그 다음 과정은 앞과 마찬가지로 리뷰를 10개씩 불러와서 tokenize를 하고 pos_tag를 붙여서 리스트로 만들어주는 작업입니다. 합산된 긍/부정 스코어를 if문을 통해 대소비교를 하는데, 긍정 수치가 높으면 1을 반환하고 그렇지 않다면 0을 predicted에 반환합니다.

[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1]
Number of correct instance: 12
Number of incorrect instance: 8

코드를 실행하면 다음과 같은 결과가 출력됩니다. 60%의 확률로 긍/부정 리뷰를 맞추는 성능을 보이고 있습니다.

다음 포스팅에서는 statistical methods중 하나인 Naive Bayes를 통한 감성 분석에 대해 알아보겠습니다.

첫번째 글에 이어서 이번에는 단어들간의 관계를 살펴보도록 하겠습니다.

similarity를 구해 리뷰의 단어 중 문맥상 서로 유사한 단어를 살펴보겠습니다.

텍스트의 연어(Collocation)을 출력해보면 아래와 같습니다.

dark knight; heath ledger; christian bale; harvey dent; comic book; christopher nolan; brucewayne; aaron eckhart; gary oldman; two face; maggie gyllenhaal; morgan freeman; rachel dawes;special effects; batman begins; gotham city; 've seen; district attorney; michael caine; superhero

빈번하게 같이 사용되는 단어들이 출력된 것을 확인할 수 있습니다.

마지막으로 연관 단어 그래프를 만들어 보도록 하겠습니다.

리뷰의 텍스트를 바탕으로 같은 문장에서 등장하는 명사들끼리 연결된 그래프를 만드려고 합니다. 먼저 unique 명사들을 추출해서 uniqueNouns 리스트에 추가하는 과정입니다.

위와 같이 행렬을 생성한 다음

이중 for문을 이용해 각 원소에 명사가 들어온 경우 1의 값을 반환하게 합니다.

그리고 이 행렬의 전치와 곱하여 co-occurrence matrix(동시 발생 행렬)를 생성합니다

행렬에서 값이 30이상은 결과 값을 이용해 노드를 만들었습니다.

http://www.imdb.com/title/tt0110912/?ref_=nv_sr_1

영어로 된 영화 평점 사이트에서 리뷰를 크롤링하고 간단한 텍스트 마이닝을 해보겠습니다.

먼저 토큰화(tokenize), 기본형 형태로 만들기(lemmatize)와 stopwords를 제거하는 작업을 했습니다.

Dark knight라는 영화의 리뷰 100개를 크롤링하여 만든 텍스트 파일을 불러와서 위의 순서로 코딩했습니다. 참고로 stopwords의 경우 소문자의 형태만 인식하기 때문에 .lower()를 통해 토큰을 전부 소문자로 변환했습니다.

결과를 다시 텍스트 파일로 저장하고…

이제 이 리뷰에서 가장 많이 등장하는 명사를 추출해보겠습니다.

혹시 중간에 nltk패키지의 오류로 실행이 안되면 nltk.download()를 입력해서 필요한 것을 받을 수 있습니다.

[('movie', 340), ('batman', 249), ('film', 247), ('joker', 177), ('dark', 113), ('ledger', 100),('knight', 95), ('heath', 88), ('time', 83), ('action', 67)]

결과를 출력하면 다음과 같이 리뷰에서 가장 많이 등장한 10개의 단어가 빈도 순으로 출력된 것을 볼 수 있습니다.

동사와 형용사도 동일한 방법으로 추출하시면 됩니다.

전체 리뷰의 토큰 개수를 구할 수도 있습니다.

20575 6069

그래프를 이용해서 토큰의 등장 횟수를 시각화 할 수도 있습니다

‘이나 ‘s와 같은 보통의 상황에서는 불필요한 단어들이 많이 등장하는데 stopwords에서 추가적으로 옵션을 두어 필터링이 되도록 하는 방법도 있습니다.

시각화에서 데이터가 어떤 특징을 지니고 있는지 확인했으니 이번에는 영화 리뷰 간 유사성을 계산해보겠습니다. 이와 같은 분석 말고도 영화 평에 대한 감성 분석과 같은 여러 분석 방법들이 있습니다.

먼저 분석하려는 영화의 리뷰들을 String 형식의 데이터로 받아보겠습니다.

review_list=[]
for n in range(30):
url = ‘http://movie.daum.net/moviedb/grade?movieId=97728&type=netizen&page={}’.format(n+1)
webpage = urlopen(url)
source = BeautifulSoup(webpage,’html.parser’,from_encoding=’utf-8′)
reviews = source.findAll(‘p’,{‘class’: ‘desc_review’})
for review in reviews:
review_list.append(review.get_text().strip().replace(‘\n’,”).replace(‘\t’,”).replace(‘\r’,”))

file = open(‘okja.txt’,’w’,encoding=’utf-8′)

for review in review_list:
file.write(review+’\n’)

file.close()

doc1 = ”
file = open(‘okja.txt‘,’r’,encoding=’utf-8′)
lines = file.readlines()
for line in lines:
doc1 += line
file.close()

영화 ‘옥자’의 리뷰를 받아와서 doc1에 저장하였습니다. 이처럼 나머지 영화들도 doc2, doc3 과 같은 형식으로 저장했습니다.

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
corpus = [doc1, doc2, doc3]
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(corpus)
X=X.todense()

sklearn 모듈을 이용해서 TF-IDF로 벡터화를 하고 코사인 유사도를 사용합니다. 세 리뷰의 명사들 간의 코사인 유사도를 활용해서 유사성이 얼마나 있는지 알아보겠습니다.

print(“similarity between ‘okja’ and ‘monster’:”,cosine_similarity(X[0],X[1]))
print(“similarity between ‘okja’ and ‘real’:”,cosine_similarity(X[0],X[2]))
print(“similarity between ‘monster’ and ‘real’:”,cosine_similarity(X[1],X[2]))

 

 

>similarity between ‘okja’ and ‘monster’: [[ 0.26134023]]

>similarity between ‘okja’ and ‘real’: [[ 0.3445885]]

>similarity between ‘monster’ and ‘real’: [[ 0.27664574]]

구한 코사인 유사도를 프린트하면 다음과 같은 결과가 나오게 됩니다.

이번에는 저번 포스팅에서 처리한 데이터를 이용해서 시각화를 해보겠습니다.

먼저 예전에 설치한 pytagcloud 모듈을 불러옵니다. 이 때 pytagcloud는 기본적으로 한국어 폰트를 지원하지 않기 때문에 사용자가 직접 한국어 폰트를 추가해야 합니다.

https://www.google.com/get/noto/

위 사이트에 접속하셔서 Noto Sans CJK KR을 검색하셔서 파일을 아래의 경로로 받아주시면 됩니다.

C:\Users\[사용자 id]\Anaconda3\Lib\site-packages\pytagcloud\fonts

받은 다음 압축을 풀고 fonts 폴더에 otf파일을 붙여넣은 뒤, fonts.json 파일을 텍스트 에디터를 이용해서 열어줍니다.

(저는 Notepad++을 사용합니다.)

{
“name”: “Noto Sans CJK”,
“ttf”: “NotoSansCJKkr-Medium.otf”,
“web”: “http://fonts.googleapis.com/css?family=Nobile”
}

그리고 위의 문장을 추가하시면 됩니다. 혹시라도 중괄호 사이에 쉼표가 빠진다면 정상적으로 동작하지 않기 때문에 주의하셔야 합니다.

import pytagcloud, random, webbrowser
from konlpy.tag import Twitter
from collections import Counter

다시 notebook으로 돌아와서 위와 같이 입력합니다.

def get_tags(text,ntags=100,multiplier=1):
t = Twitter()
nouns = []
for sentence in text:
for noun in t.nouns(sentence):

nouns.append(noun)
count = Counter(nouns)
return [{‘color’:color(),’tag’:n,’size’:2*c*multiplier} for n,c in count.most_common(ntags)]

get_tags라는 함수를 만들어서 워드클라우드에 포함될 명사를 추출했습니다. return에서 텍스트의 color와 size를 조절할 수 있습니다.

def draw_cloud(tags, filename, fontname = ‘Noto Sans CJK’,size = (1100,660)):
pytagcloud.create_tag_image(tags,filename,fontname=fontname,size=size)
webbrowser.open(filename)

다음으로 워드클라우드가 출력되는 space를 만들겠습니다. font와 size를 각각 조절할 수 있습니다.

r = lambda: random.randint(0,255)
color = lambda: (r(),r(),r())

입력되는 단어를 구분하기 위해 색을 추출하는 과정입니다. rgb값(0~255)에 랜덤 값을 각각 부여해서 새로운 색상이 나타나도록 했습니다.

okjak = []
file=open(‘okja.txt’,’r’,encoding=’utf-8′)
lines = file .readlines()
for line in lines:
okjak.append(line)
file.close()

tags = get_tags(okjak)
draw_cloud(tags,’wc.png’)

이제 okja.txt를 python으로 불러와서 앞서 작성한 2개의 function을 이용해서 워드클라우드를 작성합니다.

위와 같이 워드클라우드가 생성된 것을 확인 할 수 있습니다.

okja = []
file = open(‘okja.txt’,’r’,encoding=’utf-8′)
lines=file.readlines()

for line in lines:
okja.append(line)
file.close()

먼저 저번 포스팅에서 수집한 데이터를 불러와서 옥자라는 객체에 저장합니다.

from konlpy.tag import Twitter

twitter = Twitter()

sentences_tag=[]
for sentence in okja:
sentences_tag.append(twitter.pos(sentence))

그다음 저번에 설치한 KoNLPy 모듈을 불러와서 sentences_tag라는 리스트 형태로 저장합니다.

print(sentences_tag)
print(‘-‘*30)
print(len(sentences_tag))

를 입력하시면,

이와 같은 형태로 추출된 token과 token의 형태소 분석 결과를 출력합니다. 300개의 token이 출력된 것을 볼 수 있습니다.

이제 자주 사용되는 단어를 추출하겠습니다.

noun_adj_list = []

for sentence in sentences_tag:
for word, tag in sentence:
if tag in [‘Noun’,’Adjective’]:
noun_adj_list.append(word)

먼저 분석에 중요한 품사로 판단되는 명사와 형용사 token만 추출하여 noun_adj_list에 담았습니다.

from collections import Counter
counts = Counter(noun_adj_list)
print(counts.most_common(10))

collections모듈을 이용해서 most frequent word 10가지를 출력한 결과입니다.

텍스트를 분석 역시 일반적인 데이터 분석처럼 데이터 수집 -> 데이터 전처리 -> EDA -> 데이터 분석 -> knowledge 도출의 단계를 거칩니다. 하지만 unstructured data인 관계로 데이터의 수집과 전처리 과정에서 큰 차이가 나타납니다.

이번 포스팅에서는 movie.daum.net의 영화 리뷰 댓글을 이용해서 데이터를 수집하려고 합니다.

Jupyter notebook에서 새로운 스크립트를 만들고 제일 윗 부분에

#-*- coding: utf-8 -*-

를 입력합니다 기본적으로 윈도우 환경의 Python은 ANSI 형식을 따르기 때문에 한글이 깨지는 경우가 발생합니다. 그래서 기본 인코딩 형식을 utf-8로 바꾸셔야 텍스트를 불러왔을때 깨지지 않게 됩니다.

from urllib.request import urlopen

from bs4 import BeautifulSoup

전에 설치한 크롤링 모듈을 불러옵니다.

먼저 한 페이지의 리뷰들을 불러오는 과정을 살펴보겠습니다.

url=’http://movie.daum.net/moviedb/grade?movieId=97728&type=netizen&page=2′

webpage=urlopen(url)

먼저 urlopen을 이용해 url주소의 리뷰 데이터를 객체에 저장합니다.

source = BeautifulSoup(webpage,’html.parser’,from_encoding=’utf-8′)

HTML형식으로 된 데이터를 parsing하여 텍스트 형태로 변환합니다.

reviews = source.findAll(‘p’,{‘class’: ‘desc_review’})

for review in reviews:

print(review.get_text().strip())

HTML 소스 코드를 보면 <p class=”desc_review”>내용</p> 형태로 데이터가 저장되어 있습니다. 그래서 reviews라는 객체에 이와 같은 양식을 모두 찾아 list형식으로 변환했습니다. 또한 get_text()를 이용해 텍스트 데이터만 추출하고 strip()을 통해 공백을 제거했습니다.

2페이지의 리뷰들을 모두 추출했는데 for문을 통해 url을 리스트 형식으로 만들어 여러 페이지의 데이터를 추출할 수 있습니다.

review_list=[]
for n in range(10):
url = ‘http://movie.daum.net/moviedb/grade?movieId=97728&type=netizen&page={}’.format(n+1)
webpage = urlopen(url)
source = BeautifulSoup(webpage,’html.parser’,from_encoding=’utf-8′)
reviews = source.findAll(‘p’,{‘class’: ‘desc_review’})
for review in reviews:
review_list.append(review.get_text().strip().replace(‘\n’,”).replace(‘\t’,”).replace(‘\r’,”))

그 다음 추출한 텍스트 데이터를 txt파일로 저장합니다.

file = open(‘okja.txt’,’w’,encoding=’utf-8′)

for review in review_list:
file.write(review+’\n’)
file.close()

이번 포스팅에서는 Python을 활용하여 웹페이지에서 텍스트를 추출하고 이를 워드클라우드로 나타내고 텍스트들간의 유사도를 활용해 관련성을 구해보겠습니다.

파이썬 텍스트 마이닝은 간단한 편이지만 몇 가지 모듈을 설치해야 합니다.

웹 크롤링을 위해 Beautifulsoup4, 한국어 텍스트 분석을 위한 KoNLPy,워드 클라우드를 위한 pygame,simplejson,pytagcloud 가 필요합니다.

>pip install beautifulsoup4

cmd라인에서 다음과 같이 입력하여 먼저 beautifulsoup4 모듈을 설치하시고

http://www.lfd.uci.edu/~gohlke/pythonlibs/#jpype 로 가셔서 자신의 세팅에 맞는 JPype1-0.x.x-cp36-…whl 파일을 받으시면 됩니다. 글 작성 기준 버전은 0.6.2인데 최신버전으로 받으시면 될겁니다. 참고로 KoNLPy를 설치하시기 전에 Java가 설치되어있는지 확인하시고 없다면 설치해주시면 됩니다.

>pip install JPype1 …… .whl

cmd라인에서 파일을 받은 경로로 이동하신 뒤(cd 폴더명), 받은 파일의 이름을 install 뒤에 입력하시면 모듈이 설치됩니다.

>pip install pygame

>pip install simplejson

>pip install pytagcloud

cmd라인에 3개의 모듈을 설치하시면 됩니다.

pip install konlpy

다음 포스팅에서는 설치된 모듈을 통해 웹페이지에서 크롤링한 텍스트를 시각화 해보겠습니다.