code: import torch
  import torch.nn as nn
  from torch.nn import init
  import functools
  from torch.autograd import Variable
  import numpy as np
  from .basic_layers import ResidualBlock
  from .attention_module import AttentionModule
  
  
  class ResidualAttentionModel(nn.Module):
      def __init__(self, in_channels=3, num_classes=1000):
          super(ResidualAttentionModel, self).__init__()
          self.conv1 = nn.Sequential(
              nn.Conv2d(in_channels, 64, kernel_size=7, stride=2, padding=3, bias=False),
              nn.BatchNorm2d(64),
              nn.ReLU(inplace=True),
          )
          self.mpool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
          self.residual_block1 = ResidualBlock(64, 256)
          self.attention_module1 = AttentionModule(256, 256, (56, 56), (28, 28), (14, 14))
          self.residual_block2 = ResidualBlock(256, 512, 2)
          self.attention_module2 = AttentionModule(512, 512, (28, 28), (14, 14), (7, 7))
          self.residual_block3 = ResidualBlock(512, 1024, 2)
          self.attention_module3 = AttentionModule(1024, 1024, (14, 14), (7, 7), (4, 4))
          self.residual_block4 = ResidualBlock(1024, 2048, 2)
          self.residual_block5 = ResidualBlock(2048, 2048)
          self.residual_block6 = ResidualBlock(2048, 2048)
          self.mpool2 = nn.Sequential(
              nn.BatchNorm2d(2048),
              nn.ReLU(inplace=True),
              nn.AvgPool2d(kernel_size=7, stride=1),
          )
          self.fc = nn.Linear(2048, num_classes)
  
      def forward(self, x):
          out = self.conv1(x)
          out = self.mpool1(out)
          # print(out.data)
          out = self.residual_block1(out)
          out = self.attention_module1(out)
          out = self.residual_block2(out)
          out = self.attention_module2(out)
          out = self.residual_block3(out)
          # print(out.data)
          out = self.attention_module3(out)
          out = self.residual_block4(out)
          out = self.residual_block5(out)
          out = self.residual_block6(out)
          out = self.mpool2(out)
          out = out.view(out.size(0), -1)
          out = self.fc(out)
  
          return out
  
  
  def res_attention(in_channels=3, num_classes=1000):
      return ResidualAttentionModel(in_channels, num_classes)
  
apis: torch.nn.MaxPool2d torch.nn.BatchNorm2d torch.nn.Linear torch.nn.Conv2d torch.nn.AvgPool2d torch.nn.ReLU