​

​

​

def SoftIoULoss( pred, target):
     
        pred = torch.sigmoid(pred)
        smooth = 1
 # smooth 是一小的常数，用于防止分母为零。
 # 如果预测和真实标签都为空（所有像素都为0），那么分母会是0，导致计算错误。
 # smooth 保证了分母和分子至少为1，增加了计算的稳定性。

        intersection = pred * target

  # target (即 labels) 的值是 0. 或 1。黑色为0，白色为1，观察mask图像可知白色(1)为真实前景，黑色(0)为真实背景
        # 当 target 像素为 1(真实前景) 时，intersection = pred 的概率值。(1 x any = any)
        # 当 target 像素为 0 (真实背景) 时，intersection = 0。 (0 x any = 0)
        # 所以，`intersection` 张量在真实前景区域的值是模型的预测概率，在背景区域是0。
        loss = (intersection.sum() + smooth) / (pred.sum() + target.sum() -intersection.sum() + smooth)


        loss = 1 - loss.mean()
        # IOU是一个度量指标，值越大越好（最大为1）。而损失函数需要越小越好（最小为0）。 最简单的转换方法就是用 `1 - IoU`。
        # 如果 IoU 接近 1 (完美匹配)，损失 `1 - IoU` 就接近 0。
        # 如果 IoU 接近 0 (完全不匹配)，损失 `1 - IoU` 就接近 1。
        # 这样，通过最小化这个 `loss`，我们就能最大化 Soft IoU，从而让模型的预测结果更接近真实标签。
        return loss

def DiceLoss(pred, target):
    """
    Dice Loss 函数。

    Args:
        pred (torch.Tensor): 模型的预测输出，形状为 (B, 1, H, W)。通常是未经激活的 logits。
        target (torch.Tensor): 真实的标签掩码，形状为 (B, 1, H, W)。值为 0.0 或 1.0。

    Returns:
        torch.Tensor: 计算出的 Dice Loss，一个标量。
    """
    # 1. 将模型的原始输出转换为概率
    pred = torch.sigmoid(pred)

    # 2. 定义平滑系数，防止分母为零
    smooth = 1.0

    # 3. 计算交集 (Intersection)
    #    pred * target 会逐元素相乘。因为 target 中背景是0，前景是1，
    #    所以这个操作有效地将 pred 中对应背景区域的概率清零，只保留前景区域的概率。
    intersection = (pred * target).sum()

    # 4. 计算 Dice 系数
    #    Dice 系数的公式是：(2 * |A ∩ B|) / (|A| + |B|)
    #    |A| 在这里是 pred.sum()，|B| 是 target.sum()
    dice_coeff = (2. * intersection + smooth) / (pred.sum() + target.sum() + smooth)

    # 5. 将 Dice 系数转换为损失函数
    #    Dice 系数是相似度度量，值越大越好（最大为1）。
    #    损失函数需要越小越好（最小为0），所以用 1 - dice_coeff。
    loss = 1 - dice_coeff

    return loss

# 1.先要能定位到每一对image和mask，已知每一对image和mask名称相同（这样就不用在代码中将每对image和mask联系起来），仅文件路径不同，事先准备了一个TXT文本记录了所有image的名称（对应的mask名称相同）。可以将所有图片对名称封装到一个列表里方便读取def load_dataset (root, dataset, split_method):
    train_txt = root + '/' + dataset + '/' + split_method + '/' + 'train.txt'
    test_txt  = root + '/' + dataset + '/' + split_method + '/' + 'test.txt'
    train_img_ids = []
    val_img_ids = []
    with open(train_txt, "r") as f:
        line = f.readline()
        while line:
            train_img_ids.append(line.split('\n')[0])
            line = f.readline()
        f.close()
    with open(test_txt, "r") as f:
        line = f.readline()
        while line:
            val_img_ids.append(line.split('\n')[0])
            line = f.readline()
        f.close()
    return train_img_ids,val_img_ids,test_txt

train_img_ids, val_img_ids, test_txt = load_dataset("dataset","NUDT-SIRST","50_50")
load_dataset("dataset","NUDT-SIRST","50_50")
#成功得到记录所有图片对的名称，顺便记录一下记录文件路径，这里一个名称实际上表示的一个图片对，如dataset/NUDT-SIRST/images/001137与dataset/NUDT-SIRST/masks/001137
(['001137',
  '000345',
  '000774',
  '000593',
  '001002',
  '001024',
  '001204',
  '000683',
  '000353'],
 'dataset/NUDT-SIRST/50_50/test.txt')

#2.接下来就可以定义dataset了，功能就类似一个加工厂，定义每一项原料的加工流程（上一步已经获取了原料的地址）

from PIL import Image, ImageOps, ImageFilter
import platform, os
from torch.utils.data.dataset import Dataset
import random
import numpy as np
import  torch
from torch.nn import init
from datetime import datetime
import argparse
import shutil
from  matplotlib import pyplot as plt
from torchvision    import transforms

class TrainSetLoader(Dataset):


    """Iceberg Segmentation dataset."""
    NUM_CLASS = 1

    def __init__(self, dataset_dir, img_id ,base_size=512,crop_size=480,transform=None,suffix='.png'):
        super(TrainSetLoader, self).__init__()

        self.transform = transforms.Compose([
            transforms.ToTensor(),
            transforms.Normalize([.485, .456, .406], [.229, .224, .225])])
        
        self._items = img_id
        self.masks = dataset_dir+'/'+'masks'
        self.images = dataset_dir+'/'+'images'
        self.base_size = base_size
        self.crop_size = crop_size
        self.suffix = suffix

    def _sync_transform(self, img, mask):
        # random mirror
        if random.random() < 0.5:
            img = img.transpose(Image.FLIP_LEFT_RIGHT)
            mask = mask.transpose(Image.FLIP_LEFT_RIGHT)
        crop_size = self.crop_size
        # random scale (short edge)
        long_size = random.randint(int(self.base_size * 0.5), int(self.base_size * 2.0))
        w, h = img.size
        if h > w:
            oh = long_size
            ow = int(1.0 * w * long_size / h + 0.5)
            short_size = ow
        else:
            ow = long_size
            oh = int(1.0 * h * long_size / w + 0.5)
            short_size = oh
        img = img.resize((ow, oh), Image.BILINEAR)
        mask = mask.resize((ow, oh), Image.NEAREST)
        # pad crop
        if short_size < crop_size:
            padh = crop_size - oh if oh < crop_size else 0
            padw = crop_size - ow if ow < crop_size else 0
            img = ImageOps.expand(img, border=(0, 0, padw, padh), fill=0)
            mask = ImageOps.expand(mask, border=(0, 0, padw, padh), fill=0)
        # random crop crop_size
        w, h = img.size
        x1 = random.randint(0, w - crop_size)
        y1 = random.randint(0, h - crop_size)
        img = img.crop((x1, y1, x1 + crop_size, y1 + crop_size))
        mask = mask.crop((x1, y1, x1 + crop_size, y1 + crop_size))
        # gaussian blur as in PSP
        if random.random() < 0.5:
            img = img.filter(ImageFilter.GaussianBlur(
                radius=random.random()))
        # final transform
        img, mask = np.array(img), np.array(mask, dtype=np.float32)
        return img, mask

    def __getitem__(self, idx):

        img_id     = self._items[idx]                        # idx：('../SIRST', 'Misc_70') 成对出现，因为我的workers设置为了2
        img_path   = self.images+'/'+img_id+self.suffix   # img_id的数值正好补了self._image_path在上面定义的2个空
        label_path = self.masks +'/'+img_id+self.suffix

        img = Image.open(img_path).convert('RGB')         ##由于输入的三通道、单通道图像都有，所以统一转成RGB的三通道，这也符合Unet等网络的期待尺寸
        mask = Image.open(label_path)

        # synchronized transform
        img, mask = self._sync_transform(img, mask)

        # general resize, normalize and toTensor
        if self.transform is not None:
            img = self.transform(img)
        mask = np.expand_dims(mask, axis=0).astype('float32')/ 255.0


        return img, torch.from_numpy(mask) #img_id[-1]

    def __len__(self):
        return len(self._items)

trainset= TrainSetLoader(dataset_dir="dataset/NUDT-SIRST",img_id=train_img_ids,base_size=256,crop_size=256,transform=None,suffix=".png") #256是图片尺寸
trainset
# 加工厂成功建立，原作者把transforms向量化的工序放在外面当参数给工厂，而这里直接在工厂内部定义transforms向量化的工序

# 3.有了每个图片对的加工的方法，接下来就可以建立一个实际的可迭代对象实现批量获取原料加工成的成品
DataLoader就是一个高效的“商人+调度系统”。它从Dataset中取数据，然后把它们打包成批次（batch）。
数据流：图片文件夹->Dataset->DataLoader 就是dataloader向Dataset提出订单，Dataset把图片文件夹的数据加工一下给dataloader 
dataloader 的优点是可以多线程，打乱，多批次
from torch.utils.data import DataLoader
train_data = DataLoader(dataset=trainset, batch_size=4, shuffle=True, num_workers=0,drop_last=True)
train_data 
#DataLoader是一个 Python 的可迭代对象 (iterable)。
<torch.utils.data.dataloader.DataLoader at 0x24c30298790>

import torch
from torch.utils.data import DataLoader 


if __name__ == '__main__':

    for batch_idx, batch in enumerate(train_data):

        if isinstance(batch, (list, tuple)): 
            images, labels = batch  
            
            # 打印批次索引
            print(f"Batch {batch_idx}:")
            
            # 打印images的形状和类型（
            print(f"Images shape: {images.shape}")  
            print(f"Images type: {type(images)}")  
            print(f"Images data (first few elements): {images[:2]}")  # 只打印前2个样本，避免输出太大
            
            # 打印labels的内容
            print(f"Labels: {labels}") 
            print(f"Labels shape: {labels.shape}")  
        
        else:
            # 如果batch不是元组（例如，如果trainset只返回一个元素）
            print(f"Batch {batch_idx}: {batch}")
        
        # 添加一个分隔线，便于阅读
        print("-" * 50)
        
    

​

​

class ROCMetric():
    """Computes pixAcc and mIoU metric scores
    """
    def __init__(self, nclass, bins):  #bin的意义实际上是确定ROC曲线上的threshold取多少个离散值
        super(ROCMetric, self).__init__()
        self.nclass = nclass
        self.bins = bins
        self.tp_arr = np.zeros(self.bins+1)
        self.pos_arr = np.zeros(self.bins+1)
        self.fp_arr = np.zeros(self.bins+1)
        self.neg_arr = np.zeros(self.bins+1)
        self.class_pos=np.zeros(self.bins+1)
        # self.reset()

    def update(self, preds, labels):
        for iBin in range(self.bins+1):
            score_thresh = (iBin + 0.0) / self.bins
            # print(iBin, "-th, score_thresh: ", score_thresh)
            i_tp, i_pos, i_fp, i_neg,i_class_pos = cal_tp_pos_fp_neg(preds, labels, self.nclass,score_thresh)
            self.tp_arr[iBin]   += i_tp
            self.pos_arr[iBin]  += i_pos
            self.fp_arr[iBin]   += i_fp
            self.neg_arr[iBin]  += i_neg
            self.class_pos[iBin]+=i_class_pos

    def get(self):

        tp_rates    = self.tp_arr / (self.pos_arr + 0.001)
        fp_rates    = self.fp_arr / (self.neg_arr + 0.001)

        recall      = self.tp_arr / (self.pos_arr   + 0.001)
        precision   = self.tp_arr / (self.class_pos + 0.001)


        return tp_rates, fp_rates, recall, precision

roc_metric.update(preds, labels)

 losses = AverageMeter()

class AverageMeter(object):
    """Computes and stores the average and current value"""

    def __init__(self):
        self.reset()

    def reset(self):
        self.val = 0
        self.avg = 0
        self.sum = 0
        self.count = 0

    def update(self, val, n=1):
        self.val = val
        self.sum += val * n
        self.count += n
        self.avg = self.sum / self.count