Lesson 5.1 分类模型决策边界

已于 2023-02-05 11:29:30 修改
阅读量2.2k 收藏 27
点赞数 6
分类专栏： 机器学习 文章标签： python 人工智能
于 2023-02-03 18:53:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45891612/article/details/128858765
版权

文章目录

  • 我们需要学习一些关于分类模型的基础知识，包括观察分类模型判别性能的决策边界基本的概念与实现方法，同时也包括对于分类模型的一系列模型评估指标的基本解释与使用场景。
# 科学计算模块
import numpy as np
import pandas as pd

# 绘图模块
import matplotlib as mpl
import matplotlib.pyplot as plt

# 自定义模块
from ML_basic_function import *

一、决策边界（Decision Boundary）基本概念与用途

1. 决策边界基本概念与绘制方法

  • 关于分类模型的模型性能判别，我们可以从模型基本理论出发来进行判别，当然也可以根据长期的实践经验来进行判断。
  • 不过除此以外，还有一种常见的、用于辅助判别分类模型的模型性能的方法，那就是绘制模型决策边界。
  • 决策边界本质上是一种可视化分类效果的方法，其基本思路也非常简单——利用训练好的模型对样本空间所有的坐标点进行预测，然后观察样本空间所有点的不同类别之间的边界，最终就是模型的决策边界。
  • 例如，假设现在样本空间是二维空间，即数据总共只有两个特征，我们采用某个二分类数据集训练了一个逻辑回归模型，然后我们我们借助该模型对样本空间中所有点进行预测，并且对模型判别的不同类别的点进行不同着色，最终不同颜色（也就是不同类别）的点之间的分界线，其实就是决策边界。
  • 一般来说，我们会在决策边界图像上添加参与模型训练的样本点。相关过程如下图所示：

在这里插入图片描述

  • 另外，如果从决策边界角度出发，决策边界实际上就是模型判别样本点属于哪一类的边界，而不同颜色区域其实就是不同类别样本点所在的区域。

2. 通过决策边界观察模型性能

  • 根据决策边界图像，其实我们就能看出模型的分类性能和对于当前样本的分类结果。
  • 例如对于上图来说，首先我们能够发现，实际上逻辑回归在二维样本空间中的决策边界是一条直线，而这种决策边界的呈现直线的特性，会直接影响模型对于复杂样本的分类性能。
  • 在上述图四中能够清楚的看到，无论是红色区域的蓝色点，还是蓝色区域中红色的点，实际上都是模型错判的样本。
  • 受此限制，逻辑回归无法处理更加复杂的判别类问题，由此我们也能看到逻辑回归本身的性能瓶颈。

在这里插入图片描述

  • 当然，并非所有模型的决策边界都呈现出线性的状态，甚至对于大多数模型来说，其决策边界都不是单独一条直线。
  • 例如，对于 KNN 模型来说，其决策边界实际上是一个个圆圈叠加而成的拥有一定幅度的边界，而对于决策树模型来说，其决策边界实际上是一条条折线：

在这里插入图片描述

  • 很明显，从决策边界所呈现出来的不同形状，我们也能大致看出分类模型的判别效力，类似树模型甚至是树模型的集成模型，由于其是借助折线的决策边界来进行来进行样本类别划分，因此具备比逻辑回归更强的判别效力。
  • 此外，有时我们还能借助决策边界观察模型过拟合倾向，一般来说，模型决策边界越不规则、越是出现不同颜色区域彼此交错的情况，则说明模型越是存在过拟合倾向。

在这里插入图片描述

  • 受到平面图像呈现维度的约束，一般来说我们只能观察二维或者三维样本空间的决策边界或者决策平面，对于更高维度样本空间尽管在建模时也同样存在决策边界，但无法可视化展示。

3. 逻辑回归决策边界与模型可解释性

  • 尽管逻辑回归的线性决策边界一定程度约束了模型的分类效能，但线性决策边界实际上也为逻辑回归的模型可解释性提供了一个新的解释角度。
  • 例如，对于上述 dispersion=[6,2] 的逻辑回归决策边界来说，第一个特征（X 轴）取值越大、或者第二个特征（Y 轴）取值越大，则越有可能蓝色一类，或者说样本为蓝色类的概率就更大。

在这里插入图片描述

  • 而该现象也为解释特征之于样本类别判别的作用提供了一个新的角度。只有当决策边界是线性时才能够进行如此解释。
  • 逻辑回归线性方程系数的解释角度：假设逻辑回归方程为 y = S i g m o i d ( x 1 − 2 x 2 ) y=Sigmoid(x_1-2x_2) y=Sigmoid(x1​−2x2​)，其实我们只能说特征 x 1 x_1 x1​ 对于类别判别为 1 的结果有正向促进作用，而特征 x 2 x_2 x2​ 对于类别判别为 1 的结果有负向促进作用，并且对数优势比（ l n y 1 − y ln\frac{y}{1-y} ln1−yy​）有两倍的差异。
  • 值得一提的是，对于大多数模型来说都是试图找到一条更有效的决策边界去对样本进行类别划分，但也有些模型并不会在决策边界上下功夫，而是试图去改变样本空间。
  • 例如支持向量机 SVM，就能够通过某种映射关系改变数据分布（包括数据维度），然后在新的数据分布中利用简单的决策平面或者超平面来对数据集进行切分。

在这里插入图片描述

二、逻辑回归决策边界绘制与使用方法

1. 定义决策边界绘制函数

  • 决策边界的绘制函数其实和 Lesson 4.3 中介绍的损失函数的等高线图绘制方法类似，只是将等高线的绘制改成了分片区的着色。
  • 首先还是利用 meshgrid 函数创建区域点图
x1, x2 = np.meshgrid(np.arange(3), np.arange(1, 4))
[x1, x2]
#[array([[0, 1, 2],
#        [0, 1, 2],
#        [0, 1, 2]]),
# array([[1, 1, 1],
#        [2, 2, 2],
#        [3, 3, 3]])]
  • 回顾 Lesson 4.3 中所介绍内容，对于 meshgrid 函数生成结果，我们可以理解为第一个返回的结果为三排点的横坐标，而第二个返回结果为每个点纵坐标。
  • 所有的点是逐层排布的，每一排的点具有相同的纵坐标。实际绘图时，我们需要将这些点铺满整张画布。然后，我们需要带入画布中的所有点进行模型预测结果输出，即需要预测画布中的每个点所属类别。
  • 虽然我们知道上述 meshgrid 结果实际表示的点为 (0,1)、(1,1)、(2,1)…，但只有将这些点转化为二维数组才能带入模型进行训练，我们可以借助 reshape 方法和 concatenate 函数来进行相应的形变。
  • 同时，需要添加一列全是 1 的列在数据集的末尾，才能顺利进行逻辑回归建模预测。
np.concatenate([x1.reshape(-1, 1), x2.reshape(-1, 1), np.ones(shape=(9, 1))], 1)
#array([[0., 1., 1.],
#       [1., 1., 1.],
#       [2., 1., 1.],
#       [0., 2., 1.],
#       [1., 2., 1.],
#       [2., 2., 1.],
#       [0., 3., 1.],
#       [1., 3., 1.],
#       [2., 3., 1.]])
  • 接下来，将数据带入模型，即可输出预测结果。试想一下，当这些点密集的铺满画布时，我们就能够清楚的找出一条不同着色的边界。我们将上述过程封装为一个函数：
def logit_DB(X, w, y):
    """
    逻辑回归决策边界绘制函数
    """
    
    # 以两个特征的极值+1/-1作为边界，并在其中添加1000个点
    x1, x2 = np.meshgrid(np.linspace(X[:, 0].min()-1, X[:, 0].max()+1, 1000).reshape(-1,1),
                         np.linspace(X[:, 1].min()-1, X[:, 1].max()+1, 1000).reshape(-1,1))
    
    # 将所有点的横纵坐标转化成二维数组
    X_temp = np.concatenate([x1.reshape(-1, 1), x2.reshape(-1, 1), np.ones(shape=(1000000, 1))], 1)
    
    # 对所有点进行逻辑回归预测
    y_hat_temp = logit_cla(sigmoid(X_temp.dot(w)))
    yhat = y_hat_temp.reshape(x1.shape)
    
    # 绘制决策边界图像
    from matplotlib.colors import ListedColormap
    custom_cmap = ListedColormap(['#EF9A9A','#90CAF9'])
    plt.contourf(x1, x2, yhat, cmap=custom_cmap)
  • 关于图像绘制部分，此处采用了 plt.contourf 函数。该函数和此前介绍的等高线绘制函数 plt.contour 函数略有区别，该函数不会标注不同区域之间的边界，取而代之的是将不同区域进行着色处理。
  • 此外，ListedColormap 函数可通过输入十六进制颜色信息创建一个 colormap 对象，该对象可以作为 plt.contourf 函数中的 cmap 参数，用于指定不同区域的着色。

2. 决策边界绘制

  • 接下来，进行逻辑回归的决策边界绘制
  • 数据准备
# 设置随机数种子
np.random.seed(24)
​
# 创建数据
f, l = arrayGenCla(num_class = 2, deg_dispersion = [6, 2], bias = True)          # 离散程度较小
​
# 设置随机数种子
np.random.seed(24)   
​
# 数据切分
Xtrain, Xtest, ytrain, ytest = array_split(f, l)
​
mean_ = Xtrain[:, :-1].mean(axis=0)
std_ = Xtrain[:, :-1].std(axis=0)
​
Xtrain[:, :-1] = (Xtrain[:, :-1] - mean_) / std_
Xtest[:, :-1] = (Xtest[:, :-1] - mean_) / std_
​
# 观察数据集整体情况
plt.scatter(f[:, 0], f[:, 1], c=l)

在这里插入图片描述

  • 核心参数定义
# 设置随机数种子
np.random.seed(24)  
​
# 核心参数
batch_size = 50
num_epoch = 200
lr_init = 0.2
​
# 参数初始值
n = f.shape[1]
w = np.random.randn(n, 1)
​
# 记录迭代过程模型准确率计算结果
train_acc = []
test_acc = []
​
lr_lambda = lambda epoch: 0.95 ** epoch
  • 模型训练与结果观察
# 模型训练
for i in range(num_epoch):
    w = sgd_cal(Xtrain, w, ytrain, logit_gd, batch_size=batch_size, epoch=1, lr=lr_init*lr_lambda(i))
    train_acc.append(logit_acc(Xtrain, w, ytrain, thr=0.5))
    test_acc.append(logit_acc(Xtest, w, ytest, thr=0.5))
    
# 观察计算结果
plt.plot(list(range(num_epoch)), np.array(train_acc).flatten(), label='train_acc')
plt.plot(list(range(num_epoch)), np.array(test_acc).flatten(), label='test_acc')
plt.xlabel('epochs')
plt.ylabel('Accuracy')
plt.legend(loc = 4)

在这里插入图片描述

  • 绘制决策边界
  • 接下来，利用上述模型训练结果，来进行决策边界的图像绘制。
w
#array([[3.1894049 ],
#       [2.30553244],
#       [0.1691708 ]])

logit_DB(Xtrain, w, ytrain)

在这里插入图片描述

  • 当然，更为一般的情况是，我们会同时将样本点也绘制在包含决策边界的图像上
# 训练集上的决策边界
logit_DB(Xtrain, w, ytrain)
plt.scatter(Xtrain[(ytrain == 0).flatten(), 0], Xtrain[(ytrain == 0).flatten(), 1], color='red')
plt.scatter(Xtrain[(ytrain == 1).flatten(), 0], Xtrain[(ytrain == 1).flatten(), 1], color='blue')

在这里插入图片描述

  • 由于此处采用了一种布尔索引的方式分别筛选出两类点并对其进行不同的着色处理。
(ytrain == 0)[:10]
#array([[ True],
#       [ True],
#       [False],
#       [ True],
#       [ True],
#       [ True],
#       [False],
#       [ True],
#       [False],
#       [False]])

(ytrain == 0).sum()
#333

Xtrain[(ytrain == 0).flatten(), :][:10]
#array([[-0.54046519, -0.81824522,  1.        ],
#       [-0.54654998, -0.73750376,  1.        ],
#       [-0.31714585, -0.6904884 ,  1.        ],
#       [-0.90519121, -1.17674213,  1.        ],
#       [-0.94805   , -0.01882483,  1.        ],
#       [-1.70121658, -0.7126707 ,  1.        ],
#       [-1.65683868, -0.67489106,  1.        ],
#       [-0.85358557, -0.81544748,  1.        ],
#       [-0.78145774, -1.8732396 ,  1.        ],
#       [-0.17988496, -1.1491633 ,  1.        ]])

Xtrain[(ytrain == 0).flatten(), :].shape
#(333, 3)

# 测试集上的决策边界
logit_DB(Xtrain, w, ytrain)
plt.scatter(Xtest[(ytest == 0).flatten(), 0], Xtest[(ytest == 0).flatten(), 1], color='red')
plt.scatter(Xtest[(ytest == 1).flatten(), 0], Xtest[(ytest == 1).flatten(), 1], color='blue')

在这里插入图片描述

  • 当然，我们也可以提升数据难度再观察逻辑回归的决策边界。
# 设置随机数种子
np.random.seed(24)
​
# 创建数据
f, l = arrayGenCla(num_class = 2, deg_dispersion = [6, 4], bias = True)          # 离散程度较小
​
# 设置随机数种子
np.random.seed(24)   
​
# 数据切分
Xtrain, Xtest, ytrain, ytest = array_split(f, l)
​
mean_ = Xtrain[:, :-1].mean(axis=0)
std_ = Xtrain[:, :-1].std(axis=0)
​
Xtrain[:, :-1] = (Xtrain[:, :-1] - mean_) / std_
Xtest[:, :-1] = (Xtest[:, :-1] - mean_) / std_
​
# 设置随机数种子
np.random.seed(24)  
​
# 核心参数
batch_size = 50
num_epoch = 200
lr_init = 0.2
​
# 参数初始值
n = f.shape[1]
w = np.random.randn(n, 1)
​
# 定义学习率衰减匿名函数
lr_lambda = lambda epoch: 0.95 ** epoch
​
# 模型训练
for i in range(num_epoch):
    w = sgd_cal(Xtrain, w, ytrain, logit_gd, batch_size=batch_size, epoch=1, lr=lr_init*lr_lambda(i))

w
#array([[1.90849458],
#       [1.66037138],
#       [0.14304024]])

logit_DB(Xtrain, w, ytrain)

在这里插入图片描述

# 训练集上的决策边界
logit_DB(Xtrain, w, ytrain)
plt.scatter(Xtrain[(ytrain == 0).flatten(), 0], Xtrain[(ytrain == 0).flatten(), 1], color='red')
plt.scatter(Xtrain[(ytrain == 1).flatten(), 0], Xtrain[(ytrain == 1).flatten(), 1], color='blue')

在这里插入图片描述

# 测试集上的决策边界
logit_DB(Xtrain, w, ytrain)
plt.scatter(Xtest[(ytest == 0).flatten(), 0], Xtest[(ytest == 0).flatten(), 1], color='red')
plt.scatter(Xtest[(ytest == 1).flatten(), 0], Xtest[(ytest == 1).flatten(), 1], color='blue')

在这里插入图片描述

3. 逻辑回归决策边界与特征可解释性探索

  • 接下来，我们以鸢尾花数据集为例，来探讨为何逻辑回归的方程系数和决策边界其实都无法判别特征强弱。
  • 此处我们选取花萼宽 sepal_width 和花瓣长 petal_length 作为特征，进行是否是 setosa 鸢尾花的判别，即令 setosa 鸢尾花为类别 1，其他鸢尾花为类别 0。
  • 首先进行数据的读取。
pd.read_csv('iris.csv')

在这里插入图片描述

  • 然后进行数据提取与转化。
pd.read_csv('iris.csv').iloc[:, 1: 3]

在这里插入图片描述

features_temp = pd.read_csv('iris.csv').iloc[:, 1: 3].values

features_temp[:10]
#array([[3.5, 1.4],
#       [3. , 1.4],
#       [3.2, 1.3],
#       [3.1, 1.5],
#       [3.6, 1.4],
#       [3.9, 1.7],
#       [3.4, 1.4],
#       [3.4, 1.5],
#       [2.9, 1.4],
#       [3.1, 1.5]])

labels_temp = pd.read_csv('iris.csv').iloc[:, -1].values

labels_temp

labels_temp[labels_temp != 'Iris-setosa'] = 0
labels_temp[labels_temp == 'Iris-setosa'] = 1

labels_temp
#array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
#       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
#       1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
#       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
#       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
#       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
#       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], dtype=object)

labels = labels_temp.astype(float).reshape(-1, 1)

labels

features = np.concatenate([features_temp, np.ones(shape=labels.shape)], 1)

features[:10]
#array([[3.5, 1.4, 1. ],
#       [3. , 1.4, 1. ],
#       [3.2, 1.3, 1. ],
#       [3.1, 1.5, 1. ],
#       [3.6, 1.4, 1. ],
#       [3.9, 1.7, 1. ],
#       [3.4, 1.4, 1. ],
#       [3.4, 1.5, 1. ],
#       [2.9, 1.4, 1. ],
#       [3.1, 1.5, 1. ]])

labels[:10]
#array([[1.],
#       [1.],
#       [1.],
#       [1.],
#       [1.],
#       [1.],
#       [1.],
#       [1.],
#       [1.],
#       [1.]])

# 设置随机数种子
np.random.seed(24)  
​
# 核心参数
batch_size = 10
num_epoch = 200
lr_init = 0.5
​
# 参数初始值
n = features.shape[1]
w = np.random.randn(n, 1)
​
# 定义学习率衰减匿名函数
lr_lambda = lambda epoch: 0.95 ** epoch
​
# 模型训练
for i in range(num_epoch):
    w = sgd_cal(features, w, labels, logit_gd, batch_size=batch_size, epoch=1, lr=lr_init*lr_lambda(i))

w
#array([[ 2.8630463 ],
#       [-3.19680442],
#       [ 0.01148845]])

# 计算准确率
logit_acc(features, w, labels, thr=0.5)
#1.0

# 绘制决策边界
logit_DB(features, w, labels)
plt.scatter(features[(labels == 0).flatten(), 0], features[(labels == 0).flatten(), 1], color='red')
plt.scatter(features[(labels == 1).flatten(), 0], features[(labels == 1).flatten(), 1], color='blue')
plt.xlabel('sepal_width')
plt.ylabel('petal_length')
plt.title('Iris-setosa or not')

在这里插入图片描述

  • 根据决策边界的判别结果，我们能够得出，鸢尾花花萼越宽（sepal_width）取值越大，则越有可能是setosa鸢尾花，而鸢尾花花瓣越长（petal_length），则越有可能不是 setosa 鸢尾花。
  • 从逻辑回归方程系数来看，第一个特征系数取值为正值，也说明第一个特征对样本概率判别为 1 有正向促进作用，第二个特征系数取值为负值，也说明第二个特征对样本概率判别为 1 有负向促进作用。
  • 我们无法根据决策边界斜率基本是 1，逻辑回归的线性方程中两个特征系数绝对值类似，就判断两个特征对类别判别的贡献度类似、两个特征强弱类似。
  • 其实从样本空间中的样本分布我们不难看出，对于 setosa 类鸢尾花的识别来说，其实只需要 petal_length 一个特征即可，也就是说如果需要判别特征重要性的话，petal_length 的特征重要性远比 sepal_width 更加重要。
  • 当然，针对上述实验，我们可以通过简单调整参数的初始取值，就能够获得一个分类准确率仍然是 100%，但第二个特征的系数绝对值小于第一个特征的实验结果：
# 核心参数
batch_size = 10
num_epoch = 200
lr_init = 0.5
​
# 参数初始值
w = np.array([[10.0],[-1],[0]])
​
# 定义学习率衰减匿名函数
lr_lambda = lambda epoch: 0.95 ** epoch
​
# 设置随机数种子
np.random.seed(24)  
​
# 模型训练
for i in range(num_epoch):
    w = sgd_cal(features, w, labels, logit_gd, batch_size=batch_size, epoch=1, lr=lr_init*lr_lambda(i))
    
w
#array([[ 6.79050273],
#       [-6.44217682],
#       [-1.0895957 ]])

# 计算准确率
logit_acc(features, w, labels, thr=0.5)
#1.0

# 绘制决策边界
logit_DB(features, w, labels)
plt.scatter(features[(labels == 0).flatten(), 0], features[(labels == 0).flatten(), 1], color='red')
plt.scatter(features[(labels == 1).flatten(), 0], features[(labels == 1).flatten(), 1], color='blue')
plt.xlabel('sepal_width')
plt.ylabel('petal_length')
plt.title('Iris-setosa or not')

在这里插入图片描述

  • 从单一特征就能识别 setosa 类，其实也是鸢尾花数据集本身分类难度不大的重要原因。

三、验证逻辑回归参数和决策边界直线系数之间关系

  • 其实对于逻辑回归来说，我们也可以直接通过得到的逻辑回归线性方程来换算决策边界的直线系数，首先回到第一个例子当中，次数我们计算的 w 结果如下：
# 设置随机数种子
np.random.seed(24)
​
# 创建数据
f, l = arrayGenCla(num_class = 2, deg_dispersion = [6, 2], bias = True)          # 离散程度较小
​
# 设置随机数种子
np.random.seed(24)   
​
# 数据切分
Xtrain, Xtest, ytrain, ytest = array_split(f, l)
​
mean_ = Xtrain[:, :-1].mean(axis=0)
std_ = Xtrain[:, :-1].std(axis=0)
​
Xtrain[:, :-1] = (Xtrain[:, :-1] - mean_) / std_
Xtest[:, :-1] = (Xtest[:, :-1] - mean_) / std_
# 设置随机数种子
np.random.seed(24)  
​
# 核心参数
batch_size = 50
num_epoch = 200
lr_init = 0.2
​
# 参数初始值
n = f.shape[1]
w = np.random.randn(n, 1)
​
# 记录迭代过程模型准确率计算结果
train_acc = []
test_acc = []
​
lr_lambda = lambda epoch: 0.95 ** epoch

# 模型训练
for i in range(num_epoch):
    w = sgd_cal(Xtrain, w, ytrain, logit_gd, batch_size=batch_size, epoch=1, lr=lr_init*lr_lambda(i))
    train_acc.append(logit_acc(Xtrain, w, ytrain, thr=0.5))
    test_acc.append(logit_acc(Xtest, w, ytest, thr=0.5))
    
w
#array([[3.1894049 ],
#       [2.30553244],
#       [0.1691708 ]])

logit_DB(Xtrain, w, ytrain)

在这里插入图片描述

  • 此时逻辑回归方程为： y = s i g m o i d ( w 1 x 1 + w 2 x 2 + b ) y = sigmoid(w_1x_1+w_2x_2+b) y=sigmoid(w1​x1​+w2​x2​+b)
  • w 中三个参数分别对应 w 1 ， w 2 ， b w_1，w_2，b w1​，w2​，b。
  • 此时决策边界的直线方程即为： y = − b w 2 − w 1 w 2 ⋅ x y=-\frac{b}{w_2}-\frac{w_1}{w_2}\cdot x y=−w2​b​−w2​w1​​⋅x
  • 我们可以通过如下方式来进行验证：
Xtrain[:,0].max()+1
Xtrain[:,0].min()-1
#3.4440696978411824
#-3.5444315067469994

Xtrain[:,1].max()+1
Xtrain[:,1].min()-1
#3.4748793406727567
#-3.488450474918355

f1 = np.concatenate([np.linspace(2, 3, 100).reshape(-1, 1), 
                     np.full_like(np.linspace(2, 3, 100).reshape(-1, 1), Xtrain[:,1].min()-1), 
                     np.ones(100).reshape(-1, 1)], 1)

logit_cla(sigmoid(f1.dot(w))).sum()
#53.0

logit_cla(sigmoid(f1.dot(w)))[46]
#array([0.])

x1 = f1[46]

f2 = np.concatenate([np.linspace(-3, -2, 100).reshape(-1, 1), 
                     np.full_like(np.linspace(-3, -2, 100).reshape(-1, 1), Xtrain[:,1].max()+1), 
                     np.ones(100).reshape(-1, 1)], 1)

logit_cla(sigmoid(f2.dot(w))).sum()
#56.0

logit_cla(sigmoid(f2.dot(w)))[43]
#array([0.])

x2 = f2[43]

f3 = np.array([x1, x2])

f3
#array([[ 2.46464646, -3.48845047,  1.        ],
#       [-2.56565657,  3.47487934,  1.        ]])

f3[:, [0, 2]]
#array([[ 2.46464646,  1.        ],
#       [-2.56565657,  1.        ]])

f3[:, 1: 2]
#array([[-3.48845047],
#       [ 3.47487934]])
  • 据此，决策边界的直线系数为：
np.linalg.lstsq(f3[:, [0, 2]], f3[:, 1: 2], rcond=-1)[0]
#array([[-1.38427641],
#       [-0.07669852]])
  • 等价于 y = − b w 2 − w 1 w 2 ⋅ x y=-\frac{b}{w_2}-\frac{w_1}{w_2}\cdot x y=−w2​b​−w2​w1​​⋅x
w
#array([[3.1894049 ],
#       [2.30553244],
#       [0.1691708 ]])

- w[0] / w[1]
#array([-1.38337021])

- w[2] / w[1]
#array([-0.07337602])
虚心求知的熊
关注
  • 6
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
A002-186-2629-赖海洲
m0_46527226的博客
12-26 1280
计算机科学与工程学院作业报告 课程名称 需求分析与建模 班级 18软件工程4班 日期 2020/12/19 教导教师 董瑞生 姓名 赖海洲 学号 1814080902629 (activity diagram)活动图 https://www.smartdraw.com/activity-diagram/ An activity diagram visually presents a series of actions or flow of control in a system similar to a f
lesson9（风险决策）.pdf
04-17
为了简化模型，需求量分为三类：100件、150件和200件。假设每件未售出的损失为0.5元。 **2.5 概率估计** - 需求量为100件的概率 \(p_1 = 0.5\)。 - 需求量为150件的概率 \(p_2 = 0.3\)。 - 需求量为200件的概率 \(p...
分类模型决策边界、过拟合、评价指标、PR、ROC曲线
weixin_45715405的博客
04-10 374
很多时候不只是画一条线plt.show()
Lesson 6.4 逻辑回归手动调参实验
每天进步一点点！
02-09 1441
数据准备与评估器构造，评估器训练与过拟合实验，评估器的手动调参
微软研究深度报告：Sora文转视频AI模型全景剖析及未来展望
weixin_40262196的博客
03-02 1238
sora技术报告英文原文地址及中文翻译
数据挖掘报告
热门推荐
马如林的IT博客
04-10 1万+
 研究方向前沿读书报告数据挖掘技术的算法与应用 目录第一章 数据仓库... 51.1 概论... 51.2 数据仓库体系结构... 61.3 数据仓库规划、设计与开发... 71.3.1 确定范围... 71.3.2 环境评估... 71.3.3 分析... 71.3.4 设计... 81.3.5 开发... 81.3.5 测试... 8
Lesson 8.1 决策树的核心思想与建模流程
每天进步一点点！
03-05 1754
借助逻辑回归构建决策树，决策树的分类与流派
CTR预估 论文精读(五)--Practical Lessons from Predicting Clicks on Ads at Facebook
Dby_freedom的博客
12-12 5242
Abstract Online advertising allows advertisers to only bid and pay for measurable user responses, such as clicks on ads. As a consequence, click prediction systems are central to most online advertisi...
高级软件工程复习资料大全
qq_43400789的博客
03-29 1107
1.概述 功能 用例图 结构 业务类图 形式 数据模式 高质量需求的特点 有哪些需求类型 需求分析的两类基本方法 用例满足的四个必要条件 统一过程的核心要义是什么 模块化的基本原理 本地化外部接口是什么含义 接口的5个基本要素 通用接口定义的基本方法 依赖倒置原则的含义及其应用价值 MVC架构为什么更灵活以及MVVM架构为什么更智能（10分） 执行视图、部署视图、分解视图 没有银弹的含义 简述v模型 团队强度和项目特点的关系 简述敏
A002-186-2619-林斌锐
bcxuezha的博客
12-27 889
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录1.实体关系图(Entity relationship diagram)2.可维护性(Maintainability)3.客户要求规范（Customer requirements specification）4.需求基线（Requirements baseline）5.容器层次结构(containment hierarchy)6.统一建模语言( Unified Modeling Language(UML))7.上下文关系图（cont
lesson9（风险决策）.pdf.zip
03-21
"Lesson9（风险决策）"可能是一个课程或教程的一部分，旨在帮助学习者理解如何评估和处理风险，以便在业务决策中取得最佳结果。 【描述】：“lesson9（风险决策）.pdf.zip”很可能包含了一堂关于风险决策的详细课程...
lesson53-情感分类实战.zip
08-24
在这个"Lesson53-情感分类实战"中，我们将专注于如何利用长短期记忆网络（LSTM）来处理文本数据，尤其是对电影评论的情感进行分析。 首先，我们需要理解情感分类的基本概念。情感分类是自然语言处理（NLP）领域的一...
快醒醒，别睡了!...讲《数据分析pandas库》了—/—＜4＞
qq_64603703的博客
07-27 1070
详细解说数据分析pandas库中的常用方法
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 1171
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
Chapter 18 Python异常
2302_80253507的博客
07-28 1310
在Python中，异常是一种特定的对象，能够在程序运行过程中被抛出和处理。有效地管理异常不仅可以增强程序的稳定性，还可以提高用户体验，使程序能够优雅地处理错误情况。本章详细讲解了异常的基本概念以及如何捕获和处理异常。
python字符串数据容器练习（replace,split,count）
最新发布
2301_79600015的博客
07-31 400
Python字符串是由一系列字符组成的数据类型。在Python中，字符串是不可变的，这意味着一旦创建了一个字符串，就不能修改它的内容。以下是关于Python字符串的一些重要知识点：1. 字符串的基本操作：拼接字符串：使用`+`运算符。重复字符串：使用`*`运算符。索引和切片：使用`[]`和`:`操作符访问字符串中的子串。长度：使用`len()`函数获取字符串长度。转换大小写：使用`upper()`和`lower()`方法。分割和连接：使用`split()`和`join()`方法。
loguru日志模块：简化Python自动化测试的日志管理！
07-29 828
日志是软件开发中的关键组成部分，为开发和测试人员提供了调试和监控应用程序的重要手段。loguru 是一个第三方的 Python 日志库，以其简洁的 API 和自动化的功能脱颖而出。本文将探讨为什么项目中需要日志，loguru 为何受到青睐，以及如何封装和在接口自动化测试项目中使用 loguru，同时结合 Allure 生成丰富的测试报告。
Python入门知识点 10--闭包与装饰器
@网工小赵的博客
07-30 910
什么情况下会用到装饰器特性:在不修改源代码的基础上,给函数加功能。
"郭天祥单片机教学课件LESSON7串口通信基础与应用
郭天祥单片机教学课件LESSON7串口通信.ppt是一份关于计算机串行通信基础的教学课件。串行通信是计算机与外部设备或计算机与计算机之间进行信息交换的一种通信方式。随着多微机系统的广泛应用和计算机网络技术的普及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

虚心求知的熊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值