定义Soft Boundary Loss函数，该函数需要接收两个参数：分割结果和目标掩码。分割结果是一个大小为[N, C, H, W]的张量，其中N表示batch size，C表示类别数，H和W表示图像高度和宽度。目标掩码是一个大小为[N, H, W]的张量，其中每个元素的值为0或1，表示该像素是否为目标。 在Soft Boundary Loss函数中，需要执行以下步骤： 计算每个像素到最近的边界像素点的距离，得到一个距离图像； 对距离图像进行归一化，使其取值范围在0到1之间； 对距离图像进行平滑处理，使得边界区域的像素值更加连续； 对平滑后的距离图像进行二值化，得到一个边界掩码； 将边界掩码与目标掩码进行加权，得到最终的Soft Boundary Loss。

下面是Soft Boundary Loss函数的Python代码实现：

import torch 
import torch.nn.functional as F
import numpy as np

def soft_boundary_loss(seg_result, target_mask, kernel_size=7, sigma=3):
    # 计算距离图像
    dist_maps = []
    for i in range(seg_result.shape[0]):  # 遍历batch中的每张图像
        for j in range(seg_result.shape[1]):  # 遍历每个类别
            dist_map = distance_transform(seg_result[i, j], target_mask[i])
            dist_maps.append(dist_map)
    dist_maps = np.stack(dist_maps, axis=0)  # 将距离图像堆叠成一个张量，大小为[N*C, H, W]
    dist_maps = torch.from_numpy(dist_maps).float().to(seg_result.device)

    # 归一化距离图像
    dist_maps = dist_maps / torch.max(dist_maps)

    # 平滑距离图像
    kernel = gaussian_kernel(kernel_size, sigma).to(seg_result.device)
    smoothed_maps = F.conv2d(dist_maps.unsqueeze(1), kernel.unsqueeze(1), padding=kernel_size//2)
    smoothed_maps = smoothed_maps.squeeze(1)

    # 二值化距离图像，得到边界掩码
    boundary_masks = smoothed_maps < 0.5

    # 计算Soft Boundary Loss
    weighted_masks = (1 - target_mask) + boundary_masks
    loss = F.binary_cross_entropy(smoothed_maps, weighted_masks, reduction='mean')
    return loss

def distance_transform(seg_result, target_mask):
    # 计算边界像素点
    boundary = target_mask - F.max_pool2d(target_mask, kernel_size=3, stride=1, padding=1)
    
    # 计算每个像素到最近的边界像素点的距离
    dist = np.zeros(seg_result.shape)
    for i in range(seg_result.shape[0]):
        for j in range(seg_result.shape[1]):
            if boundary[i, j] > 0:
                dist[i, j] = 0
            else:
                dist[i, j] = np.inf
    for i in range(1, seg_result.shape[0]):
        dist[i,0] = min(dist[i,0], dist[i-1,0]+1)
    for i in range(seg_result.shape[0]-2, -1, -1):
        dist[i,-1] = min(dist[i,-1], dist[i+1,-1]+1)
    for j in range(1, seg_result.shape[1]):
        dist[0,j] = min(dist[0,j], dist[0,j-1]+1)
    for j in range(seg_result.shape[1]-2, -1, -1):
        dist[-1,j] = min(dist[-1,j], dist[-1,j+1]+1)
    for i in range(1, seg_result.shape[0]):
        for j in range(1, seg_result.shape[1]):
            dist[i,j] = min(dist[i,j], dist[i-1,j]+1, dist[i,j-1]+1)
    for i in range(seg_result.shape[0]-2, -1, -1):
        for j in range(seg_result.shape[1]-2, -1, -1):
            dist[i,j] = min(dist[i,j], dist[i+1,j]+1, dist[i,j+1]+1)

    # 归一化距离图像
    dist = dist / np.max(dist)
    return dist

def gaussian_kernel(kernel_size, sigma):
    x = np.arange(kernel_size) - kernel_size // 2
    kernel = np.exp(-x ** 2 / (2 * sigma ** 2))
    kernel = kernel / np.sum(kernel)
    return torch.from_numpy(kernel).float()

Soft Boundary Loss函数中，我们首先计算每个像素到最近的边界像素点的距离，得到一个距离图像。具体来说，对于目标掩码中的每个边界像素点，我们将其距离设为0，然后利用距离变换算法计算每个像素到最近的边界像素点的距离。计算得到的距离图像大小为[H, W]，其中每个像素表示到最近边界像素点的距离。

接下来，我们对距离图像进行归一化，使其取值范围在0到1之间，方便后续处理。

然后，我们对距离图像进行平滑处理，使得边界区域的像素值更加连续。具体来说，我们使用高斯卷积核对距离图像进行卷积，得到平滑后的距离图像。高斯卷积核的大小和标准差可以通过kernel_size和sigma参数进行指定。

接着，我们对平滑后的距离图像进行二值化，得到一个边界掩码。具体来说，我们将距离图像中小于0.5的像素设为1，其余像素设为0。

最后，我们将边界掩码与目标掩码进行加权，得到最终的Soft Boundary Loss。具体来说，我们将边界掩码的权重设为1，目标掩码的权重设为1-目标掩码的像素值。然后，我们使用二元交叉熵损失函数计算Soft Boundary Loss。