415 lines
14 KiB
Python
415 lines
14 KiB
Python
|
||
from collections import defaultdict, deque
|
||
import datetime
|
||
import time
|
||
import torch
|
||
import torch.distributed as dist
|
||
from taihuyuan_roof.compared_experiment.utils.dice_coefficient_loss import multiclass_dice_coeff, build_target
|
||
import errno
|
||
import torch.nn.functional as F
|
||
import os
|
||
|
||
import logging
|
||
from pathlib import Path
|
||
|
||
|
||
def getLogger(savedir):
|
||
logger = logging.getLogger()
|
||
logger.setLevel(logging.INFO) # Log等级总开关
|
||
formatter = logging.Formatter(fmt="[%(asctime)s|%(filename)s|%(levelname)s] %(message)s",
|
||
datefmt="%a %b %d %H:%M:%S %Y")
|
||
# StreamHandler
|
||
sHandler = logging.StreamHandler()
|
||
sHandler.setFormatter(formatter)
|
||
logger.addHandler(sHandler)
|
||
work_dir= "/"
|
||
|
||
# FileHandler
|
||
Path(savedir).mkdir(parents=True, exist_ok=True)
|
||
work_dir = os.path.join(savedir,
|
||
time.strftime("%Y-%m-%d-%H.%M", time.localtime())) # 日志文件写入目录
|
||
if not os.path.exists(work_dir):
|
||
os.makedirs(work_dir)
|
||
fHandler = logging.FileHandler(work_dir + '/log.txt', mode='w',encoding="utf-8")
|
||
fHandler.setLevel(logging.DEBUG) # 输出到file的log等级的开关
|
||
fHandler.setFormatter(formatter) # 定义handler的输出格式
|
||
logger.addHandler(fHandler) # 将logger添加到handler里面
|
||
|
||
return logger
|
||
|
||
class SmoothedValue(object):
|
||
"""Track a series of values and provide access to smoothed values over a
|
||
window or the global series average.
|
||
"""
|
||
|
||
def __init__(self, window_size=20, fmt=None):
|
||
if fmt is None:
|
||
fmt = "{value:.4f} ({global_avg:.4f})"
|
||
self.deque = deque(maxlen=window_size)
|
||
self.total = 0.0
|
||
self.count = 0
|
||
self.fmt = fmt
|
||
|
||
def update(self, value, n=1):
|
||
self.deque.append(value)
|
||
self.count += n
|
||
self.total += value * n
|
||
|
||
def synchronize_between_processes(self):
|
||
"""
|
||
Warning: does not synchronize the deque!
|
||
"""
|
||
if not is_dist_avail_and_initialized():
|
||
return
|
||
t = torch.tensor([self.count, self.total], dtype=torch.float64, device='cuda')
|
||
dist.barrier()
|
||
dist.all_reduce(t)
|
||
t = t.tolist()
|
||
self.count = int(t[0])
|
||
self.total = t[1]
|
||
|
||
@property
|
||
def median(self):
|
||
d = torch.tensor(list(self.deque))
|
||
return d.median().item()
|
||
|
||
@property
|
||
def avg(self):
|
||
d = torch.tensor(list(self.deque), dtype=torch.float32)
|
||
return d.mean().item()
|
||
|
||
@property
|
||
def global_avg(self):
|
||
return self.total / self.count
|
||
|
||
@property
|
||
def max(self):
|
||
return max(self.deque)
|
||
|
||
@property
|
||
def value(self):
|
||
return self.deque[-1]
|
||
|
||
def __str__(self):
|
||
return self.fmt.format(
|
||
median=self.median,
|
||
avg=self.avg,
|
||
global_avg=self.global_avg,
|
||
max=self.max,
|
||
value=self.value)
|
||
|
||
class ConfusionMatrix(object):
|
||
def __init__(self, num_classes):
|
||
self.num_classes = num_classes
|
||
self.mat = None
|
||
|
||
def update(self, a, b):
|
||
n = self.num_classes
|
||
if self.mat is None:
|
||
# 创建混淆矩阵
|
||
self.mat = torch.zeros((n, n), dtype=torch.int64, device=a.device)
|
||
with torch.no_grad():
|
||
# 寻找GT中为目标的像素索引
|
||
k = (a >= 0) & (a < n)
|
||
# 统计像素真实类别a[k]被预测成类别b[k]的个数(这里的做法很巧妙)
|
||
inds = n * a[k].to(torch.int64) + b[k]
|
||
self.mat += torch.bincount(inds, minlength=n**2).reshape(n, n)
|
||
|
||
def reset(self):
|
||
if self.mat is not None:
|
||
self.mat.zero_()
|
||
|
||
def compute(self):
|
||
# 注意混淆矩阵的形式
|
||
# 注意这个混淆矩阵都不太统一 有的是1的样子 有的是2的样子 本计算 借鉴的霹雳大佬的代码采用2的形式
|
||
'''1.
|
||
预测
|
||
真实
|
||
|
||
'''
|
||
|
||
'''2.
|
||
真实
|
||
预测
|
||
'''
|
||
#
|
||
# #0.sum代表所有行之间取sum 保留列的结构 1.sum代表所有列之间取sum保留行的结构
|
||
|
||
h = self.mat.float()
|
||
# 计算全局预测准确率(混淆矩阵的对角线为预测正确的个数)
|
||
acc_global = torch.diag(h).sum() / h.sum()
|
||
# 计算每个类别的准确率
|
||
acc = torch.diag(h) / h.sum(1)
|
||
# 计算每个类别预测与真实目标的iou
|
||
iu = torch.diag(h) / (h.sum(1) + h.sum(0) - torch.diag(h))
|
||
'''
|
||
22/9/24补充：每一类的准确率（p）同上边的acc和召回率r
|
||
p=tp/tp+fp 对角线/h.sum(1)
|
||
召回=tp/tp+fn 对角线/h.sum(0)
|
||
f1=2 (p*r)/p+r
|
||
'''
|
||
recall = torch.diag(h) / h.sum(1)
|
||
precion = torch.diag(h) / h.sum(0)
|
||
f1 = (2 * precion * recall) / (precion + recall)
|
||
|
||
return acc_global, acc, iu,precion,recall,f1
|
||
|
||
# def reduce_from_all_processes(self):
|
||
# if not torch.distributed.is_available():
|
||
# return
|
||
# if not torch.distributed.is_initialized():
|
||
# return
|
||
# torch.distributed.barrier()
|
||
# torch.distributed.all_reduce(self.mat)
|
||
|
||
def re_zhib(self):
|
||
acc_global, acc, iu,precion,recall,f1 = self.compute()
|
||
miou = iu.mean().item() * 100
|
||
meanf1= f1.mean().item() * 100
|
||
pv_iou=iu[1:].mean().item() * 100
|
||
pv_f1=f1[1:].mean().item() * 100
|
||
|
||
acc_global = acc_global.item() * 100
|
||
acc = [round(i, 1) for i in (acc * 100).tolist()]
|
||
iu = [round(i, 1) for i in (iu * 100).tolist()]
|
||
|
||
precion = [round(i, 1) for i in (precion * 100).tolist()]
|
||
recall = [round(i, 1) for i in (recall * 100).tolist()]
|
||
f1 = [round(i, 1) for i in (f1 * 100).tolist()]
|
||
|
||
return acc_global, acc, iu,precion,recall,f1,miou,meanf1,pv_iou,pv_f1
|
||
|
||
def __str__(self):
|
||
acc_global, acc, iu, precion, recall, f1 = self.compute()
|
||
return (
|
||
'global correct: {:.1f}\n'
|
||
'average row correct: {}\n'
|
||
'IoU: {}\n'
|
||
'Precion: {:.1f}\n'
|
||
'Recall: {:.1f}\n'
|
||
'f1: {:.1f}\n'
|
||
'mean IoU: {:.1f}\n'
|
||
|
||
|
||
|
||
).format(
|
||
acc_global.item() * 100,
|
||
['{:.1f}'.format(i) for i in (acc * 100).tolist()],
|
||
['{:.1f}'.format(i) for i in (iu * 100).tolist()],
|
||
['{:.1f}'.format(i) for i in (precion * 100).tolist()],
|
||
['{:.1f}'.format(i) for i in (recall * 100).tolist()],
|
||
['{:.1f}'.format(i) for i in (f1 * 100).tolist()],
|
||
|
||
iu.mean().item() * 100)
|
||
|
||
class MetricLogger(object):
|
||
def __init__(self, delimiter="\t"):
|
||
self.meters = defaultdict(SmoothedValue)
|
||
self.delimiter = delimiter
|
||
|
||
def update(self, **kwargs):
|
||
for k, v in kwargs.items():
|
||
if isinstance(v, torch.Tensor):
|
||
v = v.item()
|
||
assert isinstance(v, (float, int))
|
||
self.meters[k].update(v)
|
||
|
||
def __getattr__(self, attr):
|
||
if attr in self.meters:
|
||
return self.meters[attr]
|
||
if attr in self.__dict__:
|
||
return self.__dict__[attr]
|
||
raise AttributeError("'{}' object has no attribute '{}'".format(
|
||
type(self).__name__, attr))
|
||
|
||
def __str__(self):
|
||
loss_str = []
|
||
for name, meter in self.meters.items():
|
||
loss_str.append(
|
||
"{}: {}".format(name, str(meter))
|
||
)
|
||
return self.delimiter.join(loss_str)
|
||
|
||
def synchronize_between_processes(self):
|
||
for meter in self.meters.values():
|
||
meter.synchronize_between_processes()
|
||
|
||
def add_meter(self, name, meter):
|
||
self.meters[name] = meter
|
||
|
||
def log_every(self, iterable, print_freq, header=None):
|
||
i = 0
|
||
if not header:
|
||
header = ''
|
||
start_time = time.time()
|
||
end = time.time()
|
||
iter_time = SmoothedValue(fmt='{avg:.4f}')
|
||
data_time = SmoothedValue(fmt='{avg:.4f}')
|
||
space_fmt = ':' + str(len(str(len(iterable)))) + 'd'
|
||
if torch.cuda.is_available():
|
||
log_msg = self.delimiter.join([
|
||
header,
|
||
'[{0' + space_fmt + '}/{1}]',
|
||
'eta: {eta}',
|
||
'{meters}',
|
||
'time: {time}',
|
||
'data: {data}',
|
||
'max mem: {memory:.0f}'
|
||
])
|
||
else:
|
||
log_msg = self.delimiter.join([
|
||
header,
|
||
'[{0' + space_fmt + '}/{1}]',
|
||
'eta: {eta}',
|
||
'{meters}',
|
||
'time: {time}',
|
||
'data: {data}'
|
||
])
|
||
MB = 1024.0 * 1024.0
|
||
for obj in iterable:
|
||
data_time.update(time.time() - end)
|
||
yield obj
|
||
iter_time.update(time.time() - end)
|
||
if i % print_freq == 0:
|
||
eta_seconds = iter_time.global_avg * (len(iterable) - i)
|
||
eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))
|
||
if torch.cuda.is_available():
|
||
print(log_msg.format(
|
||
i, len(iterable), eta=eta_string,
|
||
meters=str(self),
|
||
time=str(iter_time), data=str(data_time),
|
||
memory=torch.cuda.max_memory_allocated() / MB))
|
||
else:
|
||
print(log_msg.format(
|
||
i, len(iterable), eta=eta_string,
|
||
meters=str(self),
|
||
time=str(iter_time), data=str(data_time)))
|
||
i += 1
|
||
end = time.time()
|
||
total_time = time.time() - start_time
|
||
total_time_str = str(datetime.timedelta(seconds=int(total_time)))
|
||
print('{} Total time: {}'.format(header, total_time_str))
|
||
|
||
class DiceCoefficient(object):
|
||
def __init__(self, num_classes: int = 2, ignore_index: int = -100):
|
||
self.cumulative_dice = None
|
||
self.num_classes = num_classes
|
||
self.ignore_index = ignore_index
|
||
self.count = None
|
||
|
||
def update(self, pred, target):
|
||
if self.cumulative_dice is None:
|
||
self.cumulative_dice = torch.zeros(1, dtype=pred.dtype, device=pred.device)
|
||
if self.count is None:
|
||
self.count = torch.zeros(1, dtype=pred.dtype, device=pred.device)
|
||
# compute the Dice score, ignoring background
|
||
pred = F.one_hot(pred.argmax(dim=1), self.num_classes).permute(0, 3, 1, 2).float()
|
||
dice_target = build_target(target, self.num_classes, self.ignore_index)
|
||
self.cumulative_dice += multiclass_dice_coeff(pred[:, 1:], dice_target[:, 1:], ignore_index=self.ignore_index)
|
||
self.count += 1
|
||
|
||
@property
|
||
def value(self):
|
||
if self.count == 0:
|
||
return 0
|
||
else:
|
||
return self.cumulative_dice / self.count
|
||
|
||
def reset(self):
|
||
if self.cumulative_dice is not None:
|
||
self.cumulative_dice.zero_()
|
||
|
||
if self.count is not None:
|
||
self.count.zeros_()
|
||
|
||
def reduce_from_all_processes(self):
|
||
if not torch.distributed.is_available():
|
||
return
|
||
if not torch.distributed.is_initialized():
|
||
return
|
||
torch.distributed.barrier()
|
||
torch.distributed.all_reduce(self.cumulative_dice)
|
||
torch.distributed.all_reduce(self.count)
|
||
|
||
|
||
def mkdir(path):
|
||
try:
|
||
os.makedirs(path)
|
||
except OSError as e:
|
||
if e.errno != errno.EEXIST:
|
||
raise
|
||
|
||
|
||
def setup_for_distributed(is_master):
|
||
"""
|
||
This function disables printing when not in master process
|
||
"""
|
||
import builtins as __builtin__
|
||
builtin_print = __builtin__.print
|
||
|
||
def print(*args, **kwargs):
|
||
force = kwargs.pop('force', False)
|
||
if is_master or force:
|
||
builtin_print(*args, **kwargs)
|
||
|
||
__builtin__.print = print
|
||
|
||
|
||
def is_dist_avail_and_initialized():
|
||
if not dist.is_available():
|
||
return False
|
||
if not dist.is_initialized():
|
||
return False
|
||
return True
|
||
|
||
|
||
def get_world_size():
|
||
if not is_dist_avail_and_initialized():
|
||
return 1
|
||
return dist.get_world_size()
|
||
|
||
|
||
def get_rank():
|
||
if not is_dist_avail_and_initialized():
|
||
return 0
|
||
return dist.get_rank()
|
||
|
||
|
||
def is_main_process():
|
||
return get_rank() == 0
|
||
|
||
|
||
def save_on_master(*args, **kwargs):
|
||
if is_main_process():
|
||
torch.save(*args, **kwargs)
|
||
|
||
|
||
def init_distributed_mode(args):
|
||
if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ:
|
||
args.rank = int(os.environ["RANK"])
|
||
args.world_size = int(os.environ['WORLD_SIZE'])
|
||
args.gpu = int(os.environ['LOCAL_RANK'])
|
||
elif 'SLURM_PROCID' in os.environ:
|
||
args.rank = int(os.environ['SLURM_PROCID'])
|
||
args.gpu = args.rank % torch.cuda.device_count()
|
||
elif hasattr(args, "rank"):
|
||
pass
|
||
else:
|
||
print('Not using distributed mode')
|
||
args.distributed = False
|
||
return
|
||
|
||
args.distributed = True
|
||
|
||
torch.cuda.set_device(args.gpu)
|
||
args.dist_backend = 'nccl'
|
||
print('| distributed init (rank {}): {}'.format(
|
||
args.rank, args.dist_url), flush=True)
|
||
torch.distributed.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
|
||
world_size=args.world_size, rank=args.rank)
|
||
setup_for_distributed(args.rank == 0)
|
||
|
||
|
||
|
||
|