机器学习（三）---Logistic回归

目录

概念了解

线性模型与回归

最小二乘与参数求解

对数线性回归

Logistic回归

梯度下降

代码实现

线性模型与回归

逻辑回归

借鉴

---

概念了解

线性模型与回归

线性模型一般形式

最小二乘与参数求解

目标函数也就是在机器学习中常说的损失函数，我们的目标是得到使目标函数最小化时候的拟合函数的模型

 

最小二乘法（least sqaure method） - 知乎 (zhihu.com)https://zhuanlan.zhihu.com/p/38128785

对数线性回归

对数线性回归模型：= ， 也就是让模型 去逼近 ，而不是y。也可以对 =做一下变换就变成了，也可以理解为让 去逼近y。形式上还是线性回归的，但实质上已是在求取输入空间到输出空间的非线性函数映射

Logistic回归

逻辑回归（Logistic Regression）又叫对数几率回归，是一种用于解决二分类（0 or 1）问题的机器学习方法（适合数值型的二值型输出的拟合），用于估计某种事物的可能性，比如根据患者的医疗数据判断它是否能被治愈，区别肿瘤是否为良性，恶性。

就如下图所示

同时单位阶跃函数会有不连续问题

logistic回归用于分类，假设得到的类别为0或者1，那么可以使用sigmoid函数处理输入

衡量的是输入数据   归属于类别 1 的概率，当 的时候， ，可以认为  归属于类别 0 的概率较大，当  的时候，，可以认为  归属于类别 1 的概率较大。如果我们将线性加权得到的

Sigmoid函数_百度百科 (baidu.com)https://baike.baidu.com/item/Sigmoid%E5%87%BD%E6%95%B0

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

（其中 选择0.5作为阈值是一个一般的做法，实际应用时特定的情况可以选择不同阈值，如果对正例的判别准确性要求高，可以选择阈值大一些，对正例的召回要求高，则可以选择阈值小一些。）

 

 

 Logistic 回归的本质是：假设数据服从这个分布，然后使用极大似然估计做参数的估计

极大似然估计，通俗理解来说，就是利用已知的样本结果信息，反推最具有可能（最大概率）导致这些样本结果出现的模型参数值！

换句话说，极大似然估计提供了一种给定观察数据来评估模型参数的方法，即：“模型已定，参数未知”。

对极大似然法还不是很了解的话可以看看下面这篇文章

一文搞懂极大似然估计 - 知乎 (zhihu.com)

梯度下降

梯度下降（Gradient descent ）是利用一阶的梯度信息找到函数局部最优解的一种方法，也是机器学习里面常用的一种优化方法。

由于梯度方向是某一个函数值域变化最快的方向，所以要找函数的最值，最好的办法就是沿该函数的梯度方向寻找。

要找到损失函数的最小值，只需要每一步都往下走，也就是每一步都可以让误差损失函数小一点，无限逼近最小值。

α是步长，y(i)是真实值，h(x)是预测值，j表示第j个回归系数，i表示第i个样本。 

代码实现

线性模型与回归

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

path =  'ex1data1.txt'
data = pd.read_csv(path, header=None, names=['Population', 'Profit'])

#创建一个以参数θ为特征函数的代价函数
def computeCost(X, y, theta):
    inner = np.power(((X * theta.T) - y), 2)
    return np.sum(inner) / (2 * len(X))
#以便我们可以使用向量化的解决方案来计算代价和梯度。
data.insert(0, 'Ones', 1)

# set X (training data) and y (target variable)
cols = data.shape[1]
X = data.iloc[:,0:cols-1]#X是所有行，去掉最后一列
y = data.iloc[:,cols-1:cols]#X是所有行，最后一列
#代价函数是应该是numpy矩阵，所以我们需要转换X和Y，然后才能使用它们。 我们还需要初始化theta。
X = np.matrix(X.values)
y = np.matrix(y.values)
theta = np.matrix(np.array([0,0]))

#梯度下降
def gradientDescent(X, y, theta, alpha, iters):
    temp = np.matrix(np.zeros(theta.shape))
    parameters = int(theta.ravel().shape[1])
    cost = np.zeros(iters)
    
    for i in range(iters):
        error = (X * theta.T) - y
        
        for j in range(parameters):
            term = np.multiply(error, X[:,j])
            temp[0,j] = theta[0,j] - ((alpha / len(X)) * np.sum(term))
            
        theta = temp
        cost[i] = computeCost(X, y, theta)
        
    return theta, cost
#初始化一些附加变量 - 学习速率α和要执行的迭代次数。
alpha = 0.01
iters = 1000
g, cost = gradientDescent(X, y, theta, alpha, iters)
computeCost(X, y, g)
#绘制线性模型以及数据，直观地看出它的拟合
x = np.linspace(data.Population.min(), data.Population.max(), 100)
f = g[0, 0] + (g[0, 1] * x)

fig, ax = plt.subplots(figsize=(12,8))
ax.plot(x, f, 'r', label='Prediction')
ax.scatter(data.Population, data.Profit, label='Traning Data')
ax.legend(loc=2)
ax.set_xlabel('Population')
ax.set_ylabel('Profit')
ax.set_title('Predicted Profit vs. Population Size')
plt.show()

逻辑回归

数据集：logistic data

根据城市人口数量，预测开小吃店的利润。第一列是城市人口数量，第二列是该城市小吃店利润

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

path='E:/Edge-Download/ex2data1.txt'
data=pd.read_csv(path,names=['Exam1','Exam2','Accepted'])
data.head()

#数据可视化
fig,ax=plt.subplots()
ax.scatter(data[data['Accepted'] == 0]['Exam1'], data[data['Accepted'] == 0]['Exam2'], c='r', marker='x', label='y=0')
ax.scatter(data[data['Accepted'] == 1]['Exam1'], data[data['Accepted'] == 1]['Exam2'], c='b', marker='o', label='y=1')
ax.legend()
ax.set_xlabel('exam1')
ax.set_ylabel('exam2')
plt.show()

def get_Xy(data):
    # 在第一列插入1
    data.insert(0, 'ones', 1)
    # 取除最后一列以外的列
    X_ = data.iloc[:, 0:-1]
    # 取特征值
    X = X_.values
    # 取最后一列
    y_ = data.iloc[:, -1]
    y = y_.values.reshape(len(y_), 1)
    return X, y

X,y=get_Xy(data)
#损失函数
def sigmoid(z):
    return 1/(1+np.exp(-z))

def costFunction(X,y,theta):
    A=sigmoid(X@theta)
    
    first=y * np.log(A)
    second =(1-y)*np.log(1-A)
    #样本的累加
    return -np.sum(first+second)/len(X)

theta=np.zeros((3,1))
theta.shape

#输出损失函数
cost_init=costFunction(X,y,theta)
print(cost_init)

#梯度下降
def gradientDescent(X, y, theta, alpha, iters):
    m = len(X)
    costs = []
    for i in range(iters):
        A = sigmoid(X @ theta)
        # X.T:X的转置
        theta = theta - (alpha / m) * X.T @ (A - y)
        cost = costFunction(X, y, theta)
        costs.append(cost)
        if i % 1000 == 0:
             print(cost)
    return costs, theta
alpha=0.004
iters=200000
costs, theta_final = gradientDescent(X, y, theta, alpha, iters)
print(costs)

def predict(X, theta):
    prob = sigmoid(X @ theta)
    return [1 if x >= 0.5 else 0 for x in prob]


print(predict(X, theta_final))

y_ = np.array(predict(X, theta_final))
print(y_)
y_pre = y_.reshape(len(y_), 1)
# 求取均值
acc = np.mean(y_pre == y)
print(acc)
print('-----------------------6.决策边界-------------------------------------')
# 决策边界就是Xθ=0的时候
coef1 = - theta_final[0, 0] / theta_final[2, 0]
coef2 = - theta_final[1, 0] / theta_final[2, 0]
x = np.linspace(20, 100, 100)
f = coef1 + coef2 * x
fig, ax = plt.subplots()
ax.scatter(data[data['Accepted'] == 0]['Exam1'], data[data['Accepted'] == 0]['Exam2'], c='r', marker='x', label='y=0')
ax.scatter(data[data['Accepted'] == 1]['Exam1'], data[data['Accepted'] == 1]['Exam2'], c='b', marker='o', label='y=1')
ax.legend()
ax.set_xlabel('exam1')
ax.set_ylabel('exam2')
ax.plot(x, f, c='g')
plt.show()

运行结果

借鉴

http://www.ai-start.com/ml2014/html/week3.htmlhttp://www.ai-start.com/ml2014/html/week3.html