吴恩达机器学习-C2W3-应用机器学习的建议

最新推荐文章于 2024-08-30 16:54:17 发布

暖季啊

最新推荐文章于 2024-08-30 16:54:17 发布

阅读量834

点赞数 21

分类专栏：学习笔记机器学习文章标签：机器学习人工智能

本文链接：https://blog.csdn.net/weixin_50946965/article/details/141354124

版权

学习笔记同时被 2 个专栏收录

28 篇文章 0 订阅

订阅专栏

机器学习

20 篇文章 0 订阅

订阅专栏

在本实验中，您将探索评估和改进机器学习模型的技术。

在这里插入图片描述

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_\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}$

训练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$ and $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_{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}$

训练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$
- 调整模型参数，如复杂性，正则化和数量的例子与交叉验证集
- 使用测试集评估你的“真实世界”表现。
比较训练和交叉验证性能，可以深入了解模型过度拟合(高方差)或欠拟合(高偏差)的倾向。

暖季啊

关注

21
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
吴恩达机器学习-C2W3-应用机器学习的建议

吴恩达机器学习实验室中文翻译-C2W3-应用机器学习的建议
复制链接

扫一扫

专栏目录