# 學員交流微信群：請加拉群專用微信號 bigdatastar # 文彤老師微信公眾號：統計之星import nltknltk.download()

nltk.__version__

# 布朗語料庫示例from nltk.corpus import brownbrown.categories()

len(brown.sents())

len(brown.words())

import pandas as pd# 有的環(huán)境配置下read_table出錯，因此改用read_csvraw = pd.read_csv("金庸-射雕英雄傳txt精校版.txt",                  names = ['txt'], sep ='aaa', encoding ="GBK")print(len(raw))raw

# 章節(jié)判斷用變量預處理def m_head(tmpstr):    return tmpstr[:1]def m_mid(tmpstr):    return tmpstr.find("回 ")# 注意：下面的raw.txt指的是raw數據框中的txt變量列，對pandas不熟悉的學員請復習相關知識raw['head'] = raw.txt.apply(m_head)raw['mid'] = raw.txt.apply(m_mid)raw['len'] = raw.txt.apply(len)# raw['chap'] = 0raw.head(50)

# 章節(jié)判斷chapnum = 0for i in range(len(raw)):    if raw['head'][i] == "第" and raw['mid'][i] > 0 and raw['len'][i] < 30 :        chapnum += 1    if chapnum >= 40 and raw['txt'][i] == "附錄一：成吉思汗家族" :        chapnum = 0    raw.loc[i, 'chap'] = chapnum    # 刪除臨時變量，這里必須刪除，否則后續(xù)sum函數處會出錯del raw['head']del raw['mid']del raw['len']raw.head(50)

raw[raw.chap == 1].head()

from matplotlib import pyplot as plt%matplotlib inlineraw.txt.agg(len).plot.box()

rawgrp = raw.groupby('chap')chapter = rawgrp.agg(sum) # 只有字符串列的情況下，sum函數自動轉為合并字符串，對pandas不熟悉的學員請復習相關知識chapter = chapter[chapter.index != 0]chapter.txt[1]

import jiebatmpstr = "郭靖和哀牢山三十六劍。"res = jieba.cut(tmpstr) # 精確模式print(res) # 是一個可迭代的 generator，可以使用 for 循環(huán)來遍歷結果，本質上類似list

print(' '.join(res))

res = jieba.cut(tmpstr)list(word for word in res) # 演示generator的用法

print(jieba.lcut(tmpstr)) # 結果直接輸出為list

print('/'.join(jieba.cut(tmpstr, cut_all = True))) # 全模式

# 搜索引擎模式，還有jieba.lcut_for_search可用print('/'.join(jieba.cut_for_search(tmpstr)))

# 動態(tài)修改詞典jieba.add_word("哀牢山三十六劍")'/'.join(jieba.cut(tmpstr))

jieba.del_word("哀牢山三十六劍")'/'.join(jieba.cut(tmpstr))

dict = '金庸小說詞庫.txt'jieba.load_userdict(dict) # dict為自定義詞典的路徑'/'.join(jieba.cut(tmpstr))

newlist = [ w for w in jieba.cut(tmpstr) if w not in ['和', '。'] ] print(newlist)

import pandas as pdtmpdf = pd.read_csv('停用詞.txt',                    names = ['w'], sep = 'aaa', encoding = 'utf-8')tmpdf.head()

# 熟悉Python的可以直接使用 open('stopWord.txt').readlines()獲取停用詞list，效率更高[ w for w in jieba.cut(tmpstr) if w not in list(tmpdf.w) ]

# 使用預先準備的停用詞表import jieba.analyse as anaana.set_stop_words('停用詞.txt')jieba.lcut(tmpstr) # 讀入的停用詞列表對分詞結果無效

ana.extract_tags(tmpstr, topK = 20) # 使用TF-IDF算法提取關鍵詞，并同時去掉停用詞

import jieba.posseg as psgtmpres = psg.cut(tmpstr) # 附加詞性的分詞結果print(tmpres)for item in tmpres:    print(item.word, item.flag)

psg.lcut(tmpstr) # 直接輸出為list，成員為pair

import jieba#分詞word_list = jieba.lcut(chapter.txt[1])word_list[:10]

word_list = jieba.lcut(" ".join(raw.txt))

word_list[:10]

import pandas as pddf = pd.DataFrame(word_list, columns = ['word'])df.head(30)

result = df.groupby(['word']).size()print(type(result))freqlist = result.sort_values(ascending=False)freqlist[:20]

freqlist[freqlist.index == '道']

freqlist[freqlist.index == '黃蓉道']

jieba.add_word('道', freq = 50000)

import nltk# 分詞等預處理工作# 這里可以根據需要做任何的preprocessing: stopwords, lemma, stemming, etc.word_list[:10]

fdist = nltk.FreqDist(word_list) # 生成完整的詞條頻數字典fdist

# 帶上某個單詞, 可以看到它在整個文章中出現的次數fdist['顏烈']

fdist.keys() # 列出詞條列表

fdist.tabulate(10)

fdist.most_common(5)

import wordcloudmyfont = r'C:\Windows\Fonts\simkai.ttf'text = 'this is shanghai, 郭靖, 和, 哀牢山 三十六劍'cloudobj = wordcloud.WordCloud(font_path = myfont).generate(text)  print(cloudobj)

import matplotlib.pyplot as pltplt.imshow(cloudobj)plt.axis("off")plt.show()

# 更改詞云參數設定cloudobj = wordcloud.WordCloud(font_path = myfont, 
    width = 360, height = 180,    mode = "RGBA", background_color = None).generate(text)  plt.imshow(cloudobj)plt.axis("off")plt.show()

cloudobj.to_file("詞云.png")# wordcloud.WordCloud(font_path = myfont).generate(text).to_file(r"詞云.png")

import pandas as pdimport jiebastoplist = list(pd.read_csv('停用詞.txt', names = ['w'], sep = 'aaa', 
                            encoding = 'utf-8', engine='python').w)def m_cut(intxt):    return [ w for w in jieba.cut(intxt) if w not in stoplist ]

cloudobj = wordcloud.WordCloud(font_path = myfont, 
    width = 1200, height = 800,    mode = "RGBA", background_color = None,    stopwords = stoplist).generate(' '.join(jieba.lcut(chapter.txt[1])))  plt.imshow(cloudobj)plt.axis("off")plt.show()

cloudobj.to_file("詞云2.png")

#基于分詞頻數繪制詞云txt_freq = {'張三':100,'李四':90,'王二麻子':50}cloudobj = wordcloud.WordCloud(font_path = myfont).fit_words(txt_freq)plt.imshow(cloudobj)plt.axis("off")plt.show()

import nltkfrom nltk import FreqDisttokens = m_cut(chapter.txt[1])fdist = FreqDist(tokens) # 生成完整的詞條頻數字典type(fdist)

cloudobj = wordcloud.WordCloud(font_path = myfont).fit_words(fdist)plt.imshow(cloudobj)plt.axis("off")plt.show()

from imageio import imreaddef m_cut(intxt):    return [ w for w in jieba.cut(intxt) if w not in stoplist and len(w) > 1 ] cloudobj = wordcloud.WordCloud(font_path = myfont, 
    mask = imread("射雕背景1.png"), 
    mode = "RGBA", background_color = None    ).generate(' '.join(m_cut(chapter.txt[1]))) plt.imshow(cloudobj)plt.axis("off")plt.show()

import numpy as npimgobj = imread("射雕背景2.png")image_colors = wordcloud.ImageColorGenerator(np.array(imgobj))cloudobj.recolor(color_func=image_colors)plt.imshow(cloudobj)plt.axis("off")plt.show()

# 官網提供的顏色分組類代碼，略有修改from wordcloud import get_single_color_funcclass GroupedColorFunc(object):    def __init__(self, color_to_words, default_color):        self.color_func_to_words = [            (get_single_color_func(color), set(words))            for (color, words) in color_to_words.items()]        self.default_color_func = get_single_color_func(default_color)    def get_color_func(self, word):        """Returns a single_color_func associated with the word"""        try:            color_func = next(                color_func for (color_func, words) in self.color_func_to_words                if word in words)        except StopIteration:            color_func = self.default_color_func        return color_func    def __call__(self, word, **kwargs):        return self.get_color_func(word)(word, **kwargs)####### 指定分組色系color_to_words = {    '#00ff00': ['顏烈', '武官', '金兵', '官兵'],    'red': ['包惜弱', '郭嘯天', '楊鐵心', '丘處機']}default_color = 'grey' # 指定其他詞條的顏色grouped_color_func = GroupedColorFunc(color_to_words, default_color)cloudobj.recolor(color_func=grouped_color_func)plt.imshow(cloudobj)plt.axis("off")plt.show()

from gensim.corpora import Dictionarytexts = [['human', 'interface', 'computer']]dct = Dictionary(texts)  # fit dictionarydct.num_nnz

# 向字典增加詞條dct.add_documents([["cat", "say", "meow"], ["dog"]])  dct.token2id

dct.doc2bow(["this", "is", "cat", "not", "a", "dog"])

dct.doc2bow(["this", "is", "cat", "not", "a", "dog"], return_missing = True)

dct.doc2idx(["this", "is", "a", "dog", "not", "cat"])

chapter.head()

# 設定分詞及清理停用詞函數# 熟悉Python的可以使用 open('stopWord.txt').readlines（） 獲取停用詞list，效率更高stoplist = list(pd.read_csv('停用詞.txt', names = ['w'], sep = 'aaa', 
                            encoding = 'utf-8', engine='python').w)import jieba def m_cut(intxt):    return [ w for w in jieba.cut(intxt) 
            if w not in stoplist and len(w) > 1 ]

# 設定數據框轉換函數def m_appdf(chapnum):    tmpdf = pd.DataFrame(m_cut(chapter.txt[chapnum + 1]), columns = ['word'])    tmpdf['chap'] = chapter.index[chapnum] # 也可以直接 = chapnum + 1    return tmpdf

# 全部讀入并轉換為數據框df0 = pd.DataFrame(columns = ['word', 'chap']) # 初始化結果數據框for i in range(len(chapter)):    df0 = df0.append(m_appdf(i))df0.tail()

# 輸出為序列格式df0.groupby(['word', 'chap']).agg('size').tail(10)

# 直接輸出為數據框t2d = pd.crosstab(df0.word, df0.chap)len(t2d)

t2d.head()

# 計算各詞條的總出現頻次，準備進行低頻詞刪減totnum = t2d.agg(func = 'sum', axis=1)totnum

t2dclean = t2d.iloc[list(totnum >= 10)]t2dclean.T

from sklearn.feature_extraction.text import CountVectorizercountvec = CountVectorizer(min_df = 2) # 在兩個以上文檔中出現的才保留analyze = countvec.build_analyzer()analyze('郭靖 和 哀牢山 三十六 劍 。')

countvec.fit(['郭靖 和 黃蓉 哀牢山 三十六 劍 。', '黃蓉 和 郭靖 郭靖'])

countvec.get_feature_names() # 詞匯列表，實際上就是獲取每個列對應的詞條

countvec.vocabulary_ # 詞條字典

x = countvec.transform(['郭靖 和 黃蓉 哀牢山 三十六 劍 。', '黃蓉 和 郭靖 郭靖'])type(x)

x.todense() # 將稀疏矩陣直接轉換為標準格式矩陣

countvec.fit_transform(['郭靖 和 哀牢山 三十六 劍 。', '黃蓉 和 郭靖 郭靖']) # 一次搞定

rawchap = [ " ".join(m_cut(w)) for w in chapter.txt.iloc[:5]] rawchap[0]

from sklearn.feature_extraction.text import CountVectorizercountvec = CountVectorizer(min_df = 5) # 在5個以上章節(jié)中出現的才保留res = countvec.fit_transform(rawchap)res

res.todense()

countvec.get_feature_names()

import jiebaimport jieba.analyse# 注意：函數是在使用默認的TFIDF模型進行分析！jieba.analyse.extract_tags(chapter.txt[1])

jieba.analyse.extract_tags(chapter.txt[1], withWeight = True) # 要求返回權重值

# 應用自定義詞典改善分詞效果jieba.load_userdict('金庸小說詞庫.txt') # dict為自定義詞典的路徑# 在TFIDF計算中直接應用停用詞表jieba.analyse.set_stop_words('停用詞.txt')TFres = jieba.analyse.extract_tags(chapter.txt[1], withWeight = True)TFres[:10]

# 使用自定義TF-IDF頻率文件jieba.analyse.set_idf_path("idf.txt.big")TFres1 = jieba.analyse.extract_tags(chapter.txt[1], withWeight = True)TFres1[:10]

from sklearn.feature_extraction.text import TfidfTransformertxtlist = [ " ".join(m_cut(w)) for w in chapter.txt.iloc[:5]] vectorizer = CountVectorizer() X = vectorizer.fit_transform(txtlist) # 將文本中的詞語轉換為詞頻矩陣  transformer = TfidfTransformer()  tfidf = transformer.fit_transform(X)  #基于詞頻矩陣X計算TF-IDF值  tfidf

tfidf.toarray() # 轉換為數組

tfidf.todense() # 轉換為矩陣

tfidf.todense().shape

print("字典長度：", len(vectorizer.vocabulary_))vectorizer.vocabulary_

# 文檔分詞及預處理  chaplist = [m_cut(w) for w in chapter.txt.iloc[:5]]chaplist

from gensim import corpora, models  # 生成文檔對應的字典和bow稀疏向量dictionary = corpora.Dictionary(chaplist)  corpus = [dictionary.doc2bow(text) for text in chaplist] # 仍為list in list  corpus

tfidf_model = models.TfidfModel(corpus) # 建立TF-IDF模型  corpus_tfidf = tfidf_model[corpus] # 對所需文檔計算TF-IDF結果corpus_tfidf

corpus_tfidf[3] # 列出所需文檔的TF-IDF計算結果

dictionary.token2id # 列出字典內容

jieba.analyse.textrank(chapter.txt[1], topK=20, withWeight = True)

# 設定分詞及清理停用詞函數# 熟悉Python的可以使用 open('stopWord.txt').readlines（） 獲取停用詞list，效率更高stoplist = list(pd.read_csv('停用詞.txt', names = ['w'], sep = 'aaa', 
                            encoding = 'utf-8', engine='python').w)import jieba def m_cut(intxt):    return [ w for w in jieba.cut(intxt) 
            if w not in stoplist and len(w) > 1 ]

# 生成分詞清理后章節(jié)文本cleanchap = [ " ".join(m_cut(w)) for w in chapter.txt]

# 將文本中的詞語轉換為詞頻矩陣  from sklearn.feature_extraction.text import CountVectorizercountvec = CountVectorizer(min_df = 5) wordmtx = countvec.fit_transform(cleanchap) wordmtx

#基于詞頻矩陣X計算TF-IDF值  from sklearn.feature_extraction.text import TfidfTransformertransformer = TfidfTransformer()  tfidf = transformer.fit_transform(wordmtx)  tfidf

# 設定LDA模型from sklearn.decomposition import LatentDirichletAllocationn_topics = 10ldamodel = LatentDirichletAllocation(n_components = n_topics)

# 擬合LDA模型，注意這里使用的是原始wordmtx矩陣ldamodel.fit(wordmtx)

# 擬合后模型的實質print(ldamodel.components_.shape)ldamodel.components_[:2]

# 主題詞打印函數def print_top_words(model, feature_names, n_top_words):    for topic_idx, topic in enumerate(model.components_):        print("Topic #%d:" % topic_idx)        print(" ".join([feature_names[i] 
                        for i in topic.argsort()[:-n_top_words - 1:-1]]))    print()

n_top_words = 12tf_feature_names = countvec.get_feature_names()print_top_words(ldamodel, tf_feature_names, n_top_words)

# 設定分詞及清理停用詞函數# 熟悉Python的可以使用 open('stopWord.txt').readlines()獲取停用詞list，效率更高stoplist = list(pd.read_csv('停用詞.txt', names = ['w'], sep = 'aaa', 
                            encoding = 'utf-8', engine='python').w)import jieba def m_cut(intxt):    return [ w for w in jieba.cut(intxt) 
            if w not in stoplist and len(w) > 1 ]

# 文檔預處理，提取主題詞  chaplist = [m_cut(w) for w in chapter.txt]

# 生成文檔對應的字典和bow稀疏向量from gensim import corpora, models  dictionary = corpora.Dictionary(chaplist)  corpus = [dictionary.doc2bow(text) for text in chaplist] # 仍為list in list  tfidf_model = models.TfidfModel(corpus) # 建立TF-IDF模型  corpus_tfidf = tfidf_model[corpus] # 對所需文檔計算TF-IDF結果corpus_tfidf

from gensim.models.ldamodel import LdaModel# 列出所消耗的時間備查%time ldamodel1 = LdaModel(corpus, id2word = dictionary, \                          num_topics = 10, passes = 2)

ldamodel1.print_topics()

# 計算各語料的LDA模型值corpus_lda = ldamodel1[corpus_tfidf] # 此處應當使用和模型訓練時相同類型的矩陣for doc in corpus_lda:    print(doc)

ldamodel1.get_topics()

# 檢索和文本內容最接近的主題query = chapter.txt[1] # 檢索和第1章最接近的主題query_bow = dictionary.doc2bow(m_cut(query)) # 頻數向量query_tfidf = tfidf_model[query_bow] # TF-IDF向量print("轉換后：", query_tfidf[:10])ldamodel1.get_document_topics(query_bow) # 需要輸入和文檔對應的bow向量

# 檢索和文本內容最接近的主題ldamodel1[query_tfidf]

# 對sklearn的LDA結果作呈現import pyLDAvisimport pyLDAvis.sklearnpyLDAvis.enable_notebook()

pyLDAvis.sklearn.prepare(ldamodel, wordmtx, countvec)

# 對gensim的LDA結果作呈現import pyLDAvis.gensimpyLDAvis.enable_notebook()

pyLDAvis.gensim.prepare(ldamodel1, corpus, dictionary)

pyLDAvis.disable_notebook() # 關閉notebook支持后，可以看到背后所生成的數據

chapter.head()

# 分詞和預處理，生成list of list格式import jiebachapter['cut'] = chapter.txt.apply(jieba.lcut)chapter.head()

# 初始化word2vec模型和詞表from gensim.models.word2vec import Word2Vecn_dim = 300 # 指定向量維度，大樣本量時300~500較好w2vmodel = Word2Vec(vector_size = n_dim, min_count = 10)w2vmodel.build_vocab(chapter.cut) # 生成詞表w2vmodel

# 在評論訓練集上建模（大數據集時可能會花費幾分鐘）# 本例消耗內存較少%time w2vmodel.train(chapter.cut, \               total_examples = w2vmodel.corpus_count, epochs = 10)

# 訓練完畢的模型實質print(w2vmodel.wv["郭靖"].shape)w2vmodel.wv["郭靖"]

w2vmodel.wv.most_similar("郭靖")

w2vmodel.wv.most_similar("黃蓉", topn = 20)

w2vmodel.wv.most_similar("黃蓉道")

# 尋找對應關系w2vmodel.wv.most_similar(['郭靖', '小紅馬'], ['黃藥師'], topn = 5)

w2vmodel.wv.most_similar(positive=['郭靖', '黃蓉'], negative=['楊康'], topn=10)

# 計算兩個詞的相似度/相關程度print(w2vmodel.wv.similarity("郭靖", "黃蓉"))print(w2vmodel.wv.similarity("郭靖", "楊康"))print(w2vmodel.wv.similarity("郭靖", "楊鐵心"))

# 尋找不合群的詞w2vmodel.wv.doesnt_match("小紅馬 黃藥師 魯有腳".split())

w2vmodel.wv.doesnt_match("楊鐵心 黃藥師 黃蓉 洪七公".split())

cleanchap = [ " ".join(m_cut(w)) for w in chapter.txt.iloc[:5]] from sklearn.feature_extraction.text import CountVectorizercountvec = CountVectorizer() resmtx = countvec.fit_transform(cleanchap)resmtx

from sklearn.metrics.pairwise import pairwise_distancespairwise_distances(resmtx, metric = 'cosine')

pairwise_distances(resmtx) # 默認值為euclidean

# 使用TF-IDF矩陣進行相似度計算pairwise_distances(tfidf[:5], metric = 'cosine')

from gensim import similaritiessimmtx = similarities.MatrixSimilarity(corpus)simmtx

# 檢索和第1章內容最相似（所屬主題相同）的章節(jié)simmtx = similarities.MatrixSimilarity(corpus) # 使用的矩陣種類需要和擬合模型時相同simmtx

simmtx.index[:2]

# 使用gensim的LDA擬合結果進行演示query = chapter.txt[1] query_bow = dictionary.doc2bow(m_cut(query))lda_vec = ldamodel1[query_bow] # 轉換為lda模型下的向量sims = simmtx[lda_vec] # 進行矩陣內向量和所提供向量的余弦相似度查詢sims = sorted(enumerate(sims), key=lambda item: -item[1])sims

import jieba import gensimfrom gensim.models import doc2vecdef m_doc(doclist):    reslist = []    for i, doc in enumerate(doclist):        reslist.append(doc2vec.TaggedDocument(jieba.lcut(doc), [i]))    return reslistcorp = m_doc(chapter.txt)

corp[:2]

d2vmodel = gensim.models.Doc2Vec(vector_size = 300, 
                window = 20, min_count = 5)%time d2vmodel.build_vocab(corp)

# The vocab attribute was removed from KeyedVector in Gensim 4.0.0.d2vmodel.wv.key_to_index

# 將新文本轉換為相應維度空間下的向量newvec = d2vmodel.infer_vector(jieba.lcut(chapter.txt[1]))

d2vmodel.docvecs.most_similar([newvec], topn = 10)

# 為章節(jié)增加名稱標簽chapter.index = [raw.txt[raw.chap == i].iloc[0] for i in chapter.index]chapter.head()

import jiebacuttxt = lambda x: " ".join(m_cut(x)) cleanchap = chapter.txt.apply(cuttxt) cleanchap[:2]

# 計算TF-IDF矩陣from sklearn.feature_extraction.text import TfidfTransformervectorizer = CountVectorizer() wordmtx = vectorizer.fit_transform(cleanchap) # 將文本中的詞語轉換為詞頻矩陣  transformer = TfidfTransformer()  tfidf = transformer.fit_transform(wordmtx)  #基于詞頻矩陣計算TF-IDF值  tfidf

# 進行聚類分析from sklearn.cluster import KMeans  clf = KMeans(n_clusters = 5)  s = clf.fit(tfidf)  print(s)  clf.cluster_centers_

clf.cluster_centers_.shape

clf.labels_

chapter['clsres'] = clf.labels_chapter.head()

chapter.sort_values('clsres').clsres

chapgrp = chapter.groupby('clsres')chapcls = chapgrp.agg(sum) # 只有字符串列的情況下，sum函數自動轉為合并字符串cuttxt = lambda x: " ".join(m_cut(x)) chapclsres = chapcls.txt.apply(cuttxt) chapclsres

# 列出關鍵詞以刻畫類別特征import jieba.analyse as anaana.set_stop_words('停用詞.txt')for item in chapclsres:    print(ana.extract_tags(item, topK = 10))

# 從原始語料df中提取出所需的前兩章段落raw12 = raw[raw.chap.isin([1,2])]raw12ana = raw12.iloc[list(raw12.txt.apply(len) > 50), :] # 只使用超過50字的段落raw12ana.reset_index(drop = True, inplace = True)print(len(raw12ana))raw12ana.head()

# 分詞和預處理import jiebacuttxt = lambda x: " ".join(jieba.lcut(x)) # 這里不做任何清理工作，以保留情感詞raw12ana["cleantxt"] = raw12ana.txt.apply(cuttxt) raw12ana.head()

from sklearn.feature_extraction.text import CountVectorizercountvec = CountVectorizer() wordmtx = countvec.fit_transform(raw12ana.cleantxt)wordmtx

# 作用：將數據集劃分為 訓練集和測試集from sklearn.model_selection import train_test_splitx_train, x_test, y_train, y_test = train_test_split(wordmtx, raw12ana.chap, 
    test_size = 0.3, random_state = 111)

from sklearn import naive_bayesNBmodel = naive_bayes.MultinomialNB()

# 擬合模型NBmodel.fit(x_train, y_train)

# 進行驗證集預測x_test

NBmodel.predict(x_test)

# 預測準確率（給模型打分）print('訓練集：', NBmodel.score(x_train, y_train), 
      '，驗證集：', NBmodel.score(x_test, y_test))

from sklearn.metrics import classification_reportprint(classification_report(y_test, NBmodel.predict(x_test)))

from sklearn.linear_model import LogisticRegressionlogitmodel = LogisticRegression() # 定義Logistic回歸模型

# 擬合模型logitmodel.fit(x_train, y_train)print(classification_report(y_test, logitmodel.predict(x_test)))

countvec.vocabulary_

string = "楊鐵心和包惜弱收養(yǎng)穆念慈"words = " ".join(jieba.lcut(string))words_vecs = countvec.transform([words]) # 數據需要轉換為可迭代的list格式words_vecs

NBmodel.predict(words_vecs)

# 使用Pandas的命令進行轉換freqlist.to_dict()

df0.groupby(['word']).agg('size').tail(10).to_dict()

# 這里直接以章節(jié)為一個單元進行分析，以簡化程序結構import nltkfrom nltk import FreqDist# 生成完整的詞條頻數字典，這部分也可以用遍歷方式實現fdist1 = FreqDist(m_cut(chapter.txt[1])) fdist2 = FreqDist(m_cut(chapter.txt[2])) fdist3 = FreqDist(m_cut(chapter.txt[3])) fdist1

from nltk.classify import NaiveBayesClassifiertraining_data = [ [fdist1, 'chap1'], [fdist2, 'chap2'], [fdist3, 'chap3'] ]

# 訓練分類模型NLTKmodel = NaiveBayesClassifier.train(training_data)

print(NLTKmodel.classify(FreqDist(m_cut("楊鐵心收養(yǎng)穆念慈"))))print(NLTKmodel.classify(FreqDist(m_cut("錢塘江 日日夜夜 包惜弱 顏烈 使出楊家槍"))))

nltk.classify.accuracy(NLTKmodel, training_data) # 準確度評價

NLTKmodel.show_most_informative_features(5)#得到似然比，檢測對于哪些特征有用

# 讀入原始數據集import pandas as pddfpos = pd.read_excel("購物評論.xlsx", sheet_name = "正向", header=None)dfpos['y'] = 1dfneg = pd.read_excel("購物評論.xlsx", sheet_name = "負向", header=None)dfneg['y'] = 0df0 = dfpos.append(dfneg, ignore_index = True)df0.head()

# 分詞和預處理import jiebacuttxt = lambda x: " ".join(jieba.lcut(x)) # 這里不做任何清理工作，以保留情感詞df0["cleantxt"] = df0[0].apply(cuttxt) df0.head()

from sklearn.feature_extraction.text import CountVectorizercountvec = CountVectorizer(min_df = 5) # 出現5次以上的才納入wordmtx = countvec.fit_transform(df0.cleantxt)wordmtx

# 按照7：3的比例生成訓練集和測試集from sklearn.model_selection import train_test_splitx_train, x_test, y_train, y_test = train_test_split(    wordmtx, df0.y, test_size=0.3) # 這里可以直接使用稀疏矩陣格式x_train[0]

# 使用SVM進行建模from sklearn.svm import SVCclf=SVC(kernel = 'rbf', verbose = True)clf.fit(x_train, y_train) # 內存占用可能較高clf.score(x_train, y_train)

# 對模型效果進行評估from sklearn.metrics import classification_reportprint(classification_report(y_test, clf.predict(x_test)))

clf.predict(countvec.transform([df0.cleantxt[0]]))[0]

# 模型預測import jiebadef m_pred(string, countvec, model) : 
    words = " ".join(jieba.lcut(string))    words_vecs = countvec.transform([words]) # 數據需要轉換為可迭代格式     
    result = model.predict(words_vecs)    
    if int(result[0]) == 1:        print(string, "：正向")    else:        print(string, "：負向")        comment = "外觀美觀，速度也不錯。上面一排觸摸鍵挺實用。應該對得起這個價格。當然再降點大家肯定也不反對。風扇噪音也不大。"m_pred(comment, countvec, clf)

comment = "作為女兒6.1的禮物。雖然晚到了幾天。等拿到的時候，女兒愛不釋手，上洗手間也看，告知不好。竟以學習毛主席來反駁我。我反對了幾句，還說我對主席不敬。暈。上周末，告訴我她把火鞋和風鞋拿到學校，好多同學羨慕她。呵呵，我也看了其中的人鴉，只可惜沒有看完就在老公的催促下睡了。說了這么多，歸納為一句：這套書買的值。"m_pred(comment, countvec, clf)

# 讀入原始數據集，和上面完全相同import pandas as pddfpos = pd.read_excel("購物評論.xlsx", sheet_name = "正向", header=None)dfpos['y'] = 1dfneg = pd.read_excel("購物評論.xlsx", sheet_name = "負向", header=None)dfneg['y'] = 0df0 = dfpos.append(dfneg, ignore_index = True)df0.head()

# 分詞和預處理，生成list of list格式import jiebadf0['cut'] = df0[0].apply(jieba.lcut)df0.head()

# 按照7：3的比例生成訓練集和測試集from sklearn.model_selection import train_test_splitx_train, x_test, y_train, y_test = train_test_split(    df0.cut, df0.y, test_size=0.3)x_train[:2]

# 初始化word2vec模型和詞表from gensim.models.word2vec import Word2Vecn_dim = 300 # 指定向量維度，大樣本量時300~500較好w2vmodel = Word2Vec(vector_size = n_dim, min_count = 10)w2vmodel.build_vocab(x_train) # 生成詞表

# 在評論訓練集上建模（大數據集時可能會花費幾分鐘）# 本例消耗內存較少%time w2vmodel.train(x_train, \               total_examples = w2vmodel.corpus_count, epochs = 10)

# 情感詞向量間的相似度w2vmodel.wv.most_similar("不錯")

w2vmodel.wv.most_similar("失望")

# 生成整句所對應的所有詞條的詞向量矩陣pd.DataFrame([w2vmodel.wv[w] for w in df0.cut[0] if w in w2vmodel.wv]).head()

# 用各個詞向量直接平均的方式生成整句對應的向量def m_avgvec(words, w2vmodel):    return pd.DataFrame([w2vmodel.wv[w] 
                  for w in words if w in w2vmodel.wv]).agg("mean")

# 生成建模用矩陣，耗時較長%time train_vecs = pd.DataFrame([m_avgvec(s, w2vmodel) for s in x_train])train_vecs.head()

# 用轉換后的矩陣擬合SVM模型from sklearn.svm import SVCclf2 = SVC(kernel = 'rbf', verbose = True)clf2.fit(train_vecs, y_train) # 占用內存小于1Gclf2.score(train_vecs, y_train)

from sklearn.metrics import classification_reportprint(classification_report(y_train, clf2.predict(train_vecs))) # 此處未用驗證集

# 保存訓練完畢的模型以便今后使用# sklearn在0.23版之后已移除joblib，需直接安裝joblib包并import joblibimport joblib # joblib.dump(modelname, 'filename')# modelname = joblib.load('filename')

# 模型預測import jiebadef m_pred(string, model):    words = jieba.lcut(string)    words_vecs = pd.DataFrame(m_avgvec(words, w2vmodel)).T     
    result = model.predict(words_vecs)    
    if int(result[0]) == 1:        print(string, "：正向")    else:        print(string, "：負向")        comment = "作為女兒6.1的禮物。雖然晚到了幾天。等拿到的時候，女兒愛不釋手，上洗手間也看，告知不好。竟以學習毛主席來反駁我。我反對了幾句，還說我對主席不敬。暈。上周末，告訴我她把火鞋和風鞋拿到學校，好多同學羨慕她。呵呵，我也看了其中的人鴉，只可惜沒有看完就在老公的催促下睡了。說了這么多，歸納為一句：這套書買的值。"m_pred(comment, clf2)

chapter.txt[1]

def cut_sentence(intxt):  
    delimiters = frozenset('。！？')  
    buf = []  
    for ch in intxt:  
        buf.append(ch)  
        if delimiters.__contains__(ch):  
            yield ''.join(buf)  
            buf = []  
    if buf:  
        yield ''.join(buf)

sentdf = pd.DataFrame(cut_sentence(chapter.txt[1]))sentdf

# 去除過短的句子，避免摘要出現無意義的內容sentdf['txtlen'] = sentdf[0].apply(len)sentdf.head()

sentlist = sentdf[0][sentdf.txtlen > 20]print(len(sentlist))sentlist

from sklearn.feature_extraction.text import CountVectorizerfrom sklearn.feature_extraction.text import TfidfTransformertxtlist = [ " ".join(jieba.lcut(w)) for w in sentlist]vectorizer = CountVectorizer() X = vectorizer.fit_transform(txtlist) # 將文本中的詞語轉換為詞頻矩陣

tfidf_matrix = TfidfTransformer().fit_transform(X)

# 利用nx包實現pagerank算法import networkx as nx  similarity = nx.from_scipy_sparse_matrix(tfidf_matrix * tfidf_matrix.T)  scores = nx.pagerank(similarity)

scores

tops = sorted(scores.items(), key = lambda x: x[1], reverse = True)

tops[:3]

print(sentlist.iloc[tops[0][0]])print(sentlist.iloc[tops[1][0]])sentlist.iloc[tops[2][0]]

topn = 5topsent = sorted(tops[:topn])abstract = ''for item in topsent:    abstract = abstract + sentlist.iloc[item[0]] + "......"abstract[:-6]

# 載入所需工具包import numpy as npimport pandas as pdfrom keras.models import Sequentialfrom keras.layers import Densefrom keras.layers import Dropoutfrom keras.layers import LSTMfrom keras.callbacks import ModelCheckpointfrom keras.utils import np_utils

rawtxt = pd.read_csv("r&j.txt", sep = 'aaaaa', 
                     names = ['txt'], engine = 'python')print(rawtxt.head())rawtxt.txt[1]

# 處理大小寫，末尾增加空格def m_perproc(tmpstr):    return (tmpstr + " ").lower()rawtxt.txt = rawtxt.txt.apply(m_perproc)rawtxt.txt[1]

raw_txt = rawtxt.txt.agg("sum")raw_txt

# 將字符轉換為數值代碼以便處理chars = sorted(list(set(raw_txt))) # 生成字符listchar_to_int = dict((c, i) for i, c in enumerate(chars)) # 字符-數值對應字典int_to_char = dict((i, c) for i, c in enumerate(chars)) # 數值-字符對應字典chars

seq_length = 100x = []; y = []for i in range(0, len(raw_txt) - seq_length):    given = raw_txt[i:i + seq_length] # 將前seq_length個字符作為預測用變量    predict = raw_txt[i + seq_length] # 將當前字符作為因變量    x.append([char_to_int[char] for char in given])    y.append(char_to_int[predict])

x[:3]

y[:3]

n_patterns = len(x)n_vocab = len(chars)# 把x變成LSTM需要的格式，reshape最后的1表示每個數值均為單獨一個向量（代表一個字母輸入）x = np.reshape(x, (n_patterns, seq_length, 1)) x = x / float(n_vocab) # 轉換為0-1之間的數值以方便計算x[0]

# 將因變量的類型正確指定為類別y = np_utils.to_categorical(y) y[0]

model = Sequential() # LSTM層指定為128個神經元model.add(LSTM(128, input_shape = (x.shape[1], x.shape[2]))) model.add(Dropout(0.2)) # 拋棄20%的結果，防止過擬合model.add(Dense(y.shape[1], activation = 'softmax')) # 使用標準的NN作為內核# 指定損失函數model.compile(loss = 'categorical_crossentropy', optimizer = 'adam')

# batch_size為分批量將數據用于訓練，以減小計算資源的需求# epochs次數越多，模型訓練效果越好，但所需時間也線性增加model.fit(x, y, epochs = 2, batch_size = 64)

def predict_next(input_array): # 進行下一個字符的預測    x = np.reshape([0 for i in range(seq_length - len(input_array))]                   + input_array, (1, seq_length, 1)) # 生成預測用的x序列    x = x / float(n_vocab)    y = model.predict(x)    return ydef string_to_index(raw_input): # 將輸入的字符轉換為索引值    res = []    for c in raw_input[(len(raw_input) - seq_length):]:        res.append(char_to_int[c])    return resdef y_to_char(y): # 將預測結果由索引值轉換回字符    largest_index = y.argmax() # 取最大數值對應的索引值    c = int_to_char[largest_index]    return c

def generate_article(init, rounds = 50): # 按照指定的字符長度進行預測    in_string = init.lower()    for i in range(rounds):        n = y_to_char(predict_next(string_to_index(in_string)))        in_string += n # 將預測到的新字符合并，用于下一步預測    return in_string

# 進行字母預測init = 'We produce about two million dollars for each hour we work. The fifty hours is one conservative estimate for how long'article = generate_article(init)article

# 載入所需工具包import jiebafrom gensim.models.word2vec import Word2Vecimport numpy as npimport pandas as pdfrom keras.models import Sequentialfrom keras.layers import Densefrom keras.layers import Dropoutfrom keras.layers import LSTMfrom keras.callbacks import ModelCheckpointfrom keras.utils import np_utils

dict = '金庸小說詞庫.txt'jieba.load_userdict(dict) # dict為自定義詞典的路徑# 以整句或者整段為基本單位進行分析顯然更為合適corpus = [jieba.lcut(item) for item in raw.txt]corpus[:3]

# 此處完全可以使用外部語料庫進行更全面的訓練w2v_model = Word2Vec(corpus, vector_size = 100, window = 5, 
                     min_count = 5, workers = 4)

w2v_model.wv['郭嘯天']

# 將數據還原為一個長listraw_input = [item for sublist in corpus for item in sublist]print(len(raw_input))raw_input[:10]

# 列出模型中納入的詞條vocab = w2v_model.wv.index_to_keyvocab

# min_count = 5參數會過濾掉低頻詞，因此需要在文本中同步清除這些低頻詞text_stream = []for word in raw_input:    if word in vocab:        text_stream.append(word)print(len(text_stream))text_stream[:10]

seq_length = 10 # 取前面10個單詞用于預測x = []; y = []for i in range(0, len(text_stream) - seq_length):    given = text_stream[i : i + seq_length]    predict = text_stream[i + seq_length]    x.append(np.array([w2v_model.wv[word] for word in given]))    y.append(w2v_model.wv[predict])

len(x)

x[0][0]

y[0]

x = np.reshape(x, (-1, seq_length, 100)) # 每一個詞條，對應一個word2vec向量y = np.reshape(y, (-1, 100))

model = Sequential()model.add(LSTM(128, input_shape = (seq_length, 100)))model.add(Dropout(0.2))model.add(Dense(100, activation = 'sigmoid'))model.compile(loss = 'mse', optimizer = 'adam')

model.fit(x, y, epochs = 5, batch_size = 64)

model.summary()

model.save_weights('LSTM.h5') # 文件類型是HDF5

model.load_weights('LSTM.h5')

model.fit(x, y, epochs = 10) # 按照指定的數據和參數繼續(xù)訓練模型

from keras.callbacks import ModelCheckpointcheckpointer = ModelCheckpoint(filepath = 'LSTM_best.hdf5', 
                               monitor = 'val_loss', 
                               save_best_only = True, 
                               verbose = 1)

model.compile(loss = 'mse', optimizer = 'adam')

model.fit(x, y, epochs = 50, 
          validation_data = (x, y), 
          callbacks = [checkpointer])

def predict_next(input_array):    x = np.reshape(input_array, (-1, seq_length, 100))    y = model.predict(x)    return ydef string_to_index(raw_input):    input_stream = []    for word in jieba.lcut(raw_input):        if word in vocab:            input_stream.append(word)    res = []    for word in input_stream[(len(input_stream) - seq_length):]:        res.append(w2v_model.wv[word])    return resdef y_to_word(y):    word = w2v_model.wv.most_similar(positive = y, topn = 1)    return word

def generate_article(init, rounds = 50):    in_string = init.lower()    for i in range(rounds):        n = y_to_word(predict_next(string_to_index(in_string)))        in_string += n[0][0]    return in_string

init = '郭嘯天、楊鐵心越聽越怒。郭嘯天道：“靖康年間徽欽二帝被金兵擄去這件大恥，我們'article = generate_article(init)print(article)