• YOLOv5结合GradCAM热力图可视化

    一、修改model/yolo.py文件中的Detect类中的forward函数如下

    1. logits_ = []  # 修改---1
    2. logits = x[i][..., 5:]  # 修改---2
    3. logits_.append(logits.view(bs, -1, self.no - 5))  # 修改---3
    4. return x if self.training else (torch.cat(z, 1), torch.cat(logits_, 1), x)  # 修改---4

     二、在model文件夹中，添加yolov5_object_detector.py文件：

    1. import numpy as np
    2. import torch
    3. from models.experimental import attempt_load
    4. from utils.general import xywh2xyxy
    5. from utils.datasets import letterbox
    6. import cv2
    7. import time
    8. import torchvision
    9. import torch.nn as nn
    10. from utils.metrics import box_iou
    11.  
    12.  
    13. class YOLOV5TorchObjectDetector(nn.Module):
    14.     def __init__(self,
    15.                  model_weight,
    16.                  device,
    17.                  img_size,
    18.                  names=None,
    19.                  mode='eval',
    20.                  confidence=0.45,
    21.                  iou_thresh=0.45,
    22.                  agnostic_nms=False):
    23.         super(YOLOV5TorchObjectDetector, self).__init__()
    24.         self.device = device
    25.         self.model = None
    26.         self.img_size = img_size
    27.         self.mode = mode
    28.         self.confidence = confidence
    29.         self.iou_thresh = iou_thresh
    30.         self.agnostic = agnostic_nms
    31.         self.model = attempt_load(model_weight, map_location=device, inplace=False, fuse=False)
    32.         self.model.requires_grad_(True)
    33.         self.model.to(device)
    34.  
    35.         if self.mode == 'train':
    36.             self.model.train()
    37.         else:
    38.             self.model.eval()
    39.         # fetch the names
    40.         if names is None:
    41.             self.names = ['your dataset classname']
    42.         else:
    43.             self.names = names
    44.  
    45.         # preventing cold start
    46.         img = torch.zeros((1, 3, *self.img_size), device=device)
    47.         self.model(img)
    48.  
    49.     @staticmethod
    50.     def non_max_suppression(prediction, logits, conf_thres=0.3, iou_thres=0.45, classes=None, agnostic=False,
    51.                             multi_label=False, labels=(), max_det=300):
    52.         """Runs Non-Maximum Suppression (NMS) on inference and logits results
    54.         Returns:
    55.              list of detections, on (n,6) tensor per image [xyxy, conf, cls] and pruned input logits (n, number-classes)
    56.         """
    57.  
    58.         nc = prediction.shape[2] - 5  # number of classes
    59.         xc = prediction[..., 4] > conf_thres  # candidates
    60.  
    61.         # Checks
    62.         assert 0 <= conf_thres <= 1, f'Invalid Confidence threshold {conf_thres}, valid values are between 0.0 and 1.0'
    63.         assert 0 <= iou_thres <= 1, f'Invalid IoU {iou_thres}, valid values are between 0.0 and 1.0'
    64.  
    65.         # Settings
    66.         min_wh, max_wh = 2, 4096  # (pixels) minimum and maximum box width and height
    67.         max_nms = 30000  # maximum number of boxes into torchvision.ops.nms()
    68.         time_limit = 10.0  # seconds to quit after
    69.         redundant = True  # require redundant detections
    70.         multi_label &= nc > 1  # multiple labels per box (adds 0.5ms/img)
    71.         merge = False  # use merge-NMS
    72.  
    73.         t = time.time()
    74.         output = [torch.zeros((0, 6), device=prediction.device)] * prediction.shape[0]
    75.         logits_output = [torch.zeros((0, nc), device=logits.device)] * logits.shape[0]
    76.         # logits_output = [torch.zeros((0, 80), device=logits.device)] * logits.shape[0]
    77.         for xi, (x, log_) in enumerate(zip(prediction, logits)):  # image index, image inference
    78.             # Apply constraints
    79.             # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0  # width-height
    80.             x = x[xc[xi]]  # confidence
    81.             log_ = log_[xc[xi]]
    82.             # Cat apriori labels if autolabelling
    83.             if labels and len(labels[xi]):
    84.                 l = labels[xi]
    85.                 v = torch.zeros((len(l), nc + 5), device=x.device)
    86.                 v[:, :4] = l[:, 1:5]  # box
    87.                 v[:, 4] = 1.0  # conf
    88.                 v[range(len(l)), l[:, 0].long() + 5] = 1.0  # cls
    89.                 x = torch.cat((x, v), 0)
    90.  
    91.             # If none remain process next image
    92.             if not x.shape[0]:
    93.                 continue
    94.  
    95.             # Compute conf
    96.             x[:, 5:] *= x[:, 4:5]  # conf = obj_conf * cls_conf
    97.             # Box (center x, center y, width, height) to (x1, y1, x2, y2)
    98.             box = xywh2xyxy(x[:, :4])
    99.  
    100.             # Detections matrix nx6 (xyxy, conf, cls)
    101.             if multi_label:
    102.                 i, j = (x[:, 5:] > conf_thres).nonzero(as_tuple=False).T
    103.                 x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)
    104.             else:  # best class only
    105.                 conf, j = x[:, 5:].max(1, keepdim=True)
    106.                 x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]
    107.                 log_ = log_[conf.view(-1) > conf_thres]
    108.             # Filter by class
    109.             if classes is not None:
    110.                 x = x[(x[:, 5:6] == torch.tensor(classes, device=x.device)).any(1)]
    111.  
    112.             # Check shape
    113.             n = x.shape[0]  # number of boxes
    114.             if not n:  # no boxes
    115.                 continue
    116.             elif n > max_nms:  # excess boxes
    117.                 x = x[x[:, 4].argsort(descending=True)[:max_nms]]  # sort by confidence
    118.  
    119.             # Batched NMS
    120.             c = x[:, 5:6] * (0 if agnostic else max_wh)  # classes
    121.             boxes, scores = x[:, :4] + c, x[:, 4]  # boxes (offset by class), scores
    122.             i = torchvision.ops.nms(boxes, scores, iou_thres)  # NMS
    123.             if i.shape[0] > max_det:  # limit detections
    124.                 i = i[:max_det]
    125.             if merge and (1 < n < 3E3):  # Merge NMS (boxes merged using weighted mean)
    126.                 # update boxes as boxes(i,4) = weights(i,n) * boxes(n,4)
    127.                 iou = box_iou(boxes[i], boxes) > iou_thres  # iou matrix
    128.                 weights = iou * scores[None]  # box weights
    129.                 x[i, :4] = torch.mm(weights, x[:, :4]).float() / weights.sum(1, keepdim=True)  # merged boxes
    130.                 if redundant:
    131.                     i = i[iou.sum(1) > 1]  # require redundancy
    132.  
    133.             output[xi] = x[i]
    134.             logits_output[xi] = log_[i]
    135.             assert log_[i].shape[0] == x[i].shape[0]
    136.             if (time.time() - t) > time_limit:
    137.                 print(f'WARNING: NMS time limit {time_limit}s exceeded')
    138.                 break  # time limit exceeded
    139.  
    140.         return output, logits_output
    141.  
    142.     @staticmethod
    143.     def yolo_resize(img, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleFill=False, scaleup=True):
    144.  
    145.         return letterbox(img, new_shape=new_shape, color=color, auto=auto, scaleFill=scaleFill, scaleup=scaleup)
    146.  
    147.     def forward(self, img):
    148.         prediction, logits, _ = self.model(img, augment=False)
    149.         prediction, logits = self.non_max_suppression(prediction, logits, self.confidence, self.iou_thresh,
    150.                                                       classes=None,
    151.                                                       agnostic=self.agnostic)
    152.         self.boxes, self.class_names, self.classes, self.confidences = [[[] for _ in range(img.shape[0])] for _ in
    153.                                                                         range(4)]
    154.         for i, det in enumerate(prediction):  # detections per image
    155.             if len(det):
    156.                 for *xyxy, conf, cls in det:
    157.                     # 返回整数
    158.                     bbox = [int(b) for b in xyxy]
    159.                     self.boxes[i].append(bbox)
    160.                     self.confidences[i].append(round(conf.item(), 2))
    161.                     cls = int(cls.item())
    162.                     self.classes[i].append(cls)
    163.                     if self.names is not None:
    164.                         self.class_names[i].append(self.names[cls])
    165.                     else:
    166.                         self.class_names[i].append(cls)
    167.         return [self.boxes, self.classes, self.class_names, self.confidences], logits
    168.  
    169.     def preprocessing(self, img):
    170.         if len(img.shape) != 4:
    171.             img = np.expand_dims(img, axis=0)
    172.         im0 = img.astype(np.uint8)
    173.         img = np.array([self.yolo_resize(im, new_shape=self.img_size)[0] for im in im0])
    174.         img = img.transpose((0, 3, 1, 2))
    175.         img = np.ascontiguousarray(img)
    176.         img = torch.from_numpy(img).to(self.device)
    177.         img = img / 255.0
    178.         return img

    三、在model文件夹中，添加gradcam.py文件：

    1. import time
    2. import torch
    3. import torch.nn.functional as F
    4.  
    5.  
    6. def find_yolo_layer(model, layer_name):
    7.     """Find yolov5 layer to calculate GradCAM and GradCAM++
    9.     Args:
    10.         model: yolov5 model.
    11.         layer_name (str): the name of layer with its hierarchical information.
    13.     Return:
    14.         target_layer: found layer
    15.     """
    16.     hierarchy = layer_name.split('_')
    17.     target_layer = model.model._modules[hierarchy[0]]
    18.  
    19.     for h in hierarchy[1:]:
    20.         target_layer = target_layer._modules[h]
    21.     return target_layer
    22.  
    23.  
    24. class YOLOV5GradCAM:
    25.     # 初始化，得到target_layer层
    26.     def __init__(self, model, layer_name, img_size=(640, 640)):
    27.         self.model = model
    28.         self.gradients = dict()
    29.         self.activations = dict()
    30.  
    31.         def backward_hook(module, grad_input, grad_output):
    32.             self.gradients['value'] = grad_output[0]
    33.             return None
    34.  
    35.         def forward_hook(module, input, output):
    36.             self.activations['value'] = output
    37.             return None
    38.  
    39.         target_layer = find_yolo_layer(self.model, layer_name)
    40.         # 获取forward过程中每层的输入和输出，用于对比hook是不是正确记录
    41.         target_layer.register_forward_hook(forward_hook)
    42.         target_layer.register_full_backward_hook(backward_hook)
    43.         device = 'cuda' if next(self.model.model.parameters()).is_cuda else 'cpu'
    44.         self.model(torch.zeros(1, 3, *img_size, device=device))
    45.  
    46.     def forward(self, input_img, class_idx=True):
    47.         """
    48.         Args:
    49.             input_img: input image with shape of (1, 3, H, W)
    50.         Return:
    51.             mask: saliency map of the same spatial dimension with input
    52.             logit: model output
    53.             preds: The object predictions
    54.         """
    55.         saliency_maps = []
    56.         b, c, h, w = input_img.size()
    57.         preds, logits = self.model(input_img)
    58.         for logit, cls, cls_name in zip(logits[0], preds[1][0], preds[2][0]):
    59.             if class_idx:
    60.                 score = logit[cls]
    61.             else:
    62.                 score = logit.max()
    63.             self.model.zero_grad()
    64.             tic = time.time()
    65.             # 获取梯度
    66.             score.backward(retain_graph=True)
    67.             print(f"[INFO] {cls_name}, model-backward took: ", round(time.time() - tic, 4), 'seconds')
    68.             gradients = self.gradients['value']
    69.             activations = self.activations['value']
    70.             b, k, u, v = gradients.size()
    71.             alpha = gradients.view(b, k, -1).mean(2)
    72.             weights = alpha.view(b, k, 1, 1)
    73.             saliency_map = (weights * activations).sum(1, keepdim=True)
    74.             saliency_map = F.relu(saliency_map)
    75.             saliency_map = F.interpolate(saliency_map, size=(h, w), mode='bilinear', align_corners=False)
    76.             saliency_map_min, saliency_map_max = saliency_map.min(), saliency_map.max()
    77.             saliency_map = (saliency_map - saliency_map_min).div(saliency_map_max - saliency_map_min).data
    78.             saliency_maps.append(saliency_map)
    79.         return saliency_maps, logits, preds
    80.  
    81.     def __call__(self, input_img):
    82.         return self.forward(input_img)
    83.  
    84.  
    85. class YOLOV5GradCAMPP(YOLOV5GradCAM):
    86.     def __init__(self, model, layer_name, img_size=(640, 640)):
    87.         super(YOLOV5GradCAMPP, self).__init__(model, layer_name, img_size)
    88.  
    89.     def forward(self, input_img, class_idx=True):
    90.         saliency_maps = []
    91.         b, c, h, w = input_img.size()
    92.         tic = time.time()
    93.         preds, logits = self.model(input_img)
    94.         print("[INFO] model-forward took: ", round(time.time() - tic, 4), 'seconds')
    95.         for logit, cls, cls_name in zip(logits[0], preds[1][0], preds[2][0]):
    96.             if class_idx:
    97.                 score = logit[cls]
    98.             else:
    99.                 score = logit.max()
    100.             self.model.zero_grad()
    101.             tic = time.time()
    102.             # 获取梯度
    103.             score.backward(retain_graph=True)
    104.             print(f"[INFO] {cls_name}, model-backward took: ", round(time.time() - tic, 4), 'seconds')
    105.             gradients = self.gradients['value']  # dS/dA
    106.             activations = self.activations['value']  # A
    107.             b, k, u, v = gradients.size()
    108.  
    109.             alpha_num = gradients.pow(2)
    110.             alpha_denom = gradients.pow(2).mul(2) + \
    111.                           activations.mul(gradients.pow(3)).view(b, k, u * v).sum(-1, keepdim=True).view(b, k, 1, 1)
    112.             # torch.where(condition, x, y) condition是条件，满足条件就返回x，不满足就返回y
    113.             alpha_denom = torch.where(alpha_denom != 0.0, alpha_denom, torch.ones_like(alpha_denom))
    114.             alpha = alpha_num.div(alpha_denom + 1e-7)
    115.  
    116.             positive_gradients = F.relu(score.exp() * gradients)  # ReLU(dY/dA) == ReLU(exp(S)*dS/dA))
    117.             weights = (alpha * positive_gradients).view(b, k, u * v).sum(-1).view(b, k, 1, 1)
    118.  
    119.             saliency_map = (weights * activations).sum(1, keepdim=True)
    120.             saliency_map = F.relu(saliency_map)
    121.             saliency_map = F.interpolate(saliency_map, size=(h, w), mode='bilinear', align_corners=False)
    122.             saliency_map_min, saliency_map_max = saliency_map.min(), saliency_map.max()
    123.             saliency_map = (saliency_map - saliency_map_min).div(saliency_map_max - saliency_map_min).data
    124.             saliency_maps.append(saliency_map)
    125.         return saliency_maps, logits, preds

    四、在根目录下新建main_gradcam.py文件 :

    1. import os
    2. import random
    3. import time
    4. import argparse
    5. import numpy as np
    6. from models.gradcam import YOLOV5GradCAM, YOLOV5GradCAMPP
    7. from models.yolov5_object_detector import YOLOV5TorchObjectDetector
    8. import cv2
    9. # 数据集类别名
    10. names = ['person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train', 'truck', 'boat', 'traffic light',
    11.          'fire hydrant', 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',
    12.          'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
    13.          'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat', 'baseball glove', 'skateboard', 'surfboard',
    14.          'tennis racket', 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl', 'banana', 'apple',
    15.          'sandwich', 'orange', 'broccoli', 'carrot', 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
    16.          'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell phone',
    17.          'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase', 'scissors', 'teddy bear',
    18.          'hair drier', 'toothbrush']  # class names
    19. # yolov5s网络中的三个detect层
    20. target_layers = ['model_17_cv3_act', 'model_20_cv3_act', 'model_23_cv3_act']
    21.  
    22. # Arguments
    23. parser = argparse.ArgumentParser()
    24. parser.add_argument('--model-path', type=str, default="weights/yolov5s.pt", help='Path to the model')
    25. parser.add_argument('--img-path', type=str, default='data/images', help='input image path')
    26. parser.add_argument('--output-dir', type=str, default='outputs/', help='output dir')
    27. parser.add_argument('--img-size', type=int, default=640, help="input image size")
    28. parser.add_argument('--target-layer', type=str, default='model_17_cv3_act',
    29.                     help='The layer hierarchical address to which gradcam will applied,'
    30.                          ' the names should be separated by underline')
    31. parser.add_argument('--method', type=str, default='gradcam', help='gradcam method')
    32. parser.add_argument('--device', type=str, default='cpu', help='cuda or cpu')
    33. parser.add_argument('--no_text_box', action='store_true',
    34.                     help='do not show label and box on the heatmap')
    35. args = parser.parse_args()
    36.  
    37.  
    38. def get_res_img(bbox, mask, res_img):
    39.     mask = mask.squeeze(0).mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).detach().cpu().numpy().astype(
    40.         np.uint8)
    41.     heatmap = cv2.applyColorMap(mask, cv2.COLORMAP_JET)
    42.     # n_heatmat = (Box.fill_outer_box(heatmap, bbox) / 255).astype(np.float32)
    43.     n_heatmat = (heatmap / 255).astype(np.float32)
    44.     res_img = res_img / 255
    45.     res_img = cv2.add(res_img, n_heatmat)
    46.     res_img = (res_img / res_img.max())
    47.     return res_img, n_heatmat
    48.  
    49.  
    50. def plot_one_box(x, img, color=None, label=None, line_thickness=3):
    51.     # this is a bug in cv2. It does not put box on a converted image from torch unless it's buffered and read again!
    52.     cv2.imwrite('temp.jpg', (img * 255).astype(np.uint8))
    53.     img = cv2.imread('temp.jpg')
    54.  
    55.     # Plots one bounding box on image img
    56.     tl = line_thickness or round(0.002 * (img.shape[0] + img.shape[1]) / 2) + 1  # line/font thickness
    57.     color = color or [random.randint(0, 255) for _ in range(3)]
    58.     c1, c2 = (int(x[0]), int(x[1])), (int(x[2]), int(x[3]))
    59.     cv2.rectangle(img, c1, c2, color, thickness=tl, lineType=cv2.LINE_AA)
    60.     if label:
    61.         tf = max(tl - 1, 1)  # font thickness
    62.         t_size = cv2.getTextSize(label, 0, fontScale=tl / 3, thickness=tf)[0]
    63.         outside = c1[1] - t_size[1] - 3 >= 0  # label fits outside box up
    64.         c2 = c1[0] + t_size[0], c1[1] - t_size[1] - 3 if outside else c1[1] + t_size[1] + 3
    65.         outsize_right = c2[0] - img.shape[:2][1] > 0  # label fits outside box right
    66.         c1 = c1[0] - (c2[0] - img.shape[:2][1]) if outsize_right else c1[0], c1[1]
    67.         c2 = c2[0] - (c2[0] - img.shape[:2][1]) if outsize_right else c2[0], c2[1]
    68.         cv2.rectangle(img, c1, c2, color, -1, cv2.LINE_AA)  # filled
    69.         cv2.putText(img, label, (c1[0], c1[1] - 2 if outside else c2[1] - 2), 0, tl / 3, [225, 255, 255], thickness=tf,
    70.                     lineType=cv2.LINE_AA)
    71.     return img
    72.  
    73.  
    74. # 检测单个图片
    75. def main(img_path):
    76.     colors = [[random.randint(0, 255) for _ in range(3)] for _ in names]
    77.     device = args.device
    78.     input_size = (args.img_size, args.img_size)
    79.     # 读入图片
    80.     img = cv2.imread(img_path)  # 读取图像格式：BGR
    81.     print('[INFO] Loading the model')
    82.     # 实例化YOLOv5模型，得到检测结果
    83.     model = YOLOV5TorchObjectDetector(args.model_path, device, img_size=input_size, names=names)
    84.     # img[..., ::-1]: BGR --> RGB
    85.     # (480, 640, 3) --> (1, 3, 480, 640)
    86.     torch_img = model.preprocessing(img[..., ::-1])
    87.     tic = time.time()
    88.     # 遍历三层检测层
    89.     for target_layer in target_layers:
    90.         # 获取grad-cam方法
    91.         if args.method == 'gradcam':
    92.             saliency_method = YOLOV5GradCAM(model=model, layer_name=target_layer, img_size=input_size)
    93.         elif args.method == 'gradcampp':
    94.             saliency_method = YOLOV5GradCAMPP(model=model, layer_name=target_layer, img_size=input_size)
    95.         masks, logits, [boxes, _, class_names, conf] = saliency_method(torch_img)  # 得到预测结果
    96.         result = torch_img.squeeze(0).mul(255).add_(0.5).clamp_(0, 255).permute(1, 2, 0).detach().cpu().numpy()
    97.         result = result[..., ::-1]  # convert to bgr
    98.         # 保存设置
    99.         imgae_name = os.path.basename(img_path)  # 获取图片名
    100.         save_path = f'{args.output_dir}{imgae_name[:-4]}/{args.method}'
    101.         if not os.path.exists(save_path):
    102.             os.makedirs(save_path)
    103.         print(f'[INFO] Saving the final image at {save_path}')
    104.         # 遍历每张图片中的每个目标
    105.         for i, mask in enumerate(masks):
    106.             # 遍历图片中的每个目标
    107.             res_img = result.copy()
    108.             # 获取目标的位置和类别信息
    109.             bbox, cls_name = boxes[0][i], class_names[0][i]
    110.             label = f'{cls_name} {conf[0][i]}'  # 类别+置信分数
    111.             # 获取目标的热力图
    112.             res_img, heat_map = get_res_img(bbox, mask, res_img)
    113.             res_img = plot_one_box(bbox, res_img, label=label, color=colors[int(names.index(cls_name))],
    114.                                    line_thickness=3)
    115.             # 缩放到原图片大小
    116.             res_img = cv2.resize(res_img, dsize=(img.shape[:-1][::-1]))
    117.             output_path = f'{save_path}/{target_layer[6:8]}_{i}.jpg'
    118.             cv2.imwrite(output_path, res_img)
    119.             print(f'{target_layer[6:8]}_{i}.jpg done!!')
    120.     print(f'Total time : {round(time.time() - tic, 4)} s')
    121.  
    122.  
    123. if __name__ == '__main__':
    124.     # 图片路径为文件夹
    125.     if os.path.isdir(args.img_path):
    126.         img_list = os.listdir(args.img_path)
    127.         print(img_list)
    128.         for item in img_list:
    129.             # 依次获取文件夹中的图片名，组合成图片的路径
    130.             main(os.path.join(args.img_path, item))
    131.     # 单个图片
    132.     else:
    133.         main(args.img_path)

    五、使用介绍

    1、更改main_gradcam.py文件中的类别

    2、更改model-path和img-path路径

    3、运行main_gradcam.py文件，结果如下

     

    4、如果不想要显示坐标框，可以将main_gradcam.py文件中的下面这段代码注释掉

     

    Appendix

    如果以上报错，即为torch版本不对，升级为1.8.0以上就可

    也可以将gradcam.py文件中的register_full_backward_hook换成register_backward_hook

    reference

    【YOLOv5】结合GradCAM热力图可视化_嗜睡的篠龙的博客-CSDN博客_yolov5 热力图icon-default.png?t=M7J4https://blog.csdn.net/weixin_43799388/article/details/126207632?spm=1001.2014.3001.5502

     

  • 相关阅读:
    基于R语言地理加权回归、主成份分析、判别分析等空间异质性数据分析
    Springboot 拦截器，拦截所有请求，判断是否登录，验证权限
    SpringCloud - Spring Cloud Alibaba 之 SkyWalking 分布式链路跟踪；SkyWalking集群（十七）
    惊讶，CRUD搬砖两三年了，不会阅读Spring源码？
    2023秋招面经记录
    机器学习之客户违约预测模型搭建之案例实战
    prometheus初窥
    04 jenkins中使用各种变量（Powershell、cmd）
    如何处理 Angular 单页面应用里的 a 标签，避免点击后重新加载整个应用
    高性能零售IT系统的建设06-当应对大量HTTP请求时兼顾性能、处理速度的架构设计
  • 原文地址：https://blog.csdn.net/m0_56247038/article/details/126677066