利用 Python 完成机械进修算法，并正在数值型数据战图象数据散上运转模子的进门教程。
装置必备的 Python 机械进修库
开端本教程前，需求先确保装置了一下的 Python 库：
Numpy：用于 Python 的数值处置
PIL：一个简朴的图象处置库
scikit-learn：包罗多种机械进修算法(留意需求接纳 0.2+ 的版本，以是下圆装置号令需求减上 --upgrade )
Kears 战 TensorFlow：用于深度进修。本教程能够仅接纳 CPU 版本的 TensorFlow
OpenCV：本教程其实不会接纳到 OpenCV，但 imutils 库依靠它；
imutils ：做者的图象处置/计较机视觉库
装置号令以下，保举接纳假造情况(好比操纵 anaconda 创立一个新的情况)：
$ 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
数据散
本教程会用到两个数据散去协助更好的理解每一个机械进修算法的机能。
第一个数据散是 Iris(鸢尾花) 数据散。那个数据散的职位，相称于您刚开端进修一门编程言语时，敲下的 “Hello，World！”
那个数据散是一个数值型的数据，以下图所示，实在便是一个表格数据，每止代表一个样本，然后每列便是差别的属性。那个数据散次要是搜集了三种差别的鸢尾花的数据，别离为：
Iris Setosa
Iris Versicolor
Iris Virginica
对应图中最初一列 Class label，然后另有四种属性，别离是：
Sepal length--萼片少度
Sepal width--萼片宽度
Petal length--花瓣少度
Petal width--花瓣宽度
那个数据散多是最简朴的机械进修数据散之一了，凡是是用于教诲法式员战工程师的机械进修战形式辨认根底的数据散。
关于该数据散，我们的目的便是按照给定的四个属性，锻炼一个机械进修模子去准确分类每一个样本的种别。
需求留意的是，此中有一个种别战别的两个种别是线性可分的，但那两个种别之间却并不是线性可分，以是我们需求接纳一个非线性模子去对它们停止分类。固然了，正在理想糊口中，接纳非线性模子的机械进修算法长短经常睹的。
第两个数据散是一个三场景的图象数据散。那是协助初教者进修怎样处置图象数据，而且哪一种算法正在那两种数据散上机能最劣。
下图是那个三场景数据散的部门图片例子，它包罗丛林、下速公路战海岸线三种场景，统共是 948 张图片，每一个种别的详细图片数目以下：
Coast: 360
Forest: 328
Highway: 260
那个三场景数据散是采样于一个八场景数据集合，做者是 Oliva 战 Torralba 的 2001 年的一篇论文，Modeling the shape of the scene: a holistic representation of the spatial envelope
操纵 Python 完成机械进修的步调
不管甚么时分完成机械进修算法，保举接纳以下流程去开端：
评价您的成绩
筹办数据(本初数据、特性提与、特性工程等等)
查抄各类机械进修算法
查验尝试成果
深化理解机能最好的算法
那个流程会跟着您机械进修圆里的经历的积聚而改进战劣化，但关于初教者，那是我倡议进门机械进修时接纳的流程。
以是，如今开端吧！第一步，便是评价我们的成绩，问一下本人：
数据散是哪一种范例？数值型，种别型仍是图象？
模子的终极目的是甚么？
怎样界说战权衡“精确率”呢？
以今朝本身的机械进修常识去看，哪些算法正在处置那类成绩上结果很好？
最初一个成绩十分主要，跟着您利用 Python 完成机械进修的次数的增长，您也会随之得到更多的经历。按照之前的经历，您能够明白有一种算法的机能借没有错。
因而，接着便是筹办数据，也便是数据预处置和特性工程了。
普通来讲，那一步，包罗了从硬盘中载进数据，查抄数据，然后决议能否需求做特性提与大概特性工程。
特性提与便是使用某种算法经由过程某种方法去量化数据的历程。好比，关于图象数据，我们能够接纳计较曲圆图的办法去统计图象中像素强度的散布，经由过程这类方法，我们便获得形貌图象色彩的特性。
而特性工程则是将本初输进数据转换成一个更好形貌潜伏成绩的特性暗示的历程。固然特性工程是一项更先辈的手艺，那里倡议正在对机械进修有了必然经历后再接纳这类办法处置数据。
第三步，便是查抄各类机械进修算法，也便是完成一系列机械进修算法，并使用正在数据散上。
那里，您的东西箱该当包罗以下几种差别范例的机械进修算法：
1.线性模子(好比，逻辑回回，线性 SVM)
2.非线性模子(好比 RBF SVM，梯度降落分类器)
3.树战基于散成的模子(好比 决议计划树战随机丛林)
4.神经收集(好比 多层感知机，卷积神经收集)
该当挑选比力鲁棒(不变)的一系列机械进修模子去评价成绩，由于我们的目的便是判定哪一种算法正在当前成绩的机能很好，而哪些算法很蹩脚。
决议好要接纳的模子后，接下去便是锻炼模子并正在数据散上测试，察看每一个模子正在数据散上的机能成果。
正在屡次尝试后，您能够便是有一种“第六感”，明白哪一种算法更合用于哪一种数据散。好比，您会发明：
关于有许多特性的数据散，随机丛林算法的结果很没有错；
而逻辑回回算法能够很益处理下维度的稠密数据；
关于图象数据，CNNs 的结果十分好。
而以上的经历得到，固然便需求您多入手，多停止真战去深化理解差别的机械进修算法了！
接下去便开端敲代码去完成机械进修算法，并正在上述两个数据散长进止测试。本教程的代码文件目次以下，包罗四份代码文件战一个 3scenes文件夹，该文件夹便是三场景数据散，而 Iris 数据散间接接纳 scikit-learn 库载进便可。
├── 3scenes
│ ├── coast [360 entries]
│ ├── forest [328 entries]
│ └── highway [260 entries]
├── classify_iris.py
├── classify_images.py
├── nn_iris.py
└── basic_cnn.py
起首是完成 classify_iris.py，那份代码是接纳机械进修算法去对 Iris 数据散停止分类。
起首导进需求的库：
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.datasets import load_iris
import 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()
}
能够看到正在 sklearn 库中便散成了我们将要完成的几种机械进修算法的代码，包罗：
KNN
朴实贝叶斯
逻辑回回
SVM
决议计划树
随机丛林
感知机
我们间接挪用 sklearn 中响应的函数去完成对应的算法便可，好比关于 knn算法，间接挪用 sklearn.neighbors 中的 KNeighborsClassifier() 便可，只需求设置参数 n_neighbors ，即近来邻的个数。
那里间接用一个 models 的字典去保留差别模子的初初化，然后按照参数 --model 去挪用对应的模子，好比号令输进 python classify_irs.py --model knn 便是挪用 knn 算法模子。
接着便是载进数据部门：
print("[INFO] loading data...")
dataset = load_iris()
(trainX, testX, trainY, testY) = train_test_split(dataset.data,
dataset.target, random_state=3, test_size=0.25)
那里间接挪用 sklearn.datasets 中的 load_iris() 载进数据，然后接纳 train_test_split 去分别锻炼散战数据散，那里是 75% 数据做为锻炼散，25% 做为测试散。
最初便是锻炼模子战猜测部门：
# 锻炼模子
print("[INFO] using '{}' model".format(args["model"]))
model = models[args["model"]]
model.fit(trainX, trainY)
# 猜测并输出一份分类成果陈述
print("[INFO] evaluating")
predictions = model.predict(testX)
print(classification_report(testY, predictions, target_names=dataset.target_names))
完好版代码代码以下：
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.datasets import load_iris
import 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()
}
# 载进 Iris 数据散，然落后止锻炼散战测试散的分别，75%数据做为锻炼散，其他25%做为测试散
print("[INFO] loading data...")
dataset = load_iris()
(trainX, testX, trainY, testY) = train_test_split(dataset.data, dataset.target, random_state=3, test_size=0.25)
# 锻炼模子
print("[INFO] using '{}' model".format(args["model"]))
model = models[args["model"]]
model.fit(trainX, trainY)
# 猜测并输出一份分类成果陈述
print("[INFO] evaluating")
predictions = model.predict(testX)
print(classification_report(testY, predictions, target_names=dataset.target_names))
接着便是接纳三场景图象数据散的分类猜测代码 classify_images.py ，跟 classify_iris.py 的代码实际上是比力类似的，起首导进库部门，增长以下几止代码：
from sklearn.preprocessing import LabelEncoder
from PIL import Image
from imutils import paths
import numpy as np
import os
此中 LabelEncoder 是为了将标签从字符串编码为整型，然后其他几项皆是处置图象相干。
关于图象数据，假如间接接纳本初像素疑息输进模子中，年夜部门的机械进修算法结果皆很不睬念，以是那里接纳特性提与办法，次要是统计图象色彩通讲的均值战尺度好疑息，统共是 RGB 3个通讲，每一个通讲各计较均值战尺度好，然后分离正在一同，获得一个六维的特性，函数以下所示：
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("[INFO] extracting image features...")
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)
# 停止锻炼散战测试散的分别，75%数据做为锻炼散，其他25%做为测试散
(trainX, testX, trainY, testY) = train_test_split(data, labels, test_size=0.25)
上述代码便完成从硬盘中减载图片的途径疑息，然后顺次遍历，读与图片，提与特性，提与标签疑息，保留特性战标签疑息，接着编码标签，然后便是分别锻炼散战测试散。
接着是不异的锻炼模子战猜测的代码，一样出有任何改动，那里便没有枚举出去了。
完好版以下：
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from PIL import Image
from imutils import paths
import numpy as np
import argparse
import 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("[INFO] extracting image features...")
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)
# 停止锻炼散战测试散的分别，75%数据做为锻炼散，其他25%做为测试散
(trainX, testX, trainY, testY) = train_test_split(data, labels, random_state=3, test_size=0.25)
# print('trainX numbers={}, testX numbers={}'.format(len(trainX), len(testX)))
# 锻炼模子
print("[INFO] using '{}' model".format(args["model"]))
model = models[args["model"]]
model.fit(trainX, trainY)
# 猜测并输出分类成果陈述
print("[INFO] evaluating...")
predictions = model.predict(testX)
print(classification_report(testY, predictions, target_names=le.classes_))
完成那两份代码后，我们就能够开端运转下代码，比照差别算法正在两个数据散上的机能。
KNN
那里我们先运转下 classify_irs.py，挪用默许的模子 knn ，看下 KNN 正在 Iris 数据散上的尝试成果，以下所示：
此中次要是给出了对每一个种别的准确率、召回率、F1 和该种别测试散数目，即别离对应 precision, recall, f1-score, support 。按照最初一止第一列，能够看到 KNN 获得 95% 的精确率。
接着是正在三场景图片数据散上的尝试成果:
那里 KNN 获得 72% 的精确率。
(ps：实践上，运转那个算法，差别次数会有差别的成果，本文做者给出的是 75%，其次要缘故原由是由于正在分别锻炼散战测试散的时分，代码出有设置参数 random_state，那招致每次运转分别的锻炼散战测试散的图片皆是差别的，以是运转成果也会没有不异！)
朴实贝叶斯
接着是朴实贝叶斯算法，别离测试两个数据散，成果以下：
一样，朴实贝叶斯正在 Iris 上有 98% 的精确率，可是正在图象数据散上唯一 63% 的精确率。
那末，我们能否能够阐明 KNN 算法比朴实贝叶斯好呢？
固然是不成以的，上述成果只能阐明正在三场景图象数据散上，KNN 算法劣于朴实贝叶斯算法。
实践上，每种算法皆有各自的劣缺陷战合用场景，不克不及混为一谈天道某种算法任什么时候候皆劣于另外一种算法，那需求详细成绩详细阐发。
逻辑回回
接着是逻辑回回算法，别离测试两个数据散，成果以下：
一样，逻辑回回正在 Iris 上有 98% 的精确率，可是正在图象数据散上唯一 77%的精确率(比照本文做者的逻辑回回精确率是 69%)
撑持背量机 SVM
接着是 SVM 算法，别离测试两个数据散，成果以下：
一样，SVM 正在 Iris 上有 98% 的精确率，可是正在图象数据散上唯一 76% 的精确率(比照本文做者的精确率是 83%，次要是发明种别 coast 不同有些年夜)
决议计划树
接着是决议计划树算法，别离测试两个数据散，成果以下：
一样，决议计划树正在 Iris 上有 98% 的精确率，可是正在图象数据散上唯一 71% 的精确率(比照本文做者的决议计划树精确率是 74%)
随机丛林
接着是随机丛林算法，别离测试两个数据散，成果以下：
一样，随机丛林正在 Iris 上有 96% 的精确率，可是正在图象数据散上唯一 77%的精确率(比照本文做者的决议计划树精确率是 84%)
留意了，普通假如决议计划树算法的结果借没有错的话，随机丛林算法该当也会获得没有错以至更好的成果，那是由于随机丛林实践上便是多棵决议计划树经由过程散成进修办法组开正在一同停止分类猜测。
多层感知机
最初是多层感知机算法，别离测试两个数据散，成果以下：
一样，多层感知机正在 Iris 上有 98% 的精确率，可是正在图象数据散上唯一 79% 的精确率(比照本文做者的决议计划树精确率是 81%).
深度进修和深度神经收集
神经收集
最初是完成深度进修的算法，也便是 nn_iris.py 战 basic_cnn.py 那两份代码。
(那里需求留意 TensorFlow 战 Keras 的版本成绩，我接纳的是 TF=1.2 战 Keras=2.1.5)
起首是 nn_iris.py 的完成，一样起首是导进库战数据的处置：
from keras.models import Sequential
from keras.layers.core import Dense
from keras.optimizers import SGD
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.datasets import load_iris
# 载进 Iris 数据散，然落后止锻炼散战测试散的分别，75%数据做为锻炼散，其他25%做为测试散
print("[INFO] loading data...")
dataset = load_iris()
(trainX, testX, trainY, testY) = train_test_split(dataset.data,
dataset.target, test_size=0.25)
# 将标签停止 one-hot 编码
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('[INFO] training network...')
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('[INFO] evaluating network...')
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 Sequential
from keras.layers.core import Dense
from keras.optimizers import SGD
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from sklearn.datasets import load_iris
# 载进 Iris 数据散，然落后止锻炼散战测试散的分别，75%数据做为锻炼散，其他25%做为测试散
print("[INFO] loading data...")
dataset = load_iris()
(trainX, testX, trainY, testY) = train_test_split(dataset.data,
dataset.target, test_size=0.25)
# 将标签停止 one-hot 编码
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('[INFO] training network...')
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('[INFO] evaluating network...')
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， 输出的成果以下：
那里获得的是 100% 的精确率，战本文的一样。固然实践上本文给出的成果以下图所示，能够看到实在种别数目上是没有不异的。
CNN
最初便是完成 basic_cnn.py 那份代码了。
一样起首是导进必需的库函数：
from keras.models import Sequential
from keras.layers.convolutional import Conv2d
from keras.layers.convolutional import MaxPooling2D
from keras.layers.core import Activation
from keras.layers.core import Flatten
from keras.layers.core import Dense
from keras.optimizers import Adam
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from PIL import Image
from imutils import paths
import numpy as np
import argparse
import 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("[INFO] extracting image features...")
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("[INFO] training network...")
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("[INFO] evaluating network...")
predictions = model.predict(testX, batch_size=32)
print(classification_report(testY.argmax(axis=1),
predictions.argmax(axis=1), target_names=lb.classes_))
完好版以下：
from keras.models import Sequential
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.layers.core import Activation
from keras.layers.core import Flatten
from keras.layers.core import Dense
from keras.optimizers import Adam
from sklearn.preprocessing import LabelBinarizer
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
from PIL import Image
from imutils import paths
import numpy as np
import argparse
import 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())
# 减载数据并提与特性
print("[INFO] extracting image features...")
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)
# 界说 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("[INFO] training network...")
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("[INFO] evaluating network...")
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， 输出成果以下：
CNN 的精确率是到达 90%，它是劣于之前的几种机械进修算法的成果。 |
