pitón máquina de aprendizaje con el uso sklearn biblioteca de imágenes, clasificación de texto (recursos de instalación sklearn incidentales y tutoriales)

pitón máquina de aprendizaje con el uso de la biblioteca sklearn imágenes, clasificación de texto

Descargar e instalar sklearn

sklearn es una biblioteca de Python, pip necesidad de instalar:

pip install sklearn

Pero a menudo no se puede instalar con éxito , ya que se basan sklearn numpy y SciPy, pero la mayoría de personas son pip numpy instalar directamente, pero no la versión completa, por lo que cuando instala normalmente sicpy de error.
Por lo que algunas personas piensan: Voy a la página web oficial para descargar el archivo para instalar whl ligeramente. Por desgracia, la pared universales sitio web oficial de la velocidad de descarga de papel de 10 kb / s, a menudo no sólo muy bien en el error. Así que deja al lector aquírecursos, El código de extracción: sdwi (disco de red Baidu no importa qué tan frenética que no será 10kb / s, derecha)
para obtener el paquete de instalación más tarde, estos dos archivos en la carpeta scripts dentro de su directorio pitón ordenador, así:
numpy ya instalado amigos, numpy desinstalación: pip uninstall numpy
entonces cmd abierto, Cd todo el camino hasta esta posición, entonces:

pip install numpy-1.16.4+mkl-cp37-cp37m-win_amd64.whl
pip install scipy-1.1.0-cp37-cp37m-win_amd64.whl

¿Qué frontal específico detrás de la cual se me olvide, hay una necesidad puede tratar.
A continuación, puede pip install sklearnamigos.

Preparación: descargar el conjunto de datos

En este artículo se describe se basa en los datos de imagen procesados ​​establece dígitos correspondientes (escritura) y texto (noticias), así que lo mejor es descargar el conjunto de datos con antelación

• Descargar conjuntos de datos Noticias

from sklearn.datasets import fetch_20newsgroups
# sample_cate 指定需要下载哪几个主题类别的新闻数据
sample_cate = ['alt.atheism', 'soc.religion.christian', 'comp.graphics', 'sci.med', 'rec.sport.baseball']
# 需要从网络上下载，受连接外网速度限制, 可能要耐心等待几分钟时间
newsgroups_train = fetch_20newsgroups(subset='train', categories=sample_cate, shuffle=True)
# 以上得到训练集，以下代码得到测试集
newsgroups_test = fetch_20newsgroups(subset='test', categories=sample_cate, shuffle=True)

El conjunto de entrenamiento en newsgroups_train, el conjunto de prueba de newsgroups_test.

Categoría de puño y letra:

Utilice la SVM, Naive Bayes, el KNN, utilizando dígitos Sklearn datos de entrenamiento de reconocimiento de escritura propio conjunto
el conjunto de datos es un tamaño de píxel de escala de grises de 8 * 8 de 1797, cuando el clasificador utilizando reconocimiento de escritura, son las imágenes cada una como 64-dimensional vector de características .

# The digits dataset
digits = datasets.load_digits()
print(digits.DESCR)

La pantalla digital en escala de grises (requerido import matplotlib.pyplot as plt)

#显示数据集中的第一个图像
plt.imshow(digits.images[0], cmap=plt.cm.gray_r, interpolation='nearest')

Este experimento requiere tres clasificadores, knn, SVM, Bayes ingenuo, descripción específica puede google, o vista desde un extremo archivos dentro de los recursos del repositorio GitHub palabra
A continuación, cree un clasificador:

# 创建svm分类器
svc_clf = svm.SVC(gamma=0.001)
# 创建KNN分类器
knn_clf = KNeighborsClassifier()
# 创建朴素贝叶斯分类器
nb_clf = MultinomialNB()

A continuación, dividir el conjunto de datos (noticia que no es necesaria, ya que al descargar los conjuntos de datos, así como buenos puntos)

# Split data into train and test subsets
# 使用train_test_split将数据集分为训练集，测试集, y_train 表示训练集中样本的类别标签, y_test表示测试集中样本的类别标签
# test_size = 0.5 表示使用一半数据进行测试, 另一半就用于训练
X_train, X_test, y_train, y_test = train_test_split(
    data, digits.target, test_size=0.5, shuffle=False)

Uso aptos para la formación:

# 调用fit方法进行训练，传入训练集样本和样本的类别标签，进行有监督学习
svc_clf.fit(X_train, y_train)
knn_clf.fit(X_train, y_train)
nb_clf.fit(X_train, y_train)

Predicción: `

# 调用predict， 用训练得到的模型在测试集进行类别预测，得到预测的类别标签
svc_predicted = svc_clf.predict(X_test)
knn_predicted = knn_clf.predict(X_test)
nb_predicted = nb_clf.predict(X_test)`

A continuación, iniciar la producción:

svc_images_and_predictions = list(zip(digits.images[n_samples // 2:], svc_predicted))
knn_images_and_predictions = list(zip(digits.images[n_samples // 2:], knn_predicted))
nb_images_and_predictions = list(zip(digits.images[n_samples // 2:], nb_predicted))

# 在图表的第二行输出svm在测试集的前四个手写体图像上的分类结果，大家可以在图上看看结果对不对
for ax, (image, svc_prediction) in zip(axes[1, :], svc_images_and_predictions[:4]):
    ax.set_axis_off()
    ax.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
    ax.set_title('Prediction: %i' % svc_prediction)

# 在图表的第三行输出KNN在测试集的前四个手写体图像上的分类结果，大家可以在图上看看结果对不对
# 大家应该可以发现KNN把第二列的8这个手写数字识别为3，发生错误
for ax, (image, knn_prediction) in zip(axes[2, :], knn_images_and_predictions[:4]):
    ax.set_axis_off()
    ax.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
    ax.set_title('Prediction: %i' % knn_prediction)

# 在图表的第四行输出朴素贝叶斯在测试集的前四个手写体图像上的分类结果，大家可以在图上看看结果对不对
for ax, (image, nb_prediction) in zip(axes[3, :], nb_images_and_predictions[:4]):
    ax.set_axis_off()
    ax.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
    ax.set_title('Prediction: %i' % nb_prediction)
    
# 绘制出图
plt.show()

indicadores de rendimiento de salida:

# 输出三个分类器的性能指标，大家需要了解二分类、多分类的性能评估指标主要有哪些

# 输出svm的分类性能指标
print("Classification report for classifier %s:\n%s\n"
      % (svc_clf, metrics.classification_report(y_test, svc_predicted)))

# 输出KNN的分类性能指标
print("Classification report for classifier %s:\n%s\n"
      % (knn_clf, metrics.classification_report(y_test, knn_predicted)))

# 输出naive bayes的分类性能指标
print("Classification report for classifier %s:\n%s\n"
      % (nb_clf, metrics.classification_report(y_test, nb_predicted)))

Escritura a mano los códigos de clasificación generales: enlace de GitHub
resultados operativos:

Noticias clasificación de texto

Es más simple que la imagen de los puntos de texto, ya que el procesamiento sin matriz.
Proceso y la palabra de escritura a mano casi, después de la predicción de ajuste, y luego el rendimiento de salida

from sklearn.datasets import fetch_20newsgroups
# sample_cate 指定需要下载哪几个主题类别的新闻数据
sample_cate = ['alt.atheism', 'soc.religion.christian', 'comp.graphics', 'sci.med', 'rec.sport.baseball']
# 需要从网络上下载，受连接外网速度限制, 可能要耐心等待几分钟时间
newsgroups_train = fetch_20newsgroups(subset='train', categories=sample_cate, shuffle=True)
# 以上得到训练集，以下代码得到测试集
newsgroups_test = fetch_20newsgroups(subset='test', categories=sample_cate, shuffle=True)

print(len(newsgroups_train.data))
print(len(newsgroups_test.data))

import matplotlib.pyplot as plt
from sklearn import datasets, svm, metrics
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfVectorizer

count_vectorizer = CountVectorizer(stop_words='english')
cv_news_train_vector = count_vectorizer.fit_transform(newsgroups_train.data)
print("news_train_vector.shape:",cv_news_train_vector.shape)
cv_news_test_vector = count_vectorizer.transform(newsgroups_test.data)
print("news_test_vector.shape:",cv_news_test_vector.shape)

svc_clf = svm.SVC(kernel="linear")
svc_clf.fit(cv_news_train_vector,newsgroups_train.target)
cv_svc_predict = svc_clf.predict(cv_news_test_vector)
print("Classification report for classifier %s:\n%s\n" % (svc_clf,metrics.classification_report(newsgroups_test.target,cv_svc_predict,target_names=newsgroups_test.target_names)))

knn_clf = KNeighborsClassifier()
knn_clf.fit(cv_news_train_vector,newsgroups_train.target)
cv_knn_predict = knn_clf.predict(cv_news_test_vector)
print("Classification report for classifier %s:\n%s\n" % (knn_clf,metrics.classification_report(newsgroups_test.target,cv_knn_predict,target_names=newsgroups_test.target_names)))

nb_clf = MultinomialNB()
nb_clf.fit(cv_news_train_vector,newsgroups_train.target)
cv_nb_predict = nb_clf.predict(cv_news_test_vector)
print("Classification report for classifier %s:\n%s\n" % (nb_clf,metrics.classification_report(newsgroups_test.target,cv_nb_predict,target_names=newsgroups_test.target_names)))

###################################################################

tfidf_vectorizer = TfidfVectorizer(stop_words='english')
tfidf_news_train_vector = tfidf_vectorizer.fit_transform(newsgroups_train.data)
print("news_train_vectorizer.shape",tfidf_news_train_vector.shape)
tfidf_news_test_vector = tfidf_vectorizer.transform(newsgroups_test.data)
print("news_test_vectorizer.shape",tfidf_news_train_vector.shape)

svc_clf2 = svm.SVC(kernel="linear")
svc_clf2.fit(tfidf_news_train_vector,newsgroups_train.target)
tfidf_svc_predict2 = svc_clf2.predict(tfidf_news_test_vector)
print("Classification report for classifier %s:\n%s\n" % (svc_clf2,metrics.classification_report(newsgroups_test.target,tfidf_svc_predict2,target_names=newsgroups_test.target_names)))

knn_clf = KNeighborsClassifier()
knn_clf.fit(tfidf_news_train_vector,newsgroups_train.target)
tfidf_knn_predict = knn_clf.predict(tfidf_news_test_vector)
print("Classification report for classifier %s:\n%s\n" % (knn_clf,metrics.classification_report(newsgroups_test.target,tfidf_knn_predict,target_names=newsgroups_test.target_names)))

nb_clf = MultinomialNB()
nb_clf.fit(tfidf_news_train_vector,newsgroups_train.target)
tfidf_nb_predict = nb_clf.predict(tfidf_news_test_vector)
print("Classification report for classifier %s:\n%s\n" % (nb_clf,metrics.classification_report(newsgroups_test.target,tfidf_nb_predict,target_names=newsgroups_test.target_names)))
©

El resultado: