第三章 线性模型

参考：https://blog.csdn.net/snoopy_yuan/article/details/64921495

题

数据集3.0α

3.1

$f(x)={\omega }^{T}x+b$ 中，${\omega }^T$ 和b有各自的意义，简单来说，${\omega }^T$决定学习得到模型(直线、平面)的方向，而b则决定截距，当学习得到的模型恰好经过原点时，可以不考虑偏置项b。偏置项b实质上就是体现拟合模型整体上的浮动，可以看做是其它变量留下的偏差的线性修正，因此一般情况下是需要考虑偏置项的。但如果对数据集进行了归一化处理，即对目标变量减去均值向量(也可以是随便一个样本)，此时就不需要考虑偏置项了。

3.2

3.3

import numpy as np
import matplotlib.pyplot as plt
import numpy.linalg as ln
from sklearn.linear_model import LogisticRegression

# 读取数据,其中前8个是好瓜，后9个是坏瓜,一共17个数据
density = np.array([0.697,0.774,0.634,0.608,0.556,0.403,0.481,0.437,0.666,0.243,0.245,0.343,0.639,0.657,0.360,0.593,0.719])
sugar = np.array([0.460,0.376,0.264,0.318,0.215,0.237,0.149,0.211,0.091,0.267,0.057,0.099,0.161,0.198,0.370,0.042,0.103])
goodMelon=np.array([1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0])
#1.准备数据
X = np.zeros(shape=(density.shape[0], 2), dtype=np.float)
Y = goodMelon
#X=np.zeros()中的元素都是0，因此需要克隆数据
X[:, 0] = density
X[:, 1] = sugar

regressor = LogisticRegression()
# 2. fit是训练
regressor.fit(X,Y)     # sklearn提供数据格式的自动处理，但是要求我们形成数据格式的规范。

#3. 预测
Y_PRE = regressor.predict(X)
#coef是系数，此时对应W;intercept是截距
print(regressor.coef_, regressor.intercept_)
#画出线性模型
fig = plt.figure(1, figsize=(5, 4))
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], title="训练模型")
ax.set_xlim(0,1)
ax.set_ylim(0, 0.5)
ax.plot(X, Y_PRE, color='green')
#画出真实值的散点图
ax.scatter(x=density[:8], y=sugar[:8], color='red')
ax.scatter(x=density[8:], y=sugar[8:], color='blue')
plt.show()

[[0.2890631  0.49458092]] [-0.37718839]

3.4

十折交叉验证法

import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split,GridSearchCV
from sklearn.svm import SVC
#加载数据集
data,target=datasets.load_iris(return_X_y=True)
print(data.shape)

#将数据变成100个
data=data[:100]
target=target[:100]
print(data.shape)

#交叉验证：训练集+测试集
#test_size=0.1,测试集是原数据规模的0.1,即十折交叉验证法
data_train,data_test,target_train,target_test=train_test_split(data,target,test_size=0.1)
print(data_train.shape)

#调用机器学习算法完成训练（常规训练+网格搜索训练）
#classifier=SVC(kernel='rbf',C=1000,gamma=0.1)  #这个算法参数是固定的
#参数字典
dic_p={
    'C':[1,10,100,10000],
    'gamma':[0.01,0.1,1],
}
#网格搜索：这个是从参数字典里自动找到最佳参数,即网格搜索
classifier=GridSearchCV(SVC(kernel='rbf'),dic_p)
classifier.fit(data_train,target_train)

#结果
pre=classifier.predict(data_test)
#测试集一共10个，打印正确预测的个数
print((pre==target_test).sum())

(150, 4)
(100, 4)
(90, 4)
10

留一法

import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split,GridSearchCV
from sklearn.svm import SVC
#加载数据集
data,target=datasets.load_iris(return_X_y=True)
print(data.shape)

#将数据变成100个
data=data[:100]
target=target[:100]
print(data.shape)

#交叉验证：训练集+测试集
#test_size=0.1,测试集是原数据规模的0.1,即十折交叉验证法
data_train,data_test,target_train,target_test=train_test_split(data,target,test_size=0.01)
print(data_train.shape)

#调用机器学习算法完成训练（常规训练+网格搜索训练）
#classifier=SVC(kernel='rbf',C=1000,gamma=0.1)  #这个算法参数是固定的
#参数字典
dic_p={
    'C':[1,10,100,10000],
    'gamma':[0.01,0.1,1],
}
#网格搜索：这个是从参数字典里自动找到最佳参数,即网格搜索
classifier=GridSearchCV(SVC(kernel='rbf'),dic_p)
classifier.fit(data_train,target_train)

#结果
pre=classifier.predict(data_test)
#测试集一共1个，打印正确预测的个数
print((pre==target_test).sum())

(150, 4)
(100, 4)
(99, 4)
1

3.5

W计算公式：$W=(X^{T}X{)}^{-1}{X}^{T}Y$

import numpy as np
import matplotlib.pyplot as plt
import numpy.linalg as ln

# 读取数据,其中前8个是好瓜，后9个是坏瓜,一共17个数据
density = np.array([0.697,0.774,0.634,0.608,0.556,0.403,0.481,0.437,0.666,0.243,0.245,0.343,0.639,0.657,0.360,0.593,0.719])
sugar = np.array([0.460,0.376,0.264,0.318,0.215,0.237,0.149,0.211,0.091,0.267,0.057,0.099,0.161,0.198,0.370,0.042,0.103])

# 用数据画一个散点图
figure = plt.figure(1, figsize=(5, 4))
ax = figure.add_axes([0.1, 0.1, 0.8, 0.8], title='密度与含糖率')
ax.set_xlim(left=0.0, right=1.0)
ax.set_ylim(bottom=0.0, top=0.5)
#好瓜用红色标记，坏瓜用蓝色
ax.scatter(x=density[:8], y=sugar[:8], color='red')
ax.scatter(x=density[8:], y=sugar[8:], color='blue')
plt.show()

#将Y=WX+b转成Y=WX，因此X最后需要加1列
X = np.zeros(shape=(density.shape[0], 2), dtype=np.float)#此处X是两列是因为对应上面的 6.简化模型，即最后一列都是1
Y = sugar.reshape(sugar.shape[0], 1)#即转成矩阵(二维数组)的17行1列形式
#X=np.zeros()中的元素都是0，因此需要克隆数据
X[:, 0] = density
X[:, 1] = 1      #最后一列都是1 
#计算得出W，W计算公式在下方
W = np.matmul(np.matmul(ln.inv(np.matmul(X.T, X)), X.T), Y)
#print(W)
#预测出Y，画出直线
Y_X = np.matmul(X, W)
#画出线性模型
fig = plt.figure(1, figsize=(5, 4))
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8], title="训练模型")
ax.set_xlim(0,1)
ax.set_ylim(0, 0.5)
ax.plot(X, Y_X, color='green')
#画出真实值的散点图
ax.scatter(x=density[:8], y=sugar[:8], color='red')
ax.scatter(x=density[8:], y=sugar[8:], color='blue')
plt.show()

3.6

对于非线性可分数据使用线性判别分析一般思想是将其映射到更高维的空间上，使它在高维空间上线性可分进一步使用判别分析，或者使用广义判别模型。

3.7

码长为9，即九个分类器,按照查阅文献应该是7个分类器，也就是码长为7，这里这个码长为9也是很魔性，因此按码长为7的写，最后两列随意写。。。

文献：https://download.csdn.net/download/qq_34405401/12251598

文献图片：

答案：

3.8

满足条件的可能性：
条件分解为两个：一是出错的概率相当，二是出错的可能性相互独立。
先看第一个把，其实就是每个一位上的分类器的泛化误差相同，要满足这个条件其实取决于样本之间的区分难度，若两个类别本身就十分相似，即越难区分，训练出的分类器出错的概率越大，原书p66也提到：
将多个类拆解为两个"类别子集“，所形成的两个类别子集的区分难度往往不同，即其导致的二分类问题的难度不同。
所以每个编码拆解后类别之间的差异越相同（区分难度相当），则满足此条件的可能性越大。在实际中其实很难满足。
第二个，相互独立。在3.7中也提到过，原文中也提出一个好的纠错输出码应该满足的其中一个条件就是各个位上分类器相互独立，当类别越多时，满足这个条件的可能性越大，在3.7中也解释了当类别较少时，很难满足这个条件。
至于产生的影响：
1.一个理论纠错牲质很好、但导致的二分类问题较难的编码，与另一个理论纠错性质差一些、但导致的二分类问题较简单的编码，最终产生的模型性能孰强孰弱很难说。
2.理论上的ECOC码能理想纠错的重要条件是每个码位出错的概率相当，因为如果某个码位的错误率很高，会导致这位始终保持相同的结果，不再有分类作用，这就相当于全0或者全 1的分类器。

3.9

书上左侧小字说：
对OvR、MvM来说，由于对每个类进行了相同的处理，其拆解出的二分类任务中类别不平衡的影响会相互抵消，因此通常不需要专门处理。

3.10

即$m^{-}$/$m^{+}$可以使用$cos{t}^{-}$/$cos{t}^{+}$简单直接进行替代