200609-005.03.02_topikTs_LDA

In [1]:

# for_005_topikTs_tomoto
# %pip install tomotopy
# %pip install nltk
#  한국어 전처리 
# %pip install --upgrade kiwipiepy  
# %pip install KoNLP
# import nltk
# nltk.download()
#############################################
import tomotopy as tp 
import pandas as pd
import numpy as np
import nltk.stem, nltk.corpus, nltk.tokenize, re ,os
from kiwipiepy import Kiwi
kiwi = Kiwi()
kiwi.prepare()
#############################################
from gensim import corpora 
from gensim import models
from konlpy.utils import pprint
from konlpy.tag import Hannanum
from konlpy.tag import Kkma
kkma = Kkma()
hannanum = Hannanum()

In [2]:

# 테스트 할 대상 분류 대상 파일을 읽어온다
import pandas as pd
ReadDataPd = pd.read_csv('D:\\app_src\\anaconda\\04-srcTest\\testfile\\all_test\\tss.csv',engine="python")
ReadDataPd['내용']
type(ReadDataPd['내용'])
all_list = ReadDataPd['내용'].tolist()

In [3]:

class fr_hannanum_mth:
    # 텍스트 정제 함수 : 분석에 불필요한 문자는 전부 제거합니다. 
    def text_cleaning(text): 
        #이모티콘 제거
        EMOJI = re.compile('[\U00010000-\U0010ffff]', flags=re.UNICODE)
        text= EMOJI.sub(r'', text)
        #이메일 주소 제거
        email =re.compile('([a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+)')
        text = email.sub('', text) 
        #URL 제거
        url =re.compile('(http|ftp|https)://(?:[-\w.]|(?:%[\da-fA-F]{2}))+')
        text = url.sub('', text) 
        #HTML 제거
        html =re.compile('<[^>]*>')
        text = html.sub('', text) 

        #특수문자를 공백으로 대체(문장을 살리기위헤 마침표는 남겨둠)
        #special =re.compile('[^\w\s]')
        #text = special.sub(' ', text) 
        special= ['*', '{', ',', ':', ']', '$', '+', '[', '#', '(', '%', '&', '}', '`', '‘', '’','·',
                    '=', ';', '>','＞', '/', '"', '“', '”', '\\', '?', '~', "'", '<', ')', '^', '!', '_',
                    '|', '@','@','©','ⓒ', '℗','®','①', '-','▶','…','☞'] #'.', 빼고
        for chr in special :
            text=text.replace(chr,' ')

        #특수문자 제거 후 생기는 중복된 공백 제거
        while text.find('  ') > 0:
            text = text.replace('  ',' ' ) # 중복된 공백 제거

        #특수문자 제거 후 생기는 중복된 개행 제거
        while text.find('\n\n') > 0:
            text = text.replace('\n\n','\n' ) # 중복된 개행 제거

        #좌우측 공백 삭제
        text.strip()

        # 좌측 공백 삭제
        # text.lstrip()

        # 우측 공백 삭제
        #text.rstrip()        
        return text 

    # 형태소 분석해서 용언(P), 체언(N)만 남김
    def get_infoText(read_text):
        #resList = list()
        resList=[]
        #GetWordSet = set(['N'])
        GetWordSet = set(['N','P'])
        for read_text_line in read_text:
            res=""

            if len(read_text_line) > 0:
                pos = hannanum.pos(read_text_line,ntags=9)
                for keyword, type in pos:
                    # 키워드가 한글자 이상일 경우만
                    if len(keyword) > 1 :
                        # 용언(P), 체언(N)만 남김
                        if (type in GetWordSet):
                            if type == 'P': #용언일 경우 '다'를 붙여줌
                                keyword=keyword+'다'
                            resList.append(keyword)  
        return resList


    texts = []
    def fm_start(get_cnt):
        # ReadDataPd['내용']
        for w in ReadDataPd['내용']:
            raw = w.lower()
            #클린징
            ReadDoc_CleanText= text_cleaning(raw)

            #클린징 마친 텍스트를 문장으로 분리
            ReadDoc_SplitText=ReadDoc_CleanText.split('\n')
            #print("ReadDoc_SplitText=",ReadDoc_SplitText)

            #문장으로 분리한 텍스트를 형태소 분석해서 용언(N), 체언(V)만 남김
            ReadDoc_Analyis=get_infoText(ReadDoc_SplitText)

            ReadDoc_Analyis=pd.Series([x for x in ReadDoc_Analyis if len(x)>1])
            #문서들을 리스트 형태로  texts에 추가
            texts.append(ReadDoc_Analyis)


        #print("texts=",texts)    

        for i in range(len(texts)) :
            print(type(texts[i].value_counts().head(get_cnt)))
            print("Doc i = ",texts[i].value_counts().head(get_cnt))
            

In [4]:

class fr_kkma_mth:
    # 형태소 분석하여 명사만 추출
    temp = []
    for i in range(len(all_list)):
        temp.append(kkma.nouns(all_list[i]))
    # print("\n temp=",temp) 

    def flatten(l): 
        flatList = [] 
        for elem in l: 
            if type(elem) == list: 
                for e in elem: 
                    flatList.append(e) 
            else: 
                flatList.append(elem) 
        return flatList
    
    def fm_start(get_cnt):
        word_list=flatten(temp)
        # print("\n word_list=",word_list) 
        # 두글자 이상인 단어만 추출
        word_list=pd.Series([x for x in word_list if len(x)>1])
        word_list.value_counts().head(get_cnt)
        print(word_list.value_counts().head(get_cnt))

# get_cnt = 6            
# fr_hannanum_mth.fm_start(get_cnt)
# fr_kkma_mth.fm_start(get_cnt)
# print('-'*30)
# testLda.startfu

In [5]:

# ######################## # # #  한국어 전처리 
filepath = './testfile/문재인대통령취임연설문_ansi.txt'
stemmer = nltk.stem.porter.PorterStemmer() 
stopwords = set(nltk.corpus.stopwords.words('korean')) 

def tokenize(sent):
    res, score = kiwi.analyze(sent)[0] # 첫번째 결과를 사용
    return [word
            for word, tag, _, _ in res
            if not tag.startswith('E') 
            and not tag.startswith('J') 
            and not tag.startswith('S')] # 조사, 어미, 특수기호는 제거


# tokenize 처리 
dic01 = {}
token0 = []
li_model = [] 
li_model_PMI = []
li_model_IDF = []
li_model_ONE = []
class fr_kiwi01_mth:
    def indata_func(model,model_PMI,model_IDF,model_ONE):
        for i, line in enumerate(open(filepath)):
            token0 = tokenize(line)
            stopwords = set([wd for wd in token0 if len(wd) <= 1]) #  한글자 단어는 불요어로 지정 
            stopwords = set('기자') #  한글자 단어는 불요어로 지정
            token0 = [wd for wd in token0 if len(wd) > 1]          # 한글자 이상 단어 토큰으로 지정 
            model.add_doc(token0)                                    # tokenize함수를 이용해 전처리한 결과를 add_doc에 넣습니다.
            model_PMI.add_doc(token0)  
            model_IDF.add_doc(token0)  
            model_ONE.add_doc(token0)  
        model.train(tran_cnt)    
        for i in range(model.k):
            ttx1= ', '.join(w for w, p in model.get_topic_words(i,top_n=top_n_cnt))
            ttx2= ', '.join(w for w, p in model_PMI.get_topic_words(i, top_n=top_n_cnt))
            ttx3= ', '.join(w for w, p in model_IDF.get_topic_words(i, top_n=top_n_cnt))
            ttx4= ', '.join(w for w, p in model_ONE.get_topic_words(i, top_n=top_n_cnt))
            
            ttx1 = re.sub('[a-zA-Z@.]','',ttx1)
            ttx2 = re.sub('[a-zA-Z@.]','',ttx2)
            ttx3 = re.sub('[a-zA-Z@.]','',ttx3)
            ttx4 = re.sub('[a-zA-Z@.]','',ttx4)
            
            li_model.append(ttx1)
            li_model_PMI.append(ttx2)
            li_model_IDF.append(ttx3)
            li_model_ONE.append(ttx4)
            
            dic01['lda_model'] = li_model
            dic01['lda_PMI'] = li_model_PMI
            dic01['lda_IDF'] = li_model_IDF
            dic01['lda_ONE'] = li_model_ONE
        return dic01
            
    #     print('Topic #{}'.format(i), end='\t')
    
    def fm_start():
        k_cnt      = 5     # 토픽의 개수    , 행 , 1 ~ 32767 사이의 정수
        top_n_cnt  = 7     # 토픽의  갯수   , 열
        min_cf_cnt = 10    # 단어 최소 출현 빈도  , 0 일시 모든 단어를 동일하게 봄 
        alpha_cnt  = 0.1   # 문헌‐토픽 빈도
        eta_cnt    = 0.01  # 토픽‐단어 빈도
        tran_cnt   = 500   # 자동학습 빈도

        model     = tp.LDAModel(k=k_cnt, alpha=alpha_cnt,eta = eta_cnt)
        model_PMI = tp.LDAModel(k=k_cnt, alpha=alpha_cnt,eta = eta_cnt, min_cf=min_cf_cnt,tw=tp.TermWeight.PMI)
        model_IDF = tp.LDAModel(k=k_cnt, alpha=alpha_cnt,eta = eta_cnt, min_cf=min_cf_cnt,tw=tp.TermWeight.IDF)
        model_ONE = tp.LDAModel(k=k_cnt, alpha=alpha_cnt,eta = eta_cnt, min_cf=min_cf_cnt,tw=tp.TermWeight.ONE)  # one 모든 단어를 동등하게 보다     
        dic01 = testLda.indata_func(model,model_PMI,model_IDF,model_ONE)
        or_ldadt = pd.DataFrame(dic01)
        
        return or_ldadt
get_cnt = 6            
# fr_hannanum_mth.fm_start(get_cnt)
fr_kkma_mth.fm_start(get_cnt)
# print('-'*30)
# fr_kiwi01_mth.fm_start()

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-5-73f9b6c1a2f6> in <module>
     74 get_cnt = 6
     75 # fr_hannanum_mth.fm_start(get_cnt)
---> 76 fr_kkma_mth.fm_start(get_cnt)
     77 # print('-'*30)
     78 # fr_kiwi01_mth.fm_start()

<ipython-input-4-e17877e48244> in fm_start(get_cnt)
     17 
     18     def fm_start(get_cnt):
---> 19         word_list=flatten(temp)
     20         # print("\n word_list=",word_list)
     21         # 두글자 이상인 단어만 추출

NameError: name 'flatten' is not defined

In [ ]:

# import os

# aa = os.listdir()
# type(aa)
# aa
# for x in os.listdir('./'):
#         if x.endswith('ipynb'):
#                 print(x)
# os.mkdir('./testfile/all_test/testFolder/')
# os.rmdir('./testfile/all_test/폴더를_생성하지')
# os.remove('./testfile/all_test/문재인대통령취임연설문_ansi - 복사본.txt')