def konlpyHannanum(inputSentence: str, sentenceList: list) -> dict:
han = Hannanum()
sentenceDict = dict()
inputPos = han.pos(inputSentence)
inputPosCount = Counter(inputPos)
inputLen = len(inputPosCount)
for line in sentenceList:
if line == '':
continue
sentencePos = han.pos(line)
sentencePosCount = Counter(sentencePos)
sentenceLen = len(sentencePosCount)
if sentenceLen >= inputLen:
common = 0
for morpheme in inputPosCount:
if morpheme in sentencePosCount:
common += min(inputPosCount[morpheme],
sentencePosCount[morpheme])
similarity = 100 * common / inputLen
sentenceDict[line] = similarity
else:
common = 0
for morpheme in inputPosCount:
if morpheme in sentencePosCount:
common += min(inputPosCount[morpheme],
sentencePosCount[morpheme])
similarity = 100 * common / sentenceLen
sentenceDict[line] = similarity
return sentenceDict
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 getSentenceByWord():
if (request.method == 'POST'):
hannanum = Hannanum()
word_data = hannanum.pos(request.form['wordData'])[0][0]
# print(word_data)
sentence_dict = {"sentenceId": 0, "sentenceData": "", "standard": ""}
sentence_id_list = []
sentence_list = []
for wd in db_session.query(Word).order_by(
Word.wordId).filter(Word.wordData == word_data):
sentence_id_list.append(wd.sentenceId)
# print(sentence_id_list)
for sid in sentence_id_list:
sentence = db_session.query(Sentence).filter(
Sentence.sentenceId == sid).first()
sentence_dict["sentenceId"] = sentence.sentenceId
sentence_dict["sentenceData"] = sentence.sentenceData
sentence_dict["standard"] = sentence.standard
sentence_list.append(sentence_dict.copy())
return json.dumps(sentence_list, ensure_ascii=False)
def preprocess_npm(document):
''' 한국어 체언(n), 용언(p), 수식언(m) 추출해 문장별로 단어 리스트로 정리'''
sentences = re.split('\.\s+', document.strip())
results = []
for sent in sentences:
try:
# 국어영어 아닌 문자 제거
letters_only = re.sub('[^ㄱ-힣a-zA-Z]', ' ', sent)
# 형태소 분석기 불러와 단어 분리
hannanum = Hannanum()
morp_words = hannanum.pos(letters_only)
# 특정 형태소 단어만 선택. 용언의 경우 '다'를 붙여 기본형으로.
morph_words = []
for w in morp_words:
if w[1] in ['N', 'M']: # N 체언 P 용언 M 수식언
morph_words.append(w[0])
elif w[1] == 'P':
morph_words.append(w[0] + "다")
else:
pass
# stopwords 적용해 불용어 제거
stopwords = [
'특파원', '기자', '단독', '앵커', '취재', '특종', '신문', '방송', '보도', '외신',
'뉴스'
] # 필요한 불용어 추가
meaningful_words = [w for w in morph_words if w not in stopwords]
# 2음절 이상만 선택
meaningful_words2 = [w for w in meaningful_words if len(w) > 1]
results.append(meaningful_words2)
except:
results.append([''])
return results
def get_derived_query(keyword):
# google translate API
os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = "My Project-a8e42c74ea7e.json"
translate_client = translate.Client()
# Hannanum pos tagger
hannanum = Hannanum()
""" Retrieve derived queries from keyword by using WordNet Synset """
nouns = [word for word, pos in hannanum.pos(keyword) if pos == "N"]
syn_dict = {}
query_list = []
for noun in nouns:
result = translate_client.translate(noun, target_language="en")
if len(result["translatedText"].split(" ")) > 1: # 복합 명사 처리 안함
continue
else:
translated_noun = result["translatedText"]
# print(noun, translated_noun)
for syn in wordnet.synsets(translated_noun):
synonyms = []
if syn.pos() == "n":
syn_word = syn.name().split(".")[0]
synonyms.append(syn_word)
syn_dict[noun] = synonyms
if len(syn_dict) > 0:
for noun in syn_dict:
for syn in syn_dict[noun]:
syn_ko = translate_client.translate(syn, target_language="ko")["translatedText"]
query_list.append(keyword.replace(noun, syn_ko))
return list(np.unique(query_list))
def make_corpus(self):
processor = Hannanum()
with open('outputs/sermon-{}-corpus.txt'.format(self.name),
'w') as fout:
data_dir = 'data/{}'.format(self.name)
for filename in os.listdir(data_dir):
if not filename.endswith('txt'):
continue
path = os.path.join(data_dir, filename)
with open(path) as fin:
print(path)
for line in fin:
_line = self.clean_punctuation(line)
if not _line:
continue
_lines = _line.split('.')
for l in _lines:
_l = self.clean_punctuation(l)
if not _l:
continue
sentence = [
'{}/{}'.format(word, tag)
for word, tag in processor.pos(_l) if
self.filter_tag(tag) and self.filter_word(word)
]
if len(sentence) > 2:
fout.write(' '.join(sentence) + '\n')
class HannanumWrapping:
def __init__(self):
self.hannanum = Hannanum()
def tf(self, doc):
words = Counter(self.hannanum.pos(doc))
words = [('%s/%s' % (word, tag), freq)
for (word, tag), freq in words.items()
if tag[0] == 'N' or tag[0] == 'P']
return words
def extract_pos(text):
h = Hannanum()
pos = h.pos(text, ntags=22, flatten=True)
pos_list = [item for item in pos if item[1] == 'NC' or item[1] == 'NQ' or item[1] == 'NN' or item[1] == 'PV' or item[1] == 'PA']
dct = dict(pos_list)
for stopword in stopwords.itertuples(): # 불용어 체크
if dct.get(stopword._1):
del dct[stopword._1]
split_pos = "|".join("%s,%s" % tup for tup in dct.items())
return split_pos
def hannanum_analyze(content):
dictionary={}
h= Hannanum()
words = h.pos(content)
for tuple in words:
value = tuple[1]
if value == "N" or value == "P" or value == "M":
key = tuple[0]
# '먹' 같은 용언에는 '-다'를 붙여 '먹다' 같은 동사로 키값 사용
if value == "P":
key += u"다"
if not key in dictionary.keys():
dictionary[key] =1
else :
dictionary[key] +=1
return OrderedDict(sorted(dictionary.items(), key=itemgetter(1), reverse=True))
class KoreanTextNormalizer(BaseEstimator, TransformerMixin):
def __init__(self) -> None:
super().__init__()
self.hannanum = Hannanum()
def fit(self, X, y=None):
return self
def transform(self, docs):
def generator():
for doc in docs:
doc = re.sub(r'[^\wㄱ-ㅎ가-힣美中&%]', ' ', doc)
# token = self.hannanum.morphs(doc) # Normalizer 문제로 나중에 조사들이 keyword로 뽑히게 됨..
token = self.hannanum.pos(doc)
token = [x[0] for x in token if x[1] not in ['E', 'J']] # 조사와 어미 버리기!
yield token
return list(generator())
def remove_particle(training_args):
"""
remove particle
Args:
training_args
"""
# load tokenizer
mecab = Mecab()
kkma = Kkma()
hannanum = Hannanum()
# load prediction file
with open(os.path.join(training_args.output_dir, "predictions.json"),
"r") as f:
prediction_json = json.load(f)
prediction_dict = dict()
for mrc_id in prediction_json.keys():
final_predictions = prediction_json[mrc_id]
pos_tag = mecab.pos(final_predictions)
# 조사가 있는 경우 삭제
if final_predictions[-1] == "의":
min_len = min(len(kkma.pos(final_predictions)[-1][0]),
len(mecab.pos(final_predictions)[-1][0]),
len(hannanum.pos(final_predictions)[-1][0]))
if min_len == 1:
final_predictions = final_predictions[:-1]
elif pos_tag[-1][-1] in {
"JX", "JKB", "JKO", "JKS", "ETM", "VCP", "JC"
}:
final_predictions = final_predictions[:-len(pos_tag[-1][0])]
prediction_dict[str(mrc_id)] = final_predictions
# save final results
with open(os.path.join(training_args.output_dir, "final_predictions.json"),
'w',
encoding='utf-8') as make_file:
json.dump(prediction_dict, make_file, indent="\t", ensure_ascii=False)
print(prediction_dict)
def hannanum_analyze_22():
h= Hannanum()
tags={
'NC':'보통명사',
'NQ':'고유명사',
}
"""
pos_dics=
{
news.id : 분석 결과 dictionary,
news.id : 분석 결과 dictionary,
...
}
"""
pos_dics = {}
news = getTodayNews()
for n in news :
content = remove_puc_marks(n.content) # 문장 부호 제거
words_dic = h.pos(content,22) # 형태소 제거
dictionary={}
for t in words_dic:
word = t[0]
key = t[1]
if key in tags.keys():
if not word in dictionary.keys():
dictionary[word] =1
else :
dictionary[word] +=1
dictionary=remove_stopwords(dictionary) # 불용어 제거
pos_dics[n]=dictionary
print "tf-idf"
analyzed_dics=tf_idf_map(pos_dics) # tfidf 계산
return analyzed_dics
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 hannanum_analyze_22_key(content):
dictionary={}
h= Hannanum()
tags={
'NC':'보통명사',
'NQ':'고유명사',
# 'NB':'의존명사',
# 'NN':'수사' ,
# 'NP':'대명사' ,
# 'PV':'동사',
# 'PA':'형용사',
# 'PX':'보조 용언',
# 'MM':'관형사' ,
# 'MA':'부사',
}
words = h.pos(content,22)
for t in words:
key = t[0]
value = t[1]
if value in tags.keys():
# '먹' 같은 용언에는 '-다'를 붙여 '먹다' 같은 동사로 키값 사용
if value.startswith("P"):
key += u"다"
key= key+ "["+value+"]"
if not key in dictionary.keys():
dictionary[key] =1
else :
dictionary[key] +=1
# print key + " " + value
dictionary=remove_stopwords(dictionary) # 불용어 제거
dictionary=OrderedDict(sorted(dictionary.items(), key=itemgetter(1), reverse=True))
return dictionary
def last_processing(text):
"""
조사 버리기
Args:
text (str): 조사가 있는 text
Returns:
[str]: 필요 없는 조사 제거
"""
mecab = Mecab()
kkma = Kkma()
hannanum = Hannanum()
pos_tag = mecab.pos(text)
# last word(조사)에 있는 단어고 형태소 분석 결과가 j일경우 삭제
if not pos_tag :
pass
elif text[-1] == "의":
min_len = min(len(kkma.pos(text)[-1][0]), len(mecab.pos(text)[-1][0]), len(hannanum.pos(text)[-1][0]))
if min_len == 1:
text = text[:-1]
elif pos_tag[-1][-1] in {"JX", "JKB", "JKO", "JKS", "ETM", "VCP", "JC"}:
text = text[:-len(pos_tag[-1][0])]
return text
def analysis(self, blog_review_url):
# self.logger.info(blog_review_url)
analysis_checker = {}
try:
r = requests.get(blog_review_url)
except requests.ConnectionError as e:
return
soup = BeautifulSoup(r.text)
r.close()
try:
blog_review_url = soup.select('#screenFrame')[0]['src']
# self.logger.info("regenerated:"+blog_review_url)
r = requests.get(blog_review_url)
soup = BeautifulSoup(r.text)
r.close()
except Exception as e:
pass
try:
real_blog_review_url = "http://blog.naver.com" + soup.select('frame#mainFrame')[0]['src']
except IndexError as e:
self.skip_count += 1
return
r = requests.get(real_blog_review_url)
soup = BeautifulSoup(r.text)
r.close()
post_view = soup.select('.post-view')[0]
p_list = post_view.select('p')
raw_str_list = []
for item in p_list:
p_str = str(item.text.encode('utf-8')).replace('\xc2\xa0', ' ').replace('\xe2\x80\x8b', ' ').strip()
p_str = p_str.replace('ㅎ', '').replace('ㅋ', '')
if len(p_str) != 0:
raw_str_list.append(p_str.decode('utf-8'))
kkma = Hannanum()
for raw_str_item in raw_str_list:
if len(raw_str_item) >= 100:
self.skip_count += 1
continue
try:
raw_str_item = raw_str_item.strip()
pos_tuple = kkma.pos(raw_str_item)
for pos_tuple_item in pos_tuple:
item = pos_tuple_item[0]
item_type = pos_tuple_item[1]
if not (analysis_checker.has_key(item)) and (
item_type.startswith('N') or item_type.startswith('V') or item_type.startswith(
'M') or item_type.startswith('XR') or item_type.startswith('U')):
if self.analysis_result.has_key(item):
analysis_item_count = self.analysis_result.get(item) + 1
else:
analysis_item_count = 1
self.analysis_result.update({
item: analysis_item_count
})
analysis_checker.update({
item: 1
})
except jpype.JavaException as exception:
pass
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 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'] # In[10]: #명사만 추출할 경우: han.nouns() han.nouns(text)
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)
# print(re.sub(r'^\[[\w\b]+\]$', '', '[2020-1학기 공과대학 수강후기 공모전]'))
# print(re.sub(r'(\[)([\w\s-]*)(\])', '', '[2018-2 경영대학 리얼 수강후기 공모전]\n*상단의 과제/조모임/학점비율 등의 항목들은 일괄적으로 가장 왼쪽 항목에 체크되었으며, 아래의 본 내용과 무관함을 알려드립니다.\n*본 후기는 온전히 경영대학 학우 분들의 의견으로 구성되었습니다.\n교수님의 수업 스타일은 매우 자유분방 하십니다. 너무 자유분방하셔서 수업의 본질을 흐리시는 것 같네요 금융시장론이란 명칭을 바꾸셔야 될거 같습니다. 밴드라는 걸 이용해서 매주 기사 스크랩을 시키고 참잘했어요를 주십니다 시험은 기말고사 한번인데 비중이 매우 적습니다 출결은 거의 반영 안되는 것 같구요 성적 비중을 교수님 마음대로 정합니다 팀프로젝트가 한 번 있어요').replace('*상단의 과제/조모임/학점비율 등의 항목들은 일괄적으로 가장 왼쪽 항목에 체크되었으며, 아래의 본 내용과 무관함을 알려드립니다.', '').replace('*본 후기는 온전히 경영대학 학우 분들의 의견으로 구성되었습니다.', ''))
with open('konlpy/preprocessed_review.csv', 'w', newline='') as output_file:
writer = csv.writer(output_file)
preprocessed_sent = []
for review in reviewlist:
print(review[0])
review = review[0]
review = re.sub(r'(\[)([\w\s-]*)(\])', '', review) # [20nn-n학기 ~~대학 공모전 ~]과 같은 형식 제거
review = re.sub(r'(\*)([\w\s\/,]*)(.)', '', review) # ex) *본 후기는 온전히 경영대학 학우 분들의 의견으로 구성되었습니다. 와 같은 형식 제거
# review = re.sub(r'(\*)([\w\s:]*)(★*)', '', review) # ex) * 공과대학 학우들에게 추천하는 정도:★★★★★ 제거
review = re.sub(r'(-)([\w\s-]*)(.)', '', review) # ex) - 공과대학 학우분들이 답변해 주신 솔직한 후기로 모든 후기들은 에브리타임 수강평 등록을 허락하신 학우님들에 한하여 작성되었습니다. 제거
review = re.sub(r'(\*)([\w\s\/,]*)(\**)', '', review) # ex) ** 20-1학기 IT대학 강의평가 공모전을 통해 접수된 강의평가입니다. ** 와 같은 형식 제거
review = re.sub(r'[~!@#$%^&*()♥★☆♡-]', '', review) # 특수문자 제거
review = review.replace('ㅋ', '')
review = review.replace('ㅎ', '')
review = review.replace('"', '')
spaced_review = spacing(review)
morphs = hannanum.pos(spaced_review)
sent=[]
for morph in morphs:
if morph[1] != 'J' and morph[1] != 'E' and morph[1] != 'S':
sent.append(morph[0])
preprocessed_sent.append(sent)
print(sent)
writer.writerow(sent)
# print(preprocessed_sent)
데이터 전처리 및 파이썬 자연어 처리 라이브러리 정리
http://aileen93.tistory.com/128
'''
from konlpy.tag import Kkma
kkma=Kkma()
kkma.sentences('한국어 분석을 시작합니다 재미있어요--')
kkma.nouns('한국어 분석을 시작합니다 재미있어요--')
kkma.pos('한국어 분석을 시작합니다 재미있어요--') #형태소 분석
from konlpy.tag import Hannanum
hannanum=Hannanum()
hannanum.nouns('한국어 분석을 시작합니다 재미있어요--')
hannanum.pos('한국어 분석을 시작합니다 재미있어요--')
from konlpy.tag import Twitter
t=Twitter()
t.nouns('한국어 분석을 시작합니다 재미있어요--')
t.morphs('한국어 분석을 시작합니다 재미있어요--')
t.pos('한국어 분석을 시작합니다 재미있어요--')
from wordcloud import WordCloud, STOPWORDS
import numpy as np
from PIL import Image
text=open('DataScience-master\\data\\09. alice.txt').read()
alice_mask=np.array(Image.open('DataScience-master\\data\\09. alice_mask.png'))
stopwords=set(STOPWORDS)
stopwords.add('said')
"""
# 꼬꼬마 형태소 분석기
"""
문장을 형태소 단위로 분리하고 품사를 태깅한다.
품사태그는 일반명사(NNG), 고유명사(NNP), 동사(VV), 형용사(VA) 등이 있다.
http://kkma.snu.ac.kr/documents/index.jsp?doc=postag 형태소 리스트 확인
"""
print(kkma.sentences(u'아버지가 방에 들어가셨다. 아버지 가방에 들어가셨다. 아버지가 방 안에 있는 가방에 들어가셨다.')
) # sentences로 나눠줌(문장단위로)
print(kkma.pos(
u'아버지가 방에 들어가셨다. 아버지 가방에 들어가셨다. 아버지가 방 안에 있는 가방에 들어가셨다.')) # 각각 태깅을 해준다.
print('---' * 30)
# 한나눔 형태소 분석기
print(hannanum.pos(u'아버지가 방에 들어가셨다. 아버지 가방에 들어가셨다. 아버지가 방 안에 있는 가방에 들어가셨다.'))
print('---' * 30)
# 트위터 형태소 분석기
print(twitter.pos('아버지가 방에 들어가셨다. 아버지 가방에 들어가셨다. 아버지가 방 안에 있는 가방에 들어가셨다.'))
print('---' * 30)
# 형태소 분석 - kkma 명사
line_list = []
f = open('centrum_review.txt', encoding='utf-8')
for line in f:
line = kkma.nouns(line)
line_list.append(line)
f.close()
print("- 불러온 문서 : ", len(line_list), "문장")
for idx in [1, 10, 100, 1000, 10000, 100000]:
#for analyzer in [hannanum, kkma, komoran, okt, nori]
sample_data = data[:idx]
print('# number of sample data: ', len(sample_data))
print('\n')
# Hannanum
start_time = time.time()
for x in sample_data:
hannanum.pos(x)
print('Hanna:\t{}'.format(time.time() - start_time))
# Kkma
start_time = time.time()
for x in sample_data:
kkma.pos(x)
print('Kkma:\t{}'.format(time.time() - start_time))
# Okt
start_time = time.time()
for x in sample_data:
okt.pos(x)
print('Okt:\t{}'.format(time.time() - start_time))
# Nori
def resultControl():
if(request.method == 'POST'):
# 클라이언트에서 sentenceId & wav file 받아옴
wav = request.files['receiveFile']
filename = request.form['fileName']
sentenceId = request.form['sentenceId']
# upload 디렉터리에 저장
wav.save(FILE_DIRECTORY + secure_filename(wav.filename))
##### upload 디렉터리에 있는 파일을 STT로 변한
# 임시 path
args = easydict.EasyDict({"local_file_path": "./uploadFile/"+filename})
# TODO Credential Error
# print(sample_recognize(args.local_file_path))
# sentenceId를 통해 DB에서 표준 발음 텍스트 가져옴
Pick_sentence = db_session.query(Sentence).filter(Sentence.sentenceId == sentenceId).first()
receiveSTTData = sample_recognize(args.local_file_path)
receiveData = similaritySentence(receiveSTTData, Pick_sentence.standard)
#receiveData = "날시가 참 말따"
print("STT result : ", receiveData)
# print(Pick_sentence)
##### 분석 알고리즘
hannanum = Hannanum()
StandardSentence = Pick_sentence.standard
sentenceData = Pick_sentence.sentenceData
# 공백 인덱스 리스트 생성
# 공백 개수는 일치
userBlankList = [i for i, value in enumerate(receiveData) if value == " "]
standardBlankList = [i for i, value in enumerate(StandardSentence) if value == " "]
# print(BlankList)
# 문자열 길이가 다르거나 공백 개수가 다르면
# 재시도 요청
if (len(receiveData) != len(StandardSentence) or len(userBlankList) != len(standardBlankList)):
os.remove("./uploadFile/"+filename)
return jsonify(
status="failure",
resultData=receiveData,
errorMessage="repeat",
)
# 공백 제거
UserSentence = receiveData.replace(" ", "")
StandardSentence = StandardSentence.replace(" ", "")
sentenceData = sentenceData.replace(" ", "")
# print(UserSentence)
# print(StandardSentence)
Total_pho = 0 # 총 음소 개수
Wrong_total_pho = 0 # 틀린 음소 개수
Wrong_word_index_list = [] # 틀린 글자 데이터가 들어있는 리스트
Wrong_word_list = [] # 틀린 단어 데이터가 들어있는 리스트
Wrong_pho_dict = {'u' : {},
'm' : {}, # 틀린 음소가 저장되는 딕셔너리
'b' : {}} # u : 자음, m : 모음, b : 받침
for index, standard in enumerate(StandardSentence):
StandPho = phonemeConvert(standard)
# 글자가 일치하는 경우
if(UserSentence[index] == standard):
if(StandPho[2] == ' '):
Total_pho += 2
else:
Total_pho += 3
# 글자가 일치하지 않는 경우
# 음소 분해
else:
Wrong_word_index_list.append(index)
UserPho = phonemeConvert(UserSentence[index])
SentencePho = phonemeConvert(sentenceData[index])
if(UserPho[2] == ' ' and StandPho[2] == ' '):
Total_pho += 2
else:
Total_pho += 3
if(UserPho[2] != StandPho[2]):
Wrong_total_pho += 1
if StandPho[2] != ' ':
if StandPho[2] in Wrong_pho_dict['b']:
Wrong_pho_dict['b'][SentencePho[2]] += 1
else:
Wrong_pho_dict['b'][SentencePho[2]] = 1
if (UserPho[0] != StandPho[0]):
Wrong_total_pho += 1
if StandPho[0] in Wrong_pho_dict['u']:
Wrong_pho_dict['u'][SentencePho[0]] += 1
else:
Wrong_pho_dict['u'][SentencePho[0]] = 1
if (UserPho[1] != StandPho[1]):
Wrong_total_pho += 1
if StandPho[1] in Wrong_pho_dict['m']:
Wrong_pho_dict['m'][SentencePho[1]] += 1
else:
Wrong_pho_dict['m'][SentencePho[1]] = 1
# print(Wrong_pho_dict)
######### 틀린 음소 record 테이블에 count 올림 -> TEST SUCCESS
for type in Wrong_pho_dict:
for pho in Wrong_pho_dict[type]:
# print(pho)
updateData = db_session.query(Record).filter(Record.recordType == type)\
.filter(Record.recordData == pho).first()
# print(updateData.type, updateData.recordData)
updateData.count += Wrong_pho_dict[type][pho]
db_session.commit()
# 일치율
Correct_rate = round(1 - (Wrong_total_pho / Total_pho), 4)
"""
# 일치율 100%인 경우
if Correct_rate == 1:
os.remove("./uploadFile/" + filename)
return jsonify(
status="perfect",
resultData=receiveData,
score=Correct_rate,
)
"""
# print(Wrong_word_list)
# 변경 후
# print(Wrong_word_index_list)
sentenceData_split = Pick_sentence.sentenceData.split()
# print(sentenceData_split)
# 틀린 인덱스가 포함된 단어 선택
word_start_point = 0
for sentence_word in sentenceData_split:
word_end_point = word_start_point + len(sentence_word)-1
# print(word_start_point, word_end_point)
for wrong_index in Wrong_word_index_list:
if word_start_point <= wrong_index and word_end_point >= wrong_index:
word_to_pos = hannanum.pos(sentence_word)
# print(word_to_pos)
wrong_word_pho_list = phonemeConvert(sentenceData[wrong_index])
# print(wrong_word_pho_list)
for pos in word_to_pos:
#TODO 틀린 단어에 N이나 P가 여러개 들어있으면??
if pos[1] == 'N' or pos[1] == 'P':
for pos_word in pos[0]:
pos_word_pho_list = phonemeConvert(pos_word)
# print(pos_word_pho_list)
if wrong_word_pho_list[0] == pos_word_pho_list[0]:
Wrong_word_list.append(pos)
break
word_start_point += len(sentence_word)
print(Wrong_word_list)
# 틀린 글자 인덱스를 원래 문장을 기준으로 변경
for i in userBlankList:
for index, j in enumerate(Wrong_word_index_list):
if(j >= i):
Wrong_word_index_list[index] += 1
# print(Wrong_word_index)
######## result 테이블에 결과값 저장 -> TEST SUCCESS
resultData = Result(stid=sentenceId, rsdata=receiveData, score=Correct_rate)
db_session.add(resultData)
db_session.commit()
# 일치율 100%인 경우
if Correct_rate == 1:
os.remove("./uploadFile/" + filename)
return jsonify(
status="perfect",
resultData=receiveData,
score=Correct_rate,
)
######## 가장 많이 틀린 단어에 대한 추천 문장 1개
recommend_OtoD = dict(sentenceId=-1, sentenceData="", standard="")
recommend_word = ""
# 틀린 단어 리스트에 단어가 존재할 경우
if Wrong_word_list:
random.shuffle(Wrong_word_list)
for random_select_word in Wrong_word_list:
Word_query = db_session.query(Word).filter(Word.wordData == random_select_word[0])\
.filter(Word.wordType == random_select_word[1]).filter(Word.sentenceId != sentenceId)
Word_entry = [pq.sentenceId for pq in Word_query]
if Word_entry:
recommend_word = random_select_word[0]
if random_select_word[1] == 'P':
recommend_word += '다'
random_select_setencdId = random.choice(Word_entry)
Recommend_sentence = db_session.query(Sentence).filter(Sentence.sentenceId == random_select_setencdId).first()
recommend_OtoD['sentenceId'] = Recommend_sentence.sentenceId
recommend_OtoD['sentenceData'] = Recommend_sentence.sentenceData
recommend_OtoD['standard'] = Recommend_sentence.standard
break
os.remove("./uploadFile/" + filename)
# response해줄 틀린 단어 리스트
wordList = []
for w in Wrong_word_list:
if w[1] == "P":
wordList.append(w[0]+"다")
else:
wordList.append(w[0])
# 결과 데이터를 모두 json으로 묶음
return jsonify(
status = "success",
score = Correct_rate,
wordList = wordList,
userBlank = userBlankList,
standardBlank = standardBlankList,
wrongIndex = Wrong_word_index_list,
resultData = receiveData
)
import numpy as np
sentence = '소은지 국민은행계좌에20만원이체해줘'
sentences = '공인인증서재발급'
from konlpy.tag import Komoran
komoran = Komoran()
print(komoran.pos(sentence))
print(komoran.pos(sentences))
print("\n")
#빠른 속도와 보통의 정확도
from konlpy.tag import Hannanum
hannanum = Hannanum()
print(hannanum.pos(sentence))
print(hannanum.pos(sentences))
print("\n")
#빠른 속도와 보통의 정확도
from konlpy.tag import Okt
okt = Okt()
print(okt.pos(sentence, stem=True))
print(okt.pos(sentences, stem=True))
print("\n")
#어느 정도의 띄어쓰기 되어있는 "인터넷"영화평/상품명을 처리할때
from konlpy.tag import Kkma
kkma = Kkma()
print(kkma.pos(sentence))
print(kkma.pos(sentences))
print("\n")
## 토큰화 # 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'그래도 계속 공부합니다. 재밌으니까!'))
# -*- coding:utf-8 -*-
"""
Title: Parts of speech tagging using KoNLPy
Purpose: To comprison the result of POS 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 parts of speech
print("okt 형태소 분석 : ", okt.pos(u"집에 가면 감자 좀 쪄줄래?")) #--> Ok
print("kkma 형태소 분석 : ", kkma.pos(u"집에 가면 감자 좀 쪄줄래?"))
print("hannanum 형태소 분석 : ", hannanum.pos(u"집에 가면 감자 좀 쪄줄래?"))
print("komoran 형태소 분석 : ", komoran.pos(u"집에 가면 감자 좀 쪄줄래?"))
print("twitter 형태소 분석 : ", twitter.pos(u"집에 가면 감자 좀 쪄줄래?")) # --> Ok
Okt = Okt()
komoran = Komoran()
hannanum = Hannanum()
kkma = Kkma()
sentences_tag = []
for sentence in okja:
morph = Okt.pos(sentence)
print("Twitter : ", morph)
for sentence in okja:
morph = komoran.pos(sentence)
print("Komoran : ", morph)
for sentence in okja:
morph = hannanum.pos(sentence)
print("hannanum : ", morph)
for sentence in okja:
morph = kkma.pos(sentence)
print("kkma : ", morph)
import time
start = time.time()
sentence = u'내년도 최저임금을 기존 방식대로 전체 업종에 동일하게 적용하기로 결정했다.\
최저임금의 업종별 차등 적용을 요구해온 사용자위원들은 이에 반발해 전원회의에서 퇴장했다.'
from konlpy.tag import Hannanum
Hannanum = Hannanum()
for word in Hannanum.pos(sentence):
print(word)
print("time:", time.time() - start)
#코모란
komoranTag=[]
for token in komoran_tokens:
komoranTag +=komoran.pos(token)
print(komoranTag)
# In[14]:
#한나눔
hannanumTag=[]
for token in hannanum_tokens:
hannanumTag+=hannanum.pos(token)
print(hannanumTag)
# In[15]:
#Okt
oktTag=[]
for token in okt_tokens:
oktTag+=okt.pos(token)
print(oktTag)
# In[16]:
d_ko = Counter(kk.nouns(lyrics))
l_ko = sorted(d_ko.items(), key=itemgetter(1), reverse=True)
print('...Done!\n')
if output_csv:
print('Now printing into .csv... (ko)')
Output_csv_more_than(l_ko, csv_min, suffix='_ko')
print('...Done!\n')
if output_wc:
print('Now printing into Wordcloud... (ko)')
Output_wc(d_ko, suffix='_ko')
print('...Done!\n')
if not output_ko_only:
print('Now analysing lyrics... (all)')
d_all = {}
for s in kk.pos(lyrics):
if s[1] == 'N' or s[1] == 'F':
if s[0] not in d_all.keys():
d_all[s[0]] = 1
else:
d_all[s[0]] += 1
l_all = sorted(d_all.items(), key=itemgetter(1), reverse=True)
print('...Done!\n')
if output_csv:
print('Now printing into .csv... (all)')
Output_csv_more_than(l_all, csv_min, suffix='_all')
print('...Done!\n')
if output_wc:
print('Now printing into Wordcloud... (all)')
Output_wc(d_all, suffix='_all')
print('...Done!\n')
# In[19]:
hannanum = Hannanum()
# In[20]:
hannanum.nouns('제가 따뜻한 커피들고 기다리고 있을게요!!')
# In[21]:
hannanum.nouns('제가 따뜻한 커피들고 기다리고 있을게요!!')
# In[22]:
hannanum.pos('제가 따뜻한 커피들고 기다리고 있을게요!!')
# In[55]:
kkma.morphs('제가 따뜻한 커피들고 기다리고 있을게욬ㅋㅋㅋ!!')
# In[24]:
def tokenize(doc):
return ['/'.join(t) for t in pos_tagger.pos(doc, norm=True, stem=True)]
# In[25]:
train = ['메리가 좋다', '고양이도 좋다', '난 수업이 지루하다', '메리는 예쁜 고양이다', '난 마치고 메리랑 놀거야']
s_moon = read_speech(
"Z:/1. 프로젝트/2019_한화시스템교육/교육자료_ML/5일차_텍스트마이닝/TM1/examples/speech_Moon.txt")
# step1: sentence split
s_park = sentence_split(s_park)
s_moon = sentence_split(s_moon)
# step2: tokenization
# skip
# step3: POS tagging
han = Hannanum()
kko = Kkma()
komo = Komoran()
han.pos(s_park[0])
han.nouns(s_park[0])
# step4: plotting
# word cloud for Park
s_park_noun = extract_nouns(s_park)
count = Counter(s_park_noun)
tags = count.most_common(100)
# WordCloud, matplotlib: 단어 구름 그리기
font_path = "C:/WINDOWS/Fonts/NANUMGOTHIC.TTF"
wc = WordCloud(font_path=font_path,
background_color='white',
width=800,
height=600)
cloud = wc.generate_from_frequencies(dict(tags))
plt.figure(figsize=(10, 8))
class KonlParser:
def __init__(self):
self.komoran = Komoran()
self.kkma = Kkma()
self.hann = Hannanum()
self.mecab = Mecab()
self.twitter = Twitter()
self.okt = Okt()
def parserKomoran(self, intext):
ch = self.komoran.nouns(intext)
return ch
def posKomoran(self, intext):
ch = self.komoran.pos(intext)
return ch
def parserKkma(self, intext):
ch = self.kkma.nouns(intext)
return ch
def posKkma(self, intext):
ch = self.kkma.pos(intext)
return ch
def parserHannanum(self, intext):
ch = self.hann.nouns(intext)
return ch
def posHannanum(self, intext):
ch = self.hann.pos(intext)
return ch
def parserMecab(self, intext):
ch = self.mecab.nouns(intext)
return ch
def posMecab(self, intext):
ch = self.mecab.pos(intext)
return ch
def parserTwitter(self, intext):
ch = self.twitter.nouns(intext)
return ch
def posTwitter(self, intext):
ch = self.twitter.pos(intext)
return ch
def parserOkt(self, intext):
ch = self.okt.nouns(intext)
return ch
def posOkt(self, intext):
ch = self.okt.pos(intext)
return ch
def parserNouns(self, intext):
buf = []
buf.append(self.parserKomoran(intext))
buf.append(self.parserKkma(intext))
buf.append(self.parserHannanum(intext))
buf.append(self.parserTwitter(intext))
buf.append(self.parserMecab(intext))
buf.append(self.parserOkt(intext))
dic = {}
for ar in buf:
for nn in ar:
if nn in dic:
dic[nn] += 1
else:
dic[nn] = 0
ret = []
for key, val in dic.items():
if val >= 3:
ret.append(key)
return ret
def parserPos(self, intext):
buf = []
buf.append(rr.posKomoran(intext))
buf.append(rr.posKkma(intext))
buf.append(rr.posHannanum(intext))
buf.append(rr.posTwitter(intext))
buf.append(rr.posMecab(intext))
buf.append(rr.posOkt(intext))
dic = {}
for ar in buf:
for vv in ar:
#if vv[0] in dic:
if vv[0] not in dic:
dic[vv[0]] = [vv[1]]
else:
dic[vv[0]].append(vv[1])
return dic
def analysis(self, blog_review_url):
# self.logger.info(blog_review_url)
analysis_checker = {}
try:
r = requests.get(blog_review_url)
except requests.ConnectionError as e:
return
soup = BeautifulSoup(r.text)
r.close()
try:
blog_review_url = soup.select('#screenFrame')[0]['src']
# self.logger.info("regenerated:"+blog_review_url)
r = requests.get(blog_review_url)
soup = BeautifulSoup(r.text)
r.close()
except Exception as e:
pass
try:
real_blog_review_url = "http://blog.naver.com" + soup.select(
'frame#mainFrame')[0]['src']
except IndexError as e:
self.skip_count += 1
return
r = requests.get(real_blog_review_url)
soup = BeautifulSoup(r.text)
r.close()
post_view = soup.select('.post-view')[0]
p_list = post_view.select('p')
raw_str_list = []
for item in p_list:
p_str = str(item.text.encode('utf-8')).replace(
'\xc2\xa0', ' ').replace('\xe2\x80\x8b', ' ').strip()
p_str = p_str.replace('ㅎ', '').replace('ㅋ', '')
if len(p_str) != 0:
raw_str_list.append(p_str.decode('utf-8'))
kkma = Hannanum()
for raw_str_item in raw_str_list:
if len(raw_str_item) >= 100:
self.skip_count += 1
continue
try:
raw_str_item = raw_str_item.strip()
pos_tuple = kkma.pos(raw_str_item)
for pos_tuple_item in pos_tuple:
item = pos_tuple_item[0]
item_type = pos_tuple_item[1]
if not (analysis_checker.has_key(item)) and (
item_type.startswith('N')
or item_type.startswith('V')
or item_type.startswith('M')
or item_type.startswith('XR')
or item_type.startswith('U')):
if self.analysis_result.has_key(item):
analysis_item_count = self.analysis_result.get(
item) + 1
else:
analysis_item_count = 1
self.analysis_result.update(
{item: analysis_item_count})
analysis_checker.update({item: 1})
except jpype.JavaException as exception:
pass
k.sentences(txt) '''['통찰력은 사물이나 현상의 원인과 결과를 이해하고 간파하는 능력이다.', '통찰력을 얻는 좋은 방법은 독서이다.']''' # 명사분석 k.nouns(txt) '''['통찰력', '사물', '현상', '원인', '결과', '이해', '간파', '능력', '방법', '독서']''' # 형태소 분석 k.pos(txt) from konlpy.tag import Hannanum h = Hannanum() h.nouns(txt) h.pos(txt) from konlpy.tag import Twitter t = Twitter() t.nouns(txt) t.pos(txt) import nltk from konlpy.corpus import kobill file_ko = kobill.fileids() # 문재인 대통령 취임사 분석 # kobill 검색 - 폴더찾아가기 - 문재인 연설 복붙 (여기서 window 파일 그대로 받으면 오류)
