python机器学习ch02
本文共 15227 字，大约阅读时间需要 50 分钟。
last madified by xiaoyao
Python 机器学习
Chapter 2 - Training Machine Learning Algorithms for Classification
训练机器学习算法从而实现分类
Note that the optional watermark extension is a small IPython notebook plugin that I developed to make the code reproducible. You can just skip the following line(s).
%load_ext watermark%watermark -a "Sebastian Raschka" -u -d -p numpy,pandas,matplotlib
Sebastian Raschka last updated: 2019-12-04 numpy 1.17.4pandas 0.25.3matplotlib 3.1.0
The use of watermark is optional. You can install this Jupyter extension via
conda install watermark -c conda-forge
or
pip install watermark
For more information, please see: https://github.com/rasbt/watermark.
Overview
from IPython.display import Image
Artificial neurons - a brief glimpse into the early history of machine learning
人工神经元，简要回顾一下机器学习的早期历史
Image(filename='./images/02_01.png', width=500)
%pwd
The formal definition of an artificial neuron
一个人工神经元的正式定义
Image(filename='./images/02_02.png', width=500)
The perceptron learning rule
感知机的学习规则
Image(filename='./images/02_03.png', width=600)
Image(filename='./images/02_04.png', width=600)
Implementing a perceptron learning algorithm in Python
使用python实现一个感知机学习算法
An object-oriented perceptron API
一个面向对象的感知器API
import numpy as npclass Perceptron(object): """Perceptron classifier. Parameters ------------ eta : float Learning rate (between 0.0 and 1.0) n_iter : int Passes over the training dataset. random_state : int Random number generator seed for random weight initialization. Attributes ----------- w_ : 1d-array Weights after fitting. errors_ : list Number of misclassifications (updates) in each epoch. """ def __init__(self, eta=0.01, n_iter=50, random_state=1): self.eta = eta self.n_iter = n_iter self.random_state = random_state def fit(self, X, y): """Fit training data. Parameters ---------- X : {array-like}, shape = [n_examples, n_features] Training vectors, where n_examples is the number of examples and n_features is the number of features. y : array-like, shape = [n_examples] Target values. Returns ------- self : object """ rgen = np.random.RandomState(self.random_state) self.w_ = rgen.normal(loc=0.0, scale=0.01, size=1 + X.shape[1]) self.errors_ = [] for _ in range(self.n_iter): errors = 0 for xi, target in zip(X, y): update = self.eta * (target - self.predict(xi)) self.w_[1:] += update * xi self.w_[0] += update errors += int(update != 0.0) self.errors_.append(errors) return self def net_input(self, X): """Calculate net input""" return np.dot(X, self.w_[1:]) + self.w_[0] def predict(self, X): """Return class label after unit step""" return np.where(self.net_input(X) >= 0.0, 1, -1) v1 = np.array([1, 2, 3])v2 = 0.5 * v1np.arccos(v1.dot(v2) / (np.linalg.norm(v1) * np.linalg.norm(v2)))
0.0
Training a perceptron model on the Iris dataset
使用鸢尾花数据集训练一个感知机模型
…
Reading-in the Iris data
读取Iris数据集
import osimport pandas as pds = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'print('URL:', s)df = pd.read_csv(s, header=None, encoding='utf-8')df.tail() URL: https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data
| 0 | 1 | 2 | 3 | 4 | |
|---|---|---|---|---|---|
| 145 | 6.7 | 3.0 | 5.2 | 2.3 | Iris-virginica |
| 146 | 6.3 | 2.5 | 5.0 | 1.9 | Iris-virginica |
| 147 | 6.5 | 3.0 | 5.2 | 2.0 | Iris-virginica |
| 148 | 6.2 | 3.4 | 5.4 | 2.3 | Iris-virginica |
| 149 | 5.9 | 3.0 | 5.1 | 1.8 | Iris-virginica |
Note:
You can find a copy of the Iris dataset (and all other datasets used in this book) in the code bundle of this book, which you can use if you are working offline or the UCI server at https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data is temporarily unavailable. For instance, to load the Iris dataset from a local directory, you can replace the line
df = pd.read_csv('https://archive.ics.uci.edu/ml/' 'machine-learning-databases/iris/iris.data', header=None) by
df = pd.read_csv('your/local/path/to/iris.data', header=None) df = pd.read_csv('iris.data', header=None, encoding='utf-8')df.tail() | 0 | 1 | 2 | 3 | 4 | |
|---|---|---|---|---|---|
| 145 | 6.7 | 3.0 | 5.2 | 2.3 | Iris-virginica |
| 146 | 6.3 | 2.5 | 5.0 | 1.9 | Iris-virginica |
| 147 | 6.5 | 3.0 | 5.2 | 2.0 | Iris-virginica |
| 148 | 6.2 | 3.4 | 5.4 | 2.3 | Iris-virginica |
| 149 | 5.9 | 3.0 | 5.1 | 1.8 | Iris-virginica |
Plotting the Iris data
绘制Iris 数据的图示示例
提取前100类别标签的数据，其中Iris-setosa和Iris-versicolor各50.类似的从这100条样本中提取第一（sepal length）和第三（petal length)列所对应的特征列，然后将其分派到特征矩阵中，这样一来我们就可以通过二维的散点图来进行可视化。
%matplotlib inlineimport matplotlib.pyplot as pltimport numpy as np# select setosa and versicolory = df.iloc[0:100, 4].valuesy = np.where(y == 'Iris-setosa', -1, 1)# extract sepal length and petal lengthX = df.iloc[0:100, [0, 2]].values# plot dataplt.scatter(X[:50, 0], X[:50, 1], color='red', marker='o', label='setosa')plt.scatter(X[50:100, 0], X[50:100, 1], color='blue', marker='x', label='versicolor')plt.xlabel('sepal length [cm]')plt.ylabel('petal length [cm]')plt.legend(loc='upper left')# plt.savefig('images/02_06.png', dpi=300)plt.show() 
Training the perceptron model
训练感知机模型
ppn = Perceptron(eta=0.1, n_iter=10)ppn.fit(X, y)plt.plot(range(1, len(ppn.errors_) + 1), ppn.errors_, marker='o')plt.xlabel('Epochs')plt.ylabel('Number of updates')# plt.savefig('images/02_07.png', dpi=300)plt.show() 
A function for plotting decision regions
一个绘制决策决策区域的函数
首先通过ListedColormap来创建一系列的颜色和标记同时创建一个调色板colormap,然后我们确定特征的最小值和最大值，通过numpy meshgris 函数，并使用这些特征向量创建一对网格阵列xx1，xx2,由于我们在两个特征维度上训练了感知器分类器，因此我们需要展平栅格阵列并创建一个矩阵，该矩阵的列数与Iris训练子集相同，因此我们可以使用predict 方法来预测类别标签z,
from matplotlib.colors import ListedColormapdef plot_decision_regions(X, y, classifier, resolution=0.02): # setup marker generator and color map markers = ('s', 'x', 'o', '^', 'v') colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan') cmap = ListedColormap(colors[:len(np.unique(y))]) # plot the decision surface # 分别使用样本的两个特征值创建图像和横轴和纵轴 x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1 x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1 xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), np.arange(x2_min, x2_max, resolution)) Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T) # 给每个分类中的样本分配不同的颜色 Z = Z.reshape(xx1.shape) plt.contourf(xx1, xx2, Z, alpha=0.3, cmap=cmap) plt.xlim(xx1.min(), xx1.max()) plt.ylim(xx2.min(), xx2.max()) # plot class examples for idx, cl in enumerate(np.unique(y)): plt.scatter(x=X[y == cl, 0], y=X[y == cl, 1], alpha=0.8, c=colors[idx], marker=markers[idx], label=cl, edgecolor='black') plot_decision_regions(X, y, classifier=ppn)plt.xlabel('sepal length [cm]')plt.ylabel('petal length [cm]')plt.legend(loc='upper left')# plt.savefig('images/02_08.png', dpi=300)plt.show() 
Adaptive linear neurons and the convergence of learning
自适应线性神经元和学习的收敛性
…
Minimizing cost functions with gradient descent
通过梯度下降来最小化损失函数
Image(filename='./images/02_09.png', width=600)
Image(filename='./images/02_10.png', width=500)
Implementing an adaptive linear neuron in Python
使用python实现一个自适应线性神经元
class AdalineGD(object): """ADAptive LInear NEuron classifier. Parameters ------------ eta : float Learning rate (between 0.0 and 1.0) n_iter : int Passes over the training dataset. random_state : int Random number generator seed for random weight initialization. Attributes ----------- w_ : 1d-array Weights after fitting. cost_ : list Sum-of-squares cost function value in each epoch. """ def __init__(self, eta=0.01, n_iter=50, random_state=1): self.eta = eta self.n_iter = n_iter self.random_state = random_state def fit(self, X, y): """ Fit training data. Parameters ---------- X : {array-like}, shape = [n_examples, n_features] Training vectors, where n_examples is the number of examples and n_features is the number of features. y : array-like, shape = [n_examples] Target values. Returns ------- self : object """ rgen = np.random.RandomState(self.random_state) self.w_ = rgen.normal(loc=0.0, scale=0.01, size=1 + X.shape[1]) self.cost_ = [] for i in range(self.n_iter): net_input = self.net_input(X) # Please note that the "activation" method has no effect # in the code since it is simply an identity function. We # could write `output = self.net_input(X)` directly instead. # The purpose of the activation is more conceptual, i.e., # in the case of logistic regression (as we will see later), # we could change it to # a sigmoid function to implement a logistic regression classifier. output = self.activation(net_input) errors = (y - output) self.w_[1:] += self.eta * X.T.dot(errors) self.w_[0] += self.eta * errors.sum() cost = (errors**2).sum() / 2.0 self.cost_.append(cost) return self def net_input(self, X): """Calculate net input""" return np.dot(X, self.w_[1:]) + self.w_[0] def activation(self, X): """Compute linear activation""" return X def predict(self, X): """Return class label after unit step""" return np.where(self.activation(self.net_input(X)) >= 0.0, 1, -1) fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(10, 4))ada1 = AdalineGD(n_iter=10, eta=0.01).fit(X, y)ax[0].plot(range(1, len(ada1.cost_) + 1), np.log10(ada1.cost_), marker='o')ax[0].set_xlabel('Epochs')ax[0].set_ylabel('log(Sum-squared-error)')ax[0].set_title('Adaline - Learning rate 0.01')ada2 = AdalineGD(n_iter=10, eta=0.0001).fit(X, y)ax[1].plot(range(1, len(ada2.cost_) + 1), ada2.cost_, marker='o')ax[1].set_xlabel('Epochs')ax[1].set_ylabel('Sum-squared-error')ax[1].set_title('Adaline - Learning rate 0.0001')# plt.savefig('images/02_11.png', dpi=300)plt.show() 
上面：左图显示出学习率挑选过大，犹如显示出学习率挑选太小，如下所示：左边的图显示出合适的学习率，损失逐渐减小，一直到全局最小；
右边的图显示出：学习率过大，越过了全局最小值；Image(filename='./images/02_12.png', width=700)
Improving gradient descent through feature scaling
通过特征缩放改进梯度下降
Image(filename='./images/02_13.png', width=700)
# standardize features# 标准化处理过程有助于实现梯度学习直到收敛更加快速，但是：他会使得原始数据集# 不呈正太分布X_std = np.copy(X)X_std[:, 0] = (X[:, 0] - X[:, 0].mean()) / X[:, 0].std()X_std[:, 1] = (X[:, 1] - X[:, 1].mean()) / X[:, 1].std()
ada_gd = AdalineGD(n_iter=15, eta=0.01)ada_gd.fit(X_std, y)plot_decision_regions(X_std, y, classifier=ada_gd)plt.title('Adaline - Gradient Descent')plt.xlabel('sepal length [standardized]')plt.ylabel('petal length [standardized]')plt.legend(loc='upper left')plt.tight_layout()# plt.savefig('images/02_14_1.png', dpi=300)plt.show()plt.plot(range(1, len(ada_gd.cost_) + 1), ada_gd.cost_, marker='o')plt.xlabel('Epochs')plt.ylabel('Sum-squared-error')plt.tight_layout()# plt.savefig('images/02_14_2.png', dpi=300)plt.show() 
Large scale machine learning and stochastic gradient descent
大规模机器学习和随机梯度下降
class AdalineSGD(object): """ADAptive LInear NEuron classifier. Parameters ------------ eta : float Learning rate (between 0.0 and 1.0) n_iter : int Passes over the training dataset. shuffle : bool (default: True) Shuffles training data every epoch if True to prevent cycles. random_state : int Random number generator seed for random weight initialization. Attributes ----------- w_ : 1d-array Weights after fitting. cost_ : list Sum-of-squares cost function value averaged over all training examples in each epoch. """ def __init__(self, eta=0.01, n_iter=10, shuffle=True, random_state=None): self.eta = eta self.n_iter = n_iter self.w_initialized = False self.shuffle = shuffle self.random_state = random_state def fit(self, X, y): """ Fit training data. Parameters ---------- X : {array-like}, shape = [n_examples, n_features] Training vectors, where n_examples is the number of examples and n_features is the number of features. y : array-like, shape = [n_examples] Target values. Returns ------- self : object """ self._initialize_weights(X.shape[1]) self.cost_ = [] for i in range(self.n_iter): if self.shuffle: X, y = self._shuffle(X, y) cost = [] for xi, target in zip(X, y): cost.append(self._update_weights(xi, target)) avg_cost = sum(cost) / len(y) self.cost_.append(avg_cost) return self def partial_fit(self, X, y): """Fit training data without reinitializing the weights""" if not self.w_initialized: self._initialize_weights(X.shape[1]) if y.ravel().shape[0] > 1: for xi, target in zip(X, y): self._update_weights(xi, target) else: self._update_weights(X, y) return self def _shuffle(self, X, y): """Shuffle training data""" r = self.rgen.permutation(len(y)) return X[r], y[r] def _initialize_weights(self, m): """Initialize weights to small random numbers""" self.rgen = np.random.RandomState(self.random_state) self.w_ = self.rgen.normal(loc=0.0, scale=0.01, size=1 + m) self.w_initialized = True def _update_weights(self, xi, target): """Apply Adaline learning rule to update the weights""" output = self.activation(self.net_input(xi)) error = (target - output) self.w_[1:] += self.eta * xi.dot(error) self.w_[0] += self.eta * error cost = 0.5 * error**2 return cost def net_input(self, X): """Calculate net input""" return np.dot(X, self.w_[1:]) + self.w_[0] def activation(self, X): """Compute linear activation""" return X def predict(self, X): """Return class label after unit step""" return np.where(self.activation(self.net_input(X)) >= 0.0, 1, -1) ada_sgd = AdalineSGD(n_iter=15, eta=0.01, random_state=1)ada_sgd.fit(X_std, y)plot_decision_regions(X_std, y, classifier=ada_sgd)plt.title('Adaline - Stochastic Gradient Descent')plt.xlabel('sepal length [standardized]')plt.ylabel('petal length [standardized]')plt.legend(loc='upper left')plt.tight_layout()# plt.savefig('images/02_15_1.png', dpi=300)plt.show()plt.plot(range(1, len(ada_sgd.cost_) + 1), ada_sgd.cost_, marker='o')plt.xlabel('Epochs')plt.ylabel('Average Cost')plt.tight_layout()# plt.savefig('images/02_15_2.png', dpi=300)plt.show() 
ada_sgd.partial_fit(X_std[0, :], y[0])
<__main__.AdalineSGD at 0x1e018370508>
Summary
…
Readers may ignore the following cell
! python ../.convert_notebook_to_script.py --input ch02.ipynb --output ch02.py
[NbConvertApp] Converting notebook ch02.ipynb to script[NbConvertApp] Writing 16677 bytes to ch02.py
转载地址：http://ccbu.baihongyu.com/
你可能感兴趣的文章
mysql中出现update-alternatives: 错误: 候选项路径 /etc/mysql/mysql.cnf 不存在 dpkg: 处理软件包 mysql-server-8.0的解决方法（全）
查看>>
Mysql中各类锁的机制图文详细解析（全）
查看>>