250x250
Notice
Recent Posts
Recent Comments
| 일 | 월 | 화 | 수 | 목 | 금 | 토 |
|---|---|---|---|---|---|---|
| 1 | 2 | 3 | 4 | 5 | ||
| 6 | 7 | 8 | 9 | 10 | 11 | 12 |
| 13 | 14 | 15 | 16 | 17 | 18 | 19 |
| 20 | 21 | 22 | 23 | 24 | 25 | 26 |
| 27 | 28 | 29 | 30 |
Tags
- tomoto
- test
- 게시판 만들기
- 토픽추출
- r
- 지마켓
- lda
- db
- oracle
- Topics
- jsp 파일 설정
- Gmarket
- RESFUL
- Python
- 幼稚园杀手(유치원킬러)
- word2vec
- 네이버뉴스
- Websocket
- java
- 이력서
- mysql
- 과학백과사전
- pytorch
- (깃)git bash
- 자바
- 크롤링
- 파이썬
- 코사인 유사도
- spring MVC(모델2)방식
- 방식으로 텍스트
Archives
- Today
- Total
무회blog
001_,original_,options_,hdl_,topicModels-,0706(토픽 pmi,ctm 구하기) 본문
In [1]:
# 읽기 경로 = './'
# 읽을 파일 = filename
# 쓰기 경로 = './ ' (path_df 기준)
path_df = './'
filename = './topics_tss.csv'
get_cnt = 5 # 토픽의 갯수 , 빈도수에서 자동화 숫자
k_cnt = 1 # 토픽의 개수 , 행 , 1 ~ 32767 사이의 정수
top_n_cnt = get_cnt # 토픽의 갯수 , 열
min_cf_cnt = 1 # 단어 최소 출현 빈도 , 0 일시 모든 단어를 동일하게 봄
alpha_cnt = 0.1 # 문헌‐토픽 빈도
eta_cnt = 0.01 # 토픽‐단어 빈도
tran_cnt = 200 # 자동학습 빈도
rm_top2 = 1
In [2]:
#############################################
import tomotopy as tp
import pandas as pd
import numpy as np
import nltk.stem, nltk.corpus, nltk.tokenize, re ,os ,time
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()
print("success import")
In [3]:
class Cleaning_Text:
def listToText(inputList):
returnText = ''
for i in inputList:
returnText = returnText + i + ', '
rt2 = Cleaning_Text.text_cleaning(returnText)
return rt2
## # step_4, 공통 코드 , 텍스트 클리닝
def text_cleaning(text):
################################## gensim 사용을 위한 정규표현식 200624
hangul_path9 = '[가-힣]+\.' # 한글로 포함되다 .
hangul_path0 = '[가-힣]+\.[가-힣]{1}' # 한글 . + 한글 처리
hangul_path1 = '[가-힣]+\.[\d]{1}' # 한글 . + 숫자 처리 [0-9]
hangul_path2 = '[가-힣]+\.[a-z]{1}' # 한글 . + 영어 소문자
hangul_path3 = '[가-힣]+\.[A-Z]{1}' # 한글 . + 영어 대문자
hangul_path4 = '[가-힣]+\.[\S]{1}' # 한글 . + 비공백 [^ \t\n\r\f\v]와 같다.
hangul_path5 = '[가-힣]+\.[\s]{1}' # 한글 . + 공백 [ \t\n\r\f\v]와 같다.
hangul_path6 = '[가-힣]+\.[\W]{1}' # 한글 . + 숫자 + 문자가 아닌 것 [^a-zA-Z0-9]와 같다.
hangul_path7 = '[가-힣]+\.[\w]{1}' # 한글 . + 숫자 + 문자 [a-zA-Z0-9]와 같다.
hangul_path8 = '[가-힣]+\.[\b]{1}' # 한글 . + 단어 경계 (`\w`와 `\W`의 경계)
reg_path = hangul_path0 + '|' + hangul_path1 + '|'+ hangul_path2 + '|'+ hangul_path3 + '|'+ hangul_path4+ '|'+ hangul_path5
hangul = re.compile(reg_path) # 한글 + 모모로 포함되다 .
result = hangul.findall(text) # 정규식에 일치되는 부분을 리스트 형태로 저장, 단어 반환
result = list(set(result))
for x in result:
text = text.replace(x, x[:-1] + '\n' + x[-1:])
### 줄단위 좌우 공백 지우기 ,
text = text.replace('\n','_').split('_')
text = [x.strip() for x in text]
tts = ''
for i in text:
tts = tts + i + '\n'
text = tts
################################## gensim 사용을 위한 정규표현식 200624
text = re.sub('\[.+?\]','', 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 = text.strip()
# 좌측 공백 삭제
# text.lstrip()
# 우측 공백 삭제
#text.rstrip()
return text
In [4]:
tg_num = 2 # 읽어드린 문서에서 타겟팅 내용
dic01 = {}
dic02 = {}
token0 = []
li_model = []
# ReadDataPd = pd.read_csv('D:\\app_src\\anaconda\\04-srcTest\\testfile\\topics_tss.csv',engine="python")
ReadDataPd = pd.read_csv(filename,engine="python")
ReadDataPd['content']
al_list = ReadDataPd['content'].tolist()
all_list = [al_list[tg_num]]
hdl_list = all_list[0].split('.')
#hdl_list = all_list[tg_num]
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')] # 조사, 어미, 특수기호는 제거
print(type(hdl_list))
print("success Setting")
In [5]:
class Hannanum:
# 텍스트 정제 함수 : 분석에 불필요한 문자는 전부 제거합니다.
## # step_4, 공통 코드 , 텍스트 클리닝
def text_cleaning(text):
################################## gensim 사용을 위한 정규표현식 200624
hangul_path9 = '[가-힣]+\.' # 한글로 포함되다 .
hangul_path0 = '[가-힣]+\.[가-힣]{1}' # 한글 . + 한글 처리
hangul_path1 = '[가-힣]+\.[\d]{1}' # 한글 . + 숫자 처리 [0-9]
hangul_path2 = '[가-힣]+\.[a-z]{1}' # 한글 . + 영어 소문자
hangul_path3 = '[가-힣]+\.[A-Z]{1}' # 한글 . + 영어 대문자
hangul_path4 = '[가-힣]+\.[\S]{1}' # 한글 . + 비공백 [^ \t\n\r\f\v]와 같다.
hangul_path5 = '[가-힣]+\.[\s]{1}' # 한글 . + 공백 [ \t\n\r\f\v]와 같다.
hangul_path6 = '[가-힣]+\.[\W]{1}' # 한글 . + 숫자 + 문자가 아닌 것 [^a-zA-Z0-9]와 같다.
hangul_path7 = '[가-힣]+\.[\w]{1}' # 한글 . + 숫자 + 문자 [a-zA-Z0-9]와 같다.
hangul_path8 = '[가-힣]+\.[\b]{1}' # 한글 . + 단어 경계 (`\w`와 `\W`의 경계)
reg_path = hangul_path0 + '|' + hangul_path1 + '|'+ hangul_path2 + '|'+ hangul_path3 + '|'+ hangul_path4+ '|'+ hangul_path5
hangul = re.compile(reg_path) # 한글 + 모모로 포함되다 .
result = hangul.findall(text) # 정규식에 일치되는 부분을 리스트 형태로 저장, 단어 반환
result = list(set(result))
for x in result:
text = text.replace(x, x[:-1] + '\n' + x[-1:])
### 줄단위 좌우 공백 지우기 ,
text = text.replace('\n','_').split('_')
text = [x.strip() for x in text]
tts = ''
for i in text:
tts = tts + i + '\n'
text = tts
################################## gensim 사용을 위한 정규표현식 200624
text = re.sub('\[.+?\]','', 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 = 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
def fm_start(get_cnt):
texts = []
for w in all_list:
raw = w.lower()
#클린징
ReadDoc_CleanText= Hannanum.text_cleaning(raw)
#클린징 마친 텍스트를 문장으로 분리
ReadDoc_SplitText=ReadDoc_CleanText.split('\n')
#print("ReadDoc_SplitText=",ReadDoc_SplitText)
#문장으로 분리한 텍스트를 형태소 분석해서 용언(N), 체언(V)만 남김
ReadDoc_Analyis=Hannanum.get_infoText(ReadDoc_SplitText)
ReadDoc_Analyis=pd.Series([x for x in ReadDoc_Analyis if len(x)>1])
#문서들을 리스트 형태로 texts에 추가
texts.append(ReadDoc_Analyis)
for i in range(len(texts)) :
series_keys = texts[i].value_counts().index.tolist()
series_value = texts[i].value_counts().head(get_cnt)
series_keys = series_keys[:5]
df0 = pd.DataFrame()
tts = Cleaning_Text.listToText(series_keys)
# tts1 = Cleaning_Text.listToText(series_value)
print(tts)
# tts = ''
# for i in series_keys:
# tts = tts + i + ", "
tts1 = ''
for i in series_value:
tts1 = tts1 + str(i) + ", "
df0['series_keys'] = [tts]
# df0['series_value'] = [tts1]
# df0.to_excel(path_df+'hannanum_model.xlsx')
return df0
print('success_Hannanum')
Hannanum.fm_start(get_cnt)
Out[5]:
In [6]:
class Tomato_OriginalTopicModel:
# tokenize 처리
dic01 = {}
token0 = []
li_model = []
li_model_PMI = []
li_model_IDF = []
li_model_ONE = []
stemmer = nltk.stem.porter.PorterStemmer()
stopwords = set(nltk.corpus.stopwords.words('korean'))
def fm_start(get_cnt):
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 모든 단어를 동등하게 보다
for i, line in enumerate(all_list):
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)
Tomato_OriginalTopicModel.li_model.append(ttx1)
Tomato_OriginalTopicModel.li_model_PMI.append(ttx2)
Tomato_OriginalTopicModel.li_model_IDF.append(ttx3)
Tomato_OriginalTopicModel.li_model_ONE.append(ttx4)
Tomato_OriginalTopicModel.dic01['lda_model'] = Tomato_OriginalTopicModel.li_model
Tomato_OriginalTopicModel.dic01['lda_PMI'] = Tomato_OriginalTopicModel.li_model_PMI
Tomato_OriginalTopicModel.dic01['lda_IDF'] = Tomato_OriginalTopicModel.li_model_IDF
Tomato_OriginalTopicModel.dic01['lda_ONE'] = Tomato_OriginalTopicModel.li_model_ONE
df1 = pd.DataFrame(Tomato_OriginalTopicModel.dic01)
df1= pd.DataFrame(df1)
# df.to_excel(path_df+'original_ldamodels.xlsx')
return df1
print('success_Tomato_OriginalTopicModel')
In [7]:
#############################################
# (tw=TermWeight.ONE, min_cf=0, rm_top=0, k=1, smoothing_alpha=0.1, eta=0.01, seed=?)
class Tomato_OptionTopicModels: # Tomato_OptionTopicModel
mdl_HDPModel = tp.HDPModel(tw=tp.TermWeight.ONE, min_cf=3, rm_top=1) # 계층적 디리클레 프로세스 ( HDPModel )
mdl_CTModel = tp.CTModel(tw=tp.TermWeight.ONE, min_cf=min_cf_cnt, rm_top=1) # 상관 토픽 모델 ( CTModel )
mdl_PAMODel = tp.PAModel(tw=tp.TermWeight.ONE, min_cf=3, rm_top=1) # 파칭코 할당 ( PAMODel )
mdl_HPAModel = tp.HPAModel(tw=tp.TermWeight.ONE, min_cf=3, rm_top=1) # 계층적 PA ( HPAModel )
mdl_MGLDAModel = tp.MGLDAModel(tw=tp.TermWeight.ONE, min_cf=3, rm_top=1) # 멀티 그레인 LDA ( MGLDAModel )
mdl_LLDAModel = tp.LLDAModel(tw=tp.TermWeight.ONE, min_cf=3, rm_top=1) # 라벨 LDA ( LLDAModel )
def fm_mdl(model):
for i, line in enumerate(all_list):
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.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))
ttx1 = re.sub('[a-zA-Z@.]','',ttx1)
li_model.append(ttx1)
return li_model
def fm_start():
li_mdl_HDPModel = Tomato_OptionTopicModels.fm_mdl(Tomato_OptionTopicModels.mdl_HDPModel)
li_mdl_CTModel = Tomato_OptionTopicModels.fm_mdl(Tomato_OptionTopicModels.mdl_CTModel)
li_mdl_PAMODel = Tomato_OptionTopicModels.fm_mdl(Tomato_OptionTopicModels.mdl_PAMODel)
li_mdl_HPAModel = Tomato_OptionTopicModels.fm_mdl(Tomato_OptionTopicModels.mdl_HPAModel)
li_mdl_MGLDAModel = Tomato_OptionTopicModels.fm_mdl(Tomato_OptionTopicModels.mdl_MGLDAModel)
li_mdl_LLDAModel = Tomato_OptionTopicModels.fm_mdl(Tomato_OptionTopicModels.mdl_LLDAModel)
dic01['mdl_HDPModel'] = li_mdl_HDPModel
dic01['mdl_CTModel'] = li_mdl_CTModel
dic01['mdl_PAMODel'] = li_mdl_PAMODel
dic01['mdl_HPAModel'] = li_mdl_HPAModel
dic01['mdl_MGLDAModel'] = li_mdl_MGLDAModel
dic01['mdl_LLDAModel'] = li_mdl_LLDAModel
df2 = pd.DataFrame(dic01).head(5)
# pd_zh_ldadt = pd.DataFrame(dic01).head(5)
# pd_zh_ldadt.to_excel(path_df+'options_ldamodels.xlsx')
return df2
print('success_Tomato_OptionTopicModels')
In [8]:
# tokenize 처리 # Tomato_OptionTopicModels
class Tomato_HLDAModel:
model = tp.HLDAModel(tw=tp.TermWeight.ONE, min_cf=3, rm_top=1) # 계층적 LDA ( HLDAModel )
def model_exe(model):
for i, line in enumerate(hdl_list):
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.train(tran_cnt)
print(model.k)
for i in range(model.k):
ttx1= ', '.join(w for w, p in model.get_topic_words(i,top_n=top_n_cnt))
ttx1 = re.sub('[a-zA-Z@.]','',ttx1)
li_model.append(ttx1)
dic02['mdl_HLDAModel'] = li_model
df3 = pd.DataFrame(dic02)
return df3
def fm_start():
Tomato_HLDAModel.model_exe(Tomato_HLDAModel.model)
print('success_Tomato_HLDAModel')
In [9]:
class Get_Result:
def merge_df():
df0 = Hannanum.fm_start(get_cnt)
df1 = Tomato_OriginalTopicModel.fm_start(get_cnt)
df2 = Tomato_OptionTopicModels.fm_start()
df1 = df1.head(1)
df2 = df2.head(1)
df_rs = pd.concat([df0,df1,df2], axis=1).head(1)
remarks = """# get_cnt = 7 # 토픽의 갯수 , 빈도수에서 자동화 숫자
# k_cnt = 5 # 토픽의 개수 , 행 , 1 ~ 32767 사이의 정수
# top_n_cnt = get_cnt # 토픽의 갯수 , 열
# min_cf_cnt = 1 # 단어 최소 출현 빈도 , 0 일시 모든 단어를 동일하게 봄
# alpha_cnt = 0.1 # 문헌‐토픽 빈도
# eta_cnt = 0.01 # 토픽‐단어 빈도
# tran_cnt = 200 # 자동학습 빈도
# rm_top2 = 1
"""
df_rs['remarks'] = remarks
df_rs= df_rs[['lda_PMI','mdl_CTModel','remarks']] ## 필요한 토픽 모델 컬럼 선택하여 선택적 출력 ,
df_rs.to_excel('result_Topics.xlsx')
return df_rs
In [10]:
Get_Result.merge_df()
print(tran_cnt)
print("success_all")
'Python' 카테고리의 다른 글
| gensim_similarity, 문서 or 텍스트 유사도 구하기, 200708-gensim_similarity_test003_ver01 (0) | 2020.07.08 |
|---|---|
| 001_topics_module-,tomato,ctm,lda,hannanums (0) | 2020.07.06 |
| 200706-gensim-,gensim_summarize,okapi,gensim,bm25 (0) | 2020.07.06 |
| 200701-summarize_test_gensim모듈화-002, gensim_summarize, gensim_bm25, okapi_bm25, completesrc,finishTest (0) | 2020.07.02 |
| 200701-summarize_test_gensim,모듈화,test,bm25test (0) | 2020.07.02 |
Comments