后台-插件-广告管理-内容页广告位一(手机)

# 三天爆肝快速入门机器学习：线性回归、逻辑回归、岭回归【第三天】

2021-04-18 18:48:31其他编程人已围观

• 线性回归
• 过拟合和欠拟合
• 岭回归
• 逻辑回归

# 线性回归

x_mean = np.mean(x_train)
y_mean = np.mean(y_train)
num = 0.0
d = 0.0
for x,y in zip(x_train,y_train):
num += (x-x_mean) * (y - y_mean)
d += (x - x_mean) ** 2
self.a_ = num /d
self.b_ = y_mean - self.a_*x_mean
x_mean = np.mean(x_train)
y_mean = np.mean(y_train)
num = (x_train - x_mean).dot(y_train - y_mean)
d = (x_train - x_mean).dot(x_train - x_mean)

d = 0.0
self.a_ = num /d
self.b_ = y_mean - self.a_*x_mean


# 过拟合和欠拟合

1 过拟合

1.1 过拟合的原因

1.2 解决过拟合的方法

Dropout
Batch Normalization
early stopping
data augmentation

2 欠拟合

2.1 欠拟合的原因

2.2 解决欠拟合的方法

3 偏差和方差

，目标函数为
，拟合出来的函数为

3.1 偏差(bias)

3.2 方差(variance)

3.3 偏差-方差窘境

3.4 方差和偏差的折中

# 岭回归

对


MATLAB代码

%% 岭回归(Ridge Regression)

%导入数据
data = load('abalone.txt');
[m,n] = size(data);

dataX = data(:,1:8);%特征
dataY = data(:,9);%标签

%标准化
yMeans = mean(dataY);
for i = 1:m
yMat(i,:) = dataY(i,:)-yMeans;
end

xMeans = mean(dataX);
xVars = var(dataX);
for i = 1:m
xMat(i,:) = (dataX(i,:) - xMeans)./xVars;
end

% 运算30次
testNum = 30;
weights = zeros(testNum, n-1);
for i = 1:testNum
w = ridgeRegression(xMat, yMat, exp(i-10));
weights(i,:) = w';
end

% 画出随着参数lam
hold on
axis([-9 20 -1.0 2.5]);
xlabel log(lam);
ylabel weights;
for i = 1:n-1
x = -9:20;
y(1,:) = weights(:,i)';
plot(x,y);
end


function [ w ] = ridgeRegression( x, y, lam )
xTx = x'*x;
[m,n] = size(xTx);
temp = xTx + eye(m,n)*lam;
if det(temp) == 0
disp('This matrix is singular, cannot do inverse');
end
w = temp^(-1)*x'*y;
end


# 逻辑回归

Sigmoid 函数

Sigmoid 函数 σ \sigma σ 表示为： σ ( t ) = 1 1 + e − t \sigma(t)=\frac{1}{1+e^{-t}} σ(t)=1+e−t1​，图示如下：

init() 方法首先初始化逻辑回归模型，theta 表示 θ \theta θ，interception 表示截距，chef_ 表示回归模型中自变量的系数：

class LogisticRegression:
def __init__(self):
self.coef_ = None
self.interceiption_ = None
self._theta = None


_sigmoid() 方法实现 Sigmoid 函数：

def _sigmoid(self, t):
return 1 / (1 + np.exp(-t))


fit() 方法根据训练数据集训练模型，J() 方法计算损失 J θ J\theta Jθ，dJ() 方法计算损失函数的梯度 ∇ J ( θ ) \nabla J(\theta) ∇J(θ)，gradient_descent() 方法就是梯度下降的过程，X_b 表示添加了 x 0 ( i ) ≡ 1 x_{0}^{(i)}\equiv1 x0(i)​≡1 的样本特征数据：

def fit(self, X_train, y_train, eta=0.01, n_iters=1e4):
def J(theta, X_b, y):
y_hat = self._sigmoid(X_b.dot(theta))
try:
return - np.sum(y * np.log(y_hat) + (1 - y) * np.log(1- y_hat) ** 2) / len(y)
except:
return float('inf')

def dJ(theta, X_b, y):
return X_b.T.dot(self._sigmoid(X_b.dot(theta)) - y) /len(y)

def gradient_descent(X_b, y, initial_theta, eta, n_iters=n_iters, epsilon=1e-8):
theta = initial_theta
i_ters = 0

while i_ters < n_iters:
gradient = dJ(theta, X_b, y)
last_theta = theta

theta = theta - eta * gradient

if (abs(J(theta, X_b, y) - J(last_theta, X_b, y)) < epsilon):
break

i_ters += 1

return theta

X_b = np.hstack([np.ones((len(X_train), 1)), X_train])
initial_theta = np.zeros(X_b.shape[1])

self._theta = gradient_descent(X_b, y_train, initial_theta, eta)
self.interception_ = self._theta[0]
self.coef_ = self._theta[1:]

return self


predict_proba() 将传入的测试数据与训练好模型后的 θ \theta θ 经过计算后返回该测试数据的概率：

def predict_proba(self, X_predict):
X_b = np.hstack([np.ones((len(X_predict), 1)), X_predict])
return self._sigmoid(X_b.dot(self._theta))


predict() 方法将经过 predict_proba() 方法得到的测试数据的概率以 0.5 为界转换成类别（0或1）：

def predict(self, X_predict):
proba = self.predict_proba(X_predict)
return np.array(proba >= 0.5, dtype='int')


score() 将测试数据集的预测分类与实际分类进行比较计算模型准确度：

def score(self, X_test, y_test):
y_predict = self.predict(X_test)
return sum(y_predict == y_test) / len(y_test)


import numpy as np

X = np.random.normal(0, 1, size=(200, 2))
y = np.array(X[:, 0] ** 2 + X[:, 1] ** 2 < 1.5, dtype='int')


from LogisticRegression import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures
from sklearn.preprocessing import StandardScaler

def PolynomailLogisticRegression(degree):
return Pipeline([
('poly', PolynomialFeatures(degree=degree)),
('std_scaler', StandardScaler()),
('log_reg', LogisticRegression())
])


poly_log_reg = PolynomailLogisticRegression(degree=2)
poly_log_reg.fit(X, y)


Scikit Learn 中的逻辑回归
Scikit Learn 中的 linear_model 模块中也提供了逻辑回归的算法，同时也封装了模型正则化相关的内容。

J ( θ ) + α L 1 J(\theta)+\alpha L_1 J(θ)+αL1​
J ( θ ) + α L 2 J(\theta)+\alpha L_2 J(θ)+αL2​
C ⋅ J ( θ ) + L 1 C·J(\theta)+L_1 C⋅J(θ)+L1​
C ⋅ J ( θ ) + L 2 C·J(\theta)+L_2 C⋅J(θ)+L2​
Scikit Learn 中的逻辑回归算法的模型正则化采用后两种的方式。

L1 为 L1正则项，即 ∑ i = 1 n ∣ θ i ∣ \sum_{i=1}^n|\theta_i| ∑i=1n​∣θi​∣，LASSO 回归使用了L1；
L2 为 L2正则项，即 1 2 ∑ i = 1 n θ i 2 \frac{1}{2}\sum_{i=1}^n\theta_i^2 21​∑i=1n​θi2​，岭回归使用了L2；

Scikit Learn 的逻辑回归算法中的参数 c 设定 C 的大小，参数 penalty 设定使用哪种正则项（l1 或 l2）。使用方式如下：

from sklearn.linear_model import LogisticRegression

def PolynomailLogisticRegression(degree, C, penalty='l2'):
return Pipeline([
('poly', PolynomialFeatures(degree=degree)),
('std_scaler', StandardScaler()),
('log_reg', LogisticRegression(C=C, penalty=penalty))
])

poly_log_reg = PolynomailLogisticRegression(degree=20, C=0.1, penalty='l1')
poly_log_reg.fit(X_train, y_train)
OvR 与 OvO


OvR（One vs Rest）将多类别简化成其中一个类别和其余类别为一个类别这种二分类，因此 n 个类别就进行 n 次分类，对于新的数据，看它在这 n 个分类结果中哪个分类得分最高即为哪个类别。

OvO（One vs One）在多类别中选取两个类别作为二分类，因此 n 个类别就进行 C n 2 C_n^2 Cn2​ 次分类，对于新的数据，看它在这 C n 2 C_n^2 Cn2​ 次分类结果中数量最大即为哪个类别。

Scikit Learn 的逻辑回归算法中的参数 multi_class 用于设定使用 OvR(参数值为 ovr）还是 OvO（参数值为 multinomial），如：

LogisticRegression(multi_class='ovr')
LogisticRegression(multi_class='multinomial')


# OvR
from sklearn.multiclass import OneVsRestClassifier
ovr = OneVsRestClassifier(LogisticRegression())
ovr.fit(X, y)

# OvO
from sklearn.multiclass import OneVsOneClassifier
ovo = OneVsOneClassifier(log_reg)
ovo.fit(X, y)


 后台-插件-广告管理-内容页广告位二(手机)

## 相关文章

 后台-插件-广告管理-内容页广告位三(手机)
 后台-插件-广告管理-内容页广告位四(手机)

## 文章评论

 留言与评论（共有 0 条评论）

 验证码：

## 站点信息

• 文章统计13614篇文章
• 浏览统计468次浏览
• 评论统计1个评论
• 标签管理标签云
• 统计数据：统计代码
• 微信公众号：扫描二维码，关注我们