Implementieren Sie ein kleines Textklassifizierungssystem mit Python

Hintergrund

Text Mining bezieht sich auf den Prozess, unbekanntes, verständliches und letztendlich nutzbares Wissen aus großen Textdatenmengen zu extrahieren und dieses Wissen zu nutzen, um Informationen für zukünftige Referenzzwecke besser zu organisieren. Das heißt, der Prozess, Wissen aus unstrukturiertem Text zu finden.

Derzeit gibt es 7 Hauptbereiche des Text Mining:

• ·Such- und Informationsabruf-IR

• ·Text-Clustering: Verwenden Sie Clustering-Methoden, um Wörter, Fragmente, Absätze oder Dateien zu gruppieren und zu klassifizieren

• · Textklassifizierung: Gruppieren und klassifizieren Sie Fragmente, Absätze oder Dateien mithilfe von Data Mining. Basierend auf der Klassifizierungsmethode werden die trainierten beschriftete Instanz Modell

• · Web Mining: Daten- und Text-Mining im Internet unter besonderer Berücksichtigung der Größe und Größe des miteinander verbundenen Netzwerks

• · Informationsextraktion IE: Identifizieren und extrahieren Sie relevante Fakten und Beziehungen aus unstrukturiertem Text; extrahieren Sie strukturierte Extraktion aus unstrukturiertem oder halbstrukturiertem Text. Der Prozess strukturierter Daten

• · Natural Language Processing NLP: Entdecken Sie die wesentliche Struktur der Sprache und ihre ausgedrückte Bedeutung aus der Perspektive der Grammatik und Semantik

Textklassifizierungssystem (Python 3.5)

Die Technologie und der Prozess zur Textklassifizierung in chinesischer Sprache umfassen hauptsächlich die folgenden Schritte:
1. Vorverarbeitung: Entfernen von Textrauschinformationen, wie z. B. HTML-Tag , Textformatkonvertierung, Erkennung von Satzgrenzen

2. Chinesische Wortsegmentierung: Verwenden Sie die chinesische Wortsegmentierung, um den Text zu segmentieren und Stoppwörter zu entfernen.

3. Erstellen Sie einen Wortvektorraum: Zählen Sie die Häufigkeit von Textwörtern und generieren Sie den Wortvektorraum Text

4. Gewichtsstrategie – TF-IDF: Verwenden Sie TF-IDF, um Merkmalswörter zu entdecken und sie als Merkmale zu extrahieren, die das Dokumentthema widerspiegeln

5. Klassifikatoren: Verwenden Sie Algorithmen, um Klassifikatoren zu trainieren

6. Klassifizierungsergebnisse auswerten

a. Wählen Sie den zu verarbeitenden Textbereich aus

b >

• Textressourcen, die in Kategorien klassifiziert wurden

• Der zu klassifizierende Textkorpus kann Teil des Trainingssatzes oder Textkorpus aus externen Quellen sein

xml

D. Satzgrenzen erkennen: Markieren Sie das Ende des Satzes

Diagrammdarstellung von RDF

# -*- Codierung: utf-8 -*-import os
import jieba
def savefile(savepath, content):
fp = open(savepath,"w",encoding='gb2312', Fehler='ignore')
fp.write(content)
fp.close()
def readfile(path):
fp = open(path,"r", binding= 'gb2312', Fehler='ignore')
content = fp.read()
fp.close()
return content
# corpus_path = „train_small/“ # Vorhersagebibliothekspfad für die Klassifizierung unsegmentierter Wörter
# seg_path = „train_seg/“ # Klassifizierungskorpuspfad nach der Wortsegmentierung corpus_path = „test_small/“ # Pfad der Vorhersagebibliothek für die Klassifizierung unsegmentierter Wörter seg_path = „test_seg/“ # Klassifizierung nach Wortsegmentierung Corpus pathcatelist= os.listdir(corpus_path) # Alle Unterverzeichnisse im geänderten Verzeichnis abrufen for mydir in catelist:
class_path = corpus_path + mydir + "/" # Geben Sie das Kategorie-Unterverzeichnis an Der Pfad
seg_dir = seg_path + mydir + "/" # Vorhersage des Kategorieverzeichnisses nach der Wortsegmentierung
if not os.path.exists(seg_dir): # Ob es existiert, erstelle es, wenn es nicht existiert
os.makedirs(seg_dir)
file_list = os.listdir(class_path)
für file_pathin file_list:
fullname = class_path + file_path
content = readfile(fullname).strip() # Datei lesenInhalt
content = content.replace("rn", "").strip() #Neue Zeilen und zusätzliche Leerzeichen entfernen
content_seg = jieba .cut(content)
                        savefile(seg_dir + file_path, " ".join(content_seg))
print("Ende der Wortsegmentierung")

Für die nachfolgende Wortgenerierung Zur Vereinfachung des Vektorraummodells müssen diese segmentierten Textinformationen mithilfe der Bunch-Datenstruktur der Scikit-Learn-Bibliothek in Textvektorinformationen umgewandelt und objektiviert werden. Der spezifische Code lautet wie folgt:

import os
import pickle
from sklearn.datasets.base import Bunch
#Bunch 类提供了一种key，value的对象形式
#target_name 所有分类集的名称列表
#label 每个文件的分类标签列表
#filenames 文件路径
#contents 分词后文件词向量形式def readfile(path):
    fp = open(path, "r", encoding='gb2312', errors='ignore')
    content = fp.read()
    fp.close()
    return content
bunch=Bunch(target_name=[],label=[],filenames=[],contents=[])
# wordbag_path="train_word_bag/train_set.dat"
# seg_path="train_seg/"wordbag_path="test_word_bag/test_set.dat"seg_path="test_seg/"catelist=os.listdir(seg_path)
bunch.target_name.extend(catelist)#将类别信息保存到Bunch对象for mydir in catelist:
    class_path=seg_path+mydir+"/"
    file_list=os.listdir(class_path)
    for file_path in file_list:
        fullname=class_path+file_path
        bunch.label.append(mydir)#保存当前文件的分类标签
        bunch.filenames.append(fullname)#保存当前文件的文件路径
        bunch.contents.append(readfile(fullname).strip())#保存文件词向量
#Bunch对象持久化file_obj=open(wordbag_path,"wb")
pickle.dump(bunch,file_obj)
file_obj.close()
print("构建文本对象结束")

3. Vektorräumliches Modell

Da Text im Speichervektorraum eine höhere Dimension hat, werden bestimmte Wörter vor der Textklassifizierung automatisch herausgefiltert Wörter Oder Wörter werden Stoppwörter genannt. Diese Tabelle mit Stoppwörtern kann hier heruntergeladen werden. 4. Gewichtsstrategie: TF-IDF-Methode

Wenn ein Wort oder eine Phrase in einem Artikel häufig und in anderen Artikeln selten vorkommt, wird dieses Wort berücksichtigt. Oder die Phrase weist eine gute Kategorienunterscheidung auf Fähigkeit und eignet sich zur Klassifizierung.

Bevor wir diesen Teil des Codes angeben, werfen wir zunächst einen Blick auf die Konzepte der Worthäufigkeit und der umgekehrten Dateihäufigkeit.

Worthäufigkeit (TF): bezieht sich auf das Vorkommen eines bestimmten Wortes in der Datei Frequenz. Diese Zahl ist die Normalisierung der Anzahl der Wörter, um zu verhindern, dass sie zu langen Dokumenten tendiert. Die Bedeutung eines Wortes in einem bestimmten Dokument kann wie folgt ausgedrückt werden:

Der Zähler ist die Anzahl der Wörter im Dokument Der Nenner ist die Summe der Häufigkeit aller Wörter im Dokument

Die inverse Dokumenthäufigkeit (IDF) ist ein Maß für die allgemeine Bedeutung eines Wortes. Die IDF eines bestimmten Wortes kann berechnet werden die Gesamthäufigkeit des Dokuments. Teilen Sie die Zahl durch die Anzahl der Dateien, die das Wort enthalten, und bilden Sie dann den Logarithmus des Quotienten:

|D| ist die Gesamtzahl der Dateien im Korpus, j ist die Anzahl der Dateien Wenn das Wort enthalten ist und das Wort nicht im Korpus enthalten ist, ist der Nenner Null. Daher wird im Allgemeinen eine zusätzliche 1

zum Nenner hinzugefügt, um das Produkt aus Worthäufigkeit und umgekehrter Dateihäufigkeit zu berechnen Die Häufigkeit hoher Wörter in einer bestimmten Datei und die Häufigkeit des Wortes in der gesamten Dokumentensammlung können zu hoch gewichtetem TF-IDF führen, sodass TF-IDF dazu neigt, häufig vorkommende Wörter herauszufiltern und wichtige Wörter beizubehalten. Der Code lautet wie folgt:

import os
from sklearn.datasets.base import Bunch
import pickle#持久化类from sklearn import feature_extraction
from sklearn.feature_extraction.text import TfidfTransformer#TF-IDF向量转换类from sklearn.feature_extraction.text import TfidfVectorizer#TF-IDF向量生成类def readbunchobj(path):
    file_obj=open(path,"rb")
    bunch=pickle.load(file_obj)
    file_obj.close()
    return bunch
def writebunchobj(path,bunchobj):
    file_obj=open(path,"wb")
    pickle.dump(bunchobj,file_obj)
    file_obj.close()
def readfile(path):
    fp = open(path, "r", encoding='gb2312', errors='ignore')
    content = fp.read()
    fp.close()
    return content
path="train_word_bag/train_set.dat"bunch=readbunchobj(path)
#停用词stopword_path="train_word_bag/hlt_stop_words.txt"stpwrdlst=readfile(stopword_path).splitlines()
#构建TF-IDF词向量空间对象tfidfspace=Bunch(target_name=bunch.target_name,label=bunch.label,filenames=bunch.filenames,tdm=[],vocabulary={})
#使用TfidVectorizer初始化向量空间模型vectorizer=TfidfVectorizer(stop_words=stpwrdlst,sublinear_tf=True,max_df=0.5)
transfoemer=TfidfTransformer()#该类会统计每个词语的TF-IDF权值
#文本转为词频矩阵，单独保存字典文件tfidfspace.tdm=vectorizer.fit_transform(bunch.contents)
tfidfspace.vocabulary=vectorizer.vocabulary_
#创建词袋的持久化space_path="train_word_bag/tfidfspace.dat"writebunchobj(space_path,tfidfspace)

Zu den häufig verwendeten Textklassifizierungsmethoden gehören die kNN-Nearest-Neighbor-Methode, der Naive-Bayes-Algorithmus und der Support-Vector-Machine-Algorithmus In Bezug auf:

Der kNN-Algorithmus ist ursprünglich der einfachste mit akzeptabler Klassifizierungsgenauigkeit, aber er ist der schnellste.

Der Naive-Bayes-Algorithmus hat die beste Wirkung bei der Kurztextklassifizierung mit hoher Genauigkeit

Der Vorteil des Support Vector Machine-Algorithmus besteht darin, dass er den Fall der linearen Untrennbarkeit unterstützt und die Genauigkeit durchschnittlich ist

上文代码中进行操作的都是训练集的数据，下面是测试集（抽取字训练集），训练步骤和训练集相同，首先是分词，之后生成词向量文件，直至生成词向量模型，不同的是，在训练词向量模型时需要加载训练集词袋，将测试集产生的词向量映射到训练集词袋的词典中，生成向量空间模型，代码如下：

import os
from sklearn.datasets.base import Bunch
import pickle#持久化类from sklearn import feature_extraction
from sklearn.feature_extraction.text import TfidfTransformer#TF-IDF向量转换类from sklearn.feature_extraction.text import TfidfVectorizer#TF-IDF向量生成类from TF_IDF import space_path
def readbunchobj(path):
    file_obj=open(path,"rb")
    bunch=pickle.load(file_obj)
    file_obj.close()
    return bunch
def writebunchobj(path,bunchobj):
    file_obj=open(path,"wb")
    pickle.dump(bunchobj,file_obj)
    file_obj.close()
def readfile(path):
    fp = open(path, "r", encoding='gb2312', errors='ignore')
    content = fp.read()
    fp.close()
    return content
#导入分词后的词向量bunch对象path="test_word_bag/test_set.dat"bunch=readbunchobj(path)
#停用词stopword_path="train_word_bag/hlt_stop_words.txt"stpwrdlst=readfile(stopword_path).splitlines()
#构建测试集TF-IDF向量空间testspace=Bunch(target_name=bunch.target_name,label=bunch.label,filenames=bunch.filenames,tdm=[],vocabulary={})
#导入训练集的词袋trainbunch=readbunchobj("train_word_bag/tfidfspace.dat")
#使用TfidfVectorizer初始化向量空间vectorizer=TfidfVectorizer(stop_words=stpwrdlst,sublinear_tf=True,max_df=0.5,vocabulary=trainbunch.vocabulary)
transformer=TfidfTransformer();
testspace.tdm=vectorizer.fit_transform(bunch.contents)
testspace.vocabulary=trainbunch.vocabulary
#创建词袋的持久化space_path="test_word_bag/testspace.dat"writebunchobj(space_path,testspace)

下面执行多项式贝叶斯算法进行测试文本分类并返回精度，代码如下：

import pickle
from sklearn.naive_bayes import MultinomialNB  # 导入多项式贝叶斯算法包
def readbunchobj(path):
    file_obj = open(path, "rb")
    bunch = pickle.load(file_obj)
    file_obj.close()
    return bunch
# 导入训练集向量空间trainpath = "train_word_bag/tfidfspace.dat"train_set = readbunchobj(trainpath)
# d导入测试集向量空间testpath = "test_word_bag/testspace.dat"test_set = readbunchobj(testpath)
# 应用贝叶斯算法
# alpha:0.001 alpha 越小，迭代次数越多，精度越高clf = MultinomialNB(alpha=0.001).fit(train_set.tdm, train_set.label)
# 预测分类结果predicted = clf.predict(test_set.tdm)
total = len(predicted);rate = 0
for flabel, file_name, expct_cate in zip(test_set.label, test_set.filenames, predicted):
    if flabel != expct_cate:
        rate += 1
        print(file_name, ": 实际类别：", flabel, "-->预测分类：", expct_cate)
# 精度print("error_rate:", float(rate) * 100 / float(total), "%")

6.分类结果评估

机器学习领域的算法评估有三个基本指标：

• · 召回率（recall rate,查全率）：是检索出的相关文档数与文档库中所有相关文档的比率，衡量的是检索系统的查全率

召回率=系统检索到的相关文件/系统所有相关的文件综述

• · 准确率（Precision，精度）：是检索出的相关文档数于检索出的文档总数的比率，衡量的是检索系统的查准率

准确率=系统检索到的相关文件/系统所有的检索到的文件数

准确率和召回率是相互影响的，理想情况下是二者都高，但是一般情况下准确率高，召回率就低；召回率高，准确率就低

• · F-Score（）：计算公式为：

当=1时就是最常见的-Measure

三者关系如下：

具体评估代码如下：

import numpy as np
from sklearn import metrics
#评估def metrics_result(actual,predict):
    print("精度：{0:.3f}".format(metrics.precision_score(actual,predict)))
    print("召回：{0:0.3f}".format(metrics.recall_score(actual,predict)))
    print("f1-score:{0:.3f}".format(metrics.f1_score(actual,predict)))
metrics_result(test_set.label,predicted)
中文文本语料
中文停用词文本集合
工程全部代码
原文链接

Das obige ist der detaillierte Inhalt vonImplementieren Sie ein kleines Textklassifizierungssystem mit Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!