前沿人工智能算法

 import torch

    
 import torch.nn.function F
    
 import torch.nn as nn
    
  
    
 in_channels = 2
    
 out_channels = 2
    
 kernel_size = 3
    
 w = 9
    
 h = 9
    
  
    
 x = torch.ones(1, in_channels, w, h) #输入图片
    
  
    
 # 方法1：原生写法
    
 conv_2d = nn.Conc2d(in_channels, out_channels, kernel_size, padding="same")
    
 conv_2d_pointwise = nn.Conv2d(in_channels, out_channels, 1)
    
 result1 = conv_2d(x) + conv_2d_pintwise(x) + x
    
  
    
 # 方法2：算子融合
    
 # 把point-wise卷积和x本身都写成3*3的卷积
    
 # 最终把三个卷积写成一个卷积
    
 # 1）改造
    
 pointwise_to_conv_weight = F.pad(conv_2d_pointewise.weight, [1,1,1,1,0,0,0,0]) # 
    
 2*2*1*1->2*2*3*3
    
 conv_2d_for_pointwise = nn.Conv2d(in_channels, out_channels, kernel_size, padding="same")
    
 conv_2d_for_pointwise.weight = nn.Parameter(pointwise_to_conv_weight)
    
 conv_2d_for_pointwise.bias = conv_2d_pointwise.bias
    
  
    
 # 2*2*3*3
    
 zeros = torch.unsequeeze(torch.zeros(kernel_size, kernel_size), 0)
    
 stars = torch.unsequenze(F.pad(torch.ones(1,1),   [1,1,1,1]),0)
    
 stars_zeros = torch.unsqueeze(torch.cat([stars, zeros], 0),0)
    
 zeros_stars = torch.unsqueeze(torch.cat([zeros, stars], 0),0)
    
 identity_to_conv_weight = torch.cat([stars_zeros, zeros_start], 0)
    
 identity_to_conv_bias = torch.zeros([out_channels])
    
 conv_2d_for_identity.weight = nn.Parameter(identity_to_conv_weight)
    
 conv_2d_for_identiyu.bias = nn.Parameter(identity_to_conv_bias)
    
  
    
 result2 = conv_2d(x) + conv_2d_for_pointwise(x) + conv_2d_for_identity(x)
    
  
    
 # 2）融合
    
 conv_2d_for_fusion = nn.Conv2d(in_cahnnels, out_channels, kernel_size, padding="same")
    
 conv_2d_for_fusion.weight = nn.Parameter(conv_2d.weight.data, conv_2d_for_pointwise.weight.data, conv_2d_for_identity.weight.data)
    
 conv_2d_for_fusion.bias = nn.Parameter(conv_2d_bias.data, conv_2d_for_pointwise.data, conv_2d_for_identity.bias.data)
    
 result3 = conv_2d_for_fusion(x)
    
 print(torch.all(torch.isclose(result2, result3)))