Implémenter un petit système de classification de texte en utilisant Python

Contexte

L'exploration de texte fait référence au processus d'extraction de connaissances inconnues, compréhensibles et finalement utilisables à partir de grandes quantités de données textuelles, tout en utilisant ces connaissances pour mieux organiser les informations pour référence future. C'est-à-dire le processus de recherche de connaissances à partir d'un texte non structuré.

Actuellement, il existe 7 domaines principaux de text mining :

• ·Recherche et récupération d'informations IR

• ·Clustering de texte : Utiliser des méthodes de regroupement pour regrouper et classer des mots, des fragments, des paragraphes ou des fichiers

• · Classification de texte : Regrouper et classer des fragments, des paragraphes ou des fichiers, à l'aide de l'exploration de données. Sur la base de la méthode de classification, les personnes formées instance labellisée modèle

• · Web mining : Exploration de données et de textes sur Internet, en accordant une attention particulière à la taille et à la taille du réseau interconnecté

  <.>
• · Extraction d'informations IE : identifier et extraire des faits et des relations pertinents à partir d'un texte non structuré ; extraire une extraction structurée à partir d'un texte non structuré ou semi-structuré. Le processus de données structurées

• · Traitement du langage naturel PNL : Découvrez la structure essentielle du langage et sa signification exprimée du point de vue de la grammaire et de la sémantique

Système de classification de texte (

python 3.5)

La technologie et le processus de classification de texte en langue chinoise comprennent principalement les étapes suivantes :

1. Prétraitement : suppression des informations sur le bruit du texte, telles que la
balise HTML , conversion du format de texte, détection des limites des phrases

2. Segmentation de mots chinois : utilisez le segmenteur de mots chinois pour segmenter le texte et supprimer les mots vides

3. Créer des mots Espace vectoriel : Comptez la fréquence des mots de texte et générez un espace vectoriel de mots de texte

4. Stratégie de pondération - TF-IDF : utilisez TF-IDF pour découvrir des mots caractéristiques et les extraire en tant que caractéristiques qui reflètent le thème du document

5. Classificateurs : utilisez des algorithmes pour entraîner les classificateurs

. 6. Évaluer les résultats de la classification

1. Prétraitement

a Sélectionnez la plage de texte à traiter

b. 🎜>

·Corpus d'ensemble de formation

• Ressources textuelles qui ont été classées en catégories

· Corpus d'ensemble de test

• Le corpus de texte à classer peut faire partie de l'ensemble d'apprentissage ou du corpus de texte provenant de sources externes

c Conversion du format de texte : utilisez la bibliothèque l

xml

de Python pour. supprimer les balises html

d. Détecter les limites des phrases : marquer la fin de la phrase2. Segmentation des mots chinois

La segmentation des mots est le processus de recombinaison de séquences de mots continues en un mot. La segmentation des mots chinois selon certaines spécifications consiste à diviser une séquence de caractères chinois (phrases) en mots indépendants. La segmentation des mots chinois est très compliquée et, dans une certaine mesure, ce n'est pas complètement un problème algorithmique. ce problème. L'algorithme est un champ aléatoire conditionnel (CRF) basé sur le modèle graphique de probabilité

La segmentation des mots est le module le plus basique et le plus bas du traitement du langage naturel. Les modules ont une grande influence. La représentation structurée du texte ou des phrases est la tâche principale du traitement du langage. Actuellement, la représentation structurée du texte est divisée en quatre catégories : l'espace vectoriel des mots, le modèle sujet, la représentation arborescente de la syntaxe dépendante,

. Représentation graphique de RDF

.

L'exemple de code pour les mots chinois est donné ci-dessous :

# -*- codage : utf-8 -*-import os
import jieba
def savefile(savepath, content):
fp = open(savepath,"w",encoding='gb2312', erreurs='ignore')
fp.write(content)
fp.close()
def readfile(path):
fp = open(path,"r", encoding= 'gb2312', erreurs='ignore')
content = fp.read()
fp.close()
return content
# corpus_path = "train_small/" # Chemin de la bibliothèque de prédiction de classification de mots non segmentés
# seg_path = "train_seg/" # Chemin du corpus de classification après la segmentation des mots corpus_path = "test_small/" # Chemin de la bibliothèque de prédiction de classification de mots non segmentés seg_path = "test_seg/" # Classification après segmentation de mots Corpus pathcatelist= os.listdir(corpus_path) # Récupère tous les sous-répertoires du répertoire modifié for mydir in catelist:
class_path = corpus_path + mydir + "/" # Épelez le sous-répertoire de la catégorie Le chemin de
seg_dir = seg_path + mydir + "/" # Prédire le répertoire des catégories après avoir épelé le mot segmentation
if not os.path.exists(seg_dir): # S'il existe , créez-le s'il n'existe pas
os.makedirs(seg_dir)
file_list = os.listdir(class_path)
pour file_pathin file_list:
fullname = class_path + file_path
content = readfile(fullname).strip() # Lire le fichiercontent
content = content.replace("rn", "").strip() #Supprimer les nouvelles lignes et les espaces supplémentaires
content_seg = jieba .cut(content)
                        savefile(seg_dir + file_path, " ".join(content_seg))
print("Fin de la segmentation des mots")

Pour la génération de mots ultérieure Pour la commodité du modèle d'espace vectoriel, ces informations textuelles segmentées doivent être converties en informations vectorielles textuelles et objectivées, à l'aide de la structure de données Bunch de la bibliothèque Scikit-Learn. Le code spécifique est le suivant :

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. Modèle spatial vectoriel

Étant donné que le texte est stocké dans un espace vectoriel de grande dimension, afin d'économiser de l'espace de stockage et d'améliorer l'efficacité de la recherche, certains mots seront

automatiquement filtrés avant la classification du texte. Ces mots ou mots sont appelés mots vides. Vous pouvez télécharger ce tableau de mots vides ici. 4. Stratégie de poids : méthode TF-IDF

Si un mot ou une phrase apparaît fréquemment dans un article et apparaît rarement dans d'autres articles, alors ce mot est considéré ou la phrase a une bonne distinction de catégorie capacité et convient à la classification.

Avant de donner cette partie du code, regardons d'abord les notions de fréquence des mots et de fréquence du fichier inversé

Fréquence des mots (TF) : fait référence à l'occurrence d'un mot donné dans le fichier fréquence. Ce nombre est la normalisation du nombre de mots pour éviter qu'il ne soit biaisé vers des documents longs. Pour un mot dans un document spécifique, son importance peut être exprimée comme suit :

Le numérateur est le nombre de mots dans le document. document Le dénominateur est la somme du nombre d'occurrences de tous les mots dans le document

La fréquence inverse du document (IDF) est une mesure de l'importance générale d'un mot. L'IDF d'un mot spécifique peut être calculée par. la fréquence totale des documents Divisez le nombre par le nombre de fichiers contenant le mot, puis prenez le logarithme du quotient :

|D| est le nombre total de fichiers dans le corpus, j est le nombre de fichiers contenant le mot, si le mot n'est pas dans le corpus, le dénominateur sera nul, donc généralement un 1

supplémentaire est ajouté au dénominateur pour calculer le produit de la fréquence des mots et de la fréquence du fichier inverse, le La fréquence des mots élevés dans un fichier spécifique et la fréquence du mot dans la faible fréquence des documents dans l'ensemble de la collection de documents peuvent produire un TF-IDF à forte pondération, de sorte que TF-IDF a tendance à filtrer les mots courants et à conserver les mots importants. Le code est le suivant :

5. Utilisez le module de classification Naive Bayes

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)

Les méthodes de classification de texte couramment utilisées incluent la méthode du voisin le plus proche kNN, l'algorithme Naive Bayes et l'algorithme de machine vectorielle de support en général. En termes de :

L'algorithme kNN est à l'origine le plus simple, avec une précision de classification acceptable, mais c'est le plus rapide

L'algorithme Naive Bayes a le meilleur effet sur la classification de textes courts, avec une grande précision

L'avantage de l'algorithme de la machine à vecteurs de support est qu'il prend en charge le cas d'inséparabilité linéaire et que la précision est moyenne

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

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)
中文文本语料
中文停用词文本集合
工程全部代码
原文链接

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!