python logistics regression_吴恩达机器学习笔记Python--ex2（logistics regression）

准备数据

data1的数据是学生两个学期的成绩exam1，exam2和是否能被录取admitted

把作业的data1数据导入，画出图形

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns

plt.style.use('fivethirtyeight')#一种绘图风格

import matplotlib.pyplot as plt

from sklearn.metrics import classification_report#这个包是评价报告

data=pd.read_csv(r'D:\MachineLearning\ex2\ex2_data1.txt',names=['exam1','exam2','admitted'])

sns.set(context='notebook',style='darkgrid',palette=sns.color_palette('RdBu',2))

sns.lmplot('exam1','exam2',hue='admitted',data=data,size=6,fit_reg=False,scatter_kws={'s':50})

plt.show()

运行结果如下：

读取数据

#读取特征

def get_X(df):

ones=pd.DataFrame({'ones':np.ones(len(df))})#ones是m行1列的dataframe

data=pd.concat([ones,df],axis=1)#合并数据，axis=1是列合并，=0是行合并。concat对大型数据集来说效率不高

return data.iloc[:,:-1].values

#读取标签

def get_y(df):

return np.array(df.iloc[:,-1])#取所有行和取最后一列

#特征缩放

def normalize_feature(df):

return df.apply(lambda column:(column-column.mean())/column.std())#apply是应用到每个数据，lambda是匿名函数

sigmoid函数

根据定义画出sigmoid函数图形

#sigmoid函数

def sigmoid(z):

return 1/(1+np.exp(-z))

fig,ax=plt.subplots(figsize=(8,6))

ax.plot(np.arange(-10,10,step=0.01),sigmoid(np.arange(-10,10,step=0.01)))

ax.set_ylim((-0.1,1.1))#y轴的刻度范围从-0.1到1.1

ax.set_xlabel('z',fontsize=18)

ax.set_ylabel('g(z)',fontsize=18)

ax.set_title('sigmoid funciton',fontsize=18)

plt.show()

结果如图：

计算代价函数

theta=np.zeros(3)#因为X(m*n)所以theta是n*1

def cost(theta,X,y):

return np.mean(-y*np.log(sigmoid(X@theta))-(1-y)*np.log(1-sigmoid(X@theta)))#X@theta与X.dot(theta)等价

print(cost(theta,get_X(data),get_y(data)))

输出的结果是0.69314718055994529

梯度下降

公式如下：

这里不像之前那样，写一个循环和设置一个学习率α，这里用到python里的fmin函数可以直接计算得到最优参数θ，实现如下：

导入scipy包：

import scipy as sp

#梯度下降

def optimizeTheta(theta,X,y):

result=sp.optimize.fmin(cost,x0=theta,args=(X,y),maxiter=400,full_output=True)

return result[0],result[1]

theta,mincost=optimizeTheta(theta,get_X(data),get_y(data))

print(cost(theta,get_X(data),get_y(data)))

运行结果如下：

得到最优参数θ：0.20349

用训练集预测和验证

#用训练集预测和验证

def predict(x,theta):

prob=sigmoid(x@theta)

return (prob>=0.5).astype(int)

y_pred=predict(get_X(data),final_theta)

print(classification_report(get_y(data),y_pred))

运行结果如下：

其中classification_report函数的详解可以参考这篇文章：https://blog.csdn.net/akadiao/article/details/78788864

预测样本

预测样本的入学概率

#预测样本exam1：45，exam2：85的入学概率

print(sigmoid(np.dot(final_theta,[1,45,85])))#1是x0

运行结果是0.7762915904112411

决策边界

类似 ax+by+c= 0，求出y即可。

#绘制决策边界

sns.set(context='notebook',style='ticks',font_scale=1.5)

sns.lmplot('exam1','exam2',hue='admitted',data=data,size=6,fit_reg=False,scatter_kws={'s':25})

boundary_x=np.array([np.min(get_X(data)[:,1]),np.max(get_X(data)[:,1])])

boundary_y=(-1./final_theta[2]*(final_theta[0]+final_theta[1]*boundary_x))

plt.plot(boundary_x,boundary_y,'grey')

plt.show()

正则化逻辑回归

data2是芯片经过两个测试后是否能通过

先是画出数据集的图形

import pandas as pd

import numpy as np

import matplotlib.pyplot as plt

import seaborn as sns

plt.style.use('fivethirtyeight')#一种绘图风格

import matplotlib.pyplot as plt

data=pd.read_csv(r'D:\MachineLearning\ex2\ex2_data2.txt',names=['test1','test2','accepted'])

#绘制出图形

sns.set(context='notebook',style='ticks',font_scale=1.5)

sns.lmplot('test1','test2',hue='accepted',data=data,size=6,fit_reg=False,scatter_kws={'s':50})#scatter_kws's'点的大小

plt.title('Regularized Logistic Regression')

plt.show()

特征映射

之所以进行特征映射，是因为特征映射的好处在于从每个特征中能创造出更多的特征。

#特征映射

def feature_mapping(x,y,power,as_ndarray=False):

data={"f{}{}".format(i-p,p):np.power(x,i-p)*np.power(y,p)

for i in np.arange(power+1)

for p in np.arange(i+1)}

if as_ndarray:

return pd.DataFrame(data).as_matrix()

else:

return pd.DataFrame(data)

x1=np.array(data.test1)

x2=np.array(data.test2)

data=feature_mapping(x1,x2,power=6)

正则化代价函数

正则化的原因是因为特征映射的过程中生成了太多高次项，当模型的特征(feature variables)非常多，而训练的样本数目(training set)又比较少，会出现过拟合的问题。如果我们发现了过拟合问题，应该如何处理?

1、丢弃一些不能帮助我们正确预测的特征。

2、正则化。保留所有的特征,但是减少参数θ的大小。

选择正则化，就需要减少高幂次的特征变量的影响，为此我们引入的罚项，假如我们有非常多的特征,我们并不知道其中哪些特征我们要惩罚，我们将对所有的特征进行惩罚。

公式如下：

#正则化代价函数

def sigmoid(z):

return 1/(1+np.exp(-z))

def cost(theta,X,y):

return np.mean(-y*np.log(sigmoid(X@theta))-(1-y)*np.log(1-sigmoid(X@theta)))

def get_y(df):

return np.array(df.iloc[:,-1])

theta=np.zeros(data.shape[1])

X=feature_mapping(x1,x2,power=6,as_ndarray=True)

#print(X.shape)

y=get_y(data)

#print(y.shape)

def regularized_cost(theta,X,y,l=1):

theta_j1_to_n=theta[1:]

regularized_term=(1/(2*len(X)))*np.power(theta_j1_to_n,2).sum()

return cost(theta,X,y)+regularized_term

print(regularized_cost(theta,X,y,l=1))

输出结果：0.69314718055

本文地址：https://blog.csdn.net/LunaLee38/article/details/110622495

希望与广大网友互动？？

点此进行留言吧！