机器学习—逻辑回归

news/2024/11/6 11:24:00/

练习2：逻辑回归

介绍

在本练习中，您将实现逻辑回归并将其应用于两个不同的数据集。还将通过将正则化加入训练算法，来提高算法的鲁棒性，并用更复杂的情形来测试模型算法。

在开始练习前，需要下载如下的文件进行数据上传：

  • ex2data1.txt -前半部分的训练数据集
  • ex2data2.txt -后半部分的训练数据集

在整个练习中，涉及如下的必做作业：

  • 绘制2D分类数据的函数----(3分)
  • 实现Sigmoid函数--------(5分)
  • 实现Logistic回归代价函数和梯度函数—(60分)
  • 实现回归预测函数--------(5分)
  • 实现正则Logisitic回归成本函数-------(27分)

1 Logistic回归

在该部分练习中，将建立一个逻辑回归模型，用以预测学生能否被大学录取。

假设你是大学某个部门的负责人，你要根据两次考试的结果来决定每个申请人的入学机会。目前已经有了以往申请者的历史数据，并且可以用作逻辑回归的训练集。对于每行数据，都包含对应申请者的两次考试分数和最终的录取结果。

在本次练习中，你需要建立一个分类模型，根据这两次的考试分数来预测申请者的录取结果。

1.1 数据可视化

在开始实施任何算法模型之前，最好先对数据进行可视化，这将会更加直观的获取数据特征。

现在，你需要编写代码来完成数据的绘图，显示如下所示的图形。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wWPJdcP2-1686574674578)(2-1.png)]
要点：

  • 导入需要使用的python库，并将从文件ex2data1.txt中读取数据，并显示前5行
  • x-y轴分别为两次考试的分数
  • 正负示例需要用不同的标记显示（不同的颜色）
###在这里填入代码###
###主要实现要点1###
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# import matplotlib.pyplot as plt_plot
path = '/home/jovyan/work/ex2data1.txt'
data = pd.read_csv(path, header=None, names=['Exam 1', 'Exam 2', 'Admitted'])
data.head()
Exam 1Exam 2Admitted
034.62366078.0246930
130.28671143.8949980
235.84740972.9021980
360.18259986.3085521
479.03273675.3443761
###在这里填入代码###
###绘制数据散点图###positive = data[data['Admitted'].isin([1])]
negative = data[data['Admitted'].isin([0])]
fig, ax = plt.subplots(figsize=(12,8))
# 正向类，绘制50个样本，c=‘b’颜色，maker=‘o’绘制的形状
ax.scatter(positive['Exam 1'], positive['Exam 2'], s=50, c='b', marker='o', label='Admitted')
ax.scatter(negative['Exam 1'], negative['Exam 2'], s=50, c='r', marker='x', label='Not Admitted')
ax.legend()# Legend 图例,获取label标签内容，如图右上角显示
ax.set_xlabel('Exam 1 Score')
Text(0.5, 0, 'Exam 1 Score')

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x900vKTm-1686574674580)(output_3_1.png)]

1.2 实现

在前部分练习中所绘制的数据分布图中可以看出，在不同标识的数据点间，有一个较为清晰的决策边界。现在需要实现逻辑回归，并使用逻辑回归来训练模型用以预测分类结果。

1.2.1 Sigmoid函数

在正式开始之前，我们先来了解一个函数：Sigmoid函数。
我们还记得逻辑回归假设的定义是：
\[{{h}{\theta }}\left( x \right)=g\left({{{\theta }^{T}}X} \right)\]
其中 g 代表一个常用的逻辑函数为S形函数（Sigmoid function），公式为：
\[g\left( z \right)=\frac{1}{1+{{e}^{-z}}}\]
合起来，我们得到逻辑回归模型的假设函数：
\[{{h}{\theta }}\left( x \right)=\frac{1}{1+{{e}^{-{{\theta }^{T}}X}}}\]

接下来，你需要编写代码实现Sigmoid函数，编写后试着测试一些值，如果x的正值较大，则函数值应接近1；如果x的负值较大，则函数值应接近0。而对于x等于0时，则函数值为0.5。

###在这里填入代码###def sigmoid(z):return 1.0/(1.0+np.exp(-z))

###请运行并测试你的代码###
###请运行并测试你的代码###
nums = np.arange(-10, 10, step=1)fig, ax = plt.subplots(figsize=(12,8))
ax.plot(nums, sigmoid(nums), 'r')
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8FW2VZ8Q-1686574674582)(output_6_0.png)]

1.2.2 代价函数和梯度

1.2.2.1 代价函数

我们知道逻辑回归的代价函数是：
J ( θ ) = 1 m ∑ i = 1 m [ − y ( i ) log ⁡ ( h θ ( x ( i ) ) ) − ( 1 − y ( i ) ) log ⁡ ( 1 − h θ ( x ( i ) ) ) ] J\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)]} J(θ)=m1​i=1∑m​[−y(i)log(hθ​(x(i)))−(1−y(i))log(1−hθ​(x(i)))]

现在，你需要编写代码实现代价函数以进行逻辑回归的成本计算，并且经过所给数据测试后，初始的成本约为0.693。

要点：

  • 实现cost函数，参数为theta，X，y.
  • 返回计算的成本值。
  • 其中theta为参数，X为训练集中的特征列，y为训练集的标签列，三者均为矩阵。
###在这里填入代码###
def cost(theta,X,y):theta = np.matrix(theta)X = np.matrix(X)y = np.matrix(y)first = np.multiply(-y, np.log(sigmoid(X* theta.T)))second = np.multiply((1 - y), np.log(1 - sigmoid(X* theta.T)))return np.sum(first - second) / (len(X))

###请运行并测试你的代码###
#增加一列值为1，这和我们在练习1中的操作很相似
data.insert(0,'Ones',1)# 定义X为训练数据，y为目的变量
cols = data.shape[1]
X = data.iloc[:,0:cols-1]
y = data.iloc[:,cols-1:cols]# 将X,y转换为numpy数组，并初始化theta值为0
X = np.array(X.values)
y = np.array(y.values)
theta = np.zeros(3)cost(theta, X, y)

0.6931471805599453
1.2.2.2 梯度下降

接下来，我们需要编写代码实现梯度下降用来计算我们的训练数据、标签和一些参数 θ \theta θ的梯度。

要点：

  • 代码实现gradient函数，参数为theta，X，y.
  • 返回计算的梯度值。
  • 其中theta为参数，X为训练集中的特征列，y为训练集的标签列，三者均为矩阵。

批量梯度下降转化为向量化计算： 1 m X T ( S i g m o i d ( X θ ) − y ) \frac{1}{m} X^T( Sigmoid(X\theta) - y ) m1​XT(Sigmoid(Xθ)−y)

∂ J ( θ ) ∂ θ j = 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) \frac{\partial J\left( \theta \right)}{\partial {{\theta }_{j}}}=\frac{1}{m}\sum\limits_{i=1}^{m}{({{h}_{\theta }}\left( {{x}^{(i)}} \right)-{{y}^{(i)}})x_{_{j}}^{(i)}} ∂θj​∂J(θ)​=m1​i=1∑m​(hθ​(x(i))−y(i))xj​(i)​

这里需要注意的是，我们实际上没有在这个函数中执行梯度下降，我们仅仅在计算一个梯度步长。由于我们使用Python，我们可以用SciPy的optimize命名空间来做同样的事情。

###在这里填入代码###
def gradient(theta, X, y):theta = np.matrix(theta)X = np.matrix(X)y = np.matrix(y)parameters = int(theta.ravel().shape[1])grad = np.zeros(parameters)error = sigmoid(X * theta.T) - yfor i in range(parameters):term = np.multiply(error, X[:,i])grad[i] = np.sum(term) / len(X)return grad

###请运行并测试你的代码###
gradient(theta, X, y)

array([ -0.1       , -12.00921659, -11.26284221])

1.2.3 寻找最优参数

现在可以用SciPy’s truncated newton（TNC）实现寻找最优参数。

###请运行并测试你的代码###
import scipy.optimize as opt
result = opt.fmin_tnc(func=cost, x0=theta, fprime=gradient, args=(X, y))
result

(array([-25.16131868,   0.20623159,   0.20147149]), 36, 0)

让我们看看在这个结论下代价函数的值：

###请运行并测试你的代码###
cost(result[0], X, y)

0.2034977015894744

1.2.4 评估逻辑回归

接下来，我们需要编写代码实现预测函数，用所学的最优参数 θ \theta θ来为数据集X输出预测结果。然后，可以使用这个函数来给我们定义的分类器的训练精度进行打分。

逻辑回归的假设函数：

\[{{h}_{\theta }}\left( x \right)=\frac{1}{1+{{e}^{-{{\theta }^{T}}X}}}\]
当 h θ {{h}_{\theta }} hθ​大于等于0.5时，预测 y=1

当 h θ {{h}_{\theta }} hθ​小于0.5时，预测 y=0。

要点：

  • 代码实现predict函数，参数为theta，X.
  • 返回X中的每行数据对应的预测结果。
  • 其中theta为参数，X为训练集中的特征列。
###在这里填入代码###
def predict(theta, X):probability = sigmoid(X * theta.T)return [1 if x >= 0.5 else 0 for x in probability]

###请运行并测试你的代码###
theta_min = np.matrix(result[0])
predict(theta_min, X)

[0,0,0,1,1,0,1,0,1,1,1,0,1,1,0,1,0,0,1,1,0,1,0,0,1,1,1,1,0,0,1,1,0,0,0,0,1,1,0,0,1,0,1,1,0,0,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,0,0,0,0,0,1,0,1,1,0,1,1,1,1,1,1,1,0,1,1,1,1,0,1,1,0,1,1,0,1,1,0,1,1,1,1,1,0,1]

###请运行并测试你的代码###
predictions = predict(theta_min, X)
correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y)]
accuracy = (sum(map(int, correct)) % len(correct))
print ('accuracy = {0}%'.format(accuracy))

accuracy = 89%

2 正则化逻辑回归

在本部分练习中，我们将要通过加入正则项提升逻辑回归算法。

正则化是成本函数中的一个术语，它使算法更倾向于“更简单”的模型。这个理论助于减少过拟合，提高模型的泛化能力。

设想你是工厂的生产主管，你有一些芯片在两次测试中的测试结果。对于这两次测试，你想决定芯片是要被接受或抛弃。为了帮助你做出艰难的决定，你拥有过去芯片的测试数据集，从其中你可以构建一个逻辑回归模型。

2.1 数据可视化

与第一部分的练习类似，首先对数据进行可视化：

path =  '/home/jovyan/work/ex2data2.txt'
data2 = pd.read_csv(path, header=None, names=['Test 1', 'Test 2', 'Accepted'])
data2.head()
Test 1Test 2Accepted
00.0512670.699561
1-0.0927420.684941
2-0.2137100.692251
3-0.3750000.502191
4-0.5132500.465641
positive = data2[data2['Accepted'].isin([1])]
negative = data2[data2['Accepted'].isin([0])]fig, ax = plt.subplots(figsize=(12,8))
ax.scatter(positive['Test 1'], positive['Test 2'], s=50, c='b', marker='o', label='Accepted')
ax.scatter(negative['Test 1'], negative['Test 2'], s=50, c='r', marker='x', label='Rejected')
ax.legend()
ax.set_xlabel('Test 1 Score')
ax.set_ylabel('Test 2 Score')
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IunlS54O-1686574674584)(output_23_0.png)]

对于这部分数据，我们可以看出不同类别的数据点之间没有明显的线性决策界限用于划分两类数据。

因此，逻辑回归无法在此数据集上得到较好的效果，因为逻辑回归只能知道线性决策边界。

2.2 特征映射

一种能够更好地拟合数据的方法是构造从原始特征的多项式中得到的特征，即特征映射。如下图所示，作为这种映射的结果，我们的两个特征向量 x 1 , x 2 x_1,x_2 x1​,x2​（两次质量保证测试的分数）已经被转换成了28维的向量。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iSC9wmDA-1686574674584)(2-3.png)]

在这个高维特征向量上训练的逻辑回归分类器将具有更复杂的决策边界，并在二维图中绘制时呈现非线性的划分曲线。

虽然特征映射允许我们构建一个更具有表现力的分类器，但它也更容易过拟合。接下来，你需要实现正则化逻辑回归用于拟合数据，并使用正则化来帮助解决过拟合问题。

我们通过创建一组多项式特征来开始！

# 设定映射深度
degree = 5
# 分别取两次测试的分数
x1 = data2['Test 1']
x2 = data2['Test 2']data2.insert(3, 'Ones', 1)# 设定计算方式进行映射
for i in range(1, degree):for j in range(0, i):data2['F' + str(i) + str(j)] = np.power(x1, i-j) * np.power(x2, j)# 整理数据列
data2.drop('Test 1', axis=1, inplace=True)
data2.drop('Test 2', axis=1, inplace=True)print("特征映射后具有特征维数：%d" %data2.shape[1])
data2.head()

特征映射后具有特征维数：12
AcceptedOnesF10F20F21F30F31F32F40F41F42F43
0110.0512670.0026280.0358640.0001350.0018390.0250890.0000070.0000940.0012860.017551
111-0.0927420.008601-0.063523-0.0007980.005891-0.0435090.000074-0.0005460.004035-0.029801
211-0.2137100.045672-0.147941-0.0097610.031616-0.1024120.002086-0.0067570.021886-0.070895
311-0.3750000.140625-0.188321-0.0527340.070620-0.0945730.019775-0.0264830.035465-0.047494
411-0.5132500.263426-0.238990-0.1352030.122661-0.1112830.069393-0.0629560.057116-0.051818

2.3 代价函数和梯度

接下来，你需要编写代码来实现计算正则化逻辑回归的代价函数和梯度，并返回计算的代价值和梯度。

正则化逻辑回归的代价函数如下：
J ( θ ) = 1 m ∑ i = 1 m [ − y ( i ) log ⁡ ( h θ ( x ( i ) ) ) − ( 1 − y ( i ) ) log ⁡ ( 1 − h θ ( x ( i ) ) ) ] + λ 2 m ∑ j = 1 n θ j 2 J\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(θ)=m1​i=1∑m​[−y(i)log(hθ​(x(i)))−(1−y(i))log(1−hθ​(x(i)))]+2mλ​j=1∑n​θj2​

其中 λ \lambda λ是“学习率”参数，其值会影响函数中的正则项值。且不应该正则化参数 θ 0 \theta_0 θ0​。

###在这里填入代码###
def costReg(theta, X, y, learningRate):theta = np.matrix(theta)X = np.matrix(X)y = np.matrix(y)first = np.multiply(-y, np.log(sigmoid(X * theta.T)))second = np.multiply((1 - y), np.log(1 - sigmoid(X * theta.T)))reg = (learningRate / (2 * len(X))) * np.sum(np.power(theta[:,1:theta.shape[1]], 2))return np.sum(first - second) / len(X) + reg

接下来，我们需要实现正则化梯度函数，使用梯度下降法使得代价函数最小化。

因为在代价函数的计算中我们未对 θ 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}

对上面的算法中 j=1,2,…,n 时的更新式子进行调整可得：
θ j : = θ j ( 1 − a λ m ) − a 1 m ∑ i = 1 m ( h θ ( x ( i ) ) − y ( i ) ) x j ( i ) {{\theta }_{j}}:={{\theta }_{j}}(1-a\frac{\lambda }{m})-a\frac{1}{m}\sum\limits_{i=1}^{m}{({{h}_{\theta }}\left( {{x}^{(i)}} \right)-{{y}^{(i)}})x_{j}^{(i)}} θj​:=θj​(1−amλ​)−am1​i=1∑m​(hθ​(x(i))−y(i))xj(i)​

def gradientReg(theta, X, y, learningRate):theta = np.matrix(theta)X = np.matrix(X)y = np.matrix(y)parameters = int(theta.ravel().shape[1])grad = np.zeros(parameters)error = sigmoid(X * theta.T) - yfor i in range(parameters):term = np.multiply(error, X[:,i])if (i == 0):grad[i] = np.sum(term) / len(X)else:grad[i] = (np.sum(term) / len(X)) + ((learningRate / len(X)) * theta[:,i])return grad

接下来，类似于第一部分的练习中，进行变量的初始化。

# 从数据集中取得对应的特征列和标签列
cols = data2.shape[1]
X2 = data2.iloc[:,1:cols]
y2 = data2.iloc[:,0:1]# 转换为Numpy数组并初始化theta为零矩阵
X2 = np.array(X2.values)
y2 = np.array(y2.values)
theta2 = np.zeros(11)# 设置初始学习率为1，后续可以修改
learningRate = 1

接下来，使用初始化的变量值来测试你实现的代价函数和梯度函数。

###请运行并测试你的代码###
costReg(theta2, X2, y2, learningRate)

0.6931471805599454

###请运行并测试你的代码###
gradientReg(theta2, X2, y2, learningRate)

array([0.00847458, 0.01878809, 0.05034464, 0.01150133, 0.01835599,0.00732393, 0.00819244, 0.03934862, 0.00223924, 0.01286005,0.00309594])

2.4 寻找最优参数

现在我们可以使用和第一部分相同的优化函数来计算优化后的结果。

result2 = opt.fmin_tnc(func=costReg, x0=theta2, fprime=gradientReg, args=(X2, y2, learningRate))
result2

(array([ 0.53010246,  0.29075567, -1.60725764, -0.58213819,  0.01781027,-0.21329507, -0.40024142, -1.3714414 ,  0.02264304, -0.95033581,0.0344085 ]), 22, 1)

2.5 评估正则化逻辑回归

最后，我们可以使用第1部分中的预测函数来查看我们的方案在训练数据上的准确度。

theta_min = np.matrix(result2[0])
predictions = predict(theta_min, X2)
correct = [1 if ((a == 1 and b == 1) or (a == 0 and b == 0)) else 0 for (a, b) in zip(predictions, y2)]
accuracy = (sum(map(int, correct)) % len(correct))
print ('accuracy = {0}%'.format(accuracy))

accuracy = 78%

http://www.ppmy.cn/news/350711.html

相关文章

又一重点项目，石岩新能源产业园建面61.6万平，配27班学校

又一重点项目，石岩新能源产业园建面61.6万平，配27班学校

近日，宝安区城市更新和土地整备局发布，关于石岩街道总部经济园区城市更新单元(一期南及二期)“工业上楼”单元规划（草案）已通过专班会议审议的公告。 公告显示，项目申报主体为深圳市开宝安区投资管理集团有限公司&…
阅读更多...
[网络工程师]-网络规划与设计-网络测试运行和维护（二）

[网络工程师]-网络规划与设计-网络测试运行和维护（二）

4、局域网测试 局域网测试主要是检验网络是否为应用系统提供了稳定、高效的网络平台，如果网络系统不够稳定，网络应用就不可能快速稳定。对于常规的以太网进行系统测试，主要包括系统连通性、链路传输速率、吞吐率、传输时延、丢包率及链路层健康状况测试等基本功能测试。 4.…
阅读更多...
我的256创作纪念日

我的256创作纪念日

机缘 挺开心的，想到自己未曾写过一些非技术类的博客，恰巧今天刚好也是我的256创作纪念日，就乘着这个日子，写一点自己过去的收获、内心的想法和对未来的展望吧。 本人不才，只就读于一所民办本科之中，我挺不想…
阅读更多...
Qt学习04：QWidget顶层窗口

Qt学习04：QWidget顶层窗口

文章首发于我的个人博客：欢迎大佬们来逛逛 Qt学习04：QWidget顶层窗口 1. QWidget QWidget类是所有可视控件的基类，控件是用户界面的最小元素，用于接受各种事件(如：鼠标、键盘等)并且绘制出来给用户观看。 每个控件…
阅读更多...
送给对象的圣诞节电子贺卡源代码，圣诞节快乐代码

送给对象的圣诞节电子贺卡源代码，圣诞节快乐代码

送给女朋友的圣诞节电子贺卡源代码&#xff0c;圣诞节快乐代码 index.html <!DOCTYPE html><html lang"en"><head> <meta charset"UTF-8"> <meta name"viewport" content"widthdevice-width,initial-scale1.…
阅读更多...
送给女朋友的圣诞节电子贺卡源代码，圣诞节快乐代码

送给女朋友的圣诞节电子贺卡源代码，圣诞节快乐代码

送给女朋友的圣诞节电子贺卡源代码&#xff0c;圣诞节快乐代码 完整代码下载地址&#xff1a;送给女朋友的圣诞节电子贺卡源代码&#xff0c;圣诞节快乐代码 index.html <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8&q…
阅读更多...
php 贺卡,用php与mysql的电子贺卡程序_PHP教程

php 贺卡,用php与mysql的电子贺卡程序_PHP教程

第二步&#xff1a;预览 if (submit"预览") { switch($new) { case "newyear": $new"newyear.gif"; break; case "newyear2_2": $querynewyear2_2.gif; break; case "newyear3_3": $querynewyear3_3.gif; break; } } ?>…
阅读更多...
使用sql服务器发送贺卡_创建和发送免费电子贺卡的最佳网站

使用sql服务器发送贺卡_创建和发送免费电子贺卡的最佳网站

使用sql服务器发送贺卡 With the holiday season upon us, it’s time to pull out the holiday card list and get writing. However, how would you like to save some money this year and also help save the environment? 随着假期的到来&#xff0c;是时候抽出节日贺卡清…
阅读更多...
最新文章

Copyright @ 2022~2023