Оценка модели PyTorch в Python

В этом разделе мы узнаем, как оценить модель PyTorch в Python.

• eval() — это тип переключателя для определенных частей модели, которые действуют по-разному во время обучения и оценки.
• Он переводит модель в режим оценки, а уровень нормализации использует текущую статистику.

В следующем коде мы импортируем несколько библиотек, из которых сможем оценить модель:

• nn.Conv2d() используется для создания ядра свертки.
• nn.MaxPool2d() используется для применения к входному сигналу, состоящему из нескольких входных плоскостей.
• nn.Linear() используется для создания сетей прямой связи.
• model = TheModelClass() используется для инициализации модели.
• optimizers = optimize.SGD (model.parameters(), lr=0,001, momentum=0,8) используется для инициализации оптимизатора.
• print(«Model state_dict:») используется для печати модели state_sict.
• print(«Optimizer state_dict:») используется для печати оптимизатора state_dict.
• torch.save(model.state_dict(), ‘model_weights.pth’) используется для сохранения модели.
• model.load_state_dict(torch.load(‘model_weights.pth’)) используется для загрузки модели.
• model.eval() используется для оценки модели.

import torch
from torch import nn
import torch.optim as optimize
import torch.nn.functional as f
# Define model
class TheModelClass(nn.Module):
    def __init__(self):
        super(TheModelClass, self).__init__()
        self.conv1 = nn.Conv2d(5, 8, 7)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(8, 18, 7)
        self.fc1 = nn.Linear(18 * 7 * 7, 140)
        self.fc2 = nn.Linear(140, 86)
        self.fc3 = nn.Linear(86, 12)

    def forward(self, X):
        X = self.pool(f.relu(self.conv1(X)))
        X = self.pool(f.relu(self.conv2(X)))
        X = x.view(-1, 16 * 5 * 5)
        X = f.relu(self.fc1(X))
        X = f.relu(self.fc2(X))
        X = self.fc3(X)
        return X

model = TheModelClass()

optimizers = optimize.SGD(model.parameters(), lr=0.001, momentum=0.8)

print("Model state_dict:")
for param_tensor in model.state_dict():
    print(param_tensor, "\t", model.state_dict()[param_tensor].size())

print("Optimizer state_dict:")

torch.save(model.state_dict(), 'model_weights.pth')
model.load_state_dict(torch.load('model_weights.pth'))
model.eval()

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором видим, что данные модели печатаются на экране после оценки.

• Функция eval()
• Набор train()
• Сравнение eval и train
• Сравнение eval и no_grad
• Отключение eval
• Batchnorm
• Оценка модели require_grad

Функция eval()

В этом разделе мы узнаем о функции eval() PyTorch в Python.

• Поезд оценки модели PyTorch определяется как процесс оценки данных. Функция eval() используется для оценки модели.
• eval() — это тип переключателя для определенных частей модели, которые действуют по-разному во время обучения и оценки.

В следующем коде мы импортируем несколько модулей, из которых мы сможем оценить обученную модель:

• netout = model() используется для инициализации модели.
• print(netout) используется для печати модели.
• optimizer = optimize.SGD(netout.parameters(), lr=0,001, импульс=0,9) используется для инициализации оптимизатора.
• torch.save() используется для сохранения модели.
• model.load_state_dict(checkpoint[‘model_state_dict’]) используется для загрузки модели.
• optimizer.load_state_dict(checkpoint[‘optimizer_state_dict’]) используется для загрузки оптимизатора.
• model.eval() используется для оценки модели.

import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as fun
class net(nn.Module):
    def __init__(self):
        super(net, self).__init__()
        self.conv = nn.Conv2d(5, 8, 7)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv1 = nn.Conv2d(8, 18, 7)
        self.fc = nn.Linear(18 * 5 * 5, 140)
        self.fc1 = nn.Linear(140, 86)
        self.fc2 = nn.Linear(86, 12)

    def forward(self, y):
        y = self.pool(fun.relu(self.conv1(Y)))
        y = self.pool(fun.relu(self.conv2(y)))
        y = y.view(-1, 16 * 5 * 5)
        y = fun.relu(self.fc1(y))
        y = fun.relu(self.fc2(y))
        y = self.fc3(y)
        return y

netout = net()
print(netout)
optimizers = optim.SGD(netout.parameters(), lr=0.001, momentum=0.9)
# Additional information
epoch = 7
path = "model.pt"
loss = 0.6

torch.save({
            'epoch': epoch,
            'model_state_dict': netout.state_dict(),
            'optimizer_state_dict': optimizers.state_dict(),
            'loss': loss,
            }, path)
models = net()
optimizers = optim.SGD(netout.parameters(), lr=0.001, momentum=0.9)

CheckPoint = torch.load(path)
models.load_state_dict(CheckPoint['model_state_dict'])
optimizers.load_state_dict(CheckPoint['optimizer_state_dict'])
Epoch = CheckPoint['epoch']
Loss = CheckPoint['loss']

models.eval()
models.train()

Выход:

В следующем выводе мы видим, что обученная модель оценивается на экране.

Набор train()

Оценка модели определяется как процесс, который может использовать различные матрицы оценки для понимания модели train.

В следующем коде мы импортируем модуль torch, из которого мы сможем оценить модель train.

• torch.nn.Linear() используется для создания сети прямой связи.
• X = torch.randn(N, D_in) используется для создания случайного тензора для хранения входных и выходных данных.
• loss_func = torch.nn.MSELoss(reduction=’sum’) используется для построения функции потерь.
• optimizer = torch.optim.SGD(model.parameters(), lr=1e-4) используется для инициализации оптимизатора.
• loss = loss_func(Ypred, Y) используется для печати потерь.
• optimizer.zero_grad() используется для оптимизации нулевого градиента.

import torch

class Net(torch.nn.Module):
  def __init__(self, Dinp, hidd, Doutp):
    
    super(Net, self).__init__()
    self.linear1 = torch.nn.Linear(Dinp, hidd)
    self.linear2 = torch.nn.Linear(hidd, Doutp)

  def forward(self, X):
    
    h_relu = self.linear1(X).clamp(min=0)
    ypred = self.linear2(h_relu)
    return ypred


bsize, Dinp, hidd, Doutp = 66, 1001, 101, 11

X = torch.randn(bsize, Dinp)
Y = torch.randn(bsize, Doutp)

modl = Net(Dinp, hidd, Doutp)

loss_func = torch.nn.MSELoss(reduction='sum')
opt = torch.optim.SGD(modl.parameters(), lr=1e-4)
for t in range(500):
  Ypred = modl(X)

  losses = loss_func(Ypred, Y)
  print(t, losses.item())

  opt.zero_grad()
  losses.backward()
  opt.step()
  modl.eval()

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, из которого видно, что оценка модели train может быть выполнена.

Сравнение eval и train

В этом разделе мы узнаем о модели PyTorch eval и train в Python:

• Набор train() сообщает нашей модели, что она в настоящее время находится на этапе обучения, и они сохраняют некоторые уровни, такие как отсев и пакетная нормализация, которые действуют по-разному, но зависят от текущего состояния.
• Набор eval() действует совершенно иначе, чем набор поездов, когда вызывается eval(), тогда наша модель деактивирует все слои.

В следующем коде мы импортируем некоторые библиотеки, из которых мы сможем увидеть разницу между наборами eval и train:

• dropout = nn.Dropout() используется для удаления модулей в нейронной сети.
• X = torch.ones(2, 12) используется для инициализации тензора.
• dropout.train() используется как режим поезда.
• dropout.eval() используется как режим оценки.

import torch
import torch.nn as nn
dropout = nn.Dropout()
X = torch.ones(2, 12)
# Train mode 
dropout.train()
print(dropout(X))
# Eval mode
dropout.eval()
print(dropout(X))

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором видим, что значение обучения и значение оценки выводятся на экран.

Сравнение eval и no_grad

Набор eval() сообщает всем слоям, что вы находитесь в режиме eval. Слои отсева и норм партии работают в режиме оценки, а не в режиме обучения.

Следующий синтаксис имеет значение eval:

model.eval()

no_grad() влияет на движок autograd и деактивирует его, а также уменьшает объем памяти и ускоряет вычисления.

Синтаксис no_grad:

torch.no_grad()

Отключение eval

Отсев eval определяется как процесс, в котором отсев деактивирован и только что передан входные данные.

В следующем коде мы импортируем модуль torch, из которого реализуем модель исключения eval:

• nn.Dropout() используется для определения вероятности деактивации нейрона.
• dropout.eval() используется для оценки модели.
• print(dropout(X)) используется для печати значения на экране.

import torch
import torch.nn as nn
dropout = nn.Dropout()
dropout.eval()
print(dropout(X))

Выход:

В следующем выводе мы видим, что значение исключения eval модели PyTorch выводится на экран.

Batchnorm

Batchnorm определяется как процесс, используемый для обучения глубоких нейронных сетей, которые нормализуют входные данные слоя для всех мини-пакетов.

В следующем коде мы импортируем несколько библиотек, из которых сможем оценить пакетную норму.

• В качестве ширины используется wid = 64.
• heig = 64 используется в качестве высоты.
• package = torch.ones([4, 1, 64, 64], dtype=torch.float, device=torch.device(«cuda»)) используется для расчета пакета.
• output_one = torch.tensor([.5, .5]).to(torch.device(«cuda»)) используется для получения выходных данных пакета.
• optimizers = optim.SGD(nets.parameters(), 0.0001) используется для инициализации оптимизатора.
• optimizers.zero_grad() используется для обнуления градиентов параметров.
• loss = критерии(netout, outp) используется для расчета потерь.
• print(«t1 loss1:», train_model(networks, patch_one, output_one)) используется для печати модели поезда.
• print(«v1 loss1:», пакет_оценка(сети, пакет_один, выход_один, True)) используется для печати пакета оценки.

import torch
import torch.nn as nn
import torch.optim as optim        
                                                                       
class net(nn.Module):
    def __init__(self, image_size_total):
        super(net, self).__init__()
                           
        self.conv = nn.Conv2d(1, 64, 3, padding=1)
        self.relu = nn.ReLU(inplace=True)
        self.bn = nn.BatchNorm2d(64)
        self.max_pool = nn.MaxPool2d(2)
                                                               
        self.fc = nn.Linear((image_size_total//4) * 64, 2)

    def forward(self, X):
        X = self.conv(X)
        X = self.relu(X)
        X = self.bn(X)
        X = self.max_pool(X)

        X = X.view(-1, self.numfeatures(X))
        X = self.fc(X)
        return X


    def numfeatures(self, X):
        Size = X.size()[1:] # all dimensions except the batch dimension
        numfeatures = 1
        for i in Size:
            numfeatures *= i
        return numfeatures
wid = 64
heig = 64
networks = net(wid* heig)

batch_one = torch.ones([4, 1, 64, 64], dtype=torch.float, device=torch.device("cuda"))
output_one = torch.tensor([.5, .5]).to(torch.device("cuda"))
batch_two = torch.randn([4, 1, 64, 64], dtype=torch.float, device=torch.device("cuda"))
output_two = torch.tensor([.01, 1.0]).to(torch.device("cuda"))

def train_model(nets, batch, outp):
        nets.train()

        optimizers = optim.SGD(nets.parameters(), 0.0001)
        criterions = nn.MSELoss()

        
        optimizers.zero_grad()

        netout = nets(batch)
        loss = criterions(netout, outp)
        loss.backward()
        optimizers.step()
        return float(loss)

def batch_evaluate(nets, batch, outp, should_eval):
        if should_eval:
            nets.eval()
        else:
            nets.train()

        criterion = nn.MSELoss()

        netout = nets(batch)
        loss = criterion(netout, outp)
        return float(loss)

networks.to(torch.device("cuda"))

for i in range(60):
    print("t1 loss1:", train_model(networks, batch_one, output_one))
    print("t1 loss2:", train_model(networks, batch_two, output_one))

print("v1 loss1:", batch_evaluate(networks, batch_one, output_one, True))
print("v1 loss2:", batch_evaluate(networks, batch_two, output_one, True))
print("train v1 loss1:", batch_evaluate(networks, batch_one, output_one, False))
print("train v2 loss2:", batch_evaluate(networks, batch_two, output_one, False))

Примечание. Перед запуском кода измените время выполнения «Нет» на «ГП» в Google Colab. После этого наш код работает отлично.

Выход:

После запуска приведенного выше кода мы получаем следующий вывод, в котором видим, что model.eval() выдает неправильные потери с пакетной нормой.

Оценка модели require_grad

В PyTorch require_grad определяется как параметр. Если значение require_grad истинно, то требуется вычисление градиента. А если оно ложно, то рассчитывать градиент не требуется.

В следующем коде мы импортируем модуль факела, из которого мы сможем рассчитать градиент, если значение require_grad истинно.

• dropout = nn.Dropout() используется для определения вероятности деактивации нейрона.
• X = torch.ones(6, 12, require_grad = False) используется для присвоения значения переменной x.
• dropout.eval() используется как режим оценки.
• print(dropout(X)) используется для печати значения.

import torch
import torch.nn as nn
dropout = nn.Dropout()
X = torch.ones(6, 12, requires_grad = False)
y =torch.ones(6, 12,requires_grad = True)

dropout.eval()
print(dropout(X))
print(dropout(y))

Выход:

В следующем выводе мы видим, что значение require_grad для оценки модели PyTorch выводится на экран.