Воспроизводимые результаты Pytorch и случайные семена - PullRequest
Новая
       54

Воспроизводимые результаты Pytorch и случайные семена

0 голосов
/ 18 мая 2018

У меня простая игрушка NN с Pytorch.Я сажаю все семена, которые я могу найти в документах, а также случайные цифры.

Если я запускаю приведенный ниже код сверху вниз, результаты кажутся воспроизводимыми.

НО, если я запускаю блок 1 только один раз, а затем каждый раз запускаю блок 2, результат изменяется (иногда резко).Я не уверен, почему это происходит, поскольку сеть повторно инициализируется и оптимизатор сбрасывается каждый раз.

Я использую версию 0.4.0

BLOCK # 1 

from __future__ import division
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

import torch
import torch.utils.data as utils_data
from torch.autograd import Variable
from torch import optim, nn
from torch.utils.data import Dataset 
import torch.nn.functional as F
from torch.nn.init import xavier_uniform_, xavier_normal_,uniform_

torch.manual_seed(123)

import random
random.seed(123)


from sklearn.datasets import load_boston
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split

%matplotlib inline 

cuda=True #set to true uses GPU

if cuda:
    torch.cuda.manual_seed(123)

#load boston data from scikit
boston = load_boston()
x=boston.data
y=boston.target
y=y.reshape(y.shape[0],1)

#train and test
x_train, x_test, y_train, y_test = train_test_split(x,y,test_size=0.3, random_state=123, shuffle=False)


#change to tensors
x_train = torch.from_numpy(x_train)
y_train = torch.from_numpy(y_train)

#create dataset and use data loader
training_samples = utils_data.TensorDataset(x_train, y_train)
data_loader_trn = utils_data.DataLoader(training_samples, batch_size=64,drop_last=False)

#change to tensors
x_test = torch.from_numpy(x_test)
y_test = torch.from_numpy(y_test)

#create dataset and use data loader
testing_samples = utils_data.TensorDataset(x_test, y_test)
data_loader_test = utils_data.DataLoader(testing_samples, batch_size=64,drop_last=False)

#simple model
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()

        #all the layers
        self.fc1   = nn.Linear(x.shape[1], 20)
        xavier_uniform_(self.fc1.weight.data) #this is how you can change the weight init
        self.drop = nn.Dropout(p=0.5)
        self.fc2   = nn.Linear(20, 1)


    def forward(self, x):
        x = F.relu(self.fc1(x))
        x=  self.drop(x)
        x = self.fc2(x)
        return x

БЛОК # 2 

net=Net()

if cuda:
    net.cuda()

# create a stochastic gradient descent optimizer
optimizer = optim.Adam(net.parameters())
# create a loss function (mse)
loss = nn.MSELoss(size_average=False)

# run the main training loop
epochs =20
hold_loss=[]

for epoch in range(epochs):
    cum_loss=0.
    cum_records_epoch =0

    for batch_idx, (data, target) in enumerate(data_loader_trn):
        tr_x, tr_y = data.float(), target.float()
        if cuda:
            tr_x, tr_y = tr_x.cuda(), tr_y.cuda() 

        # Reset gradient
        optimizer.zero_grad()

        # Forward pass
        fx = net(tr_x)
        output = loss(fx, tr_y) #loss for this batch

        cum_loss += output.item() #accumulate the loss

        # Backward 
        output.backward()

        # Update parameters based on backprop
        optimizer.step()

        cum_records_epoch +=len(tr_x)
        if batch_idx % 1 == 0:
            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
            epoch, cum_records_epoch, len(data_loader_trn.dataset),
            100. * (batch_idx+1) / len(data_loader_trn), output.item()))
    print('Epoch average loss: {:.6f}'.format(cum_loss/cum_records_epoch))

    hold_loss.append(cum_loss/cum_records_epoch)  

#training loss
plt.plot(np.array(hold_loss))
plt.show()

1 Ответ

0 голосов
/ 08 июня 2018

Возможная причина

Не зная, что такое "иногда драматические различия", трудно точно ответить;но иметь разные результаты при запуске [block_1 x1; block_2 x1] xN (прочитайте «работает block_1, затем block_2 один раз; и повторите обе операции N раз) и [block_1 x1; block_2 xN] x1 имеет смысл, учитывая, как генераторы псевдослучайных чисел (PRNG) и начальные числаработа.

В первом случае вы повторно инициализируете PRNG в block_1 после каждого block_2, поэтому каждый из N экземпляров block_2 будет иметь доступ к одной и той же последовательности псевдо-случайные числа, отмеченные каждым block_1 ранее.

Во втором случае PRNG инициализируются только один раз, одним прогоном block_1, поэтому каждый экземпляр block_2 будет иметь разные случайные значения.

(Подробнее о PRNG и семенах вы можете проверить: random.seed (): что он делает? )

Упрощенный пример

Предположим, что numpy / CUDA / pytorch на самом деле использует действительно плохой PRNG, который возвращает только увеличенные значения (т. Е. PRNG(x_n) = PRNG(x_(n-1)) + 1, с x_0 = seed). Если вы запустите этот генератор с 0, он, таким образом, вернет 1 первый random() звонок, 2 второй звонокll и т. д.

Теперь давайте также упростим ваши блоки для примера: 

def block_1():
    seed = 0
    print("seed: {}".format(seed))
    prng.seed(seed)

- 

def block_2():
    res = "random results:"
    for i in range(4):
         res  += " {}".format(prng.random())
    print(res)

Давайте сравним [block_1 x1; block_2 x1] xN и [block_1 x1; block_2 xN] x1 с N=3: 

for i in range(3):
    block_1()
    block_2()
# > seed: 0
# > random results: 1 2 3 4
# > seed: 0
# > random results: 1 2 3 4
# > seed: 0
# > random results: 1 2 3 4


block_1()
for i in range(3):
    block_2()
# > seed: 0
# > random results: 1 2 3 4
# > random results: 4 5 6 7
# > random results: 8 9 10 11
...