在Python中实现文本分类（附代码、数据集）

言

文本分类是商业问题中常见的自然语言处理任务，目标是自动将文本文件分到一个或多个已定义好的类别中。文本分类的一些例子如下：

分析社交媒体中的大众情感
鉴别垃圾邮件和非垃圾邮件
自动标注客户问询
将新闻文章按主题分类

本文将详细介绍文本分类问题并用Python实现这个过程：

文本分类是有监督学习的一个例子，它使用包含文本文档和标签的数据集来训练一个分类器。端到端的文本分类训练主要由三个部分组成：

1. 准备数据集：第一步是准备数据集，包括加载数据集和执行基本预处理，然后把数据集分为训练集和验证集。

特征工程：第二步是特征工程，将原始数据集被转换为用于训练机器学习模型的平坦特征（flat features），并从现有数据特征创建新的特征。

2. 模型训练：最后一步是建模，利用标注数据集训练机器学习模型。

3. 进一步提高分类器性能：本文还将讨论用不同的方法来提高文本分类器的性能。

注意：本文不深入讲述NLP任务，如果你想先复习下基础知识，可以通过这篇文章
https://www.analyticsvidhya.com/blog/2017/01/ultimate-guide-to-understand-implement-natural-language-processing-codes-in-python/

准备好你的机器

先安装基本组件，创建Python的文本分类框架。首先导入所有所需的库。如果你没有安装这些库，可以通过以下官方链接来安装它们。

Pandas:https://pandas.pydata.org/pandas-docs/stable/install.html
Scikit-learn:http://scikit-learn.org/stable/install.html
XGBoost:http://xgboost.readthedocs.io/en/latest/build.html
TextBlob:http://textblob.readthedocs.io/en/dev/install.html
Keras:https://keras.io/#installation

#导入数据集预处理、特征工程和模型训练所需的库
from sklearn import model_selection, preprocessing, linear_model, naive_bayes, metrics, svm
from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
from sklearn import decomposition, ensemble
import pandas, xgboost, numpy, textblob, string
from keras.preprocessing import text, sequence
from keras import layers, models, optimizers

一、准备数据集

在本文中，我使用亚马逊的评论数据集，它可以从这个链接下载：

https://gist.github.com/kunalj101/ad1d9c58d338e20d09ff26bcc06c4235

这个数据集包含3.6M的文本评论内容及其标签，我们只使用其中一小部分数据。首先，将下载的数据加载到包含两个列（文本和标签）的pandas的数据结构（dataframe）中。

数据集链接：

https://drive.google.com/drive/folders/0Bz8a_Dbh9Qhbfll6bVpmNUtUcFdjYmF2SEpmZUZUcVNiMUw1TWN6RDV3a0JHT3kxLVhVR2M

#加载数据集
data = open('data/corpus').read()
labels, texts = [], []
for i, line in enumerate(data.split("\n")):
content = line.split()
labels.append(content[0])
texts.append(content[1])
#创建一个dataframe，列名为text和label
trainDF = pandas.DataFrame()
trainDF['text'] = texts
trainDF['label'] = labels

接下来，我们将数据集分为训练集和验证集，这样我们可以训练和测试分类器。另外，我们将编码我们的目标列，以便它可以在机器学习模型中使用:

#将数据集分为训练集和验证集
train_x, valid_x, train_y, valid_y = model_selection.train_test_split(trainDF['text'], trainDF['label'])
# label编码为目标变量
encoder = preprocessing.LabelEncoder()
train_y = encoder.fit_transform(train_y)
valid_y = encoder.fit_transform(valid_y)

二、特征工程

接下来是特征工程，在这一步，原始数据将被转换为特征向量，另外也会根据现有的数据创建新的特征。为了从数据集中选出重要的特征，有以下几种方式：

计数向量作为特征
TF-IDF向量作为特征
单个词语级别
多个词语级别（N-Gram）
词性级别
词嵌入作为特征
基于文本/NLP的特征
主题模型作为特征

接下来分别看看它们如何实现：

2.1 计数向量作为特征

计数向量是数据集的矩阵表示，其中每行代表来自语料库的文档，每列表示来自语料库的术语，并且每个单元格表示特定文档中特定术语的频率计数：

#创建一个向量计数器对象
count_vect = CountVectorizer(analyzer='word', token_pattern=r'\w{1,}')
count_vect.fit(trainDF['text'])
#使用向量计数器对象转换训练集和验证集
xtrain_count = count_vect.transform(train_x)
xvalid_count = count_vect.transform(valid_x)

2.2 TF-IDF向量作为特征

TF-IDF的分数代表了词语在文档和整个语料库中的相对重要性。TF-IDF分数由两部分组成：第一部分是计算标准的词语频率（TF），第二部分是逆文档频率（IDF）。其中计算语料库中文档总数除以含有该词语的文档数量，然后再取对数就是逆文档频率。

TF(t)=（该词语在文档出现的次数）/（文档中词语的总数）

IDF(t)= log_e（文档总数/出现该词语的文档总数）

TF-IDF向量可以由不同级别的分词产生（单个词语，词性，多个词（n-grams））

词语级别TF-IDF：矩阵代表了每个词语在不同文档中的TF-IDF分数。
N-gram级别TF-IDF:N-grams是多个词语在一起的组合，这个矩阵代表了N-grams的TF-IDF分数。
词性级别TF-IDF：矩阵代表了语料中多个词性的TF-IDF分数。

#词语级tf-idf
tfidf_vect = TfidfVectorizer(analyzer='word', token_pattern=r'\w{1,}', max_features=5000)
tfidf_vect.fit(trainDF['text'])
xtrain_tfidf = tfidf_vect.transform(train_x)
xvalid_tfidf = tfidf_vect.transform(valid_x)
# ngram 级tf-idf
tfidf_vect_ngram = TfidfVectorizer(analyzer='word', token_pattern=r'\w{1,}', ngram_range=(2,3), max_features=5000)
tfidf_vect_ngram.fit(trainDF['text'])
xtrain_tfidf_ngram = tfidf_vect_ngram.transform(train_x)
xvalid_tfidf_ngram = tfidf_vect_ngram.transform(valid_x)
#词性级tf-idf
tfidf_vect_ngram_chars = TfidfVectorizer(analyzer='char', token_pattern=r'\w{1,}', ngram_range=(2,3), max_features=5000)
tfidf_vect_ngram_chars.fit(trainDF['text'])
xtrain_tfidf_ngram_chars = tfidf_vect_ngram_chars.transform(train_x)
xvalid_tfidf_ngram_chars = tfidf_vect_ngram_chars.transform(valid_x)

2.3 词嵌入

词嵌入是使用稠密向量代表词语和文档的一种形式。向量空间中单词的位置是从该单词在文本中的上下文学习到的，词嵌入可以使用输入语料本身训练，也可以使用预先训练好的词嵌入模型生成，词嵌入模型有：Glove, FastText,Word2Vec。它们都可以下载，并用迁移学习的方式使用。想了解更多的词嵌入资料，可以访问：

https://www.analyticsvidhya.com/blog/2017/06/word-embeddings-count-word2veec/

接下来介绍如何在模型中使用预先训练好的词嵌入模型，主要有四步：

1. 加载预先训练好的词嵌入模型

2. 创建一个分词对象

3. 将文本文档转换为分词序列并填充它们

4. 创建分词和各自嵌入的映射

#加载预先训练好的词嵌入向量
embeddings_index = {}
for i, line in enumerate(open('data/wiki-news-300d-1M.vec')):
values = line.split()
embeddings_index[values[0]] = numpy.asarray(values[1:], dtype='float32')
#创建一个分词器
token = text.Tokenizer()
token.fit_on_texts(trainDF['text'])
word_index = token.word_index
#将文本转换为分词序列，并填充它们保证得到相同长度的向量
train_seq_x = sequence.pad_sequences(token.texts_to_sequences(train_x), maxlen=70)
valid_seq_x = sequence.pad_sequences(token.texts_to_sequences(valid_x), maxlen=70)
#创建分词嵌入映射
embedding_matrix = numpy.zeros((len(word_index) + 1, 300))
for word, i in word_index.items():
embedding_vector = embeddings_index.get(word)
if embedding_vector is not None:
embedding_matrix[i] = embedding_vector

2.4 基于文本/NLP的特征

创建许多额外基于文本的特征有时可以提升模型效果。比如下面的例子：

文档的词语计数—文档中词语的总数量
文档的词性计数—文档中词性的总数量
文档的平均字密度--文件中使用的单词的平均长度
完整文章中的标点符号出现次数--文档中标点符号的总数量
整篇文章中的大写次数—文档中大写单词的数量
完整文章中标题出现的次数—文档中适当的主题（标题）的总数量
词性标注的频率分布
名词数量
动词数量
形容词数量
副词数量
代词数量

这些特征有很强的实验性质，应该具体问题具体分析。

trainDF['char_count'] = trainDF['text'].apply(len)
trainDF['word_count'] = trainDF['text'].apply(lambda x: len(x.split()))
trainDF['word_density'] = trainDF['char_count'] / (trainDF['word_count']+1)
trainDF['punctuation_count'] = trainDF['text'].apply(lambda x: len("".join(_ for _ in x if _ in string.punctuation)))
trainDF['title_word_count'] = trainDF['text'].apply(lambda x: len([wrd for wrd in x.split() if wrd.istitle()]))
trainDF['upper_case_word_count'] = trainDF['text'].apply(lambda x: len([wrd for wrd in x.split() if wrd.isupper()]))
trainDF['char_count'] = trainDF['text'].apply(len)
trainDF['word_count'] = trainDF['text'].apply(lambda x: len(x.split()))
trainDF['word_density'] = trainDF['char_count'] / (trainDF['word_count']+1)
trainDF['punctuation_count'] = trainDF['text'].apply(lambda x: len("".join(_ for _ in x if _ in string.punctuation)))
trainDF['title_word_count'] = trainDF['text'].apply(lambda x: len([wrd for wrd in x.split() if wrd.istitle()]))
trainDF['upper_case_word_count'] = trainDF['text'].apply(lambda x: len([wrd for wrd in x.split() if wrd.isupper()]))
pos_family = {
'noun' : ['NN','NNS','NNP','NNPS'],
'pron' : ['PRP','PRP$','WP','WP$'],
'verb' : ['VB','VBD','VBG','VBN','VBP','VBZ'],
'adj' : ['JJ','JJR','JJS'],
'adv' : ['RB','RBR','RBS','WRB']
}
#检查和获得特定句子中的单词的词性标签数量
def check_pos_tag(x, flag):
cnt = 0
try:
wiki = textblob.TextBlob(x)
for tup in wiki.tags:
ppo = list(tup)[1]
if ppo in pos_family[flag]:
cnt += 1
except:
pass
return cnt
trainDF['noun_count'] = trainDF['text'].apply(lambda x: check_pos_tag(x, 'noun'))
trainDF['verb_count'] = trainDF['text'].apply(lambda x: check_pos_tag(x, 'verb'))
trainDF['adj_count'] = trainDF['text'].apply(lambda x: check_pos_tag(x, 'adj'))
trainDF['adv_count'] = trainDF['text'].apply(lambda x: check_pos_tag(x, 'adv'))
trainDF['pron_count'] = trainDF['text'].apply(lambda x: check_pos_tag(x, 'pron'))

2.5 主题模型作为特征

主题模型是从包含重要信息的文档集中识别词组（主题）的技术，我已经使用LDA生成主题模型特征。LDA是一个从固定数量的主题开始的迭代模型，每一个主题代表了词语的分布，每一个文档表示了主题的分布。虽然分词本身没有意义，但是由主题表达出的词语的概率分布可以传达文档思想。如果想了解更多主题模型，请访问：

https://www.analyticsvidhya.com/blog/2016/08/beginners-guide-to-topic-modeling-in-python/

我们看看主题模型运行过程：

#训练主题模型
lda_model = decomposition.LatentDirichletAllocation(n_components=20, learning_method='online', max_iter=20)
X_topics = lda_model.fit_transform(xtrain_count)
topic_word = lda_model.components_
vocab = count_vect.get_feature_names()
#可视化主题模型
n_top_words = 10
topic_summaries = []
for i, topic_dist in enumerate(topic_word):
topic_words = numpy.array(vocab)[numpy.argsort(topic_dist)][:-(n_top_words+1):-1]
topic_summaries.append(' '.join(topic_words)

三、建模

文本分类框架的最后一步是利用之前创建的特征训练一个分类器。关于这个最终的模型，机器学习中有很多模型可供选择。我们将使用下面不同的分类器来做文本分类：

朴素贝叶斯分类器
线性分类器
支持向量机（SVM）
Bagging Models
Boosting Models
浅层神经网络
深层神经网络
卷积神经网络（CNN）
LSTM
GRU
双向RNN
循环卷积神经网络（RCNN）
其它深层神经网络的变种

接下来我们详细介绍并使用这些模型。下面的函数是训练模型的通用函数，它的输入是分类器、训练数据的特征向量、训练数据的标签，验证数据的特征向量。我们使用这些输入训练一个模型，并计算准确度。

def train_model(classifier, feature_vector_train, label, feature_vector_valid, is_neural_net=False):
# fit the training dataset on the classifier
classifier.fit(feature_vector_train, label)
# predict the labels on validation dataset
predictions = classifier.predict(feature_vector_valid)
if is_neural_net:
predictions = predictions.argmax(axis=-1)
return metrics.accuracy_score(predictions, valid_y)

3.1 朴素贝叶斯

利用sklearn框架，在不同的特征下实现朴素贝叶斯模型。

朴素贝叶斯是一种基于贝叶斯定理的分类技术，并且假设预测变量是独立的。朴素贝叶斯分类器假设一个类别中的特定特征与其它存在的特征没有任何关系。

想了解朴素贝叶斯算法细节可点击：

A Naive Bayes classifier assumes that the presence of a particular feature in a class is unrelated to the presence of any other feature

#特征为计数向量的朴素贝叶斯
accuracy = train_model(naive_bayes.MultinomialNB(), xtrain_count, train_y, xvalid_count)
print "NB, Count Vectors: ", accuracy
#特征为词语级别TF-IDF向量的朴素贝叶斯
accuracy = train_model(naive_bayes.MultinomialNB(), xtrain_tfidf, train_y, xvalid_tfidf)
print "NB, WordLevel TF-IDF: ", accuracy
#特征为多个词语级别TF-IDF向量的朴素贝叶斯
accuracy = train_model(naive_bayes.MultinomialNB(), xtrain_tfidf_ngram, train_y, xvalid_tfidf_ngram)
print "NB, N-Gram Vectors: ", accuracy
#特征为词性级别TF-IDF向量的朴素贝叶斯
accuracy = train_model(naive_bayes.MultinomialNB(), xtrain_tfidf_ngram_chars, train_y, xvalid_tfidf_ngram_chars)
print "NB, CharLevel Vectors: ", accuracy
#输出结果
NB, Count Vectors: 0.7004
NB, WordLevel TF-IDF: 0.7024
NB, N-Gram Vectors: 0.5344
NB, CharLevel Vectors: 0.6872

3.2 线性分类器

实现一个线性分类器（Logistic Regression）：Logistic回归通过使用logistic / sigmoid函数估计概率来度量类别因变量与一个或多个独立变量之间的关系。如果想了解更多关于logistic回归，请访问：

https://www.analyticsvidhya.com/blog/2015/10/basics-logistic-regression/

# Linear Classifier on Count Vectors
accuracy = train_model(linear_model.LogisticRegression(), xtrain_count, train_y, xvalid_count)
print "LR, Count Vectors: ", accuracy
#特征为词语级别TF-IDF向量的线性分类器
accuracy = train_model(linear_model.LogisticRegression(), xtrain_tfidf, train_y, xvalid_tfidf)
print "LR, WordLevel TF-IDF: ", accuracy
#特征为多个词语级别TF-IDF向量的线性分类器
accuracy = train_model(linear_model.LogisticRegression(), xtrain_tfidf_ngram, train_y, xvalid_tfidf_ngram)
print "LR, N-Gram Vectors: ", accuracy
#特征为词性级别TF-IDF向量的线性分类器
accuracy = train_model(linear_model.LogisticRegression(), xtrain_tfidf_ngram_chars, train_y, xvalid_tfidf_ngram_chars)
print "LR, CharLevel Vectors: ", accuracy
#输出结果
LR, Count Vectors: 0.7048
LR, WordLevel TF-IDF: 0.7056
LR, N-Gram Vectors: 0.4896
LR, CharLevel Vectors: 0.7012

3.3 实现支持向量机模型

支持向量机（SVM）是监督学习算法的一种，它可以用来做分类或回归。该模型提取了分离两个类的最佳超平面或线。如果想了解更多关于SVM，请访问：

https://www.analyticsvidhya.com/blog/2017/09/understaing-support-vector-machine-example-code/

#特征为多个词语级别TF-IDF向量的SVM
accuracy = train_model(svm.SVC(), xtrain_tfidf_ngram, train_y, xvalid_tfidf_ngram)
print "SVM, N-Gram Vectors: ", accuracy
#输出结果
SVM, N-Gram Vectors: 0.5296

3.4 Bagging Model

实现一个随机森林模型：随机森林是一种集成模型，更准确地说是Bagging model。它是基于树模型家族的一部分。如果想了解更多关于随机森林，请访问：

https://www.analyticsvidhya.com/blog/2014/06/introduction-random-forest-simplified/

#特征为计数向量的RF
accuracy = train_model(ensemble.RandomForestClassifier(), xtrain_count, train_y, xvalid_count)
print "RF, Count Vectors: ", accuracy
#特征为词语级别TF-IDF向量的RF
accuracy = train_model(ensemble.RandomForestClassifier(), xtrain_tfidf, train_y, xvalid_tfidf)
print "RF, WordLevel TF-IDF: ", accuracy
#输出结果
RF, Count Vectors: 0.6972
RF, WordLevel TF-IDF: 0.6988

3.5 Boosting Model

实现一个Xgboost模型：Boosting model是另外一种基于树的集成模型。Boosting是一种机器学习集成元算法，主要用于减少模型的偏差，它是一组机器学习算法，可以把弱学习器提升为强学习器。其中弱学习器指的是与真实类别只有轻微相关的分类器（比随机猜测要好一点）。如果想了解更多，请访问：

https://www.analyticsvidhya.com/blog/2016/01/xgboost-algorithm-easy-steps/

#特征为计数向量的Xgboost
accuracy = train_model(xgboost.XGBClassifier(), xtrain_count.tocsc(), train_y, xvalid_count.tocsc())
print "Xgb, Count Vectors: ", accuracy
#特征为词语级别TF-IDF向量的Xgboost
accuracy = train_model(xgboost.XGBClassifier(), xtrain_tfidf.tocsc(), train_y, xvalid_tfidf.tocsc())
print "Xgb, WordLevel TF-IDF: ", accuracy
#特征为词性级别TF-IDF向量的Xgboost
accuracy = train_model(xgboost.XGBClassifier(), xtrain_tfidf_ngram_chars.tocsc(), train_y, xvalid_tfidf_ngram_chars.tocsc())
print "Xgb, CharLevel Vectors: ", accuracy
#输出结果
Xgb, Count Vectors: 0.6324
Xgb, WordLevel TF-IDF: 0.6364
Xgb, CharLevel Vectors: 0.6548

3.6 浅层神经网络

神经网络被设计成与生物神经元和神经系统类似的数学模型，这些模型用于发现被标注数据中存在的复杂模式和关系。一个浅层神经网络主要包含三层神经元-输入层、隐藏层、输出层。如果想了解更多关于浅层神经网络，请访问：

https://www.analyticsvidhya.com/blog/2017/05/neural-network-from-scratch-in-python-and-r/

def create_model_architecture(input_size):
# create input layer
input_layer = layers.Input((input_size, ), sparse=True)
# create hidden layer
hidden_layer = layers.Dense(100, activation="relu")(input_layer)
# create output layer
output_layer = layers.Dense(1, activation="sigmoid")(hidden_layer)
classifier = models.Model(inputs = input_layer, outputs = output_layer)
classifier.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')
return classifier
classifier = create_model_architecture(xtrain_tfidf_ngram.shape[1])
accuracy = train_model(classifier, xtrain_tfidf_ngram, train_y, xvalid_tfidf_ngram, is_neural_net=True)
print "NN, Ngram Level TF IDF Vectors", accuracy
#输出结果：
Epoch 1/1
7500/7500 [==============================] - 1s 67us/step - loss: 0.6909
NN, Ngram Level TF IDF Vectors 0.5296

3.7 深层神经网络

深层神经网络是更复杂的神经网络，其中隐藏层执行比简单Sigmoid或Relu激活函数更复杂的操作。不同类型的深层学习模型都可以应用于文本分类问题。

卷积神经网络

卷积神经网络中，输入层上的卷积用来计算输出。本地连接结果中，每一个输入单元都会连接到输出神经元上。每一层网络都应用不同的滤波器（filter）并组合它们的结果。

如果想了解更多关于卷积神经网络，请访问：

https://www.analyticsvidhya.com/blog/2017/06/architecture-of-convolutional-neural-networks-simplified-demystified/

def create_cnn():
# Add an Input Layer
input_layer = layers.Input((70, ))
# Add the word embedding Layer
embedding_layer = layers.Embedding(len(word_index) + 1, 300, weights=[embedding_matrix], trainable=False)(input_layer)
embedding_layer = layers.SpatialDropout1D(0.3)(embedding_layer)
# Add the convolutional Layer
conv_layer = layers.Convolution1D(100, 3, activation="relu")(embedding_layer)
# Add the pooling Layer
pooling_layer = layers.GlobalMaxPool1D()(conv_layer)
# Add the output Layers
output_layer1 = layers.Dense(50, activation="relu")(pooling_layer)
output_layer1 = layers.Dropout(0.25)(output_layer1)
output_layer2 = layers.Dense(1, activation="sigmoid")(output_layer1)
# Compile the model
model = models.Model(inputs=input_layer, outputs=output_layer2)
model.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')
return model
classifier = create_cnn()
accuracy = train_model(classifier, train_seq_x, train_y, valid_seq_x, is_neural_net=True)
print "CNN, Word Embeddings", accuracy
#输出结果
Epoch 1/1
7500/7500 [==============================] - 12s 2ms/step - loss: 0.5847
CNN, Word Embeddings 0.5296

循环神经网络-LSTM

与前馈神经网络不同，前馈神经网络的激活输出仅在一个方向上传播，而循环神经网络的激活输出在两个方向传播（从输入到输出，从输出到输入）。因此在神经网络架构中产生循环，充当神经元的“记忆状态”，这种状态使神经元能够记住迄今为止学到的东西。RNN中的记忆状态优于传统的神经网络，但是被称为梯度弥散的问题也因这种架构而产生。这个问题导致当网络有很多层的时候，很难学习和调整前面网络层的参数。为了解决这个问题，开发了称为LSTM（Long Short Term Memory）模型的新型RNN：

如果想了解更多关于LSTM，请访问：

https://www.analyticsvidhya.com/blog/2017/12/fundamentals-of-deep-learning-introduction-to-lstm/

def create_rnn_lstm():
# Add an Input Layer
input_layer = layers.Input((70, ))
# Add the word embedding Layer
embedding_layer = layers.Embedding(len(word_index) + 1, 300, weights=[embedding_matrix], trainable=False)(input_layer)
embedding_layer = layers.SpatialDropout1D(0.3)(embedding_layer)
# Add the LSTM Layer
lstm_layer = layers.LSTM(100)(embedding_layer)
# Add the output Layers
output_layer1 = layers.Dense(50, activation="relu")(lstm_layer)
output_layer1 = layers.Dropout(0.25)(output_layer1)
output_layer2 = layers.Dense(1, activation="sigmoid")(output_layer1)
# Compile the model
model = models.Model(inputs=input_layer, outputs=output_layer2)
model.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')
return model
classifier = create_rnn_lstm()
accuracy = train_model(classifier, train_seq_x, train_y, valid_seq_x, is_neural_net=True)
print "RNN-LSTM, Word Embeddings", accuracy
#输出结果
Epoch 1/1
7500/7500 [==============================] - 22s 3ms/step - loss: 0.6899
RNN-LSTM, Word Embeddings 0.5124

循环神经网络-GRU

门控递归单元是另一种形式的递归神经网络,我们在网络中添加一个GRU层来代替LSTM。

defcreate_rnn_gru():
# Add an Input Layer
input_layer = layers.Input((70, ))
# Add the word embedding Layer
embedding_layer = layers.Embedding(len(word_index) + 1, 300, weights=[embedding_matrix], trainable=False)(input_layer)
embedding_layer = layers.SpatialDropout1D(0.3)(embedding_layer)
# Add the GRU Layer
lstm_layer = layers.GRU(100)(embedding_layer)
# Add the output Layers
output_layer1 = layers.Dense(50, activation="relu")(lstm_layer)
output_layer1 = layers.Dropout(0.25)(output_layer1)
output_layer2 = layers.Dense(1, activation="sigmoid")(output_layer1)
# Compile the model
model = models.Model(inputs=input_layer, outputs=output_layer2)
model.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')
return model
classifier = create_rnn_gru()
accuracy = train_model(classifier, train_seq_x, train_y, valid_seq_x, is_neural_net=True)
print "RNN-GRU, Word Embeddings", accuracy
#输出结果
Epoch 1/1
7500/7500 [==============================] - 19s 3ms/step - loss: 0.6898
RNN-GRU, Word Embeddings 0.5124

双向RNN

RNN层也可以被封装在双向层中，我们把GRU层封装在双向RNN网络中。

defcreate_bidirectional_rnn():
# Add an Input Layer
input_layer = layers.Input((70, ))
# Add the word embedding Layer
embedding_layer = layers.Embedding(len(word_index) + 1, 300, weights=[embedding_matrix], trainable=False)(input_layer)
embedding_layer = layers.SpatialDropout1D(0.3)(embedding_layer)
# Add the LSTM Layer
lstm_layer = layers.Bidirectional(layers.GRU(100))(embedding_layer)
# Add the output Layers
output_layer1 = layers.Dense(50, activation="relu")(lstm_layer)
output_layer1 = layers.Dropout(0.25)(output_layer1)
output_layer2 = layers.Dense(1, activation="sigmoid")(output_layer1)
# Compile the model
model = models.Model(inputs=input_layer, outputs=output_layer2)
model.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')
return model
classifier = create_bidirectional_rnn()
accuracy = train_model(classifier, train_seq_x, train_y, valid_seq_x, is_neural_net=True)
print "RNN-Bidirectional, Word Embeddings", accuracy
#输出结果
Epoch 1/1
7500/7500 [==============================] - 32s 4ms/step - loss: 0.6889
RNN-Bidirectional, Word Embeddings 0.5124

循环卷积神经网络

如果基本的架构已经尝试过，则可以尝试这些层的不同变体，如递归卷积神经网络，还有其它变体，比如：

层次化注意力网络（Sequence to Sequence Models with Attention）
具有注意力机制的seq2seq（Sequence to Sequence Models with Attention）
双向循环卷积神经网络
更多网络层数的CNNs和RNNs

defcreate_rcnn():
# Add an Input Layer
input_layer = layers.Input((70, ))
# Add the word embedding Layer
embedding_layer = layers.Embedding(len(word_index) + 1, 300, weights=[embedding_matrix], trainable=False)(input_layer)
embedding_layer = layers.SpatialDropout1D(0.3)(embedding_layer)
# Add the recurrent layer
rnn_layer = layers.Bidirectional(layers.GRU(50, return_sequences=True))(embedding_layer)
# Add the convolutional Layer
conv_layer = layers.Convolution1D(100, 3, activation="relu")(embedding_layer)
# Add the pooling Layer
pooling_layer = layers.GlobalMaxPool1D()(conv_layer)
# Add the output Layers
output_layer1 = layers.Dense(50, activation="relu")(pooling_layer)
output_layer1 = layers.Dropout(0.25)(output_layer1)
output_layer2 = layers.Dense(1, activation="sigmoid")(output_layer1)
# Compile the model
model = models.Model(inputs=input_layer, outputs=output_layer2)
model.compile(optimizer=optimizers.Adam(), loss='binary_crossentropy')
return model
classifier = create_rcnn()
accuracy = train_model(classifier, train_seq_x, train_y, valid_seq_x, is_neural_net=True)
print "CNN, Word Embeddings", accuracy
#输出结果
Epoch 1/1
7500/7500 [==============================] - 11s 1ms/step - loss: 0.6902
CNN, Word Embeddings 0.5124

进一步提高文本分类模型的性能

虽然上述框架可以应用于多个文本分类问题，但是为了达到更高的准确率，可以在总体框架中进行一些改进。例如，下面是一些改进文本分类模型和该框架性能的技巧：

1. 清洗文本：文本清洗有助于减少文本数据中出现的噪声，包括停用词、标点符号、后缀变化等。这篇文章有助于理解如何实现文本分类：

https://www.analyticsvidhya.com/blog/2014/11/text-data-cleaning-steps-python/

2. 组合文本特征向量的文本/NLP特征：特征工程阶段，我们把生成的文本特征向量组合在一起，可能会提高文本分类器的准确率。

模型中的超参数调优：参数调优是很重要的一步，很多参数通过合适的调优可以获得最佳拟合模型，例如树的深层、叶子节点数、网络参数等。

3. 集成模型：堆叠不同的模型并混合它们的输出有助于进一步改进结果。如果想了解更多关于模型集成，请访问：

https://www.analyticsvidhya.com/blog/2015/08/introduction-ensemble-learning/

写在最后

本文讨论了如何准备一个文本数据集，如清洗、创建训练集和验证集。使用不同种类的特征工程，比如计数向量、TF-IDF、词嵌入、主题模型和基本的文本特征。然后训练了多种分类器，有朴素贝叶斯、Logistic回归、SVM、MLP、LSTM和GRU。最后讨论了提高文本分类器性能的多种方法。

、算法设计

Python 的数据结构，算法和设计模式的实现。另请参阅真棒算法。

演算法

algorithms 数据结构和算法的最小示例。

https://github.com/keon/algorithms

python-ds 用于采访采访的数据结构和算法的集合。

https://github.com/prabhupant/python-ds

sortedcontainers 排序集合的快速和纯 Python 实现。

https://github.com/grantjenks/python-sortedcontainers

TheAlgorithms- 用 Python 实现的所有算法。

https://github.com/TheAlgorithms/Python

设计模式

PyPattyrn- 一个简单但有效的库，用于实现常见的设计模式。

https://github.com/tylerlaberge/PyPattyrn

python-patterns -Python 中设计模式的集合。

https://github.com/faif/python-patterns

transitions - 一种轻量级的，面向对象的有限状态机实现。

https://github.com/pytransitions/transitions

二、声音、视频、图像、文字处理

用于处理音频及其元数据的库。

声音的

audioread- 跨库（GStreamer + 核心音频 + MAD + FFmpeg）音频解码。

https://github.com/beetbox/audioread

dejavu- 音频指纹识别。

https://github.com/worldveil/dejavu

kapre - Keras 音频预处理器

https://github.com/keunwoochoi/kapre

librosa- 用于音频和音乐分析的 Python 库

https://github.com/librosa/librosa

matchering - 一个用于自动参考音频制作的库。

https://github.com/sergree/matchering

mingus- 带有 MIDI 文件和播放支持的高级音乐理论和乐谱包。

http://bspaans.github.io/python-mingus/

pyAudioAnalysis- 音频特征提取，分类，分段和应用。

https://github.com/tyiannak/pyAudioAnalysis

pydub- 使用简单易用的高级界面处理音频。

https://github.com/jiaaro/pydub

TimeSide- 开放的 Web 音频处理框架。

https://github.com/Parisson/TimeSide

Metadata

beets- 音乐库管理器和 MusicBrainz 标记器。

https://github.com/beetbox/beets

eyeD3- 一种用于处理音频文件的工具，特别是包含 ID3 元数据的 MP3 文件。

https://github.com/nicfit/eyeD3

mutagen- 处理音频元数据的 Python 模块。

https://github.com/quodlibet/mutagen

tinytag- 用于读取 MP3，OGG，FLAC 和 Wave 文件的音乐元数据的库。

https://github.com/devsnd/tinytag

用于处理视频和 GIF 的库。

moviepy- 用于基于脚本的电影编辑的模块，具有多种格式，包括动画 GIF。

https://zulko.github.io/moviepy/

scikit-video -SciPy 的视频处理例程。

https://github.com/aizvorski/scikit-video

vidgear- 最强大的多线程视频处理框架。

https://github.com/abhiTronix/vidgear

用于处理图像的库。

hmap- 图像直方图重新映射。

https://github.com/rossgoodwin/hmap

imgSeek- 使用视觉相似性搜索图像集合的项目。

https://sourceforge.net/projects/imgseek/

nude.py- 裸露检测。

https://github.com/hhatto/nude.py

pagan - 复古 identicon（阿凡达）根据输入的字符串和哈希生成。

https://github.com/daboth/pagan

pillow- 枕头是友好的 PIL 叉。

https://github.com/python-pillow/Pillow

python- barcode - 在 Python 中创建条形码，没有任何额外的依赖关系。

https://github.com/WhyNotHugo/python-barcode

pygram- 类似 Instagram 的图像过滤器。

https://github.com/ajkumar25/pygram

PyMatting -Alpha 遮罩的库。

http://github.com/pymatting/pymatting

python-qrcode- 一个纯 Python QR Code 生成器。

https://github.com/lincolnloop/python-qrcode

pywal- 一种从图像生成配色方案的工具。

https://github.com/dylanaraps/pywal

pyvips- 具有低内存需求的快速图像处理库。

https://github.com/libvips/pyvips

Quads - 基于四叉树的计算机艺术。

https://github.com/fogleman/Quads

scikit-image- 用于（科学）图像处理的 Python 库。

http://scikit-image.org/

thumbor- 智能影像服务。它可以按需裁剪，调整图像大小和翻转图像。

https://github.com/thumbor/thumbor

wand - MagickWand 的 Python 绑定，ImageMagick 的 C API。

https://github.com/dahlia/wand

用于解析和处理纯文本的库。

一般的

chardet- 与 Python 2/3 兼容的字符编码检测器。

https://github.com/chardet/chardet

difflib-（Python 标准库）用于计算增量的帮助程序。

https://docs.python.org/3/library/difflib.html

ftfy- 自动使 Unicode 文本更清晰，更一致。

https://github.com/LuminosoInsight/python-ftfy

Fuzzywuzzy- 模糊字符串匹配。

https://github.com/seatgeek/fuzzywuzzy

Levenshtein- 快速计算 Levenshtein 距离和字符串相似度。

https://github.com/ztane/python-Levenshtein/

pangu.py- 偏执的文字间距。

https://github.com/vinta/pangu.py

pyfiglet- 用 Python 编写的 figlet 的实现。

https://github.com/pwaller/pyfiglet

pypinyin- 将汉字（Hanzi）转换为拼音（Pyyin）。

https://github.com/mozillazg/python-pinyin

textdistance- 使用 30 多种算法计算序列之间的距离。

https://github.com/orsinium/textdistance

unidecode -Unicode 文本的 ASCII 音译。

https://pypi.org/project/Unidecode/

Slugify

awesome-slugify- 一个可以保留 unicode 的 Python slugify 库。

https://github.com/dimka665/awesome-slugify

python-slugify- 一个 Python slugify 库，它将 unicode 转换为 ASCII。

https://github.com/un33k/python-slugify

unicode-slugify- 一种 Slugifier，它以 Django 为依赖项生成 unicode slug。

https://github.com/mozilla/unicode-slugify

唯一标识符

hashids- 在 Python 中实现 hashids。

https://github.com/davidaurelio/hashids-python

shortuuid- 简洁，明确和 URL 安全的 UUID 的生成器库。

https://github.com/skorokithakis/shortuuid

解析器

ply - 的 lex 和 yacc 解析工具的 Python 实现。

https://github.com/dabeaz/ply

pygments- 通用语法荧光笔。

http://pygments.org/

pyparsing- 生成解析器的通用框架。

https://github.com/pyparsing/pyparsing

python-nameparser - 将人名解析为它们的各个组成部分。

https://github.com/derek73/python-nameparser

python-phonenumbers- 解析，格式化，存储和验证国际电话号码。

https://github.com/daviddrysdale/python-phonenumbers

python-user-agents- 浏览器用户代理解析器。

https://github.com/selwin/python-user-agents

sqlparse- 一个非验证的 SQL 解析器。

https://github.com/andialbrecht/sqlparse

三、日期和时间

用于处理日期和时间的库。

Arrow- 一个 Python 库，提供了一种明智且人性化的方法来创建，操作，格式化和转换日期，时间和时间戳。

https://arrow.readthedocs.io/en/latest/

Chronyk- 一个 Python 3 库，用于解析人类编写的时间和日期。

https://github.com/KoffeinFlummi/Chronyk

dateutil- 标准 Python datetime 模块的扩展。

https://github.com/dateutil/dateutil

delorean- 一个库，用于清除与日期时间有关的不便的事实。

https://github.com/myusuf3/delorean/

maya- 人类的日期时间。

https://github.com/timofurrer/maya

moment - 一个 Python 库用于处理日期 / 时间。受到 Moment.js 的启发。

https://github.com/zachwill/moment

Pendulum-Python 日期时间变得容易。

https://github.com/sdispater/pendulum

PyTime- 一个易于使用的 Python 模块，旨在按字符串操作日期 / 时间 / 日期时间。

https://github.com/shinux/PyTime

pytz- 世界时区定义，现代和历史。将 tz 数据库带入 Python。

https://launchpad.net/pytz

when.py- 提供用户友好的功能来帮助执行常见的日期和时间操作。

https://github.com/dirn/When.py

四、爬虫

自动执行 Web 抓取。

cola- 分布式抓取框架。

https://github.com/chineking/cola

feedparser- 通用供稿解析器。

https://pythonhosted.org/feedparser/

grab - 网站抓取框架。

https://github.com/lorien/grab

MechanicalSoup- 用于自动与网站进行交互的 Python 库。

https://github.com/MechanicalSoup/MechanicalSoup

portia - Scrapy 的视觉抓取。

https://github.com/scrapinghub/portia

pyspider- 强大的蜘蛛系统。

https://github.com/binux/pyspider

robobrowser- 一个简单的 Pythonic 库，无需独立的 Web 浏览器即可浏览 Web。

https://github.com/jmcarp/robobrowser

scrapy- 快速的高级屏幕抓取和网络爬网框架。

https://scrapy.org/

用于提取 Web 内容的库。

html2text- 将 HTML 转换为 Markdown 格式的文本。

https://github.com/Alir3z4/html2text

lassie- 人类的 Web 内容检索。

https://github.com/michaelhelmick/lassie

micawber- 一个小型库，用于从 URL 中提取丰富的内容。
https://github.com/coleifer/micawber

newspaper -Python 中的新闻提取，文章提取和内容管理。

https://github.com/codelucas/newspaper

python- readability - arc90 的可读性工具的快速 Python 端口。

https://github.com/buriy/python-readability

requests-html –适用于人类的 Pythonic HTML 解析。

https://github.com/psf/requests-html

sumy- 自动汇总文本文档和 HTML 页面的模块。

https://github.com/miso-belica/sumy

textract- 从任何文档，Word，PowerPoint，PDF 等中提取文本

https://github.com/deanmalmgren/textract

toapi- 每个网站都提供 API。

https://github.com/gaojiuli/toapi

五、HTML、XML

用于处理 HTML 和 XML 的库。

BeautifulSoup- 提供 Pythonic 惯用法来迭代，搜索和修改 HTML 或 XML。

bleach –基于白名单 HTML 清理和文本 linkification 库中的。

cssutils- 一个 Python 的 CSS 库。

html5lib- 一个符合标准的库，用于解析和序列化 HTML 文档和片段。

lxml- 一个非常快速，易于使用的通用库，用于处理 HTML 和 XML。

MarkupSafe- 为 Python 实现 XML / HTML / XHTML 标记安全字符串。

pyquery- 用于解析 HTML 的类似 jQuery 的库。

untangle –将 XML 文档转换为 Python 对象，以方便访问。

WeasyPrint- 用于 HTML 和 CSS 的可视渲染引擎，可以导出为 PDF。

xmldataset- 简单的 XML 解析。

xmltodict- 使用 XML 就像使用 JSON。

六、HTTP 客户端

使用 HTTP 的库。

grequests- 异步 HTTP 请求的 request + gevent。

httplib2- 全面的 HTTP 客户端库。

httpx- 用于 Python 的下一代 HTTP 客户端。

requests -HTTP 对人类的请求。

treq -Python 请求，例如在 Twisted 的 HTTP 客户端之上构建的 API。

七、office 模块

用于解析和处理特定文本格式的库。

General

tablib -XLS，CSV，JSON，YAML 中的表格数据集的模块。

Office

docxtpl- 通过 jinja2 模板编辑 docx 文档

openpyxl- 用于读取和写入 Excel 2010 xlsx /xlsm/xltx /xltm 文件的库。

pyexcel- 提供一个用于读取，操作和写入 csv，ods，xls，xlsx 和 xlsm 文件的 API。

python-docx- 读取，查询和修改 Microsoft Word 2007/2008 docx 文件。

python-pptx- 用于创建和更新 PowerPoint（.pptx）文件的 Python 库。

unoconv- 在 LibreOffice / OpenOffice 支持的任何文档格式之间转换。

XlsxWriter- 一个用于创建 Excel .xlsx 文件的 Python 模块。

xlwings -BSD 许可的库，可以轻松地从 Excel 调用 Python，反之亦然。

xlwt / xlrd- 从 Excel 文件写入和读取数据以及格式化信息。

PDF 格式

PDFMiner- 一种从 PDF 文档提取信息的工具。

PyPDF2- 一个能够拆分，合并和转换 PDF 页面的库。

ReportLab- 允许快速创建丰富的 PDF 文档。

Markdown

Mistune-Markdown 最快，功能最全的纯 Python 解析器。

Python-Markdown -John Gruber 的 Markdown 的 Python 实现。

YAML

PyYAML- 适用于 Python 的 YAML 实现。

CSV

csvkit- 转换为 CSV 并使用 CSV 的实用程序。

Archive

unp- 一个命令行工具，可以轻松地解压缩档案。

八、序列化

用于序列化复杂数据类型的库

marshmallow- 一个轻量级的库，用于将复杂的对象与简单的 Python 数据类型相互转换。

pysimdjson - 一个 Python 绑定 simdjson。

python-rapidjson- 一个 Python 包装周围 RapidJSON。

ultrajson- 使用 Python 绑定用 C 编写的快速 JSON 解码器和编码器。

九、代码分析、测试

码质量检查器的工具。另请参阅令人敬畏的静态分析。

代码分析

Coala- 语言独立且易于扩展的代码分析应用程序。

code2flow- 将您的 Python 和 JavaScript 代码转换为 DOT 流程图。

prospector- 分析 Python 代码的工具。

pycallgraph- 一个可视化 Python 应用程序流程（调用图）的库。

vulture- 查找和分析无效的 Python 代码的工具。

Code Linters

flake8 - 一个包装器 pycodestyle，pyflakes 和麦凯布。

很棒的片状 8 扩展

pylama- 用于 Python 和 JavaScript 的代码审核工具。

pylint- 完全可定制的源代码分析器。

wemake-python-styleguide- 有史以来最严格，最自以为是的 python linter。

代码格式化程序

black –毫不妥协的 Python 代码格式化程序。

isort- 用于对导入进行排序的 Python 实用程序 / 库。

yapf- 另一个来自 Google 的 Python 代码格式化程序。

静态类型检查器，另请参见 awesome-python-typing

mypy- 在编译期间检查变量类型。

pyre-check- 性能类型检查。

typeshed- 具有静态类型的 Python 库存根的集合。

静态类型注释生成器

MonkeyType- 一个用于 Python 的系统，通过收集运行时类型来生成静态类型注释。

pyannotate- 自动生成 PEP-484 注释。

pytype -pytype 检查并推断 Python 代码的类型 - 无需类型注释。

渗透测试的框架和工具。

fsociety- 渗透测试框架。

setoolkit- 社会工程的工具包。

sqlmap- 自动 SQL 注入和数据库接管工具。

用于测试代码库和生成测试数据的库。

测试框架

hypothesis –假设是一个高级的 Quickcheck 样式基于属性的测试库。

nose2 -nose 基于 `unittest2。的后继者。

pytest- 一个成熟的功能齐全的 Python 测试工具。

Robot Framework 通用的测试自动化框架。

unittest-（Python 标准库）单元测试框架。

测试选手

green - 干净，多彩的测试运行器。

mamba -Python 的权威测试工具。生于 BDD 的旗帜下。

tox- 自动构建和测试多个 Python 版本的发行版

GUI / Web 测试

locust- 用 Python 编写的可扩展用户负载测试工具。

PyAutoGUI -PyAutoGUI 是适用于人类的跨平台 GUI 自动化 Python 模块。

Schemathesis- 用于对基于 Open API / Swagger 规范构建的 Web 应用程序进行基于属性的自动测试的工具。

Selenium - Selenium WebDriver 的 Python 绑定。

sixpack- 与语言无关的 A / B 测试框架。

splinter- 用于测试 Web 应用程序的开源工具。

Mock

doublex- 强大的 Python 测试框架加倍。

Frozengun- 通过模拟 datetime 模块来穿越时间。

httmock- 一个针对 Python 2.6 + 和 3.2 + 的请求的模拟库。

httpretty- 适用于 Python 的 HTTP 请求模拟工具。

mock-（Python 标准库）一个模拟和修补库。

mocket - 具有 gevent /asyncio/ SSL 支持的套接字模拟框架。

responses 一个实用程序库，用于模拟请求 Python 库。

VCR.py- 记录并重放测试中的 HTTP 交互。

对象工厂

factory_boy -Python 的测试装置替代品。

mixer- 另一种灯具更换。支持 Django，Flask，SQLAlchemy，Peewee 等

model_mommy- 创建随机夹具以在 Django 中进行测试。

代码覆盖率

coverage- 代码覆盖率度量。

伪数据

fake2db- 伪数据库生成器。

faker- 一个生成伪造数据的 Python 包。

mimesis- 是一个 Python 库，可帮助您生成虚假数据。

radar - 生成随机的日期时间 / 时间。

用于验证数据的库。

Cerberus- 一个轻量级和可扩展的数据验证库。

colander- 验证和反序列化通过 XML，JSON 和 HTML 表单发布获得的数据。

jsonschema - Python 的 JSON 模式的实现。

schema- 用于验证 Python 数据结构的库。

Schematics –数据结构验证。

valideer - 轻量级可扩展数据验证和适配库。

voluptuous - 的 - 一个 Python 数据验证库。

十、web 框架

传统的全栈 Web 框架。另请参阅 RESTful API。

同步

Django -Python 中最流行的 Web 框架。

很棒的 django

Flask -Python 的微框架。

很棒的烧瓶

Pyramid- 一个小型，快速，扎实的开源 Python Web 框架。

真棒金字塔

Masonite- 以开发人员为中心的现代 Python Web 框架。

异步

Tornado- 一个 Web 框架和异步网络库。

十一、搜索

用于对数据建立索引并执行搜索查询的库和软件。

django-haystack- 模块化搜索 Django。

elasticsearch-dsl-py -Elasticsearch 的官方高级 Python 客户端。

elasticsearch-py - Elasticsearch 的官方低层 Python 客户端。

pysolr - Apache Solr 的轻量级 Python 包装器。

whoosh- 一个快速的纯 Python 搜索引擎库。

十二、日志记录

用于生成和使用日志的库。

logbook - - 记录 Python 的替换记录。

logging-（Python 标准库）Python 的日志记录工具。

loguru- 旨在以 Python 带来令人愉悦的日志记录的库。

sentry- python - 适用于 Python 的 Sentry SDK。

structlog- 结构化日志变得容易。

十三、并发与并行

用于并发和并行执行的库。另请参阅 awesome-asyncio。

parallel.futures-（Python 标准库）用于异步执行可调用对象的高级接口。

eventlet- 具有 WSGI 支持的异步框架。

gevent- 使用 greenlet 的基于协程的 Python 网络库。

multiprocessing-（Python 标准库）基于进程的并行性。

scoop -Python 中的可伸缩并发操作。

uvloop - 在.NET 之上的 asyncio 事件循环的超快速实现 libuv。

十四、任务队列

用于处理任务队列的库。

celery- 基于分布式消息传递的异步任务队列 / 作业队列。

Dramatiq- 用于 Python 3 的快速可靠的后台任务处理库。

huey- 小多线程任务队列。

mrq- 使用 Redis 和 gevent 的 Python 中的分布式工作者任务队列。

rq -Python 的简单作业队列。

十五、自然语言处理

用于使用人类语言的图书馆。

一般的

gensim- 人类主题建模。

langid.py- 独立的语言识别系统。

nltk- 用于构建 Python 程序以使用人类语言数据的领先平台。

pattern- 一个 Web 挖掘模块。

polyglot- 支持数百种语言的自然语言管道。

pytext 的 - 基于 PyTorch 自然语言建模框架。

PyTorch-NLP- 一种工具包，可用于研究的快速深度学习 NLP 原型。

spacy - 一种用于 Python 和用 Cython 工业强度的自然语言处理库。

Stanza -Stanford NLP Group 的官方 Python 库，支持 60 多种语言。

中国人

funNLP- 中国 NLP 的工具和数据集的集合。

jieba- 最受欢迎的中文文本分割库。

pkuseg-python- 用于各种领域的中文分词的工具包。

snownlp- 用于处理中文文本的库。

十六、深度学习、机器学习、计算机视觉

神经网络和深度学习框架。另请参阅真棒深度学习。

caffe- 深度学习的快速开放框架。

keras- 一个高级神经网络库，能够在 TensorFlow 或 Theano 之上运行。

mxnet- 专为效率和灵活性而设计的深度学习框架。

pytorch- 具有强大 GPU 加速功能的 Python 中的张量和动态神经网络。

SerpentAI- 游戏代理框架。使用任何视频游戏作为深度学习沙箱。

tensorflow- 由 Google 创建的最受欢迎的深度学习框架。

Theano- 一个用于快速数值计算的库。

机器学习图书馆。另请参阅很棒的机器学习。

健身房 - 用于开发和比较强化学习算法的工具包。

H2O- 开源快速可扩展机器学习平台。

指标 - 机器学习评估指标。

NuPIC -Numenta 智能计算平台。

scikit-learn- 最受欢迎的机器学习 Python 库。

Spark ML - Apache Spark 的可扩展机器学习库。

vowpal_porpoise- 用于 Vowpal Wabbit 的轻量级 Python 包装器。

xgboost- 一个可扩展，可移植和分布式的梯度增强库。

MindsDB -MindsDB 是现有数据库的开源 AI 层，可让您使用标准查询轻松地开发，训练和部署最新的机器学习模型。

计算机视觉图书馆。

EasyOCR- 支持 40 多种语言的即用型 OCR。

人脸识别 - 简单的人脸识别库。

Kornia - PyTorch 的开源可区分计算机视觉库。

OpenCV- 开源计算机视觉库。

pytesseract - Google Tesseract OCR 的包装。

SimpleCV- 用于构建计算机视觉应用程序的开源框架。

tesserocr-tesseract-ocr 用于 OCR 的 API 的另一种简单，对枕头友好的包装。

十七、数据分析、可视化

用于数据分析的库。

AWS Data Wrangler -AWS 上的 Pandas。

Blaze -NumPy 和 Pandas 连接到大数据。

Pandas 界面中的 Open Mining- 商业智能（BI）。

Optimus –敏捷数据科学的工作流程变得容易与 PySpark。

Orange –通过可视化编程或脚本进行数据挖掘，数据可视化，分析和机器学习。

Pandas- 一个提供高性能，易于使用的数据结构和数据分析工具的库。

用于可视化数据的库。另请参阅 awesome-javascript。

Altair- 用于 Python 的声明性统计可视化库。

Bokeh- 用于 Python 的交互式 Web 绘图。

bqplot -Jupyter Notebook 的交互式绘图库

Cartopy- 具有 matplotlib 支持的制图 python 库

短跑 - 建立在烧瓶顶部，反应，Plotly 旨在分析 Web 应用程序。

很棒的破折号

图表 - 图表为代码。

Matplotlib- 一个 Python 2D 绘图库。

plotnine- 基于 ggplot2 的 Python 图形语法。

Pygal- 一个 Python SVG 图表创建器。

PyGraphviz - Graphviz 的 Python 接口。

PyQtGraph- 交互式和实时 2D / 3D / 图像绘制以及科学 / 工程小部件。

Seaborn - 使用 Matplotlib 统计数据可视化。

VisPy- 基于 OpenGL 的高性能科学可视化。

十八、数据库驱动程序

用于连接和操作数据库的库。

MySQL- 很棒的 MySQL

mysqlclient- 支持 Python 3 的 MySQL 连接器（mysql-python fork）。

PyMySQL- 与 mysql-python 兼容的纯 Python MySQL 驱动程序。

PostgreSQL- 很棒的 Postgres

psycopg2- 最受欢迎的 Python PostgreSQL 适配器。

查询 -psycopg2 库的包装，用于与 PostgreSQL 交互。

SQlite- 很棒的 SQLite

sqlite3-（Python 标准库）与 DB-API 2.0 兼容的 SQlite 接口

SuperSQLite- 建立在 apsw 之上的增压 SQLite 库。

其他关系数据库

pymssql -Microsoft SQL Server 的简单数据库接口。

clickhouse-driver- 具有 ClickHouse 本地接口的 Python 驱动程序。

NoSQL 数据库

cassandra-driver -Apache Cassandra 的 Python 驱动程序。

happybase -Apache HBase 的开发人员友好型库。

kafka-python -Apache Kafka 的 Python 客户端。

py2neo- 用于 Neo4j 的客户端库和工具包。

pymongo -MongoDB 的官方 Python 客户端。

redis-py -Redis 的 Python 客户端。

异步客户端

motor -MongoDB 的异步 Python 驱动程序。

十九、DevOps 工具

DevOps 的软件和库。

配置管理

ansible- 一个非常简单的 IT 自动化平台。

cloudinit- 一个多分发包，用于处理云实例的早期初始化。

OpenStack- 用于构建私有和公共云的开源软件。

pyinfra- 通用的 CLI 工具和 python 库，可自动执行基础架构。

saltstack- 基础结构自动化和管理系统。

SSH 样式的部署

cuisine - 类似于 Fabric 的厨师功能。

fabric - 一个简单的，Python 化工具，用于远程执行和部署。

fabtools- 编写很棒的 Fabric 文件的工具。

流程管理

honcho - Foreman 的 Python 克隆，用于管理基于 Procfile 的应用程序。

supervisor - 用于 UNIX 监事过程控制系统。

监控方式

psutil- 跨平台的流程和系统实用程序模块。

后备

BorgBackup- 具有压缩和加密功能的重复数据删除存档器。

其他

docker- compose- 使用 Docker 的快速隔离开发环境。

二十、分布式计算

分布式计算的框架和库。

批量处理

dask- 用于分析计算的灵活并行计算库。

luigi- 一个模块，可帮助您构建批处理作业的复杂管道。

mrjob- 在 Hadoop 或 Amazon Web Services 上运行 MapReduce 作业。

PySpark - Apache Spark Python API。

Ray- 用于并行和分布式 Python 的系统，统一了机器学习生态系统。

流处理

faust- 流处理库，将想法从 Kafka Streams 移植到 Python。

streamparse- 通过 Apache Storm 针对实时数据流运行 Python 代码。

二十一、配置、打包构建

用于存储和解析配置选项的库。

configobj- 带有验证的 INI 文件解析器。

configparser-（Python 标准库）INI 文件解析器。

hydra -Hydra 是用于优雅配置复杂应用程序的框架。

profig- 使用值转换从多种格式进行配置。

python-decouple- 严格将设置与代码分开。

用于创建打包的可执行文件以进行发行的库。

dh-virtualenv- 以 Debian 软件包的形式构建和分发 virtualenv。

Nuitka - 将脚本，模块，程序包编译为可执行文件或扩展模块。

py2app- 冻结 Python 脚本（Mac OS X）。

py2exe- 冻结 Python 脚本（Windows）。

pyarmor- 一种用于混淆 python 脚本，将混淆后的脚本绑定到固定计算机或使混淆后的脚本失效的工具。

PyInstaller- 将 Python 程序转换为独立的可执行文件（跨平台）。

pynsist- 用于构建 Windows 安装程序的工具，安装程序将 Python 本身捆绑在一起。

shiv- 命令行实用程序，用于构建完全独立的 zipapp（PEP 441），但包括其所有依赖项。

二十二、虚拟环境

用于 Python 版本和虚拟环境管理的库。

pyenv- 简单的 Python 版本管理。

virtualenv- 创建隔离的 Python 环境的工具。

二十三、界面开发

用于处理图形用户界面应用程序的库。

curses - - 内置包装器 ncurses 的用于创建终端 GUI 的应用程序。

Eel- 一个用于制作简单的类似于电子的脱机 HTML / JS GUI 应用程序的库。

enaml- 使用声明性语法（如 QML）创建漂亮的用户界面。

Flexx -Flexx 是用于创建 GUI 的纯 Python 工具包，它使用 Web 技术进行呈现。

Gooey - 使用命令行将命令行程序转换为完整的 GUI 应用程序。

kivy- 用于创建 NUI 应用程序的库，可在 Windows，Linux，Mac OS X，Android 和 iOS 上运行。

pyglet -Python 的跨平台窗口和多媒体库。

PyGObject -GLib / GObject / GIO / GTK +（GTK + 3）的 Python 绑定。

PyQt - Qt 跨平台应用程序和 UI 框架的 Python 绑定。

PySimpleGUI - tkinter，Qt，WxPython 和 Remi 的包装。

pywebview- 围绕 webview 组件的轻量级跨平台本机包装器。

Tkinter -Tkinter 是 Python 的事实上的标准 GUI 软件包。

Toga -Python 本机，OS 本机 GUI 工具箱。

urwid- 一个用于创建终端 GUI 应用程序的库，该库对小部件，事件，丰富的颜色等具有强大的支持。

wxPython -wxWidgets C ++ 类库与 Python 的混合。

DearPyGui- 一个简单的 GPU 加速的 Python GUI 框架

二十四、游戏开发

很棒的游戏开发库。

Arcade -Arcade 是一个现代 Python 框架，用于制作具有引人注目的图形和声音的游戏。

Cocos2d -cocos2d 是用于构建 2D 游戏，演示和其他图形 / 交互应用程序的框架。

Harfang3D- 用于 3D，VR 和游戏开发的 Python 框架。

Panda3D- 迪士尼开发的 3D 游戏引擎。

Pygame -Pygame 是一组旨在编写游戏的 Python 模块。

PyOgre -Ogre 3D 渲染引擎的 Python 绑定，可用于游戏，模拟或任何 3D。

PyOpenGL -OpenGL 及其相关 API 的 Python ctypes 绑定。

PySDL2 -SDL2 库的基于 ctypes 的包装器。

RenPy- 一个视觉小说引擎

二十五、任务调度器

用于计划作业的库。

Airflow 气流是一个以编程方式编写，安排和监视工作流的平台。

APScheduler- 轻巧但功能强大的进程内任务计划程序，可让您计划功能。

django-schedule -Django 的日历应用程序。

doit- 一个任务运行器和构建工具。

gunnery - 具有基于 Web 界面的分布式系统的多用途任务执行工具。

Joblib- 一套在 Python 中提供轻量级流水线的工具。

Plan - 像用吊饰一样用 Python 编写 crontab 文件。

Prefect- 一个现代的工作流程编排框架，可轻松构建，调度和监视强大的数据管道。

schedule- 针对人类的 Python 作业调度。

Spiff- 用纯 Python 实现的功能强大的工作流引擎。

TaskFlow- 一个 Python 库，可帮助简化，一致且可靠的任务执行

二十六、科学计算

用于科学计算的图书馆。另请参见 Python for-Scientists。

astropy- 天文学的社区 Python 库。

bcbio-nextgen- 提供最佳实践流水线，用于全自动高通量测序分析。

bccb- 收集与生物学分析有关的有用代码。

Biopython -Biopython 是一套免费的生物计算工具。

cclib- 一个用于解析和解释计算化学程序包结果的库。

Colour - 实施大量的颜色理论转换和算法。

Karate Club - 用于图形结构化数据的无监督机器学习工具箱。

NetworkX- 用于复杂网络的高生产率软件。

NIPY- 神经影像工具箱的集合。

NumPy- 使用 Python 进行科学计算的基本软件包。

ObsPy- 地震学的 Python 工具箱。

Open Babel- 一种化学工具箱，旨在讲多种化学数据语言。

PyDy -Python Dynamics 的缩写，用于协助工作流进行动态运动建模。

PyMC- 马尔可夫链蒙特卡洛采样工具包。

QuTiP -Python 中的 Quantum Toolbox。

RDKit- 化学信息学和机器学习软件。

SciPy- 用于数学，科学和工程的基于 Python 的开源软件生态系统。

SimPy- 一个基于过程的离散事件模拟框架。

statsmodels -Python 中的统计建模和计量经济学。

SymPy- 一个用于符号数学的 Python 库。

Zipline- 一个 Pythonic 算法交易库。

RPC

RPC 兼容服务器。

RPyC（远程 Python 调用）- 用于 Python 的透明且对称的 RPC 库

zeroRPC -zerorpc 是基于 ZeroMQ 和 MessagePack 的灵活 RPC 实现。

ython 提供了多种库来处理纯文本数据，这些库可以应对从基本文本操作到复杂文本分析的各种需求。以下是一些常用的纯文本处理相关的库：

str 类型: Python 内建的字符串类型提供了许多简便的方法来进行基础文本处理，如分割、连接、替换文本等。

# 分割字符串
text = "hello, world"
print(text.split(","))  # 输出：['hello', ' world']

# 连接字符串
words = ["Python", "is", "awesome"]
print(" ".join(words))  # 输出：Python is awesome

# 替换字符串中的子字符串
text = "Hello World"
print(text.replace("World", "Python"))  # 输出：Hello Python

re: Python 的标准库之一，用于执行正则表达式操作。这个库对于复杂的字符串匹配和提取非常有用。

import re

text = "The rain in Spain"
x = re.search("^The.*Spain$", text)
if x:
      print("YES! We have a match!")
else:
      print("No match")

string: 这个标准库模块包含了一些常见的字符串操作函数和常量。

import string

# 示例：使用 string 常量
print(string.ascii_lowercase)  # 输出：abcdefghijklmnopqrstuvwxyz

textwrap: 用于格式化文本段落以适应屏幕宽度的工具。

import textwrap
sample_text = '''
 This is a very very very very very long string.
 '''
print(textwrap.fill(sample_text, width=50))

difflib: 可以用来比较序列之间的差异，包括文本文件。

import difflib

text1 = "Python is great"
text2 = "Python is good"
d = difflib.Differ()
diff = d.compare(text1.split(), text2.split())
print('\n'.join(diff))

codecs: 用于编码和解码文本文件，特别是涉及不同编码的场景。

import codecs

# 读取一个 UTF-8 编码的文件
with codecs.open('example.txt', 'r', 'utf-8') as f:
      print(f.read())

unicodedata: 用于处理Unicode字符的数据库。

import unicodedata

# 获取字符的名称
char = 'ñ'
name = unicodedata.name(char)
print(name)  # 输出：LATIN SMALL LETTER N WITH TILDE

csv: 用于读写CSV格式文件的库，虽然CSV不是纯文本，但是通常被视为简单文本数据的一种。

import csv

with open('example.csv', mode='r') as file:
      reader = csv.reader(file)
      for row in reader:
         print(row)

json: 用于读写JSON格式的数据，虽然JSON通常用于数据交换，但也是文本格式的一种。

import json

data = {'key': 'value'}
json_data = json.dumps(data)
print(json_data)

xml.etree.ElementTree: 用于解析和创建XML数据。

import xml.etree.ElementTree as ET
# 解析XML
tree = ET.parse('example.xml')
root = tree.getroot()
# 遍历XML文档
for child in root:
   print(child.tag, child.attrib)

html.parser: 用于解析HTML文档。

from html.parser import HTMLParser

class MyHTMLParser(HTMLParser):
   def handle_starttag(self, tag, attrs):
      print("Start tag:", tag)

   def handle_endtag(self, tag):
      print("End tag:", tag)

   def handle_data(self, data):
      print("Data:", data)

parser = MyHTMLParser()
parser.feed('<html><head><title>Test</title></head>'
            '<body><h1>Parse me!</h1></body></html>')

nltk (Natural Language Toolkit): 一个强大的文本处理库，用于处理人类使用的自然语言数据。

import nltk
nltk.download('punkt')
from nltk.tokenize import word_tokenize

text = "Hello Mr. Smith, how are you doing today?"
tokens = word_tokenize(text)
print(tokens)

通过使用这些库，Python 程序员能够执行各种文本处理任务，从简单的字符串操作到复杂的文本分析和处理。根据项目的具体需求，正确选择合适的库对于提高效率和代码质量至关重要。

在线咨询

上一篇：HTML之基础篇
下一篇：页面排版很难吗？一起来学Markdown吧！04使用Typora排版（二）

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

整合营销服务商

在Python中实现文本分类（附代码、数据集）

您的项目需求