加入收藏 | 设为首页 |

qq音乐下载-初学者的机器学习入门实战教程

海外新闻 时间: 浏览:293 次

原文链接:https://www.pyimagesearch.com/2019/01/14/machine-learning-in-python/

作者:Adrian Roseb国网电子商务平台rock

这是一篇手把手教你运用 Python 完结机器学习算法,并在数值型数据和图画数据集上运转模型的入门教程,当你看完本文后,你应当能够开端你的机器学习之旅了!

本教程会选用下述两个库来完结机器学习算法:

  • scikit-learn
  • Keras

此外,你还将学习到:

  • 评价你的问题
  • 预备数据(原始数据、特征提取、特征工程等等)
  • 查看各种机器学习算法
  • 查验试验成果
  • 深化了解功能最好的算法

在本文会用到的机器学习算法包括:

  1. KNN
  2. 朴素贝叶斯
  3. 逻辑回归
  4. SVM
  5. 决策树
  6. 随机森林
  7. 感知机
  8. 多层前向网络
  9. CNNs

装置必备的 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: http://people.csail.mit.edu/torralba/code/spatialenvelope/

运用 Python 完结机器学习的进程

不管什么时分完结机器学习算法,引荐选用如下流程来开端:

  • 评价你的问题
  • 预备数据(原始数据、特征提取、特征工程等等)
  • 查看各种机器学习算法
  • 查验试验成果
  • 深化了解功能最好的算法

这个流程会跟着你机器学习方面的经历的堆集而改进和优化,但关于初学者,这是我主张入门机器学习时选用的流程。

所以,现在开端吧!榜首步,便是评价咱们的问题,问一下自己:

  • 数据集是哪种类型?数值型,类别型仍是图画?
  • 模型的最终方针是什么?
  • 怎么界说和衡量“准确率”呢?
  • 以现在本身的机器学习常识来看,哪些算法在处理这类问题上作用很好?

最终一个问题非常重要,跟着你运用 Python 完结机器学习的次数的添加,你也会随之获得更多的经历。依据之前的经历,你或许知道有一种算法的功能还不错。

因而,接着便是预备数据,也便是数据预处理以及特征工程了。

一般来说,这一步,包括了从硬盘中载入数据,查看数据,然后决议是否需求做特征提取或许特征工程。

特征提取便是运用某种算法经过某种办法来量化数据的进程。比方,关于图画数据,咱们能够选用核算直方图的办法来核算图画中像素强度的散布,经过这种办法,咱们就得到描绘图画色彩的特征。

特征工程则是将原始输入数据转换成一个更好描绘潜在问题的特征表明的进程。当然特征工程是一项更先进的技能,这儿主张在对机器学习有了必定经历后再选用这种办法处理数据。

第三步,便是查看各种机器学习算法,也便是完结一系列机器学习算法,并运用在数据集上。

这儿,你的工具箱应当包括以下几种不同类型的机器学习算法:

  1. 线性模型(比方,逻辑回归,线性 SVM)
  2. 非线性模型(比方 RBF SVM,梯度下降分类器)
  3. 树和依据集成的模型(比方 决策树和随机森林)
  4. 神经网络(比方 多层感知机,卷积神经网络)

应当挑选比较鲁棒(安稳)的一系列机器学习模型来评价问题,由于咱们的方针便是判别哪种算法在当时问题的功能很好,而哪些算法很糟糕。

决议好要选用的模型后,接下来便是操练模型并在数据集上测验,调查每个模型在数据集上的功能成果。

在屡次试验后,你或许便是有一种“第六感”,知道哪种算法更适用于哪种数据集。

比方,你会发现:

  • 关于有许多特征的数据集,随机森林算法的作用很不错;
  • 而逻辑qq音乐下载-初学者的机器学习入门实战教程回归算法能够很好处理高维度的稀少数据;
  • 关于图画数据,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

代码和数据集文件能够在大众号后台,也便是大众号会话界面回复 『py_ml』获取!

首要是完结 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 imqq音乐下载-初学者的机器学习入门实战教程port 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,调用默许的模型 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.metriqq音乐下载-初学者的机器学习入门实战教程cs 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 skleaqq音乐下载-初学者的机器学习入门实战教程rn.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 也是要导入的。

然后是加载数据和区分操练集和测验集,关于加载数据,这儿直接选用原始图画像素数据,只需求对图画数据做一致尺度的调整,这儿是一致调整为 3232,并做归一化到 [0,1] 的规模。

# 加载数据并提取特征
print("[INFO] extracting image features...")
imagePaths = paths.list_images(args['dataset'])
data = []
labels = []
# 循环遍历一切的图片数据
for imagePath in imagePaths:
# 加载图片,然后调整成 3232 巨细,并做归一化到 [0,1]
image = Image.open(imagePath)
image = np.array(image.resize((32, 32))) / 255.0
data.append(image)
# 保存图片的标签信息
label = imagePath.split(os.paqq音乐下载-初学者的机器学习入门实战教程th.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:
# 加载图片,然后调整成 3232 巨细,并做归一化到 [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.pqq音乐下载-初学者的机器学习入门实战教程y, 输出成果如下:

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


小结

最终,这仅仅是一份对机器学习彻底是初学者的教程,其实便是简略调用现有的库来完结对应的机器学习算法,让初学者简略感触下怎么运用机器学习算法,正好像在学习编程言语的时分,对着书本的代码比方敲起来,然后运转代码,看看自己写出来的程序的运转成果。

经过这份简略的入门教程,你应该理解的是:

  1. 没有任何一种算法是完美的,能够彻底适用一切的场景,即便是现在很抢手的深度学习办法,也存在它的局限性,所以应该详细问题详细分析
  2. 记住最初引荐的 5 步机器学习操作流程,这儿再次温习一遍:
  • 评价你的问题
  • 预备数据(原始数据、特征提取、特征工程等等)
  • 查看各种机器学习算法
  • 查验试验成果
  • 深化了解功能最好的算法
  1. 最终一点,是我运转算法成果,和原文作者的成果会不相同,这实际上便是每次采样数据,区分操练集和测验集不相同的原因!这其实也阐明晰数据非常重要,关于机器学习来说,好的数据很重要

接着,依据这份教程,你能够持续进一步了解每种机器学习算法,了解每种算法的基本原理和完结,测验自己手动完结,而不是简略调用现有的库,这样愈加能加深形象,这儿引荐《机器学习实战》,经典的机器学习算法都有介绍,并且都会带你一步步完结算法!

最终,极力引荐我们去阅览下原文作者的博客,原文作者也是一个大神,他的博客地址如下:

https://www.pyimagesearch.com/

他的博客包括了 Opencv、Python、机器学习和深度学习方面的教程和文章,并且作者喜爱经过实战学习,所以许多文章都是经过一些实战操练来学习某个常识点或许某个算法,正好像本文经过完结这几种常见的机器学习算法在两个不同类型数据集上的实战来带领初学者入门机器学习。