def divide_with_morpheme(raw_data, total=1):
data = []
hannanum = Hannanum()
if total == 1:
for itr, article in enumerate(raw_data):
for sentence in article:
#print(sentence)
if sentence != '':
pos_result = hannanum.morphs(sentence)
tmp = " ".join(pos_result)
data.append(tmp)
print(str(itr)+ 'th article processed')
print('last sentence : ' + tmp)
return data
elif total ==0 :
for itr, article in enumerate(raw_data):
tmp_data = []
for sentence in article:
#print(sentence)
if sentence != '':
pos_result = hannanum.morphs(sentence)
tmp = " ".join(pos_result)
tmp_data.append(tmp)
print(str(itr)+ 'th article processed')
print('last sentence : ' + tmp)
data.append(tmp_data)
return data
def lineAnalyzer(sentence, analyzeType):
hannanum = Hannanum()
wordList = list()
if (analyzeType == 1):
# Nouns
wordList = hannanum.nouns(str(sentence))
elif (analyzeType == 2):
# Morphs
wordList = hannanum.morphs(str(sentence))
elif (analyzeType == 3):
# Bi-grams
bigram_measures = collocations.BigramAssocMeasures()
pos = hannanum.pos(str(sentence))
words = [s for s, t in pos]
finder = collocations.BigramCollocationFinder.from_words(words)
finder.apply_word_filter(lambda w: len(w) < 2)
finder.apply_freq_filter(3)
wordList = finder.nbest(bigram_measures.pmi, 10)
elif (analyzeType == 4):
# Tri-grams
trigram_measures = collocations.TrigramAssocMeasures()
pos = hannanum.pos(str(sentence))
words = [s for s, t in pos]
finder = collocations.TrigramCollocationFinder.from_words(words)
finder.apply_word_filter(lambda w: len(w) < 2)
finder.apply_freq_filter(3)
wordList = finder.nbest(trigram_measures.pmi, 10)
else:
print("error on top!")
return wordList
def parse(df, _type: str):
"""Parse function"""
# Parser
korean_parser = Hannanum()
neg = df[df['label'] == 0]['document'].tolist()
pos = df[df['label'] == 1]['document'].tolist()
nouns_doc_f = open('./input/nouns_{}_documents.txt'.format(_type), 'w')
nouns_label_f = open('./input/nouns_{}_labels.txt'.format(_type), 'w')
morphs_doc_f = open('./input/morphs_{}_documents.txt'.format(_type), 'w')
morphs_label_f = open('./input/morphs_{}_labels.txt'.format(_type), 'w')
logger.info("Starting parsing...")
for doc in neg:
try:
nouns_doc_f.write(','.join(korean_parser.nouns(doc)) + '\n')
nouns_label_f.write('{}\n'.format(0))
except:
pass
try:
morphs_doc_f.write(','.join(korean_parser.morphs(doc)) + '\n')
morphs_label_f.write('{}\n'.format(0))
except:
pass
logger.info('%s pos document parsing completed.' % _type)
for doc in pos:
try:
nouns_doc_f.write(','.join(korean_parser.nouns(doc)) + '\n')
nouns_label_f.write('{}\n'.format(1))
except:
pass
try:
morphs_doc_f.write(','.join(korean_parser.morphs(doc)) + '\n')
morphs_label_f.write('{}\n'.format(1))
except:
pass
logger.info('%s neg document parsing completed.' % _type)
nouns_doc_f.close()
nouns_label_f.close()
morphs_doc_f.close()
morphs_label_f.close()
def sentiment_analysis(tweet, tweets):
#1) 형태소로 나눈다.
content = tweet[1]
content_morphs = []
hannanum = Hannanum()
content_morphs = hannanum.morphs(content)
# print("형태소 분류: ", content_morphs)
#1)-2 띄어쓰기로 나눈다.
space = content.split(" ")
print(space)
#2) 불용어 제거하기
# 2) -1 불용어 불어오기 stopwords => 불용어 리스트
stopwords_file = open("불용어.txt", 'r', encoding='utf-8')
stopwords = []
lines = stopwords_file.readlines()
for line in lines:
line = line.replace("\n", "")
stopwords.append(line)
# 2) -2 불용어 제거하기
for i in content_morphs:
if i in stopwords:
content_morphs.remove(i)
# print("불용어 제거: " ,content_morphs)
#3) 형태소별 극성 계산
# data: 감성사전
with open('data/SentiWord_info.json', encoding='utf-8-sig', mode='r') as f:
data = json.load(f)
score = 0
for wordname in space:
for i in range(0, len(data)):
#어근 비교 및 단어 비교를 같이 한다.
if (data[i]['word_root'] == wordname) or (data[i]['word']
== wordname):
if data[i]['polarity'] != "None":
score += int(data[i]['polarity'])
break
if score > 0:
polarity = "positive"
elif score == 0:
polarity = "neutral"
else:
polarity = "negative"
tweet[4] = polarity
# hashtag_sentiment_analysis(tweet, tweets)
tweets.append(tweet)
print("content: ", content)
print("polarity: ", polarity)
def parse_line(self, path):
print("parse line start...")
hannanum = Hannanum()
lines = [line.strip() for line in open(path, "r", encoding="utf-8")]
data = []
# self.max_sentence_length = 0
for line in lines:
sbj, obj, rel, src = line.split("\t")
src = src.replace("<< _sbj_ >>", "<<_sbj_>>")
src = src.replace("<< _obj_ >>", "<<_obj_>>")
tokens = src.split()
e1 = tokens.index("<<_sbj_>>")
e2 = tokens.index("<<_obj_>>")
src = src.replace("<<_sbj_>>", sbj)
src = src.replace("<<_obj_>>", obj)
# src = re.sub(r'\([^)]*\)', '', src)
src = src.strip()
# tokens = [p[0] + '/' + p[1] for p in hannanum.pos(src)]
tokens = hannanum.morphs(src)
print(tokens)
# self.max_sentence_length = max(self.max_sentence_length, len(tokens))
pos1, pos2 = self.get_relative_position(tokens, e1, e2)
rel = self.labels[rel]
tokens = tokens[:self.max_sentence_length] + \
['UNK' for _ in range(self.max_sentence_length - len(tokens))]
dat = {
'sbj': sbj,
'obj': obj,
'rel': rel,
'src': src,
'tokens': tokens,
'pos1': pos1,
'pos2': pos2
}
data.append(dat)
return data
def run_hannanum():
hannanum = Hannanum()
start_time = time.time()
print('hannanum 시작')
hannanum_morphs = hannanum.morphs(news1)
hannanum_nouns = hannanum.nouns(news1)
hannanum_pos = hannanum.pos(news1)
end_time = time.time()
print('hannanum 끝 - %s 초' % str(end_time - start_time))
with open('hannanum.txt', 'w', encoding='utf-8') as fstream:
fstream.write('hannanum time : %s s\n' % str(end_time - start_time))
fstream.write('hannanum_morphs\n')
write_list(hannanum_morphs, fstream)
fstream.write('\n\n')
fstream.write('hannanum_nouns\n')
write_list(hannanum_nouns, fstream)
fstream.write('\n\n')
fstream.write('hannanum_pos\n')
write_pos(hannanum_pos, fstream)
fstream.write('\n')
def cut(fpath, lang):
fp = open(fpath, encoding='utf-8')
new_fp = open(data_dir + 'norm.seg.txt', 'w', encoding='utf-8')
# jieba中文分词
if lang == "zh":
os.system(
'python -m jieba -d " " ${data_dir}/norm.txt > ${data_dir}/norm.seg.txt'
)
# 日语分词
if lang == "jp":
mecab = MeCab.Tagger("-Owakati")
for line in fp.readlines():
newline = mecab.parse(str(line))
new_fp.write(newline)
# 韩语分词
if lang == "ko":
hannanum = Hannanum()
for line in fp.readlines():
seg_list = hannanum.morphs(line)
newline = " ".join(seg_list)
new_fp.write(newline + "\n")
fp.close()
new_fp.close()
import time
start = time.time()
from konlpy.tag import Hannanum
doc = input("문장을 입력해주세요 : ") ## 문장을 입력받는다
n = input("입력문장과 유사한 몇개의 문장을 출력할까요? : ") ## 유사한 문장을 몇개 출력할지 입력 받는다
print(" ")
hannanum = Hannanum() ##형태소 분석을 위하여 konlpy의 Hannanum class를 이용하여 준다
doc_tokenized = hannanum.morphs(doc) ##입력문장을 형태소 단위로 쪼개준다
doc_tokenized_size = len(doc_tokenized) ##입력문장의 형태소 개수
list = []
with open('KCCq28.txt', 'r', encoding='utf-8') as input: # 유사도 검사할 말뭉치를 가져옴
for line in input: ##말뭉치에서 라인 단위로 읽어준다
file_tokenized = hannanum.morphs(line) ##읽어들인 라인을 형태소 단위로 쪼개준다
file_tokenized_size = len(file_tokenized) ##읽어들인 라인의 형태소 개수
intersection_size = 0 ##교집합 형태소 개수를 초기화
for x in doc_tokenized:
if x in file_tokenized:
intersection_size += 1 ##입력문장과 라인문장을 비교하여 겹치는 형태소가 있다면 교집합 형태소 개수 증가시키기
if len(doc) <= len(line):
short = doc_tokenized_size
else:
short = file_tokenized_size ## 입력문장과 파일 각 문장의(라인단위) 길이를 비교하여 짧은 문장의 형태소 개수를 short에 저장
similarity = float(intersection_size) / float(
short) ## 공통 형태소 개수 / 짧은 문장소 형태소 개수 = 유사도
list.append([line, similarity * 100
]) ##list 배열에 문장과, 그문장의 입력문장에 대한 유사도를 집어넣어준다
sorted_list = sorted(
list,
class AnalysisDiction:
"""
This class is for analysis of korean texts using kkma and twitter dictionaries
"""
def __init__(self, on_han=False, on_twitter=False, on_mecab=False): # maybe move to init of analysis_app
"""
Allocate kkma or twitter diction instance
:param on_han: han instance
:param on_twitter: twitter instance
:param on_mecab: mecab instance
"""
if on_han is True:
self.han = Hannanum()
if on_twitter is True:
self.twitter = Twitter()
# if on_mecab is True:
# self.mecab = Mecab()
def analyzer_hannaum(self, string_data, mode):
"""
This method is for hannanum. It acts differently depends on its mode.
:param string_data: String data for analysis
:param mode: Analyze string data depending on its mode
:return: Return its results. If have no mode in param , return false
ref: http://konlpy.org/ko/v0.4.4/api/konlpy.tag/#module-konlpy.tag._hannanum
"""
if mode is 'morphs':
return self.han.morphs(string_data)
elif mode is 'nouns':
return self.han.nouns(string_data)
elif mode is 'pos':
return self.han.pos(string_data)
else:
return False
def analyzer_mecab(self, string_data, mode):
"""
This method is for mecab. It acts differently depends on its mode.
:param string_data: String data for analysis
:param mode: Analyze string data depending on its mode
:return: Return its results. If have no mode in param , return false
ref: http://konlpy.org/ko/v0.4.4/api/konlpy.tag/#mecab-class
"""
if mode is 'morphs':
return self.mecab.morphs(string_data)
elif mode is 'nouns':
return self.mecab.nouns(string_data)
elif mode is 'pos':
return self.mecab.pos(string_data)
else:
return False
def analyzer_twitter(self, string_data, mode):
"""
This method is for twitter. It acts differently depends on its mode.
:param string_data: String data for analysis
:param mode: Analyze string data depending on its mode
:return: Return its results. If have no mode in param , return false
ref: http://konlpy.org/ko/v0.4.4/api/konlpy.tag/#module-konlpy.tag._twitter
"""
if mode is 'morphs':
return self.twitter.morphs(string_data)
elif mode is 'nouns':
return self.twitter.nouns(string_data)
elif mode is 'pos':
return self.twitter.pos(string_data)
elif mode is 'posmore':
return self.twitter.pos(string_data, True, True)
else:
return False
# ### 3.1 HanNanum # In[5]: from konlpy.tag import Hannanum han = Hannanum() han.analyze(text) #Hannanum (ntags=69) # ### 형태소 분석 및 품사 태깅 # - Korean POS tags comparison chart: https://docs.google.com/spreadsheets/d/1OGAjUvalBuX-oZvZ_-9tEfYD2gQe7hTGsgUpiiBSXI8/edit#gid=0 # In[6]: #형태소 분석만 print(han.morphs(text)) # In[7]: #품사 태깅 print(han.pos(text, ntags=9)) #han.pos()의 기본값 ntags=9 # In[8]: print(han.pos(text, ntags=22)) #han.post()의 ntags는 9, 22 중 선택 가능 (26, 69는 불가능) # In[9]: #text중에 형용사(PA)만 추출 tagged_text = han.pos(text, ntags=22) [t[0] for t in tagged_text if t[1] == 'PA']
# -*- coding: utf-8 -*-
from konlpy.tag import Hannanum
hannanum = Hannanum()
doc1 = input("첫번쨰 문장을 입력해주세요 : ")
doc2 = input("첫번쨰 문장을 입력해주세요 : ")
hannanum1 = hannanum.morphs(doc1) ## 문장 1을 형태소 단위로 쪼개준다
hannanum2 = hannanum.morphs(doc2) ## 문장 2를 형태소 단위로 쪼개준다
hannanum1_size = len(hannanum1)
hannanum2_size = len(hannanum2)
hannanum_intersection = [value for value in hannanum1
if value in hannanum2] ## 문장 1과 문장 2에서의 형태소 교집합
hannanum_intersection_size = len(
hannanum_intersection) ## hannanum intersection_size : 겹치는 형태소의 개수(사이즈)
if len(doc1) <= len(doc2):
short_hannanum = hannanum1_size
else:
short_hannanum = hannanum2_size ## 문장 1과 문장 2의 길이를 비교하여 짧은 문장의 형태소 개수를 short_hannanum에 저장
simillarity = float(hannanum_intersection_size) / float(
short_hannanum) ## 공통 형태 개수 / 짧은 문장소 형태소 개수 = 유사도
print(simillarity * 100) ##형태소 유사도 출력
# 1) 형태소로 나눈다.
# 2) 불용어를 제거한다.
# 3) 형태소별 극성을 계산한다.
# 어근 : r_word
# 극성 : s_word
import json
from konlpy.tag import Hannanum
# 인스타그램 content을 읽어온다.
content = "나는 니가 정말 싫어"
#1) 형태소로 나눈다.
content_morphs = []
hannanum = Hannanum()
content_morphs = hannanum.morphs(content)
print(content_morphs)
#2) 불용어 제거하기
# 2) -1 불용어 불어오기 stopwords => 불용어 리스트
stopwords_file = open("불용어.txt", 'r', encoding='utf-8')
stopwords = []
lines = stopwords_file.readlines()
for line in lines:
line = line.replace("\n", "")
stopwords.append(line)
# 2) -2 불용어 제거하기
for i in content_morphs:
if i in stopwords:
content_morphs.remove(i)
from konlpy.tag import Hannanum
hannanum = Hannanum()
ko_sentence_short = input()
ko_sentence_long = input()
hannanum.morphs(ko_sentence_short)
hannanum.morphs(ko_sentence_long)
def word_calculate(short, long):
frequency_count = {}
long_word_arr = long.split(" ")
short_word_arr = short.split(" ")
for word in short_word_arr:
frequency_count[word] = 0
for word in long_word_arr:
for compared_word in frequency_count:
if (word == compared_word):
frequency_count[word] += 1
frequency_sum = 0
for word in frequency_count:
frequency_sum += frequency_count[word]
frequency = frequency_sum / len(short_word_arr)
return frequency
class AnalysisDiction:
"""
This class is for analysis of korean texts using kkma and twitter dictionaries
"""
def __init__(self,
on_han=False,
on_twitter=False,
on_mecab=False): # maybe move to init of analysis_app
"""
Allocate kkma or twitter diction instance
:param on_han: han instance
:param on_twitter: twitter instance
:param on_mecab: mecab instance
"""
if on_han is True:
self.han = Hannanum()
if on_twitter is True:
self.twitter = Twitter()
# if on_mecab is True:
# self.mecab = Mecab()
def analyzer_hannaum(self, string_data, mode):
"""
This method is for hannanum. It acts differently depends on its mode.
:param string_data: String data for analysis
:param mode: Analyze string data depending on its mode
:return: Return its results. If have no mode in param , return false
ref: http://konlpy.org/ko/v0.4.4/api/konlpy.tag/#module-konlpy.tag._hannanum
"""
if mode is 'morphs':
return self.han.morphs(string_data)
elif mode is 'nouns':
return self.han.nouns(string_data)
elif mode is 'pos':
return self.han.pos(string_data)
else:
return False
def analyzer_mecab(self, string_data, mode):
"""
This method is for mecab. It acts differently depends on its mode.
:param string_data: String data for analysis
:param mode: Analyze string data depending on its mode
:return: Return its results. If have no mode in param , return false
ref: http://konlpy.org/ko/v0.4.4/api/konlpy.tag/#mecab-class
"""
if mode is 'morphs':
return self.mecab.morphs(string_data)
elif mode is 'nouns':
return self.mecab.nouns(string_data)
elif mode is 'pos':
return self.mecab.pos(string_data)
else:
return False
def analyzer_twitter(self, string_data, mode):
"""
This method is for twitter. It acts differently depends on its mode.
:param string_data: String data for analysis
:param mode: Analyze string data depending on its mode
:return: Return its results. If have no mode in param , return false
ref: http://konlpy.org/ko/v0.4.4/api/konlpy.tag/#module-konlpy.tag._twitter
"""
if mode is 'morphs':
return self.twitter.morphs(string_data)
elif mode is 'nouns':
return self.twitter.nouns(string_data)
elif mode is 'pos':
return self.twitter.pos(string_data)
elif mode is 'posmore':
return self.twitter.pos(string_data, True, True)
else:
return False
from konlpy.tag import Twitter
twitter = Twitter() # 트위터 객체 설정
# Twitter 객체의 pos() 메소드를 이용
# pos(분석할 문장, norm옵션, stem옵션)
# norm : 오타가 있을 때 정확하게 표기를 해주는 옵션
# stem : 원형을 찾아주는 옵션
## wordList = twitter.pos("친구가 집에 놀러 왔다",norm=True,stem=True)
##print(wordList)
# 한나눔 분석기(Hannanum)
from konlpy.tag import Hannanum
hannanum = Hannanum()
## wordList = hannanum.analyze(u'롯데마트의 흙마늘 양념 치킨이 논란이 되고 있다.')
##print(wordList)
wordList = hannanum.morphs(u'롯데마트의 흙마늘 양념 치킨이 논란이 되고 있다.')
nounList = hannanum.nouns(u'다람쥐 새 쳇바퀴에 타고싶어')
print(wordList)
print(nounList)
print(hannanum.pos(u'웃으면 더 행복합니다'))
hannanum.analyze # 구(Phrase) 분석
hannanum.morphs # 형태소 분석
hannanum.nouns # 명사 분석
hannanum.pos # 형태소 분석 태깅
i = 0
with open('./data/auctionComment_영양제.json', 'rt',
encoding='UTF8') as json_file:
for line in json_file:
try:
y = json.loads(line)
# json_data = json.load(line)
# print(json_data["product_title"])
y["analyze"] = hannanum.analyze(y["comment_content"])
y["morphs"] = hannanum.morphs(y["comment_content"])
y["pos"] = hannanum.pos(y["comment_content"])
y["nouns"] = hannanum.nouns(y["comment_content"])
print(y)
with open("data/analyzed_영양제.json", "a", encoding="utf-8") as fp:
json.dump(y, fp, ensure_ascii=False)
fp.write("\n")
i = i + 1
if i == 2000:
break
except Exception as e:
print(e)
고속 충전기라고 구매했다가 기본 번들 충전기나 다름없는 속도로 충전되는 셈. 이런 참사를 막기 위해서는 9V/2A 규격을 준수하는 USB-PD 2.0 규격의 충전기를 사용해야 한다. 비슷한 맥락에서 애플이
기본으로 지급하는 Lightning Cable 을 보고 고속 충전기로 오해를 할 수 있는데, 한쪽 단자가 USB-C가 아니라 기존의 USB-A 단자로 되어있다면 그건 그냥 5W짜리 충전기이다. 적어도 애플
기기에서 USB-PD를 사용한 고속충전은 무조건 입력 측 단자가 USB-C여야만 한다. 이에 반해 삼성과 LG 등은 모두 18W 이상의 고속 충전기를 기본 증정하고 있다. 다만 아이폰은 언제나
타사 스마트폰보다 배터리의 양을 적게 탑재해도 그만큼 배터리의 소모도 적다는 옹호 의견도 있으나, 11 이전 아이폰의 배터리 타임은 이미 타사 대비 열세를 보이고 있었다. 더욱이 아이폰의
배터리는 플러스 모델과 X 이후의 모델부터 급격이 증가하며 현재는 일반적인 안드로이드 스마트폰의 배터리인 3000 mAh 이상까지 올라왔으며 이미 5W로 커버할 수준이 아니라는 반론도 존재한다. 역시나 동급모델
기준 충전 속도는 가장 느리다. 이미 아이폰 XS는 3시간, 아이폰 XS Max는 3시간 30분 가량에 달하는 엄청나게 긴 충전 시간을 보여주고 있었던 상황이었다! 10W 이상의 고속충전이 리튬이온 배터리의
기대 수명을 해친다는 이야기가 나오고 있기 때문에 애플은 배터리가 8000 mAh가 넘어가는 아이패드나 맥북 등을 제외하고 아이폰은 아직 5W 충전기를 고수하려는 입장인 듯하다는 의견도 존재하나 이는 아이폰
11 Pro의 경우 18W 고속충전기를 동봉해준 것을 설명할 수 없으므로 다소 무리가 있는 해석이다."""
splited = gisa.replace("\n", "").split(".")[:-1]
print(splited)
han = Hannanum()
okt = Okt()
han_tag = []
okt_tag = []
okt_noun = []
for texts in splited:
han_tag.append(han.morphs(texts))
okt_tag.append(okt.morphs(texts))
okt_noun.append(okt.nouns(texts))
pretrained_model = Word2Vec.load("model/ko.bin")
# embedding_model = Word2Vec(sentences=okt_noun, size=30, window=2, min_count=3, workers=4, iter=100, sg=1)
similar_test = pretrained_model.wv.most_similar("충전")
print(similar_test)
class Word(object):
"""Analyze pharse set by word
Attributes:
compare_set (dict): for correlation calculation
hannanum (object): for morphere analyzing
ke (object): for korean analying
set (list): 4 parent sets
"""
def __init__(self):
"""Initialize unigram class
this method initialize all attributes of this class
"""
self.compare_set = []
self.hannanum = Hannanum()
self.ke_object = KE()
self.set = ['pure', 'pure_number', 'pure_punctuation', 'pure_number_punctuation']
def analyze(self, analyze_path, output_path, filename):
"""Analyze pharse set from target filename by word
Args:
analyze_path (str): target input file's path
output_path (str): output file's path
filename (str): target filename
"""
input_file = filename + '.txt'
output_file = 'word_analyze_' + filename + '.txt'
with open(analyze_path + input_file, 'r') as file_read:
word_list = []
for line in file_read:
if len(line.strip()) == 0:
continue
#self.hannanum.morphs(line.decode('utf-8'))
#for word in line.decode('utf-8').split(' '):
try:
morphs_list = self.hannanum.morphs(line.decode('utf-8'))
except UnicodeDecodeError as e:
morphs_list = self.hannanum.morphs(line.encode('utf-8'))
for word in morphs_list:
changed = self.ke_object.change_complete_korean(word, 3)
word_item = "".join(changed)
word_list.append(word_item)
if filename in self.set:
if not word_item in self.compare_set:
self.compare_set.append(word_item)
#self.copy_set_file(filename, word_list)
final = self.update_dict(word_list)
if not filename in self.set:
for key in self.compare_set:
if not key in final.keys():
final[key] = 0
with open(output_path + output_file, 'w') as file_write:
for key, value in final.iteritems():
file_write.write(str(key) + ' : ' + str(value) + '\n')
def copy_set_file(self, filename, result):
"""Copy parent set file from filename for compare set
Args:
filename (str): target filename
result (list): target result
"""
if filename in self.set:
self.compare_set = copy.deepcopy(result)
@staticmethod
def update_dict(result):
"""generate dict for correlation calc as analyze result
Args:
result (list): target result
Return:
final (dict): calculated dict
"""
final = {}
for item in result:
if item in final.keys():
updated = final[item]
del final[item]
final[item] = updated + 1
else:
final[item] = 1
return final
print(kkma.pos('한국어 분석을 시작합니다 재미있어요~~'))
# 해당 단어가 품사가 명사인지 부사인지 같이 알려주는 함수 (품사 정보는 카페 참조)
# 결과
# [('한국어', 'NNG'), ('분석', 'NNG'), ('을', 'JKO'), ('시작하', 'VV'), ('ㅂ니다', 'EFN'),
# ('재미있', 'VA'), ('어요', 'EFN'), ('~~', 'SW')]
# Hannanum 한나눔
from konlpy.tag import Hannanum
hannanum = Hannanum()
print(hannanum.nouns('한국어 분석을 시작합니다 재미있어요~~'))
# 결과 : ['한국어', '분석', '시작']
print(hannanum.morphs('한국어 분석을 시작합니다 재미있어요~~'))
# 결과 : ['한국어', '분석', '을', '시작', '합', '니다', '재미있', '어요', '~~']
print(hannanum.pos('한국어 분석을 시작합니다 재미있어요~~'))
# [('한국어', 'N'), ('분석', 'N'), ('을', 'J'), ('시작', 'N'), ('하', 'X'), ('ㅂ니다', 'E'),
# ('재미있', 'P'), ('어요', 'E'), ('~~', 'S')]
# Twitter
from konlpy.tag import Okt
# 과거에는 Okt 가 아니고 twitter 이었다. 나중에 과거버전인지 확인할것
t = Okt()
print(t.nouns('한국어 분석을 시작합니다 재미있어요~~'))
# 결과 : ['한국어', '분석', '시작']
## 토큰화 # 1. Hannanum - KAIST 말뭉치를 이용해 생성된 사전 from konlpy.tag import Hannanum hannanum = Hannanum() hannanum.analyze # 구(Phrase) 분석 hannanum.morphs # 형태소 분석 hannanum.nouns # 명사 분석 hannanum.pos # 형태소 분석 태깅 print(hannanum.analyze(u'롯데마트의 흑마늘 양념 치킨이 논란이 되고 있다.')) print(hannanum.morphs(u'롯데마트의 흑마늘 양념 치킨이 논란이 되고 있다.')) print(hannanum.nouns(u'다람쥐 헌 쳇바퀴에 타고파')) print(hannanum.pos(u'웃으면 더 행복합니다!')) # 2. Kkma - 세종 말뭉치를 이용해 생성된 사전 (꼬꼬마) from konlpy.tag import Kkma kkma = Kkma() kkma.morphs # 형태소 분석 kkma.nouns # 명사 분석 kkma.pos # 형태소 분석 태깅 kkma.sentences # 문장 분석 print(kkma.morphs(u'공부를 하면할수록 모르는게 많다는 것을 알게 됩니다.')) print(kkma.nouns(u'대학에서 DB, 통계학, 이산수학 등을 배웠지만...')) print(kkma.pos(u'다 까먹어버렸네요?ㅋㅋ')) print(kkma.sentences(u'그래도 계속 공부합니다. 재밌으니까!'))
# Twitter 객체의 pos()메소드 이용
# pos(분석할 문장, norm옵션, stem옵션)
from konlpy.tag import Twitter
twitter = Twitter() #트위터 객체 생성
wordList = twitter.pos("친구가 집에 놀러왔다",norm=True,stem=True)
print(wordList)
# 한나눔(Hannanum) 분석기
from konlpy.tag import Hannanum
hannanum = Hannanum()
# analyze() 메소드는 가독성이 떨어진다!
wordList = hannanum.analyze(u'롯데마트의 흑마늘 양념 치킨이 논란이 되고 있다')
print(wordList)
# morphs() 는 한 줄에 구분되는 형태소를 출력. 품사정보 X
wordList = hannanum.morphs(u'롯데마트의 흑마늘 양념 치킨이 논란이 되고 있다')
print(wordList)
nounList = hannanum.nouns(u'다람쥐는 새 쳇바퀴에 타고 싶다')
print(hannanum.pos(u'웃으면 더 행복합니다')
komoran =Komoran() #토큰화 : morphs komoran_tokens = komoran.morphs(text) print(komoran_tokens) # In[9]: # 한나눔 from konlpy.tag import Hannanum hannanum = Hannanum() hannanum_tokens=hannanum.morphs(text) print(hannanum_tokens) # In[10]: #Okt (Twitter tokenizer가 v0.5.0.부터 Okt로 변경) from konlpy.tag import Okt okt=Okt() okt_tokens =okt.morphs(text) print(okt_tokens) # In[12]:
# -*- coding:utf-8 -*-
"""
Title: Morphological analysis using KoNLPy
Purpose: To check result of morphological analysis using KoNLPy
"""
from konlpy.tag import Kkma
from konlpy.tag import Okt
from konlpy.tag import Hannanum
from konlpy.tag import Komoran
from konlpy.tag import Twitter
if __name__ == '__main__':
kkma = Kkma()
okt = Okt()
komoran = Komoran()
hannanum = Hannanum()
twitter = Twitter()
# Only Kkma can split the setences
print("kkma 문장 분리 : ", kkma.sentences("네 안녕하세요 반갑습니다."))
# Comprison of Konlpy's library morphological analysis.
print("okt 형태소 분석 : ", okt.morphs(u"집에 가면 감자 좀 쪄줄래?")) #--> Ok
print("kkma 형태소 분석 : ", kkma.morphs(u"집에 가면 감자 좀 쪄줄래?"))
print("hannanum 형태소 분석 : ", hannanum.morphs(u"집에 가면 감자 좀 쪄줄래?"))
print("komoran 형태소 분석 : ", komoran.morphs(u"집에 가면 감자 좀 쪄줄래?"))
print("twitter 형태소 분석 : ", twitter.morphs(u"집에 가면 감자 좀 쪄줄래?")) # --> Ok
text = args.text
print("-"*5,"원본 텍스트", "-"*5)
print(text)
print("-"*5, "Mecab", "-"*5)
print(mecab.morphs(text))
print("-"*5, "Okt", "-"*5)
print(okt.morphs(text))
print("-"*5, "Komoran", "-"*5)
print(komoran.morphs(text))
print("-"*5, "Hannanum", "-"*5)
print(hannanum.morphs(text))
print("-"*5, "Kkma", "-"*5)
print(kkma.morphs(text))
print("-"*5, "Khaiii", "-"*5)
tokens = []
for word in khaiii.analyze(text):
tokens.extend([str(m).split('/')[0] for m in word.morphs])
print(tokens)
print("-"*5, "bert-base-multilingual-cased", "-"*5)
print(tokenizer.tokenize(text))
print('')
print('######## Kkma ########')
print('')
print('normalization : ')
print(normalizations)
print('')
print('tokenization : ')
print(tokenizations)
print('')
######## use Hannanum ########
hannanum = Hannanum()
normalizations = hannanum.morphs(input_text)
tokenizations = hannanum.pos(input_text)
print('')
print('######## Hannanum ########')
print('')
print('normalization : ')
print(normalizations)
print('')
print('tokenization : ')
print(tokenizations)
print('')
######## use Komoran ########
komoran = Komoran()