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 파일 그대로 받으면 오류)