在本实验中，您将探索评估和改进机器学习模型的技术。
1-调包
首先，让我们运行下面的单元格来导入在此任务中需要的所有包。
- numpy
- matplotlib
- scikitlearn
- tensorflow
import numpy as np
%matplotlib widget
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression, Ridge
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.activations import relu,linear
from tensorflow.keras.losses import SparseCategoricalCrossentropy
from tensorflow.keras.optimizers import Adam
import logging
logging.getLogger("tensorflow").setLevel(logging.ERROR)
from public_tests_a1 import *
tf.keras.backend.set_floatx('float64')
from assigment_utils import *
tf.autograph.set_verbosity(0)
2 -评估学习算法(多项式回归)
假设你创建了一个机器学习模型，你发现它非常适合你的训练数据。你做了什么?不完全是。创建模型的目标是能够预测new示例的值。
在部署新数据之前，如何在新数据上测试模型的性能?
答案有两个部分:
- 将原始数据集拆分为“训练”和“测试”集。
- 使用训练数据拟合模型参数
- 使用测试数据在新数据上评估模型
- 开发一个误差函数来评估你的模型。
2.1拆分数据集
讲座建议保留20-40%的数据集用于测试。让我们使用一个sklearn函数train_test_split来执行分割。运行以下单元格后再次检查形状。
# Generate some data
X,y,x_ideal,y_ideal = gen_data(18, 2, 0.7)
print("X.shape", X.shape, "y.shape", y.shape)
#split the data using sklearn routine
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.33, random_state=1)
print("X_train.shape", X_train.shape, "y_train.shape", y_train.shape)
print("X_test.shape", X_test.shape, "y_test.shape", y_test.shape)
2.1.1 plot 训练，test 设置
您可以在下面看到，将成为训练一部分的数据点(红色)与模型未训练的数据点(测试)混合在一起。这个特殊的数据集是一个加了噪声的二次函数。“理想”曲线为参考。
fig, ax = plt.subplots(1,1,figsize=(4,4))
ax.plot(x_ideal, y_ideal, "--", color = "orangered", label="y_ideal", lw=1)
ax.set_title("Training, Test",fontsize = 14)
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.scatter(X_train, y_train, color = "red", label="train")
ax.scatter(X_test, y_test, color = dlc["dlblue"], label="test")
ax.legend(loc='upper left')
plt.show()
2.2模型评价误差计算，线性回归
在评估线性回归模型时，将预测值和目标值的平方误差差取平均值。
J
test
(
w
,
b
)
=
1
2
m
test
∑
i
=
0
m
test
−
1
(
f
w
,
b
(
x
test
(
i
)
)
−
y
test
(
i
)
)
2
(1)
J_\text{test}(\mathbf{w},b) = \frac{1}{2m_\text{test}}\sum_{i=0}^{m_\text{test}-1} ( f_{\mathbf{w},b}(\mathbf{x}^{(i)}_\text{test}) - y^{(i)}_\text{test} )^2 \tag{1}
Jtest(w,b)=2mtest1i=0∑mtest−1(fw,b(xtest(i))−ytest(i))2(1)
训练1
下面，创建一个函数来评估线性回归模型的数据集上的误差。
# UNQ_C1
# GRADED CELL: eval_mse
def eval_mse(y, yhat):
"""
Calculate the mean squared error on a data set.
Args:
y : (ndarray Shape (m,) or (m,1)) target value of each example
yhat : (ndarray Shape (m,) or (m,1)) predicted value of each example
Returns:
err: (scalar)
"""
m = len(y)
err = 0.0
for i in range(m):
### START CODE HERE ###
### END CODE HERE ###
return(err)
y_hat = np.array([2.4, 4.2])
y_tmp = np.array([2.3, 4.1])
eval_mse(y_hat, y_tmp)
# BEGIN UNIT TEST
test_eval_mse(eval_mse)
# END UNIT TEST
2.3对比训练和测试数据的性能
让我们建立一个高次多项式模型来最小化训练误差。这将使用来自’ sklearn '的线性回归函数。如果您想查看详细信息，代码位于导入的实用程序文件中。步骤如下:
- 创建和适合模型。(“fit”是训练或运行梯度下降的另一个名称)。
- 计算训练数据的误差。
- 计算测试数据的误差。
# create a model in sklearn, train on training data
degree = 10
lmodel = lin_model(degree)
lmodel.fit(X_train, y_train)
# predict on training data, find training error
yhat = lmodel.predict(X_train)
err_train = lmodel.mse(y_train, yhat)
# predict on test data, find error
yhat = lmodel.predict(X_test)
err_test = lmodel.mse(y_test, yhat)
训练集的计算误差基本上小于测试集的计算误差。
print(f"training err {err_train:0.2f}, test err {err_test:0.2f}")
下面的图表说明了为什么会这样。该模型与训练数据拟合良好。为此，它创建了一个复杂的函数。测试数据不是训练的一部分，模型在预测这些数据方面做得很差。
该模型将被描述为1)过拟合，2)具有高方差3)“概括”不佳。
# plot predictions over data range
x = np.linspace(0,int(X.max()),100) # predict values for plot
y_pred = lmodel.predict(x).reshape(-1,1)
plt_train_test(X_train, y_train, X_test, y_test, x, y_pred, x_ideal, y_ideal, degree)
测试集误差表明该模型在新数据上不能很好地工作。如果您使用测试错误来指导模型的改进，那么模型将在测试数据上表现良好……但是测试数据是用来表示新数据的。您还需要另一组数据来测试新数据的性能。
讲座中提出的建议是将数据分成三组。下表所示的训练、交叉验证和测试集的分布是一个典型的分布，但可以根据可用数据的数量而变化。
| data | % of total | Description |
|---|---|---|
| training | 60 | Data used to tune model parameters w w w and b b b in training or fitting |
| cross-validation | 20 | Data used to tune other model parameters like degree of polynomial, regularization or the architecture of a neural network. |
| test | 20 | Data used to test the model after tuning to gauge performance on new data |
下面让我们生成三个数据集。我们将再次使用来自’ sklearn ‘的’ train_test_split '，但将调用它两次以获得三次分裂:
# Generate data
X,y, x_ideal,y_ideal = gen_data(40, 5, 0.7)
print("X.shape", X.shape, "y.shape", y.shape)
#split the data using sklearn routine
X_train, X_, y_train, y_ = train_test_split(X,y,test_size=0.40, random_state=1)
X_cv, X_test, y_cv, y_test = train_test_split(X_,y_,test_size=0.50, random_state=1)
print("X_train.shape", X_train.shape, "y_train.shape", y_train.shape)
print("X_cv.shape", X_cv.shape, "y_cv.shape", y_cv.shape)
print("X_test.shape", X_test.shape, "y_test.shape", y_test.shape)
3 -偏差和方差
由此可见，多项式模型的程度过高。如何选择性价比高的产品?事实证明，如图所示，训练和交叉验证性能可以提供指导。通过尝试一定范围的度值，可以评估训练和交叉验证的性能。当交叉验证的程度过大时，交叉验证的性能就会相对于训练性能开始下降。让我们在我们的例子中试试。
3.1情节训练、交叉验证、检验
您可以在下面看到，将成为训练一部分的数据点(红色)与模型未训练的数据点(test和cv)混合在一起。
fig, ax = plt.subplots(1,1,figsize=(4,4))
ax.plot(x_ideal, y_ideal, "--", color = "orangered", label="y_ideal", lw=1)
ax.set_title("Training, CV, Test",fontsize = 14)
ax.set_xlabel("x")
ax.set_ylabel("y")
ax.scatter(X_train, y_train, color = "red", label="train")
ax.scatter(X_cv, y_cv, color = dlc["dlorange"], label="cv")
ax.scatter(X_test, y_test, color = dlc["dlblue"], label="test")
ax.legend(loc='upper left')
plt.show()
3.2寻找最优度
在之前的实验中，你发现你可以通过使用多项式创建一个能够拟合复杂曲线的模型(参见课程1，第二周特征工程和多项式回归实验室)。此外，您还演示了通过增加多项式的程度，可以创建过拟合。(参见课程1，第三周，过度拟合实验)。让我们用这些知识来测试我们区分过拟合和欠拟合的能力。
让我们反复训练模型，每次迭代增加多项式的次数。这里，我们将使用scikit-learn线性回归
max_degree = 9
err_train = np.zeros(max_degree)
err_cv = np.zeros(max_degree)
x = np.linspace(0,int(X.max()),100)
y_pred = np.zeros((100,max_degree)) #columns are lines to plot
for degree in range(max_degree):
lmodel = lin_model(degree+1)
lmodel.fit(X_train, y_train)
yhat = lmodel.predict(X_train)
err_train[degree] = lmodel.mse(y_train, yhat)
yhat = lmodel.predict(X_cv)
err_cv[degree] = lmodel.mse(y_cv, yhat)
y_pred[:,degree] = lmodel.predict(x)
optimal_degree = np.argmin(err_cv)+1
让我们来绘制结果:
plt.close("all")
plt_optimal_degree(X_train, y_train, X_cv, y_cv, x, y_pred, x_ideal, y_ideal,
err_train, err_cv, optimal_degree, max_degree)
上图表明，将数据分为两组，即模型训练过的数据和模型未训练过的数据，可以用来确定模型是欠拟合还是过拟合。在我们的示例中，我们通过增加所使用的多项式的程度，创建了从欠拟合到过拟合的各种模型。
- 在左边的图中，实线代表了这些模型的预测结果。次数为1的多项式模型产生一条与很少数据点相交的直线，而最大次数与每个数据点非常接近。
- 在右边:
- 训练数据上的误差(蓝色)随着模型复杂度的增加而减少
- 交叉验证数据的误差最初随着模型开始符合数据而减小，但随着模型开始过度拟合训练数据(无法泛化)而增大。
值得注意的是，这些例子中的曲线并不像讲课时画的那么光滑。很明显，分配给每一组的特定数据点可以显著改变你的结果。大趋势才是最重要的。
调优正则化
在以前的实验中，您使用正则化来减少过拟合。与degree类似，可以使用相同的方法来调优正则化参数lambda (λ）.
让我们从一个高次多项式开始并改变正则化参数来证明这一点。
lambda_range = np.array([0.0, 1e-6, 1e-5, 1e-4,1e-3,1e-2, 1e-1,1,10,100])
num_steps = len(lambda_range)
degree = 10
err_train = np.zeros(num_steps)
err_cv = np.zeros(num_steps)
x = np.linspace(0,int(X.max()),100)
y_pred = np.zeros((100,num_steps)) #columns are lines to plot
for i in range(num_steps):
lambda_= lambda_range[i]
lmodel = lin_model(degree, regularization=True, lambda_=lambda_)
lmodel.fit(X_train, y_train)
yhat = lmodel.predict(X_train)
err_train[i] = lmodel.mse(y_train, yhat)
yhat = lmodel.predict(X_cv)
err_cv[i] = lmodel.mse(y_cv, yhat)
y_pred[:,i] = lmodel.predict(x)
optimal_reg_idx = np.argmin(err_cv)
plt.close("all")
plt_tune_regularization(X_train, y_train, X_cv, y_cv, x, y_pred, err_train, err_cv, optimal_reg_idx, lambda_range)
上面的图显示，随着正则化的增加，模型从高方差(过拟合)模型移动到高偏差(欠拟合)模型。右图中的垂直线表示lambda的最佳值。在本例中，多项式度设置为10。
3.4获取更多数据:增加训练集大小(m)
当模型过度拟合(高方差)时，收集额外的数据可以提高性能。让我们在这里试试。
X_train, y_train, X_cv, y_cv, x, y_pred, err_train, err_cv, m_range,degree = tune_m()
plt_tune_m(X_train, y_train, X_cv, y_cv, x, y_pred, err_train, err_cv, m_range, degree)
上面的图表明，当一个模型具有高方差和过拟合时，增加更多的样本可以提高性能。注意左图上的曲线。的最大值的最终曲线
是位于数据中心的平滑曲线。在右边，随着样本数量的增加，训练集和交叉验证集的性能收敛到相似的值。注意，这些曲线并不像你在课堂上看到的那样平滑。这是意料之中的。趋势仍然很明显:更多的数据可以提高归纳能力。
请注意，当模型具有高偏差(欠拟合)时，添加更多的示例并不能提高性能。
评估学习算法(神经网络)
上面，您调优了多项式回归模型的各个方面。在这里，您将使用神经网络模型。让我们从创建一个分类数据集开始。
4.1数据集
运行下面的单元格生成一个数据集，并将其分成训练集、交叉验证集(CV)和测试集。在这个例子中，我们增加了交叉验证数据点的百分比。
# Generate and split data set
X, y, centers, classes, std = gen_blobs()
# split the data. Large CV population for demonstration
X_train, X_, y_train, y_ = train_test_split(X,y,test_size=0.50, random_state=1)
X_cv, X_test, y_cv, y_test = train_test_split(X_,y_,test_size=0.20, random_state=1)
print("X_train.shape:", X_train.shape, "X_cv.shape:", X_cv.shape, "X_test.shape:", X_test.shape)
plt_train_eq_dist(X_train, y_train,classes, X_cv, y_cv, centers, std)
在上面，您可以看到左侧的数据。按颜色分为六组。同时显示训练点(点)和交叉验证点(三角形)。有趣的是那些落在模糊位置的点，任何一个集群都可能认为它们是成员。你期望神经网络模型能做什么?过拟合的例子是什么?underfitting吗?
右边是一个“理想”模型的例子，或者是一个知道数据来源后可能创建的模型。这些线表示中心点之间的距离相等的“等距”边界。值得注意的是，这个模型会“错误分类”大约8%的总数据集。
4.2通过计算分类误差来评价分类模型
这里使用的分类模型的评估函数只是不正确预测的比例:
J
c
v
=
1
m
∑
i
=
0
m
−
1
{
1
,
if
y
^
(
i
)
≠
y
(
i
)
0
,
otherwise
J_{cv} =\frac{1}{m}\sum_{i=0}^{m-1} \begin{cases} 1, & \text{if $\hat{y}^{(i)} \neq y^{(i)}$}\\ 0, & \text{otherwise} \end{cases}
Jcv=m1i=0∑m−1{1,0,if y^(i)=y(i)otherwise
训练2
下面，完成计算分类误差的例程。注意，在本实验中，目标值是类别的索引，并不是一次性编码的。
# UNQ_C2
# GRADED CELL: eval_cat_err
def eval_cat_err(y, yhat):
"""
Calculate the categorization error
Args:
y : (ndarray Shape (m,) or (m,1)) target value of each example
yhat : (ndarray Shape (m,) or (m,1)) predicted value of each example
Returns:|
cerr: (scalar)
"""
m = len(y)
incorrect = 0
for i in range(m):
### START CODE HERE ###
### END CODE HERE ###
return(cerr)
y_hat = np.array([1, 2, 0])
y_tmp = np.array([1, 2, 3])
print(f"categorization error {np.squeeze(eval_cat_err(y_hat, y_tmp)):0.3f}, expected:0.333" )
y_hat = np.array([[1], [2], [0], [3]])
y_tmp = np.array([[1], [2], [1], [3]])
print(f"categorization error {np.squeeze(eval_cat_err(y_hat, y_tmp)):0.3f}, expected:0.250" )
# BEGIN UNIT TEST
test_eval_cat_err(eval_cat_err)
# END UNIT TEST
# BEGIN UNIT TEST
test_eval_cat_err(eval_cat_err)
# END UNIT TEST
点击查看提示
def eval_cat_err(y, yhat):
"""
Calculate the categorization error
Args:
y : (ndarray Shape (m,) or (m,1)) target value of each example
yhat : (ndarray Shape (m,) or (m,1)) predicted value of each example
Returns:|
cerr: (scalar)
"""
m = len(y)
incorrect = 0
for i in range(m):
if yhat[i] != y[i]: # @REPLACE
incorrect += 1 # @REPLACE
cerr = incorrect/m # @REPLACE
return(cerr)
5 -模型复杂性
下面，您将构建两个模型。一个复杂的模型和一个简单的模型。您将评估模型，以确定它们是否可能过拟合或欠拟合。
5.1复杂模型
训练3
下面，组成一个三层模型:
- 有120个单位的密集层，可轻松激活
- 有40个单位的密集层，可轻松激活
- 密集层与6个单位和线性激活(不是softmax)
编译使用 - 丢失’ SparseCategoricalCrossentropy ‘，记得使用’ from_logits=True ’
- Adam优化器，学习率为0.01。
# UNQ_C3
# GRADED CELL: model
import logging
logging.getLogger("tensorflow").setLevel(logging.ERROR)
tf.random.set_seed(1234)
model = Sequential(
[
### START CODE HERE ###
### END CODE HERE ###
], name="Complex"
)
model.compile(
### START CODE HERE ###
loss=None,
optimizer=None,
### END CODE HERE ###
)
# BEGIN UNIT TEST
model.fit(
X_train, y_train,
epochs=1000
)
# END UNIT TEST
# BEGIN UNIT TEST
model.summary()
model_test(model, classes, X_train.shape[1])
# END UNIT TEST
提示：
tf.random.set_seed(1234)
model = Sequential(
[
Dense(120, activation = 'relu', name = "L1"),
Dense(40, activation = 'relu', name = "L2"),
Dense(classes, activation = 'linear', name = "L3")
], name="Complex"
)
model.compile(
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
optimizer=tf.keras.optimizers.Adam(0.01),
)
model.fit(
X_train,y_train,
epochs=1000
)
#make a model for plotting routines to call
model_predict = lambda Xl: np.argmax(tf.nn.softmax(model.predict(Xl)).numpy(),axis=1)
plt_nn(model_predict,X_train,y_train, classes, X_cv, y_cv, suptitle="Complex Model")
这个模型非常努力地捕捉每一类别的异常值。因此，它错误地分类了一些交叉验证数据。让我们计算一下分类误差。
training_cerr_complex = eval_cat_err(y_train, model_predict(X_train))
cv_cerr_complex = eval_cat_err(y_cv, model_predict(X_cv))
print(f"categorization error, training, complex model: {training_cerr_complex:0.3f}")
print(f"categorization error, cv, complex model: {cv_cerr_complex:0.3f}")
5.1简单模型
现在，让我们尝试一个简单的模型
训练4
下面，组成一个两层模型:
- 密集层6个单位，轻松激活
- 密集层与6个单位和一个线性激活。编译使用
- 丢失’ SparseCategoricalCrossentropy ‘，记得使用’ from_logits=True ’
- Adam优化器，学习率为0.01。
# UNQ_C4
# GRADED CELL: model_s
tf.random.set_seed(1234)
model_s = Sequential(
[
### START CODE HERE ###
### END CODE HERE ###
], name = "Simple"
)
model_s.compile(
### START CODE HERE ###
loss=None,
optimizer=None,
### START CODE HERE ###
)
import logging
logging.getLogger("tensorflow").setLevel(logging.ERROR)
# BEGIN UNIT TEST
model_s.fit(
X_train,y_train,
epochs=1000
)
# END UNIT TEST
# BEGIN UNIT TEST
model_s.summary()
model_s_test(model_s, classes, X_train.shape[1])
# END UNIT TEST
代码提示：
tf.random.set_seed(1234)
model_s = Sequential(
[
Dense(6, activation = 'relu', name="L1"), # @REPLACE
Dense(classes, activation = 'linear', name="L2") # @REPLACE
], name = "Simple"
)
model_s.compile(
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), # @REPLACE
optimizer=tf.keras.optimizers.Adam(0.01), # @REPLACE
)
model_s.fit(
X_train,y_train,
epochs=1000
)
#make a model for plotting routines to call
model_predict_s = lambda Xl: np.argmax(tf.nn.softmax(model_s.predict(Xl)).numpy(),axis=1)
plt_nn(model_predict_s,X_train,y_train, classes, X_cv, y_cv, suptitle="Simple Model")
这个简单的模型做得很好。让我们计算一下分类误差。
training_cerr_simple = eval_cat_err(y_train, model_predict_s(X_train))
cv_cerr_simple = eval_cat_err(y_cv, model_predict_s(X_cv))
print(f"categorization error, training, simple model, {training_cerr_simple:0.3f}, complex model: {training_cerr_complex:0.3f}" )
print(f"categorization error, cv, simple model, {cv_cerr_simple:0.3f}, complex model: {cv_cerr_complex:0.3f}" )
我们的简单模型在训练数据上有更高的分类误差，但在交叉验证数据上比更复杂的模型做得更好。
6 -正则化
在多项式回归的情况下，可以应用正则化来缓和更复杂模型的影响。让我们在下面试试。
训练5
重建您的复杂模型，但这一次包括正则化。
下面，组成一个三层模型:
- 120个单位的密集层，relu激活，’ kernel_regularizer=tf.keras. regularers .l2(0.1) ’
- 40个单元的密集层，relu激活，’ kernel_regularizer=tf.keras. regularers .l2(0.1) ’
- 密集层与6个单位和一个线性激活。编译使用
- 丢失’ SparseCategoricalCrossentropy ‘，记得使用’ from_logits=True ’
- Adam优化器，学习率为0.01。
# UNQ_C5
# GRADED CELL: model_r
tf.random.set_seed(1234)
model_r = Sequential(
[
### START CODE HERE ###
### START CODE HERE ###
], name= None
)
model_r.compile(
### START CODE HERE ###
loss=None,
optimizer=None,
### START CODE HERE ###
)
# BEGIN UNIT TEST
model_r.fit(
X_train, y_train,
epochs=1000
)
# END UNIT TEST
# BEGIN UNIT TEST
model_r.summary()
model_r_test(model_r, classes, X_train.shape[1])
# END UNIT TEST
代码提示：
tf.random.set_seed(1234)
model_r = Sequential(
[
Dense(120, activation = 'relu', kernel_regularizer=tf.keras.regularizers.l2(0.1), name="L1"),
Dense(40, activation = 'relu', kernel_regularizer=tf.keras.regularizers.l2(0.1), name="L2"),
Dense(classes, activation = 'linear', name="L3")
], name="ComplexRegularized"
)
model_r.compile(
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
optimizer=tf.keras.optimizers.Adam(0.01),
)
model_r.fit(
X_train,y_train,
epochs=1000
)
#make a model for plotting routines to call
model_predict_r = lambda Xl: np.argmax(tf.nn.softmax(model_r.predict(Xl)).numpy(),axis=1)
plt_nn(model_predict_r, X_train,y_train, classes, X_cv, y_cv, suptitle="Regularized")
结果看起来与“理想”模型非常相似。让我们检查一下分类错误。
training_cerr_reg = eval_cat_err(y_train, model_predict_r(X_train))
cv_cerr_reg = eval_cat_err(y_cv, model_predict_r(X_cv))
test_cerr_reg = eval_cat_err(y_test, model_predict_r(X_test))
print(f"categorization error, training, regularized: {training_cerr_reg:0.3f}, simple model, {training_cerr_simple:0.3f}, complex model: {training_cerr_complex:0.3f}" )
print(f"categorization error, cv, regularized: {cv_cerr_reg:0.3f}, simple model, {cv_cerr_simple:0.3f}, complex model: {cv_cerr_complex:0.3f}" )
简单模型在训练集中优于正则化模型，但在交叉验证集中表现较差。
7-迭代找到最优正则化值
正如在线性回归中所做的那样，您可以尝试许多正则化值。这段代码需要几分钟才能运行。如果您有时间，您可以运行它并检查结果。如果没有，你已经完成了作业的评分部分!
tf.random.set_seed(1234)
lambdas = [0.0, 0.001, 0.01, 0.05, 0.1, 0.2, 0.3]
models=[None] * len(lambdas)
for i in range(len(lambdas)):
lambda_ = lambdas[i]
models[i] = Sequential(
[
Dense(120, activation = 'relu', kernel_regularizer=tf.keras.regularizers.l2(lambda_)),
Dense(40, activation = 'relu', kernel_regularizer=tf.keras.regularizers.l2(lambda_)),
Dense(classes, activation = 'linear')
]
)
models[i].compile(
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
optimizer=tf.keras.optimizers.Adam(0.01),
)
models[i].fit(
X_train,y_train,
epochs=1000
)
print(f"Finished lambda = {lambda_}")
plot_iterate(lambdas, models, X_train, y_train, X_cv, y_cv)
随着正则化程度的提高，模型在训练数据集和交叉验证数据集上的性能趋于收敛。对于这个数据集和模型，lambda > 0.01似乎是一个合理的选择。
7.1测试
让我们在测试集上尝试我们优化的模型，并将它们与“理想”性能进行比较。
plt_compare(X_test,y_test, classes, model_predict_s, model_predict_r, centers)
我们的测试集很小，似乎有很多异常值，所以分类误差很高。然而，我们优化的模型的性能与理想性能相当。
祝贺
您已经熟悉了在评估机器学习模型时应用的重要工具。即:
*将数据分为训练集和未训练集，可以区分过拟合和欠拟合
- 创建三个数据集，训练，交叉验证和测试允许您
- 用训练集训练你的参数 W , B W,B W,B
- 调整模型参数，如复杂性，正则化和数量的例子与交叉验证集
- 使用测试集评估你的“真实世界”表现。
- 比较训练和交叉验证性能，可以深入了解模型过度拟合(高方差)或欠拟合(高偏差)的倾向。
