逻辑回归python正则化 选择参数_吴恩达机器学习第二次作业（python实现）：逻辑回归...

逻辑回归

数据在这

import matplotlib.pyplot as plt

import numpy as np

import scipy.optimize as opt

from sklearn.metrics import classification_report

import pandas as pd

from sklearn import linear_model

# 获取原始数据

def raw_data(path):

data=pd.read_csv(path,names=['exam1','exam2','admit'])

return data

# 绘制原始数据

def draw_data(data):

accept=data[data['admit'].isin([1])]

refuse=data[data['admit'].isin([0])]

plt.scatter(accept['exam1'],accept['exam2'],c='g',label='admit')

plt.scatter(refuse['exam1'],refuse['exam2'],c='r',label='not admit')

plt.title('admission')

plt.xlabel('score1')

plt.ylabel('score2')

return plt

# sigmoid函数

def sigmoid(z):

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

# 代价函数

def cost_function(theta,x,y):

m=x.shape[0]

j=(y.dot(np.log(sigmoid(x.dot(theta))))+(1-y).dot(np.log(1-sigmoid(x.dot(theta)))))/(-m)

return j

# 计算偏导数即可

def gradient_descent(theta,x,y):

return ((sigmoid(x.dot(theta))-y).T).dot(x)

# 假设函数

def predict(theta,x):

h=sigmoid(x.dot(theta))

return [1 if x>=0.5 else 0 for x in h]

# 决策边界theta*x=0

def boundary(theta,data):

x1=np.arange(20,100,0.01)

x2=(theta[0]+theta[1]*x1)/-theta[2]

plt=draw_data(data)

plt.title('boundary')

plt.plot(x1,x2)

plt.show()

def main():

data=raw_data('venv/lib/dataset/ex2data1.txt')

# print(data.head())

# plt=draw_data(data)

# plt.show()

x1=data['exam1']

x2=data['exam2']

x=np.c_[np.ones(x1.shape[0]),x1,x2]

y=data['admit']

# 不要将theta初始化为1，初始化为1的话，h(x)会过大，sigmoid近似返回1，log(1-h(x))无意义

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

# print(cost_function(theta,x,y)) # 0.6931471805599453

# theta=opt.fmin_tnc(func=cost_function,x0=theta,fprime=gradient_descent,args=(x,y))

theta=opt.minimize(fun=cost_function,x0=theta,args=(x,y),method='tnc',jac=gradient_descent)

theta=theta.x

# print(cost_function(theta,x,y))

print(classification_report(predict(theta,x),y))

'''

model=linear_model.LogisticRegression()

model.fit(x,y)

print(model.score(x,y))

'''

boundary(theta,data)

main()

关于opt.fmin_tnc()函数的参数问题

func是要最小化的函数

x0是最小化函数的自变量

fprime是最小化的方法

args是func的除theta外的

opt.minimize()函数的参数基本同上

结果：

训练数据集

决策边界

classification_report()的结果：

关于如何看classification_report()的结果，请看classification_report结果说明

正则化逻辑回归

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd

from sklearn import linear_model

import scipy.optimize as opt

from sklearn.metrics import classification_report

# 读取数据

def raw_data(path):

data=pd.read_csv(path,names=['test1','test2','accept'])

return data

# 画出原始数据

def draw_data(data):

accept=data[data['accept'].isin(['1'])]

reject=data[data['accept'].isin(['0'])]

plt.scatter(accept['test1'],accept['test2'],c='g')

plt.scatter(reject['test1'],reject['test2'],c='r')

plt.title('raw_data')

plt.xlabel('test1')

plt.ylabel('test2')

return plt

# 特征映射

def feature_mapping(x1,x2,power):

datamap={}

for i in range(power+1):

for j in range(i+1):

datamap["f{}{}".format(j,i-j)]=np.power(x1,j)*np.power(x2,i-j)

return pd.DataFrame(datamap)

def sigmoid(z):

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

# 正则化代价函数

def regularized_cost_function(theta,x,y,lam):

m=x.shape[0]

j=((y.dot(np.log(sigmoid(x.dot(theta)))))+((1-y).dot(np.log(1-sigmoid(x.dot(theta))))))/-m

penalty=lam*(theta.dot(theta))/(2*m)

return j+penalty

# 计算偏导数

def regularized_gradient_descent(theta,x,y,lam):

m=x.shape[0]

partial_j=((sigmoid(x.dot(theta))-y).T).dot(x)/m

partial_penalty=lam*theta/m

# 不惩罚第一项

partial_penalty[0]=0

return partial_j+partial_penalty

def predict(theta,x):

h=x.dot(theta)

return [1 if x>=0.5 else 0 for x in h]

def boundary(theta,data):

"""

[X,Y] = meshgrid(x,y)

将向量x和y定义的区域转换成矩阵X和Y,

其中矩阵X的行向量是向量x的简单复制，而矩阵Y的列向量是向量y的简单复制

假设x是长度为m的向量，y是长度为n的向量，则最终生成的矩阵X和Y的维度都是 nm(注意不是mn)

"""

# 绘制方程theta*x=0

x = np.linspace(-1, 1.5, 200)

x1, x2 = np.meshgrid(x, x)

z = feature_mapping(x1.ravel(), x2.ravel(), 6).values

z = z.dot(theta)

# print(xx.shape) # (200,200)

# print(z.shape) # (40000,)

z=z.reshape(x1.shape)

plt=draw_data(data)

plt.contour(x1,x2,z,0)

plt.title('boundary')

plt.show()

def main():

rawdata=raw_data('venv/lib/dataset/ex2data2.txt')

# print(rawdata.head())

# plt=draw_data(rawdata)

# plt.show()

data=feature_mapping(rawdata['test1'],rawdata['test2'],power=6)

# print(data.head())

x=data.values

y=rawdata['accept']

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

'''

print(type(x))

print(type(y))

print(type(data))

print(x.shape)

print(y.shape)

print(theta.shape)

'''

# print(regularized_cost_function(theta,x,y,1)) #0.6931471805599454

theta=opt.minimize(fun=regularized_cost_function,x0=theta,args=(x,y,1),method='tnc',jac=regularized_gradient_descent).x

# print(regularized_cost_function(theta,x,y,1)) # 0.5357749513533407

# print(classification_report(predict(theta,x),y))

boundary(theta,rawdata)

main()

原始数据：

决策边界：

classification_report()结果：