• Welcome to the world's largest Chinese hacker forum

    Welcome to the world's largest Chinese hacker forum, our forum registration is open! You can now register for technical communication with us, this is a free and open to the world of the BBS, we founded the purpose for the study of network security, please don't release business of black/grey, or on the BBS posts, to seek help hacker if violations, we will permanently frozen your IP and account, thank you for your cooperation. Hacker attack and defense cracking or network Security

    business please click here: Creation Security  From CNHACKTEAM

Recommended Posts

先G后D

训练g:

——S:pred1,pred2=模型(图片);loss_seg1=loss_calc(pred1,labels);损失。backward();

——T:预测目标1,预测目标2=模型(图像);D_out1=模型_ D1(f . soft max(pred _ target 1));loss _ adv _ target 1=BCE _ loss(D _ out 1,(source_label))。损失。backward();

训练d:

——S:pred 1=pred1。detach();D_out1=模型_ D1(f . soft max(pred 1));loss_D1=bce_loss(D_out1,(source_label)).损失_ D1。backward();source_label=0

——吨:预解码_目标1=预解码_目标1。detach();D_out1=模型_ D1(f . soft max(pred _ target 1));损失_ D1=BCE _损失(D_out1,(目标_标签));损失_ D1。backward();target_label=1

注意: nn.BCELoss(F.sigmoid(input), target),所以,这里的input=D_out1,相当于将概率值得分经过了sigmoid转变成标签,再去和0或者1比较,做一个二分类

optimizer_D1.step()optimizer_D2.step()

打印(' exp={} ' .format(args.snapshot_dir))

print(' ITER={ 0:8d }/{ 1:8d },loss _ seg 1={ 2:3 f } loss _ seg 2={ 3:3 f } loss _ adv 1={ 4:3 f },loss _ adv 2={ 5:3 f } loss _ D1={ 6:3 f } loss _ D2={ 733:3 f }).格式(

i_iter,args.num_steps,损失分段值1,损失分段值2,损失高级目标值1

损失_高级_目标_价值2,损失_ D _价值1,损失_ D _价值2))

exp=./快照/

iter=0/1,loss _ seg 1=5.472 loss _ seg 2=5.143 loss _ adv 1=0.695,loss _ adv 2=0.687 loss _ D1=0.693 loss _ D2=0.693

判别器D

2类FCDiscriminator(nn .模块):

3 def __init__(self,num_classes,ndf=64):

四超(FCDiscriminator,self).__init__()

5 self.conv1=nn .Conv2d(数量类,ndf,内核大小=4,步幅=2,填充=1)

6 self.conv2=nn .Conv2d(ndf,ndf*2,kernel_size=4,stride=2,padding=1)

7 self.conv3=nn .Conv2d(ndf*2,ndf*4,kernel_size=4,stride=2,padding=1)

8 self.conv4=nn .Conv2d(ndf*4,ndf*8,kernel_size=4,stride=2,padding=1)

9自我分类器=nn .Conv2d(ndf*8,1,kernel_size=4,stride=2,padding=1)

10 self.leaky_relu=nn .LeakyReLU(负斜率=0.2,原地=真)

11 #self.up_sample=nn .上采样(比例因子=32,模式='bi

linear') 12 #self.sigmoid = nn.Sigmoid() 13 def forward(self, x): 14 x = self.conv1(x) 15 x = self.leaky_relu(x) 16 x = self.conv2(x) 17 x = self.leaky_relu(x) 18 x = self.conv3(x) 19 x = self.leaky_relu(x) 20 x = self.conv4(x) 21 x = self.leaky_relu(x) 22 x = self.classifier(x) 23 # x = self.up_sample(x) 24 # x = self.sigmoid(x) 25 return x 26 model_D1 = FCDiscriminator(num_classes=args.num_classes) 27 model_D2 = FCDiscriminator(num_classes=args.num_classes) 28 source_label = 0 29 target_label = 1

model = DeeplabMulti(num_classes=args.num_classes)
model_D1:

FCDiscriminator( (conv1): Conv2d(19, 64, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1)) (conv2): Conv2d(64, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1)) (conv3): Conv2d(128, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1)) (conv4): Conv2d(256, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1)) (classifier): Conv2d(512, 1, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1)) (leaky_relu): LeakyReLU(negative_slope=0.2, inplace=True) )
 

 

 

生成器 G

 1 model = DeeplabMulti(num_classes=args.num_classes)
 2 
 3 def DeeplabMulti(num_classes=21):
 4     model = ResNetMulti(Bottleneck, [3, 4, 23, 3], num_classes)
 5     return model
 6 
 7 class ResNetMulti(nn.Module):
 8     def __init__(self, block, layers, num_classes):
 9         self.inplanes = 64
10         super(ResNetMulti, self).__init__()
11         self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
12                                bias=False)
13         self.bn1 = nn.BatchNorm2d(64, affine=affine_par)
14         for i in self.bn1.parameters():
15             i.requires_grad = False
16         self.relu = nn.ReLU(inplace=True)
17         self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1, ceil_mode=True)  # change
18         self.layer1 = self._make_layer(block, 64, layers[0])
19         self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
20         self.layer3 = self._make_layer(block, 256, layers[2], stride=1, dilation=2)
21         self.layer4 = self._make_layer(block, 512, layers[3], stride=1, dilation=4)
22         self.layer5 = self._make_pred_layer(Classifier_Module, 1024, [6, 12, 18, 24], [6, 12, 18, 24], num_classes)
23         self.layer6 = self._make_pred_layer(Classifier_Module, 2048, [6, 12, 18, 24], [6, 12, 18, 24], num_classes)
24     def forward(self, x):
25     x = self.conv1(x)
26     x = self.bn1(x)
27     x = self.relu(x)
28     x = self.maxpool(x)
29     x = self.layer1(x)
30     x = self.layer2(x)
31 
32     x = self.layer3(x)
33     x1 = self.layer5(x)
34 
35     x2 = self.layer4(x)
36     x2 = self.layer6(x2)
37     return x1, x2

 

 

训练G

 1         for sub_i in range(args.iter_size):  # 迭代 1 次
 2 ############# train G
 3             # 训练G的时候,不累计D的梯度
 4             for param in model_D1.parameters():
 5                 param.requires_grad = False
 6             for param in model_D2.parameters():
 7                 param.requires_grad = False
 8 
 9             # train with source
10             _, batch = trainloader_iter.__next__()
11 
12             images, labels, _, _ = batch
13             images = Variable(images).cuda(args.gpu)
14 
15             pred1, pred2 = model(images)  # 得到最后两层的特征图
16             pred1 = interp(pred1)  # 特征图 上采样
17             pred2 = interp(pred2)
18 
19             loss_seg1 = loss_calc(pred1, labels, args.gpu)
20             loss_seg2 = loss_calc(pred2, labels, args.gpu)
21             loss = loss_seg2 + args.lambda_seg * loss_seg1  # loss_seg2为主,最后一层是loss_2, 倒数第二层为loss_1
22 
23             # proper normalization        # 归一化
24             loss = loss / args.iter_size
25             loss.backward()               # 损失反向传播
26             loss_seg_value1 += loss_seg1.data.item() / args.iter_size
27             loss_seg_value2 += loss_seg2.data.item() / args.iter_size
28 
29             # train with target
30             _, batch = targetloader_iter.__next__()
31             images, _, _ = batch
32             images = Variable(images).cuda(args.gpu)
33 
34             pred_target1, pred_target2 = model(images)
35             pred_target1 = interp_target(pred_target1)
36             pred_target2 = interp_target(pred_target2)
37 
38             D_out1 = model_D1(F.softmax(pred_target1))  # D_out 目标域 最后两层的标签   为什么这里还要用 softmax
39             # print('D_out1.shape:', D_out1.shape)
40             D_out2 = model_D2(F.softmax(pred_target2))
41             
42             loss_adv_target1 = bce_loss(D_out1,
43                                         Variable(torch.FloatTensor(D_out1.data.size()).fill_(source_label)).cuda(
44                                             args.gpu))
45             loss_adv_target2 = bce_loss(D_out2,
46                                         Variable(torch.FloatTensor(D_out2.data.size()).fill_(source_label)).cuda(
47                                             args.gpu))
48             loss = args.lambda_adv_target1 * loss_adv_target1 + args.lambda_adv_target2 * loss_adv_target2
49             loss = loss / args.iter_size
50             loss.backward()  # 损失反向传播
51             loss_adv_target_value1 += loss_adv_target1.item() / args.iter_size
52             loss_adv_target_value2 += loss_adv_target2.item() / args.iter_size

 

训练 D

############# train D
            # bring back requires_grad
            for param in model_D1.parameters():  # 计算判别器D的梯度
                param.requires_grad = True
            for param in model_D2.parameters():
                param.requires_grad = True
            # train with source
            pred1 = pred1.detach()  # detach():截断node反向传播的梯度流,将某个node变成不需要梯度的Varibale
            pred2 = pred2.detach()
            D_out1 = model_D1(F.softmax(pred1))
            D_out2 = model_D2(F.softmax(pred2))
            loss_D1 = bce_loss(D_out1,
                               Variable(torch.FloatTensor(D_out1.data.size()).fill_(source_label)).cuda(args.gpu))
            loss_D2 = bce_loss(D_out2,
                               Variable(torch.FloatTensor(D_out2.data.size()).fill_(source_label)).cuda(args.gpu))
            loss_D1 = loss_D1 / args.iter_size / 2
            loss_D2 = loss_D2 / args.iter_size / 2
            loss_D1.backward()
            loss_D2.backward()
            loss_D_value1 += loss_D1.item()
            loss_D_value2 += loss_D2.item()
            # train with target
            pred_target1 = pred_target1.detach()
            pred_target2 = pred_target2.detach()
            D_out1 = model_D1(F.softmax(pred_target1))
            D_out2 = model_D2(F.softmax(pred_target2))
            loss_D1 = bce_loss(D_out1,
                               Variable(torch.FloatTensor(D_out1.data.size()).fill_(target_label)).cuda(args.gpu))
            loss_D2 = bce_loss(D_out2,
                               Variable(torch.FloatTensor(D_out2.data.size()).fill_(target_label)).cuda(args.gpu))
            loss_D1 = loss_D1 / args.iter_size / 2
            loss_D2 = loss_D2 / args.iter_size / 2
            loss_D1.backward()
            loss_D2.backward()
            loss_D_value1 += loss_D1.item()
            loss_D_value2 += loss_D2.item()
        optimizer.step()
        optimizer_D1.step()
        optimizer_D2.step()

 

 

 1 class Conv2d(_ConvNd):
 2     def __init__(self, in_channels, out_channels, kernel_size, stride=1,
 3                  padding=0, dilation=1, groups=1,
 4                  bias=True, padding_mode='zeros'):
 5         kernel_size = _pair(kernel_size)
 6         stride = _pair(stride)
 7         padding = _pair(padding)
 8         dilation = _pair(dilation)
 9         super(Conv2d, self).__init__(
10             in_channels, out_channels, kernel_size, stride, padding, dilation,
11             False, _pair(0), groups, bias, padding_mode)
12 
13     def _conv_forward(self, input, weight):
14         if self.padding_mode != 'zeros':
15             return F.conv2d(F.pad(input, self._padding_repeated_twice, mode=self.padding_mode),
16                             weight, self.bias, self.stride,
17                             _pair(0), self.dilation, self.groups)
18         return F.conv2d(input, weight, self.bias, self.stride,
19                         self.padding, self.dilation, self.groups)
20 
21     def forward(self, input):
22         return self._conv_forward(input, self.weight)

 

pred1:

pred1.shape: torch.Size([1, 19, 720, 1280])   (batch size, channel, height, width)

tensor([[[[-5.4827, -5.4827, -5.4827,  ..., -1.7684, -1.7684, -1.7684],
          [-2.9857, -2.9857, -2.9857,  ..., -1.5283, -1.5283, -1.5283]],
         ...,
         [[-4.5589, -4.5589, -4.5589,  ..., -1.5543, -1.5543, -1.5543],
          [-4.5589, -4.5589, -4.5589,  ..., -1.5543, -1.5543, -1.5543],
          [-4.5589, -4.5589, -4.5589,  ..., -1.5543, -1.5543, -1.5543],
          ...,
          [ 1.5536,  1.5536,  1.5536,  ..., -1.1647, -1.1647, -1.1647],
          [ 1.5536,  1.5536,  1.5536,  ..., -1.1647, -1.1647, -1.1647],
          [ 1.5536,  1.5536,  1.5536,  ..., -1.1647, -1.1647, -1.1647]]]],
       device='cuda:0', grad_fn=<UpsampleBilinear2DBackward>)

 

pred2:

tensor([[[[-1.3769, -1.3769, -1.3769,  ...,  1.5919,  1.5919,  1.5919],
          [-1.3769, -1.3769, -1.3769,  ...,  1.5919,  1.5919,  1.5919],
          [-1.3769, -1.3769, -1.3769,  ...,  1.5919,  1.5919,  1.5919],
          ...,
         [[ 5.6749,  5.6749,  5.6749,  ..., -1.6352, -1.6352, -1.6352],
          [ 5.6749,  5.6749,  5.6749,  ..., -1.6352, -1.6352, -1.6352],
          [ 5.6749,  5.6749,  5.6749,  ..., -1.6352, -1.6352, -1.6352],
          ...,
          [ 0.5306,  0.5306,  0.5306,  ..., -0.0221, -0.0221, -0.0221],
          [ 0.5306,  0.5306,  0.5306,  ..., -0.0221, -0.0221, -0.0221],
          [ 0.5306,  0.5306,  0.5306,  ..., -0.0221, -0.0221, -0.0221]]]],
       device='cuda:0', grad_fn=<UpsampleBilinear2DBackward>)

 

Images:

images.shape: torch.Size([1, 3, 720, 1280])

tensor([[[[-43.0070, -43.0070, -43.0070,  ..., -14.0070, -14.0070, -14.0070],
          [-43.0070, -43.0070, -43.0070,  ..., -14.0070, -15.0070, -15.0070],
          [-43.0070, -43.0070, -43.0070,  ..., -14.0070, -15.0070, -15.0070],
          ...,
         [[-87.6789, -87.6789, -87.6789,  ..., -64.6789, -65.6789, -65.6789],
          [-87.6789, -87.6789, -87.6789,  ..., -64.6789, -65.6789, -65.6789],
          [-87.6789, -87.6789, -87.6789,  ..., -64.6789, -65.6789, -65.6789],
          ...,
          [ -8.6789, -13.6789,  -8.6789,  ...,  -6.6789,  -1.6789,  13.3211],
          [ -6.6789,  -1.6789,  13.3211,  ...,   2.3211,   2.3211,   3.3211],
          [ 13.3211,  14.3211,  20.3211,  ...,  24.3211,  11.3211,  -0.6789]]]],
       device='cuda:0')

 

labels:

labels.shape: torch.Size([1, 720, 1280])

tensor([[[2., 2., 2.,  ..., 2., 2., 2.],
         [2., 2., 2.,  ..., 2., 2., 2.],
         [2., 2., 2.,  ..., 2., 2., 2.],
         ...,
         [0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.]]])

 

batch:

<class 'list'>: [tensor([[[[-43.0070, -43.0070, -43.0070,  ..., -14.0070, -14.0070, -14.0070],
          [-43.0070, -43.0070, -43.0070,  ..., -14.0070, -15.0070, -15.0070],
          [-43.0070, -43.0070, -43.0070,  ..., -14.0070, -15.0070, -15.0070],
          ...,
         [[-87.6789, -87.6789, -87.6789,  ..., -64.6789, -65.6789, -65.6789],
          [-87.6789, -87.6789, -87.6789,  ..., -64.6789, -65.6789, -65.6789],
          [-87.6789, -87.6789, -87.6789,  ..., -64.6789, -65.6789, -65.6789],
          ...,
          [ -8.6789, -13.6789,  -8.6789,  ...,  -6.6789,  -1.6789,  13.3211],
          [ -6.6789,  -1.6789,  13.3211,  ...,   2.3211,   2.3211,   3.3211],
          [ 13.3211,  14.3211,  20.3211,  ...,  24.3211,  11.3211,  -0.6789]]]]), tensor([[[2., 2., 2.,  ..., 2., 2., 2.],
         [2., 2., 2.,  ..., 2., 2., 2.],
         [2., 2., 2.,  ..., 2., 2., 2.],
         ...,
         [0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.],
         [0., 0., 0.,  ..., 0., 0., 0.]]]), tensor([[ 720, 1280,    3]]), ['19636.png']]

 

loss_seg1: loss_seg1 = loss_calc(pred1, labels, args.gpu)

tensor(4.7282, device='cuda:0', grad_fn=<NllLossBackward>)

loss_seg2:

tensor(5.1414, device='cuda:0', grad_fn=<NllLossBackward>)

loss_seg1 = 6.467 , loss_seg2 = 5.127, loss_adv1 = 0.688, loss_adv2 = 0.693, loss_D1 = 0.693 ,loss_D2 = 0.693

 

 

pred_target1:  pred_target1, pred_target2 = model(images)

pred_target1.shape: torch.Size([1, 19, 65, 129])

上采样后的pred_target1 :interp_pred_target1.shape: torch.Size([1, 19, 512, 1024])

tensor([[[[-4.8436, -4.8436, -4.8436,  ..., -0.3238, -0.3238, -0.3238],
          [-4.8436, -4.8436, -4.8436,  ..., -0.3238, -0.3238, -0.3238],
          [-4.8436, -4.8436, -4.8436,  ..., -0.3238, -0.3238, -0.3238],
          ...,
          [ 1.0468,  1.0468,  1.0468,  ..., -1.2073, -1.2073, -1.2073],
          [ 1.0468,  1.0468,  1.0468,  ..., -1.2073, -1.2073, -1.2073],
          [ 1.0468,  1.0468,  1.0468,  ..., -1.2073, -1.2073, -1.2073]],
         [[ 1.5940,  1.5940,  1.5940,  ...,  0.3063,  0.3063,  0.3063],
          [ 1.5940,  1.5940,  1.5940,  ...,  0.3063,  0.3063,  0.3063],
          [ 1.5940,  1.5940,  1.5940,  ...,  0.3063,  0.3063,  0.3063],
          ...,
          [-3.3119, -3.3119, -3.3119,  ..., -0.8856, -0.8856, -0.8856],
          [-3.3119, -3.3119, -3.3119,  ..., -0.8856, -0.8856, -0.8856],
          [-3.3119, -3.3119, -3.3119,  ..., -0.8856, -0.8856, -0.8856]]]],
       device='cuda:0', grad_fn=<UpsampleBilinear2DBackward>)

 

D_out1 : D_out1 = model_D1(F.softmax(pred_target1))  

 

D_out1.shape: torch.Size([1, 1, 16, 32])  16行32列的tensor

 

tensor([[[[0.0063, 0.0083, 0.0089, 0.0097, 0.0071, 0.0091, 0.0084, 0.0092,
           0.0082, 0.0081, 0.0091, 0.0074, 0.0087, 0.0089, 0.0089, 0.0069,
           0.0109, 0.0111, 0.0072, 0.0070, 0.0083, 0.0082, 0.0084, 0.0088,
           0.0075, 0.0076, 0.0086, 0.0098, 0.0104, 0.0088, 0.0080, 0.0112],
          [0.0069, 0.0097, 0.0101, 0.0111, 0.0104, 0.0115, 0.0102, 0.0095,
           0.0114, 0.0099, 0.0110, 0.0100, 0.0103, 0.0115, 0.0097, 0.0105,
           0.0121, 0.0096, 0.0108, 0.0092, 0.0126, 0.0090, 0.0095, 0.0091,
           0.0127, 0.0104, 0.0102, 0.0115, 0.0116, 0.0091, 0.0112, 0.0130],
          [0.0068, 0.0098, 0.0096, 0.0115, 0.0097, 0.0104, 0.0105, 0.0121,
           0.0120, 0.0098, 0.0124, 0.0124, 0.0102, 0.0121, 0.0119, 0.0116,
           0.0090, 0.0111, 0.0104, 0.0109, 0.0129, 0.0109, 0.0097, 0.0092,
           0.0079, 0.0103, 0.0096, 0.0106, 0.0102, 0.0099, 0.0083, 0.0137],
          [0.0061, 0.0081, 0.0090, 0.0115, 0.0121, 0.0102, 0.0111, 0.0107,
           0.0121, 0.0111, 0.0119, 0.0108, 0.0119, 0.0110, 0.0099, 0.0123,
           0.0101, 0.0075, 0.0113, 0.0130, 0.0105, 0.0100, 0.0067, 0.0091,
           0.0091, 0.0074, 0.0091, 0.0068, 0.0096, 0.0089, 0.0100, 0.0151],
          [0.0064, 0.0096, 0.0092, 0.0090, 0.0086, 0.0106, 0.0099, 0.0119,
           0.0110, 0.0104, 0.0119, 0.0074, 0.0088, 0.0110, 0.0088, 0.0111,
           0.0087, 0.0091, 0.0097, 0.0110, 0.0113, 0.0083, 0.0107, 0.0098,
           0.0103, 0.0095, 0.0087, 0.0093, 0.0103, 0.0120, 0.0128, 0.0138],
          [0.0058, 0.0093, 0.0124, 0.0090, 0.0103, 0.0105, 0.0074, 0.0091,
           0.0103, 0.0103, 0.0095, 0.0090, 0.0090, 0.0072, 0.0057, 0.0099,
           0.0067, 0.0077, 0.0067, 0.0100, 0.0091, 0.0103, 0.0077, 0.0106,
           0.0097, 0.0100, 0.0097, 0.0066, 0.0104, 0.0093, 0.0060, 0.0125],
          [0.0079, 0.0122, 0.0117, 0.0107, 0.0100, 0.0086, 0.0086, 0.0084,
           0.0093, 0.0093, 0.0102, 0.0091, 0.0119, 0.0075, 0.0083, 0.0089,
           0.0051, 0.0101, 0.0101, 0.0087, 0.0082, 0.0090, 0.0088, 0.0116,
           0.0118, 0.0118, 0.0079, 0.0104, 0.0102, 0.0101, 0.0123, 0.0121],
          [0.0064, 0.0099, 0.0107, 0.0110, 0.0087, 0.0070, 0.0079, 0.0095,
           0.0088, 0.0085, 0.0102, 0.0102, 0.0091, 0.0099, 0.0098, 0.0099,
           0.0100, 0.0098, 0.0085, 0.0080, 0.0090, 0.0079, 0.0074, 0.0087,
           0.0091, 0.0103, 0.0095, 0.0110, 0.0093, 0.0096, 0.0096, 0.0117],
          [0.0073, 0.0096, 0.0093, 0.0121, 0.0095, 0.0099, 0.0080, 0.0088,
           0.0087, 0.0098, 0.0106, 0.0096, 0.0114, 0.0106, 0.0117, 0.0111,
           0.0097, 0.0097, 0.0094, 0.0097, 0.0080, 0.0094, 0.0102, 0.0091,
           0.0116, 0.0091, 0.0081, 0.0105, 0.0106, 0.0091, 0.0122, 0.0131],
          [0.0089, 0.0098, 0.0093, 0.0111, 0.0083, 0.0094, 0.0111, 0.0119,
           0.0104, 0.0093, 0.0088, 0.0101, 0.0095, 0.0116, 0.0101, 0.0091,
           0.0103, 0.0117, 0.0129, 0.0103, 0.0094, 0.0087, 0.0086, 0.0099,
           0.0126, 0.0108, 0.0113, 0.0094, 0.0089, 0.0099, 0.0083, 0.0128],
          [0.0056, 0.0104, 0.0097, 0.0091, 0.0107, 0.0094, 0.0101, 0.0116,
           0.0094, 0.0113, 0.0110, 0.0102, 0.0111, 0.0081, 0.0093, 0.0090,
           0.0102, 0.0109, 0.0117, 0.0103, 0.0086, 0.0098, 0.0094, 0.0091,
           0.0094, 0.0125, 0.0101, 0.0107, 0.0101, 0.0085, 0.0097, 0.0132],
          [0.0073, 0.0100, 0.0104, 0.0104, 0.0103, 0.0108, 0.0089, 0.0087,
           0.0077, 0.0077, 0.0118, 0.0111, 0.0096, 0.0100, 0.0107, 0.0110,
           0.0108, 0.0095, 0.0094, 0.0085, 0.0075, 0.0104, 0.0105, 0.0119,
           0.0115, 0.0111, 0.0119, 0.0104, 0.0105, 0.0107, 0.0098, 0.0141],
          [0.0070, 0.0100, 0.0109, 0.0085, 0.0061, 0.0083, 0.0117, 0.0093,
           0.0098, 0.0106, 0.0107, 0.0098, 0.0101, 0.0118, 0.0094, 0.0097,
           0.0077, 0.0095, 0.0087, 0.0096, 0.0106, 0.0102, 0.0109, 0.0100,
           0.0102, 0.0100, 0.0093, 0.0083, 0.0095, 0.0080, 0.0109, 0.0132],
          [0.0069, 0.0093, 0.0086, 0.0089, 0.0081, 0.0101, 0.0085, 0.0095,
           0.0099, 0.0082, 0.0093, 0.0083, 0.0076, 0.0083, 0.0091, 0.0092,
           0.0106, 0.0093, 0.0096, 0.0099, 0.0094, 0.0099, 0.0076, 0.0085,
           0.0087, 0.0093, 0.0093, 0.0071, 0.0088, 0.0088, 0.0096, 0.0125],
          [0.0066, 0.0094, 0.0123, 0.0115, 0.0097, 0.0094, 0.0083, 0.0096,
           0.0096, 0.0110, 0.0080, 0.0092, 0.0102, 0.0093, 0.0101, 0.0097,
           0.0099, 0.0109, 0.0107, 0.0098, 0.0094, 0.0101, 0.0106, 0.0102,
           0.0092, 0.0098, 0.0106, 0.0106, 0.0098, 0.0092, 0.0099, 0.0142],
          [0.0075, 0.0117, 0.0124, 0.0126, 0.0120, 0.0120, 0.0104, 0.0118,
           0.0123, 0.0125, 0.0130, 0.0132, 0.0129, 0.0141, 0.0131, 0.0136,
           0.0118, 0.0124, 0.0135, 0.0107, 0.0114, 0.0115, 0.0117, 0.0112,
           0.0107, 0.0115, 0.0121, 0.0122, 0.0129, 0.0124, 0.0098, 0.0138]]]],
       device='cuda:0', grad_fn=<AddBackward0>)

 

Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now