Python torch.utils.data.to() Examples
The following are 30
code examples of torch.utils.data.to().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
torch.utils.data
, or try the search function
.
Example #1
Source File: trainvae.py From world-models with MIT License | 6 votes |
def test(): """ One test epoch """ model.eval() dataset_test.load_next_buffer() test_loss = 0 with torch.no_grad(): for data in test_loader: data = data.to(device) recon_batch, mu, logvar = model(data) test_loss += loss_function(recon_batch, data, mu, logvar).item() test_loss /= len(test_loader.dataset) print('====> Test set loss: {:.4f}'.format(test_loss)) return test_loss # check vae dir exists, if not, create it
Example #2
Source File: main.py From examples with BSD 3-Clause "New" or "Revised" License | 6 votes |
def test(epoch): model.eval() test_loss = 0 with torch.no_grad(): for i, (data, _) in enumerate(test_loader): data = data.to(device) recon_batch, mu, logvar = model(data) test_loss += loss_function(recon_batch, data, mu, logvar).item() if i == 0: n = min(data.size(0), 8) comparison = torch.cat([data[:n], recon_batch.view(args.batch_size, 1, 28, 28)[:n]]) save_image(comparison.cpu(), 'results/reconstruction_' + str(epoch) + '.png', nrow=n) test_loss /= len(test_loader.dataset) print('====> Test set loss: {:.4f}'.format(test_loss))
Example #3
Source File: main.py From examples with BSD 3-Clause "New" or "Revised" License | 6 votes |
def train(epoch): model.train() train_loss = 0 for batch_idx, (data, _) in enumerate(train_loader): data = data.to(device) optimizer.zero_grad() recon_batch, mu, logvar = model(data) loss = loss_function(recon_batch, data, mu, logvar) loss.backward() train_loss += loss.item() optimizer.step() if batch_idx % args.log_interval == 0: print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, batch_idx * len(data), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.item() / len(data))) print('====> Epoch: {} Average loss: {:.4f}'.format( epoch, train_loss / len(train_loader.dataset)))
Example #4
Source File: main.py From ArtificialIntelligenceEngines with MIT License | 6 votes |
def loss_function(recon_x, x, mu, logvar): # next 2 lines are equivalent BCE = -F.binary_cross_entropy(recon_x, x.view(-1, 784), reduction='sum') #BCE = -F.binary_cross_entropy(recon_x, x.view(-1, 784), size_average=False) # deprecated # for binary_cross_entropy, see https://pytorch.org/docs/stable/nn.html # KLD is Kullback–Leibler divergence -- how much does one learned # distribution deviate from another, in this specific case the # learned distribution from the unit Gaussian # see Appendix B from VAE paper: # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014 # https://arxiv.org/abs/1312.6114 # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2) KLD = 0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) # JVS: Kingma's repo = https://github.com/dpkingma/examples/blob/master/vae/main.py # BCE tries to make our reconstruction as accurate as possible # KLD tries to push the distributions as close as possible to unit Gaussian ELBO = BCE + KLD loss = -ELBO return loss
Example #5
Source File: gpt2tunediscrim.py From PPLM with Apache License 2.0 | 6 votes |
def train_epoch(data_loader, discriminator, device='cuda', args=None, epoch=1): optimizer = optim.Adam(discriminator.parameters(), lr=0.0001) discriminator.train_custom() for batch_idx, (data, target) in enumerate(data_loader): data, target = data.to(device), target.to(device) optimizer.zero_grad() output = discriminator(data) loss = F.nll_loss(output, target) loss.backward(retain_graph=True) optimizer.step() if batch_idx % args.log_interval == 0: print('Relu Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, batch_idx * len(data), len(data_loader.dataset), 100. * batch_idx / len(data_loader), loss.item()))
Example #6
Source File: gpt2tunediscrim.py From PPLM with Apache License 2.0 | 6 votes |
def test_epoch(data_loader, discriminator, device='cuda', args=None): discriminator.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, target in data_loader: data, target = data.to(device), target.to(device) output = discriminator(data) test_loss += F.nll_loss(output, target, reduction='sum').item() # sum up batch loss pred = output.argmax(dim=1, keepdim=True) # get the index of the max log-probability correct += pred.eq(target.view_as(pred)).sum().item() test_loss /= len(data_loader.dataset) print('\nRelu Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format( test_loss, correct, len(data_loader.dataset), 100. * correct / len(data_loader.dataset)))
Example #7
Source File: main.py From ArtificialIntelligenceEngines with MIT License | 6 votes |
def __init__(self): super(VAE, self).__init__() # ENCODER # 28 x 28 pixels = 784 input pixels, 400 outputs self.fc1 = nn.Linear(784, 400) # rectified linear unit layer from 400 to 400 self.relu = nn.ReLU() self.fc21 = nn.Linear(400, ZDIMS) # mu layer self.fc22 = nn.Linear(400, ZDIMS) # logvariance layer # this last layer is the bottleneck of ZDIMS=20 connections # DECODER # from bottleneck to hidden 400 self.fc3 = nn.Linear(ZDIMS, 400) # from hidden 400 to 784 outputs self.fc4 = nn.Linear(400, 784) self.sigmoid = nn.Sigmoid()
Example #8
Source File: main.py From pytorch-cifar10 with Apache License 2.0 | 6 votes |
def train(self): print("train:") self.model.train() train_loss = 0 train_correct = 0 total = 0 for batch_num, (data, target) in enumerate(self.train_loader): data, target = data.to(self.device), target.to(self.device) self.optimizer.zero_grad() output = self.model(data) loss = self.criterion(output, target) loss.backward() self.optimizer.step() train_loss += loss.item() prediction = torch.max(output, 1) # second param "1" represents the dimension to be reduced total += target.size(0) # train_correct incremented by one if predicted right train_correct += np.sum(prediction[1].cpu().numpy() == target.cpu().numpy()) progress_bar(batch_num, len(self.train_loader), 'Loss: %.4f | Acc: %.3f%% (%d/%d)' % (train_loss / (batch_num + 1), 100. * train_correct / total, train_correct, total)) return train_loss, train_correct / total
Example #9
Source File: main.py From pytorch-cifar10 with Apache License 2.0 | 6 votes |
def test(self): print("test:") self.model.eval() test_loss = 0 test_correct = 0 total = 0 with torch.no_grad(): for batch_num, (data, target) in enumerate(self.test_loader): data, target = data.to(self.device), target.to(self.device) output = self.model(data) loss = self.criterion(output, target) test_loss += loss.item() prediction = torch.max(output, 1) total += target.size(0) test_correct += np.sum(prediction[1].cpu().numpy() == target.cpu().numpy()) progress_bar(batch_num, len(self.test_loader), 'Loss: %.4f | Acc: %.3f%% (%d/%d)' % (test_loss / (batch_num + 1), 100. * test_correct / total, test_correct, total)) return test_loss, test_correct / total
Example #10
Source File: main.py From PyTorch with MIT License | 6 votes |
def train(epoch): model.train() train_loss = 0 for batch_idx, (data, _) in enumerate(train_loader): data = data.to(device) optimizer.zero_grad() recon_batch, mu, logvar = model(data) loss = loss_function(recon_batch, data, mu, logvar) loss.backward() train_loss += loss.item() optimizer.step() if batch_idx % args.log_interval == 0: print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, batch_idx * len(data), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.item() / len(data))) print('====> Epoch: {} Average loss: {:.4f}'.format( epoch, train_loss / len(train_loader.dataset)))
Example #11
Source File: main.py From PyTorch with MIT License | 6 votes |
def test(epoch): model.eval() test_loss = 0 with torch.no_grad(): for i, (data, _) in enumerate(test_loader): data = data.to(device) recon_batch, mu, logvar = model(data) test_loss += loss_function(recon_batch, data, mu, logvar).item() if i == 0: n = min(data.size(0), 8) comparison = torch.cat([data[:n], recon_batch.view(args.batch_size, 1, 28, 28)[:n]]) save_image(comparison.cpu(), 'results/reconstruction_' + str(epoch) + '.png', nrow=n) test_loss /= len(test_loader.dataset) print('====> Test set loss: {:.4f}'.format(test_loss))
Example #12
Source File: trainvae.py From world-models with MIT License | 6 votes |
def train(epoch): """ One training epoch """ model.train() dataset_train.load_next_buffer() train_loss = 0 for batch_idx, data in enumerate(train_loader): data = data.to(device) optimizer.zero_grad() recon_batch, mu, logvar = model(data) loss = loss_function(recon_batch, data, mu, logvar) loss.backward() train_loss += loss.item() optimizer.step() if batch_idx % 20 == 0: print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( epoch, batch_idx * len(data), len(train_loader.dataset), 100. * batch_idx / len(train_loader), loss.item() / len(data))) print('====> Epoch: {} Average loss: {:.4f}'.format( epoch, train_loss / len(train_loader.dataset)))
Example #13
Source File: run.py From MobileNetV2-pytorch with MIT License | 6 votes |
def test(model, loader, criterion, device, dtype): model.eval() test_loss = 0 correct1, correct5 = 0, 0 for batch_idx, (data, target) in enumerate(tqdm(loader)): data, target = data.to(device=device, dtype=dtype), target.to(device=device) with torch.no_grad(): output = model(data) test_loss += criterion(output, target).item() # sum up batch loss corr = correct(output, target, topk=(1, 5)) correct1 += corr[0] correct5 += corr[1] test_loss /= len(loader) tqdm.write( '\nTest set: Average loss: {:.4f}, Top1: {}/{} ({:.2f}%), ' 'Top5: {}/{} ({:.2f}%)'.format(test_loss, int(correct1), len(loader.dataset), 100. * correct1 / len(loader.dataset), int(correct5), len(loader.dataset), 100. * correct5 / len(loader.dataset))) return test_loss, correct1 / len(loader.dataset), correct5 / len(loader.dataset)
Example #14
Source File: main.py From pytorch-distributed-example with MIT License | 6 votes |
def run(args): device = torch.device('cuda' if torch.cuda.is_available() and not args.no_cuda else 'cpu') model = Net() if distributed_is_initialized(): model.to(device) model = nn.parallel.DistributedDataParallel(model) else: model = nn.DataParallel(model) model.to(device) optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate) train_loader = MNISTDataLoader(args.root, args.batch_size, train=True) test_loader = MNISTDataLoader(args.root, args.batch_size, train=False) trainer = Trainer(model, optimizer, train_loader, test_loader, device) trainer.fit(args.epochs)
Example #15
Source File: run.py From MobileNetV3-pytorch with MIT License | 6 votes |
def test(model, loader, criterion, device, dtype, child): model.eval() test_loss = 0 correct1, correct5 = 0, 0 enum_load = enumerate(loader) if child else enumerate(tqdm(loader)) with torch.no_grad(): for batch_idx, (data, target) in enum_load: data, target = data.to(device=device, dtype=dtype), target.to(device=device) output = model(data) test_loss += criterion(output, target).item() # sum up batch loss corr = correct(output, target, topk=(1, 5)) correct1 += corr[0] correct5 += corr[1] test_loss /= len(loader) if not child: tqdm.write( '\nTest set: Average loss: {:.4f}, Top1: {}/{} ({:.2f}%), ' 'Top5: {}/{} ({:.2f}%)'.format(test_loss, int(correct1), len(loader.sampler), 100. * correct1 / len(loader.sampler), int(correct5), len(loader.sampler), 100. * correct5 / len(loader.sampler))) return test_loss, correct1 / len(loader.sampler), correct5 / len(loader.sampler)
Example #16
Source File: main.py From pytorch-distributed-example with MIT License | 6 votes |
def evaluate(self): self.model.eval() test_loss = Average() test_acc = Accuracy() for data, target in self.test_loader: data = data.to(self.device) target = target.to(self.device) output = self.model(data) loss = F.cross_entropy(output, target) test_loss.update(loss.item(), data.size(0)) test_acc.update(output, target) return test_loss, test_acc
Example #17
Source File: main.py From pytorch-distributed-example with MIT License | 6 votes |
def train(self): self.model.train() train_loss = Average() train_acc = Accuracy() for data, target in self.train_loader: data = data.to(self.device) target = target.to(self.device) output = self.model(data) loss = F.cross_entropy(output, target) self.optimizer.zero_grad() loss.backward() self.optimizer.step() train_loss.update(loss.item(), data.size(0)) train_acc.update(output, target) return train_loss, train_acc
Example #18
Source File: mnist.py From aws-step-functions-data-science-sdk-python with Apache License 2.0 | 6 votes |
def test(model, test_loader, device): model.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, target in test_loader: data, target = data.to(device), target.to(device) output = model(data) test_loss += F.nll_loss(output, target, size_average=False).item() # sum up batch loss pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability correct += pred.eq(target.view_as(pred)).sum().item() test_loss /= len(test_loader.dataset) logger.info('Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format( test_loss, correct, len(test_loader.dataset), 100. * correct / len(test_loader.dataset)))
Example #19
Source File: mnist.py From sagemaker-pytorch-training-toolkit with Apache License 2.0 | 6 votes |
def test(model, test_loader, device): model.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, target in test_loader: data, target = data.to(device), target.to(device) output = model(data) test_loss += F.nll_loss(output, target, size_average=None).item() # sum up batch loss pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability correct += pred.eq(target.view_as(pred)).sum().item() test_loss /= len(test_loader.dataset) logger.debug('Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format( test_loss, correct, len(test_loader.dataset), 100. * correct / len(test_loader.dataset)))
Example #20
Source File: mnist.py From sagemaker-python-sdk with Apache License 2.0 | 6 votes |
def test(model, test_loader, device): model.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, target in test_loader: data, target = data.to(device), target.to(device) output = model(data) test_loss += F.nll_loss(output, target, size_average=False).item() # sum up batch loss pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability correct += pred.eq(target.view_as(pred)).sum().item() test_loss /= len(test_loader.dataset) accuracy = 100.0 * correct / len(test_loader.dataset) logger.debug( "Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n".format( test_loss, correct, len(test_loader.dataset), accuracy ) ) return accuracy
Example #21
Source File: run.py From ShuffleNetV2-pytorch with MIT License | 6 votes |
def test(model, loader, criterion, device, dtype): model.eval() test_loss = 0 correct1, correct5 = 0, 0 for batch_idx, (data, target) in enumerate(tqdm(loader)): data, target = data.to(device=device, dtype=dtype), target.to(device=device) with torch.no_grad(): output = model(data) test_loss += criterion(output, target).item() # sum up batch loss corr = correct(output, target, topk=(1, 5)) correct1 += corr[0] correct5 += corr[1] test_loss /= len(loader) tqdm.write( '\nTest set: Average loss: {:.4f}, Top1: {}/{} ({:.2f}%), ' 'Top5: {}/{} ({:.2f}%)'.format(test_loss, int(correct1), len(loader.dataset), 100. * correct1 / len(loader.dataset), int(correct5), len(loader.dataset), 100. * correct5 / len(loader.dataset))) return test_loss, correct1 / len(loader.dataset), correct5 / len(loader.dataset)
Example #22
Source File: main.py From pytorch-cifar10 with Apache License 2.0 | 5 votes |
def save(self): model_out_path = "model.pth" torch.save(self.model, model_out_path) print("Checkpoint saved to {}".format(model_out_path))
Example #23
Source File: main.py From pytorch-cifar10 with Apache License 2.0 | 5 votes |
def load_model(self): if self.cuda: self.device = torch.device('cuda') cudnn.benchmark = True else: self.device = torch.device('cpu') # self.model = LeNet().to(self.device) # self.model = AlexNet().to(self.device) # self.model = VGG11().to(self.device) # self.model = VGG13().to(self.device) # self.model = VGG16().to(self.device) # self.model = VGG19().to(self.device) # self.model = GoogLeNet().to(self.device) # self.model = resnet18().to(self.device) # self.model = resnet34().to(self.device) # self.model = resnet50().to(self.device) # self.model = resnet101().to(self.device) # self.model = resnet152().to(self.device) # self.model = DenseNet121().to(self.device) # self.model = DenseNet161().to(self.device) # self.model = DenseNet169().to(self.device) # self.model = DenseNet201().to(self.device) self.model = WideResNet(depth=28, num_classes=10).to(self.device) self.optimizer = optim.Adam(self.model.parameters(), lr=self.lr) self.scheduler = optim.lr_scheduler.MultiStepLR(self.optimizer, milestones=[75, 150], gamma=0.5) self.criterion = nn.CrossEntropyLoss().to(self.device)
Example #24
Source File: mnist.py From aws-step-functions-data-science-sdk-python with Apache License 2.0 | 5 votes |
def model_fn(model_dir): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = torch.nn.DataParallel(Net()) with open(os.path.join(model_dir, 'model.pth'), 'rb') as f: model.load_state_dict(torch.load(f)) return model.to(device)
Example #25
Source File: run.py From ShuffleNetV2-pytorch with MIT License | 5 votes |
def find_bounds_clr(model, loader, optimizer, criterion, device, dtype, min_lr=8e-6, max_lr=8e-5, step_size=2000, mode='triangular', save_path='.'): model.train() correct1, correct5 = 0, 0 scheduler = CyclicLR(optimizer, base_lr=min_lr, max_lr=max_lr, step_size=step_size, mode=mode) epoch_count = step_size // len(loader) # Assuming step_size is multiple of batch per epoch accuracy = [] for _ in trange(epoch_count): for batch_idx, (data, target) in enumerate(tqdm(loader)): if scheduler is not None: scheduler.batch_step() data, target = data.to(device=device, dtype=dtype), target.to(device=device) optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() corr = correct(output, target) accuracy.append(corr[0] / data.shape[0]) lrs = np.linspace(min_lr, max_lr, step_size) plt.plot(lrs, accuracy) plt.show() plt.savefig(os.path.join(save_path, 'find_bounds_clr.png')) np.save(os.path.join(save_path, 'acc.npy'), accuracy) return
Example #26
Source File: run.py From ShuffleNetV2-pytorch with MIT License | 5 votes |
def train(model, loader, epoch, optimizer, criterion, device, dtype, batch_size, log_interval, scheduler): model.train() correct1, correct5 = 0, 0 for batch_idx, (data, target) in enumerate(tqdm(loader)): if isinstance(scheduler, CyclicLR): scheduler.batch_step() data, target = data.to(device=device, dtype=dtype), target.to(device=device) optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() corr = correct(output, target, topk=(1, 5)) correct1 += corr[0] correct5 += corr[1] if batch_idx % log_interval == 0: tqdm.write( 'Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}. ' 'Top-1 accuracy: {:.2f}%({:.2f}%). ' 'Top-5 accuracy: {:.2f}%({:.2f}%).'.format(epoch, batch_idx, len(loader), 100. * batch_idx / len(loader), loss.item(), 100. * corr[0] / batch_size, 100. * correct1 / (batch_size * (batch_idx + 1)), 100. * corr[1] / batch_size, 100. * correct5 / (batch_size * (batch_idx + 1)))) return loss.item(), correct1 / len(loader.dataset), correct5 / len(loader.dataset)
Example #27
Source File: main.py From ArtificialIntelligenceEngines with MIT License | 5 votes |
def forward(self, x): mu, logvar = self.encode(x.view(-1, 784)) z = self.reparameterize(mu, logvar) return self.decode(z), mu, logvar # Reconstruction + KL divergence losses summed over all elements and batch # This loss is actually minus the ELBO (ie ELBO is a likelihood, which we want to maximise) # so we use Adam to minimise minus ELBO
Example #28
Source File: lottery_torch_mnist_fc.py From nni with MIT License | 5 votes |
def test(model, test_loader, criterion): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.eval() test_loss = 0 correct = 0 with torch.no_grad(): for data, target in test_loader: data, target = data.to(device), target.to(device) output = model(data) test_loss += F.nll_loss(output, target, reduction='sum').item() # sum up batch loss pred = output.data.max(1, keepdim=True)[1] # get the index of the max log-probability correct += pred.eq(target.data.view_as(pred)).sum().item() test_loss /= len(test_loader.dataset) accuracy = 100. * correct / len(test_loader.dataset) return accuracy
Example #29
Source File: main.py From pytorch-distributed-example with MIT License | 5 votes |
def main(): parser = argparse.ArgumentParser() parser.add_argument('--backend', type=str, default='gloo', help='Name of the backend to use.') parser.add_argument('-i', '--init-method', type=str, default='tcp://127.0.0.1:23456', help='URL specifying how to initialize the package.') parser.add_argument('-s', '--world-size', type=int, default=1, help='Number of processes participating in the job.') parser.add_argument('-r', '--rank', type=int, default=0, help='Rank of the current process.') parser.add_argument('--epochs', type=int, default=20) parser.add_argument('--no-cuda', action='store_true') parser.add_argument('-lr', '--learning-rate', type=float, default=1e-3) parser.add_argument('--root', type=str, default='data') parser.add_argument('--batch-size', type=int, default=128) args = parser.parse_args() print(args) if args.world_size > 1: distributed.init_process_group( backend=args.backend, init_method=args.init_method, world_size=args.world_size, rank=args.rank, ) run(args)
Example #30
Source File: train_model.py From nupic.torch with GNU Affero General Public License v3.0 | 5 votes |
def test(model, loader, criterion, device, desc="Test"): """ Evaluate trained model using given dataset loader. Called on every epoch. :param model: Pretrained pytorch model :type model: torch.nn.Module :param loader: DataLoader configured for the epoch. :type loader: :class:`torch.utils.data.DataLoader` :param criterion: loss function to use :type criterion: function :param device: :type device: :class:`torch.device` :param desc: Description for progress bar :type desc: str :return: Dict with "accuracy", "loss" and "total_correct" """ model.eval() loss = 0 total_correct = 0 with torch.no_grad(): for data, target in tqdm(loader, desc=desc, leave=False): data, target = data.to(device), target.to(device) output = model(data) # sum up batch loss loss += criterion(output, target, reduction="sum").item() # get the index of the max log-probability pred = output.argmax(dim=1, keepdim=True) total_correct += pred.eq(target.view_as(pred)).sum().item() return {"accuracy": total_correct / len(loader.dataset), "loss": loss / len(loader.dataset), "total_correct": total_correct}