Last active
May 20, 2020 06:37
-
-
Save buttercutter/8ddd9794f242c24ffdaa612bcb0bfa33 to your computer and use it in GitHub Desktop.
YOLOv3 + AdderNet
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ''' | |
| Copyright (C) 2020. Huawei Technologies Co., Ltd. All rights reserved. | |
| This program is free software; you can redistribute it and/or modify | |
| it under the terms of BSD 3-Clause License. | |
| This program is distributed in the hope that it will be useful, | |
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| BSD 3-Clause License for more details. | |
| ''' | |
| import torch | |
| import torch.nn as nn | |
| import numpy as np | |
| from torch.autograd import Function | |
| import math | |
| # https://github.com/pytorch/pytorch/issues/15253#issuecomment-491467128 | |
| @torch.jit.script | |
| def my_cdist(x1, x2, p:int): | |
| x1_norm = x1.pow(p).sum(dim=-1, keepdim=True) | |
| x2_norm = x2.pow(p).sum(dim=-1, keepdim=True) | |
| res = torch.addmm(x2_norm.transpose(-2, -1), x1, x2.transpose(-2, -1), alpha=-2).add_(x1_norm) | |
| res = res.clamp_min_(1e-30).sqrt_() | |
| return res | |
| # https://github.com/pytorch/pytorch/pull/25799#issuecomment-529021810 | |
| def fast_cdist(x1, x2, p:int): | |
| adjustment = x1.mean(-2, keepdim=True) | |
| x1 = x1 - adjustment | |
| x2 = x2 - adjustment # x1 and x2 should be identical in all dims except -2 at this point | |
| # Compute distance matrix | |
| # But be clever and do it with a single matmul call | |
| x1_norm = x1.pow(p).sum(dim=-1, keepdim=True) | |
| x1_pad = torch.ones_like(x1_norm) | |
| x2_norm = x2.pow(p).sum(dim=-1, keepdim=True) | |
| x2_pad = torch.ones_like(x2_norm) | |
| x1_ = torch.cat([-2. * x1, x1_norm, x1_pad], dim=-1) | |
| x2_ = torch.cat([x2, x2_pad, x2_norm], dim=-1) | |
| res = x1_.matmul(x2_.transpose(-2, -1)) | |
| # Zero out negative values | |
| res.clamp_min_(1e-30).sqrt_() | |
| return res | |
| def new_cdist(p, eta): ## https://github.com/huawei-noah/AdderNet/issues/6#issuecomment-594212162 | |
| class cdist(torch.autograd.Function): | |
| @staticmethod | |
| def forward(ctx, W, X): | |
| ctx.save_for_backward(W, X) | |
| out = -my_cdist(W, X, p) | |
| return out | |
| @staticmethod | |
| def backward(ctx, grad_output): | |
| W, X = ctx.saved_tensors | |
| grad_W = grad_X = None | |
| if ctx.needs_input_grad[0]: | |
| _temp1 = torch.unsqueeze(X, 2).expand(X.shape[0], X.shape[1], W.shape[0]).permute(1, 0, 2) | |
| _temp2 = torch.unsqueeze(W.transpose(0, 1), 1) | |
| _temp = my_cdist(_temp1, _temp2, p).squeeze().transpose(0, 1) | |
| grad_W = torch.matmul(grad_output, _temp) | |
| # print('before norm: ', torch.norm(grad_W)) | |
| grad_W = eta * np.sqrt(grad_W.numel()) / torch.norm(grad_W) * grad_W | |
| print('after norm: ', torch.norm(grad_W)) | |
| if ctx.needs_input_grad[1]: | |
| _temp1 = torch.unsqueeze(W, 2).expand(W.shape[0], W.shape[1], X.shape[0]).permute(1, 0, 2) | |
| _temp2 = torch.unsqueeze(X.transpose(0, 1), 1) | |
| _temp = my_cdist(_temp1, _temp2, p).squeeze().transpose(0, 1) | |
| _temp = torch.nn.functional.hardtanh(_temp, min_val=-1., max_val=1.) | |
| grad_X = torch.matmul(grad_output.transpose(0, 1), _temp) | |
| return grad_W, grad_X | |
| return cdist().apply | |
| def adder2d_function(X, W, stride=1, padding=0): | |
| n_filters, d_filter, h_filter, w_filter = W.size() | |
| n_x, d_x, h_x, w_x = X.size() | |
| h_out = (h_x - h_filter + 2 * padding) / stride + 1 | |
| w_out = (w_x - w_filter + 2 * padding) / stride + 1 | |
| h_out, w_out = int(h_out), int(w_out) | |
| X_col = torch.nn.functional.unfold(X.view(1, -1, h_x, w_x), h_filter, dilation=1, padding=padding, stride=stride).view(n_x, -1, h_out*w_out) | |
| X_col = X_col.permute(1,2,0).contiguous().view(X_col.size(1),-1) | |
| W_col = W.view(n_filters, -1) | |
| cdist = new_cdist(1, 0.2) ## https://github.com/huawei-noah/AdderNet/issues/9 | |
| out = -cdist(W_col,X_col.transpose(0,1)) | |
| out = out.view(n_filters, h_out, w_out, n_x) | |
| out = out.permute(3, 0, 1, 2).contiguous() | |
| return out | |
| class adder2d(nn.Module): | |
| def __init__(self,input_channel,output_channel,kernel_size, stride=1, padding=0, bias = False): | |
| super(adder2d, self).__init__() | |
| self.stride = stride | |
| self.padding = padding | |
| self.input_channel = input_channel | |
| self.output_channel = output_channel | |
| self.kernel_size = kernel_size | |
| self.adder = torch.nn.Parameter(nn.init.normal_(torch.randn(output_channel,input_channel,kernel_size,kernel_size))) | |
| self.bias = bias | |
| if bias: | |
| self.b = torch.nn.Parameter(nn.init.uniform_(torch.zeros(output_channel))) | |
| def forward(self, x): | |
| output = adder2d_function(x,self.adder, self.stride, self.padding) | |
| if self.bias: | |
| output += self.b.unsqueeze(0).unsqueeze(2).unsqueeze(3) | |
| return output | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| ''' | |
| Copyright (C) 2020. Huawei Technologies Co., Ltd. All rights reserved. | |
| This program is free software; you can redistribute it and/or modify | |
| it under the terms of BSD 3-Clause License. | |
| This program is distributed in the hope that it will be useful, | |
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| BSD 3-Clause License for more details. | |
| ''' | |
| import torch | |
| import torch.nn as nn | |
| import numpy as np | |
| from torch.autograd import Function | |
| import math | |
| # https://github.com/pytorch/pytorch/issues/15253#issuecomment-491467128 | |
| @torch.jit.script | |
| def my_cdist(x1, x2, p:int): | |
| x1_norm = x1.pow(p).sum(dim=-1, keepdim=True) | |
| x2_norm = x2.pow(p).sum(dim=-1, keepdim=True) | |
| res = torch.addmm(x2_norm.transpose(-2, -1), x1, x2.transpose(-2, -1), alpha=-2).add_(x1_norm) | |
| res = res.clamp_min_(1e-30).sqrt_() | |
| return res | |
| # https://github.com/pytorch/pytorch/pull/25799#issuecomment-529021810 | |
| def fast_cdist(x1, x2, p:int): | |
| adjustment = x1.mean(-2, keepdim=True) | |
| x1 = x1 - adjustment | |
| x2 = x2 - adjustment # x1 and x2 should be identical in all dims except -2 at this point | |
| # Compute distance matrix | |
| # But be clever and do it with a single matmul call | |
| x1_norm = x1.pow(p).sum(dim=-1, keepdim=True) | |
| x1_pad = torch.ones_like(x1_norm) | |
| x2_norm = x2.pow(p).sum(dim=-1, keepdim=True) | |
| x2_pad = torch.ones_like(x2_norm) | |
| x1_ = torch.cat([-2. * x1, x1_norm, x1_pad], dim=-1) | |
| x2_ = torch.cat([x2, x2_pad, x2_norm], dim=-1) | |
| res = x1_.matmul(x2_.transpose(-2, -1)) | |
| # Zero out negative values | |
| res.clamp_min_(1e-30).sqrt_() | |
| return res | |
| def new_cdist(p, eta): ## https://github.com/huawei-noah/AdderNet/issues/6#issuecomment-594212162 | |
| class cdist(torch.autograd.Function): | |
| @staticmethod | |
| def forward(ctx, W, X): | |
| ctx.save_for_backward(W, X) | |
| out = -fast_cdist(W, X, p) | |
| return out | |
| @staticmethod | |
| def backward(ctx, grad_output): | |
| W, X = ctx.saved_tensors | |
| grad_W = grad_X = None | |
| if ctx.needs_input_grad[0]: | |
| _temp1 = torch.unsqueeze(X, 2).expand(X.shape[0], X.shape[1], W.shape[0]).permute(1, 0, 2) | |
| _temp2 = torch.unsqueeze(W.transpose(0, 1), 1) | |
| _temp = fast_cdist(_temp1, _temp2, p).squeeze().transpose(0, 1) | |
| grad_W = torch.matmul(grad_output, _temp) | |
| # print('before norm: ', torch.norm(grad_W)) | |
| grad_W = eta * np.sqrt(grad_W.numel()) / torch.norm(grad_W) * grad_W | |
| print('after norm: ', torch.norm(grad_W)) | |
| if ctx.needs_input_grad[1]: | |
| _temp1 = torch.unsqueeze(W, 2).expand(W.shape[0], W.shape[1], X.shape[0]).permute(1, 0, 2) | |
| _temp2 = torch.unsqueeze(X.transpose(0, 1), 1) | |
| _temp = fast_cdist(_temp1, _temp2, p).squeeze().transpose(0, 1) | |
| _temp = torch.nn.functional.hardtanh(_temp, min_val=-1., max_val=1.) | |
| grad_X = torch.matmul(grad_output.transpose(0, 1), _temp) | |
| return grad_W, grad_X | |
| return cdist().apply | |
| def adder2d_function(X, W, stride=1, padding=0): | |
| n_filters, d_filter, h_filter, w_filter = W.size() | |
| n_x, d_x, h_x, w_x = X.size() | |
| h_out = (h_x - h_filter + 2 * padding) / stride + 1 | |
| w_out = (w_x - w_filter + 2 * padding) / stride + 1 | |
| h_out, w_out = int(h_out), int(w_out) | |
| X_col = torch.nn.functional.unfold(X.view(1, -1, h_x, w_x), h_filter, dilation=1, padding=padding, stride=stride).view(n_x, -1, h_out*w_out) | |
| X_col = X_col.permute(1,2,0).contiguous().view(X_col.size(1),-1) | |
| W_col = W.view(n_filters, -1) | |
| cdist = new_cdist(1, 0.2) ## https://github.com/huawei-noah/AdderNet/issues/9 | |
| out = -cdist(W_col,X_col.transpose(0,1)) | |
| out = out.view(n_filters, h_out, w_out, n_x) | |
| out = out.permute(3, 0, 1, 2).contiguous() | |
| return out | |
| class adder2d(nn.Module): | |
| def __init__(self,input_channel,output_channel,kernel_size, stride=1, padding=0, bias = False): | |
| super(adder2d, self).__init__() | |
| self.stride = stride | |
| self.padding = padding | |
| self.input_channel = input_channel | |
| self.output_channel = output_channel | |
| self.kernel_size = kernel_size | |
| self.adder = torch.nn.Parameter(nn.init.normal_(torch.randn(output_channel,input_channel,kernel_size,kernel_size))) | |
| self.bias = bias | |
| if bias: | |
| self.b = torch.nn.Parameter(nn.init.uniform_(torch.zeros(output_channel))) | |
| def forward(self, x): | |
| output = adder2d_function(x,self.adder, self.stride, self.padding) | |
| if self.bias: | |
| output += self.b.unsqueeze(0).unsqueeze(2).unsqueeze(3) | |
| return output | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| aeroplane | |
| bicycle | |
| bird | |
| boat | |
| bottle | |
| bus | |
| car | |
| cat | |
| chair | |
| cow | |
| diningtable | |
| dog | |
| horse | |
| motorbike | |
| person | |
| pottedplant | |
| sheep | |
| sofa | |
| train | |
| tvmonitor |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| #!/bin/bash | |
| NUM_CLASSES=$1 | |
| echo " | |
| [net] | |
| # Testing | |
| #batch=1 | |
| #subdivisions=1 | |
| # Training | |
| batch=2 | |
| subdivisions=2 | |
| width=416 | |
| height=416 | |
| channels=3 | |
| momentum=0.9 | |
| decay=0.0005 | |
| angle=0 | |
| saturation = 1.5 | |
| exposure = 1.5 | |
| hue=.1 | |
| learning_rate=0.001 | |
| burn_in=1000 | |
| max_batches = 500200 | |
| policy=steps | |
| steps=400000,450000 | |
| scales=.1,.1 | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=32 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| # Downsample | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=64 | |
| size=3 | |
| stride=2 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=32 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=64 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| # Downsample | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=3 | |
| stride=2 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=64 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=64 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| # Downsample | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=3 | |
| stride=2 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| # Downsample | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=3 | |
| stride=2 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| # Downsample | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=1024 | |
| size=3 | |
| stride=2 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=1024 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=1024 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=1024 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=1024 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [shortcut] | |
| from=-3 | |
| activation=linear | |
| ###################### | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| filters=1024 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| filters=1024 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=512 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| filters=1024 | |
| activation=leaky | |
| [convolutional] | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| filters=$(expr 3 \* $(expr $NUM_CLASSES \+ 5)) | |
| activation=linear | |
| [yolo] | |
| mask = 6,7,8 | |
| anchors = 10,13, 16,30, 33,23, 30,61, 62,45, 59,119, 116,90, 156,198, 373,326 | |
| classes=$NUM_CLASSES | |
| num=9 | |
| jitter=.3 | |
| ignore_thresh = .7 | |
| truth_thresh = 1 | |
| random=1 | |
| [route] | |
| layers = -4 | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [upsample] | |
| stride=2 | |
| [route] | |
| layers = -1, 61 | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| filters=512 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| filters=512 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=256 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| filters=512 | |
| activation=leaky | |
| [convolutional] | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| filters=$(expr 3 \* $(expr $NUM_CLASSES \+ 5)) | |
| activation=linear | |
| [yolo] | |
| mask = 3,4,5 | |
| anchors = 10,13, 16,30, 33,23, 30,61, 62,45, 59,119, 116,90, 156,198, 373,326 | |
| classes=$NUM_CLASSES | |
| num=9 | |
| jitter=.3 | |
| ignore_thresh = .7 | |
| truth_thresh = 1 | |
| random=1 | |
| [route] | |
| layers = -4 | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [upsample] | |
| stride=2 | |
| [route] | |
| layers = -1, 36 | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| filters=256 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| filters=256 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| filters=128 | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| activation=leaky | |
| [convolutional] | |
| batch_normalize=1 | |
| size=3 | |
| stride=1 | |
| pad=1 | |
| filters=256 | |
| activation=leaky | |
| [convolutional] | |
| size=1 | |
| stride=1 | |
| pad=1 | |
| filters=$(expr 3 \* $(expr $NUM_CLASSES \+ 5)) | |
| activation=linear | |
| [yolo] | |
| mask = 0,1,2 | |
| anchors = 10,13, 16,30, 33,23, 30,61, 62,45, 59,119, 116,90, 156,198, 373,326 | |
| classes=$NUM_CLASSES | |
| num=9 | |
| jitter=.3 | |
| ignore_thresh = .7 | |
| truth_thresh = 1 | |
| random=1 | |
| " >> yolov3-custom.cfg |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import os | |
| import argparse | |
| import shutil | |
| import tarfile | |
| import sys | |
| from pathlib import Path | |
| import json | |
| image_types = ('.jpg', '.jpeg', '.jpe', '.img', '.png', '.bmp') | |
| def parser(): | |
| parser = argparse.ArgumentParser(description=' ') | |
| parser.add_argument('--source_archive_dir', | |
| type=str, | |
| required=False, | |
| help='Full path to the source archive') | |
| parser.add_argument('--source_images_archive_dir', | |
| type=str, | |
| required=False, | |
| help='Full path to the source archive') | |
| parser.add_argument('--source_annotations_archive_dir', | |
| type=str, | |
| required=False, | |
| help='Full path to the source archive') | |
| parser.add_argument('--output_size', | |
| type=int, | |
| required=True, | |
| help='Number of images in the output dataset') | |
| parser.add_argument('--first_image', | |
| type=int, | |
| required=False, | |
| default=0, | |
| help='Number of the image to start from') | |
| parser.add_argument('--output_archive_dir', | |
| type=str, | |
| required=True, | |
| help='Full path to the output archive (without the name of the archive)') | |
| parser.add_argument('--dataset_type', | |
| type=str, | |
| choices=['imagenet','voc', 'coco'], | |
| required=True, | |
| help='Dataset format: ImageNet, Pascal VOC, or COCO') | |
| return parser | |
| def unarchive(source_archive_dir, output_folder_dir): | |
| shutil.unpack_archive(source_archive_dir, output_folder_dir) | |
| def is_possible_to_cut(dataset_size, subset_size, first_image): | |
| return first_image < dataset_size - subset_size | |
| def cut_imagenet(output_size, output_folder_dir, first_image): | |
| file_names = os.listdir(output_folder_dir) | |
| image_names = [] | |
| text_files = [] | |
| for file_name in file_names: | |
| if file_name.lower().endswith('.txt'): | |
| text_files.append(file_name) | |
| if len(text_files) > 1: | |
| sys.exit('Incorrect dataset format.') | |
| else: | |
| annotation_name = file_name | |
| elif file_name.lower().endswith(image_types): | |
| image_names.append(file_name) | |
| image_ext = os.path.splitext(image_names[0])[1] | |
| if not image_names: | |
| sys.exit('Incorrect dataset format.') | |
| if not is_possible_to_cut(len(image_names), output_size, first_image): | |
| sys.exit('Invalid --first_image value. The number of the starting image should be less than the difference\n' | |
| 'between the dataset size and the subset size.') | |
| annotation_path = os.path.join(output_folder_dir, annotation_name) | |
| with open(annotation_path, 'r') as annotation: | |
| annotation_text = annotation.readlines() | |
| new_annotation_text = annotation_text[first_image:output_size+first_image] | |
| with open(annotation_path, 'w') as new_annotation: | |
| for line in new_annotation_text: | |
| new_annotation.write(line) | |
| new_file_names = [annotation_name, ] | |
| for line in new_annotation_text: | |
| new_file_names.append('{}{}'.format(os.path.splitext(line.split()[0])[0], image_ext)) | |
| files_to_archive = new_file_names | |
| return (files_to_archive, '',) | |
| def cut_voc(output_size, output_folder_dir, first_image): | |
| voc_folder = os.listdir(output_folder_dir)[0] | |
| if voc_folder == 'TrainVal': | |
| voc_devkit_folder_dir = os.path.join(output_folder_dir, voc_folder) | |
| voc_devkit_folder = os.listdir(voc_devkit_folder_dir)[0] | |
| voc_year_folder_dir = os.path.join(voc_devkit_folder_dir, voc_devkit_folder) | |
| voc_year_folder = os.listdir(voc_year_folder_dir)[0] | |
| else: | |
| voc_year_folder_dir = os.path.join(output_folder_dir, voc_folder) | |
| voc_year_folder = os.listdir(voc_year_folder_dir)[0] | |
| voc_root_dir = os.path.join(voc_year_folder_dir, voc_year_folder) | |
| voc_content_root_folders = os.listdir(voc_root_dir) | |
| annotation_dir = os.path.join(voc_root_dir, 'Annotations') | |
| for element in voc_content_root_folders: | |
| path_to_element = os.path.join(voc_root_dir, element) | |
| if os.path.isdir(path_to_element) and 'Images' in element: | |
| images_dir = path_to_element | |
| images_files = os.listdir(images_dir) | |
| if not is_possible_to_cut(len(images_files), output_size, first_image): | |
| sys.exit('Invalid --first_image value. The number of the starting image should be less than the difference\n' | |
| 'between the dataset and subset sizes.') | |
| images_files = images_files[first_image:first_image+output_size] | |
| main_dir = os.path.join(voc_root_dir, 'ImageSets', 'Main') | |
| if (not os.path.isdir(annotation_dir) or not os.path.isdir(main_dir) | |
| or not os.path.isdir(images_dir)): | |
| sys.exit('Incorrect dataset format.') | |
| names = [] | |
| files_directories = [] | |
| for images_file in images_files: | |
| img_name = os.path.splitext(images_file)[0] | |
| annotation = '{}.xml'.format(os.path.join(annotation_dir, img_name)) | |
| if images_file.lower().endswith(image_types) and os.path.isfile(annotation): | |
| names.append(img_name) | |
| files_directories.append(os.path.join(images_dir, images_file)) | |
| if not names: | |
| sys.exit('Incorrect dataset format.') | |
| for name in names: | |
| files_directories.append('{}.xml'.format(os.path.join(annotation_dir, name))) | |
| possible_names = ('test.txt', 'trainval.txt', 'val.txt') | |
| main_txt_dir = None | |
| for name in possible_names: | |
| if os.path.isfile(os.path.join(main_dir, name)): | |
| main_txt_dir = os.path.join(main_dir, name) | |
| break | |
| if not os.path.isfile(main_txt_dir): | |
| sys.exit('Incorrect dataset format') | |
| with open(main_txt_dir, 'w') as main: | |
| main.write('\n'.join(names)) | |
| files_directories.append(main_txt_dir) | |
| return (files_directories, 'VOCdevkit',) | |
| def cut_coco(output_size, output_folder_dir, first_image): | |
| num_of_folders = 2 | |
| root_folders = os.listdir(output_folder_dir) | |
| if len(root_folders) != num_of_folders: | |
| sys.exit('Incorrect dataset format.') | |
| annotations_folder = str(next(Path(output_folder_dir).glob('annotations'))) | |
| images_folder_dir = os.path.join(output_folder_dir, str(next(Path(output_folder_dir).glob('val*[0-9]')))) | |
| images_folder = os.listdir(images_folder_dir) | |
| annotation_name = next(Path(annotations_folder).glob('instances_val*[0-9].json')) | |
| annotation_dir = os.path.join(str(annotations_folder), str(annotation_name)) | |
| annotation_name_train = next(Path(annotations_folder).glob('instances_train*[0-9].json')) | |
| if annotation_name_train: | |
| annotation_dir_train = os.path.join(str(annotations_folder), str(annotation_name_train)) | |
| os.remove(annotation_dir_train) | |
| if not images_folder or not annotation_name: | |
| sys.exit('Incorrect dataset format.') | |
| if not is_possible_to_cut(len(images_folder), output_size, first_image): | |
| sys.exit('Invalid --first_image value. The number of the starting image should be less than the difference ' | |
| 'between the dataset size and the subset size.') | |
| with open(annotation_dir) as json_file: | |
| json_data = json.load(json_file) | |
| json_data['images'] = json_data['images'][first_image:output_size+first_image] | |
| image_filenames = [] | |
| image_ids = [] | |
| for image in json_data['images']: | |
| image_ids.append(image['id']) | |
| image_filenames.append(image['file_name']) | |
| annotations = json_data['annotations'] | |
| cut_annotations = [] | |
| for annotation in annotations: | |
| if annotation['image_id'] in image_ids: | |
| cut_annotations.append(annotation) | |
| json_data['annotations'] = cut_annotations | |
| with open(annotation_name, 'w') as outfile: | |
| json.dump(json_data, outfile) | |
| new_image_filenames = [] | |
| for image in image_filenames: | |
| new_image_filenames.append(os.path.join(images_folder_dir, image)) | |
| files_to_archive = new_image_filenames.copy() | |
| files_to_archive.append(annotations_folder) | |
| return (files_to_archive, 'subset_folder',) | |
| def archive(new_file_names, source_path, output_archive_name, output_folder_dir, rel_path_finder): | |
| with tarfile.open(os.path.join(source_path, '{}.tar.gz'.format(output_archive_name)), 'w:gz') as tar: | |
| for file_name in new_file_names: | |
| relative_path = '{}'.format(file_name[file_name.find(rel_path_finder):]) | |
| tar.add(os.path.join(output_folder_dir, file_name), arcname=relative_path) | |
| def clean_up(path): | |
| shutil.rmtree(path) | |
| def is_imagenet(dataset_type): | |
| return dataset_type == 'imagenet' | |
| def is_voc(dataset_type): | |
| return dataset_type == 'voc' | |
| def is_coco(dataset_type): | |
| return dataset_type == 'coco' | |
| if __name__ == '__main__': | |
| args = parser().parse_args() | |
| output_folder_dir = os.path.join(args.output_archive_dir, 'subset_folder') | |
| output_archive_name = '{}_subset_{}_{}'.format(args.dataset_type, args.first_image, args.first_image + args.output_size - 1) | |
| if is_imagenet(args.dataset_type) and not args.source_archive_dir: | |
| sys.exit('--source_archive_dir is required for the selected dataset type.') | |
| if is_voc(args.dataset_type) and not args.source_archive_dir: | |
| sys.exit('--source_archive_dir is required for the selected dataset type.') | |
| if is_coco(args.dataset_type) and (not args.source_images_archive_dir or not args.source_annotations_archive_dir): | |
| sys.exit('Both --source_images_archive_dir and --source_annotations_archive_dir are required for the selected dataset type.') | |
| if is_imagenet(args.dataset_type): | |
| unarchive(args.source_archive_dir, output_folder_dir) | |
| imagenet_data = cut_imagenet(args.output_size, output_folder_dir, args.first_image) | |
| new_file_names = imagenet_data[0] | |
| rel_path_finder = imagenet_data[1] | |
| elif is_voc(args.dataset_type): | |
| unarchive(args.source_archive_dir, output_folder_dir) | |
| voc_data = cut_voc(args.output_size, output_folder_dir, args.first_image) | |
| new_file_names = voc_data[0] | |
| rel_path_finder = voc_data[1] | |
| else: | |
| unarchive(args.source_images_archive_dir, output_folder_dir) | |
| unarchive(args.source_annotations_archive_dir, output_folder_dir) | |
| coco_data = cut_coco(args.output_size, output_folder_dir, args.first_image) | |
| new_file_names = coco_data[0] | |
| rel_path_finder = coco_data[1] | |
| archive(new_file_names, args.output_archive_dir, output_archive_name, output_folder_dir, rel_path_finder) | |
| clean_up(output_folder_dir) | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import glob | |
| import random | |
| import os | |
| import sys | |
| import numpy as np | |
| from PIL import Image | |
| import torch | |
| import torch.nn.functional as F | |
| from utils.augmentations import horisontal_flip | |
| from torch.utils.data import Dataset | |
| import torchvision.transforms as transforms | |
| def pad_to_square(img, pad_value): | |
| c, h, w = img.shape | |
| dim_diff = np.abs(h - w) | |
| # (upper / left) padding and (lower / right) padding | |
| pad1, pad2 = dim_diff // 2, dim_diff - dim_diff // 2 | |
| # Determine padding | |
| pad = (0, 0, pad1, pad2) if h <= w else (pad1, pad2, 0, 0) | |
| # Add padding | |
| img = F.pad(img, pad, "constant", value=pad_value) | |
| return img, pad | |
| def resize(image, size): | |
| image = F.interpolate(image.unsqueeze(0), size=size, mode="nearest").squeeze(0) | |
| return image | |
| def random_resize(images, min_size=288, max_size=448): | |
| new_size = random.sample(list(range(min_size, max_size + 1, 32)), 1)[0] | |
| images = F.interpolate(images, size=new_size, mode="nearest") | |
| return images | |
| class ImageFolder(Dataset): | |
| def __init__(self, folder_path, img_size=416): | |
| self.files = sorted(glob.glob("%s/*.*" % folder_path)) | |
| self.img_size = img_size | |
| def __getitem__(self, index): | |
| img_path = self.files[index % len(self.files)] | |
| # Extract image as PyTorch tensor | |
| img = transforms.ToTensor()(Image.open(img_path)) | |
| # Pad to square resolution | |
| img, _ = pad_to_square(img, 0) | |
| # Resize | |
| img = resize(img, self.img_size) | |
| return img_path, img | |
| def __len__(self): | |
| return len(self.files) | |
| class ListDataset(Dataset): | |
| def __init__(self, list_path, img_size=416, augment=True, multiscale=True, normalized_labels=True): | |
| with open(list_path, "r") as file: | |
| self.img_files = file.readlines() | |
| self.label_files = [ | |
| path.replace("JPEGImages", "labels").replace(".png", ".txt").replace(".jpg", ".txt") | |
| for path in self.img_files | |
| ] | |
| self.img_size = img_size | |
| self.max_objects = 100 | |
| self.augment = augment | |
| self.multiscale = multiscale | |
| self.normalized_labels = normalized_labels | |
| self.min_size = self.img_size - 3 * 32 | |
| self.max_size = self.img_size + 3 * 32 | |
| self.batch_count = 0 | |
| def __getitem__(self, index): | |
| # --------- | |
| # Image | |
| # --------- | |
| img_path = self.img_files[index % len(self.img_files)].rstrip() | |
| # Extract image as PyTorch tensor | |
| img = transforms.ToTensor()(Image.open(img_path).convert('RGB')) | |
| # Handle images with less than three channels | |
| if len(img.shape) != 3: | |
| img = img.unsqueeze(0) | |
| img = img.expand((3, img.shape[1:])) | |
| _, h, w = img.shape | |
| h_factor, w_factor = (h, w) if self.normalized_labels else (1, 1) | |
| # Pad to square resolution | |
| img, pad = pad_to_square(img, 0) | |
| _, padded_h, padded_w = img.shape | |
| # --------- | |
| # Label | |
| # --------- | |
| label_path = self.label_files[index % len(self.img_files)].rstrip() | |
| targets = None | |
| if os.path.exists(label_path): | |
| boxes = torch.from_numpy(np.loadtxt(label_path).reshape(-1, 5)) | |
| # Extract coordinates for unpadded + unscaled image | |
| x1 = w_factor * (boxes[:, 1] - boxes[:, 3] / 2) | |
| y1 = h_factor * (boxes[:, 2] - boxes[:, 4] / 2) | |
| x2 = w_factor * (boxes[:, 1] + boxes[:, 3] / 2) | |
| y2 = h_factor * (boxes[:, 2] + boxes[:, 4] / 2) | |
| # Adjust for added padding | |
| x1 += pad[0] | |
| y1 += pad[2] | |
| x2 += pad[1] | |
| y2 += pad[3] | |
| # Returns (x, y, w, h) | |
| boxes[:, 1] = ((x1 + x2) / 2) / padded_w | |
| boxes[:, 2] = ((y1 + y2) / 2) / padded_h | |
| boxes[:, 3] *= w_factor / padded_w | |
| boxes[:, 4] *= h_factor / padded_h | |
| targets = torch.zeros((len(boxes), 6)) | |
| targets[:, 1:] = boxes | |
| # Apply augmentations | |
| if self.augment: | |
| if np.random.random() < 0.5: | |
| img, targets = horisontal_flip(img, targets) | |
| return img_path, img, targets | |
| def collate_fn(self, batch): | |
| paths, imgs, targets = list(zip(*batch)) | |
| # Remove empty placeholder targets | |
| targets = [boxes for boxes in targets if boxes is not None] | |
| # Add sample index to targets | |
| for i, boxes in enumerate(targets): | |
| boxes[:, 0] = i | |
| targets = torch.cat(targets, 0) | |
| # Selects new image size every tenth batch | |
| if self.multiscale and self.batch_count % 10 == 0: | |
| self.img_size = random.choice(range(self.min_size, self.max_size + 1, 32)) | |
| # Resize images to input shape | |
| imgs = torch.stack([resize(img, self.img_size) for img in imgs]) | |
| self.batch_count += 1 | |
| return paths, imgs, targets | |
| def __len__(self): | |
| return len(self.img_files) |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import tensorflow as tf | |
| class Logger(object): | |
| def __init__(self, log_dir): | |
| """Create a summary writer logging to log_dir.""" | |
| #self.writer = tf.summary.FileWriter(log_dir) | |
| self.writer = tf.summary.create_file_writer(log_dir) | |
| def scalar_summary(self, tag, value, step): | |
| """Log a scalar variable.""" | |
| #summary = tf.Summary(value=[tf.Summary.Value(tag=tag, simple_value=value)]) | |
| #self.writer.add_summary(summary, step) | |
| with self.writer.as_default(): | |
| tf.summary.scalar(tag, value, step=step) | |
| self.writer.flush() | |
| def list_of_scalars_summary(self, tag_value_pairs, step): | |
| """Log scalar variables.""" | |
| #summary = tf.Summary(value=[tf.Summary.Value(tag=tag, simple_value=value) for tag, value in tag_value_pairs]) | |
| #self.writer.add_summary(summary, step) | |
| with self.writer.as_default(): | |
| for tag, value in tag_value_pairs: | |
| tf.summary.scalar(tag, value, step=step) | |
| self.writer.flush() |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| from __future__ import division | |
| import torch | |
| import torch.nn as nn | |
| import torch.nn.functional as F | |
| from torch.autograd import Variable | |
| import numpy as np | |
| from utils.parse_config import * | |
| from utils.utils import build_targets, to_cpu, non_max_suppression | |
| import matplotlib.pyplot as plt | |
| import matplotlib.patches as patches | |
| import adder ########### | |
| def conv2d(in_channels, out_channels, kernel_size, stride, padding, bias): | |
| """3x3 or 1x1 convolution with padding""" | |
| return adder.adder2d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, | |
| padding=padding, bias=bias) | |
| def create_modules(module_defs): | |
| """ | |
| Constructs module list of layer blocks from module configuration in module_defs | |
| """ | |
| hyperparams = module_defs.pop(0) | |
| output_filters = [int(hyperparams["channels"])] | |
| module_list = nn.ModuleList() | |
| for module_i, module_def in enumerate(module_defs): | |
| modules = nn.Sequential() | |
| if module_def["type"] == "convolutional": | |
| bn = int(module_def["batch_normalize"]) | |
| filters = int(module_def["filters"]) | |
| kernel_size = int(module_def["size"]) | |
| pad = (kernel_size - 1) // 2 | |
| modules.add_module( | |
| f"conv_{module_i}", | |
| # nn.Conv2d( ##################### | |
| conv2d( | |
| in_channels=output_filters[-1], | |
| out_channels=filters, | |
| kernel_size=kernel_size, | |
| stride=int(module_def["stride"]), | |
| padding=pad, | |
| bias=not bn, | |
| ), | |
| ) | |
| if bn: | |
| modules.add_module(f"batch_norm_{module_i}", nn.BatchNorm2d(filters, momentum=0.9, eps=1e-5)) | |
| if module_def["activation"] == "leaky": | |
| modules.add_module(f"leaky_{module_i}", nn.LeakyReLU(0.1)) | |
| elif module_def["type"] == "maxpool": | |
| kernel_size = int(module_def["size"]) | |
| stride = int(module_def["stride"]) | |
| if kernel_size == 2 and stride == 1: | |
| modules.add_module(f"_debug_padding_{module_i}", nn.ZeroPad2d((0, 1, 0, 1))) | |
| maxpool = nn.MaxPool2d(kernel_size=kernel_size, stride=stride, padding=int((kernel_size - 1) // 2)) | |
| modules.add_module(f"maxpool_{module_i}", maxpool) | |
| elif module_def["type"] == "upsample": | |
| upsample = Upsample(scale_factor=int(module_def["stride"]), mode="nearest") | |
| modules.add_module(f"upsample_{module_i}", upsample) | |
| elif module_def["type"] == "route": | |
| layers = [int(x) for x in module_def["layers"].split(",")] | |
| filters = sum([output_filters[1:][i] for i in layers]) | |
| modules.add_module(f"route_{module_i}", EmptyLayer()) | |
| elif module_def["type"] == "shortcut": | |
| filters = output_filters[1:][int(module_def["from"])] | |
| modules.add_module(f"shortcut_{module_i}", EmptyLayer()) | |
| elif module_def["type"] == "yolo": | |
| anchor_idxs = [int(x) for x in module_def["mask"].split(",")] | |
| # Extract anchors | |
| anchors = [int(x) for x in module_def["anchors"].split(",")] | |
| anchors = [(anchors[i], anchors[i + 1]) for i in range(0, len(anchors), 2)] | |
| anchors = [anchors[i] for i in anchor_idxs] | |
| num_classes = int(module_def["classes"]) | |
| img_size = int(hyperparams["height"]) | |
| # Define detection layer | |
| yolo_layer = YOLOLayer(anchors, num_classes, img_size) | |
| modules.add_module(f"yolo_{module_i}", yolo_layer) | |
| # Register module list and number of output filters | |
| module_list.append(modules) | |
| output_filters.append(filters) | |
| return hyperparams, module_list | |
| class Upsample(nn.Module): | |
| """ nn.Upsample is deprecated """ | |
| def __init__(self, scale_factor, mode="nearest"): | |
| super(Upsample, self).__init__() | |
| self.scale_factor = scale_factor | |
| self.mode = mode | |
| def forward(self, x): | |
| x = F.interpolate(x, scale_factor=self.scale_factor, mode=self.mode) | |
| return x | |
| class EmptyLayer(nn.Module): | |
| """Placeholder for 'route' and 'shortcut' layers""" | |
| def __init__(self): | |
| super(EmptyLayer, self).__init__() | |
| class YOLOLayer(nn.Module): | |
| """Detection layer""" | |
| def __init__(self, anchors, num_classes, img_dim=416): | |
| super(YOLOLayer, self).__init__() | |
| self.anchors = anchors | |
| self.num_anchors = len(anchors) | |
| self.num_classes = num_classes | |
| self.ignore_thres = 0.5 | |
| self.mse_loss = nn.MSELoss() | |
| self.bce_loss = nn.BCELoss() | |
| self.obj_scale = 1 | |
| self.noobj_scale = 100 | |
| self.metrics = {} | |
| self.img_dim = img_dim | |
| self.grid_size = 0 # grid size | |
| def compute_grid_offsets(self, grid_size, cuda=True): | |
| self.grid_size = grid_size | |
| g = self.grid_size | |
| FloatTensor = torch.cuda.FloatTensor if cuda else torch.FloatTensor | |
| self.stride = self.img_dim / self.grid_size | |
| # Calculate offsets for each grid | |
| self.grid_x = torch.arange(g).repeat(g, 1).view([1, 1, g, g]).type(FloatTensor) | |
| self.grid_y = torch.arange(g).repeat(g, 1).t().view([1, 1, g, g]).type(FloatTensor) | |
| self.scaled_anchors = FloatTensor([(a_w / self.stride, a_h / self.stride) for a_w, a_h in self.anchors]) | |
| self.anchor_w = self.scaled_anchors[:, 0:1].view((1, self.num_anchors, 1, 1)) | |
| self.anchor_h = self.scaled_anchors[:, 1:2].view((1, self.num_anchors, 1, 1)) | |
| def forward(self, x, targets=None, img_dim=None): | |
| # Tensors for cuda support | |
| FloatTensor = torch.cuda.FloatTensor if x.is_cuda else torch.FloatTensor | |
| LongTensor = torch.cuda.LongTensor if x.is_cuda else torch.LongTensor | |
| ByteTensor = torch.cuda.ByteTensor if x.is_cuda else torch.ByteTensor | |
| self.img_dim = img_dim | |
| num_samples = x.size(0) | |
| grid_size = x.size(2) | |
| prediction = ( | |
| x.view(num_samples, self.num_anchors, self.num_classes + 5, grid_size, grid_size) | |
| .permute(0, 1, 3, 4, 2) | |
| .contiguous() | |
| ) | |
| # Get outputs | |
| x = torch.sigmoid(prediction[..., 0]) # Center x | |
| y = torch.sigmoid(prediction[..., 1]) # Center y | |
| w = prediction[..., 2] # Width | |
| h = prediction[..., 3] # Height | |
| pred_conf = torch.sigmoid(prediction[..., 4]) # Conf | |
| pred_cls = torch.sigmoid(prediction[..., 5:]) # Cls pred. | |
| # If grid size does not match current we compute new offsets | |
| if grid_size != self.grid_size: | |
| self.compute_grid_offsets(grid_size, cuda=x.is_cuda) | |
| # Add offset and scale with anchors | |
| pred_boxes = FloatTensor(prediction[..., :4].shape) | |
| pred_boxes[..., 0] = x.data + self.grid_x | |
| pred_boxes[..., 1] = y.data + self.grid_y | |
| pred_boxes[..., 2] = torch.exp(w.data) * self.anchor_w | |
| pred_boxes[..., 3] = torch.exp(h.data) * self.anchor_h | |
| output = torch.cat( | |
| ( | |
| pred_boxes.view(num_samples, -1, 4) * self.stride, | |
| pred_conf.view(num_samples, -1, 1), | |
| pred_cls.view(num_samples, -1, self.num_classes), | |
| ), | |
| -1, | |
| ) | |
| if targets is None: | |
| return output, 0 | |
| else: | |
| iou_scores, class_mask, obj_mask, noobj_mask, tx, ty, tw, th, tcls, tconf = build_targets( | |
| pred_boxes=pred_boxes, | |
| pred_cls=pred_cls, | |
| target=targets, | |
| anchors=self.scaled_anchors, | |
| ignore_thres=self.ignore_thres, | |
| ) | |
| # Loss : Mask outputs to ignore non-existing objects (except with conf. loss) | |
| loss_x = self.mse_loss(x[obj_mask], tx[obj_mask]) | |
| loss_y = self.mse_loss(y[obj_mask], ty[obj_mask]) | |
| loss_w = self.mse_loss(w[obj_mask], tw[obj_mask]) | |
| loss_h = self.mse_loss(h[obj_mask], th[obj_mask]) | |
| loss_conf_obj = self.bce_loss(pred_conf[obj_mask], tconf[obj_mask]) | |
| loss_conf_noobj = self.bce_loss(pred_conf[noobj_mask], tconf[noobj_mask]) | |
| loss_conf = self.obj_scale * loss_conf_obj + self.noobj_scale * loss_conf_noobj | |
| loss_cls = self.bce_loss(pred_cls[obj_mask], tcls[obj_mask]) | |
| total_loss = loss_x + loss_y + loss_w + loss_h + loss_conf + loss_cls | |
| # Metrics | |
| cls_acc = 100 * class_mask[obj_mask].mean() | |
| conf_obj = pred_conf[obj_mask].mean() | |
| conf_noobj = pred_conf[noobj_mask].mean() | |
| conf50 = (pred_conf > 0.5).float() | |
| iou50 = (iou_scores > 0.5).float() | |
| iou75 = (iou_scores > 0.75).float() | |
| detected_mask = conf50 * class_mask * tconf | |
| precision = torch.sum(iou50 * detected_mask) / (conf50.sum() + 1e-16) | |
| recall50 = torch.sum(iou50 * detected_mask) / (obj_mask.sum() + 1e-16) | |
| recall75 = torch.sum(iou75 * detected_mask) / (obj_mask.sum() + 1e-16) | |
| self.metrics = { | |
| "loss": to_cpu(total_loss).item(), | |
| "x": to_cpu(loss_x).item(), | |
| "y": to_cpu(loss_y).item(), | |
| "w": to_cpu(loss_w).item(), | |
| "h": to_cpu(loss_h).item(), | |
| "conf": to_cpu(loss_conf).item(), | |
| "cls": to_cpu(loss_cls).item(), | |
| "cls_acc": to_cpu(cls_acc).item(), | |
| "recall50": to_cpu(recall50).item(), | |
| "recall75": to_cpu(recall75).item(), | |
| "precision": to_cpu(precision).item(), | |
| "conf_obj": to_cpu(conf_obj).item(), | |
| "conf_noobj": to_cpu(conf_noobj).item(), | |
| "grid_size": grid_size, | |
| } | |
| return output, total_loss | |
| class Darknet(nn.Module): | |
| """YOLOv3 object detection model""" | |
| def __init__(self, config_path, img_size=416): | |
| super(Darknet, self).__init__() | |
| self.module_defs = parse_model_config(config_path) | |
| self.hyperparams, self.module_list = create_modules(self.module_defs) | |
| self.yolo_layers = [layer[0] for layer in self.module_list if hasattr(layer[0], "metrics")] | |
| self.img_size = img_size | |
| self.seen = 0 | |
| self.header_info = np.array([0, 0, 0, self.seen, 0], dtype=np.int32) | |
| def forward(self, x, targets=None): | |
| img_dim = x.shape[2] | |
| loss = 0 | |
| layer_outputs, yolo_outputs = [], [] | |
| for i, (module_def, module) in enumerate(zip(self.module_defs, self.module_list)): | |
| if module_def["type"] in ["convolutional", "upsample", "maxpool"]: | |
| x = module(x) | |
| elif module_def["type"] == "route": | |
| x = torch.cat([layer_outputs[int(layer_i)] for layer_i in module_def["layers"].split(",")], 1) | |
| elif module_def["type"] == "shortcut": | |
| layer_i = int(module_def["from"]) | |
| x = layer_outputs[-1] + layer_outputs[layer_i] | |
| elif module_def["type"] == "yolo": | |
| x, layer_loss = module[0](x, targets, img_dim) | |
| loss += layer_loss | |
| yolo_outputs.append(x) | |
| layer_outputs.append(x) | |
| yolo_outputs = to_cpu(torch.cat(yolo_outputs, 1)) | |
| return yolo_outputs if targets is None else (loss, yolo_outputs) | |
| def load_darknet_weights(self, weights_path): | |
| """Parses and loads the weights stored in 'weights_path'""" | |
| # Open the weights file | |
| with open(weights_path, "rb") as f: | |
| header = np.fromfile(f, dtype=np.int32, count=5) # First five are header values | |
| self.header_info = header # Needed to write header when saving weights | |
| self.seen = header[3] # number of images seen during training | |
| weights = np.fromfile(f, dtype=np.float32) # The rest are weights | |
| # Establish cutoff for loading backbone weights | |
| cutoff = None | |
| if "darknet53.conv.74" in weights_path: | |
| cutoff = 75 | |
| ptr = 0 | |
| for i, (module_def, module) in enumerate(zip(self.module_defs, self.module_list)): | |
| if i == cutoff: | |
| break | |
| if module_def["type"] == "convolutional": | |
| conv_layer = module[0] | |
| if module_def["batch_normalize"]: | |
| # Load BN bias, weights, running mean and running variance | |
| bn_layer = module[1] | |
| num_b = bn_layer.bias.numel() # Number of biases | |
| # Bias | |
| bn_b = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(bn_layer.bias) | |
| bn_layer.bias.data.copy_(bn_b) | |
| ptr += num_b | |
| # Weight | |
| bn_w = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(bn_layer.weight) | |
| bn_layer.weight.data.copy_(bn_w) | |
| ptr += num_b | |
| # Running Mean | |
| bn_rm = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(bn_layer.running_mean) | |
| bn_layer.running_mean.data.copy_(bn_rm) | |
| ptr += num_b | |
| # Running Var | |
| bn_rv = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(bn_layer.running_var) | |
| bn_layer.running_var.data.copy_(bn_rv) | |
| ptr += num_b | |
| else: | |
| # Load conv. bias | |
| num_b = conv_layer.bias.numel() | |
| conv_b = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(conv_layer.bias) | |
| conv_layer.bias.data.copy_(conv_b) | |
| ptr += num_b | |
| # Load conv. weights | |
| num_w = conv_layer.weight.numel() | |
| conv_w = torch.from_numpy(weights[ptr : ptr + num_w]).view_as(conv_layer.weight) | |
| conv_layer.weight.data.copy_(conv_w) | |
| ptr += num_w | |
| def save_darknet_weights(self, path, cutoff=-1): | |
| """ | |
| @:param path - path of the new weights file | |
| @:param cutoff - save layers between 0 and cutoff (cutoff = -1 -> all are saved) | |
| """ | |
| fp = open(path, "wb") | |
| self.header_info[3] = self.seen | |
| self.header_info.tofile(fp) | |
| # Iterate through layers | |
| for i, (module_def, module) in enumerate(zip(self.module_defs[:cutoff], self.module_list[:cutoff])): | |
| if module_def["type"] == "convolutional": | |
| conv_layer = module[0] | |
| # If batch norm, load bn first | |
| if module_def["batch_normalize"]: | |
| bn_layer = module[1] | |
| bn_layer.bias.data.cpu().numpy().tofile(fp) | |
| bn_layer.weight.data.cpu().numpy().tofile(fp) | |
| bn_layer.running_mean.data.cpu().numpy().tofile(fp) | |
| bn_layer.running_var.data.cpu().numpy().tofile(fp) | |
| # Load conv bias | |
| else: | |
| conv_layer.bias.data.cpu().numpy().tofile(fp) | |
| # Load conv weights | |
| conv_layer.weight.data.cpu().numpy().tofile(fp) | |
| fp.close() |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| from __future__ import division | |
| from models import * | |
| from utils.utils import * | |
| from utils.datasets import * | |
| from utils.parse_config import * | |
| import os | |
| import sys | |
| import time | |
| import datetime | |
| import argparse | |
| import tqdm | |
| import torch | |
| from torch.utils.data import DataLoader | |
| from torchvision import datasets | |
| from torchvision import transforms | |
| from torch.autograd import Variable | |
| import torch.optim as optim | |
| def evaluate(model, path, iou_thres, conf_thres, nms_thres, img_size, batch_size): | |
| model.eval() | |
| # Get dataloader | |
| dataset = ListDataset(path, img_size=img_size, augment=False, multiscale=False) | |
| dataloader = torch.utils.data.DataLoader( | |
| dataset, batch_size=batch_size, shuffle=False, num_workers=0, collate_fn=dataset.collate_fn | |
| ) | |
| Tensor = torch.cuda.FloatTensor if torch.cuda.is_available() else torch.FloatTensor | |
| labels = [] | |
| sample_metrics = [] # List of tuples (TP, confs, pred) | |
| for batch_i, (_, imgs, targets) in enumerate(tqdm.tqdm(dataloader, desc="Detecting objects")): | |
| # Extract labels | |
| labels += targets[:, 1].tolist() | |
| # Rescale target | |
| targets[:, 2:] = xywh2xyxy(targets[:, 2:]) | |
| targets[:, 2:] *= img_size | |
| imgs = Variable(imgs.type(Tensor), requires_grad=False) | |
| with torch.no_grad(): | |
| outputs = model(imgs) | |
| outputs = non_max_suppression(outputs, conf_thres=conf_thres, nms_thres=nms_thres) | |
| sample_metrics += get_batch_statistics(outputs, targets, iou_threshold=iou_thres) | |
| # Concatenate sample statistics | |
| true_positives, pred_scores, pred_labels = [np.concatenate(x, 0) for x in list(zip(*sample_metrics))] | |
| precision, recall, AP, f1, ap_class = ap_per_class(true_positives, pred_scores, pred_labels, labels) | |
| return precision, recall, AP, f1, ap_class | |
| if __name__ == "__main__": | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--batch_size", type=int, default=2, help="size of each image batch") | |
| parser.add_argument("--model_def", type=str, default="config/yolov3.cfg", help="path to model definition file") | |
| parser.add_argument("--data_config", type=str, default="config/coco.data", help="path to data config file") | |
| parser.add_argument("--weights_path", type=str, default="weights/yolov3.weights", help="path to weights file") | |
| parser.add_argument("--class_path", type=str, default="data/coco.names", help="path to class label file") | |
| parser.add_argument("--iou_thres", type=float, default=0.5, help="iou threshold required to qualify as detected") | |
| parser.add_argument("--conf_thres", type=float, default=0.001, help="object confidence threshold") | |
| parser.add_argument("--nms_thres", type=float, default=0.5, help="iou thresshold for non-maximum suppression") | |
| parser.add_argument("--n_cpu", type=int, default=8, help="number of cpu threads to use during batch generation") | |
| parser.add_argument("--img_size", type=int, default=416, help="size of each image dimension") | |
| opt = parser.parse_args() | |
| print(opt) | |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") | |
| data_config = parse_data_config(opt.data_config) | |
| valid_path = data_config["valid"] | |
| class_names = load_classes(data_config["names"]) | |
| # Initiate model | |
| model = Darknet(opt.model_def).to(device) | |
| if opt.weights_path.endswith(".weights"): | |
| # Load darknet weights | |
| model.load_darknet_weights(opt.weights_path) | |
| else: | |
| # Load checkpoint weights | |
| model.load_state_dict(torch.load(opt.weights_path)) | |
| print("Compute mAP...") | |
| precision, recall, AP, f1, ap_class = evaluate( | |
| model, | |
| path=valid_path, | |
| iou_thres=opt.iou_thres, | |
| conf_thres=opt.conf_thres, | |
| nms_thres=opt.nms_thres, | |
| img_size=opt.img_size, | |
| batch_size=2, | |
| ) | |
| print("Average Precisions:") | |
| for i, c in enumerate(ap_class): | |
| print(f"+ Class '{c}' ({class_names[c]}) - AP: {AP[i]}") | |
| print(f"mAP: {AP.mean()}") |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| from __future__ import division | |
| from models import * | |
| from utils.logger import * | |
| from utils.utils import * | |
| from utils.datasets import * | |
| from utils.parse_config import * | |
| from test import evaluate | |
| from terminaltables import AsciiTable | |
| import os | |
| import sys | |
| import time | |
| import datetime | |
| import argparse | |
| import torch | |
| from torch.utils.data import DataLoader | |
| from torchvision import datasets | |
| from torchvision import transforms | |
| from torch.autograd import Variable | |
| import torch.optim as optim | |
| if __name__ == "__main__": | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--epochs", type=int, default=100, help="number of epochs") | |
| parser.add_argument("--batch_size", type=int, default=2, help="size of each image batch") | |
| parser.add_argument("--gradient_accumulations", type=int, default=2, help="number of gradient accums before step") | |
| parser.add_argument("--model_def", type=str, default="config/yolov3.cfg", help="path to model definition file") | |
| parser.add_argument("--data_config", type=str, default="config/coco.data", help="path to data config file") | |
| parser.add_argument("--pretrained_weights", type=str, help="if specified starts from checkpoint model") | |
| parser.add_argument("--n_cpu", type=int, default=0, help="number of cpu threads to use during batch generation") | |
| parser.add_argument("--img_size", type=int, default=416, help="size of each image dimension") | |
| parser.add_argument("--checkpoint_interval", type=int, default=1, help="interval between saving model weights") | |
| parser.add_argument("--evaluation_interval", type=int, default=1, help="interval evaluations on validation set") | |
| parser.add_argument("--compute_map", default=False, help="if True computes mAP every tenth batch") | |
| parser.add_argument("--multiscale_training", default=True, help="allow for multi-scale training") | |
| opt = parser.parse_args() | |
| print(opt) | |
| ## logger = Logger("logs") | |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") | |
| os.makedirs("output", exist_ok=True) | |
| os.makedirs("checkpoints", exist_ok=True) | |
| # Get data configuration | |
| data_config = parse_data_config(opt.data_config) | |
| train_path = data_config["train"] | |
| valid_path = data_config["valid"] | |
| class_names = load_classes(data_config["names"]) | |
| # Initiate model | |
| model = Darknet(opt.model_def).to(device) | |
| model.apply(weights_init_normal) | |
| # If specified we start from checkpoint | |
| # if opt.pretrained_weights: | |
| # if opt.pretrained_weights.endswith(".pth"): | |
| # model.load_state_dict(torch.load(opt.pretrained_weights)) | |
| # else: | |
| # model.load_darknet_weights(opt.pretrained_weights) | |
| # Get dataloader | |
| dataset = ListDataset(train_path, augment=True, multiscale=opt.multiscale_training) | |
| dataloader = torch.utils.data.DataLoader( | |
| dataset, | |
| batch_size=opt.batch_size, | |
| shuffle=True, | |
| num_workers=opt.n_cpu, | |
| pin_memory=True, | |
| collate_fn=dataset.collate_fn, | |
| ) | |
| optimizer = torch.optim.Adam(model.parameters()) | |
| metrics = [ | |
| "grid_size", | |
| "loss", | |
| "x", | |
| "y", | |
| "w", | |
| "h", | |
| "conf", | |
| "cls", | |
| "cls_acc", | |
| "recall50", | |
| "recall75", | |
| "precision", | |
| "conf_obj", | |
| "conf_noobj", | |
| ] | |
| for epoch in range(opt.epochs): | |
| model.train() | |
| start_time = time.time() | |
| for batch_i, (_, imgs, targets) in enumerate(dataloader): | |
| batches_done = len(dataloader) * epoch + batch_i | |
| imgs = Variable(imgs.to(device)) | |
| targets = Variable(targets.to(device), requires_grad=False) | |
| loss, outputs = model(imgs, targets) | |
| loss.backward() | |
| if batches_done % opt.gradient_accumulations: | |
| # Accumulates gradient before each step | |
| optimizer.step() | |
| optimizer.zero_grad() | |
| # ---------------- | |
| # Log progress | |
| # ---------------- | |
| log_str = "\n---- [Epoch %d/%d, Batch %d/%d] ----\n" % (epoch, opt.epochs, batch_i, len(dataloader)) | |
| metric_table = [["Metrics", *[f"YOLO Layer {i}" for i in range(len(model.yolo_layers))]]] | |
| # Log metrics at each YOLO layer | |
| for i, metric in enumerate(metrics): | |
| formats = {m: "%.6f" for m in metrics} | |
| formats["grid_size"] = "%2d" | |
| formats["cls_acc"] = "%.2f%%" | |
| row_metrics = [formats[metric] % yolo.metrics.get(metric, 0) for yolo in model.yolo_layers] | |
| metric_table += [[metric, *row_metrics]] | |
| # Tensorboard logging | |
| tensorboard_log = [] | |
| for j, yolo in enumerate(model.yolo_layers): | |
| for name, metric in yolo.metrics.items(): | |
| if name != "grid_size": | |
| tensorboard_log += [(f"{name}_{j+1}", metric)] | |
| tensorboard_log += [("loss", loss.item())] | |
| ## logger.list_of_scalars_summary(tensorboard_log, batches_done) | |
| log_str += AsciiTable(metric_table).table | |
| log_str += f"\nTotal loss {loss.item()}" | |
| # Determine approximate time left for epoch | |
| epoch_batches_left = len(dataloader) - (batch_i + 1) | |
| time_left = datetime.timedelta(seconds=epoch_batches_left * (time.time() - start_time) / (batch_i + 1)) | |
| log_str += f"\n---- ETA {time_left}" | |
| print(log_str) | |
| model.seen += imgs.size(0) | |
| if epoch % opt.evaluation_interval == 0: | |
| print("\n---- Evaluating Model ----") | |
| # Evaluate the model on the validation set | |
| precision, recall, AP, f1, ap_class = evaluate( | |
| model, | |
| path=valid_path, | |
| iou_thres=0.5, | |
| conf_thres=0.5, | |
| nms_thres=0.5, | |
| img_size=opt.img_size, | |
| batch_size=2, | |
| ) | |
| evaluation_metrics = [ | |
| ("val_precision", precision.mean()), | |
| ("val_recall", recall.mean()), | |
| ("val_mAP", AP.mean()), | |
| ("val_f1", f1.mean()), | |
| ] | |
| ## logger.list_of_scalars_summary(evaluation_metrics, epoch) | |
| # Print class APs and mAP | |
| ap_table = [["Index", "Class name", "AP"]] | |
| for i, c in enumerate(ap_class): | |
| ap_table += [[c, class_names[c], "%.5f" % AP[i]]] | |
| print(AsciiTable(ap_table).table) | |
| print(f"---- mAP {AP.mean()}") | |
| if epoch % opt.checkpoint_interval == 0: | |
| torch.save(model.state_dict(), f"checkpoints/yolov3_ckpt_%d.pth" % epoch) |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| from __future__ import division | |
| from models import * | |
| from utils.logger import * | |
| from utils.utils import * | |
| from utils.datasets import * | |
| from utils.parse_config import * | |
| from test import evaluate | |
| from terminaltables import AsciiTable | |
| import os | |
| import sys | |
| import time | |
| import datetime | |
| import argparse | |
| import torch | |
| from torch.utils.data import DataLoader | |
| from torchvision import datasets | |
| from torchvision import transforms | |
| from torch.autograd import Variable | |
| import torch.optim as optim | |
| import apex | |
| from apex import amp | |
| if __name__ == "__main__": | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument("--epochs", type=int, default=100, help="number of epochs") | |
| parser.add_argument("--batch_size", type=int, default=2, help="size of each image batch") | |
| parser.add_argument("--gradient_accumulations", type=int, default=2, help="number of gradient accums before step") | |
| parser.add_argument("--model_def", type=str, default="config/yolov3.cfg", help="path to model definition file") | |
| parser.add_argument("--data_config", type=str, default="config/coco.data", help="path to data config file") | |
| parser.add_argument("--pretrained_weights", type=str, help="if specified starts from checkpoint model") | |
| parser.add_argument("--n_cpu", type=int, default=0, help="number of cpu threads to use during batch generation") | |
| parser.add_argument("--img_size", type=int, default=416, help="size of each image dimension") | |
| parser.add_argument("--checkpoint_interval", type=int, default=1, help="interval between saving model weights") | |
| parser.add_argument("--evaluation_interval", type=int, default=1, help="interval evaluations on validation set") | |
| parser.add_argument("--compute_map", default=False, help="if True computes mAP every tenth batch") | |
| parser.add_argument("--multiscale_training", default=True, help="allow for multi-scale training") | |
| opt = parser.parse_args() | |
| print(opt) | |
| ## logger = Logger("logs") | |
| device = torch.device("cuda" if torch.cuda.is_available() else "cpu") | |
| os.makedirs("output", exist_ok=True) | |
| os.makedirs("checkpoints", exist_ok=True) | |
| # Get data configuration | |
| data_config = parse_data_config(opt.data_config) | |
| train_path = data_config["train"] | |
| valid_path = data_config["valid"] | |
| class_names = load_classes(data_config["names"]) | |
| # Initiate model | |
| model = Darknet(opt.model_def).to(device) | |
| model.apply(weights_init_normal) | |
| # If specified we start from checkpoint | |
| # if opt.pretrained_weights: | |
| # if opt.pretrained_weights.endswith(".pth"): | |
| # model.load_state_dict(torch.load(opt.pretrained_weights)) | |
| # else: | |
| # model.load_darknet_weights(opt.pretrained_weights) | |
| # Get dataloader | |
| dataset = ListDataset(train_path, augment=True, multiscale=opt.multiscale_training) | |
| dataloader = torch.utils.data.DataLoader( | |
| dataset, | |
| batch_size=opt.batch_size, | |
| shuffle=True, | |
| num_workers=opt.n_cpu, | |
| pin_memory=True, | |
| collate_fn=dataset.collate_fn, | |
| ) | |
| optimizer = torch.optim.Adam(model.parameters()) | |
| model, optimizer = amp.initialize(model, optimizer, opt_level="O3") | |
| metrics = [ | |
| "grid_size", | |
| "loss", | |
| "x", | |
| "y", | |
| "w", | |
| "h", | |
| "conf", | |
| "cls", | |
| "cls_acc", | |
| "recall50", | |
| "recall75", | |
| "precision", | |
| "conf_obj", | |
| "conf_noobj", | |
| ] | |
| for epoch in range(opt.epochs): | |
| model.train() | |
| start_time = time.time() | |
| for batch_i, (_, imgs, targets) in enumerate(dataloader): | |
| batches_done = len(dataloader) * epoch + batch_i | |
| imgs = Variable(imgs.to(device)) | |
| targets = Variable(targets.to(device), requires_grad=False) | |
| loss, outputs = model(imgs, targets) | |
| with amp.scale_loss(loss, optimizer) as scaled_loss: | |
| scaled_loss.backward() | |
| if batches_done % opt.gradient_accumulations: | |
| # Accumulates gradient before each step | |
| optimizer.step() | |
| optimizer.zero_grad() | |
| # ---------------- | |
| # Log progress | |
| # ---------------- | |
| log_str = "\n---- [Epoch %d/%d, Batch %d/%d] ----\n" % (epoch, opt.epochs, batch_i, len(dataloader)) | |
| metric_table = [["Metrics", *[f"YOLO Layer {i}" for i in range(len(model.yolo_layers))]]] | |
| # Log metrics at each YOLO layer | |
| for i, metric in enumerate(metrics): | |
| formats = {m: "%.6f" for m in metrics} | |
| formats["grid_size"] = "%2d" | |
| formats["cls_acc"] = "%.2f%%" | |
| row_metrics = [formats[metric] % yolo.metrics.get(metric, 0) for yolo in model.yolo_layers] | |
| metric_table += [[metric, *row_metrics]] | |
| # Tensorboard logging | |
| tensorboard_log = [] | |
| for j, yolo in enumerate(model.yolo_layers): | |
| for name, metric in yolo.metrics.items(): | |
| if name != "grid_size": | |
| tensorboard_log += [(f"{name}_{j+1}", metric)] | |
| tensorboard_log += [("loss", loss.item())] | |
| ## logger.list_of_scalars_summary(tensorboard_log, batches_done) | |
| log_str += AsciiTable(metric_table).table | |
| log_str += f"\nTotal loss {loss.item()}" | |
| # Determine approximate time left for epoch | |
| epoch_batches_left = len(dataloader) - (batch_i + 1) | |
| time_left = datetime.timedelta(seconds=epoch_batches_left * (time.time() - start_time) / (batch_i + 1)) | |
| log_str += f"\n---- ETA {time_left}" | |
| print(log_str) | |
| model.seen += imgs.size(0) | |
| if epoch % opt.evaluation_interval == 0: | |
| print("\n---- Evaluating Model ----") | |
| # Evaluate the model on the validation set | |
| precision, recall, AP, f1, ap_class = evaluate( | |
| model, | |
| path=valid_path, | |
| iou_thres=0.5, | |
| conf_thres=0.5, | |
| nms_thres=0.5, | |
| img_size=opt.img_size, | |
| batch_size=2, | |
| ) | |
| evaluation_metrics = [ | |
| ("val_precision", precision.mean()), | |
| ("val_recall", recall.mean()), | |
| ("val_mAP", AP.mean()), | |
| ("val_f1", f1.mean()), | |
| ] | |
| ## logger.list_of_scalars_summary(evaluation_metrics, epoch) | |
| # Print class APs and mAP | |
| ap_table = [["Index", "Class name", "AP"]] | |
| for i, c in enumerate(ap_class): | |
| ap_table += [[c, class_names[c], "%.5f" % AP[i]]] | |
| print(AsciiTable(ap_table).table) | |
| print(f"---- mAP {AP.mean()}") | |
| if epoch % opt.checkpoint_interval == 0: | |
| torch.save(model.state_dict(), f"checkpoints/yolov3_ckpt_%d.pth" % epoch) | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| import xml.etree.ElementTree as ET | |
| import pickle | |
| import os | |
| from os import listdir, getcwd | |
| from os.path import join | |
| sets=[('2007', 'train'), ('2007', 'val'), ('2007', 'test')] | |
| classes = ["aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"] | |
| def convert(size, box): | |
| dw = 1./(size[0]) | |
| dh = 1./(size[1]) | |
| x = (box[0] + box[1])/2.0 - 1 | |
| y = (box[2] + box[3])/2.0 - 1 | |
| w = box[1] - box[0] | |
| h = box[3] - box[2] | |
| x = x*dw | |
| w = w*dw | |
| y = y*dh | |
| h = h*dh | |
| return (x,y,w,h) | |
| def convert_annotation(year, image_id): | |
| in_file = open('VOCdevkit/VOC%s/Annotations/%s.xml'%(year, image_id)) | |
| out_file = open('VOCdevkit/VOC%s/labels/%s.txt'%(year, image_id), 'w') | |
| tree=ET.parse(in_file) | |
| root = tree.getroot() | |
| size = root.find('size') | |
| w = int(size.find('width').text) | |
| h = int(size.find('height').text) | |
| for obj in root.iter('object'): | |
| difficult = obj.find('difficult').text | |
| cls = obj.find('name').text | |
| if cls not in classes or int(difficult)==1: | |
| continue | |
| cls_id = classes.index(cls) | |
| xmlbox = obj.find('bndbox') | |
| b = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), float(xmlbox.find('ymin').text), float(xmlbox.find('ymax').text)) | |
| bb = convert((w,h), b) | |
| out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n') | |
| wd = getcwd() | |
| for year, image_set in sets: | |
| if not os.path.exists('VOCdevkit/VOC%s/labels/'%(year)): | |
| os.makedirs('VOCdevkit/VOC%s/labels/'%(year)) | |
| image_ids = open('VOCdevkit/VOC%s/ImageSets/Main/%s.txt'%(year, image_set)).read().strip().split() | |
| list_file = open('%s_%s.txt'%(year, image_set), 'w') | |
| for image_id in image_ids: | |
| list_file.write('%s/VOCdevkit/VOC%s/JPEGImages/%s.jpg\n'%(wd, year, image_id)) | |
| convert_annotation(year, image_id) | |
| list_file.close() | |
| os.system("cat 2007_train.txt 2007_val.txt > train.txt") | |
| os.system("cat 2007_train.txt 2007_val.txt 2007_test.txt > train.all.txt") | |
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| { | |
| "nbformat": 4, | |
| "nbformat_minor": 0, | |
| "metadata": { | |
| "colab": { | |
| "name": "YOLOv3 + AdderNet.ipynb", | |
| "provenance": [], | |
| "collapsed_sections": [] | |
| }, | |
| "kernelspec": { | |
| "name": "python3", | |
| "display_name": "Python 3" | |
| }, | |
| "accelerator": "GPU" | |
| }, | |
| "cells": [ | |
| { | |
| "cell_type": "code", | |
| "metadata": { | |
| "id": "ht9Wcnrbmbgm", | |
| "colab_type": "code", | |
| "outputId": "a811d173-abc0-4168-c1ed-c0c471821315", | |
| "colab": { | |
| "base_uri": "https://localhost:8080/", | |
| "height": 1000 | |
| } | |
| }, | |
| "source": [ | |
| "!git clone https://github.com/NVIDIA/apex\n", | |
| "%cd /content/apex/\n", | |
| "!pip3 install -v --no-cache-dir --global-option=\"--cpp_ext\" --global-option=\"--cuda_ext\" ./" | |
| ], | |
| "execution_count": 0, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "text": [ | |
| "Cloning into 'apex'...\n", | |
| "remote: Enumerating objects: 4, done.\u001b[K\n", | |
| "remote: Counting objects: 25% (1/4)\u001b[K\rremote: Counting objects: 50% (2/4)\u001b[K\rremote: Counting objects: 75% (3/4)\u001b[K\rremote: Counting objects: 100% (4/4)\u001b[K\rremote: Counting objects: 100% (4/4), done.\u001b[K\n", | |
| "remote: Compressing objects: 100% (4/4), done.\u001b[K\n", | |
| "remote: Total 6593 (delta 0), reused 0 (delta 0), pack-reused 6589\u001b[K\n", | |
| "Receiving objects: 100% (6593/6593), 13.71 MiB | 24.37 MiB/s, done.\n", | |
| "Resolving deltas: 100% (4384/4384), done.\n", | |
| "/content/apex\n", | |
| "/usr/local/lib/python3.6/dist-packages/pip/_internal/commands/install.py:283: UserWarning: Disabling all use of wheels due to the use of --build-options / --global-options / --install-options.\n", | |
| " cmdoptions.check_install_build_global(options)\n", | |
| "Created temporary directory: /tmp/pip-ephem-wheel-cache-mgede09u\n", | |
| "Created temporary directory: /tmp/pip-req-tracker-g3lyu538\n", | |
| "Created requirements tracker '/tmp/pip-req-tracker-g3lyu538'\n", | |
| "Created temporary directory: /tmp/pip-install-h14cohfw\n", | |
| "Processing /content/apex\n", | |
| " Created temporary directory: /tmp/pip-req-build-0cj84n_w\n", | |
| " Added file:///content/apex to build tracker '/tmp/pip-req-tracker-g3lyu538'\n", | |
| " Running setup.py (path:/tmp/pip-req-build-0cj84n_w/setup.py) egg_info for package from file:///content/apex\n", | |
| " Running command python setup.py egg_info\n", | |
| " torch.__version__ = 1.4.0\n", | |
| " running egg_info\n", | |
| " creating /tmp/pip-req-build-0cj84n_w/pip-egg-info/apex.egg-info\n", | |
| " writing /tmp/pip-req-build-0cj84n_w/pip-egg-info/apex.egg-info/PKG-INFO\n", | |
| " writing dependency_links to /tmp/pip-req-build-0cj84n_w/pip-egg-info/apex.egg-info/dependency_links.txt\n", | |
| " writing top-level names to /tmp/pip-req-build-0cj84n_w/pip-egg-info/apex.egg-info/top_level.txt\n", | |
| " writing manifest file '/tmp/pip-req-build-0cj84n_w/pip-egg-info/apex.egg-info/SOURCES.txt'\n", | |
| " writing manifest file '/tmp/pip-req-build-0cj84n_w/pip-egg-info/apex.egg-info/SOURCES.txt'\n", | |
| " /tmp/pip-req-build-0cj84n_w/setup.py:46: UserWarning: Option --pyprof not specified. Not installing PyProf dependencies!\n", | |
| " warnings.warn(\"Option --pyprof not specified. Not installing PyProf dependencies!\")\n", | |
| " Source in /tmp/pip-req-build-0cj84n_w has version 0.1, which satisfies requirement apex==0.1 from file:///content/apex\n", | |
| " Removed apex==0.1 from file:///content/apex from build tracker '/tmp/pip-req-tracker-g3lyu538'\n", | |
| "Skipping wheel build for apex, due to binaries being disabled for it.\n", | |
| "Installing collected packages: apex\n", | |
| " Created temporary directory: /tmp/pip-record-mieu_b4r\n", | |
| " Running command /usr/bin/python3 -u -c 'import sys, setuptools, tokenize; sys.argv[0] = '\"'\"'/tmp/pip-req-build-0cj84n_w/setup.py'\"'\"'; __file__='\"'\"'/tmp/pip-req-build-0cj84n_w/setup.py'\"'\"';f=getattr(tokenize, '\"'\"'open'\"'\"', open)(__file__);code=f.read().replace('\"'\"'\\r\\n'\"'\"', '\"'\"'\\n'\"'\"');f.close();exec(compile(code, __file__, '\"'\"'exec'\"'\"'))' --cpp_ext --cuda_ext install --record /tmp/pip-record-mieu_b4r/install-record.txt --single-version-externally-managed --compile\n", | |
| " torch.__version__ = 1.4.0\n", | |
| " /tmp/pip-req-build-0cj84n_w/setup.py:46: UserWarning: Option --pyprof not specified. Not installing PyProf dependencies!\n", | |
| " warnings.warn(\"Option --pyprof not specified. Not installing PyProf dependencies!\")\n", | |
| "\n", | |
| " Compiling cuda extensions with\n", | |
| " nvcc: NVIDIA (R) Cuda compiler driver\n", | |
| " Copyright (c) 2005-2019 NVIDIA Corporation\n", | |
| " Built on Sun_Jul_28_19:07:16_PDT_2019\n", | |
| " Cuda compilation tools, release 10.1, V10.1.243\n", | |
| " from /usr/local/cuda/bin\n", | |
| "\n", | |
| " running install\n", | |
| " running build\n", | |
| " running build_py\n", | |
| " creating build\n", | |
| " creating build/lib.linux-x86_64-3.6\n", | |
| " creating build/lib.linux-x86_64-3.6/apex\n", | |
| " copying apex/__init__.py -> build/lib.linux-x86_64-3.6/apex\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/pyprof\n", | |
| " copying apex/pyprof/__init__.py -> build/lib.linux-x86_64-3.6/apex/pyprof\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/contrib\n", | |
| " copying apex/contrib/__init__.py -> build/lib.linux-x86_64-3.6/apex/contrib\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/normalization\n", | |
| " copying apex/normalization/fused_layer_norm.py -> build/lib.linux-x86_64-3.6/apex/normalization\n", | |
| " copying apex/normalization/__init__.py -> build/lib.linux-x86_64-3.6/apex/normalization\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/mlp\n", | |
| " copying apex/mlp/mlp.py -> build/lib.linux-x86_64-3.6/apex/mlp\n", | |
| " copying apex/mlp/__init__.py -> build/lib.linux-x86_64-3.6/apex/mlp\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/RNN\n", | |
| " copying apex/RNN/models.py -> build/lib.linux-x86_64-3.6/apex/RNN\n", | |
| " copying apex/RNN/RNNBackend.py -> build/lib.linux-x86_64-3.6/apex/RNN\n", | |
| " copying apex/RNN/__init__.py -> build/lib.linux-x86_64-3.6/apex/RNN\n", | |
| " copying apex/RNN/cells.py -> build/lib.linux-x86_64-3.6/apex/RNN\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/multi_tensor_apply\n", | |
| " copying apex/multi_tensor_apply/multi_tensor_apply.py -> build/lib.linux-x86_64-3.6/apex/multi_tensor_apply\n", | |
| " copying apex/multi_tensor_apply/__init__.py -> build/lib.linux-x86_64-3.6/apex/multi_tensor_apply\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/optimizers\n", | |
| " copying apex/optimizers/fused_adam.py -> build/lib.linux-x86_64-3.6/apex/optimizers\n", | |
| " copying apex/optimizers/fused_lamb.py -> build/lib.linux-x86_64-3.6/apex/optimizers\n", | |
| " copying apex/optimizers/fused_novograd.py -> build/lib.linux-x86_64-3.6/apex/optimizers\n", | |
| " copying apex/optimizers/__init__.py -> build/lib.linux-x86_64-3.6/apex/optimizers\n", | |
| " copying apex/optimizers/fused_sgd.py -> build/lib.linux-x86_64-3.6/apex/optimizers\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/parallel\n", | |
| " copying apex/parallel/multiproc.py -> build/lib.linux-x86_64-3.6/apex/parallel\n", | |
| " copying apex/parallel/sync_batchnorm.py -> build/lib.linux-x86_64-3.6/apex/parallel\n", | |
| " copying apex/parallel/LARC.py -> build/lib.linux-x86_64-3.6/apex/parallel\n", | |
| " copying apex/parallel/distributed.py -> build/lib.linux-x86_64-3.6/apex/parallel\n", | |
| " copying apex/parallel/optimized_sync_batchnorm.py -> build/lib.linux-x86_64-3.6/apex/parallel\n", | |
| " copying apex/parallel/sync_batchnorm_kernel.py -> build/lib.linux-x86_64-3.6/apex/parallel\n", | |
| " copying apex/parallel/optimized_sync_batchnorm_kernel.py -> build/lib.linux-x86_64-3.6/apex/parallel\n", | |
| " copying apex/parallel/__init__.py -> build/lib.linux-x86_64-3.6/apex/parallel\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/reparameterization\n", | |
| " copying apex/reparameterization/__init__.py -> build/lib.linux-x86_64-3.6/apex/reparameterization\n", | |
| " copying apex/reparameterization/reparameterization.py -> build/lib.linux-x86_64-3.6/apex/reparameterization\n", | |
| " copying apex/reparameterization/weight_norm.py -> build/lib.linux-x86_64-3.6/apex/reparameterization\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/_process_optimizer.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/__version__.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/compat.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/handle.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/_initialize.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/rnn_compat.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/amp.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/opt.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/__init__.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/utils.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/frontend.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/_amp_state.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/wrap.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " copying apex/amp/scaler.py -> build/lib.linux-x86_64-3.6/apex/amp\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/fp16_utils\n", | |
| " copying apex/fp16_utils/fp16util.py -> build/lib.linux-x86_64-3.6/apex/fp16_utils\n", | |
| " copying apex/fp16_utils/fp16_optimizer.py -> build/lib.linux-x86_64-3.6/apex/fp16_utils\n", | |
| " copying apex/fp16_utils/__init__.py -> build/lib.linux-x86_64-3.6/apex/fp16_utils\n", | |
| " copying apex/fp16_utils/loss_scaler.py -> build/lib.linux-x86_64-3.6/apex/fp16_utils\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/pyprof/nvtx\n", | |
| " copying apex/pyprof/nvtx/__init__.py -> build/lib.linux-x86_64-3.6/apex/pyprof/nvtx\n", | |
| " copying apex/pyprof/nvtx/nvmarker.py -> build/lib.linux-x86_64-3.6/apex/pyprof/nvtx\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/conv.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/blas.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/prof.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/softmax.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/recurrentCell.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/misc.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/base.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/embedding.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/usage.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/activation.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/loss.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/optim.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/dropout.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/pointwise.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/data.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/reduction.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/output.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/index_slice_join_mutate.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/pooling.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/__main__.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/__init__.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/linear.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/utility.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/randomSample.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/convert.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " copying apex/pyprof/prof/normalization.py -> build/lib.linux-x86_64-3.6/apex/pyprof/prof\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/pyprof/parse\n", | |
| " copying apex/pyprof/parse/kernel.py -> build/lib.linux-x86_64-3.6/apex/pyprof/parse\n", | |
| " copying apex/pyprof/parse/nvvp.py -> build/lib.linux-x86_64-3.6/apex/pyprof/parse\n", | |
| " copying apex/pyprof/parse/parse.py -> build/lib.linux-x86_64-3.6/apex/pyprof/parse\n", | |
| " copying apex/pyprof/parse/__main__.py -> build/lib.linux-x86_64-3.6/apex/pyprof/parse\n", | |
| " copying apex/pyprof/parse/__init__.py -> build/lib.linux-x86_64-3.6/apex/pyprof/parse\n", | |
| " copying apex/pyprof/parse/db.py -> build/lib.linux-x86_64-3.6/apex/pyprof/parse\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/contrib/groupbn\n", | |
| " copying apex/contrib/groupbn/batch_norm.py -> build/lib.linux-x86_64-3.6/apex/contrib/groupbn\n", | |
| " copying apex/contrib/groupbn/__init__.py -> build/lib.linux-x86_64-3.6/apex/contrib/groupbn\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/contrib/xentropy\n", | |
| " copying apex/contrib/xentropy/__init__.py -> build/lib.linux-x86_64-3.6/apex/contrib/xentropy\n", | |
| " copying apex/contrib/xentropy/softmax_xentropy.py -> build/lib.linux-x86_64-3.6/apex/contrib/xentropy\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/contrib/optimizers\n", | |
| " copying apex/contrib/optimizers/fused_adam.py -> build/lib.linux-x86_64-3.6/apex/contrib/optimizers\n", | |
| " copying apex/contrib/optimizers/fp16_optimizer.py -> build/lib.linux-x86_64-3.6/apex/contrib/optimizers\n", | |
| " copying apex/contrib/optimizers/fused_lamb.py -> build/lib.linux-x86_64-3.6/apex/contrib/optimizers\n", | |
| " copying apex/contrib/optimizers/__init__.py -> build/lib.linux-x86_64-3.6/apex/contrib/optimizers\n", | |
| " copying apex/contrib/optimizers/fused_sgd.py -> build/lib.linux-x86_64-3.6/apex/contrib/optimizers\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn\n", | |
| " copying apex/contrib/multihead_attn/self_multihead_attn_func.py -> build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn\n", | |
| " copying apex/contrib/multihead_attn/encdec_multihead_attn.py -> build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn\n", | |
| " copying apex/contrib/multihead_attn/fast_encdec_multihead_attn_func.py -> build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn\n", | |
| " copying apex/contrib/multihead_attn/fast_self_multihead_attn_norm_add_func.py -> build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn\n", | |
| " copying apex/contrib/multihead_attn/self_multihead_attn.py -> build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn\n", | |
| " copying apex/contrib/multihead_attn/fast_self_multihead_attn_func.py -> build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn\n", | |
| " copying apex/contrib/multihead_attn/__init__.py -> build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn\n", | |
| " copying apex/contrib/multihead_attn/encdec_multihead_attn_func.py -> build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn\n", | |
| " copying apex/contrib/multihead_attn/fast_encdec_multihead_attn_norm_add_func.py -> build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn\n", | |
| " creating build/lib.linux-x86_64-3.6/apex/amp/lists\n", | |
| " copying apex/amp/lists/tensor_overrides.py -> build/lib.linux-x86_64-3.6/apex/amp/lists\n", | |
| " copying apex/amp/lists/functional_overrides.py -> build/lib.linux-x86_64-3.6/apex/amp/lists\n", | |
| " copying apex/amp/lists/torch_overrides.py -> build/lib.linux-x86_64-3.6/apex/amp/lists\n", | |
| " copying apex/amp/lists/__init__.py -> build/lib.linux-x86_64-3.6/apex/amp/lists\n", | |
| " running build_ext\n", | |
| " building 'apex_C' extension\n", | |
| " creating build/temp.linux-x86_64-3.6\n", | |
| " creating build/temp.linux-x86_64-3.6/csrc\n", | |
| " x86_64-linux-gnu-gcc -pthread -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -fPIC -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/include/python3.6m -c csrc/flatten_unflatten.cpp -o build/temp.linux-x86_64-3.6/csrc/flatten_unflatten.o -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=apex_C -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++11\n", | |
| " x86_64-linux-gnu-g++ -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-Bsymbolic-functions -Wl,-z,relro -Wl,-Bsymbolic-functions -Wl,-z,relro -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 build/temp.linux-x86_64-3.6/csrc/flatten_unflatten.o -o build/lib.linux-x86_64-3.6/apex_C.cpython-36m-x86_64-linux-gnu.so\n", | |
| " building 'amp_C' extension\n", | |
| " x86_64-linux-gnu-gcc -pthread -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -fPIC -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/amp_C_frontend.cpp -o build/temp.linux-x86_64-3.6/csrc/amp_C_frontend.o -O3 -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=amp_C -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++11\n", | |
| " /usr/local/cuda/bin/nvcc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/multi_tensor_sgd_kernel.cu -o build/temp.linux-x86_64-3.6/csrc/multi_tensor_sgd_kernel.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options '-fPIC' -lineinfo -O3 --use_fast_math -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=amp_C -D_GLIBCXX_USE_CXX11_ABI=0 -gencode=arch=compute_37,code=sm_37 -std=c++11\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/cuda/bin/nvcc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/multi_tensor_scale_kernel.cu -o build/temp.linux-x86_64-3.6/csrc/multi_tensor_scale_kernel.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options '-fPIC' -lineinfo -O3 --use_fast_math -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=amp_C -D_GLIBCXX_USE_CXX11_ABI=0 -gencode=arch=compute_37,code=sm_37 -std=c++11\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/cuda/bin/nvcc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/multi_tensor_axpby_kernel.cu -o build/temp.linux-x86_64-3.6/csrc/multi_tensor_axpby_kernel.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options '-fPIC' -lineinfo -O3 --use_fast_math -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=amp_C -D_GLIBCXX_USE_CXX11_ABI=0 -gencode=arch=compute_37,code=sm_37 -std=c++11\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/cuda/bin/nvcc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/multi_tensor_l2norm_kernel.cu -o build/temp.linux-x86_64-3.6/csrc/multi_tensor_l2norm_kernel.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options '-fPIC' -lineinfo -O3 --use_fast_math -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=amp_C -D_GLIBCXX_USE_CXX11_ABI=0 -gencode=arch=compute_37,code=sm_37 -std=c++11\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/cuda/bin/nvcc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/multi_tensor_lamb_stage_1.cu -o build/temp.linux-x86_64-3.6/csrc/multi_tensor_lamb_stage_1.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options '-fPIC' -lineinfo -O3 --use_fast_math -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=amp_C -D_GLIBCXX_USE_CXX11_ABI=0 -gencode=arch=compute_37,code=sm_37 -std=c++11\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/cuda/bin/nvcc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/multi_tensor_lamb_stage_2.cu -o build/temp.linux-x86_64-3.6/csrc/multi_tensor_lamb_stage_2.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options '-fPIC' -lineinfo -O3 --use_fast_math -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=amp_C -D_GLIBCXX_USE_CXX11_ABI=0 -gencode=arch=compute_37,code=sm_37 -std=c++11\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/cuda/bin/nvcc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/multi_tensor_adam.cu -o build/temp.linux-x86_64-3.6/csrc/multi_tensor_adam.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options '-fPIC' -lineinfo -O3 --use_fast_math -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=amp_C -D_GLIBCXX_USE_CXX11_ABI=0 -gencode=arch=compute_37,code=sm_37 -std=c++11\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/cuda/bin/nvcc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/multi_tensor_novograd.cu -o build/temp.linux-x86_64-3.6/csrc/multi_tensor_novograd.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options '-fPIC' -lineinfo -O3 --use_fast_math -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=amp_C -D_GLIBCXX_USE_CXX11_ABI=0 -gencode=arch=compute_37,code=sm_37 -std=c++11\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/cuda/bin/nvcc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/multi_tensor_lamb.cu -o build/temp.linux-x86_64-3.6/csrc/multi_tensor_lamb.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options '-fPIC' -lineinfo -O3 --use_fast_math -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=amp_C -D_GLIBCXX_USE_CXX11_ABI=0 -gencode=arch=compute_37,code=sm_37 -std=c++11\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " x86_64-linux-gnu-g++ -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-Bsymbolic-functions -Wl,-z,relro -Wl,-Bsymbolic-functions -Wl,-z,relro -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 build/temp.linux-x86_64-3.6/csrc/amp_C_frontend.o build/temp.linux-x86_64-3.6/csrc/multi_tensor_sgd_kernel.o build/temp.linux-x86_64-3.6/csrc/multi_tensor_scale_kernel.o build/temp.linux-x86_64-3.6/csrc/multi_tensor_axpby_kernel.o build/temp.linux-x86_64-3.6/csrc/multi_tensor_l2norm_kernel.o build/temp.linux-x86_64-3.6/csrc/multi_tensor_lamb_stage_1.o build/temp.linux-x86_64-3.6/csrc/multi_tensor_lamb_stage_2.o build/temp.linux-x86_64-3.6/csrc/multi_tensor_adam.o build/temp.linux-x86_64-3.6/csrc/multi_tensor_novograd.o build/temp.linux-x86_64-3.6/csrc/multi_tensor_lamb.o -L/usr/local/cuda/lib64 -lcudart -o build/lib.linux-x86_64-3.6/amp_C.cpython-36m-x86_64-linux-gnu.so\n", | |
| " building 'syncbn' extension\n", | |
| " x86_64-linux-gnu-gcc -pthread -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -fPIC -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/syncbn.cpp -o build/temp.linux-x86_64-3.6/csrc/syncbn.o -O3 -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=syncbn -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++11\n", | |
| " /usr/local/cuda/bin/nvcc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/welford.cu -o build/temp.linux-x86_64-3.6/csrc/welford.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options '-fPIC' -O3 -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=syncbn -D_GLIBCXX_USE_CXX11_ABI=0 -gencode=arch=compute_37,code=sm_37 -std=c++11\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " x86_64-linux-gnu-g++ -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-Bsymbolic-functions -Wl,-z,relro -Wl,-Bsymbolic-functions -Wl,-z,relro -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 build/temp.linux-x86_64-3.6/csrc/syncbn.o build/temp.linux-x86_64-3.6/csrc/welford.o -L/usr/local/cuda/lib64 -lcudart -o build/lib.linux-x86_64-3.6/syncbn.cpython-36m-x86_64-linux-gnu.so\n", | |
| " building 'fused_layer_norm_cuda' extension\n", | |
| " x86_64-linux-gnu-gcc -pthread -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -fPIC -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/layer_norm_cuda.cpp -o build/temp.linux-x86_64-3.6/csrc/layer_norm_cuda.o -O3 -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=fused_layer_norm_cuda -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++11\n", | |
| " /usr/local/cuda/bin/nvcc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/layer_norm_cuda_kernel.cu -o build/temp.linux-x86_64-3.6/csrc/layer_norm_cuda_kernel.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options '-fPIC' -maxrregcount=50 -O3 --use_fast_math -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=fused_layer_norm_cuda -D_GLIBCXX_USE_CXX11_ABI=0 -gencode=arch=compute_37,code=sm_37 -std=c++11\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " x86_64-linux-gnu-g++ -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-Bsymbolic-functions -Wl,-z,relro -Wl,-Bsymbolic-functions -Wl,-z,relro -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 build/temp.linux-x86_64-3.6/csrc/layer_norm_cuda.o build/temp.linux-x86_64-3.6/csrc/layer_norm_cuda_kernel.o -L/usr/local/cuda/lib64 -lcudart -o build/lib.linux-x86_64-3.6/fused_layer_norm_cuda.cpython-36m-x86_64-linux-gnu.so\n", | |
| " building 'mlp_cuda' extension\n", | |
| " x86_64-linux-gnu-gcc -pthread -DNDEBUG -g -fwrapv -O2 -Wall -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 -fPIC -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/mlp.cpp -o build/temp.linux-x86_64-3.6/csrc/mlp.o -O3 -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=mlp_cuda -D_GLIBCXX_USE_CXX11_ABI=0 -std=c++11\n", | |
| " csrc/mlp.cpp: In function ‘std::vector<at::Tensor> mlp_forward(std::vector<at::Tensor>)’:\n", | |
| " csrc/mlp.cpp:47:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]\n", | |
| " for (int i = 0; i < num_layers; i++) {\n", | |
| " ~~^~~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:56:68: warning: narrowing conversion of ‘reserved_size’ from ‘long unsigned int’ to ‘long int’ inside { } [-Wnarrowing]\n", | |
| " auto reserved_space = at::empty({reserved_size}, inputs[0].type());\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:56:68: warning: narrowing conversion of ‘reserved_size’ from ‘long unsigned int’ to ‘long int’ inside { } [-Wnarrowing]\n", | |
| " In file included from /usr/local/lib/python3.6/dist-packages/torch/include/ATen/ATen.h:9:0,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/types.h:3,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader_options.h:4,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader/base.h:3,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader/stateful.h:3,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader.h:3,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data.h:3,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/all.h:4,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/extension.h:4,\n", | |
| " from csrc/mlp.cpp:1:\n", | |
| " csrc/mlp.cpp: In lambda function:\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:116:56: warning: ‘c10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)’ is deprecated [-Wdeprecated-declarations]\n", | |
| " at::ScalarType _st = ::detail::scalar_type(the_type); \\\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:58:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:31:23: note: declared here\n", | |
| " inline at::ScalarType scalar_type(const at::DeprecatedTypeProperties &t) {\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp: In lambda function:\n", | |
| " csrc/mlp.cpp:61:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]\n", | |
| " for (int i = 0; i < num_layers; i++) {\n", | |
| " ~~^~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:58:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:65:10: warning: unused variable ‘result’ [-Wunused-variable]\n", | |
| " auto result = mlp_fp<scalar_t>(\n", | |
| " ^\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:58:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp: In lambda function:\n", | |
| " csrc/mlp.cpp:61:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]\n", | |
| " for (int i = 0; i < num_layers; i++) {\n", | |
| " ~~^~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:58:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:65:10: warning: unused variable ‘result’ [-Wunused-variable]\n", | |
| " auto result = mlp_fp<scalar_t>(\n", | |
| " ^\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:58:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp: In lambda function:\n", | |
| " csrc/mlp.cpp:61:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]\n", | |
| " for (int i = 0; i < num_layers; i++) {\n", | |
| " ~~^~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:58:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:65:10: warning: unused variable ‘result’ [-Wunused-variable]\n", | |
| " auto result = mlp_fp<scalar_t>(\n", | |
| " ^\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:58:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp: In function ‘std::vector<at::Tensor> mlp_backward(at::Tensor, std::vector<at::Tensor>, std::vector<at::Tensor>)’:\n", | |
| " csrc/mlp.cpp:90:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]\n", | |
| " for (int i = 0; i < num_layers; i++) {\n", | |
| " ~~^~~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:95:21: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]\n", | |
| " for (int i = 0; i < inputs.size(); i++) {\n", | |
| " ~~^~~~~~~~~~~~~~~\n", | |
| " In file included from /usr/local/lib/python3.6/dist-packages/torch/include/ATen/ATen.h:9:0,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/types.h:3,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader_options.h:4,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader/base.h:3,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader/stateful.h:3,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data/dataloader.h:3,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/data.h:3,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/all.h:4,\n", | |
| " from /usr/local/lib/python3.6/dist-packages/torch/include/torch/extension.h:4,\n", | |
| " from csrc/mlp.cpp:1:\n", | |
| " csrc/mlp.cpp: In lambda function:\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:116:56: warning: ‘c10::ScalarType detail::scalar_type(const at::DeprecatedTypeProperties&)’ is deprecated [-Wdeprecated-declarations]\n", | |
| " at::ScalarType _st = ::detail::scalar_type(the_type); \\\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:31:23: note: declared here\n", | |
| " inline at::ScalarType scalar_type(const at::DeprecatedTypeProperties &t) {\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp: In lambda function:\n", | |
| " csrc/mlp.cpp:102:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]\n", | |
| " for (int i = 0; i < num_layers; i++) {\n", | |
| " ~~^~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:107:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]\n", | |
| " for (int i = 0; i < inputs.size(); i++) {\n", | |
| " ~~^~~~~~~~~~~~~~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:115:44: warning: narrowing conversion of ‘(work_size / sizeof (scalar_t))’ from ‘long unsigned int’ to ‘long int’ inside { } [-Wnarrowing]\n", | |
| " auto work_space = at::empty({work_size / sizeof(scalar_t)}, inputs[0].type());\n", | |
| " ~~~~~~~~~~^~~~~~~~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:115:44: warning: narrowing conversion of ‘(work_size / sizeof (scalar_t))’ from ‘long unsigned int’ to ‘long int’ inside { } [-Wnarrowing]\n", | |
| " auto work_space = at::empty({work_size / sizeof(scalar_t)}, inputs[0].type());\n", | |
| " ~~~~~~~~~~^~~~~~~~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:117:10: warning: unused variable ‘result’ [-Wunused-variable]\n", | |
| " auto result = mlp_bp<scalar_t>(\n", | |
| " ^\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp: In lambda function:\n", | |
| " csrc/mlp.cpp:102:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]\n", | |
| " for (int i = 0; i < num_layers; i++) {\n", | |
| " ~~^~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:107:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]\n", | |
| " for (int i = 0; i < inputs.size(); i++) {\n", | |
| " ~~^~~~~~~~~~~~~~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:115:44: warning: narrowing conversion of ‘(work_size / sizeof (scalar_t))’ from ‘long unsigned int’ to ‘long int’ inside { } [-Wnarrowing]\n", | |
| " auto work_space = at::empty({work_size / sizeof(scalar_t)}, inputs[0].type());\n", | |
| " ~~~~~~~~~~^~~~~~~~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:115:44: warning: narrowing conversion of ‘(work_size / sizeof (scalar_t))’ from ‘long unsigned int’ to ‘long int’ inside { } [-Wnarrowing]\n", | |
| " auto work_space = at::empty({work_size / sizeof(scalar_t)}, inputs[0].type());\n", | |
| " ~~~~~~~~~~^~~~~~~~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:117:10: warning: unused variable ‘result’ [-Wunused-variable]\n", | |
| " auto result = mlp_bp<scalar_t>(\n", | |
| " ^\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp: In lambda function:\n", | |
| " csrc/mlp.cpp:102:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]\n", | |
| " for (int i = 0; i < num_layers; i++) {\n", | |
| " ~~^~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:107:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]\n", | |
| " for (int i = 0; i < inputs.size(); i++) {\n", | |
| " ~~^~~~~~~~~~~~~~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:115:44: warning: narrowing conversion of ‘(work_size / sizeof (scalar_t))’ from ‘long unsigned int’ to ‘long int’ inside { } [-Wnarrowing]\n", | |
| " auto work_space = at::empty({work_size / sizeof(scalar_t)}, inputs[0].type());\n", | |
| " ~~~~~~~~~~^~~~~~~~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:115:44: warning: narrowing conversion of ‘(work_size / sizeof (scalar_t))’ from ‘long unsigned int’ to ‘long int’ inside { } [-Wnarrowing]\n", | |
| " auto work_space = at::empty({work_size / sizeof(scalar_t)}, inputs[0].type());\n", | |
| " ~~~~~~~~~~^~~~~~~~~\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " csrc/mlp.cpp:117:10: warning: unused variable ‘result’ [-Wunused-variable]\n", | |
| " auto result = mlp_bp<scalar_t>(\n", | |
| " ^\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/ATen/Dispatch.h:12:12: note: in definition of macro ‘AT_PRIVATE_CASE_TYPE’\n", | |
| " return __VA_ARGS__(); \\\n", | |
| " ^~~~~~~~~~~\n", | |
| " csrc/mlp.cpp:99:3: note: in expansion of macro ‘AT_DISPATCH_FLOATING_TYPES_AND_HALF’\n", | |
| " AT_DISPATCH_FLOATING_TYPES_AND_HALF(inputs[0].type(), \"mlp_forward\", [&] {\n", | |
| " ^\n", | |
| " /usr/local/cuda/bin/nvcc -I/usr/local/lib/python3.6/dist-packages/torch/include -I/usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include -I/usr/local/lib/python3.6/dist-packages/torch/include/TH -I/usr/local/lib/python3.6/dist-packages/torch/include/THC -I/usr/local/cuda/include -I/usr/include/python3.6m -c csrc/mlp_cuda.cu -o build/temp.linux-x86_64-3.6/csrc/mlp_cuda.o -D__CUDA_NO_HALF_OPERATORS__ -D__CUDA_NO_HALF_CONVERSIONS__ -D__CUDA_NO_HALF2_OPERATORS__ --expt-relaxed-constexpr --compiler-options '-fPIC' -O3 -DVERSION_GE_1_1 -DVERSION_GE_1_3 -DTORCH_API_INCLUDE_EXTENSION_H -DTORCH_EXTENSION_NAME=mlp_cuda -D_GLIBCXX_USE_CXX11_ABI=0 -gencode=arch=compute_37,code=sm_37 -std=c++11\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(14): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(15): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(15): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(15): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(18): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(19): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(19): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(19): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(23): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(24): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(24): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(24): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/autograd/profiler.h(97): warning: attribute \"__visibility__\" does not apply here\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/autograd/profiler.h(112): warning: attribute \"__visibility__\" does not apply here\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/c10/core/TensorTypeSet.h(44): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(14): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(15): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(15): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(15): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(18): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(19): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(19): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(19): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(23): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(24): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(24): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/api/include/torch/nn/functional/padding.h(24): warning: integer conversion resulted in a change of sign\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/autograd/profiler.h(97): warning: attribute \"__visibility__\" does not apply here\n", | |
| "\n", | |
| " /usr/local/lib/python3.6/dist-packages/torch/include/torch/csrc/autograd/profiler.h(112): warning: attribute \"__visibility__\" does not apply here\n", | |
| "\n", | |
| " x86_64-linux-gnu-g++ -pthread -shared -Wl,-O1 -Wl,-Bsymbolic-functions -Wl,-Bsymbolic-functions -Wl,-z,relro -Wl,-Bsymbolic-functions -Wl,-z,relro -g -fstack-protector-strong -Wformat -Werror=format-security -Wdate-time -D_FORTIFY_SOURCE=2 build/temp.linux-x86_64-3.6/csrc/mlp.o build/temp.linux-x86_64-3.6/csrc/mlp_cuda.o -L/usr/local/cuda/lib64 -lcudart -o build/lib.linux-x86_64-3.6/mlp_cuda.cpython-36m-x86_64-linux-gnu.so\n", | |
| " running install_lib\n", | |
| " copying build/lib.linux-x86_64-3.6/fused_layer_norm_cuda.cpython-36m-x86_64-linux-gnu.so -> /usr/local/lib/python3.6/dist-packages\n", | |
| " copying build/lib.linux-x86_64-3.6/apex_C.cpython-36m-x86_64-linux-gnu.so -> /usr/local/lib/python3.6/dist-packages\n", | |
| " copying build/lib.linux-x86_64-3.6/amp_C.cpython-36m-x86_64-linux-gnu.so -> /usr/local/lib/python3.6/dist-packages\n", | |
| " copying build/lib.linux-x86_64-3.6/mlp_cuda.cpython-36m-x86_64-linux-gnu.so -> /usr/local/lib/python3.6/dist-packages\n", | |
| " copying build/lib.linux-x86_64-3.6/syncbn.cpython-36m-x86_64-linux-gnu.so -> /usr/local/lib/python3.6/dist-packages\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/pyprof\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/pyprof/nvtx\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/nvtx/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/nvtx\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/nvtx/nvmarker.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/nvtx\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/conv.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/blas.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/prof.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/softmax.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/recurrentCell.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/misc.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/base.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/embedding.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/usage.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/activation.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/loss.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/optim.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/dropout.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/pointwise.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/data.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/reduction.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/output.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/index_slice_join_mutate.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/pooling.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/__main__.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/linear.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/utility.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/randomSample.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/convert.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/prof/normalization.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/pyprof/parse\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/parse/kernel.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/parse\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/parse/nvvp.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/parse\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/parse/parse.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/parse\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/parse/__main__.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/parse\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/parse/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/parse\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/pyprof/parse/db.py -> /usr/local/lib/python3.6/dist-packages/apex/pyprof/parse\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/contrib\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/contrib/groupbn\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/groupbn/batch_norm.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/groupbn\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/groupbn/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/groupbn\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/contrib/xentropy\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/xentropy/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/xentropy\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/xentropy/softmax_xentropy.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/xentropy\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/contrib/optimizers\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/optimizers/fused_adam.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/optimizers\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/optimizers/fp16_optimizer.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/optimizers\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/optimizers/fused_lamb.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/optimizers\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/optimizers/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/optimizers\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/optimizers/fused_sgd.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/optimizers\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn/self_multihead_attn_func.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn/encdec_multihead_attn.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn/fast_encdec_multihead_attn_func.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn/fast_self_multihead_attn_norm_add_func.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn/self_multihead_attn.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn/fast_self_multihead_attn_func.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn/encdec_multihead_attn_func.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/multihead_attn/fast_encdec_multihead_attn_norm_add_func.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/contrib/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/contrib\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/normalization\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/normalization/fused_layer_norm.py -> /usr/local/lib/python3.6/dist-packages/apex/normalization\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/normalization/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/normalization\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/mlp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/mlp/mlp.py -> /usr/local/lib/python3.6/dist-packages/apex/mlp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/mlp/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/mlp\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/RNN\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/RNN/models.py -> /usr/local/lib/python3.6/dist-packages/apex/RNN\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/RNN/RNNBackend.py -> /usr/local/lib/python3.6/dist-packages/apex/RNN\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/RNN/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/RNN\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/RNN/cells.py -> /usr/local/lib/python3.6/dist-packages/apex/RNN\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/multi_tensor_apply\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/multi_tensor_apply/multi_tensor_apply.py -> /usr/local/lib/python3.6/dist-packages/apex/multi_tensor_apply\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/multi_tensor_apply/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/multi_tensor_apply\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/optimizers\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/optimizers/fused_adam.py -> /usr/local/lib/python3.6/dist-packages/apex/optimizers\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/optimizers/fused_lamb.py -> /usr/local/lib/python3.6/dist-packages/apex/optimizers\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/optimizers/fused_novograd.py -> /usr/local/lib/python3.6/dist-packages/apex/optimizers\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/optimizers/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/optimizers\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/optimizers/fused_sgd.py -> /usr/local/lib/python3.6/dist-packages/apex/optimizers\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/parallel\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/parallel/multiproc.py -> /usr/local/lib/python3.6/dist-packages/apex/parallel\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/parallel/sync_batchnorm.py -> /usr/local/lib/python3.6/dist-packages/apex/parallel\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/parallel/LARC.py -> /usr/local/lib/python3.6/dist-packages/apex/parallel\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/parallel/distributed.py -> /usr/local/lib/python3.6/dist-packages/apex/parallel\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/parallel/optimized_sync_batchnorm.py -> /usr/local/lib/python3.6/dist-packages/apex/parallel\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/parallel/sync_batchnorm_kernel.py -> /usr/local/lib/python3.6/dist-packages/apex/parallel\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/parallel/optimized_sync_batchnorm_kernel.py -> /usr/local/lib/python3.6/dist-packages/apex/parallel\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/parallel/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/parallel\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/reparameterization\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/reparameterization/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/reparameterization\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/reparameterization/reparameterization.py -> /usr/local/lib/python3.6/dist-packages/apex/reparameterization\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/reparameterization/weight_norm.py -> /usr/local/lib/python3.6/dist-packages/apex/reparameterization\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/_process_optimizer.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/__version__.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/compat.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/handle.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/_initialize.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/rnn_compat.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/amp.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/opt.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/utils.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/frontend.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/amp/lists\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/lists/tensor_overrides.py -> /usr/local/lib/python3.6/dist-packages/apex/amp/lists\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/lists/functional_overrides.py -> /usr/local/lib/python3.6/dist-packages/apex/amp/lists\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/lists/torch_overrides.py -> /usr/local/lib/python3.6/dist-packages/apex/amp/lists\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/lists/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/amp/lists\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/_amp_state.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/wrap.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/amp/scaler.py -> /usr/local/lib/python3.6/dist-packages/apex/amp\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex\n", | |
| " creating /usr/local/lib/python3.6/dist-packages/apex/fp16_utils\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/fp16_utils/fp16util.py -> /usr/local/lib/python3.6/dist-packages/apex/fp16_utils\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/fp16_utils/fp16_optimizer.py -> /usr/local/lib/python3.6/dist-packages/apex/fp16_utils\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/fp16_utils/__init__.py -> /usr/local/lib/python3.6/dist-packages/apex/fp16_utils\n", | |
| " copying build/lib.linux-x86_64-3.6/apex/fp16_utils/loss_scaler.py -> /usr/local/lib/python3.6/dist-packages/apex/fp16_utils\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/nvtx/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/nvtx/nvmarker.py to nvmarker.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/conv.py to conv.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/blas.py to blas.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/prof.py to prof.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/softmax.py to softmax.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/recurrentCell.py to recurrentCell.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/misc.py to misc.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/base.py to base.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/embedding.py to embedding.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/usage.py to usage.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/activation.py to activation.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/loss.py to loss.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/optim.py to optim.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/dropout.py to dropout.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/pointwise.py to pointwise.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/data.py to data.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/reduction.py to reduction.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/output.py to output.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/index_slice_join_mutate.py to index_slice_join_mutate.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/pooling.py to pooling.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/__main__.py to __main__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/linear.py to linear.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/utility.py to utility.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/randomSample.py to randomSample.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/convert.py to convert.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/prof/normalization.py to normalization.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/parse/kernel.py to kernel.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/parse/nvvp.py to nvvp.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/parse/parse.py to parse.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/parse/__main__.py to __main__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/parse/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/pyprof/parse/db.py to db.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/groupbn/batch_norm.py to batch_norm.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/groupbn/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/xentropy/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/xentropy/softmax_xentropy.py to softmax_xentropy.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/optimizers/fused_adam.py to fused_adam.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/optimizers/fp16_optimizer.py to fp16_optimizer.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/optimizers/fused_lamb.py to fused_lamb.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/optimizers/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/optimizers/fused_sgd.py to fused_sgd.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn/self_multihead_attn_func.py to self_multihead_attn_func.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn/encdec_multihead_attn.py to encdec_multihead_attn.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn/fast_encdec_multihead_attn_func.py to fast_encdec_multihead_attn_func.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn/fast_self_multihead_attn_norm_add_func.py to fast_self_multihead_attn_norm_add_func.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn/self_multihead_attn.py to self_multihead_attn.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn/fast_self_multihead_attn_func.py to fast_self_multihead_attn_func.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn/encdec_multihead_attn_func.py to encdec_multihead_attn_func.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/multihead_attn/fast_encdec_multihead_attn_norm_add_func.py to fast_encdec_multihead_attn_norm_add_func.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/contrib/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/normalization/fused_layer_norm.py to fused_layer_norm.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/normalization/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/mlp/mlp.py to mlp.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/mlp/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/RNN/models.py to models.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/RNN/RNNBackend.py to RNNBackend.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/RNN/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/RNN/cells.py to cells.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/multi_tensor_apply/multi_tensor_apply.py to multi_tensor_apply.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/multi_tensor_apply/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/optimizers/fused_adam.py to fused_adam.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/optimizers/fused_lamb.py to fused_lamb.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/optimizers/fused_novograd.py to fused_novograd.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/optimizers/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/optimizers/fused_sgd.py to fused_sgd.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/parallel/multiproc.py to multiproc.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/parallel/sync_batchnorm.py to sync_batchnorm.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/parallel/LARC.py to LARC.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/parallel/distributed.py to distributed.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/parallel/optimized_sync_batchnorm.py to optimized_sync_batchnorm.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/parallel/sync_batchnorm_kernel.py to sync_batchnorm_kernel.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/parallel/optimized_sync_batchnorm_kernel.py to optimized_sync_batchnorm_kernel.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/parallel/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/reparameterization/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/reparameterization/reparameterization.py to reparameterization.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/reparameterization/weight_norm.py to weight_norm.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/_process_optimizer.py to _process_optimizer.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/__version__.py to __version__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/compat.py to compat.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/handle.py to handle.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/_initialize.py to _initialize.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/rnn_compat.py to rnn_compat.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/amp.py to amp.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/opt.py to opt.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/utils.py to utils.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/frontend.py to frontend.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/lists/tensor_overrides.py to tensor_overrides.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/lists/functional_overrides.py to functional_overrides.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/lists/torch_overrides.py to torch_overrides.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/lists/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/_amp_state.py to _amp_state.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/wrap.py to wrap.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/amp/scaler.py to scaler.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/fp16_utils/fp16util.py to fp16util.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/fp16_utils/fp16_optimizer.py to fp16_optimizer.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/fp16_utils/__init__.py to __init__.cpython-36.pyc\n", | |
| " byte-compiling /usr/local/lib/python3.6/dist-packages/apex/fp16_utils/loss_scaler.py to loss_scaler.cpython-36.pyc\n", | |
| " running install_egg_info\n", | |
| " running egg_info\n", | |
| " creating apex.egg-info\n", | |
| " writing apex.egg-info/PKG-INFO\n", | |
| " writing dependency_links to apex.egg-info/dependency_links.txt\n", | |
| " writing top-level names to apex.egg-info/top_level.txt\n", | |
| " writing manifest file 'apex.egg-info/SOURCES.txt'\n", | |
| " writing manifest file 'apex.egg-info/SOURCES.txt'\n", | |
| " Copying apex.egg-info to /usr/local/lib/python3.6/dist-packages/apex-0.1-py3.6.egg-info\n", | |
| " running install_scripts\n", | |
| " writing list of installed files to '/tmp/pip-record-mieu_b4r/install-record.txt'\n", | |
| " Running setup.py install for apex ... \u001b[?25l\u001b[?25hdone\n", | |
| " Removing source in /tmp/pip-req-build-0cj84n_w\n", | |
| "Successfully installed apex-0.1\n", | |
| "Cleaning up...\n", | |
| "Removed build tracker '/tmp/pip-req-tracker-g3lyu538'\n" | |
| ], | |
| "name": "stdout" | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "metadata": { | |
| "id": "g4Zs8VBQe8mD", | |
| "colab_type": "code", | |
| "outputId": "978f22bd-c08e-4699-a8ca-539111670be2", | |
| "colab": { | |
| "base_uri": "https://localhost:8080/", | |
| "height": 1000 | |
| } | |
| }, | |
| "source": [ | |
| "%cd /content/\n", | |
| "\n", | |
| "!git clone https://github.com/promach/PyTorch-YOLOv3\n", | |
| "\n", | |
| "%cd /content/PyTorch-YOLOv3/\n", | |
| "\n", | |
| "!git checkout addernet\n", | |
| "!sudo pip3 install -r requirements.txt" | |
| ], | |
| "execution_count": 0, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "text": [ | |
| "/content\n", | |
| "Cloning into 'PyTorch-YOLOv3'...\n", | |
| "remote: Enumerating objects: 742, done.\u001b[K\n", | |
| "remote: Total 742 (delta 0), reused 0 (delta 0), pack-reused 742\u001b[K\n", | |
| "Receiving objects: 100% (742/742), 16.20 MiB | 17.86 MiB/s, done.\n", | |
| "Resolving deltas: 100% (424/424), done.\n", | |
| "/content/PyTorch-YOLOv3\n", | |
| "Branch 'addernet' set up to track remote branch 'addernet' from 'origin'.\n", | |
| "Switched to a new branch 'addernet'\n", | |
| "Requirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from -r requirements.txt (line 1)) (1.18.3)\n", | |
| "Requirement already satisfied: torch>=1.0 in /usr/local/lib/python3.6/dist-packages (from -r requirements.txt (line 2)) (1.4.0)\n", | |
| "Requirement already satisfied: torchvision in /usr/local/lib/python3.6/dist-packages (from -r requirements.txt (line 3)) (0.5.0)\n", | |
| "Requirement already satisfied: matplotlib in /usr/local/lib/python3.6/dist-packages (from -r requirements.txt (line 4)) (3.2.1)\n", | |
| "Requirement already satisfied: tensorflow in /usr/local/lib/python3.6/dist-packages (from -r requirements.txt (line 5)) (2.2.0rc3)\n", | |
| "Requirement already satisfied: tensorboard in /usr/local/lib/python3.6/dist-packages (from -r requirements.txt (line 6)) (2.2.1)\n", | |
| "Collecting terminaltables\n", | |
| " Downloading https://files.pythonhosted.org/packages/9b/c4/4a21174f32f8a7e1104798c445dacdc1d4df86f2f26722767034e4de4bff/terminaltables-3.1.0.tar.gz\n", | |
| "Requirement already satisfied: pillow in /usr/local/lib/python3.6/dist-packages (from -r requirements.txt (line 8)) (7.0.0)\n", | |
| "Requirement already satisfied: tqdm in /usr/local/lib/python3.6/dist-packages (from -r requirements.txt (line 9)) (4.38.0)\n", | |
| "Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from torchvision->-r requirements.txt (line 3)) (1.12.0)\n", | |
| "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->-r requirements.txt (line 4)) (2.4.7)\n", | |
| "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.6/dist-packages (from matplotlib->-r requirements.txt (line 4)) (0.10.0)\n", | |
| "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->-r requirements.txt (line 4)) (2.8.1)\n", | |
| "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.6/dist-packages (from matplotlib->-r requirements.txt (line 4)) (1.2.0)\n", | |
| "Requirement already satisfied: termcolor>=1.1.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (1.1.0)\n", | |
| "Requirement already satisfied: opt-einsum>=2.3.2 in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (3.2.1)\n", | |
| "Requirement already satisfied: wrapt>=1.11.1 in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (1.12.1)\n", | |
| "Requirement already satisfied: grpcio>=1.8.6 in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (1.28.1)\n", | |
| "Requirement already satisfied: google-pasta>=0.1.8 in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (0.2.0)\n", | |
| "Requirement already satisfied: wheel>=0.26; python_version >= \"3\" in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (0.34.2)\n", | |
| "Requirement already satisfied: astunparse==1.6.3 in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (1.6.3)\n", | |
| "Requirement already satisfied: scipy==1.4.1; python_version >= \"3\" in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (1.4.1)\n", | |
| "Requirement already satisfied: absl-py>=0.7.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (0.9.0)\n", | |
| "Requirement already satisfied: protobuf>=3.8.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (3.10.0)\n", | |
| "Requirement already satisfied: tensorflow-estimator<2.3.0,>=2.2.0rc0 in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (2.2.0)\n", | |
| "Requirement already satisfied: h5py<2.11.0,>=2.10.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (2.10.0)\n", | |
| "Requirement already satisfied: keras-preprocessing>=1.1.0 in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (1.1.0)\n", | |
| "Requirement already satisfied: gast==0.3.3 in /usr/local/lib/python3.6/dist-packages (from tensorflow->-r requirements.txt (line 5)) (0.3.3)\n", | |
| "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard->-r requirements.txt (line 6)) (2.21.0)\n", | |
| "Requirement already satisfied: werkzeug>=0.11.15 in /usr/local/lib/python3.6/dist-packages (from tensorboard->-r requirements.txt (line 6)) (1.0.1)\n", | |
| "Requirement already satisfied: setuptools>=41.0.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard->-r requirements.txt (line 6)) (46.1.3)\n", | |
| "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.6/dist-packages (from tensorboard->-r requirements.txt (line 6)) (3.2.1)\n", | |
| "Requirement already satisfied: google-auth<2,>=1.6.3 in /usr/local/lib/python3.6/dist-packages (from tensorboard->-r requirements.txt (line 6)) (1.7.2)\n", | |
| "Requirement already satisfied: google-auth-oauthlib<0.5,>=0.4.1 in /usr/local/lib/python3.6/dist-packages (from tensorboard->-r requirements.txt (line 6)) (0.4.1)\n", | |
| "Requirement already satisfied: tensorboard-plugin-wit>=1.6.0 in /usr/local/lib/python3.6/dist-packages (from tensorboard->-r requirements.txt (line 6)) (1.6.0.post3)\n", | |
| "Requirement already satisfied: urllib3<1.25,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard->-r requirements.txt (line 6)) (1.24.3)\n", | |
| "Requirement already satisfied: chardet<3.1.0,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard->-r requirements.txt (line 6)) (3.0.4)\n", | |
| "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard->-r requirements.txt (line 6)) (2020.4.5.1)\n", | |
| "Requirement already satisfied: idna<2.9,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests<3,>=2.21.0->tensorboard->-r requirements.txt (line 6)) (2.8)\n", | |
| "Requirement already satisfied: rsa<4.1,>=3.1.4 in /usr/local/lib/python3.6/dist-packages (from google-auth<2,>=1.6.3->tensorboard->-r requirements.txt (line 6)) (4.0)\n", | |
| "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.6/dist-packages (from google-auth<2,>=1.6.3->tensorboard->-r requirements.txt (line 6)) (0.2.8)\n", | |
| "Requirement already satisfied: cachetools<3.2,>=2.0.0 in /usr/local/lib/python3.6/dist-packages (from google-auth<2,>=1.6.3->tensorboard->-r requirements.txt (line 6)) (3.1.1)\n", | |
| "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.6/dist-packages (from google-auth-oauthlib<0.5,>=0.4.1->tensorboard->-r requirements.txt (line 6)) (1.3.0)\n", | |
| "Requirement already satisfied: pyasn1>=0.1.3 in /usr/local/lib/python3.6/dist-packages (from rsa<4.1,>=3.1.4->google-auth<2,>=1.6.3->tensorboard->-r requirements.txt (line 6)) (0.4.8)\n", | |
| "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.6/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<0.5,>=0.4.1->tensorboard->-r requirements.txt (line 6)) (3.1.0)\n", | |
| "Building wheels for collected packages: terminaltables\n", | |
| " Building wheel for terminaltables (setup.py) ... \u001b[?25l\u001b[?25hdone\n", | |
| " Created wheel for terminaltables: filename=terminaltables-3.1.0-cp36-none-any.whl size=15356 sha256=63bf5fffc6534a2b661d02bbf1ff151de5c8e803c366502515ce12d18fea662f\n", | |
| " Stored in directory: /root/.cache/pip/wheels/30/6b/50/6c75775b681fb36cdfac7f19799888ef9d8813aff9e379663e\n", | |
| "Successfully built terminaltables\n", | |
| "Installing collected packages: terminaltables\n", | |
| "Successfully installed terminaltables-3.1.0\n" | |
| ], | |
| "name": "stdout" | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "metadata": { | |
| "id": "1DCdNEvzO3gf", | |
| "colab_type": "code", | |
| "outputId": "3a6941d2-a803-438d-9f93-29f56bd9bc6d", | |
| "colab": { | |
| "base_uri": "https://localhost:8080/", | |
| "height": 384 | |
| } | |
| }, | |
| "source": [ | |
| "!nvidia-smi\n", | |
| "\n", | |
| "!python3 -c \"import torch; print(torch.__version__)\"\n", | |
| "!python3 -c 'import tensorflow as tf; print(tf.__version__)'" | |
| ], | |
| "execution_count": 0, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "text": [ | |
| "Sun Apr 26 16:15:15 2020 \n", | |
| "+-----------------------------------------------------------------------------+\n", | |
| "| NVIDIA-SMI 440.64.00 Driver Version: 418.67 CUDA Version: 10.1 |\n", | |
| "|-------------------------------+----------------------+----------------------+\n", | |
| "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n", | |
| "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n", | |
| "|===============================+======================+======================|\n", | |
| "| 0 Tesla K80 Off | 00000000:00:04.0 Off | 0 |\n", | |
| "| N/A 49C P8 31W / 149W | 0MiB / 11441MiB | 0% Default |\n", | |
| "+-------------------------------+----------------------+----------------------+\n", | |
| " \n", | |
| "+-----------------------------------------------------------------------------+\n", | |
| "| Processes: GPU Memory |\n", | |
| "| GPU PID Type Process name Usage |\n", | |
| "|=============================================================================|\n", | |
| "| No running processes found |\n", | |
| "+-----------------------------------------------------------------------------+\n", | |
| "1.4.0\n", | |
| "2020-04-26 16:15:21.796379: I tensorflow/stream_executor/platform/default/dso_loader.cc:44] Successfully opened dynamic library libcudart.so.10.1\n", | |
| "2.2.0-rc3\n" | |
| ], | |
| "name": "stdout" | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "metadata": { | |
| "id": "P2CiGdNuIZ8a", | |
| "colab_type": "code", | |
| "outputId": "11e60130-240b-4bf5-9a62-ea71470413cc", | |
| "colab": { | |
| "base_uri": "https://localhost:8080/", | |
| "height": 34 | |
| } | |
| }, | |
| "source": [ | |
| "%cd /content/PyTorch-YOLOv3/config/\n", | |
| "\n", | |
| "!bash create_custom_model.sh 20" | |
| ], | |
| "execution_count": 0, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "text": [ | |
| "/content/PyTorch-YOLOv3/config\n" | |
| ], | |
| "name": "stdout" | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "metadata": { | |
| "id": "hDRJ3JfqnDJu", | |
| "colab_type": "code", | |
| "outputId": "1c63ee60-fa47-41c0-8e31-842c5f86264b", | |
| "colab": { | |
| "base_uri": "https://localhost:8080/", | |
| "height": 627 | |
| } | |
| }, | |
| "source": [ | |
| "%cd /content/PyTorch-YOLOv3/data/\n", | |
| "\n", | |
| "!wget http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtrainval_06-Nov-2007.tar\n", | |
| "!wget http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtest_06-Nov-2007.tar\n", | |
| "\n", | |
| "!tar -xf VOCtest_06-Nov-2007.tar\n", | |
| "!tar -xf VOCtrainval_06-Nov-2007.tar\n", | |
| "\n", | |
| "!ls -al" | |
| ], | |
| "execution_count": 0, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "text": [ | |
| "/content/PyTorch-YOLOv3/data\n", | |
| "--2020-04-26 16:15:28-- http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtrainval_06-Nov-2007.tar\n", | |
| "Resolving host.robots.ox.ac.uk (host.robots.ox.ac.uk)... 129.67.94.152\n", | |
| "Connecting to host.robots.ox.ac.uk (host.robots.ox.ac.uk)|129.67.94.152|:80... connected.\n", | |
| "HTTP request sent, awaiting response... 200 OK\n", | |
| "Length: 460032000 (439M) [application/x-tar]\n", | |
| "Saving to: ‘VOCtrainval_06-Nov-2007.tar’\n", | |
| "\n", | |
| "VOCtrainval_06-Nov- 100%[===================>] 438.72M 9.14MB/s in 51s \n", | |
| "\n", | |
| "2020-04-26 16:16:20 (8.61 MB/s) - ‘VOCtrainval_06-Nov-2007.tar’ saved [460032000/460032000]\n", | |
| "\n", | |
| "--2020-04-26 16:16:30-- http://host.robots.ox.ac.uk/pascal/VOC/voc2007/VOCtest_06-Nov-2007.tar\n", | |
| "Resolving host.robots.ox.ac.uk (host.robots.ox.ac.uk)... 129.67.94.152\n", | |
| "Connecting to host.robots.ox.ac.uk (host.robots.ox.ac.uk)|129.67.94.152|:80... connected.\n", | |
| "HTTP request sent, awaiting response... 200 OK\n", | |
| "Length: 451020800 (430M) [application/x-tar]\n", | |
| "Saving to: ‘VOCtest_06-Nov-2007.tar’\n", | |
| "\n", | |
| "VOCtest_06-Nov-2007 100%[===================>] 430.13M 8.80MB/s in 51s \n", | |
| "\n", | |
| "2020-04-26 16:17:21 (8.47 MB/s) - ‘VOCtest_06-Nov-2007.tar’ saved [451020800/451020800]\n", | |
| "\n", | |
| "total 889740\n", | |
| "drwxr-xr-x 5 root root 4096 Apr 26 16:17 .\n", | |
| "drwxr-xr-x 8 root root 4096 Apr 26 16:15 ..\n", | |
| "-rw-r--r-- 1 root root 625 Apr 26 16:15 coco.names\n", | |
| "drwxr-xr-x 4 root root 4096 Apr 26 16:15 custom\n", | |
| "-rw-r--r-- 1 root root 898 Apr 26 16:15 get_coco_dataset.sh\n", | |
| "drwxr-xr-x 2 root root 4096 Apr 26 16:15 samples\n", | |
| "drwxrwxrwx 3 root root 4096 Nov 6 2007 VOCdevkit\n", | |
| "-rw-r--r-- 1 root root 2241 Apr 26 16:15 voc_label.py\n", | |
| "-rw-r--r-- 1 root root 451020800 Jan 1 2019 VOCtest_06-Nov-2007.tar\n", | |
| "-rw-r--r-- 1 root root 460032000 Jan 1 2019 VOCtrainval_06-Nov-2007.tar\n" | |
| ], | |
| "name": "stdout" | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "metadata": { | |
| "id": "MI1IU-2hKDp_", | |
| "colab_type": "code", | |
| "outputId": "072b84e0-59ac-4034-b35f-bb394db6a413", | |
| "colab": { | |
| "base_uri": "https://localhost:8080/", | |
| "height": 245 | |
| } | |
| }, | |
| "source": [ | |
| "%cd /content/PyTorch-YOLOv3/data/\n", | |
| "\n", | |
| "!rm voc_label.py\n", | |
| "!wget https://gist.githubusercontent.com/promach/8ddd9794f242c24ffdaa612bcb0bfa33/raw/ec1915e4f2958ed8d6df4cb394852f6f894b22f6/voc_label.py\n", | |
| "\n", | |
| "!python3 voc_label.py\n", | |
| "\n", | |
| "!mv train.txt /content/PyTorch-YOLOv3/data/custom\n", | |
| "!cp /content/PyTorch-YOLOv3/data/2007_val.txt /content/PyTorch-YOLOv3/data/custom/valid.txt" | |
| ], | |
| "execution_count": 0, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "text": [ | |
| "/content/PyTorch-YOLOv3/data\n", | |
| "--2020-04-26 16:18:32-- https://gist.githubusercontent.com/promach/8ddd9794f242c24ffdaa612bcb0bfa33/raw/ec1915e4f2958ed8d6df4cb394852f6f894b22f6/voc_label.py\n", | |
| "Resolving gist.githubusercontent.com (gist.githubusercontent.com)... 151.101.0.133, 151.101.64.133, 151.101.128.133, ...\n", | |
| "Connecting to gist.githubusercontent.com (gist.githubusercontent.com)|151.101.0.133|:443... connected.\n", | |
| "HTTP request sent, awaiting response... 200 OK\n", | |
| "Length: 2149 (2.1K) [text/plain]\n", | |
| "Saving to: ‘voc_label.py’\n", | |
| "\n", | |
| "voc_label.py 100%[===================>] 2.10K --.-KB/s in 0s \n", | |
| "\n", | |
| "2020-04-26 16:18:32 (20.4 MB/s) - ‘voc_label.py’ saved [2149/2149]\n", | |
| "\n" | |
| ], | |
| "name": "stdout" | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "metadata": { | |
| "id": "ybfyzuPKXhOA", | |
| "colab_type": "code", | |
| "colab": {} | |
| }, | |
| "source": [ | |
| "!rm -rf /content/PyTorch-YOLOv3/data/custom/labels\n", | |
| "!ln -s /content/PyTorch-YOLOv3/data/VOCdevkit/VOC2007/labels /content/PyTorch-YOLOv3/data/custom/labels\n", | |
| "\n", | |
| "!rm -rf /content/PyTorch-YOLOv3/data/custom/images\n", | |
| "!ln -s /content/PyTorch-YOLOv3/data/VOCdevkit/VOC2007/JPEGImages /content/PyTorch-YOLOv3/data/custom/images" | |
| ], | |
| "execution_count": 0, | |
| "outputs": [] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "metadata": { | |
| "id": "drY7fclPGWCZ", | |
| "colab_type": "code", | |
| "outputId": "1b0d0b35-bc30-4d02-de8b-fafeb311a691", | |
| "colab": { | |
| "base_uri": "https://localhost:8080/", | |
| "height": 1000 | |
| } | |
| }, | |
| "source": [ | |
| "%cd /content/PyTorch-YOLOv3\n", | |
| "\n", | |
| "!rm train.py\n", | |
| "!wget https://gist.githubusercontent.com/promach/8ddd9794f242c24ffdaa612bcb0bfa33/raw/6b3c8e1f5ec9c682cc9db5ae0fe20ce4fb1327a4/train_using_apex.py -O train.py\n", | |
| "!python3 train.py --model_def config/yolov3-custom.cfg --data_config config/custom.data" | |
| ], | |
| "execution_count": 0, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "text": [ | |
| "\u001b[1;30;43mStreaming output truncated to the last 5000 lines.\u001b[0m\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 2669937.25\n", | |
| "---- ETA 16:59:03.435909\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(44.3405, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(88.6810, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(9.0510, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(5.8788, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 0.015625\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 21/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 1314210.125000 | 332894.343750 | 84593.257812 |\n", | |
| "| x | 0.365700 | 0.396134 | 0.264534 |\n", | |
| "| y | 0.301267 | 0.171734 | 0.333601 |\n", | |
| "| w | 617060.125000 | 168005.234375 | 37889.949219 |\n", | |
| "| h | 694360.000000 | 162099.187500 | 43913.355469 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249470 | 26.249470 | 26.249470 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1731697.75\n", | |
| "---- ETA 16:55:01.030213\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(44.3405, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(88.6810, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(9.0510, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 22/2506] ----\n", | |
| "+------------+----------------+---------------+----------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+----------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 1279190.125000 | 687262.375000 | 1878227.375000 |\n", | |
| "| x | 0.562275 | 0.579100 | 0.836399 |\n", | |
| "| y | 0.480150 | 0.400600 | 0.482399 |\n", | |
| "| w | 640947.125000 | 356097.718750 | 943188.375000 |\n", | |
| "| h | 635452.500000 | 328374.312500 | 932248.375000 |\n", | |
| "| conf | 2763.102295 | 2763.102051 | 2763.101807 |\n", | |
| "| cls | 26.249470 | 26.249470 | 26.249470 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+----------------+\n", | |
| "Total loss 3844680.0\n", | |
| "---- ETA 16:51:14.668318\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(44.3405, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(88.6810, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(9.0510, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(5.8788, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 0.00390625\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 23/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 2713162.750000 | 333436.718750 | 85473.406250 |\n", | |
| "| x | 0.389737 | 0.398946 | 0.455508 |\n", | |
| "| y | 0.416936 | 0.402291 | 0.253292 |\n", | |
| "| w | 1322899.625000 | 176294.843750 | 38197.777344 |\n", | |
| "| h | 1387473.375000 | 154352.000000 | 44485.570312 |\n", | |
| "| conf | 2763.102539 | 2763.102539 | 2763.102051 |\n", | |
| "| cls | 25.998280 | 25.998280 | 26.249470 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 3132073.0\n", | |
| "---- ETA 16:47:45.489503\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(44.3405, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(88.6810, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(9.0510, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(5.8788, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 24/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 1310942.125000 | 332823.281250 | 85462.726562 |\n", | |
| "| x | 0.238460 | 0.417840 | 0.423359 |\n", | |
| "| y | 0.296200 | 0.340800 | 0.387200 |\n", | |
| "| w | 621029.000000 | 176258.296875 | 38129.828125 |\n", | |
| "| h | 687123.187500 | 153774.890625 | 44542.738281 |\n", | |
| "| conf | 2763.102539 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249468 | 26.249468 | 26.249468 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1729228.125\n", | |
| "---- ETA 16:44:32.856522\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(44.3405, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(88.6810, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(9.0510, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(5.8788, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 0.0009765625\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 25/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 1302875.875000 | 331433.093750 | 85540.679688 |\n", | |
| "| x | 0.603640 | 0.593200 | 0.359467 |\n", | |
| "| y | 0.363240 | 0.445800 | 0.396533 |\n", | |
| "| w | 623274.687500 | 176538.093750 | 37608.570312 |\n", | |
| "| h | 676811.125000 | 152104.625000 | 45142.000000 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 25.973162 | 26.249470 | 26.249470 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1719849.625\n", | |
| "---- ETA 16:41:32.191961\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(88.6810, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8154, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(9.0510, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(5.8788, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 26/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 2191150.000000 | 334822.531250 | 85468.492188 |\n", | |
| "| x | 0.411850 | 0.320000 | 0.480000 |\n", | |
| "| y | 0.314433 | 0.230971 | 0.535314 |\n", | |
| "| w | 1072250.000000 | 173042.500000 | 38380.226562 |\n", | |
| "| h | 1116110.000000 | 158990.156250 | 44297.894531 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249470 | 26.249470 | 26.249468 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 2611441.0\n", | |
| "---- ETA 16:38:43.159290\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(88.6810, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8154, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(9.0510, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(5.8788, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 0.000244140625\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 27/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 1347592.875000 | 332446.093750 | 85401.992188 |\n", | |
| "| x | 0.446100 | 0.416520 | 0.362081 |\n", | |
| "| y | 0.219533 | 0.459480 | 0.425920 |\n", | |
| "| w | 639567.125000 | 174986.578125 | 38302.781250 |\n", | |
| "| h | 705235.812500 | 154669.281250 | 44309.074219 |\n", | |
| "| conf | 2763.102539 | 2763.102539 | 2763.102051 |\n", | |
| "| cls | 26.095964 | 26.249470 | 26.249470 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1765441.0\n", | |
| "---- ETA 16:36:14.322552\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(44.3405, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(88.6810, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4465, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(9.0510, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(5.8788, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 28/2506] ----\n", | |
| "+------------+----------------+---------------+---------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+---------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 2735530.750000 | 735616.687500 | 458560.406250 |\n", | |
| "| x | 0.284178 | 0.478933 | 0.404622 |\n", | |
| "| y | 0.512945 | 0.518445 | 0.491556 |\n", | |
| "| w | 1352326.625000 | 377337.156250 | 227252.312500 |\n", | |
| "| h | 1380414.000000 | 355489.156250 | 228517.875000 |\n", | |
| "| conf | 2763.102539 | 2763.102539 | 2763.102051 |\n", | |
| "| cls | 26.249468 | 26.249468 | 26.249468 |\n", | |
| "| cls_acc | 11.11% | 11.11% | 11.11% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+---------------+\n", | |
| "Total loss 3929708.0\n", | |
| "---- ETA 16:33:47.333279\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 6.103515625e-05\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 29/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 1312635.625000 | 336043.406250 | 84596.710938 |\n", | |
| "| x | 0.241900 | 0.394267 | 0.513067 |\n", | |
| "| y | 0.384807 | 0.325894 | 0.346241 |\n", | |
| "| w | 621143.312500 | 175399.703125 | 38957.902344 |\n", | |
| "| h | 688702.250000 | 157853.625000 | 42848.601562 |\n", | |
| "| conf | 2763.102539 | 2763.102295 | 2763.101807 |\n", | |
| "| cls | 26.249470 | 26.249470 | 26.249470 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1733275.75\n", | |
| "---- ETA 16:31:19.229688\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(88.6810, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(9.0510, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(5.8788, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 30/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 12 | 24 | 48 |\n", | |
| "| loss | 1849925.375000 | 328940.968750 | 84526.429688 |\n", | |
| "| x | 0.283637 | 0.062549 | 0.250197 |\n", | |
| "| y | 0.082245 | 0.328982 | 0.326593 |\n", | |
| "| w | 938947.625000 | 180284.343750 | 37126.125000 |\n", | |
| "| h | 908188.000000 | 145866.875000 | 44610.375000 |\n", | |
| "| conf | 2763.102051 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 2263392.75\n", | |
| "---- ETA 16:40:30.480148\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(88.6810, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4078, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(18.1019, device='cuda:0')\n", | |
| "after norm: tensor(54.3058, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(9.0510, device='cuda:0')\n", | |
| "after norm: tensor(27.1529, device='cuda:0')\n", | |
| "after norm: tensor(5.8788, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 1.52587890625e-05\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 31/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 12 | 24 | 48 |\n", | |
| "| loss | 6038854.500000 | 327135.343750 | 84872.109375 |\n", | |
| "| x | 0.567099 | 0.329728 | 0.150911 |\n", | |
| "| y | 0.103285 | 0.005141 | 0.020565 |\n", | |
| "| w | 3008203.750000 | 172108.156250 | 37177.308594 |\n", | |
| "| h | 3027861.000000 | 152237.531250 | 44905.277344 |\n", | |
| "| conf | 2763.102051 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 6450862.0\n", | |
| "---- ETA 16:48:32.758190\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 32/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 12 | 24 | 48 |\n", | |
| "| loss | 1273040.250000 | 325496.781250 | 84854.507812 |\n", | |
| "| x | 0.299699 | 0.395597 | 0.319987 |\n", | |
| "| y | 0.256595 | 0.360781 | 0.441524 |\n", | |
| "| w | 642388.625000 | 178562.343750 | 37249.207031 |\n", | |
| "| h | 627861.687500 | 144144.359375 | 44815.191406 |\n", | |
| "| conf | 2763.102051 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249470 | 26.249470 | 26.249470 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1683391.5\n", | |
| "---- ETA 16:56:04.381727\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(36.2039, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(72.4077, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 3.814697265625e-06\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 33/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 12 | 24 | 48 |\n", | |
| "| loss | 1263741.375000 | 325384.656250 | 84812.492188 |\n", | |
| "| x | 0.045200 | 0.180800 | 0.215200 |\n", | |
| "| y | 0.521384 | 0.197536 | 0.790143 |\n", | |
| "| w | 648792.187500 | 178337.453125 | 37150.492188 |\n", | |
| "| h | 612159.250000 | 144257.468750 | 44871.648438 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1673938.5\n", | |
| "---- ETA 17:03:10.056257\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 34/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 12 | 24 | 48 |\n", | |
| "| loss | 1311132.500000 | 331294.656250 | 85576.117188 |\n", | |
| "| x | 0.346022 | 0.397166 | 0.336220 |\n", | |
| "| y | 0.289287 | 0.286962 | 0.239847 |\n", | |
| "| w | 619075.750000 | 175295.171875 | 37862.515625 |\n", | |
| "| h | 689266.750000 | 153209.437500 | 44923.679688 |\n", | |
| "| conf | 2763.102295 | 2763.102051 | 2763.102051 |\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1728003.25\n", | |
| "---- ETA 17:09:48.487258\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(144.8155, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 9.5367431640625e-07\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 35/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 12 | 24 | 48 |\n", | |
| "| loss | 1280190.125000 | 328215.468750 | 85082.101562 |\n", | |
| "| x | 0.286124 | 0.188496 | 0.315983 |\n", | |
| "| y | 0.432652 | 0.394608 | 0.406432 |\n", | |
| "| w | 641714.375000 | 177545.437500 | 37417.800781 |\n", | |
| "| h | 635685.625000 | 147880.125000 | 44874.226562 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249470 | 26.249470 | 26.249470 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1693487.75\n", | |
| "---- ETA 17:16:05.624982\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(108.6116, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(217.2232, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(434.4464, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 36/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 12 | 24 | 48 |\n", | |
| "| loss | 1263927.875000 | 325591.500000 | 84882.898438 |\n", | |
| "| x | 0.495720 | 0.538880 | 0.767521 |\n", | |
| "| y | 0.320616 | 0.390464 | 0.477856 |\n", | |
| "| w | 649443.375000 | 178701.734375 | 37309.187500 |\n", | |
| "| h | 611694.375000 | 144099.500000 | 44783.117188 |\n", | |
| "| conf | 2763.102051 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1674402.25\n", | |
| "---- ETA 17:21:59.915799\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 2.384185791015625e-07\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 37/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 12 | 24 | 48 |\n", | |
| "| loss | 1274118.375000 | 325606.875000 | 84885.867188 |\n", | |
| "| x | 0.330088 | 0.394566 | 0.277360 |\n", | |
| "| y | 0.370929 | 0.353452 | 0.504473 |\n", | |
| "| w | 644119.375000 | 178844.468750 | 37370.320312 |\n", | |
| "| h | 627208.937500 | 143972.312500 | 44725.417969 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249470 | 26.249470 | 26.249470 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1684611.125\n", | |
| "---- ETA 17:27:25.191112\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 38/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 12 | 24 | 48 |\n", | |
| "| loss | 1289659.375000 | 328678.718750 | 85301.039062 |\n", | |
| "| x | 0.498440 | 0.581760 | 0.351040 |\n", | |
| "| y | 0.439304 | 0.473216 | 0.172865 |\n", | |
| "| w | 633286.125000 | 169266.000000 | 37365.664062 |\n", | |
| "| h | 653583.000000 | 156622.312500 | 45145.500000 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1703639.125\n", | |
| "---- ETA 17:32:35.761913\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 5.960464477539063e-08\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 39/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 12 | 24 | 48 |\n", | |
| "| loss | 1304078.500000 | 331137.937500 | 85389.062500 |\n", | |
| "| x | 0.661781 | 0.585121 | 0.466481 |\n", | |
| "| y | 0.579088 | 0.446352 | 0.295407 |\n", | |
| "| w | 624800.750000 | 176307.968750 | 37500.359375 |\n", | |
| "| h | 676487.125000 | 152039.593750 | 45098.589844 |\n", | |
| "| conf | 2763.102051 | 2763.102051 | 2763.102051 |\n", | |
| "| cls | 26.249470 | 26.249470 | 26.249470 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1720605.5\n", | |
| "---- ETA 17:37:34.042359\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 40/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 1294857.875000 | 326911.687500 | 85171.242188 |\n", | |
| "| x | 0.349867 | 0.272800 | 0.257866 |\n", | |
| "| y | 0.352383 | 0.296200 | 0.451465 |\n", | |
| "| w | 626614.062500 | 175694.562500 | 37397.320312 |\n", | |
| "| h | 665453.812500 | 148427.218750 | 44983.855469 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1706940.75\n", | |
| "---- ETA 17:33:55.006795\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 1.4901161193847656e-08\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 41/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 1297826.375000 | 331753.218750 | 85697.351562 |\n", | |
| "| x | 0.320667 | 0.336000 | 0.450667 |\n", | |
| "| y | 0.488267 | 0.233067 | 0.198933 |\n", | |
| "| w | 627264.125000 | 170955.421875 | 37528.355469 |\n", | |
| "| h | 667772.125000 | 158007.875000 | 45378.992188 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.101807 |\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1715277.0\n", | |
| "---- ETA 17:30:33.908618\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 42/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 1298281.625000 | 330226.593750 | 83514.257812 |\n", | |
| "| x | 0.279033 | 0.369467 | 0.277867 |\n", | |
| "| y | 0.394333 | 0.670666 | 0.429333 |\n", | |
| "| w | 628412.500000 | 177545.718750 | 37737.179688 |\n", | |
| "| h | 667079.125000 | 149890.484375 | 42987.023438 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1712022.5\n", | |
| "---- ETA 17:27:22.238279\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 3.725290298461914e-09\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 43/2506] ----\n", | |
| "+------------+----------------+----------------+---------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+----------------+---------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 9221770.000000 | 2574541.250000 | 119947.351562 |\n", | |
| "| x | 0.336650 | 0.266600 | 0.406400 |\n", | |
| "| y | 0.474450 | 0.397800 | 0.471200 |\n", | |
| "| w | 4578816.500000 | 1291927.625000 | 57024.882812 |\n", | |
| "| h | 4640163.500000 | 1279823.875000 | 60132.238281 |\n", | |
| "| conf | 2763.102295 | 2763.102539 | 2763.101807 |\n", | |
| "| cls | 26.249470 | 26.249470 | 26.249470 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+----------------+---------------+\n", | |
| "Total loss 11916258.0\n", | |
| "---- ETA 17:24:14.119284\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 44/2506] ----\n", | |
| "+------------+-----------------+-----------------+----------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+-----------------+-----------------+----------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 24683324.000000 | 19409498.000000 | 9002498.000000 |\n", | |
| "| x | 0.110067 | 0.440267 | 0.761066 |\n", | |
| "| y | 0.449633 | 0.278533 | 0.074133 |\n", | |
| "| w | 12322758.000000 | 9715872.000000 | 4518256.000000 |\n", | |
| "| h | 12357775.000000 | 9690835.000000 | 4481452.000000 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+-----------------+-----------------+----------------+\n", | |
| "Total loss 53095320.0\n", | |
| "---- ETA 17:21:16.765526\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 9.313225746154785e-10\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 45/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 1296184.125000 | 332803.250000 | 85481.867188 |\n", | |
| "| x | 0.505500 | 0.368667 | 0.168000 |\n", | |
| "| y | 0.061200 | 0.244800 | 0.259201 |\n", | |
| "| w | 627457.750000 | 175529.281250 | 37558.371094 |\n", | |
| "| h | 665936.500000 | 154484.015625 | 45133.718750 |\n", | |
| "| conf | 2763.102295 | 2763.102051 | 2763.102051 |\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1714469.25\n", | |
| "---- ETA 17:18:24.874063\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 46/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 1296381.625000 | 326171.531250 | 85210.398438 |\n", | |
| "| x | 0.351567 | 0.206267 | 0.171734 |\n", | |
| "| y | 0.348167 | 0.312667 | 0.130667 |\n", | |
| "| w | 627488.187500 | 178890.000000 | 37405.796875 |\n", | |
| "| h | 666103.312500 | 144491.687500 | 45014.949219 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1707763.5\n", | |
| "---- ETA 17:15:40.461917\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 2.3283064365386963e-10\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 47/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 1350743.750000 | 329000.343750 | 85318.101562 |\n", | |
| "| x | 0.410250 | 0.336000 | 0.339000 |\n", | |
| "| y | 0.489613 | 0.403450 | 0.483800 |\n", | |
| "| w | 647982.000000 | 173893.375000 | 37773.007812 |\n", | |
| "| h | 699971.500000 | 152316.890625 | 44754.914062 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249470 | 26.249470 | 26.249470 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 1765062.25\n", | |
| "---- ETA 17:13:01.046673\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 48/2506] ----\n", | |
| "+------------+----------------+---------------+---------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+---------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 1313528.500000 | 335148.718750 | 171856.859375 |\n", | |
| "| x | 0.279230 | 0.263057 | 0.309371 |\n", | |
| "| y | 0.551260 | 0.374486 | 0.363657 |\n", | |
| "| w | 617568.125000 | 174198.937500 | 82985.703125 |\n", | |
| "| h | 693170.312500 | 158159.796875 | 86081.125000 |\n", | |
| "| conf | 2763.102539 | 2763.102295 | 2763.101807 |\n", | |
| "| cls | 26.111317 | 26.249470 | 26.249470 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+---------------+\n", | |
| "Total loss 1820534.125\n", | |
| "---- ETA 17:10:28.112011\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(39.1918, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(55.4256, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "after norm: tensor(nan, device='cuda:0')\n", | |
| "Gradient overflow. Skipping step, loss scaler 0 reducing loss scale to 5.820766091346741e-11\n", | |
| "\n", | |
| "---- [Epoch 0/100, Batch 49/2506] ----\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| Metrics | YOLO Layer 0 | YOLO Layer 1 | YOLO Layer 2 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "| grid_size | 10 | 20 | 40 |\n", | |
| "| loss | 3252319.250000 | 325892.531250 | 85099.648438 |\n", | |
| "| x | 0.377000 | 0.288000 | 0.212000 |\n", | |
| "| y | 0.080050 | 0.320199 | 0.180799 |\n", | |
| "| w | 1599078.750000 | 178528.562500 | 37237.917969 |\n", | |
| "| h | 1650450.875000 | 144574.000000 | 45071.984375 |\n", | |
| "| conf | 2763.102295 | 2763.102295 | 2763.102051 |\n", | |
| "| cls | 26.249472 | 26.249472 | 26.249472 |\n", | |
| "| cls_acc | 0.00% | 0.00% | 0.00% |\n", | |
| "| recall50 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| recall75 | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| precision | 0.000000 | 0.000000 | 0.000000 |\n", | |
| "| conf_obj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "| conf_noobj | 1.000000 | 1.000000 | 1.000000 |\n", | |
| "+------------+----------------+---------------+--------------+\n", | |
| "Total loss 3663311.5\n", | |
| "---- ETA 17:07:57.524339\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "/pytorch/aten/src/ATen/native/IndexingUtils.h:20: UserWarning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead.\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "Warning: indexing with dtype torch.uint8 is now deprecated, please use a dtype torch.bool instead. (expandTensors at /pytorch/aten/src/ATen/native/IndexingUtils.h:20)\n", | |
| "after norm: tensor(27.7128, device='cuda:0')\n", | |
| "Traceback (most recent call last):\n", | |
| " File \"train.py\", line 112, in <module>\n", | |
| " scaled_loss.backward()\n", | |
| " File \"/usr/local/lib/python3.6/dist-packages/torch/tensor.py\", line 195, in backward\n", | |
| " torch.autograd.backward(self, gradient, retain_graph, create_graph)\n", | |
| " File \"/usr/local/lib/python3.6/dist-packages/torch/autograd/__init__.py\", line 99, in backward\n", | |
| " allow_unreachable=True) # allow_unreachable flag\n", | |
| " File \"/usr/local/lib/python3.6/dist-packages/torch/autograd/function.py\", line 77, in apply\n", | |
| " return self._forward_cls.backward(self, *args)\n", | |
| " File \"/content/PyTorch-YOLOv3/adder.py\", line 31, in backward\n", | |
| " _temp = torch.cdist(_temp1, _temp2, p).squeeze().transpose(0, 1)\n", | |
| " File \"/usr/local/lib/python3.6/dist-packages/torch/functional.py\", line 671, in cdist\n", | |
| " return torch._C._VariableFunctions.cdist(x1, x2, p, None)\n", | |
| "RuntimeError: CUDA out of memory. Tried to allocate 5.94 GiB (GPU 0; 11.17 GiB total capacity; 2.03 GiB already allocated; 5.75 GiB free; 5.05 GiB reserved in total by PyTorch)\n" | |
| ], | |
| "name": "stdout" | |
| } | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "metadata": { | |
| "id": "W3e-WcVxnKfs", | |
| "colab_type": "code", | |
| "outputId": "d4d6815c-9339-44ba-bbdb-66c496fe8c18", | |
| "colab": { | |
| "base_uri": "https://localhost:8080/", | |
| "height": 159 | |
| } | |
| }, | |
| "source": [ | |
| "!python3 test.py --weights_path weights/yolov3.weights" | |
| ], | |
| "execution_count": 0, | |
| "outputs": [ | |
| { | |
| "output_type": "stream", | |
| "text": [ | |
| "Namespace(batch_size=2, class_path='data/coco.names', conf_thres=0.001, data_config='config/coco.data', img_size=416, iou_thres=0.5, model_def='config/yolov3.cfg', n_cpu=8, nms_thres=0.5, weights_path='weights/yolov3.weights')\n", | |
| "Traceback (most recent call last):\n", | |
| " File \"test.py\", line 84, in <module>\n", | |
| " model.load_darknet_weights(opt.weights_path)\n", | |
| " File \"/content/PyTorch-YOLOv3/models.py\", line 277, in load_darknet_weights\n", | |
| " with open(weights_path, \"rb\") as f:\n", | |
| "FileNotFoundError: [Errno 2] No such file or directory: 'weights/yolov3.weights'\n" | |
| ], | |
| "name": "stdout" | |
| } | |
| ] | |
| } | |
| ] | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Hi thanks for your code. I have encountered the following issues when running your addernet
cdist only supports 2D tensors, X1 got: 3D
File "~/AdderNet/adder.py", line 33, in backward
_temp = torch.cdist(_temp1, _temp2, p).squeeze().transpose(0, 1)
after operation
_temp1 = torch.unsqueeze(X, 2).expand(X.shape[0], X.shape[1], W.shape[0]).permute(1, 0, 2)
_temp2 = torch.unsqueeze(W.transpose(0, 1), 1)
_temp1 and _temp2 both should be 3D tensor. Do you have any idea about the issue? Thans