请写出基于Pytorch框架的deeplabv3+网络加入注意力机制的方法与代码，要求代码可以成功分割图像

首先，我们需要导入必要的库：

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils import data
import torchvision.transforms as transforms
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt

接下来，我们定义一个带有注意力机制的 deeplabv3+ 模型：

class AtrousSpatialPyramidPoolingModule(nn.Module):
    def __init__(self, in_channels, out_channels):
        super(AtrousSpatialPyramidPoolingModule, self).__init__()
        self.conv1x1 = nn.Conv2d(in_channels, out_channels, kernel_size=1)
        self.conv3x3_1 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1, dilation=1)
        self.conv3x3_2 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=2, dilation=2)
        self.conv3x3_3 = nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=4, dilation=4)
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.conv1x1_out = nn.Conv2d(out_channels*5, out_channels, kernel_size=1)
        self.sigmoid = nn.Sigmoid()
        
    def forward(self, x):
        x1 = self.conv1x1(x)
        x2 = self.conv3x3_1(x)
        x3 = self.conv3x3_2(x)
        x4 = self.conv3x3_3(x)
        x5 = self.avg_pool(x)
        x5 = F.interpolate(x5, size=x.size()[2:], mode="bilinear", align_corners=True)
        x = torch.cat([x1, x2, x3, x4, x5], dim=1)
        x = self.conv1x1_out(x)
        x = self.sigmoid(x)
        x = x * x1
        return x

class DeepLabv3Plus(nn.Module):
    def __init__(self, num_classes):
        super(DeepLabv3Plus, self).__init__()

        self.backbone = ResNet101(output_stride=8)
        self.aspp = AtrousSpatialPyramidPoolingModule(2048, 256)
        self.decoder = Decoder(256, 256, num_classes)
        
    def forward(self, x):
        low_level_features, x = self.backbone(x)
        x = self.aspp(x)
        x = self.decoder(x, low_level_features)
        x = F.interpolate(x, size=x0.size()[2:], mode="bilinear", align_corners=True)
        return x

注意力机制的实现在 `AtrousSpatialPyramidPoolingModule` 中。这个模块包含了多个不同大小的卷积核的卷积操作，以及一个全局平均池化操作。接着，将这些卷积的输出以及全局池化的输出拼接在一起，通过一个 $1 \times 1$ 的卷积层进行降维，之后通过 Sigmoid 函数进行归一化。最后，将注意力机制的输出与原来的输入相乘即可。

在模型训练的时候，我们可以使用交叉熵损失函数和 Adam 优化器：

model = DeepLabv3Plus(num_classes=21)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

for epoch in range(num_epochs):
    for i, (images, labels) in enumerate(train_loader):
        images = images.to(device)
        labels = labels.to(device)
        
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        if (i+1) % 10 == 0:
            print("Epoch [{}/{}], Step [{}/{}] Loss: {:.4f}".format(epoch+1, num_epochs, i+1, total_step, loss.item()))

在模型训练完成后，我们可以进行图像分割：

model.eval()

image = Image.open("image.jpg")
transform = transforms.Compose([
    transforms.Resize((512, 512)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
image = transform(image).unsqueeze(0)

with torch.no_grad():
    output = model(image)
    output = F.softmax(output, dim=1)
    output = torch.argmax(output, dim=1)
    output = output.squeeze(0).cpu().numpy()

plt.imshow(output)
plt.show()

这里我们使用了 softmax 函数和 argmax 函数对输出进行了处理，得到了每个像素点的类别。最后，我们可以将输出的图片显示出来，得到图像分割的结果。