编程作业 3 - 多类分类

对于此练习，我们将使用逻辑回归来识别手写数字（0到9）。我们将扩展我们在练习2中写的逻辑回归的实现，并将其应用于一对一的分类。让我们开始加载数据集。它是在MATLAB的本机格式，所以要加载它在Python，我们需要使用一个SciPy工具。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.io import loadmat

data = loadmat('ex3data1.mat') #加载数据
data

{'__header__': b'MATLAB 5.0 MAT-file, Platform: GLNXA64, Created on: Sun Oct 16 13:09:09 2011','__version__': '1.0','__globals__': [],'X': array([[0., 0., 0., ..., 0., 0., 0.],[0., 0., 0., ..., 0., 0., 0.],[0., 0., 0., ..., 0., 0., 0.],...,[0., 0., 0., ..., 0., 0., 0.],[0., 0., 0., ..., 0., 0., 0.],[0., 0., 0., ..., 0., 0., 0.]]),'y': array([[10],[10],[10],...,[ 9],[ 9],[ 9]], dtype=uint8)}

data['X'].shape, data['y'].shape

((5000, 400), (5000, 1))

好的，我们已经加载了我们的数据。图像在martix X中表示为400维向量（其中有5,000个）。 400维“特征”是原始20 x 20图像中每个像素的灰度强度。类标签在向量y中作为表示图像中数字的数字类。

第一个任务是将我们的逻辑回归实现修改为完全向量化（即没有“for”循环）。这是因为向量化代码除了简洁外，还能够利用线性代数优化，并且通常比迭代代码快得多。但是，如果从练习2中看到我们的代价函数已经完全向量化实现了，所以我们可以在这里重复使用相同的实现。

sigmoid 函数

g 代表一个常用的逻辑函数（logistic function）为S形函数（Sigmoid function），公式为： \[g\left( z \right)=\frac{1}{1+{{e}^{-z}}}\]
合起来，我们得到逻辑回归模型的假设函数：
\[{{h}_{\theta }}\left( x \right)=\frac{1}{1+{{e}^{-{{\theta }^{T}}X}}}\]

def sigmoid(z):return 1 / (1 + np.exp(-z))

代价函数：
J(θ)=1m∑i=1m[−y(i)log⁡(hθ(x(i)))−(1−y(i))log⁡(1−hθ(x(i)))]+λ2m∑j=1nθj2J\left( \theta \right)=\frac{1}{m}\sum\limits_{i=1}^{m}{[-{{y}^{(i)}}\log \left( {{h}_{\theta }}\left( {{x}^{(i)}} \right) \right)-\left( 1-{{y}^{(i)}} \right)\log \left( 1-{{h}_{\theta }}\left( {{x}^{(i)}} \right) \right)]}+\frac{\lambda }{2m}\sum\limits_{j=1}^{n}{\theta _{j}^{2}}J(θ)=m1i=1∑m[−y(i)log(hθ(x(i)))−(1−y(i))log(1−hθ(x(i)))]+2mλj=1∑nθj2

Tip：可以通过np.matrix()函数将一个变量转换为numpy型矩阵

def cost(theta, X, y, learningRate):# INPUT：参数值theta，数据X，标签y，正则化参数  学习率作业中设为1 # OUTPUT：当前参数值下的交叉熵损失# TODO：根据参数和输入的数据计算交叉熵损失函数# STEP1：将theta, X, y转换为numpy类型的矩阵# your code here  (appro ~ 3 lines)theta =np.matrix(theta)X = np.matrix(X)y = np.matrix(y)# STEP2：根据公式计算损失函数（不含正则化）# your code here  (appro ~ 2 lines)cross_cost =np.multiply(-y, np.log(sigmoid(X * theta.T)))-np.multiply((1 - y), np.log(1 - sigmoid(X * theta.T)))# STEP3：根据公式计算损失函数中的正则化部分# your code here  (appro ~ 1 lines)reg =  (learningRate / (2 * len(X))) * np.sum(np.power(theta[1:], 2))#reg = (learningRate / (2 * len(X))) * np.sum(np.power(theta[:,1:theta.shape[1]], 2))均可# STEP4：把上两步当中的结果加起来得到整体损失函数# your code here  (appro ~ 1 lines)whole_cost=np.sum(cross_cost)/len(X)+reg   #sum不要忘掉 ，否则最后准确率差别很大return whole_cost

如果我们要使用梯度下降法令这个代价函数最小化，因为我们未对θ0{{\theta }_{0}}θ0 进行正则化，所以梯度下降算法将分两种情形：
\begin{align}
& Repeat\text{ }until\text{ }convergence\text{ }!!{!!\text{ } \
& \text{ }{{\theta }{0}}:={{\theta }{0}}-a\frac{1}{m}\sum\limits_{i=1}^{m}{[{{h}{\theta }}\left( {{x}^{(i)}} \right)-{{y}^{{(i)}}]x_{_{0}}}{(i)}} \
& \text{ }{{\theta }{j}}:={{\theta }{j}}-a\frac{1}{m}\sum\limits{i=1}^{m}{[{{h}{\theta }}\left( {{x}^{(i)}} \right)-{{y}^{(i)}}]x_{j}{(i)}}+\frac{\lambda }{m}{{\theta }{j}} \
& \text{ }!!}!!\text{ } \
& Repeat \
\end{align}

向量化的梯度函数

def gradient(theta, X, y, learningRate):# INPUT：参数值theta，数据X，标签y，正则化参数# OUTPUT：当前参数值下的梯度# TODO：根据参数和输入的数据计算梯度# STEP1：将theta, X, y转换为numpy类型的矩阵# your code here  (appro ~ 3 lines)theta = np.matrix(theta)X = np.matrix(X)y = np.matrix(y)# STEP2：将theta矩阵拉直（转换为一个向量）# your code here  (appro ~ 1 lines)parameters =int(theta.ravel().shape[1])  #theta数量# STEP3：计算预测的误差# your code here  (appro ~ 1 lines)    error = sigmoid(X * theta.T) - y# STEP4：根据上面的公式计算梯度# your code here  (appro ~ 1 lines)grad = ((X.T * error) / len(X)).T + ((learningRate / len(X)) * theta)# STEP5：由于j=0时不需要正则化，所以这里重置一下# your code here  (appro ~ 1 lines)grad[0, 0] = np.sum(np.multiply(error, X[:,0])) / len(X)return np.array(grad).ravel()

现在我们已经定义了代价函数和梯度函数，现在是构建分类器的时候了。对于这个任务，我们有10个可能的类，并且由于逻辑回归只能一次在2个类之间进行分类，我们需要多类分类的策略。在本练习中，我们的任务是实现一对一全分类方法，其中具有k个不同类的标签就有k个分类器，每个分类器在“类别 i”和“不是 i”之间决定。我们将把分类器训练包含在一个函数中，该函数计算10个分类器中的每个分类器的最终权重，并将权重返回为k X（n + 1）数组，其中n是参数数量。

from scipy.optimize import minimizedef one_vs_all(X, y, num_labels, learning_rate):rows = X.shape[0]params = X.shape[1]# k X (n + 1) array for the parameters of each of the k classifiersall_theta = np.zeros((num_labels, params + 1))# insert a column of ones at the beginning for the intercept termX = np.insert(X, 0, values=np.ones(rows), axis=1)  #插了一列1# labels are 1-indexed instead of 0-indexedfor i in range(1, num_labels + 1):theta = np.zeros(params + 1)y_i = np.array([1 if label == i else 0 for label in y])y_i = np.reshape(y_i, (rows, 1))# minimize the objective functionfmin = minimize(fun=cost, x0=theta, args=(X, y_i, learning_rate), method='TNC', jac=gradient) # 参数位置保证正确all_theta[i-1,:] = fmin.xreturn all_theta

这里需要注意的几点：首先，我们为theta添加了一个额外的参数（与训练数据一列），以计算截距项（常数项）。其次，我们将y从类标签转换为每个分类器的二进制值（要么是类i，要么不是类i）。最后，我们使用SciPy的较新优化API来最小化每个分类器的代价函数。如果指定的话，API将采用目标函数，初始参数集，优化方法和jacobian（渐变）函数。然后将优化程序找到的参数分配给参数数组。

实现向量化代码的一个更具挑战性的部分是正确地写入所有的矩阵，保证维度正确。

rows = data['X'].shape[0]
params = data['X'].shape[1]all_theta = np.zeros((10, params + 1))X = np.insert(data['X'], 0, values=np.ones(rows), axis=1)theta = np.zeros(params + 1)y_0 = np.array([1 if label == 0 else 0 for label in data['y']])
y_0 = np.reshape(y_0, (rows, 1))X.shape, y_0.shape, theta.shape, all_theta.shape

((5000, 401), (5000, 1), (401,), (10, 401))

注意，theta是一维数组，因此当它被转换为计算梯度的代码中的矩阵时，它变为（1×401）矩阵。我们还检查y中的类标签，以确保它们看起来像我们想象的一致。

np.unique(data['y'])#看下有几类标签

array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10], dtype=uint8)

让我们确保我们的训练函数正确运行，并且得到合理的输出。

all_theta = one_vs_all(data['X'], data['y'], 10, 1)
all_theta

array([[-2.34893352e+00,  0.00000000e+00,  0.00000000e+00, ...,1.31757773e-03, -3.85035187e-09,  0.00000000e+00],[-3.16159637e+00,  0.00000000e+00,  0.00000000e+00, ...,4.38005251e-03, -4.99993633e-04,  0.00000000e+00],[-4.79720105e+00,  0.00000000e+00,  0.00000000e+00, ...,-2.86616687e-05, -2.45161016e-07,  0.00000000e+00],...,[-7.98140404e+00,  0.00000000e+00,  0.00000000e+00, ...,-1.00807641e-04,  7.78771593e-06,  0.00000000e+00],[-4.57449090e+00,  0.00000000e+00,  0.00000000e+00, ...,-1.18847935e-03,  8.79935802e-05,  0.00000000e+00],[-5.30054826e+00,  0.00000000e+00,  0.00000000e+00, ...,-1.12938541e-04,  9.28175840e-06,  0.00000000e+00]])

我们现在准备好最后一步 - 使用训练完毕的分类器预测每个图像的标签。对于这一步，我们将计算每个类的类概率，对于每个训练样本（使用当然的向量化代码），并将输出类标签为具有最高概率的类。

Tip：可以使用np.argmax()函数找到矩阵中指定维度的最大值

def predict_all(X, all_theta):# INPUT：参数值theta，测试数据X# OUTPUT：预测值# TODO：对测试数据进行预测# STEP1：获取矩阵的维度信息rows = X.shape[0]params = X.shape[1]num_labels = all_theta.shape[0]# STEP2：把矩阵X加入一行零元素# your code here  (appro ~ 1 lines)X = np.insert(X, 0, values=np.ones(rows), axis=1)# STEP3：把矩阵X和all_theta转换为numpy型矩阵# your code here  (appro ~ 2 lines)X = np.matrix(X)all_theta = np.matrix(all_theta)# STEP4：计算样本属于每一类的概率# your code here  (appro ~ 1 lines)h = sigmoid(X * all_theta.T)# STEP5：找到每个样本中预测概率最大的值# your code here  (appro ~ 1 lines)h_argmax = np.argmax(h, axis=1)# STEP6：因为我们的数组是零索引的，所以我们需要为真正的标签+1h_argmax = h_argmax + 1return h_argmax

现在我们可以使用predict_all函数为每个实例生成类预测，看看我们的分类器是如何工作的。

y_pred = predict_all(data['X'], all_theta)
correct = [1 if a == b else 0 for (a, b) in zip(y_pred, data['y'])]
accuracy = (sum(map(int, correct)) / float(len(correct)))
print ('accuracy = {0}%'.format(accuracy * 100))

accuracy = 94.5%

正确的话accuracy = 94.46% 差一点点也可以在下一个练习中，我们将介绍如何从头开始实现前馈神经网络。

##error case1 accuracy = 77.58% 10% cost 函数写的有问题

##error case2 调用优化算法维度不匹配参数位置问题

机器学习作业班_python实现逻辑回归多类分类相关推荐

吴恩达《机器学习》学习笔记七——逻辑回归（二分类）代码
吴恩达<机器学习>学习笔记七--逻辑回归(二分类)代码一.无正则项的逻辑回归 1.问题描述 2.导入模块 3.准备数据 4.假设函数 5.代价函数 6.梯度下降 7.拟合参数 8.用训练 ...
stanford coursera 机器学习编程作业 exercise 3（逻辑回归实现多分类问题）
本作业使用逻辑回归(logistic regression)和神经网络(neural networks)识别手写的阿拉伯数字(0-9) 关于逻辑回归的一个编程练习,可参考:http://www.cnb ...
吴恩达《机器学习》学习笔记八——逻辑回归（多分类）代码
吴恩达<机器学习>笔记八--逻辑回归(多分类)代码导入模块及加载数据 sigmoid函数与假设函数代价函数梯度下降一对多分类预测验证课程链接:https://www.bilib ...
机器学习笔记（三）---- 逻辑回归（二分类）
逻辑回归基本概念前面提到过线性模型也可以用来做分类任务,但线性模型的预测输出 y = wx + b 可能是(-∞,+∞)范围内的任意实数,而二分类任务的输出y={0,1},如何在这之间做转换呢?答案 ...
机器学习笔记（四）---- 逻辑回归的多分类
一般情况下,我们都认为逻辑回归(LR)用来解决二分类问题,模型输出是y=1的概率值.那逻辑回归能否用来做多分类任务呢,答案是肯定的. 这里有两种方法使得逻辑回归能进行多分类任务: 一.将多分类任务拆解 ...
吴恩达《机器学习》学习笔记五——逻辑回归
吴恩达<机器学习>学习笔记五--逻辑回归一. 分类(classification) 1.定义 2.阈值二. 逻辑(logistic)回归假设函数 1.假设的表达式 2.假设表达式的意义 ...
【机器学习基础】(三)：理解逻辑回归及二分类、多分类代码实践
本文是机器学习系列的第三篇,算上前置机器学习系列是第八篇.本文的概念相对简单,主要侧重于代码实践. 上一篇文章说到,我们可以用线性回归做预测,但显然现实生活中不止有预测的问题还有分类的问题.我们可以从 ...
机器学习学习吴恩达逻辑回归_机器学习基础：逻辑回归
机器学习学习吴恩达逻辑回归 In the previous stories, I had given an explanation of the program for implementation ...
吴恩达机器学习（四）逻辑回归（二分类与多分类）
目录 0. 前言 1. 假设函数(Hypothesis) 2. 决策边界(Decision Boundary) 3. 代价函数(Cost Funciton) 4. 梯度下降(Gradient Desc ...
机器学习：理解逻辑回归及二分类、多分类代码实践
作者 | caiyongji 责编 | 张红月来源 | 转载自 caiyongji(ID:cai-yong-ji) 本文的概念相对简单,主要侧重于代码实践.现实生活中不止有预测的问题还有分类的问 ...

机器学习作业班_python实现逻辑回归多类分类

编程作业 3 - 多类分类

sigmoid 函数

机器学习作业班_python实现逻辑回归多类分类相关推荐

最新文章

热门文章