YOLOV8改进：soft-nms、DIOU-nms、SIOU-nms、EIOU-nms、WIOU-nms

news2024/11/15 21:41:39

1.nms介绍

1.1 nms

NMS（Non-Maximum Suppression，非极大值抑制）是一种常用的目标检测算法，用于抑制冗余的边界框，保留最具代表性的目标框。

在目标检测任务中，通常会生成多个候选边界框（bounding box），每个边界框都对应着一个可能的目标。然而，由于图像中可能存在多个重叠的边界框，为了提取出最准确的目标框，需要使用NMS来进行筛选。

NMS的基本原理如下：

  1. 首先，根据目标框的置信度（或者其他评分指标），按照降序排列所有的候选框。
  2. 选择具有最高置信度的框，并将其添加到最终输出的结果列表中。
  3. 对于剩余的候选框，计算它们与已选框之间的重叠区域的面积（例如，使用交并比IoU）。
  4. 如果某个候选框与已选框的重叠面积大于设定的阈值（通常为0.5），则将该候选框舍弃；否则，将其添加到最终输出的结果列表中。
  5. 重复步骤3和步骤4，直到处理完所有的候选框。
  6. 得到最终的输出结果列表，其中包含经过非极大值抑制筛选后的目标框。

通过使用NMS，能够有效地减少冗余的目标框，只保留最具代表性的目标框，提高目标检测的准确性和效率。NMS在各种目标检测算法中都得到了广泛应用，如Faster R-CNN、YOLO等

1.2 Soft-NMS   

Soft-NMS（Soft Non-Maximum Suppression，软性非极大值抑制）是一种改进的目标检测算法，用于在NMS过程中更加平滑地抑制冗余的边界框。

传统的NMS方法是通过设置一个固定的阈值来判断两个边界框是否重叠并进行抑制。然而，由于固定的阈值可能无法很好地适应不同目标之间的交叠情况，导致一些具有较低置信度但与真实目标高度重叠的候选框被错误地排除。     

Soft-NMS通过引入一个衰减函数来解决这个问题，将重叠区域的置信度进行衰减，而不是直接舍弃。其基本步骤如下：

  1. 首先，根据目标框的置信度（或其他评分指标），按降序对所有候选框进行排序。
  2. 选择具有最高置信度的框，并将其添加到最终输出的结果列表中。
  3. 对于剩余的候选框，计算它们与已选框之间的重叠区域的面积（例如，使用交并比IoU）。
  4. 根据计算得到的重叠面积和预设的衰减函数，对该候选框的置信度进行衰减。
  5. 如果衰减后的置信度低于一定阈值，将该候选框舍弃；否则，将其保留并添加到最终输出结果列表中。
  6. 重复步骤3到步骤5，直到处理完所有候选框。
  7. 得到最终的输出结果列表，其中包含经过软性非极大值抑制筛选后的目标框。

通过引入衰减函数，Soft-NMS可以更加灵活地调整候选框的权重，对于与已选择框高度重叠但置信度较低的候选框，仍有机会被保留下来，从而提高目标检测的准确性。Soft-NMS在一些目标检测算法中得到了广泛应用，如Faster R-CNN、YOLO等。

2. yolov8改进添加soft-nms

首先需要修改损失函数部分

在ultralytics/yolo/utils/metrics.py，加入以下代码：

class WIoU_Scale:
    ''' monotonous: {
            None: origin v1
            True: monotonic FM v2
            False: non-monotonic FM v3
        }
        momentum: The momentum of running mean'''
    
    iou_mean = 1.
    monotonous = False
    _momentum = 1 - 0.5 ** (1 / 7000)
    _is_train = True
 
    def __init__(self, iou):
        self.iou = iou
        self._update(self)
    
    @classmethod
    def _update(cls, self):
        if cls._is_train: cls.iou_mean = (1 - cls._momentum) * cls.iou_mean + \
                                         cls._momentum * self.iou.detach().mean().item()
    
    @classmethod
    def _scaled_loss(cls, self, gamma=1.9, delta=3):
        if isinstance(self.monotonous, bool):
            if self.monotonous:
                return (self.iou.detach() / self.iou_mean).sqrt()
            else:
                beta = self.iou.detach() / self.iou_mean
                alpha = delta * torch.pow(gamma, beta - delta)
                return beta / alpha
        return 1
    
 
def bbox_iou(box1, box2, xywh=True, GIoU=False, DIoU=False, CIoU=False, SIoU=False, EIoU=False, WIoU=False, Focal=False, alpha=1, gamma=0.5, scale=False, eps=1e-7):
    # Returns Intersection over Union (IoU) of box1(1,4) to box2(n,4)
 
    # Get the coordinates of bounding boxes
    if xywh:  # transform from xywh to xyxy
        (x1, y1, w1, h1), (x2, y2, w2, h2) = box1.chunk(4, -1), box2.chunk(4, -1)
        w1_, h1_, w2_, h2_ = w1 / 2, h1 / 2, w2 / 2, h2 / 2
        b1_x1, b1_x2, b1_y1, b1_y2 = x1 - w1_, x1 + w1_, y1 - h1_, y1 + h1_
        b2_x1, b2_x2, b2_y1, b2_y2 = x2 - w2_, x2 + w2_, y2 - h2_, y2 + h2_
    else:  # x1, y1, x2, y2 = box1
        b1_x1, b1_y1, b1_x2, b1_y2 = box1.chunk(4, -1)
        b2_x1, b2_y1, b2_x2, b2_y2 = box2.chunk(4, -1)
        w1, h1 = b1_x2 - b1_x1, (b1_y2 - b1_y1).clamp(eps)
        w2, h2 = b2_x2 - b2_x1, (b2_y2 - b2_y1).clamp(eps)
 
    # Intersection area
    inter = (b1_x2.minimum(b2_x2) - b1_x1.maximum(b2_x1)).clamp(0) * \
            (b1_y2.minimum(b2_y2) - b1_y1.maximum(b2_y1)).clamp(0)
 
    # Union Area
    union = w1 * h1 + w2 * h2 - inter + eps
    if scale:
        self = WIoU_Scale(1 - (inter / union))
 
    # IoU
    # iou = inter / union # ori iou
    iou = torch.pow(inter/(union + eps), alpha) # alpha iou
    if CIoU or DIoU or GIoU or EIoU or SIoU or WIoU:
        cw = b1_x2.maximum(b2_x2) - b1_x1.minimum(b2_x1)  # convex (smallest enclosing box) width
        ch = b1_y2.maximum(b2_y2) - b1_y1.minimum(b2_y1)  # convex height
        if CIoU or DIoU or EIoU or SIoU or WIoU:  # Distance or Complete IoU https://arxiv.org/abs/1911.08287v1
            c2 = (cw ** 2 + ch ** 2) ** alpha + eps  # convex diagonal squared
            rho2 = (((b2_x1 + b2_x2 - b1_x1 - b1_x2) ** 2 + (b2_y1 + b2_y2 - b1_y1 - b1_y2) ** 2) / 4) ** alpha  # center dist ** 2
            if CIoU:  # https://github.com/Zzh-tju/DIoU-SSD-pytorch/blob/master/utils/box/box_utils.py#L47
                v = (4 / math.pi ** 2) * (torch.atan(w2 / h2) - torch.atan(w1 / h1)).pow(2)
                with torch.no_grad():
                    alpha_ciou = v / (v - iou + (1 + eps))
                if Focal:
                    return iou - (rho2 / c2 + torch.pow(v * alpha_ciou + eps, alpha)), torch.pow(inter/(union + eps), gamma)  # Focal_CIoU
                else:
                    return iou - (rho2 / c2 + torch.pow(v * alpha_ciou + eps, alpha))  # CIoU
            elif EIoU:
                rho_w2 = ((b2_x2 - b2_x1) - (b1_x2 - b1_x1)) ** 2
                rho_h2 = ((b2_y2 - b2_y1) - (b1_y2 - b1_y1)) ** 2
                cw2 = torch.pow(cw ** 2 + eps, alpha)
                ch2 = torch.pow(ch ** 2 + eps, alpha)
                if Focal:
                    return iou - (rho2 / c2 + rho_w2 / cw2 + rho_h2 / ch2), torch.pow(inter/(union + eps), gamma) # Focal_EIou
                else:
                    return iou - (rho2 / c2 + rho_w2 / cw2 + rho_h2 / ch2) # EIou
            elif SIoU:
                # SIoU Loss https://arxiv.org/pdf/2205.12740.pdf
                s_cw = (b2_x1 + b2_x2 - b1_x1 - b1_x2) * 0.5 + eps
                s_ch = (b2_y1 + b2_y2 - b1_y1 - b1_y2) * 0.5 + eps
                sigma = torch.pow(s_cw ** 2 + s_ch ** 2, 0.5)
                sin_alpha_1 = torch.abs(s_cw) / sigma
                sin_alpha_2 = torch.abs(s_ch) / sigma
                threshold = pow(2, 0.5) / 2
                sin_alpha = torch.where(sin_alpha_1 > threshold, sin_alpha_2, sin_alpha_1)
                angle_cost = torch.cos(torch.arcsin(sin_alpha) * 2 - math.pi / 2)
                rho_x = (s_cw / cw) ** 2
                rho_y = (s_ch / ch) ** 2
                gamma = angle_cost - 2
                distance_cost = 2 - torch.exp(gamma * rho_x) - torch.exp(gamma * rho_y)
                omiga_w = torch.abs(w1 - w2) / torch.max(w1, w2)
                omiga_h = torch.abs(h1 - h2) / torch.max(h1, h2)
                shape_cost = torch.pow(1 - torch.exp(-1 * omiga_w), 4) + torch.pow(1 - torch.exp(-1 * omiga_h), 4)
                if Focal:
                    return iou - torch.pow(0.5 * (distance_cost + shape_cost) + eps, alpha), torch.pow(inter/(union + eps), gamma) # Focal_SIou
                else:
                    return iou - torch.pow(0.5 * (distance_cost + shape_cost) + eps, alpha) # SIou
            elif WIoU:
                if Focal:
                    raise RuntimeError("WIoU do not support Focal.")
                elif scale:
                    return getattr(WIoU_Scale, '_scaled_loss')(self), (1 - iou) * torch.exp((rho2 / c2)), iou # WIoU https://arxiv.org/abs/2301.10051
                else:
                    return iou, torch.exp((rho2 / c2)) # WIoU v1
            if Focal:
                return iou - rho2 / c2, torch.pow(inter/(union + eps), gamma)  # Focal_DIoU
            else:
                return iou - rho2 / c2  # DIoU
        c_area = cw * ch + eps  # convex area
        if Focal:
            return iou - torch.pow((c_area - union) / c_area + eps, alpha), torch.pow(inter/(union + eps), gamma)  # Focal_GIoU https://arxiv.org/pdf/1902.09630.pdf
        else:
            return iou - torch.pow((c_area - union) / c_area + eps, alpha)  # GIoU https://arxiv.org/pdf/1902.09630.pdf
    if Focal:
        return iou, torch.pow(inter/(union + eps), gamma)  # Focal_IoU
    else:
        return iou  # IoU

2.1、同样需要在ultralytics/yolo/utils/metrics.py，加入以下代码：

def bbox_iou_for_nms(box1, box2, xywh=True, GIoU=False, DIoU=False, CIoU=False, SIoU=False, EIoU=False, WIoU=False, Focal=False, alpha=1, gamma=0.5, scale=False, eps=1e-7):
    # Returns Intersection over Union (IoU) of box1(1,4) to box2(n,4)
 
    # Get the coordinates of bounding boxes
    if xywh:  # transform from xywh to xyxy
        (x1, y1, w1, h1), (x2, y2, w2, h2) = box1.chunk(4, -1), box2.chunk(4, -1)
        w1_, h1_, w2_, h2_ = w1 / 2, h1 / 2, w2 / 2, h2 / 2
        b1_x1, b1_x2, b1_y1, b1_y2 = x1 - w1_, x1 + w1_, y1 - h1_, y1 + h1_
        b2_x1, b2_x2, b2_y1, b2_y2 = x2 - w2_, x2 + w2_, y2 - h2_, y2 + h2_
    else:  # x1, y1, x2, y2 = box1
        b1_x1, b1_y1, b1_x2, b1_y2 = box1.chunk(4, -1)
        b2_x1, b2_y1, b2_x2, b2_y2 = box2.chunk(4, -1)
        w1, h1 = b1_x2 - b1_x1, (b1_y2 - b1_y1).clamp(eps)
        w2, h2 = b2_x2 - b2_x1, (b2_y2 - b2_y1).clamp(eps)
 
    # Intersection area
    inter = (b1_x2.minimum(b2_x2) - b1_x1.maximum(b2_x1)).clamp(0) * \
            (b1_y2.minimum(b2_y2) - b1_y1.maximum(b2_y1)).clamp(0)
 
    # Union Area
    union = w1 * h1 + w2 * h2 - inter + eps
    if scale:
        self = WIoU_Scale(1 - (inter / union))
 
    # IoU
    # iou = inter / union # ori iou
    iou = torch.pow(inter/(union + eps), alpha) # alpha iou
    if CIoU or DIoU or GIoU or EIoU or SIoU or WIoU:
        cw = b1_x2.maximum(b2_x2) - b1_x1.minimum(b2_x1)  # convex (smallest enclosing box) width
        ch = b1_y2.maximum(b2_y2) - b1_y1.minimum(b2_y1)  # convex height
        if CIoU or DIoU or EIoU or SIoU or WIoU:  # Distance or Complete IoU https://arxiv.org/abs/1911.08287v1
            c2 = (cw ** 2 + ch ** 2) ** alpha + eps  # convex diagonal squared
            rho2 = (((b2_x1 + b2_x2 - b1_x1 - b1_x2) ** 2 + (b2_y1 + b2_y2 - b1_y1 - b1_y2) ** 2) / 4) ** alpha  # center dist ** 2
            if CIoU:  # https://github.com/Zzh-tju/DIoU-SSD-pytorch/blob/master/utils/box/box_utils.py#L47
                v = (4 / math.pi ** 2) * (torch.atan(w2 / h2) - torch.atan(w1 / h1)).pow(2)
                with torch.no_grad():
                    alpha_ciou = v / (v - iou + (1 + eps))
                if Focal:
                    return iou - (rho2 / c2 + torch.pow(v * alpha_ciou + eps, alpha)), torch.pow(inter/(union + eps), gamma)  # Focal_CIoU
                else:
                    return iou - (rho2 / c2 + torch.pow(v * alpha_ciou + eps, alpha))  # CIoU
            elif EIoU:
                rho_w2 = ((b2_x2 - b2_x1) - (b1_x2 - b1_x1)) ** 2
                rho_h2 = ((b2_y2 - b2_y1) - (b1_y2 - b1_y1)) ** 2
                cw2 = torch.pow(cw ** 2 + eps, alpha)
                ch2 = torch.pow(ch ** 2 + eps, alpha)
                if Focal:
                    return iou - (rho2 / c2 + rho_w2 / cw2 + rho_h2 / ch2), torch.pow(inter/(union + eps), gamma) # Focal_EIou
                else:
                    return iou - (rho2 / c2 + rho_w2 / cw2 + rho_h2 / ch2) # EIou
            elif SIoU:
                # SIoU Loss https://arxiv.org/pdf/2205.12740.pdf
                s_cw = (b2_x1 + b2_x2 - b1_x1 - b1_x2) * 0.5 + eps
                s_ch = (b2_y1 + b2_y2 - b1_y1 - b1_y2) * 0.5 + eps
                sigma = torch.pow(s_cw ** 2 + s_ch ** 2, 0.5)
                sin_alpha_1 = torch.abs(s_cw) / sigma
                sin_alpha_2 = torch.abs(s_ch) / sigma
                threshold = pow(2, 0.5) / 2
                sin_alpha = torch.where(sin_alpha_1 > threshold, sin_alpha_2, sin_alpha_1)
                angle_cost = torch.cos(torch.arcsin(sin_alpha) * 2 - math.pi / 2)
                rho_x = (s_cw / cw) ** 2
                rho_y = (s_ch / ch) ** 2
                gamma = angle_cost - 2
                distance_cost = 2 - torch.exp(gamma * rho_x) - torch.exp(gamma * rho_y)
                omiga_w = torch.abs(w1 - w2) / torch.max(w1, w2)
                omiga_h = torch.abs(h1 - h2) / torch.max(h1, h2)
                shape_cost = torch.pow(1 - torch.exp(-1 * omiga_w), 4) + torch.pow(1 - torch.exp(-1 * omiga_h), 4)
                if Focal:
                    return iou - torch.pow(0.5 * (distance_cost + shape_cost) + eps, alpha), torch.pow(inter/(union + eps), gamma) # Focal_SIou
                else:
                    return iou - torch.pow(0.5 * (distance_cost + shape_cost) + eps, alpha) # SIou
            elif WIoU:
                if Focal:
                    raise RuntimeError("WIoU do not support Focal.")
                elif scale:
                    return getattr(WIoU_Scale, '_scaled_loss')(self), (1 - iou) * torch.exp((rho2 / c2)), iou # WIoU https://arxiv.org/abs/2301.10051
                else:
                    return iou, torch.exp((rho2 / c2)) # WIoU v1
            if Focal:
                return iou - rho2 / c2, torch.pow(inter/(union + eps), gamma)  # Focal_DIoU
            else:
                return iou - rho2 / c2  # DIoU
        c_area = cw * ch + eps  # convex area
        if Focal:
            return iou - torch.pow((c_area - union) / c_area + eps, alpha), torch.pow(inter/(union + eps), gamma)  # Focal_GIoU https://arxiv.org/pdf/1902.09630.pdf
        else:
            return iou - torch.pow((c_area - union) / c_area + eps, alpha)  # GIoU https://arxiv.org/pdf/1902.09630.pdf
    if Focal:
        return iou, torch.pow(inter/(union + eps), gamma)  # Focal_IoU
    else:
        return iou  # IoU
 
def soft_nms(bboxes, scores, iou_thresh=0.5,sigma=0.5,score_threshold=0.25):
    order = torch.arange(0, scores.size(0)).to(bboxes.device)
    keep = []
    
    while order.numel() > 1:
        if order.numel() == 1:
            keep.append(order[0])
            break
        else:
            i = order[0]
            keep.append(i)
        
        iou = bbox_iou_for_nms(bboxes[i], bboxes[order[1:]]).squeeze()
        
        idx = (iou > iou_thresh).nonzero().squeeze()
        if idx.numel() > 0: 
            iou = iou[idx] 
            newScores = torch.exp(-torch.pow(iou,2)/sigma)
            scores[order[idx+1]] *= newScores
        
        newOrder = (scores[order[1:]] > score_threshold).nonzero().squeeze() 
        if newOrder.numel() == 0: 
            break
        else:
            maxScoreIndex = torch.argmax(scores[order[newOrder+1]]) 
            if maxScoreIndex != 0: 
                newOrder[[0,maxScoreIndex],] = newOrder[[maxScoreIndex,0],]
            order = order[newOrder+1]
    
    return torch.LongTensor(keep)

2.2 在ultralytics/yolo/utils/ops.py中找到 non_max_suppression 函数，

把原torchvision.ops.nms替换。

注意：在ops.py需要导入soft-nms

from .metrics import box_iou,soft_nms

原torchvision.ops.nms为：
 

i = torchvision.ops.nms(boxes, scores, iou_thres)  # NMS

替换：

i = soft_nms(boxes, scores, iou_thres)

 2.3、soft-nms和其他损失函数搭配使用

只需要在soft-nms函数的iou增加需要的损失函数并且设置为True，例如：以下是添加EIoU，也可以添加其他IoU

iou = bbox_iou_for_nms(bboxes[i], bboxes[order[1:]], EIoU=True).squeeze()

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1079079.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

基于SSM的网络安全宣传网站设计与实现

基于SSM的网络安全宣传网站设计与实现

末尾获取源码 开发语言：Java Java开发工具：JDK1.8 后端框架：SSM 前端：采用JSP技术开发 数据库：MySQL5.7和Navicat管理工具结合 服务器：Tomcat8.5 开发软件：IDEA / Eclipse 是否Maven项目&#x…
阅读更多...
立即提升吃鸡战斗力！分享顶级游戏干货！

立即提升吃鸡战斗力！分享顶级游戏干货！

各位吃鸡玩家，您好！在这里，我将与您分享一些提高游戏战斗力的实用技巧，同时带您体验顶级游戏作战干货！ 首先，我向您推荐绝地求生作图工具。通过使用这些强大的作图工具，您可以轻松编辑出炫酷的吃…
阅读更多...
华为OD机考算法题：字符串划分

华为OD机考算法题：字符串划分

题目部分 题目字符串划分难度难题目说明给定一个小写字母组成的字符串s，请找出字符串中两个不同位置的字符作为分割点，使得字符串分成的三个连续子串且子串权重相等，注意子串不包含分割点。 若能找到满足条件的两个分割点，请输出…
阅读更多...
bert----学习笔记

bert----学习笔记

一个简单基础模板： bert导入，分词，编码 from transformers import BertConfig, BertTokenizer, BertModel import torch from transformers import BertModel, BertTokenizer # 指定模型文件夹路径（包含 pytorch_model.bin&#…
阅读更多...
面面俱到：揭秘吃鸡新手最关心的要领和细节，全方位指引你成为绝地求生高手！

面面俱到：揭秘吃鸡新手最关心的要领和细节，全方位指引你成为绝地求生高手！

你是否正在探索绝地求生的神秘世界，却感到迷茫和困惑？想要掌握吃鸡的要领和细节，成为一名顶尖玩家吗？现在，我们将为你揭秘吃鸡新手最关心的要领和细节，带你全面了解这个充满挑战的游戏。无论是如何选择起跳…
阅读更多...
摆脱繁杂工作：Appwrite 带你高效开发 | 开源日报 No.50

摆脱繁杂工作：Appwrite 带你高效开发 | 开源日报 No.50

TheAlgorithms/Java Stars: 53.8k License: MIT 这个项目是一个用 Java 实现的算法集合，旨在提供学习目的。它包含了各种不同类型的算法，并且可以通过 Gitpod.io 进行运行、编辑和贡献。该项目具有以下核心优势： 提供了大量常见算法及其实…
阅读更多...
澳大利亚教育部宣布ChatGPT将被允许在澳学校使用！

澳大利亚教育部宣布ChatGPT将被允许在澳学校使用！

教育部长最近宣布，从 2024 年起，包括 ChatGPT 在内的人工智能将被允许在所有澳大利亚学校使用。 （图片来源：卫报） 而早些时候，澳洲各高校就已经在寻找与Chatgpt之间的平衡了。 之前，悉尼大学就…
阅读更多...
微服务10-Sentinel中的隔离和降级

微服务10-Sentinel中的隔离和降级

文章目录 降级和隔离1.Feign整合Sentinel来完成降级1.2总结 2.线程隔离两种实现方式的区别3.线程隔离中的舱壁模式3.2总结 4.熔断降级5.熔断策略（根据异常比例或者异常数） 回顾 我们的限流——>目的：在并发请求的情况下服务出现故障&…
阅读更多...
2023年软考网工上半年下午真题

2023年软考网工上半年下午真题

试题一： 阅读以下说明，回答问题1至问题4，将解答填入答题纸对应的解答栏内。 [说明] 某企业办公楼网络拓扑如图1-1所示。该网络中交换机Switch1-Switch 4均是二层设备，分布在办公楼的各层，上联采用干兆光纤。核心交换…
阅读更多...
前端 vite+vue3——写一个随机抽奖组件

前端 vite+vue3——写一个随机抽奖组件

文章目录 ⭐前言⭐设计布局⭐交互设计⭐整体代码⭐insicode代码 ⭐总结⭐结束 ⭐前言 大家好，我是yma16，本文分享关于前端 vitevue3——写一个抽奖随机组件。 vue3系列相关文章： 前端vue2、vue3去掉url路由“ # ”号——nginx配置 csdn新星计…
阅读更多...
FHRP首跳冗余的解析

FHRP首跳冗余的解析

首跳冗余的解析 个人简介 HSRP hot standby router protocol 热备份路由协议 思科设备上 HSRP VRRP 华为设备上 VRRP HSRP v1 version 1 HSRP v2 version 2 虚拟一个HSRP虚拟IP地址 192.168.1.1 开启HSRP的抢占功能 通过其他参数 人为调整谁是主 谁是从 &a…
阅读更多...
入门C++程序员需要怎么下手？

入门C++程序员需要怎么下手？

前言 众所周知，C是一种非常流行的编程语言，它广泛应用于计算机科学和软件开发中，无论是计算机专业的学生还是自学编程的程序员，学习C都是一个必备的技能。那么，如果想成为一名C程序员，学习C需要多久才能入门…
阅读更多...
Vuex获取、修改参数值及异步数据处理

Vuex获取、修改参数值及异步数据处理

14天阅读挑战赛 学不可以已... 目录 一、Vuex简介 1.1 vuex介绍 1.2 vuex核心 二、Vuex使用 2.1 Vuex安装 2.2 创建store模块 2.3 创建vuex的store实例并注册上面引入的各大模块 三、使用Vuex获取、修改值案例 3.1 创建两个菜单组件 3.2 配置路由 3.3 模拟菜单数据 …
阅读更多...
设计模式 - 行为型模式考点篇：迭代器模式（概述 | 案例实现 | 优缺点 | 使用场景）

设计模式 - 行为型模式考点篇：迭代器模式（概述 | 案例实现 | 优缺点 | 使用场景）

目录 一、行为型模式 一句话概括行为型模式 1.1、迭代器模式 1.1.1、概述 1.1.2、案例实现 1.1.3、优缺点 1.1.4、使用场景 一、行为型模式 一句话概括行为型模式 行为型模式：类或对象间如何交互、如何划分职责，从而更好的完成任务. 1.1、迭代器…
阅读更多...
ruoyi 若依 前端vue npm install 运行vue前端

ruoyi 若依 前端vue npm install 运行vue前端

首次导入，需要先执行 npm install #进入到前端模块目录下 cd ruoyi-ui # 安装 npm install 启动后端项目 运行前端项目：运行成功后，会浏览器自动加载到前端首页（或者 浏览器访问打印的两个地址） # 运行 npm run dev 部…
阅读更多...
[sqoop]hive导入mysql,其中mysql的列存在默认值列

[sqoop]hive导入mysql,其中mysql的列存在默认值列

一、思路 直接在hive表中去掉有默认值的了列，在sqoop导入时,指定非默认值列即可， 二、具体 mysql的表 hive的表 create table dwd.dwd_hk_rcp_literature(id string,literature_no string,authors string,article_title string,source_title string…
阅读更多...
【MySql】6- 实践篇(四)

【MySql】6- 实践篇(四)

文章目录 1. 为何SQL语句逻辑相同，性能却差异巨大1.1 性能差异大的SQL语句问题1.1.1 案例一:条件字段函数操作1.1.2 案例二:隐式类型转换1.1.3 案例三:隐式字符编码转换 2. 为何只查询一行的SQL执行很慢2.1 场景一:查询长时间不返回2.1.1 等MDL锁2.1.2 等 flush2.1.…
阅读更多...
vscode远程ssh服务器且更改服务器别名

vscode远程ssh服务器且更改服务器别名

目录 1、打开VS Code并确保已安装"Remote - SSH"扩展。如果尚未安装，请在扩展市场中搜索并安装它。 2、单击左下角的"Remote Explorer"图标，打开远程资源管理器。 3、在远程资源管理器中，单击右上角的齿轮图标&#x…
阅读更多...
区块链在游戏行业的应用

区块链在游戏行业的应用

区块链技术在游戏行业有许多潜在的应用，它可以改变游戏开发、发行和玩家交互的方式。以下是区块链技术在游戏行业的一些主要应用，希望对大家有所帮助。北京木奇移动技术有限公司，专业的软件外包开发公司，欢迎交流合作。 1.游戏资产…
阅读更多...
《Node.js 学习笔记 之 切换node版本》

《Node.js 学习笔记 之 切换node版本》

目录 Node.js 学习笔记nvm第一步安装 nvm 常用命令遇到的问题 Node.js 学习笔记 个人博客地址： 使用npm 命令经常遇到npm 与node.js 版本不兼容报错的情况，下面通过nvm 版本管理工具解决问题 nvm node.js version management 通过它可以安装和切换不同版…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023