总结:本文为和鲸python 可视化探索训练营资料整理而来,加入了自己的理解(by GPT4o)
目录
总结 *:
关于案例1
关于机器学习算法的线性回归,如果是二分类且分类标签是0和1,预测结果默认是为1的概率,可以这样理解吗
是的,对于二分类问题,如果使用线性回归算法(具体来说是逻辑回归),并且分类标签是0和1,那么预测结果可以理解为属于类别1的概率。
具体来说,在逻辑回归中,模型通过一个线性函数(线性回归)计算出一个实数值,然后通过一个sigmoid函数(或逻辑函数)将该值转换为一个介于0和1之间的概率。这个概率可以解释为输入样本属于类别1的概率。数学上,可以表示为:
[ P(y=1|x) = \frac{1}{1 + e^{-(\beta_0 + \beta_1 x_1 + \beta_2 x_2 + … + \beta_n x_n)}} ]
其中:
- ( P(y=1|x) ) 是样本 ( x ) 属于类别1的概率。
- ( \beta_0, \beta_1, \beta_2, …, \beta_n ) 是模型的参数(权重)。
- ( x_1, x_2, …, x_n ) 是输入特征。
如果这个概率大于0.5,通常我们会将样本分类为类别1;如果小于等于0.5,则分类为类别0。
因此,你的理解是正确的,线性回归在二分类问题中可以通过逻辑回归的方式,预测类别1的概率。
关于案例2
重点关注对于数据的处理,包括:
删除空值(删除前观察空值分布)
查看非数值型数据的分布,使用LabelEncoder()处理数据
查看各维度与预测值Price的相关性,并删除相关性较小的维度
之后再进行常规的模型构建
逻辑回归
在开始逻辑回归模型实践之前,我们先复习一下逻辑回归的相关算法原理
函数公式
逻辑回归的基本函数公式如下:
y = w * x + b
上面函数公式内的字符含义如下:
x
: 自变量,可以理解为不确定因素。y
: 因变量,可以理解为不确定因素导致的结果。w
: 影响自变量的权重,即不同的系数会导致不同的变化。b
: 影响因变量的权值,b 跟w 是不同的含义。
举个最简单的例子就是初中学过的一元二次方程,y
与 x
成正比或反比取决于w
的正负,y在纵轴上 x=0
的位置取决于 b
的大小。
那么如何将上面的式子推广到用于解决实际的问题呢?
对于某个事件,说到底其结果无非是有限,而导致该结果的变化则可能是多种的,则会出现以下情况:
y = w1 * x1 + w2 * x2 + ... + b
其中的 x
表示的对 y
结果产生影响的变量,而 w
则是该变量产生影响的程度大小。
优化算法
提出可以解决实际问题的函数之后,x
、y
都是已知的,那又该如何求解 w*
和 b
呢? (w*
表示所有的w
)
随机梯度下降算法。
那又该如何理解随机梯度下降算法呢?
举个最简单的例子,一个球从群山中下到最低的山底,如何确保怎么是最底呢?
那就是准备无数多个球从山顶放下去,总会有那么一个球能到达最低的山底。但现实不太靠谱,那是不是可以优化下,比如环视 10
米找到最低的地方滚下去,然后以此类推,就可以到达最低点。
总结前面的例子就是,对目标点出发,首先给出一个初始值 w*
和 b
,然后向着这个目标点不断计算 w*
和 b
(求导),直至到达这个目标点,通过n 次的计算,直至 w*
和 b
可以明确的表达 x
和 y
之间的关系就完成计算。
乳腺癌诊断之分类问题
乳腺癌是全球妇女健康的主要威胁之一,早期发现和治疗对于提高患者生存率至关重要。传统的乳腺癌诊断方法存在一定的局限性,如依赖医生经验各项检测成本较高等。为了提高乳腺癌的诊断效率和准确性,计划开发一个基于机器学习的乳腺癌诊断模型,通过分析患者的细胞分析检查数据,实现对乳腺癌的提前诊断。该数据集为 sklearn
提供的示例数据集,其中有 569
例记录,包含编号细胞大小的均匀性细胞形状的均匀性上皮细胞大小正常核苷酸数量等特征。
乳腺癌数据集每列的含义如下:
特征列编号 | 特征含义 |
---|---|
1 | 平均纹理 |
2 | 平均半径 |
3 | 中值周长 |
4 | 均值面积 |
5 | 平均平滑度 |
6 | 平均紧凑度 |
7 | 平均凹点 |
8 | 平均对称性 |
9 | 均值分形维数 |
10 | 半径错误 |
11 | 纹理错误 |
12 | 周长错误 |
13 | 面积错误 |
14 | 平滑度误差 |
15 | 紧凑度误差 |
16 | 凹度误差 |
17 | 凹点误差 |
18 | 对称误差 |
19 | 分形维数误差 |
20 | 最差半径 |
21 | 最大纹理 |
22 | 最差周长 |
23 | 最差面积 |
24 | 最低平滑度 |
25 | 最差紧凑性 |
26 | 最差凹度 |
27 | 最大凹点 |
28 | 最差对称性 |
29 | 最差分形维数 |
乳腺癌数据集结果表示如下:
结果 | 含义 |
---|---|
1 | 患有乳腺癌 |
0 | 未患乳腺癌 |
引入依赖
import pandas as pd import numpy as np import matplotlib.pyplot as plt import seaborn as sns from sklearn.linear_model import LinearRegression from sklearn import datasets from sklearn.model_selection import train_test_split from sklearn.metrics import accuracy_score, mean_squared_error from sklearn.preprocessing import LabelEncoder
加载数据及基础分析
# 获取数据 cancer = datasets.load_breast_cancer() x = pd.DataFrame(cancer.data) y = pd.DataFrame(cancer.target) x.head(), y.head()
( 0 1 2 3 4 5 6 7 8 \ 0 17.99 10.38 122.80 1001.0 0.11840 0.27760 0.3001 0.14710 0.2419 1 20.57 17.77 132.90 1326.0 0.08474 0.07864 0.0869 0.07017 0.1812 2 19.69 21.25 130.00 1203.0 0.10960 0.15990 0.1974 0.12790 0.2069 3 11.42 20.38 77.58 386.1 0.14250 0.28390 0.2414 0.10520 0.2597 4 20.29 14.34 135.10 1297.0 0.10030 0.13280 0.1980 0.10430 0.1809 9 ... 20 21 22 23 24 25 26 27 \ 0 0.07871 ... 25.38 17.33 184.60 2019.0 0.1622 0.6656 0.7119 0.2654 1 0.05667 ... 24.99 23.41 158.80 1956.0 0.1238 0.1866 0.2416 0.1860 2 0.05999 ... 23.57 25.53 152.50 1709.0 0.1444 0.4245 0.4504 0.2430 3 0.09744 ... 14.91 26.50 98.87 567.7 0.2098 0.8663 0.6869 0.2575 4 0.05883 ... 22.54 16.67 152.20 1575.0 0.1374 0.2050 0.4000 0.1625 28 29 0 0.4601 0.11890 1 0.2750 0.08902 2 0.3613 0.08758 3 0.6638 0.17300 4 0.2364 0.07678 [5 rows x 30 columns], 0 0 0 1 0 2 0 3 0 4 0)
x[x.index == 411]
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ... | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
411 | 11.04 | 16.83 | 70.92 | 373.2 | 0.1077 | 0.07804 | 0.03046 | 0.0248 | 0.1714 | 0.0634 | ... | 12.41 | 26.44 | 79.93 | 471.4 | 0.1369 | 0.1482 | 0.1067 | 0.07431 | 0.2998 | 0.07881 |
1 rows × 30 columns
# 数据基础分析 x.info(), y.info()
<class 'pandas.core.frame.DataFrame'> RangeIndex: 569 entries, 0 to 568 Data columns (total 30 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 0 569 non-null float64 1 1 569 non-null float64 2 2 569 non-null float64 3 3 569 non-null float64 4 4 569 non-null float64 5 5 569 non-null float64 6 6 569 non-null float64 7 7 569 non-null float64 8 8 569 non-null float64 9 9 569 non-null float64 10 10 569 non-null float64 11 11 569 non-null float64 12 12 569 non-null float64 13 13 569 non-null float64 14 14 569 non-null float64 15 15 569 non-null float64 16 16 569 non-null float64 17 17 569 non-null float64 18 18 569 non-null float64 19 19 569 non-null float64 20 20 569 non-null float64 21 21 569 non-null float64 22 22 569 non-null float64 23 23 569 non-null float64 24 24 569 non-null float64 25 25 569 non-null float64 26 26 569 non-null float64 27 27 569 non-null float64 28 28 569 non-null float64 29 29 569 non-null float64 dtypes: float64(30) memory usage: 133.5 KB <class 'pandas.core.frame.DataFrame'> RangeIndex: 569 entries, 0 to 568 Data columns (total 1 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 0 569 non-null int32 dtypes: int32(1) memory usage: 2.3 KB (None, None)
x.describe().T, y.describe().T
( count mean std min 25% 50% \ 0 569.0 14.127292 3.524049 6.981000 11.700000 13.370000 1 569.0 19.289649 4.301036 9.710000 16.170000 18.840000 2 569.0 91.969033 24.298981 43.790000 75.170000 86.240000 3 569.0 654.889104 351.914129 143.500000 420.300000 551.100000 4 569.0 0.096360 0.014064 0.052630 0.086370 0.095870 5 569.0 0.104341 0.052813 0.019380 0.064920 0.092630 6 569.0 0.088799 0.079720 0.000000 0.029560 0.061540 7 569.0 0.048919 0.038803 0.000000 0.020310 0.033500 8 569.0 0.181162 0.027414 0.106000 0.161900 0.179200 9 569.0 0.062798 0.007060 0.049960 0.057700 0.061540 10 569.0 0.405172 0.277313 0.111500 0.232400 0.324200 11 569.0 1.216853 0.551648 0.360200 0.833900 1.108000 12 569.0 2.866059 2.021855 0.757000 1.606000 2.287000 13 569.0 40.337079 45.491006 6.802000 17.850000 24.530000 14 569.0 0.007041 0.003003 0.001713 0.005169 0.006380 15 569.0 0.025478 0.017908 0.002252 0.013080 0.020450 16 569.0 0.031894 0.030186 0.000000 0.015090 0.025890 17 569.0 0.011796 0.006170 0.000000 0.007638 0.010930 18 569.0 0.020542 0.008266 0.007882 0.015160 0.018730 19 569.0 0.003795 0.002646 0.000895 0.002248 0.003187 20 569.0 16.269190 4.833242 7.930000 13.010000 14.970000 21 569.0 25.677223 6.146258 12.020000 21.080000 25.410000 22 569.0 107.261213 33.602542 50.410000 84.110000 97.660000 23 569.0 880.583128 569.356993 185.200000 515.300000 686.500000 24 569.0 0.132369 0.022832 0.071170 0.116600 0.131300 25 569.0 0.254265 0.157336 0.027290 0.147200 0.211900 26 569.0 0.272188 0.208624 0.000000 0.114500 0.226700 27 569.0 0.114606 0.065732 0.000000 0.064930 0.099930 28 569.0 0.290076 0.061867 0.156500 0.250400 0.282200 29 569.0 0.083946 0.018061 0.055040 0.071460 0.080040 75% max 0 15.780000 28.11000 1 21.800000 39.28000 2 104.100000 188.50000 3 782.700000 2501.00000 4 0.105300 0.16340 5 0.130400 0.34540 6 0.130700 0.42680 7 0.074000 0.20120 8 0.195700 0.30400 9 0.066120 0.09744 10 0.478900 2.87300 11 1.474000 4.88500 12 3.357000 21.98000 13 45.190000 542.20000 14 0.008146 0.03113 15 0.032450 0.13540 16 0.042050 0.39600 17 0.014710 0.05279 18 0.023480 0.07895 19 0.004558 0.02984 20 18.790000 36.04000 21 29.720000 49.54000 22 125.400000 251.20000 23 1084.000000 4254.00000 24 0.146000 0.22260 25 0.339100 1.05800 26 0.382900 1.25200 27 0.161400 0.29100 28 0.317900 0.66380 29 0.092080 0.20750 , count mean std min 25% 50% 75% max 0 569.0 0.627417 0.483918 0.0 0.0 1.0 1.0 1.0)
在对数据经过初步分析之后,发现数据未出现缺失值(nan值或空字符串等),也不存在异常值(明显超出数据范围或与数据定义取值区间不符等)。
训练模型并计算指标
# 模型训练 # 1. 拆分数据训练集和测试集,比例 7:3 x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=42) x_train.head(), x_test.head(), y_train.head(), y_test.head()
( 0 1 2 3 4 5 6 7 8 \ 149 13.74 17.91 88.12 585.0 0.07944 0.06376 0.02881 0.01329 0.1473 124 13.37 16.39 86.10 553.5 0.07115 0.07325 0.08092 0.02800 0.1422 421 14.69 13.98 98.22 656.1 0.10310 0.18360 0.14500 0.06300 0.2086 195 12.91 16.33 82.53 516.4 0.07941 0.05366 0.03873 0.02377 0.1829 545 13.62 23.23 87.19 573.2 0.09246 0.06747 0.02974 0.02443 0.1664 9 ... 20 21 22 23 24 25 26 \ 149 0.05580 ... 15.34 22.46 97.19 725.9 0.09711 0.1824 0.1564 124 0.05823 ... 14.26 22.75 91.99 632.1 0.10250 0.2531 0.3308 421 0.07406 ... 16.46 18.34 114.10 809.2 0.13120 0.3635 0.3219 195 0.05667 ... 13.88 22.00 90.81 600.6 0.10970 0.1506 0.1764 545 0.05801 ... 15.35 29.09 97.58 729.8 0.12160 0.1517 0.1049 27 28 29 149 0.06019 0.2350 0.07014 124 0.08978 0.2048 0.07628 421 0.11080 0.2827 0.09208 195 0.08235 0.3024 0.06949 545 0.07174 0.2642 0.06953 [5 rows x 30 columns], 0 1 2 3 4 5 6 7 8 \ 204 12.47 18.60 81.09 481.9 0.09965 0.1058 0.08005 0.03821 0.1925 70 18.94 21.31 123.60 1130.0 0.09009 0.1029 0.10800 0.07951 0.1582 131 15.46 19.48 101.70 748.9 0.10920 0.1223 0.14660 0.08087 0.1931 431 12.40 17.68 81.47 467.8 0.10540 0.1316 0.07741 0.02799 0.1811 540 11.54 14.44 74.65 402.9 0.09984 0.1120 0.06737 0.02594 0.1818 9 ... 20 21 22 23 24 25 26 \ 204 0.06373 ... 14.97 24.64 96.05 677.9 0.1426 0.2378 0.2671 70 0.05461 ... 24.86 26.58 165.90 1866.0 0.1193 0.2336 0.2687 131 0.05796 ... 19.26 26.00 124.90 1156.0 0.1546 0.2394 0.3791 431 0.07102 ... 12.88 22.91 89.61 515.8 0.1450 0.2629 0.2403 540 0.06782 ... 12.26 19.68 78.78 457.8 0.1345 0.2118 0.1797 27 28 29 204 0.10150 0.3014 0.08750 70 0.17890 0.2551 0.06589 131 0.15140 0.2837 0.08019 431 0.07370 0.2556 0.09359 540 0.06918 0.2329 0.08134 [5 rows x 30 columns], 0 149 1 124 1 421 1 195 1 545 1, 0 204 1 70 0 131 0 431 1 540 1)
# 2. 构建模型 model = LinearRegression()
# 3. 训练模型 model.fit(x_train, y_train)
LinearRegression()In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
LinearRegression()
# 4. 使用测试集测试模型获取测试结果 y_pred = model.predict(x_test) y_pred[:10] # 此输出的是预测为1 的概率
array([[ 0.63641068], [ 0.19893156], [ 0.25993004], [ 1.1312271 ], [ 1.12862197], [-0.71286467], [-0.08514511], [ 0.40315066], [ 0.25276242], [ 0.95836231]])
# 5. 计算指标 # mse 均方误差 # rmse 均方根误差 # 对于这两个指标,数值越小越好,因为它们衡量了模型预测值与真实值之间的差异,越小表示模型的预测越接近真实值 mse = mean_squared_error(y_test, y_pred) rmse = np.sqrt(mse) mse, rmse
(0.06728376859363167, 0.2593911497981989)
# 输出模型的斜率、倾斜量和测试集的准确率 model.coef_, model.intercept_, model.score(x_test, y_test)
(array([[ 1.37372577e-01, 7.79428357e-03, -1.82105707e-02, -9.78666191e-05, -1.90315420e+00, 5.26086706e+00, -3.35439139e-01, -6.69106766e+00, 3.21568985e-01, -4.27164704e+00, -4.61122438e-01, 7.97442502e-02, -3.75583740e-03, 1.66070766e-03, -2.38396965e+01, 2.29146524e+00, 4.20544140e+00, -1.97044602e+01, 1.78524925e+00, -9.75990317e-01, -1.81809089e-01, -2.03391654e-02, 7.82072632e-03, 8.10744800e-04, 1.29891730e+00, -8.91398060e-01, -8.93861181e-01, 2.23179043e+00, -1.02916501e+00, -8.55319728e-01]]), array([3.01708661]), 0.7108399944964163)
总结
在实际训练模型时,大部分花费的时间都在于如何处理数据上:特征归一化、空值处理、缺失值填充等,不过现在不需要处理这些,现在的主要目的在于学习如何训练模型以及评估模型指标。
二手车价格之回归问题
随着二手车市场的快速发展,如何准确评估二手车价格成为买卖双方关注的焦点。传统的定价方法存在效率低、主观性强、欺诈风险等问题。为了解决这一问题,计划开发一个基于机器学习的二手车交易售价预测模型,通过分析历史交易数据,实现对二手车价格的快速、准确评估。该数据集收集了 8015
例记录,其中包含车辆名称、行驶公里数、注册年份、品牌、燃油类型、变速箱、发动机功率等特征,本小结将从日常可收集到的数据预测其实际市场价格。
二手车数据集特征含义说明:
特征列名称 | 特征含义 |
---|---|
Car Name | 汽车品牌或汽车型号 |
Year Bought | 购车年份 |
Distance | 行驶里程 (单位:公里) |
Owner | 持有类型 ‘个人或机构’ |
Fuel | 燃料类型 ‘petrol 汽油, diesel 柴油, CNG 压缩天然气, other 其他’ |
Location | 车管所所在地 |
Drive | 变速箱类型 ‘Automatic 自动, Manual 手动’ |
Type | 车型 ‘Sedan 轿车, SUV SUV, HatchBack 两厢车, Lux_SUV 豪华SUV, Lux_sedan 豪华轿车’ |
Price | 价格 |
加载数据
# 读取数据 cars = pd.read_csv('./data/cars_24.csv', index_col='Index') cars.head()
Car Name | Year | Distance | Owner | Fuel | Location | Drive | Type | Price | |
---|---|---|---|---|---|---|---|---|---|
Index | |||||||||
0 | Maruti S PRESSO | 2022.0 | 3878 | 1 | PETROL | HR-98 | Manual | HatchBack | 514000 |
1 | Hyundai Xcent | 2018.0 | 32041 | 1 | PETROL | TN-22 | Manual | Sedan | 674000 |
2 | Tata Safari | 2021.0 | 96339 | 1 | DIESEL | TS-08 | Automatic | SUV | 1952000 |
3 | Maruti Vitara Brezza | 2019.0 | 51718 | 1 | DIESEL | WB-24 | Manual | SUV | 690000 |
4 | Tata Tiago | 2021.0 | 19811 | 1 | PETROL | HR-51 | Manual | HatchBack | 526000 |
数据基础性分析
# 数据基础分析 cars.info() # 通过数据详情查看Car Name、Year 缺少 1 行,Location 缺少 213 行。
<class 'pandas.core.frame.DataFrame'> Index: 8015 entries, 0 to 8014 Data columns (total 9 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 Car Name 8014 non-null object 1 Year 8014 non-null float64 2 Distance 8015 non-null int64 3 Owner 8015 non-null int64 4 Fuel 8015 non-null object 5 Location 7802 non-null object 6 Drive 8015 non-null object 7 Type 8015 non-null object 8 Price 8015 non-null int64 dtypes: float64(1), int64(3), object(5) memory usage: 626.2+ KB
# 删除所有空的数据 cars.dropna(inplace=True) cars.info()
<class 'pandas.core.frame.DataFrame'> Index: 7801 entries, 0 to 8014 Data columns (total 9 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 Car Name 7801 non-null object 1 Year 7801 non-null float64 2 Distance 7801 non-null int64 3 Owner 7801 non-null int64 4 Fuel 7801 non-null object 5 Location 7801 non-null object 6 Drive 7801 non-null object 7 Type 7801 non-null object 8 Price 7801 non-null int64 dtypes: float64(1), int64(3), object(5) memory usage: 609.5+ KB
cars.describe().T
count | mean | std | min | 25% | 50% | 75% | max | |
---|---|---|---|---|---|---|---|---|
Year | 7801.0 | 2017.043584 | 2.847698 | 2010.0 | 2015.0 | 2017.0 | 2019.0 | 2023.0 |
Distance | 7801.0 | 50936.111524 | 25866.884915 | 0.0 | 30198.0 | 49245.0 | 69981.0 | 153870.0 |
Owner | 7801.0 | 1.298936 | 0.510013 | 1.0 | 1.0 | 1.0 | 2.0 | 4.0 |
Price | 7801.0 | 578755.935137 | 266132.614326 | 119000.0 | 396000.0 | 538000.0 | 702000.0 | 3300000.0 |
# 分类型数据查看分布 columns = ['Drive', 'Type', 'Fuel' , 'Location'] for col in columns: print('-'*30) print(cars[col].value_counts())
------------------------------ Drive Manual 6271 Automatic 1530 Name: count, dtype: int64 ------------------------------ Type HatchBack 4952 Sedan 1557 SUV 1155 Lux_SUV 80 Lux_sedan 57 Name: count, dtype: int64 ------------------------------ Fuel PETROL 6199 DIESEL 1066 CNG 535 LPG 1 Name: count, dtype: int64 ------------------------------ Location MH-12 286 GJ-01 245 HR-26 228 KA-03 198 TS-07 189 ... TS-27 1 HR-07 1 HR-27 1 TN-34 1 PB-46 1 Name: count, Length: 436, dtype: int64
训练模型并计算指标
# 训练模型 # 1. 数据预处理 # 用来对分类型特征值进行编码,即对不连续的数值或文本进行编码 lb = LabelEncoder() columns = ['Drive', 'Fuel', 'Type', 'Location'] for col in columns: cars[col] = lb.fit_transform(cars[col])
cars.info()
<class 'pandas.core.frame.DataFrame'> Index: 7801 entries, 0 to 8014 Data columns (total 9 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 Car Name 7801 non-null object 1 Year 7801 non-null float64 2 Distance 7801 non-null int64 3 Owner 7801 non-null int64 4 Fuel 7801 non-null int32 5 Location 7801 non-null int32 6 Drive 7801 non-null int32 7 Type 7801 non-null int32 8 Price 7801 non-null int64 dtypes: float64(1), int32(4), int64(3), object(1) memory usage: 487.6+ KB
# 2. 查看数据特征与结果之间的相关性 # 1. 选择数值型列 numeric_cols = cars.select_dtypes(include=[float, int]).columns # 2. 计算相关性矩阵 correlation_matrix = cars[numeric_cols].corr() # 3. 提取与 'Price' 列相关的相关性值 price_correlation = correlation_matrix['Price'] # 打印结果 print(price_correlation) # print(cars.corr()['Price']) # Car Name 与 Price 的相关性太小训练模型时可以删除该列
Year 0.496389 Distance -0.195088 Owner -0.151772 Fuel -0.147064 Location 0.040065 Drive -0.363527 Type 0.449268 Price 1.000000 Name: Price, dtype: float64
# 3. 构建模型训练数据 y = cars['Price'] x = cars.drop(['Price', 'Car Name'], axis=1) x.head(), y.head()
( Year Distance Owner Fuel Location Drive Type Index 0 2022.0 3878 1 3 102 1 0 1 2018.0 32041 1 3 313 1 4 2 2021.0 96339 1 1 368 0 3 3 2019.0 51718 1 1 425 1 3 4 2021.0 19811 1 3 90 1 0, Index 0 514000 1 674000 2 1952000 3 690000 4 526000 Name: Price, dtype: int64)
# 4. 拆分数据训练集和测试集,比例 7:3 x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=42) x_train.head(), x_test.head(), y_train.head(), y_test.head()
( Year Distance Owner Fuel Location Drive Type Index 4036 2018.0 78356 1 1 304 0 4 7773 2011.0 52946 2 3 156 1 0 2215 2019.0 34284 1 0 31 1 0 2719 2018.0 76611 1 3 42 0 4 7671 2012.0 97763 2 3 103 1 0, Year Distance Owner Fuel Location Drive Type Index 2170 2018.0 70968 1 3 105 1 4 2136 2021.0 31793 1 1 105 0 3 1109 2020.0 13150 1 3 202 1 4 5551 2018.0 38995 3 3 103 1 3 106 2014.0 63838 2 3 397 1 0, Index 4036 942000 7773 199650 2215 533000 2719 689000 7671 425000 Name: Price, dtype: int64, Index 2170 617000 2136 1295000 1109 714350 5551 631000 106 281000 Name: Price, dtype: int64)
# 5. 构建模型 model_2 = LinearRegression()
# 6. 训练模型 model_2.fit(x_train, y_train)
LinearRegression()In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
LinearRegression()
# 7. 预测测试集 y_pred = model_2.predict(x_test) y_pred
array([ 709301.25445336, 1040053.77189565, 838302.19949879, ..., 674032.59566195, 742026.31668977, 772885.15245588])
# 8. 计算指标 mse = mean_squared_error(y_test, y_pred) mse # 从该指标可以看出,逻辑回归对于解决回归问题有一点有力无心。不过不要灰心!现阶段的重点在于了解模型、训练模型,后面会学习到如何解决该问题。
32537438119.812634
课后思考题
- 随机梯度算法为什么不是全局最优,而是当前最优?
闯关题
STEP1:请根据要求完成题目
Q1. 优化算法是基于什么进行计算?
A. 随机梯度下降算法。
B. 随机梯度上升算法。
C. 随机梯度算法。
Q2. 假如你在训练一个线性回归模型,有下面两句话:
如果数据量较少,容易发生过拟合。 如果假设空间较小,容易发生过拟合。
关于这两句话,下列说法正确的是? (过拟合是指模型在训练集上表现很好,但在测试集上却表现很差。即模型对训练集有点死记硬背的意思,对于测试集完全随机给出结果,泛化能力很差。)
A. 1 和 2 都错误
B. 1 正确,2 错误
C. 1 错误,2 正确
D. 1 和 2 都正确
关于这两句话的正确说法如下:
数据量较少,容易发生过拟合:
- 正确。过拟合是指模型在训练数据上表现很好,但在测试数据上表现较差。这通常发生在模型记住了训练数据中的噪声或特定样本的情况下。如果数据量较少,模型可能会倾向于记住这些数据点,而不是学习到数据的整体规律,从而导致过拟合。
假设空间较小,容易发生过拟合:
- 不正确。假设空间(hypothesis space)是指模型可能的参数和结构的集合。假设空间较小通常意味着模型的复杂度较低,模型能够表示的函数或关系的范围较小。假设空间较小会导致欠拟合(underfitting),因为模型可能无法捕捉到数据的复杂模式。过拟合通常发生在假设空间较大、模型复杂度较高的情况下,因为这样的模型更容易在训练数据上表现良好,但在新数据上表现不佳。
综上所述,只有第一句话是正确的,第二句话是不正确的。
Q3. 现在有一个病人的检测数据,根据已经训练的糖尿病模型预测其是否会患有乳腺癌?
(11.04, 16.83, 70.92, 373.2, 0.1077, 0.07804, 0.03046, 0.0248, 0.1714, 0.0634, 0.1967, 1.387, 1.342, 13.54, 0.005158, 0.009355, 0.01056, 0.007483, 0.01718, 0.002198, 12.41, 26.44, 79.93, 471.4, 0.1369, 0.1482, 0.1067, 0.07431, 0.2998, 0.07881)
A. 1(是)
B. 0(否)
data_tmp = pd.DataFrame({0:11.04, 1:16.83, 2:70.92, 3:373.2, 4:0.1077, 5:0.07804, 6:0.03046, 7:0.0248, 8:0.1714, 9:0.0634, 10:0.1967, 11:1.387, 12:1.342, 13:13.54, 14:0.005158, 15:0.009355, 16:0.01056, 17:0.007483, 18:0.01718, 19:0.002198, 20:12.41, 21:26.44, 22:79.93, 23:471.4, 24:0.1369, 25:0.1482, 26:0.1067, 27:0.07431, 28:0.2998, 29:0.07881}, index=[0]) data_tmp # 使用训练好的模型预测数据集
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ... | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | |
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
0 | 11.04 | 16.83 | 70.92 | 373.2 | 0.1077 | 0.07804 | 0.03046 | 0.0248 | 0.1714 | 0.0634 | ... | 12.41 | 26.44 | 79.93 | 471.4 | 0.1369 | 0.1482 | 0.1067 | 0.07431 | 0.2998 | 0.07881 |
1 rows × 30 columns
model.predict(data_tmp)
array([[0.965385]])
#填入你的答案并运行,注意大小写 a1 = 'A' # 如 a1= 'B' a2 = 'B' # 如 a2= 'B' a3 = 'A' # 如 a3= 'B'