作者：韩信子@ShowMeAI
教程地址：http://www.showmeai.tech/tutorials/41
本文地址：http://www.showmeai.tech/article-detail/201
申明：版权所有，转载请分割平台与作者并注明出处
珍藏ShowMeAI查看更多精彩内容

引言

本篇文章心愿带大家残缺走一遍机器学习利用流程，咱们会解说到基于Python的机器学习算法，利用在结构化数据和非结构化数据(图像)上，心愿通过文章内容帮忙大家在案例中重温机器学习基础知识，并学习利用机器学习解决问题的根本流程。

文章中会用到下述两个库来实现机器学习算法：

  • Scikit-Learn：最罕用的python机器学习算法工具库之一。
  • Keras：便捷的深度学习神经网络搭建利用工具库。
    对于上述两个工具库的用法，大家也能够通过ShowMeAI的文章 AI建模工具速查 | Scikit-Learn使用指南 和 AI建模工具速查 | Keras使用指南 来疾速查问和应用。

在本篇文章中，咱们将解说到以下内容：

  • 问题形象与了解
  • 数据筹备与解决(预处理、特征提取、特色工程等)
  • 各种机器学习算法
  • 试验后果剖析与比照
  • 模型抉择与调优

咱们会笼罩到的机器学习算法包含：KNN、奢侈贝叶斯、逻辑回归、SVM、决策树、随机森林、感知机、前馈神经网络、卷积神经网络。

1.环境筹备

工欲善其事必先利其器，咱们先装置一下必须的Python库(当然咱们也举荐大家用集成环境anaconda，具体的装置与设置能够参考ShowMeAI文章 图解Python | 装置与环境设置 实现)：

  • Numpy：用于Python的科学计算。

    • 相干重点常识请查看 数据迷信工具速查 | Numpy使用指南 或者 图解数据分析：从入门到精通系列教程 中的Numpy详解教程。
  • PIL：一个简略的图像处理库。

  • Scikit-Learn：蕴含多种机器学习算法。

    • 相干重点常识请查看 AI建模工具速查 | Scikit-Learn使用指南

  • Kears和TensorFlow：用于深度学习。本教程能够仅采纳CPU版本的TensorFlow。

    • 相干重点常识请查看 AI建模工具速查 | TensorFlow使用指南、AI建模工具速查 | Keras使用指南

  • OpenCV：本教程并不间接应用OpenCV，但imutils库依赖它。

    • 相干重点常识请查看 AI建模工具速查 | OpenCV使用指南
  • imutils：图像处理/计算机视觉库。
能够采纳pip装置，命令如下：$ pip install numpy$ pip install pillow$ pip install --upgrade scikit-learn$ pip install tensorflow # or tensorflow-gpu$ pip install keras$ pip install opencv-contrib-python$ pip install --upgrade imutils

2.数据集

因为本篇文章咱们介绍结构化数据和非结构化数据的不同建模，咱们这里用到两个数据集。

2.1 iris(鸢尾花)数据集

第一个数据集是iris(鸢尾花)数据集，它是一个入门级数据集。整个数据集都是数值型的数据，是一个结构化的表格数据，每一行代表一个样本，而后每一列就是不同的属性。

这个数据集次要是收集了三种不同的鸢尾花的数据，别离为：

  • Iris Setosa
  • Iris Versicolor
  • Iris Virginica

对应图中最初一列Class label，而后还有四种属性，别离是：

  • Sepal length：萼片长度
  • Sepal width：萼片宽度
  • Petal length：花瓣长度
  • Petal width：花瓣宽度

对于该数据集，咱们的指标就是依据给定的四个属性，训练一个机器学习模型来正确分类每个样本的类别，这是一个典型的分类工作。

2.2 图像数据集

第二个数据集是一个图像数据集。它包含海岸线(Coast)、森林(Forest)和高速公路(Highway)三种场景，总共是 948 张图片，咱们须要构建模型实现类别的分类，每个类别的具体图片数量如下：

  • 海岸线(Coast)：360
  • 森林(Forest)：328
  • 高速公路(Highway)：260

3.机器学习利用步骤

咱们在不同场景下利用机器学习算法，都有大抵的步骤，比方上面是一个典型的机器学习利用流程：

当然，并不是其中的每一步都是必须的，咱们也可能会调整其中某些步骤中的细节。

3.1 问题形象与了解

针对咱们的问题，问一下本人：

  • 数据集是哪种类型？数值型，类别型还是图像？
  • 模型的最终目标是什么？
  • 如何定义和掂量“准确率”呢？
  • 以目前本身的机器学习常识来看，哪些算法在解决这类问题上成果很好？

前序问题比较简单，最初的问题，随着大家利用机器学习解决问题的教训积攒，能够更精确疾速地答复。

3.2 数据筹备与解决

数据筹备与解决，包含数据预处理以及特色工程了。个别这一步，包含了加载数据、检查数据、探索性数据分析(EDA)、数据预处理，进而决定须要做的特征提取或者特色工程。

特征提取是利用某种算法通过某种形式来量化数据的过程。比方，对于图像数据，咱们能够采纳计算直方图的办法来统计图像中像素强度的散布，通过这种形式，咱们就失去形容图像色彩的特色。

特色工程是将原始输出数据转换成一个更好形容潜在问题的特色示意的过程。大家能够查看ShowMeAI的 机器学习专题文章 零碎理解特色工程的常见办法。

3.3 多模型利用

下一步能够抉择各种候选机器学习算法，并利用在数据集上。咱们装置的工具包内，蕴含很多机器学习算法，比方下述模型都能够用作分类：

  • 线性模型(逻辑回归、线性SVM)
  • 非线性模型(RBF、SVM、梯度降落分类器)
  • 树和基于集成的模型(决策树、随机森林)
  • 神经网络(多层感知机、卷积神经网络)

对于模型抉择，当然很多须要根据试验成果来定，但咱们也有一些先序的教训，比方：

  • 对于浓密型多特色的数据集，随机森林算法的成果很不错；
  • 逻辑回归算法能够很好解决高维度的稠密数据；
  • 对于图像数据，CNNs的成果十分好。

下图为 scikit-learn工具库 官网给的一个模型抉择思路参考：

4.构建机器学习流程并试验剖析

咱们构建如下的代码文件目录，蕴含四个代码文件和一个3scenes图像文件夹(内含三场景数据集)，iris数据集无需另外存储，间接采纳scikit-learn库载入即可。

├── 3scenes│   ├── coast [360 entries]│   ├── forest [328 entries]│   └── highway [260 entries]├── iris_classifier.py├── image_classifier.py├── nn_iris.py└── basic_cnn.py

4.1 结构化数据建模

首先实现iris_classifier，咱们这里间接应用sklearn的机器学习算法来对iris数据集进行分类。

# 导入须要的库from sklearn.neighbors import KNeighborsClassifierfrom sklearn.naive_bayes import GaussianNBfrom sklearn.linear_model import LogisticRegressionfrom sklearn.svm import SVCfrom sklearn.tree import DecisionTreeClassifierfrom sklearn.ensemble import RandomForestClassifierfrom sklearn.neural_network import MLPClassifierfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import classification_reportfrom sklearn.datasets import load_irisimport argparse# 设置参数ap = argparse.ArgumentParser()ap.add_argument("-m", "--model", type=str, default="knn", help="type of python machine learning model to use")args = vars(ap.parse_args())# 定义一个保留模型的字典，依据 key 来抉择加载哪个模型models = {    "knn": KNeighborsClassifier(n_neighbors=1),    "naive_bayes": GaussianNB(),    "logit": LogisticRegression(solver="lbfgs", multi_class="auto"),    "svm": SVC(kernel="rbf", gamma="auto"),    "decision_tree": DecisionTreeClassifier(),    "random_forest": RandomForestClassifier(n_estimators=100),    "mlp": MLPClassifier()}

其中，models从前往后顺次包含这些算法：KNN、奢侈贝叶斯、逻辑回归、SVM、决策树、随机森林、感知机等。

咱们间接调用sklearn中相应的函数来实现对应的算法即可，这里间接用一个models的字典来保留不同模型的初始化，而后依据参数--model来调用对应的模型，比方命令输出python iris_classifier.py --model knn就是调用knn算法模型。

接着就是载入数据局部：

print("加载数据中...")dataset = load_iris()trainX, testX, trainY, testY = train_test_split(dataset.data, dataset.target, random_state=3, test_size=0.2)

这里间接调用sklearn.datasets中的load_iris()载入数据，而后采纳train_test_split来划分训练集和数据集，这里是80%数据作为训练集，20%作为测试集。

最初就是训练模型和预测局部：

# 训练模型print("利用 '{}' 模型建模...".format(args["model"]))model = models[args["model"]]model.fit(trainX, trainY)# 预测并输入一份分类后果报告print("评估模型成果...")predictions = model.predict(testX)print(classification_report(testY, predictions, target_names=dataset.target_names))

4.2 图像数据建模

相似的过程对三场景图像数据集构建代码image_classifier.py：

# 导入工具库from sklearn.preprocessing import LabelEncoderfrom PIL import Imagefrom imutils import pathsimport numpy as npimport os

其中LabelEncoder是为了将标签从字符串编码为整型，而后其余几项都是解决图像相干。

对于图像数据，如果间接采纳原始像素信息输出模型中，大部分的机器学习算法成果都很不现实，所以这里采纳特征提取办法，次要是统计图像色彩通道的均值和标准差信息，总共是RGB3个通道，每个通道各计算均值和标准差，而后联合在一起，失去一个六维的特色，函数如下所示：

def extract_color_stats(image):    '''    将图片分成 RGB 三通道，而后别离计算每个通道的均值和标准差，而后返回    :param image:    :return:    '''    (R, G, B) = image.split()    features = [np.mean(R), np.mean(G), np.mean(B), np.std(R), np.std(G), np.std(B)]    return features

而后同样会定义一个models字典，代码一样，这里就不贴出来了，而后图像载入局部的代码如下：

# 加载数据并提取特色print("抽取图像特色中...")imagePaths = paths.list_images(args['dataset'])data = []labels = []# 循环遍历所有的图片数据for imagePath in imagePaths:    # 加载图片，而后计算图片的色彩通道统计信息    image = Image.open(imagePath)    features = extract_color_stats(image)    data.append(features)    # 保留图片的标签信息    label = imagePath.split(os.path.sep)[-2]    labels.append(label)# 对标签进行编码，从字符串变为整数类型le = LabelEncoder()labels = le.fit_transform(labels)# 进行训练集和测试集的划分，80%数据作为训练集，其余20%作为测试集trainX, testX, trainY, testY = train_test_split(data, labels, test_size=0.2)

上述代码就实现加载图片的门路信息，而后顺次遍历，读取图片，提取特色，提取标签信息，保留特色和标签信息，接着编码标签，而后就是划分训练集和测试集。

接着是雷同的训练模型和预测的代码，和后面的分类器一样。完整版代码如下：

# 导入工具库from sklearn.neighbors import KNeighborsClassifierfrom sklearn.naive_bayes import GaussianNBfrom sklearn.linear_model import LogisticRegressionfrom sklearn.svm import SVCfrom sklearn.tree import DecisionTreeClassifierfrom sklearn.ensemble import RandomForestClassifierfrom sklearn.neural_network import MLPClassifierfrom sklearn.preprocessing import LabelEncoderfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import classification_reportfrom PIL import Imagefrom imutils import pathsimport numpy as npimport argparseimport os# 抽取图像特色def extract_color_stats(image):    '''    将图片分成 RGB 三通道，而后别离计算每个通道的均值和标准差，而后返回    :param image:    :return:    '''    (R, G, B) = image.split()    features = [np.mean(R), np.mean(G), np.mean(B), np.std(R), np.std(G), np.std(B)]    return features# 设置参数ap = argparse.ArgumentParser()ap.add_argument("-d", "--dataset", type=str, default="3scenes",                help="path to directory containing the '3scenes' dataset")ap.add_argument("-m", "--model", type=str, default="knn",                help="type of python machine learning model to use")args = vars(ap.parse_args())# 定义一个保留模型的字典，依据 key 来抉择加载哪个模型models = {    "knn": KNeighborsClassifier(n_neighbors=1),    "naive_bayes": GaussianNB(),    "logit": LogisticRegression(solver="lbfgs", multi_class="auto"),    "svm": SVC(kernel="rbf", gamma="auto"),    "decision_tree": DecisionTreeClassifier(),    "random_forest": RandomForestClassifier(n_estimators=100),    "mlp": MLPClassifier()}# 加载数据并提取特色print("抽取图像特色中...")imagePaths = paths.list_images(args['dataset'])data = []labels = []# 循环遍历所有的图片数据for imagePath in imagePaths:    # 加载图片，而后计算图片的色彩通道统计信息    image = Image.open(imagePath)    features = extract_color_stats(image)    data.append(features)    # 保留图片的标签信息    label = imagePath.split(os.path.sep)[-2]    labels.append(label)# 对标签进行编码，从字符串变为整数类型le = LabelEncoder()labels = le.fit_transform(labels)# 进行训练集和测试集的划分，80%数据作为训练集，其余20%作为测试集trainX, testX, trainY, testY = train_test_split(data, labels, random_state=3, test_size=0.2)# print('trainX numbers={}, testX numbers={}'.format(len(trainX), len(testX)))# 训练模型print("[利用 '{}' 模型建模".format(args["model"]))model = models[args["model"]]model.fit(trainX, trainY)# 预测并输入分类后果报告print("模型评估")predictions = model.predict(testX)print(classification_report(testY, predictions, target_names=le.classes_))

实现这两份代码后，咱们就能够开始运行下代码，比照不同算法在两个数据集上的性能。

4.3 不同模型建模比照

(1) KNN

K-Nearest Neighbors分类器最简略的分类算法之一。该算法依赖于特征向量之间的间隔。简略地说，KNN算法通过在k个最靠近的样本中最多的类别来对未知数据点进行分类。对于KNN的具体解说能够浏览ShowMeAI的文章 图解机器学习 | KNN算法及其利用。

这里咱们先运行下image_classifier.py，调用默认的模型knn，看下KNN在iris数据集上的试验后果，如下所示：

$ !python iris_classifier.py --model knn加载数据中...利用 'knn' 模型建模...评估模型成果...              precision    recall  f1-score   support      setosa       1.00      1.00      1.00        10  versicolor       0.90      0.90      0.90        10   virginica       0.90      0.90      0.90        10    accuracy                           0.93        30   macro avg       0.93      0.93      0.93        30weighted avg       0.93      0.93      0.93        30

其中次要是给出了对每个类别的准确率、召回率、F1以及该类别测试集数量，即别离对应precision、recall、f1-score、support。依据最初一行第一列，能够看到KNN获得93%的准确率。

接着是在三场景图片数据集上的试验后果：

$ !python image_classifier.py --model knn抽取图像特色中...利用 'knn' 模型建模...评估模型成果...              precision    recall  f1-score   support       coast       0.84      0.68      0.75       105      forest       0.78      0.77      0.77        78     highway       0.56      0.78      0.65        54   micro avg       0.73      0.73      0.73       237   macro avg       0.72      0.74      0.72       237weighted avg       0.75      0.73      0.73       237

这里KNN获得75%的准确率。

ps：实际上，运行这个算法，不同次数会有不同的后果，其次要起因是因为在划分训练集和测试集的时候，代码没有设置参数random_state，这导致每次运行划分的训练集和测试集的图片都是不同的，所以运行后果也会不雷同！

(2) 奢侈贝叶斯

接着是奢侈贝叶斯算法，对于奢侈贝叶斯算法的具体解说能够浏览ShowMeAI的文章 图解机器学习 | 奢侈贝叶斯算法详解。

别离测试两个数据集，后果如下：

$ !python iris_classifier.py --model naive_bayes加载数据中...利用 'naive_bayes' 模型建模...评估模型成果...              precision    recall  f1-score   support      setosa       1.00      1.00      1.00        15  versicolor       1.00      0.92      0.96        12   virginica       0.92      1.00      0.96        11   micro avg       0.97      0.97      0.97        38   macro avg       0.97      0.97      0.97        38weighted avg       0.98      0.97      0.97        38
$ !python image_classifier.py --model naive_bayes抽取图像特色中...利用 'naive_bayes' 模型建模...评估模型成果...              precision    recall  f1-score   support       coast       0.69      0.40      0.50        88      forest       0.68      0.82      0.74        84     highway       0.61      0.78      0.68        65   micro avg       0.65      0.65      0.65       237   macro avg       0.66      0.67      0.64       237weighted avg       0.66      0.65      0.64       237

同样，奢侈贝叶斯在iris上有98%的准确率，然而在图像数据集上仅有66%的准确率。

那么，咱们是否能够阐明KNN算法比奢侈贝叶斯好呢？当然是不能够的，上述后果只能阐明在三场景图像数据集上，KNN算法优于奢侈贝叶斯算法。
实际上，每种算法都有各自的优缺点和实用场景，不能一概而论地说某种算法任何时候都优于另一种算法，这须要具体问题具体分析。

(3) 逻辑回归

接着是逻辑回归算法，对于逻辑回归算法的具体解说能够浏览ShowMeAI的文章 图解机器学习 | 逻辑回归算法详解。

别离测试两个数据集，后果如下：

$ !python iris_classifier.py --model logit加载数据中...利用 'logit' 模型建模...评估模型成果...              precision    recall  f1-score   support      setosa       1.00      1.00      1.00        15  versicolor       1.00      0.92      0.96        12   virginica       0.92      1.00      0.96        11   micro avg       0.97      0.97      0.97        38   macro avg       0.97      0.97      0.97        38weighted avg       0.98      0.97      0.97        38
$ !python image_classifier.py --model logit抽取图像特色中...利用 'logit' 模型建模...评估模型成果...              precision    recall  f1-score   support       coast       0.67      0.67      0.67        92      forest       0.79      0.82      0.80        82     highway       0.61      0.57      0.59        63   micro avg       0.70      0.70      0.70       237   macro avg       0.69      0.69      0.69       237weighted avg       0.69      0.70      0.69       237

同样，逻辑回归在 iris 上有 98% 的准确率，然而在图像数据集上仅有 69% 的准确率

(4) 反对向量机 SVM

接着是SVM算法，对于SVM算法的具体解说能够浏览ShowMeAI的文章 图解机器学习 | 反对向量机模型详解。

别离测试两个数据集，后果如下：

$ !python iris_classifier.py --model svm加载数据中...利用 'svm' 模型建模...评估模型成果...              precision    recall  f1-score   support      setosa       1.00      1.00      1.00        15  versicolor       1.00      0.92      0.96        12   virginica       0.92      1.00      0.96        11   micro avg       0.97      0.97      0.97        38   macro avg       0.97      0.97      0.97        38weighted avg       0.98      0.97      0.97        38
$ !python image_classifier.py --model svm抽取图像特色中...利用 'svm' 模型建模...评估模型成果...              precision    recall  f1-score   support       coast       0.84      0.76      0.80        92      forest       0.86      0.93      0.89        84     highway       0.78      0.80      0.79        61   micro avg       0.83      0.83      0.83       237   macro avg       0.83      0.83      0.83       237

同样，SVM在iris上有98%的准确率，然而在图像数据集上仅有83%的准确率。

(5) 决策树

接着是决策树算法，对于决策树算法的具体解说能够浏览ShowMeAI的文章 图解机器学习 | 决策树模型详解。

别离测试两个数据集，后果如下：

$ !python iris_classifier.py --model decision_tree加载数据中...利用 'decision_tree' 模型建模...评估模型成果...              precision    recall  f1-score   support      setosa       1.00      1.00      1.00        15  versicolor       0.92      0.92      0.92        12   virginica       0.91      0.91      0.91        11   micro avg       0.95      0.95      0.95        38   macro avg       0.94      0.94      0.94        38weighted avg       0.95      0.95      0.95        38
$ !python image_classifier.py --model decision_tree抽取图像特色中...利用 'decision_tree' 模型建模...评估模型成果...              precision    recall  f1-score   support       coast       0.71      0.74      0.72        85      forest       0.76      0.80      0.78        83     highway       0.77      0.68      0.72        69   micro avg       0.74      0.74      0.74       237   macro avg       0.75      0.74      0.74       237weighted avg       0.74      0.74      0.74       237

同样，决策树在iris上有98%的准确率，然而在图像数据集上仅有74%的准确率。

(6) 随机森林

接着是随机森林算法，对于随机森林算法的具体解说能够浏览ShowMeAI的文章 图解机器学习 | 随机森林分类模型详解。

别离测试两个数据集，后果如下：

$ !python iris_classifier.py --model random_forest加载数据中...利用 'random_forest' 模型建模...评估模型成果...              precision    recall  f1-score   support      setosa       1.00      1.00      1.00        15  versicolor       1.00      0.83      0.91        12   virginica       0.85      1.00      0.92        11   micro avg       0.95      0.95      0.95        38   macro avg       0.95      0.94      0.94        38weighted avg       0.96      0.95      0.95        38
$ !python image_classifier.py --model random_forest加载数据中...利用 'random_forest' 模型建模...评估模型成果...              precision    recall  f1-score   support       coast       0.80      0.83      0.81        84      forest       0.92      0.84      0.88        90     highway       0.77      0.81      0.79        63   micro avg       0.83      0.83      0.83       237   macro avg       0.83      0.83      0.83       237weighted avg       0.84      0.83      0.83       237

同样，随机森林在iris上有96%的准确率，然而在图像数据集上仅有84%的准确率。

留神了，个别如果决策树算法的成果还不错的话，随机森林算法应该也会获得不错甚至更好的后果，这是因为随机森林实际上就是多棵决策树通过集成学习办法组合在一起进行分类预测。

(7) 多层感知机

最初是多层感知机算法，别离测试两个数据集，后果如下：

$ !python iris_classifier.py --model mlp加载数据中...利用 'mlp' 模型建模...评估模型成果...              precision    recall  f1-score   support      setosa       1.00      1.00      1.00        15  versicolor       1.00      0.92      0.96        12   virginica       0.92      1.00      0.96        11   micro avg       0.97      0.97      0.97        38   macro avg       0.97      0.97      0.97        38weighted avg       0.98      0.97      0.97        38
$ !python image_classifier.py --model mlp抽取图像特色中...利用 'mlp' 模型建模...评估模型成果...              precision    recall  f1-score   support       coast       0.72      0.91      0.80        86      forest       0.92      0.89      0.90        79     highway       0.79      0.58      0.67        72   micro avg       0.80      0.80      0.80       237   macro avg       0.81      0.79      0.79       237weighted avg       0.81      0.80      0.80       237

同样，多层感知机在 iris 上有 98% 的准确率，然而在图像数据集上仅有 81% 的准确率.

(8) 神经网络

最初是实现深度学习的算法，也就是nn_iris.py和basic_cnn.py这两份代码。

首先是nn_iris.py的实现，同样首先是导入库和数据的解决：

# 导入工具库from keras.models import Sequentialfrom keras.layers.core import Densefrom keras.optimizers import SGDfrom sklearn.preprocessing import LabelBinarizerfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import classification_reportfrom sklearn.datasets import load_iris# 载入 Iris 数据集，而后进行训练集和测试集的划分，80%数据作为训练集，其余20%作为测试集print("加载数据中...")dataset = load_iris()(trainX, testX, trainY, testY) = train_test_split(dataset.data,                                                  dataset.target, test_size=0.2)# 将标签进行独热向量编码lb = LabelBinarizer()trainY = lb.fit_transform(trainY)testY = lb.transform(testY)

咱们采纳Keras来实现神经网络，而后这里须要将标签进行one-hot编码，即独热向量编码。

接着就是搭建网络模型的构造和训练、预测代码：

# 利用 Keras 定义网络模型model = Sequential()model.add(Dense(3, input_shape=(4,), activation="sigmoid"))model.add(Dense(3, activation="sigmoid"))model.add(Dense(3, activation="softmax"))# 采纳梯度降落训练模型print('训练网络中...')opt = SGD(lr=0.1, momentum=0.9, decay=0.1 / 250)model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=["accuracy"])H = model.fit(trainX, trainY, validation_data=(testX, testY), epochs=250, batch_size=16)# 预测print('评估模型成果')predictions = model.predict(testX, batch_size=16)print(classification_report(testY.argmax(axis=1), predictions.argmax(axis=1), target_names=dataset.target_names))

上述代码构建了3层全连贯层的神经网络，前两层采纳Sigmoid激活函数，而后最初一层是输入层，所以采纳softmax将输入变成概率值。优化算法抉择的随机梯度降落SGD，损失函数是categorical_crossentropy，迭代次数是250次，每一批次的数据量batch_size是16。

完整版代码如下：

# 加载工具库from keras.models import Sequentialfrom keras.layers.core import Densefrom keras.optimizers import SGDfrom sklearn.preprocessing import LabelBinarizerfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import classification_reportfrom sklearn.datasets import load_iris# 载入 Iris 数据集，而后进行训练集和测试集的划分，80%数据作为训练集，其余20%作为测试集print("加载数据中...")dataset = load_iris()(trainX, testX, trainY, testY) = train_test_split(dataset.data,                                                  dataset.target, test_size=0.2)# 将标签进行独热向量编码lb = LabelBinarizer()trainY = lb.fit_transform(trainY)testY = lb.transform(testY)# 利用 Keras 定义网络模型model = Sequential()model.add(Dense(3, input_shape=(4,), activation="sigmoid"))model.add(Dense(3, activation="sigmoid"))model.add(Dense(3, activation="softmax"))# 采纳梯度降落训练模型print('训练网络中...')opt = SGD(lr=0.1, momentum=0.9, decay=0.1 / 250)model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=["accuracy"])H = model.fit(trainX, trainY, validation_data=(testX, testY), epochs=250, batch_size=16)# 预测print('评估模型成果...')predictions = model.predict(testX, batch_size=16)print(classification_report(testY.argmax(axis=1), predictions.argmax(axis=1), target_names=dataset.target_names))

间接运行命令python nn_iris.py，输入的后果如下：

$ python nn_iris.py Using TensorFlow backend.加载数据中...训练网络中...Train on 112 samples, validate on 38 samplesEpoch 1/2502022-02-08 10:28:19.104933: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 AVX512F FMA112/112 [==============================] - 0s 2ms/step - loss: 1.1454 - acc: 0.3214 - val_loss: 1.1867 - val_acc: 0.2368Epoch 2/250112/112 [==============================] - 0s 48us/step - loss: 1.0828 - acc: 0.3929 - val_loss: 1.2132 - val_acc: 0.5000Epoch 3/250112/112 [==============================] - 0s 47us/step - loss: 1.0491 - acc: 0.5268 - val_loss: 1.0593 - val_acc: 0.4737...Epoch 248/250112/112 [==============================] - 0s 46us/step - loss: 0.1319 - acc: 0.9554 - val_loss: 0.0407 - val_acc: 1.0000Epoch 249/250112/112 [==============================] - 0s 46us/step - loss: 0.1024 - acc: 0.9643 - val_loss: 0.1595 - val_acc: 0.8947Epoch 250/250112/112 [==============================] - 0s 47us/step - loss: 0.0795 - acc: 0.9821 - val_loss: 0.0335 - val_acc: 1.0000评估模型成果...             precision    recall  f1-score   support     setosa       1.00      1.00      1.00         9 versicolor       1.00      1.00      1.00        10  virginica       1.00      1.00      1.00        19avg / total       1.00      1.00      1.00        38

这里失去的是100%的准确率。

(9) CNN

最初咱们要利用卷积神经网络，咱们实现一下basic_cnn.py代码。

同样首先是导入必须的库函数：

# 导入工具库from keras.models import Sequentialfrom keras.layers.convolutional import Conv2Dfrom keras.layers.convolutional import MaxPooling2Dfrom keras.layers.core import Activationfrom keras.layers.core import Flattenfrom keras.layers.core import Densefrom keras.optimizers import Adamfrom sklearn.preprocessing import LabelBinarizerfrom sklearn.model_selection import train_test_splitfrom sklearn.metrics import classification_reportfrom PIL import Imagefrom imutils import pathsimport numpy as npimport argparseimport os# 配置参数ap = argparse.ArgumentParser()ap.add_argument("-d", "--dataset", type=str, default="3scenes",                help="path to directory containing the '3scenes' dataset")args = vars(ap.parse_args())

同样是要导入Keras来建设CNN的网络模型，另外因为是解决图像数据，所以PIL、imutils也是要导入的。

而后是加载数据和划分训练集和测试集，对于加载数据，这里间接采纳原始图像像素数据，只须要对图像数据做对立尺寸的调整，这里是对立调整为32×32，并做归一化到[0,1]的范畴。

# 加载数据并提取特色print("抽取图像特色中...")imagePaths = paths.list_images(args['dataset'])data = []labels = []# 循环遍历所有的图片数据for imagePath in imagePaths:    # 加载图片，而后调整成 32×32 大小，并做归一化到 [0,1]    image = Image.open(imagePath)    image = np.array(image.resize((32, 32))) / 255.0    data.append(image)    # 保留图片的标签信息    label = imagePath.split(os.path.sep)[-2]    labels.append(label)# 对标签编码，从字符串变为整型lb = LabelBinarizer()labels = lb.fit_transform(labels)# 划分训练集和测试集(trainX, testX, trainY, testY) = train_test_split(np.array(data), np.array(labels), test_size=0.25)

接着定义了一个4层的CNN网络结构，蕴含3层卷积层和最初一层输入层，优化算法采纳的是Adam而不是SGD。代码如下所示：

# 定义 CNN 网络模型构造model = Sequential()model.add(Conv2D(8, (3, 3), padding="same", input_shape=(32, 32, 3)))model.add(Activation("relu"))model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))model.add(Conv2D(16, (3, 3), padding="same"))model.add(Activation("relu"))model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))model.add(Conv2D(32, (3, 3), padding="same"))model.add(Activation("relu"))model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))model.add(Flatten())model.add(Dense(3))model.add(Activation("softmax"))# 训练模型print("训练网络中...")opt = Adam(lr=1e-3, decay=1e-3 / 50)model.compile(loss="categorical_crossentropy", optimizer=opt, metrics=["accuracy"])H = model.fit(trainX, trainY, validation_data=(testX, testY),              epochs=50, batch_size=32)# 预测print("评估模型成果...")predictions = model.predict(testX, batch_size=32)print(classification_report(testY.argmax(axis=1),                            predictions.argmax(axis=1), target_names=lb.classes_))

运行命令python basic_cnn.py，输入后果如下：

$ python basic_cnn.py Using TensorFlow backend.加载图像数据...训练网络中...Train on 711 samples, validate on 237 samplesEpoch 1/50711/711 [==============================] - 0s 629us/step - loss: 1.0647 - acc: 0.4726 - val_loss: 0.9920 - val_acc: 0.5359Epoch 2/50711/711 [==============================] - 0s 313us/step - loss: 0.9200 - acc: 0.6188 - val_loss: 0.7778 - val_acc: 0.6624Epoch 3/50711/711 [==============================] - 0s 308us/step - loss: 0.6775 - acc: 0.7229 - val_loss: 0.5310 - val_acc: 0.7553...Epoch 48/50711/711 [==============================] - 0s 307us/step - loss: 0.0627 - acc: 0.9887 - val_loss: 0.2426 - val_acc: 0.9283Epoch 49/50711/711 [==============================] - 0s 310us/step - loss: 0.0608 - acc: 0.9873 - val_loss: 0.2236 - val_acc: 0.9325Epoch 50/50711/711 [==============================] - 0s 307us/step - loss: 0.0587 - acc: 0.9887 - val_loss: 0.2525 - val_acc: 0.9114评估模型成果...             precision    recall  f1-score   support      coast       0.85      0.96      0.90        85     forest       0.99      0.94      0.97        88    highway       0.91      0.80      0.85        64avg / total       0.92      0.91      0.91       237

CNN的准确率是达到92%，它是优于之前的几种机器学习算法的后果。

5.小结

这篇简略的机器学习教程文章中，咱们调用现有的库来利用对应的机器学习算法，解决了2个简略的场景问题。通过这份简略的入门教程，心愿大家理解到：

(1) 没有任何一种算法是完满的，能够齐全实用所有的场景，即使是目前很热门的深度学习办法，也存在它的局限性，所以应该具体问题具体分析！

(2) 经典的5步机器学习操作流程：

  • 问题形象与了解
  • 数据筹备与解决(预处理、特征提取、特色工程等)
  • 各种机器学习算法
  • 试验后果剖析与比照
  • 模型抉择与调优

参考资料

  • AI建模工具速查 | Scikit-Learn使用指南
  • AI建模工具速查 | Keras使用指南
  • 图解机器学习算法 | 从入门到精通系列

ShowMeAI系列教程举荐

  • 图解Python编程：从入门到精通系列教程
  • 图解数据分析：从入门到精通系列教程
  • 图解AI数学根底：从入门到精通系列教程
  • 图解大数据技术：从入门到精通系列教程
  • 图解机器学习算法：从入门到精通系列教程
  • 机器学习实战：手把手教你玩转机器学习系列

相干文章举荐

  • Python机器学习算法利用实际
  • SKLearn入门与简略利用案例
  • SKLearn最全利用指南
  • XGBoost建模利用详解
  • LightGBM建模利用详解
  • Python机器学习综合我的项目-电商销量预估
  • Python机器学习综合我的项目-电商销量预估<进阶计划>
  • 机器学习特色工程最全解读
  • 自动化特色工程工具Featuretools利用
  • AutoML自动化机器学习建模