超参数调整和实验-训练深度神经网络 | PyTorch系列（二十六）

最新推荐文章于 2024-08-29 06:45:00 发布

flyfor2013

最新推荐文章于 2024-08-29 06:45:00 发布

阅读量2.1k

点赞数 2

文章标签： python 人工智能深度学习大数据编程语言

本文链接：https://blog.csdn.net/flyfor2013/article/details/112300883

版权

点击上方“AI算法与图像处理”，选择加"星标"或“置顶”

重磅干货，第一时间送达

文 |AI_study

原标题：Hyperparameter Tuning And Experimenting - Training Deep Neural Networks

为TensorBoard命名训练运行

为了利用TensorBoard的比较功能，我们需要执行多次运行，并以一种我们可以唯一标识它的方式来命名每个运行。

使用PyTorch的SummaryWriter，当writer对象实例被创建时，运行就开始了，当writer实例被关闭或超出作用域时，运行就结束了。

要惟一地标识每个运行，我们可以直接设置运行的文件名，或者将注释字符串传递给构造函数，该构造函数将附加到自动生成的文件名中。

在创建这篇文章时，运行的名称包含在SummaryWriter中一个名为log_dir的属性中。它是这样产生的:

# PyTorch version 1.1.0 SummaryWriter class
if not log_dir:
    import socket
    from datetime import datetime
    current_time = datetime.now().strftime('%b%d_%H-%M-%S')
    log_dir = os.path.join(
        'runs', 
        current_time + '_' + socket.gethostname() + comment
    )
self.log_dir = log_di

在这里，我们可以看到log_dir属性(对应于磁盘上的位置和运行的名称)被设置为run + time + host + comment。当然，这是假设log_dir参数没有传入的值。因此，这是默认的行为。

为运行选择一个名称

命名运行的一种方法是添加参数名和值作为运行的注释。这将允许我们在稍后检查TensorBoard内部的运行时查看每个参数值与其他参数值的堆栈情况。

稍后我们会看到我们是这样设置注释的:

tb = SummaryWriter(comment=f' batch_size={batch_size} lr={lr}')

TensorBoard还具有查询功能，因此我们可以很容易地通过查询独立参数值。

例如，假设这个SQL查询:

SELECT * FROM TBL_RUNS WHERE lr = 0.01

没有SQL，这基本上就是我们在TensorBoard中可以做的。

为超参数创建变量

为了简化实验，我们将提取硬编码的值并将它们转换为变量。

这是硬编码的方式:

network = Network()
train_loader = torch.utils.data.DataLoader(
    train_set, batch_size=100
)
optimizer = optim.Adam(
    network.parameters(), lr=0.01
)

注意batch_size和lr参数值是如何硬编码的。

这是我们把它变成(现在我们的值是用变量设置的):

batch_size = 100
lr = 0.01


network = Network()
train_loader = torch.utils.data.DataLoader(
    train_set, batch_size=batch_size
)
optimizer = optim.Adam(
    network.parameters(), lr=lr
)

这将允许我们在单个位置更改值，并让它们在我们的代码中传播。

现在，我们将使用像这样的变量为我们的评论参数创建值:

tb = SummaryWriter(comment=f' batch_size={batch_size} lr={lr}')

通过此设置，我们可以更改超参数的值，并且我们的运行将在TensorBoard中被自动跟踪和识别。

计算不同batch大小的损失

由于我们现在将更改批量大小，因此我们需要更改计算和累积损失的方式。不仅仅是将损失函数返回的损失相加。我们将对其进行调整以适应批次大小。

total_loss += loss.item() * batch_size

为什么这样我们将对cross_entropy损失函数进行平均，以计算批次产生的损失值，然后返回该平均损失。这就是为什么我们需要考虑批次大小的原因。

cross_entropy函数接受一个参数，称为reduction，我们也可以使用。

reduction 参数可选地接受字符串作为参数。此参数指定要应用于损失函数的输出的减少量。

'none' - no reduction will be applied.
'mean' - the sum of the output will be divided by the number of elements in the output.
'sum' - the output will be summed.

请注意，默认值为“平均值”。这就是为什么loss.item（）* batch_size起作用的原因。

试验超参数值

现在我们有了这个设置，我们可以做更多的事情！

我们需要做的就是创建一些列表和一些循环，然后我们可以运行代码，坐下来等待所有组合运行。

这是我们的意思的例子：

参数清单

batch_size_list = [100, 1000, 10000]
lr_list = [.01, .001, .0001, .00001]

嵌套迭代

for batch_size in batch_size_list:
    for lr in lr_list:
        network = Network()


        train_loader = torch.utils.data.DataLoader(
            train_set, batch_size=batch_size
        )
        optimizer = optim.Adam(
            network.parameters(), lr=lr
        )


        images, labels = next(iter(train_loader))
        grid = torchvision.utils.make_grid(images)


        comment=f' batch_size={batch_size} lr={lr}'
        tb = SummaryWriter(comment=comment)
        tb.add_image('images', grid)
        tb.add_graph(network, images)


        for epoch in range(5):
            total_loss = 0
            total_correct = 0
            for batch in train_loader:
                images, labels = batch # Get Batch
                preds = network(images) # Pass Batch
                loss = F.cross_entropy(preds, labels) # Calculate Loss
                optimizer.zero_grad() # Zero Gradients
                loss.backward() # Calculate Gradients
                optimizer.step() # Update Weights


                total_loss += loss.item() * batch_size
                total_correct += get_num_correct(preds, labels)


            tb.add_scalar(
                'Loss', total_loss, epoch
            )
            tb.add_scalar(
                'Number Correct', total_correct, epoch
            )
            tb.add_scalar(
                'Accuracy', total_correct / len(train_set), epoch
            )


            for name, param in network.named_parameters():
                tb.add_histogram(name, param, epoch)
                tb.add_histogram(f'{name}.grad', param.grad, epoch)


            print(
                "epoch", epoch
                ,"total_correct:", total_correct
                ,"loss:", total_loss
            )  
        tb.close()

这段代码完成后，我们将运行TensorBoard，所有运行将以图形方式显示并易于比较。

tensorboard --logdir runs

Batch Size Vs Training Set Size

如果训练集大小不能被批次大小整除，则最后一批数据将包含比其他批次更少的样本。

解决此差异的一种简单方法是删除最后一批。PyTorch DataLoader类使我们能够通过设置drop_last = True来执行此操作。默认情况下，drop_last参数值设置为False。

让我们考虑包括样本数量少于批次大小的批次如何影响上面代码中的total_loss计算。

对于每个批次，我们都使用batch_size变量来更新total_loss值。我们正在按batch_size值按比例放大批次中样品的平均损失值。但是，正如我们刚才所讨论的，有时最后一批将包含更少的样本。因此，按预定义的batch_size值进行缩放是不准确的。

通过动态访问每个批次的样本数量，可以更新Cur代码以更准确。

当前，我们有以下内容：

total_loss += loss.item() * batch_size

使用下面的更新代码，我们可以获得更准确的total_loss值：

total_loss += loss.item() * images.shape[0]

请注意，当训练集大小可被批处理大小整除时，这两行代码为我们提供了相同的total_loss值。

将网络参数和渐变添加到TensorBoard

请注意，在上一集中，我们向TensorBoard添加了以下值：

conv1.weight
conv1.bias
conv1.weight.grad

我们使用以下代码进行了此操作：

tb.add_histogram('conv1.bias', network.conv1.bias, epoch)
tb.add_histogram('conv1.weight', network.conv1.weight, epoch)
tb.add_histogram('conv1.weight.grad', network.conv1.weight.grad, epoch)

现在，我们通过使用以下循环为所有层添加这些值来增强此功能：

for name, weight in network.named_parameters():
    tb.add_histogram(name, weight, epoch)
    tb.add_histogram(f'{name}.grad', weight.grad, epoch)

之所以可行，是因为PyTorch nn.Module方法名为named_parameters（）为我们提供了网络内部所有参数的名称和值。

在不嵌套的情况下添加更多超参数

这很酷。但是，如果我们想添加第三个甚至第四个参数进行迭代该怎么办？我们将，这将使许多嵌套的for循环变得混乱。

有一个解决方案。我们可以为每次运行创建一组参数，并将所有参数打包为一个可迭代的参数。这是我们的方法。

如果有参数列表，则可以使用笛卡尔乘积将它们打包为每个运行的集合。为此，我们将使用itertools库中的product函数。

from itertools import product

Init signature: product(*args, **kwargs)
Docstring:     
"""
product(*iterables, repeat=1) --> product object
Cartesian product of input iterables.  Equivalent to nested for-loops.
"""

接下来，我们定义一个字典，该字典包含作为键的参数和要用作值的参数值。

parameters = dict(
    lr = [.01, .001]
    ,batch_size = [100, 1000]
    ,shuffle = [True, False]
)

接下来，我们将创建可传递给产品函数的可迭代项列表。

param_values = [v for v in parameters.values()]
param_values


[[0.01, 0.001], [100, 1000], [True, False]]

现在，我们有三个参数值列表。取这三个列表的笛卡尔积后，我们将为每个运行提供一组参数值。请注意，这等效于嵌套的for循环，如乘积函数的doc字符串所示。

for lr, batch_size, shuffle in product(*param_values): 
    print (lr, batch_size, shuffle)


0.01 100 True
0.01 100 False
0.01 1000 True
0.01 1000 False
0.001 100 True
0.001 100 False
0.001 1000 True
0.001 1000 False

好了，现在我们可以使用单个for循环遍历每组参数。我们要做的就是使用序列解包对集合进行解包。看起来像这样。

for lr, batch_size, shuffle in product(*param_values): 
    comment = f' batch_size={batch_size} lr={lr} shuffle={shuffle}'


    train_loader = torch.utils.data.DataLoader(
        train_set
        ,batch_size=batch_size
        ,shuffle=shuffle 
    )


    optimizer = optim.Adam(
        network.parameters(), lr=lr
    )


    # Rest of training process given the set of parameters

注意我们构建注释字符串以标识运行的方式。我们只是插入值。另外，请注意*运算符。这是Python中将列表解压缩为一组参数的一种特殊方法。因此，在这种情况下，我们将三个单独的未打包参数传递给与单个列表相对的乘积函数。

这是*，星号，splat，点差运算符的两个参考。这些都是这一名称的通用名称。

Python doc: More Control Flow Tools https://docs.python.org/3/tutorial/controlflow.html#unpacking-argument-lists
PEP 448 -- Additional Unpacking Generalizations
https://www.python.org/dev/peps/pep-0448