一，什么是逻辑回归？
逻辑回归的使用频率最高
虽然叫回归，但是解决的是分类问题
原理：讲样本的特征和样本发生的概率联系起来，概率是一个数，所以叫回归问题
p=f(x)，再对p进行分类，p表示发生的概率。因此逻辑回归既可以看作回归算法也可以看作分类算法。通常作为分类算法用，只能解决二分类问题。（P的分界点是0.5）
注意概率的值域是[0,1]
可以对y施加一个函数：
使用sigmoid函数：
函数的值域是（0，1）
当t>0, p>0,5, y预测=1
当t<0, p<0.5, y预测=0
问题：对于给定的样本数据集X、y，如何找到参数theta，使得使用这样的方式可以最大程度的获得样本数据集X对应的分类输出y？
二，逻辑回归的损失函数
如果y真值=1，p越小，损失函数cost越大
如果y真值=0，p越大，损失函数cost越大
=>化为：
=>目标函数
其中：注意是总体的全部样本X，X的第一列全是1
对于目标函数最优值的求解没有公式解，只能利用梯度下降法求解。
三，逻辑回归损失函数的梯度
=>（写错了是J的求导）
对于线性回归：
四，实现逻辑回归算法
在线性回归算法的基础上进行修改
- 对损失函数进行修改，加入了sigmod激活函数
- 建立新的梯度
- 对评价函数score进行了修改
数据采集：
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
iris = datasets.load_iris()
逻辑回归算法只能解决二分法问题
X = iris.data
y = iris.target #表示种类的标签
X = X[y<2,:2]
y = y[y<2]
使用逻辑回归：
from playML.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, seed=666)
from playML.LogisticRegression import LogisticRegression
log_reg = LogisticRegression()
log_reg.fit(X_train, y_train)
最终预测结果和测试集的对比
五，决策边界
分别求出逻辑回归的系数和逻辑回归的截距
就可以用一条直线表示这个决策边界了
def x2(x1):
return (-log_reg.coef_[0] * x1 - log_reg.intercept_) / log_reg.coef_[1]
x1_plot = np.linspace(4, 8, 1000)
x2_plot = x2(x1_plot)
训练数据集：
测试数据集：
上述可以看出，简单 的逻辑回归是线性的，可以加入多项式项变成非线性的边界
大多数的数据不是线性的，我们要绘制出不规则的决策边界
不规则边界的绘制方法：
KNN算法的决策边界
from sklearn.neighbors import KNeighborsClassifier
knn_clf = KNeighborsClassifier()
knn_clf.fit(X_train, y_train)
plot_decision_boundary(knn_clf, axis=[4, 7.5, 1.5, 4.5])
plt.scatter(X[y==0,0], X[y==0,1])
plt.scatter(X[y==1,0], X[y==1,1])
plt.show()
当选取三个种类的鸢尾花：
knn_clf_all = KNeighborsClassifier()
knn_clf_all.fit(iris.data[:,:2], iris.target)
plot_decision_boundary(knn_clf_all, axis=[4, 8, 1.5, 4.5])
plt.scatter(iris.data[iris.target==0,0], iris.data[iris.target==0,1])
plt.scatter(iris.data[iris.target==1,0], iris.data[iris.target==1,1])
plt.scatter(iris.data[iris.target==2,0], iris.data[iris.target==2,1])
plt.show()
过拟合的表现，因为k值默认是5
knn_clf_all = KNeighborsClassifier(n_neighbors=50)
knn_clf_all.fit(iris.data[:,:2], iris.target)
plot_decision_boundary(knn_clf_all, axis=[4, 8, 1.5, 4.5])
plt.scatter(iris.data[iris.target==0,0], iris.data[iris.target==0,1])
plt.scatter(iris.data[iris.target==1,0], iris.data[iris.target==1,1])
plt.scatter(iris.data[iris.target==2,0], iris.data[iris.target==2,1])
plt.show()
六，在逻辑回归中使用多项式特征
数据生成：
import numpy as np
import matplotlib.pyplot as plt
import sklearn
np.random.seed(666)
X = np.random.normal(0, 1, size=(200, 2)) #200个样本，2个特征
y = np.array((X[:,0]**2+X[:,1]**2)<1.5, dtype='int')
plt.scatter(X[y==0,0], X[y==0,1])
plt.scatter(X[y==1,0], X[y==1,1])
plt.show()
使用逻辑回归：
from sklearn.linear_model import LogisticRegression
log_reg = LogisticRegression()
log_reg.fit(X, y)
准确度比较低
使用上节构造的plot_decision_boundary函数
plot_decision_boundary(log_reg, axis=[-4, 4, -4, 4])
plt.scatter(X[y==0,0], X[y==0,1])
plt.scatter(X[y==1,0], X[y==1,1])
plt.show()
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
def PolynomialLogisticRegression(degree):
return Pipeline([
('poly', PolynomialFeatures(degree=degree)),
('std_scaler', StandardScaler()),
('log_reg', LogisticRegression())
])
poly_log_reg = PolynomialLogisticRegression(degree=3)
poly_log_reg.fit(X, y)
当degree=40：
出现了过拟合现象
解决过拟合的方式有模型的正则化
七，逻辑回归中使用正则化
生成数据：
import numpy as np
import matplotlib.pyplot as plt
np.random.seed(666)
X = np.random.normal(0, 1, size=(200, 2))
y = np.array((X[:,0]**2+X[:,1])<1.5, dtype='int')
for _ in range(20): #强制改变样本的结果来添加噪音
y[np.random.randint(200)] = 1
plt.scatter(X[y==0,0], X[y==0,1])
plt.scatter(X[y==1,0], X[y==1,1])
plt.show()
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=666)
sklearn中的逻辑回归：
from sklearn.linear_model import LogisticRegression
log_reg = LogisticRegression()
log_reg.fit(X_train, y_train)
plot_decision_boundary(log_reg, axis=[-4, 4, -4, 4])
plt.scatter(X[y==0,0], X[y==0,1])
plt.scatter(X[y==1,0], X[y==1,1])
plt.show()
同样使用pipline加入多项式项：
poly_log_reg = PolynomialLogisticRegression(degree=2)
poly_log_reg.fit(X_train, y_train)
若degree=20:
泛化能力降低，有一定过拟合现象
重新定义管道，加入正则化的参数C（Jθ前的系数）
让正则化项权重更高
边界明显更简单
新建立管道，加上参数字符串penalty表示正则化
sklearn.linear_model.LogisticRegression — scikit-learn 1.2.2 documentation
但从边界图来看，加入正则化项后，边界变得更接近真实边界！
八，OvR与OvO解决多分类问题
逻辑回归只能解决二分类问题
OvR与OvO是一种通过用的，可以使二分类算法扩展到多分类算法的方式
OvR (One vs Rest) 一个对剩下分类的可能性的进行比较
n个类别就进行n此分类，选择分类得分最高的
OvO (One vs One) 一个对另一个可能性进行比较
每次挑出俩个，进行分类，那么四个类别每次挑俩个，有六种方式
n个类别要进行C(n,2)次分类，选择赢数最高的分类
消耗时间更多，但分类结果更加准确
数据生成：
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
iris = datasets.load_iris()
X = iris.data[:,:2]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=666)
from sklearn.linear_model import LogisticRegression #自动添加了多分类的功能
log_reg = LogisticRegression() #默认传入参数是ovr，新版本默认是ovo
log_reg.fit(X_train, y_train)
调用绘制边界图像的函数：
结果更加准确
使用所有数据
X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=666)
log_reg = LogisticRegression()
log_reg.fit(X_train, y_train)
log_reg.score(X_test, y_test) 100%
使用ovr会低一些
俩个类：
from sklearn.multiclass import OneVsOneClassifier
from sklearn.multiclass import OneVsRestClassifier
