人工智能知识分享第五天-正则化.丧失函数案例

正则化

欠拟合与过拟合

过拟合：一个假设 在练习数据上可以或许得到比其他假设更好的拟合， 但是在测试数据集上却不能很好地拟合数据 (体如今正确率下降)，此时以为这个假设出现了过拟合的现象。(模子过于复杂)
欠拟合：一个假设 在练习数据上不能得到更好的拟合，并且在测试数据集上也不能很好地拟合数据 ，此时以为这个假设出现了欠拟合的现象。(模子过于简单)
过拟合和欠拟合的区别：

欠拟合在练习集和测试集上的误差都较大
过拟合在练习集上误差较小，而测试集上误差较大

丧失函数案例

波士顿房价预测

案例背景先容

数据先容

给定的这些特征，是专家们得出的影响房价的效果属性。不须要自己去探究特征是否有用，只须要使用这些特征。
案例分析

回归当中的数据大小不一致，是否会导致效果影响较大。以是须要做尺度化处理。

• 数据分割与尺度化处理
  
• 回归预测
  
• 线性回归的算法效果评估
  

回归性能评估

均方误差(Mean Squared Error, MSE)评价机制

• 均方误差回归丧失
  
• y_true:真实值
  
• y_pred:预测值
  
• return:浮点数效果
  

波士顿房价预测_正规方程解法

1. """
2. 案例:
3.     波士顿房价预测, 正规方程解法.
5. 回顾:
6.     正规方程解法 和 梯度下降的区别:
7.         相同点: 都可以用来找 损失函数的极小值, 评估 回归模型.
8.         不同点:
9.             正规方程: 一次性求解, 资源开销较大, 适合于小批量干净的数据集, 如果数据没有逆, 也无法计算.
10.             梯度下降: 迭代求解, 资源开销相对较小, 适用于大批量的数据集, 实际开发 更推荐.
11.                 分类:
12.                     全梯度下降
13.                     随机梯度下降
14.                     小批量梯度下降
15.                     随机平均梯度下降
17.     线性回归模型 评估的方案:
18.         方案1: 平均绝对误差, Mean Absolute Error,  误差绝对值的和 的 平均值.
19.         方案2: 均方误差, Mean Squared Error, 误差的平方和的平均值
20.         方案3: 均方根误差, Root Mean Squared Error, 误差的平方和的平均值的 平方根.
22.     机器学习项目的研发流程:
23.         1. 获取数据.
24.         2. 数据的预处理.
25.         3. 特征工程.
26.             特征提取, 特征预处理(标准化, 归一化), 特征降维, 特征选取, 特征组合.
27.         4. 模型训练.
28.         5. 模型评估.
29.         6. 模型预测.
30. """
32. # 导包
35. # from sklearn.datasets import load_boston           # 数据集
36. from sklearn.preprocessing import StandardScaler  # 特征处理
37. from sklearn.model_selection import train_test_split  # 数据集划分
38. from sklearn.linear_model import LinearRegression  # 正规方程的回归模型
39. from sklearn.metrics import mean_squared_error, mean_absolute_error, root_mean_squared_error  # 均方误差评估 平均绝对值误差评估 均方根误差评估
40. import pandas as pd
41. import numpy as np
43. # 1. 获取数据.
44. data_url = "http://lib.stat.cmu.edu/datasets/boston"
45. raw_df = pd.read_csv(data_url, sep="\s+", skiprows=22, header=None)
46. data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])
47. target = raw_df.values[1::2, 2]
49. # 查看数据 以及数量
50. # print(f'特征: {len(data)}, {data[:5]}')
51. # print(f'目标: {len(target)}, {target[:5]}')
52. # 2. 数据的预处理.
53. x_train, x_test, y_train, y_test = train_test_split(data, target, test_size=0.2, random_state=22)
55. # 3. 特征工程, 特征提取, 特征预处理(标准化, 归一化), 特征降维, 特征选取, 特征组合.
56. # 3.1 创建标准化对象.
57. transfer = StandardScaler()
58. # 3.2 对训练和 和 测试集的 特征进行标准化处理.
59. x_train = transfer.fit_transform(x_train)
60. x_test = transfer.transform(x_test)
62. # 4. 模型训练.
63. # 4.1 创建 线性回归之 正规方程对象.
64. # 参数: fit_intercept: 是否计算截距(bias, 偏置), 默认是: True
65. estimator = LinearRegression(fit_intercept=True)
66. # 4.2 模型训练.
67. estimator.fit(x_train, y_train)
69. # 5. 模型预测.
70. y_predict = estimator.predict(x_test)
71. print(f'预测值为:{y_predict}')
72. print(f'权重:{estimator.coef_}')
73. print(f'偏置:{estimator.intercept_}')
75. # 6. 模型评估.
76. # 参1: 真实值, 参2: 预测值
77. # MAE(平均绝对误差) 和 RMSE(均方根误差) 都可以衡量模型的预测效果, 如果更关注异常值, 就用 RMSE
79. print(f'平均绝对误差: {mean_absolute_error(y_test, y_predict)}')
80. print(f'均方误差: {mean_squared_error(y_test, y_predict)}')  # 20.77068478427006
82. print(f'均方根误差: {root_mean_squared_error(y_test, y_predict)}')  # 4.557486674063903
83. print(f'均方根误差: {np.sqrt(mean_squared_error(y_test, y_predict))}')  # 4.557486674063903, 效果同上, sqrt全称是: square root

复制代码

波士顿房价预测_梯度下降解法

1. """
2. 案例:
3.     波士顿房价预测, 梯度下降解法.
5. 回顾:
6.     正规方程解法 和 梯度下降的区别:
7.         相同点: 都可以用来找 损失函数的极小值, 评估 回归模型.
8.         不同点:
9.             正规方程: 一次性求解, 资源开销较大, 适合于小批量干净的数据集, 如果数据没有逆, 也无法计算.
10.             梯度下降: 迭代求解, 资源开销相对较小, 适用于大批量的数据集, 实际开发 更推荐.
11.                 分类:
12.                     全梯度下降
13.                     随机梯度下降
14.                     小批量梯度下降
15.                     随机平均梯度下降
17.     线性回归模型 评估的方案:
18.         方案1: 平均绝对误差, Mean Absolute Error,  误差绝对值的和 的 平均值.
19.         方案2: 均方误差, Mean Squared Error, 误差的平方和的平均值
20.         方案3: 均方根误差, Root Mean Squared Error, 误差的平方和的平均值的 平方根.
22.     机器学习项目的研发流程:
23.         1. 获取数据.
24.         2. 数据的预处理.
25.         3. 特征工程.
26.             特征提取, 特征预处理(标准化, 归一化), 特征降维, 特征选取, 特征组合.
27.         4. 模型训练.
28.         5. 模型评估.
29.         6. 模型预测.
30. """
32. # 导包
33. # from sklearn.datasets import load_boston                # 数据
34. from sklearn.preprocessing import StandardScaler  # 特征处理
35. from sklearn.model_selection import train_test_split  # 数据集划分
36. from sklearn.linear_model import LinearRegression  # 正规方程的回归模型
37. from sklearn.linear_model import SGDRegressor  # 梯度下降的回归模型
38. from sklearn.metrics import mean_squared_error, mean_absolute_error, \
39.     root_mean_squared_error  # 均方误差评估, 平均绝对值误差评估, 均方根误差评估
40. import pandas as pd
41. import numpy as np
43. # 1. 获取数据.
44. data_url = "http://lib.stat.cmu.edu/datasets/boston"
45. raw_df = pd.read_csv(data_url, sep="\\s+", skiprows=22, header=None)
46. data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])
47. target = raw_df.values[1::2, 2]
48. print(f'特征: {len(data)}, {data[:3]}')
49. print(f'标签: {len(target)}, {target[:3]}')
51. # 2. 数据的预处理.                                            特征   标签    测试集占比           随机种子
52. x_train, x_test, y_train, y_test = train_test_split(data, target, test_size=0.2, random_state=22)
54. # 3. 特征工程, 特征提取, 特征预处理(标准化, 归一化), 特征降维, 特征选取, 特征组合.
55. # 3.1 创建标准化对象.
56. transfer = StandardScaler()
57. # 3.2 对训练和 和 测试集的 特征进行标准化处理.
58. x_train = transfer.fit_transform(x_train)
59. x_test = transfer.transform(x_test)
61. # 4. 模型训练.
62. # 4.1 创建 线性回归之 梯度下降对象.
63. # 参数: fit_intercept: 是否计算截距(bias, 偏置), 默认是: True
64. # estimator = LinearRegression(fit_intercept=True)
65. #                            参1: 是否计算偏置   参2 : 学习率固定为常量     参3: 学习率的值
66. estimator = SGDRegressor(fit_intercept=True, learning_rate='constant', eta0=0.008)
67. # 4.2 模型训练.4
68. estimator.fit(x_train, y_train)
70. # 5. 模型预测.
71. y_predict = estimator.predict(x_test)
72. print(f'权重: {estimator.coef_}')
73. print(f'偏置: {estimator.intercept_}')
74. print('-' * 22)
76. # 6. 模型评估.
77. # 参1: 真实值, 参2: 预测值
78. # MAE(平均绝对误差) 和 RMSE(均方根误差) 都可以衡量模型的预测效果, 如果更关注异常值, 就用 RMSE
79. print(f'平均绝对误差: {mean_absolute_error(y_test, y_predict)}')
80. print(f'均方误差: {mean_squared_error(y_test, y_predict)}')
82. print(f'均方根误差: {root_mean_squared_error(y_test, y_predict)}')
83. print(f'均方根误差: {np.sqrt(mean_squared_error(y_test, y_predict))}')

复制代码

正则化办理过拟合案例

1. """
2. 案例:
3.     演示正则化解决 拟合问题.
5. 回顾:
6.     拟合: 指的是 模型和数据之间存在关系, 即: 预测值 和 真实值之间的关系.
7.     欠拟合: 模型在训练集, 测试集标签都不好.
8.         原因: 模型过于简单了.
9.     过拟合: 模型在训练集表现好, 在测试集表现不好.
10.         原因: 模型过于复杂了, 数据不纯, 数据量少.
11.     正好拟合(泛化): 模型在训练集, 测试集都好
13.     奥卡姆剃刀: 在误差相同(泛化程度一样)的情况下, 优先选择简单的模型.
15. 正则化解释:
16.     概述:
17.         正则化: 是一种对模型复杂度的一种控制, 通过 降低特征的权重 实现.
18.     分类:
19.         L1正则化, 指的是: Lasso模块, 会 降低权重, 甚至可能降为0 -> 特征选取.
20.         L2正则化, 指的是: Ridge模块, 会 降低权重, 但不会降为0.
21. """
22. # 导包
23. import numpy as np  # 主要是做数学相关运算操作等.
24. import matplotlib.pyplot as plt  # Matplotlib绘图的
25. from sklearn.linear_model import LinearRegression, Lasso, Ridge  # 线性回归的 正规方程解法, L1正则化, L2正则化.
26. from sklearn.metrics import mean_squared_error, root_mean_squared_error, mean_absolute_error  # 计算均方误差, 均方根误差, 平均绝对误差
27. from sklearn.model_selection import train_test_split  # 切割测试集和训练集.
30. # 1. 定义函数, 演示: 欠拟合情况.
31. def dm01_模型欠拟合():
32.     # 1. 生成数据.
33.     # 1.1 指定随机数种子, 种子一样, 则每次生成的随机数的规则都是相同的.
34.     np.random.seed(22)
35.     # 1.2 生成x轴的坐标.
36.     x = np.random.uniform(-3, 3, size=100)
37.     # 1.3 基于x轴的值, 结合线性公式, 生成y轴的值.
38.     # 回顾一元线性回归公式: y = kx + b, 这里为了数据效果更好, 加入噪声...
39.     # 即: y = 0.5x² + x + 2 + 噪声(正太分布生成的随机数).
40.     #  np.random.normal(0, 1, size=100)意思是: 生成正态分布的随机数, 均值是0, 标准差是1, 随机数个数是100.
41.     y = 0.5 * x ** 2 + x + 2 + np.random.normal(0, 1, size=100)
42.     # 1.4 查看数据集.
43.     print(f'x轴的值: {x}')     #  [1, 2, 3]
44.     print(f'y轴的值: {y}')
46.     # 2. 数据的预处理.
47.     X1 = x.reshape(-1, 1)
48.     print(f'处理后, X: {X1}')   # [[1], [2], [3]]
50.     # 3. 创建模型(算法)对象.
51.     # 3.1 线性回归的 正规方程对象.
52.     estimator = LinearRegression()
53.     # 3.2 模型训练.
54.     estimator.fit(X1, y)
56.     # 4. 模型预测.
57.     y_predict = estimator.predict(X1)
58.     print(f'预测值: {y_predict}')
60.     # 5. 模型评估.
61.     print(f'均方误差: {mean_squared_error(y, y_predict)}')
62.     print(f'均方根误差: {root_mean_squared_error(y, y_predict)}')
63.     print(f'平均绝对误差: {mean_absolute_error(y, y_predict)}')
65.     # 6. 绘制图形.
66.     plt.scatter(x, y)                           # 真实值的x轴, y轴 绘制散点图.
67.     plt.plot(x, y_predict, color='red')   # 预测值的x轴, y轴 绘制折线图(充当拟合回归线)
68.     plt.show()
71. # 2. 定义函数, 演示: 正好拟合的情况.
72. def dm02_模型正好拟合():
73.     # 1. 生成数据.
74.     # 1.1 指定随机数种子, 种子一样, 则每次生成的随机数的规则都是相同的.
75.     np.random.seed(22)
76.     # 1.2 生成x轴的坐标.
77.     x = np.random.uniform(-3, 3, size=100)
78.     # 1.3 基于x轴的值, 结合线性公式, 生成y轴的值.
79.     # 回顾一元线性回归公式: y = kx + b, 这里为了数据效果更好, 加入噪声...
80.     # 即: y = 0.5x² + x + 2 + 噪声(正太分布生成的随机数).
81.     #  np.random.normal(0, 1, size=100)意思是: 生成正态分布的随机数, 均值是0, 标准差是1, 随机数个数是100.
82.     y = 0.5 * x ** 2 + x + 2 + np.random.normal(0, 1, size=100)
83.     # 1.4 查看数据集.
84.     print(f'x轴的值: {x}')     # [1, 2, 3]
85.     print(f'y轴的值: {y}')
87.     # 2. 数据的预处理.
88.     X1 = x.reshape(-1, 1)
89.     # np.hstack()解释: 垂直合并, 即: 竖直方向合并.
90.     X2 = np.hstack([X1, X1 ** 2])
91.     print(f'处理后, X1: {X1}')   # [[1], [2], [3]]
92.     print(f'处理后, X2: {X2}')   # [[1, 1], [2, 4], [3, 9]]
94.     # 3. 创建模型(算法)对象.
95.     # 3.1 线性回归的 正规方程对象.
96.     estimator = LinearRegression()
97.     # 3.2 模型训练.
98.     estimator.fit(X2, y)
100.     # 4. 模型预测.
101.     y_predict = estimator.predict(X2)
102.     print(f'预测值: {y_predict}')
104.     # 5. 模型评估.
105.     print(f'均方误差: {mean_squared_error(y, y_predict)}')
106.     print(f'均方根误差: {root_mean_squared_error(y, y_predict)}')
107.     print(f'平均绝对误差: {mean_absolute_error(y, y_predict)}')
109.     # 6. 绘制图形.
110.     # 6.1 真实值的x轴, y轴 绘制散点图.
111.     plt.scatter(x, y)
112.     # 6.2 根据预测值的x轴(升序排序), y轴值, 绘制折线图(充当拟合回归线).
113.     plt.plot(np.sort(x), y_predict[np.argsort(x)], color='red')   # 预测值的x轴, y轴 绘制折线图(充当拟合回归线)
114.     plt.show()
117. # 3. 定义函数, 演示: 过拟合的情况.
118. def dm03_模型过拟合():
119.     # 1. 生成数据.
120.     # 1.1 指定随机数种子, 种子一样, 则每次生成的随机数的规则都是相同的.
121.     np.random.seed(22)
122.     # 1.2 生成x轴的坐标.
123.     x = np.random.uniform(-3, 3, size=100)
124.     # 1.3 基于x轴的值, 结合线性公式, 生成y轴的值.
125.     # 回顾一元线性回归公式: y = kx + b, 这里为了数据效果更好, 加入噪声...
126.     # 即: y = 0.5x² + x + 2 + 噪声(正太分布生成的随机数).
127.     #  np.random.normal(0, 1, size=100)意思是: 生成正态分布的随机数, 均值是0, 标准差是1, 随机数个数是100.
128.     y = 0.5 * x ** 2 + x + 2 + np.random.normal(0, 1, size=100)
129.     # 1.4 查看数据集.
130.     print(f'x轴的值: {x}')     # [1, 2, 3]
131.     print(f'y轴的值: {y}')
133.     # 2. 数据的预处理.
134.     X1 = x.reshape(-1, 1)
135.     # np.hstack()解释: 垂直合并, 即: 竖直方向合并.
136.     X3 = np.hstack([X1, X1 ** 2, X1 ** 3, X1 ** 4, X1 ** 5, X1 ** 6, X1 ** 7, X1 ** 8, X1 ** 9, X1 ** 10])
137.     print(f'处理后, X1: {X1}')   # [[1], [2], [3]]
138.     print(f'处理后, X3: {X3}')   # [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024], [3, 9, 27...]]
140.     # 3. 创建模型(算法)对象.
141.     # 3.1 线性回归的 正规方程对象.
142.     estimator = LinearRegression()
143.     # 3.2 模型训练.
144.     estimator.fit(X3, y)
146.     # 4. 模型预测.
147.     y_predict = estimator.predict(X3)
148.     print(f'预测值: {y_predict}')
150.     # 5. 模型评估.
151.     print(f'均方误差: {mean_squared_error(y, y_predict)}')
152.     print(f'均方根误差: {root_mean_squared_error(y, y_predict)}')
153.     print(f'平均绝对误差: {mean_absolute_error(y, y_predict)}')
155.     # 6. 绘制图形.
156.     # 6.1 真实值的x轴, y轴 绘制散点图.
157.     plt.scatter(x, y)
158.     # 6.2 根据预测值的x轴(升序排序), y轴值, 绘制折线图(充当拟合回归线).
159.     plt.plot(np.sort(x), y_predict[np.argsort(x)], color='red')   # 预测值的x轴, y轴 绘制折线图(充当拟合回归线)
160.     plt.show()
163. # 4. 定义函数, 演示: L1正则化 解决 过拟合.
164. def dm04_L1正则化():
165.     # 1. 生成数据.
166.     # 1.1 指定随机数种子, 种子一样, 则每次生成的随机数的规则都是相同的.
167.     np.random.seed(22)
168.     # 1.2 生成x轴的坐标.
169.     x = np.random.uniform(-3, 3, size=100)
170.     # 1.3 基于x轴的值, 结合线性公式, 生成y轴的值.
171.     # 回顾一元线性回归公式: y = kx + b, 这里为了数据效果更好, 加入噪声...
172.     # 即: y = 0.5x² + x + 2 + 噪声(正太分布生成的随机数).
173.     #  np.random.normal(0, 1, size=100)意思是: 生成正态分布的随机数, 均值是0, 标准差是1, 随机数个数是100.
174.     y = 0.5 * x ** 2 + x + 2 + np.random.normal(0, 1, size=100)
175.     # 1.4 查看数据集.
176.     print(f'x轴的值: {x}')     # [1, 2, 3]
177.     print(f'y轴的值: {y}')
179.     # 2. 数据的预处理.
180.     X1 = x.reshape(-1, 1)
181.     # np.hstack()解释: 垂直合并, 即: 竖直方向合并.
182.     X3 = np.hstack([X1, X1 ** 2, X1 ** 3, X1 ** 4, X1 ** 5, X1 ** 6, X1 ** 7, X1 ** 8, X1 ** 9, X1 ** 10])
183.     print(f'处理后, X1: {X1}')   # [[1], [2], [3]]
184.     print(f'处理后, X3: {X3}')   # [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024], [3, 9, 27...]]
186.     # 3. 创建模型(算法)对象.
187.     # 3.1 线性回归的 正规方程对象.
188.     # estimator = LinearRegression()
190.     # 创建 L1正则化对象.
191.     # 参数alpha: 正则化的(惩罚)系数, (惩罚)系数越大, 则正则化项的权重越小.
192.     estimator = Lasso(alpha=0.1)
194.     # 3.2 模型训练.
195.     estimator.fit(X3, y)
197.     # 4. 模型预测.
198.     y_predict = estimator.predict(X3)
199.     print(f'预测值: {y_predict}')
201.     # 5. 模型评估.
202.     print(f'均方误差: {mean_squared_error(y, y_predict)}')
203.     print(f'均方根误差: {root_mean_squared_error(y, y_predict)}')
204.     print(f'平均绝对误差: {mean_absolute_error(y, y_predict)}')
206.     # 6. 绘制图形.
207.     # 6.1 真实值的x轴, y轴 绘制散点图.
208.     plt.scatter(x, y)
209.     # 6.2 根据预测值的x轴(升序排序), y轴值, 绘制折线图(充当拟合回归线).
210.     plt.plot(np.sort(x), y_predict[np.argsort(x)], color='red')   # 预测值的x轴, y轴 绘制折线图(充当拟合回归线)
211.     plt.show()
214. # 5. 定义函数, 演示: L2正则化 解决 过拟合.
215. def dm05_L2正则化():
216.     # 1. 生成数据.
217.     # 1.1 指定随机数种子, 种子一样, 则每次生成的随机数的规则都是相同的.
218.     np.random.seed(22)
219.     # 1.2 生成x轴的坐标.
220.     x = np.random.uniform(-3, 3, size=100)
221.     # 1.3 基于x轴的值, 结合线性公式, 生成y轴的值.
222.     # 回顾一元线性回归公式: y = kx + b, 这里为了数据效果更好, 加入噪声...
223.     # 即: y = 0.5x² + x + 2 + 噪声(正太分布生成的随机数).
224.     #  np.random.normal(0, 1, size=100)意思是: 生成正态分布的随机数, 均值是0, 标准差是1, 随机数个数是100.
225.     y = 0.5 * x ** 2 + x + 2 + np.random.normal(0, 1, size=100)
226.     # 1.4 查看数据集.
227.     print(f'x轴的值: {x}')     # [1, 2, 3]
228.     print(f'y轴的值: {y}')
230.     # 2. 数据的预处理.
231.     X1 = x.reshape(-1, 1)
232.     # np.hstack()解释: 垂直合并, 即: 竖直方向合并.
233.     X3 = np.hstack([X1, X1 ** 2, X1 ** 3, X1 ** 4, X1 ** 5, X1 ** 6, X1 ** 7, X1 ** 8, X1 ** 9, X1 ** 10])
234.     print(f'处理后, X1: {X1}')   # [[1], [2], [3]]
235.     print(f'处理后, X3: {X3}')   # [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024], [3, 9, 27...]]
237.     # 3. 创建模型(算法)对象.
238.     # 3.1 线性回归的 正规方程对象.
239.     # estimator = LinearRegression()
241.     # 创建 L1正则化对象.
242.     # 参数alpha: 正则化的(惩罚)系数, (惩罚)系数越大, 则正则化项的权重越小.
243.     # estimator = Lasso(alpha=0.1)
245.     # 创建 L2正则化对象.
246.     estimator = Ridge(alpha=0.1)
248.     # 3.2 模型训练.
249.     estimator.fit(X3, y)
251.     # 4. 模型预测.
252.     y_predict = estimator.predict(X3)
253.     print(f'预测值: {y_predict}')
255.     # 5. 模型评估.
256.     print(f'均方误差: {mean_squared_error(y, y_predict)}')
257.     print(f'均方根误差: {root_mean_squared_error(y, y_predict)}')
258.     print(f'平均绝对误差: {mean_absolute_error(y, y_predict)}')
260.     # 6. 绘制图形.
261.     # 6.1 真实值的x轴, y轴 绘制散点图.
262.     plt.scatter(x, y)
263.     # 6.2 根据预测值的x轴(升序排序), y轴值, 绘制折线图(充当拟合回归线).
264.     plt.plot(np.sort(x), y_predict[np.argsort(x)], color='red')   # 预测值的x轴, y轴 绘制折线图(充当拟合回归线)
265.     plt.show()
268. # 6. 在main方法中测试.
269. if __name__ == '__main__':
270.     # dm01_模型欠拟合()
271.     # dm02_模型正好拟合()
272.     # dm03_模型过拟合()
273.     # dm04_L1正则化()
274.     dm05_L2正则化()

复制代码

对峙分享 共同进步 如有错误 欢迎指出

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。