shancx 1.8.92__py3-none-any.whl → 1.9.33.218__py3-none-any.whl

shancx/Algo/MetricTracker.py

@@ -0,0 +1,132 @@
+# https://github.com/pytorch/examples/blob/master/imagenet/main.py
+class MetricTracker(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
+"""
+train_acc = metrics.MetricTracker()
+train_acc.update(metrics.acc(outputs, labels,threshold=0.1), outputs.size(0))
+train_acc.avg
+"""
+
+
+from tqdm import tqdm
+
+class TrainingManager:
+    def __init__(self, loader, description="Training Progress", log_file=None):
+        """
+        封装进度条和日志记录的训练管理类
+        :param loader: 数据加载器
+        :param description: 进度条描述
+        :param log_file: 日志文件路径，可选
+        """
+        self.loader = tqdm(loader, desc=description)
+        self.metrics = {}
+        self.log_file = log_file
+        if log_file:
+            with open(log_file, 'w') as f:
+                headers = "Epoch,Step," + ",".join(self.metrics.keys()) + "\n"
+                f.write(headers)
+
+    def add_metric(self, name, initial_value=0.0):
+        """
+        添加指标用于追踪
+        :param name: 指标名称
+        :param initial_value: 初始值
+        """
+        self.metrics[name] = Metric(initial_value)
+
+    def update_metrics(self, **kwargs):
+        """
+        更新指定的指标值
+        :param kwargs: 关键字参数，指标名和更新值
+        """
+        for name, value in kwargs.items():
+            if name in self.metrics:
+                self.metrics[name].update(value)
+
+    def log_progress(self, epoch, step):
+        """
+        更新进度条和日志文件
+        :param epoch: 当前训练轮次
+        :param step: 当前训练步骤
+        """
+        description = f"Epoch {epoch}: " + " ".join(
+            [f"{name}: {metric.avg:.4f}" for name, metric in self.metrics.items()]
+        )
+        self.loader.set_description(description)
+
+        if self.log_file:
+            with open(self.log_file, 'a') as f:
+                line = f"{epoch},{step}," + ",".join([f"{metric.avg:.4f}" for metric in self.metrics.values()]) + "\n"
+                f.write(line)
+
+    def close(self):
+        """关闭进度条"""
+        self.loader.close()
+
+class Metric:
+    def __init__(self, initial_value=0.0):
+        """
+        用于追踪的指标
+        :param initial_value: 初始值
+        """
+        self.total = initial_value
+        self.count = 0
+        self.avg = initial_value
+
+    def update(self, value, count=1):
+        """
+        更新指标值
+        :param value: 新增的值
+        :param count: 数据数量，默认1
+        """
+        self.total += value * count
+        self.count += count
+        self.avg = self.total / self.count
+
+# 示例代码
+if __name__ == "__main__":
+    # 假设 train_dataloader 是数据加载器，示例模拟100条数据
+    train_dataloader = [{"sat_img": None, "map_img": None} for _ in range(100)]
+
+    manager = TrainingManager(train_dataloader, description="Training Progress", log_file="training_log.csv")
+    manager.add_metric("Loss")
+    manager.add_metric("Accuracy")
+    manager.add_metric("Ts")
+    manager.add_metric("Fsc")
+    manager.add_metric("Far")
+
+    for epoch in range(3):  # 模拟3个epoch
+        for idx, data in enumerate(manager.loader):
+            # 模拟训练过程的计算
+            loss_value = 0.5 + idx * 0.01
+            accuracy_value = 0.8 - idx * 0.001
+            ts_value = 0.7 + idx * 0.001
+            fsc_value = 0.6 + idx * 0.002
+            far_value = 0.2 + idx * 0.001
+
+            # 更新指标
+            manager.update_metrics(
+                Loss=loss_value,
+                Accuracy=accuracy_value,
+                Ts=ts_value,
+                Fsc=fsc_value,
+                Far=far_value
+            )
+
+            # 记录进度和日志
+            manager.log_progress(epoch, idx)
+
+    # 关闭进度条
+    manager.close()

shancx/Algo/Normalize.py

@@ -0,0 +1,66 @@
+ 
+from torchvision.transforms import Resize# Function to calculate valid size based on scale factor
+def get_valid_size(size, scale_factor=2):
+    return size - (size % scale_factor)
+# Function to resize a high-resolution image to a low-resolution image
+def resize_to_low_res(high_res_image, scale_factor):
+    _, width, height = high_res_image.size()    
+    # Get valid width and height divisible by the scale factor
+    width = get_valid_size(width, scale_factor)
+    height = get_valid_size(height, scale_factor)    
+    # Crop the high-res image to the valid dimensions
+    high_res_image = high_res_image[:, :width, :height]    
+    # Create the low-res image by resizing the high-res image
+    low_res_image = Resize((width // scale_factor, height // scale_factor))(high_res_image)    
+    return low_res_image
+"""
+
+cuda-version              11.8                 hcce14f8_3
+cudatoolkit               11.8.0               h6a678d5_0
+cudnn                     8.9.2.26               cuda11_0
+nvidia-cuda-cupti-cu12    12.1.105                 pypi_0    pypi
+nvidia-cuda-nvrtc-cu12    12.1.105                 pypi_0    pypi
+nvidia-cuda-runtime-cu12  12.1.105                 pypi_0    pypi
+nvidia-cudnn-cu12         8.9.2.26                 pypi_0    pypi
+mqpf conda install pytorch  torchvision torchaudio  cudatoolkit=11.8 -c pytorch  
+conda install cudnn=8.9.2.26 cudatoolkit=11.8 
+resunet pip install torch==2.4.0  torchvision    torchaudio
+conda install cudnn==8.9.2.26 cudatoolkit==11.8.0
+conda install pytorch=2.2.2 torchvision torchaudio cudatoolkit=11.8 -c pytorch
+resunet pip install torch==2.4.0  torchvision    torchaudio
+pip install protobuf==3.20
+
+my-envmf1
+torch                     2.3.0                    pypi_0    pypi
+torchvision               0.18.0                   pypi_0    pypi
+
+RES:
+torch                     2.4.0                    pypi_0    pypi
+torchaudio                2.2.2                 py311_cpu    pytorch
+torchsummary              1.5.1                    pypi_0    pypi
+torchvision               0.19.0                   pypi_0    pypi
+
+mqpf:
+torch                     2.3.1                    pypi_0    pypi
+torchaudio                2.3.1                    pypi_0    pypi
+torchvision               0.18.1                   pypi_0    pypi
+onnxruntime-gpu           1.16.0
+onnx                      1.15.0 
+numpy                     1.26.4
+
+vllm:
+torch                     2.1.2                    pypi_0    pypi
+torchvision               0.15.1+cu118             pypi_0    pypi
+vllm                      0.2.7                    pypi_0    pypi
+
+import torch
+print("CUDA available:", torch.cuda.is_available())
+print("CUDA version:", torch.version.cuda)
+print("GPU device:", torch.cuda.get_device_name(0) if torch.cuda.is_available() else "No GPU")
+nvidia-smi 
+nvcc --version
+系统已经检测到物理 GPU（NVIDIA GeForce RTX 4090）和 NVIDIA 驱动，同时安装了 CUDA 12.1。然而，PyTorch 没有正确检测到 GPU，可能是因为 PyTorch 版本与 CUDA 驱动不兼容，或者环境变量未正确配置。
+
+pip install torch==2.3.1    torchvision==0.18.1  
+
+"""

shancx/Algo/OptimizerWScheduler.py

@@ -0,0 +1,38 @@
+import torch
+
+class OptimizerWithScheduler:
+    def __init__(self, model, lr=0.001, step_size=40, gamma=0.1):
+        """
+        初始化优化器和学习率调度器。
+        :param model: 要优化的模型
+        :param lr: 初始学习率
+        :param step_size: 调度器每隔多少个 epoch 调整学习率
+        :param gamma: 调度器调整学习率的乘法因子
+        """
+        self.optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+        self.lr_scheduler = torch.optim.lr_scheduler.StepLR(
+            self.optimizer, step_size=step_size, gamma=gamma
+        )
+    def zero_grad(self):
+        self.optimizer.zero_grad()
+    def step(self):
+        self.optimizer.step()
+    def step_scheduler(self):
+        self.lr_scheduler.step()
+    def get_lr(self):
+        return self.optimizer.param_groups[0]['lr']
+"""  
+if __name__ == "__main__":
+    model = torch.nn.Linear(10, 1)
+    optimizer_with_scheduler = OptimizerWithScheduler(model, lr=0.001, step_size=40, gamma=0.1)
+    for epoch in range(100):
+        optimizer_with_scheduler.step_scheduler()
+        for idx, data in enumerate(loader):
+            inputs = data["sat_img"].cuda()
+            labels = data["map_img"].cuda()
+            optimizer_with_scheduler.zero_grad()
+            loss = torch.randn(1)  # 仅为示例
+            loss.backward()   
+            optimizer_with_scheduler.step()  
+            print(f"Epoch {epoch + 1}, Learning Rate: {optimizer_with_scheduler.get_lr()}")
+"""

shancx/Algo/Rmageresize.py

@@ -0,0 +1,79 @@
+import torch
+from torchvision.transforms import Resize
+from torchvision.transforms.functional import InterpolationMode
+import numpy as np
+
+def image_resize(image, scale_factor, antialiasing=True):
+    """
+    Resize the input image with a specified scale factor using torchvision's Resize.
+
+    Args:
+        image (np.ndarray or torch.Tensor): Input image of shape (H, W, C) or (C, H, W).
+        scale_factor (float): Scale factor to resize the image.
+        antialiasing (bool): Whether to use antialiasing (default: True).
+
+    Returns:
+        Resized image in the same format as input (NumPy or PyTorch Tensor).
+    """
+    # Check if input is NumPy array
+    numpy_type = isinstance(image, np.ndarray)
+
+    # Handle missing values for NumPy arrays
+    if numpy_type:
+        image = np.nan_to_num(image)  # Replace NaNs with 0
+        if image.ndim == 3:  # (H, W, C)
+            image = torch.from_numpy(image.transpose(2, 0, 1)).float()  # Convert to (C, H, W)
+        elif image.ndim == 2:  # (H, W)
+            image = torch.from_numpy(image[None, :, :]).float()  # Convert to (C, H, W)
+
+    # Calculate new dimensions
+    _, in_h, in_w = image.shape  # Assuming (C, H, W) format
+    out_h, out_w = int(in_h * scale_factor), int(in_w * scale_factor)
+
+    # Perform resizing
+    mode = InterpolationMode.BICUBIC if antialiasing else InterpolationMode.NEAREST
+    resize_transform = Resize((out_h, out_w), interpolation=mode)
+    resized_image = resize_transform(image)
+
+    # Convert back to NumPy array if input was NumPy
+    if numpy_type:
+        resized_image = resized_image.numpy().transpose(1, 2, 0)  # Convert back to (H, W, C)
+
+    return resized_image
+# resized_image = image_resize(image, scale_factor, antialiasing)
+
+# Example for loading image data and processing NaNs
+def process_image(file_path, scale_factor, antialiasing=True):
+    """
+    Load an image from a file, handle NaN values, and resize it.
+
+    Args:
+        file_path (str): Path to the image file (e.g., .npy for NumPy arrays).
+        scale_factor (float): Scale factor for resizing.
+        antialiasing (bool): Use antialiasing during resizing (default: True).
+
+    Returns:
+        Resized image as a NumPy array.
+    """
+    # Load the image from a .npy file
+    image = np.load(file_path)
+    image[np.isnan(image)] = 0  # Replace NaN values with 0
+
+    # Resize the image
+    resized_image = image_resize(image, scale_factor, antialiasing)
+    return resized_image
+if __name__=="__main__":
+    import matplotlib.pyplot as plt
+
+    # Path to a NumPy array image file
+    file_path = 'example.npy'  # Replace with your .npy file path
+
+    # Resize the image
+    scale_factor = 0.5  # Downscale by 50%
+    resized_image = process_image(file_path, scale_factor)
+
+    # Display the resized image
+    plt.title("Resized Image")
+    plt.imshow(resized_image.astype(np.uint8))
+    plt.axis("off")
+    plt.show()

shancx/Algo/Savemodel.py

@@ -0,0 +1,33 @@
+import os
+import torch
+def save_model_checkpoint(step, epoch, model, optimizer, best_loss, best_acc, checkpoint_dir, name):
+    if not os.path.exists(checkpoint_dir):
+        os.makedirs(checkpoint_dir)
+    save_path = os.path.join(checkpoint_dir, f"{name}_checkpoint_{step:04d}.pt")
+    torch.save({
+        "step": step,
+        "epoch": epoch,
+        "arch": model.__class__.__name__,  
+        "state_dict": model.state_dict(),  
+        "best_acc": best_acc, 
+        "best_loss": best_loss,  
+        "optimizer": optimizer.state_dict(), 
+    }, save_path)
+    return save_path
+
+"""
+if valid_loss < best_loss:
+    best_loss = valid_loss
+    wait = 0  # Reset wait counter
+    save_path = save_model_checkpoint(
+        step=step,
+        epoch=epoch,
+        model=model,
+        optimizer=optimizer,
+        best_loss=best_loss,
+        best_acc=best_acc,
+        checkpoint_dir=checkpoint_dir,
+        name=name
+    )
+    print(f"Checkpoint saved at: {save_path}")
+"""

shancx/Algo/SmoothL1_losses.py

@@ -0,0 +1,27 @@
+import torch
+import torch.nn.functional as F
+import torch.nn as nn
+def smoothL1_loss(x, y):
+    smoothL1loss = nn.SmoothL1Loss()
+    return smoothL1loss(x, y)
+def compute_smoothL1_losses(x,y, y_label):
+    """
+    计算每个标签类别的 Smooth L1 损失。    
+    参数:
+    - x (torch.Tensor): 预测值。
+    - y (torch.Tensor): 真实值。
+    - y_label (torch.Tensor): 标签值，用于选择对应类别的预测和真实值。    
+    返回:
+    - smoothL1_losses (list): 包含每个类别的 Smooth L1 损失值的列表。
+    """
+    smoothL1_losses = []
+    for label_value in range(1, 5):
+        mask = y_label == label_value
+        x_masked = torch.masked_select(x, mask)
+        y_masked = torch.masked_select(y, mask)
+        if x_masked.numel() > 0:
+            smoothL1_val = smoothL1_loss(x_masked, y_masked) #, reduction='mean'
+            smoothL1_losses.append(smoothL1_val) 
+        else:
+            smoothL1_losses.append(torch.tensor(0.0))        #增强逻辑   
+    return smoothL1_losses

shancx/Algo/Tqdm.py

@@ -0,0 +1,62 @@
+from tqdm import tqdm
+class TrainingManager:
+    def __init__(self, loader, description="Training Progress", log_file=None):
+        self.loader = tqdm(loader, desc=description)
+        self.metrics = {}
+        self.log_file = log_file
+        if log_file:
+            with open(log_file, 'w') as f:
+                headers = "Epoch,Step," + ",".join(self.metrics.keys()) + "\n"
+                f.write(headers)
+    def add_metric(self, name, initial_value=0.0):
+        self.metrics[name] = Metric(initial_value)        ###用的另外一个更新类计算均值的
+    def update_metrics(self, **kwargs):
+        for name, value in kwargs.items(): #param kwargs: 关键字参数，指标名和更新值
+            if name in self.metrics:
+                self.metrics[name].update(value)
+    def log_progress(self, epoch, step):
+        description = f"Epoch {epoch}: " + " ".join(
+            [f"{name}: {metric.avg:.4f}" for name, metric in self.metrics.items()]
+        )
+        self.loader.set_description(description)
+        if self.log_file:
+            with open(self.log_file, 'a') as f:
+                line = f"{epoch},{step}," + ",".join([f"{metric.avg:.4f}" for metric in self.metrics.values()]) + "\n"
+                f.write(line)
+    def log_progress1(self, description):
+        self.loader.set_description(description)
+    def close(self):
+        self.loader.close()
+class Metric:
+    def __init__(self, initial_value=0.0):
+        self.total = initial_value
+        self.count = 0
+        self.avg = initial_value
+    def update(self, value, count=1):
+        self.total += value * count
+        self.count += count
+        self.avg = self.total / self.count
+if __name__ == "__main__":
+    train_dataloader = [{"sat_img": None, "map_img": None} for _ in range(100)]
+    manager = TrainingManager(train_dataloader, description="Training Progress", log_file="training_log.csv")
+    manager.add_metric("Loss")
+    manager.add_metric("Accuracy")
+    manager.add_metric("Ts")
+    manager.add_metric("Fsc")
+    manager.add_metric("Far")
+    for epoch in range(3):  # 模拟3个epoch
+        for idx, data in enumerate(manager.loader):
+            loss_value = 0.5 + idx * 0.01
+            accuracy_value = 0.8 - idx * 0.001
+            ts_value = 0.7 + idx * 0.001
+            fsc_value = 0.6 + idx * 0.002
+            far_value = 0.2 + idx * 0.001
+            manager.update_metrics(
+                Loss=loss_value,
+                Accuracy=accuracy_value,
+                Ts=ts_value,
+                Fsc=fsc_value,
+                Far=far_value
+            )
+            manager.log_progress(epoch, idx)
+    manager.close()

shancx/Algo/__init__.py

@@ -0,0 +1,121 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+# @Time : 2024/10/17 上午午10:40
+# @Author : shancx
+# @File : __init__.py
+# @email : shanhe12@163.com
+ 
+def quick_sort(arr):
+    if len(arr) <= 1:
+        return arr
+    pivot = arr[len(arr) // 2]
+    left = [x for x in arr if x < pivot]
+    middle = [x for x in arr if x == pivot]
+    right = [x for x in arr if x > pivot]
+    return quick_sort(left) + middle + quick_sort(right)
+def sort_dict_by_key(d):
+    sorted_dict = {key: d[key] for key in sorted(d.keys())}
+    return sorted_dict
+from tqdm import tqdm
+class TrainingManager:
+    def __init__(self, loader, desc="Training Progress", log_file=None):
+        self.loader = tqdm(loader, desc=desc)
+        self.metrics = {}
+        self.log_file = log_file
+        if log_file:
+            with open(log_file, 'w') as f:
+                headers = "Epoch,Step," + ",".join(self.metrics.keys()) + "\n"
+                f.write(headers)
+    def add_metric(self, name, initial_value=0.0):
+        self.metrics[name] = Metric(initial_value)        ###用的另外一个更新类计算均值的
+    def update_metrics(self, **kwargs):
+        for name, value in kwargs.items(): #param kwargs: 关键字参数，指标名和更新值
+            if name in self.metrics:
+                self.metrics[name].update(value)
+    def log_progress(self, epoch, step):
+        description = f"Epoch {epoch}: " + " ".join(
+            [f"{name}: {metric.avg:.4f}" for name, metric in self.metrics.items()]
+        )
+        self.loader.set_description(description)
+        if self.log_file:
+            with open(self.log_file, 'a') as f:
+                line = f"{epoch},{step}," + ",".join([f"{metric.avg:.4f}" for metric in self.metrics.values()]) + "\n"
+                f.write(line)
+    """ 
+    description = f"Epoch {epoch}: " + " ".join(
+            [f"{name}: {metric.avg:.4f}" for name, metric in self.metrics.items()]
+        )
+    def log_progress1(self,description):
+        self.loader.set_description(description)
+    """
+    def close(self):
+        self.loader.close()
+class Metric:
+    def __init__(self, initial_value=0.0):
+        self.total = initial_value
+        self.count = 0
+        self.avg = initial_value
+    def update(self, value, count=1):
+        self.total += value * count
+        self.count += count
+        self.avg = self.total / self.count
+if __name__ == "__main__":
+    train_dataloader = [{"sat_img": None, "map_img": None} for _ in range(100)]
+    manager = TrainingManager(train_dataloader, description="Training Progress", log_file="training_log.csv")
+    manager.add_metric("Loss")
+    manager.add_metric("Accuracy")
+    manager.add_metric("Ts")
+    manager.add_metric("Fsc")
+    manager.add_metric("Far")
+    for epoch in range(3):  # 模拟3个epoch
+        for idx, data in enumerate(manager.loader):
+            loss_value = 0.5 + idx * 0.01
+            accuracy_value = 0.8 - idx * 0.001
+            ts_value = 0.7 + idx * 0.001
+            fsc_value = 0.6 + idx * 0.002
+            far_value = 0.2 + idx * 0.001
+            manager.update_metrics(
+                Loss=loss_value,
+                Accuracy=accuracy_value,
+                Ts=ts_value,
+                Fsc=fsc_value,
+                Far=far_value
+            )
+            manager.log_progress(epoch, idx)
+    manager.close()
+    
+import psutil
+import os
+def get_memory():
+    process = psutil.Process(os.getpid())
+    return process.memory_info().rss / 1024 / 1024 
+
+'''
+initial_memory = get_memory()
+logger.info(f"内存使用前: {initial_memory:.2f} MB {sUTC}")
+load_memory = get_memory()
+logger.info(f"创建对象后: {load_memory:.2f} MB {sUTC}")
+final_memory = get_memory()
+logger.info(f"删除对象后: {final_memory:.2f} MB {sUTC}")
+logger.info(f"内存变化: 初始{initial_memory:.2f} -> 峰值{load_memory:.2f} -> 最终{final_memory:.2f}")
+'''
+
+import psutil
+import sys
+def check_memory_threshold(threshold=90):
+    mem = psutil.virtual_memory()
+    return mem.percent >= threshold
+try:
+    if check_memory_threshold(90):
+        raise RuntimeError("The system memory usage is too high. Terminating the task. error")   
+except RuntimeError as e:
+    print(f"Memory warning error: {e}")
+except MemoryError:
+    print("Insufficient memory, task failed. error")
+# except Exception as e:
+#     print(f"未知错误：{e}")
+'''
+if check_memory_threshold(90):
+    raise RuntimeError("The system memory usage is too high. Terminating the task. error")  
+
+'''

shancx/Algo/checknan.py

@@ -0,0 +1,28 @@
+import torch
+import numpy as np
+
+def checkData(data, name="data"):
+    if isinstance(data, torch.Tensor):
+        # 检查 Tensor 数据
+        has_nan = torch.isnan(data).any().item()
+        has_inf = torch.isinf(data).any().item()
+        print(f"torch.isnan(data).any() {torch.isnan(data).any()} torch.isinf(data).any() {torch.isinf(data).any()} ")
+    elif isinstance(data, np.ndarray):
+        # 检查 NumPy 数据
+        has_nan = np.isnan(data).any()
+        has_inf = np.isinf(data).any()
+        print(f"np.isnan(data).any() {np.isnan(data).any()} np.isinf(data).any() {np.isinf(data).any()} ")
+    else:
+        raise TypeError(f"Unsupported data type: {type(data)}. Expected torch.Tensor or numpy.ndarray.")
+
+    # 如果有 NaN 或 Inf，打印日志并返回 False
+    if has_nan or has_inf:
+        print(f"{name} contains NaN or Inf values!" 
+              f"has_nan: {has_nan}, has_inf: {has_inf}")
+        return False
+    return True
+    """  训练循环跳过
+            if not check_data(data, "data") or not check_data(label, "label"):
+            logger.info("# 跳过异常数据")
+            continue  # 跳过异常数据
+    """

shancx/Algo/iouJU.py

@@ -0,0 +1,83 @@
+
+def iou(inputs,targets,thresholds=[0, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 80]):
+    ts_sum = 0
+    for i in range(len(thresholds)):
+        inputs_copy = inputs.flatten().copy()   # nputs_copy = inputs.flatten().clone()
+        targets_copy = targets.flatten().copy()
+        inputs_copy[inputs.flatten() < thresholds[i]] = 0
+        inputs_copy[inputs.flatten() >= thresholds[i]] = 1
+        targets_copy[targets.flatten() < thresholds[i]] = 0
+        targets_copy[targets.flatten() >= thresholds[i]] = 1
+        intersection = (inputs_copy.flatten() * targets_copy).sum()
+        total = (inputs_copy.flatten() + targets_copy).sum()
+        union = total - intersection
+        iou = (intersection + 1e-16)/ (union + 1e-16)
+        ts_sum += iou
+    return ts_sum/len(thresholds)
+import torch
+
+def iouPlus(inputs, targets, thresholds=[0, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 80]):
+    inputs_flat = inputs.flatten()  # 提前展平
+    targets_flat = targets.flatten()
+    ts_sum = 0
+
+    for threshold in thresholds:
+        # 根据阈值二值化
+        inputs_bin = (inputs_flat >= threshold).float()
+        targets_bin = (targets_flat >= threshold).float()
+
+        # 计算交集和并集
+        intersection = (inputs_bin * targets_bin).sum()
+        union = inputs_bin.sum() + targets_bin.sum() - intersection
+
+        # 计算 IoU
+        iou = (intersection + 1e-16) / (union + 1e-16)
+        ts_sum += iou
+
+    # 返回平均 IoU
+    return ts_sum / len(thresholds)
+def IouOrder(inputs,targets,thresholds=[15]):
+    lower_threshold = thresholds[0]
+    upper_threshold = thresholds[1]
+    inputs_copy = (inputs.flatten() >= lower_threshold) & (inputs.flatten() <= upper_threshold)
+    targets_copy = (targets.flatten() >= lower_threshold) & (targets.flatten() <= upper_threshold)
+    inputs_copy = inputs_copy.astype(int)
+    targets_copy = targets_copy.astype(int)
+    intersection = (inputs_copy.flatten() * targets_copy).sum()
+    total = (inputs_copy.flatten() + targets_copy).sum()
+    union = total - intersection
+    iou = (intersection + 1e-16)/ (union + 1e-16)
+    return iou
+
+def iouMask(inputs, targets, mask, thresholds=[0, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 80],type=None):
+    # 检查输入类型
+    is_tensor = type
+    # 确保 inputs, targets, mask_data 在同一设备上
+    targets = targets 
+    mask_data = mask     
+    # 生成 mask：mask_data == 0 的区域为 True    
+    # 展平 inputs, targets, mask
+    inputs_flat = inputs.flatten()
+    targets_flat = targets.flatten()
+    mask_flat = mask.flatten()    
+    # 只计算 mask 区域的 IoU
+    if is_tensor:
+        inputs_flat = inputs_flat[mask_flat]  # 只保留 mask 为 True 的区域
+        targets_flat = targets_flat[mask_flat]
+    else:
+        inputs_flat = inputs_flat[mask_flat == 1]  # 只保留 mask 为 1 的区域
+        targets_flat = targets_flat[mask_flat == 1]    
+    ts_sum = 0.0    
+    for threshold in thresholds:
+        if is_tensor:
+            inputs_bin = (inputs_flat >= threshold).float()
+            targets_bin = (targets_flat >= threshold).float()
+        else:
+            inputs_bin = (inputs_flat >= threshold).astype(float)
+            targets_bin = (targets_flat >= threshold).astype(float)
+        intersection = (inputs_bin * targets_bin).sum()
+        union = inputs_bin.sum() + targets_bin.sum() - intersection
+        iou = (intersection + 1e-16) / (union + 1e-16)
+        ts_sum += iou
+    return ts_sum / len(thresholds)
+