经典目标检测YOLO系列(二)YOLOV2的复现(1)总体网络架构及前向推理过程

经典目标检测YOLO系列(二)YOLOV2的复现(1)总体网络架构及前向推理过程

和之前实现的YOLOv1一样，根据《YOLO目标检测》(ISBN:9787115627094)一书，在不脱离YOLOv2的大部分核心理念的前提下，重构一款较新的YOLOv2检测器，来对YOLOV2有更加深刻的认识。

书中源码连接: RT-ODLab: YOLO Tutorial

对比原始YOLOV2网络，主要改进点如下：

  • 添加了后续YOLO中使用的neck，即SPPF模块

  • 使用普遍用在RetinaNet、FCOS、YOLOX等通用目标检测网络中的解耦检测头（Decoupled head）

  • 修改损失函数，分类分支替换为BCE loss，回归分支替换为GIou loss。

  • 由基于边界框的正样本匹配策略，改为基于先验框的正样本匹配策略。

对比之前实现的YOLOV1网络，主要改进点：

  • 主干网络由ResNet18改为DarkNet19

  • 添加先验框机制

  • 正样本匹配策略改为：基于先验框的正样本匹配策略

  • YOLOv2代码和之前实现的YOLOv1相比，修改之处不多，建议先看之前实现的YOLOv1的相关文章。

1、YOLOv2网络架构

1.1 DarkNet19主干网络

  • 使用原版YOLOv2中提出的DarkNet19作为主干网络(backbone)。
  • 不同于分类网络，我们去掉网络中的平均池化层以及分类层。DarkNet19网络的下采样倍数为32，一张图片(416×416×3)经过主干网络，得到13×13×1024的特征图。
  • 根据官方的做法，DarkNet19需要现在ImageNet数据集上进行预训练。不过，作者提供了DarkNet19在ImageNet数据集上的预训练权重，因此，我们只需要直接加载即可。
  • 这里我们不去实现原版YOLOv2中的passthrough层，仅仅输出一个尺度，即c5层。

在这里插入图片描述

# RT-ODLab/models/detectors/yolov2/yolov2_backbone.pyimport torch
import torch.nn as nnmodel_urls = {"darknet19": "https://github.com/yjh0410/image_classification_pytorch/releases/download/weight/darknet19.pth",
}__all__ = ['DarkNet19']# --------------------- Basic Module -----------------------
class Conv_BN_LeakyReLU(nn.Module):def __init__(self, in_channels, out_channels, ksize, padding=0, stride=1, dilation=1):super(Conv_BN_LeakyReLU, self).__init__()self.convs = nn.Sequential(nn.Conv2d(in_channels, out_channels, ksize, padding=padding, stride=stride, dilation=dilation),nn.BatchNorm2d(out_channels),nn.LeakyReLU(0.1, inplace=True))def forward(self, x):return self.convs(x)# --------------------- DarkNet-19 -----------------------
class DarkNet19(nn.Module):def __init__(self):super(DarkNet19, self).__init__()# backbone network : DarkNet-19# output : stride = 2, c = 32self.conv_1 = nn.Sequential(Conv_BN_LeakyReLU(3, 32, 3, 1),nn.MaxPool2d((2,2), 2),)# output : stride = 4, c = 64self.conv_2 = nn.Sequential(Conv_BN_LeakyReLU(32, 64, 3, 1),nn.MaxPool2d((2,2), 2))# output : stride = 8, c = 128self.conv_3 = nn.Sequential(Conv_BN_LeakyReLU(64, 128, 3, 1),Conv_BN_LeakyReLU(128, 64, 1),Conv_BN_LeakyReLU(64, 128, 3, 1),nn.MaxPool2d((2,2), 2))# output : stride = 8, c = 256self.conv_4 = nn.Sequential(Conv_BN_LeakyReLU(128, 256, 3, 1),Conv_BN_LeakyReLU(256, 128, 1),Conv_BN_LeakyReLU(128, 256, 3, 1),)# output : stride = 16, c = 512self.maxpool_4 = nn.MaxPool2d((2, 2), 2)self.conv_5 = nn.Sequential(Conv_BN_LeakyReLU(256, 512, 3, 1),Conv_BN_LeakyReLU(512, 256, 1),Conv_BN_LeakyReLU(256, 512, 3, 1),Conv_BN_LeakyReLU(512, 256, 1),Conv_BN_LeakyReLU(256, 512, 3, 1),)# output : stride = 32, c = 1024self.maxpool_5 = nn.MaxPool2d((2, 2), 2)self.conv_6 = nn.Sequential(Conv_BN_LeakyReLU(512, 1024, 3, 1),Conv_BN_LeakyReLU(1024, 512, 1),Conv_BN_LeakyReLU(512, 1024, 3, 1),Conv_BN_LeakyReLU(1024, 512, 1),Conv_BN_LeakyReLU(512, 1024, 3, 1))def forward(self, x):c1 = self.conv_1(x)                    # c1c2 = self.conv_2(c1)                   # c2c3 = self.conv_3(c2)                   # c3c3 = self.conv_4(c3)                   # c3c4 = self.conv_5(self.maxpool_4(c3))   # c4c5 = self.conv_6(self.maxpool_5(c4))   # c5return c5# --------------------- Fsnctions -----------------------
def build_backbone(model_name='darknet19', pretrained=False):if model_name == 'darknet19':# modelmodel = DarkNet19()feat_dim = 1024# load weightif pretrained:print('Loading pretrained weight ...')url = model_urls['darknet19']# checkpoint state dictcheckpoint_state_dict = torch.hub.load_state_dict_from_url(url=url, map_location="cpu", check_hash=True)# model state dictmodel_state_dict = model.state_dict()# checkfor k in list(checkpoint_state_dict.keys()):if k in model_state_dict:shape_model = tuple(model_state_dict[k].shape)shape_checkpoint = tuple(checkpoint_state_dict[k].shape)if shape_model != shape_checkpoint:checkpoint_state_dict.pop(k)else:checkpoint_state_dict.pop(k)print(k)model.load_state_dict(checkpoint_state_dict)return model, feat_dimif __name__ == '__main__':import timemodel, feat_dim = build_backbone(pretrained=True)x = torch.randn(1, 3, 416, 416)t0 = time.time()for layer in model.children():x = layer(x)print(layer.__class__.__name__, 'output shape:', x.shape)# y = model(x)t1 = time.time()print('Time: ', t1 - t0)

1.2 添加neck

  • 和之前实现的YOLOv1一致，选择YOLOV5版本中所用的SPPF模块。
  • 代码在RT-ODLab/models/detectors/yolov2/yolov2_neck.py文件中，不在赘述。

在这里插入图片描述

1.3 Detection Head网络

  • 和之前实现的YOLOv1一致，即使用解耦检测头（Decoupled head）。
  • 代码在RT-ODLab/models/detectors/yolov2/yolov1_head.py文件中，不在赘述。

在这里插入图片描述

1.4 预测层

  • 如下图，由于预测层多了先验框，因此预测层的输出通道的数量略有变化。

在这里插入图片描述

        ## 预测层# 与YoloV1相比，YoloV2每个网格会预测5个框(VOC数据集)，因此需×5self.obj_pred = nn.Conv2d(head_dim, 1 * self.num_anchors, kernel_size=1)self.cls_pred = nn.Conv2d(head_dim, num_classes * self.num_anchors, kernel_size=1)self.reg_pred = nn.Conv2d(head_dim, 4 * self.num_anchors, kernel_size=1)

1.5 改进YOLOv2的详细网络图

  • 与之前实现的YOLOv1相比，主干网络由ResNet18变为DarkNet19，每个网格预测5个anchor box，其他方面一致。
  • 与原版的YOLOv2相比，做了更加符合当下的设计理念的修改，包括添加Neck模块、修改检测头等，但是没有引入passthrough层。
  • 尽管和原版的YOLOv2有所差别，但内核思想是一致的，均是在YOLOv1的单级检测架构上引入了先验框。

在这里插入图片描述

# RT-ODLab/models/detectors/yolov2/yolov2.pyimport torch
import torch.nn as nn
import numpy as npfrom utils.misc import multiclass_nmsfrom .yolov2_backbone import build_backbone
from .yolov2_neck import build_neck
from .yolov2_head import build_head# YOLOv2
class YOLOv2(nn.Module):def __init__(self,cfg,device,num_classes=20,conf_thresh=0.01,nms_thresh=0.5,topk=100,trainable=False,deploy=False,nms_class_agnostic=False):super(YOLOv2, self).__init__()# ------------------- Basic parameters -------------------self.cfg = cfg                                 # 模型配置文件self.device = device                           # cuda或者是cpuself.num_classes = num_classes                 # 类别的数量self.trainable = trainable                     # 训练的标记self.conf_thresh = conf_thresh                 # 得分阈值self.nms_thresh = nms_thresh                   # NMS阈值self.topk = topk                               # topkself.stride = 32                               # 网络的最大步长self.deploy = deployself.nms_class_agnostic = nms_class_agnostic# ------------------- Anchor box -------------------self.anchor_size = torch.as_tensor(cfg['anchor_size']).float().view(-1, 2) # [A, 2]self.num_anchors = self.anchor_size.shape[0]# ------------------- Network Structure -------------------## 主干网络self.backbone, feat_dim = build_backbone(cfg['backbone'], trainable&cfg['pretrained'])## 颈部网络self.neck = build_neck(cfg, feat_dim, out_dim=512)head_dim = self.neck.out_dim## 检测头self.head = build_head(cfg, head_dim, head_dim, num_classes)## 预测层# 与YoloV1相比，YoloV2每个网格会预测5个框(VOC数据集)，因此需×5self.obj_pred = nn.Conv2d(head_dim, 1 * self.num_anchors, kernel_size=1)self.cls_pred = nn.Conv2d(head_dim, num_classes * self.num_anchors, kernel_size=1)self.reg_pred = nn.Conv2d(head_dim, 4 * self.num_anchors, kernel_size=1)if self.trainable:self.init_bias()def init_bias(self):# init biasinit_prob = 0.01bias_value = -torch.log(torch.tensor((1. - init_prob) / init_prob))nn.init.constant_(self.obj_pred.bias, bias_value)nn.init.constant_(self.cls_pred.bias, bias_value)def generate_anchors(self, fmp_size):passdef decode_boxes(self, anchors, reg_pred):passdef postprocess(self, obj_pred, cls_pred, reg_pred, anchors):"""后处理代码，包括topk操作、阈值筛选和非极大值抑制"""pass@torch.no_grad()def inference(self, x):bs = x.shape[0]# 主干网络feat = self.backbone(x)# 颈部网络feat = self.neck(feat)# 检测头cls_feat, reg_feat = self.head(feat)# 预测层obj_pred = self.obj_pred(reg_feat)cls_pred = self.cls_pred(cls_feat)reg_pred = self.reg_pred(reg_feat)fmp_size = obj_pred.shape[-2:]# anchors: [M, 2]anchors = self.generate_anchors(fmp_size)# 对 pred 的size做一些view调整，便于后续的处理# [B, A*C, H, W] -> [B, H, W, A*C] -> [B, H*W*A, C]obj_pred = obj_pred.permute(0, 2, 3, 1).contiguous().view(bs, -1, 1)                 # [1, 845=13×13×5, 1]cls_pred = cls_pred.permute(0, 2, 3, 1).contiguous().view(bs, -1, self.num_classes)reg_pred = reg_pred.permute(0, 2, 3, 1).contiguous().view(bs, -1, 4)# 测试时，默认batch是1，# 因此，我们不需要用batch这个维度，用[0]将其取走。obj_pred = obj_pred[0]       # [H*W*A, 1]cls_pred = cls_pred[0]       # [H*W*A, NC]reg_pred = reg_pred[0]       # [H*W*A, 4]if self.deploy:scores = torch.sqrt(obj_pred.sigmoid() * cls_pred.sigmoid())bboxes = self.decode_boxes(anchors, reg_pred)# [n_anchors_all, 4 + C]outputs = torch.cat([bboxes, scores], dim=-1)return outputselse:# post processbboxes, scores, labels = self.postprocess(obj_pred, cls_pred, reg_pred, anchors)return bboxes, scores, labelsdef forward(self, x):if not self.trainable:return self.inference(x)else:bs = x.shape[0]# 主干网络feat = self.backbone(x)# 颈部网络feat = self.neck(feat)# 检测头cls_feat, reg_feat = self.head(feat)# 预测层obj_pred = self.obj_pred(reg_feat)cls_pred = self.cls_pred(cls_feat)reg_pred = self.reg_pred(reg_feat)fmp_size = obj_pred.shape[-2:]# A就是Anchor的数量，VOC数据集上设置为5# anchors: [M, 2], M = H*W*Aanchors = self.generate_anchors(fmp_size)# 对 pred 的size做一些view调整，便于后续的处理# [B, A*C, H, W] -> [B, H, W, A*C] -> [B, H*W*A, C]obj_pred = obj_pred.permute(0, 2, 3, 1).contiguous().view(bs, -1, 1)cls_pred = cls_pred.permute(0, 2, 3, 1).contiguous().view(bs, -1, self.num_classes)reg_pred = reg_pred.permute(0, 2, 3, 1).contiguous().view(bs, -1, 4)# decode bboxbox_pred = self.decode_boxes(anchors, reg_pred)# 网络输出outputs = {"pred_obj": obj_pred,                   # (Tensor) [B, M, 1]"pred_cls": cls_pred,                   # (Tensor) [B, M, C]"pred_box": box_pred,                   # (Tensor) [B, M, 4]"stride": self.stride,                  # (Int)"fmp_size": fmp_size                    # (List) [fmp_h, fmp_w]}           return outputs

2、YOLOV2的前向推理

在1.5代码中，还遗留几个问题：

  1. 如何从边界框偏移量reg_pred解耦出边界框坐标box_pred？
  2. 如何实现后处理操作？
  3. 如何计算训练阶段的损失？

2.1 解耦边界框坐标

2.1.1 先验框矩阵的生成

YOLOv2网络配置参数如下，我们从中能看到anchor_size变量。这是基于kmeans聚类，在COCO数据集上聚类出的先验框，由于COCO数据集更大、图片更加丰富，因此我们将这几个先验框用在VOC数据集上。

# RT-ODLab/config/model_config/yolov2_config.py
# YOLOv2 Configyolov2_cfg = {# input'trans_type': 'ssd','multi_scale': [0.5, 1.5],# model'backbone': 'darknet19','pretrained': True,'stride': 32,  # P5'max_stride': 32,# neck'neck': 'sppf','expand_ratio': 0.5,'pooling_size': 5,'neck_act': 'lrelu','neck_norm': 'BN','neck_depthwise': False,# head'head': 'decoupled_head','head_act': 'lrelu','head_norm': 'BN','num_cls_head': 2,'num_reg_head': 2,'head_depthwise': False,'anchor_size': [[17,  25],[55,  75],[92,  206],[202, 21],[289, 311]],  # 416# matcher'iou_thresh': 0.5,# loss weight'loss_obj_weight': 1.0,'loss_cls_weight': 1.0,'loss_box_weight': 5.0,# training configuration'trainer_type': 'yolov8',
}

  • 回想一下，在之前实现的YOLOv1中，我们通过构造矩阵G，得到了每一个网格(grid_x，grid_y)的坐标。

  • 由于我们在YOLOv2中引入了先验框，因此，我们不仅需要每一个网格(grid_x，grid_y)的坐标，还要包含先验框(5个)的尺寸信息。

  • 先验框矩阵生成代码如下

    # RT-ODLab/models/detectors/yolov2/yolov2.pydef generate_anchors(self, fmp_size):"""fmp_size: (List) [H, W]默认缩放后的图像为416×416，那么经过32倍下采样后，fmp_size为13×13"""# 1、特征图的宽和高fmp_w, fmp_h  = fmp_size# 2、生成网格的x坐标和y坐标anchor_y, anchor_x = torch.meshgrid([torch.arange(fmp_h), torch.arange(fmp_w)])# 3、将xy两部分的坐标拼接起来，shape为[H, W, 2]#    再转换下, shape变为[HW, 2]anchor_xy = torch.stack([anchor_x, anchor_y], dim=-1).float().view(-1, 2)# 4、引入了anchor box机制，每个网格包含A个anchor，因此每个(grid_x, grid_y)的坐标需要复制A(Anchor nums)份# 相当于  每个网格左上角的坐标点复制5份  作为5个不同宽高anchor box的中心点# [HW, 2] -> [HW, A, 2] -> [M, 2]anchor_xy = anchor_xy.unsqueeze(1).repeat(1, self.num_anchors, 1)anchor_xy = anchor_xy.view(-1, 2).to(self.device)# 5、将kmeans聚类得出的5组anchor box的宽高复制13×13份# [A, 2] -> [1, A, 2] -> [HW, A, 2] -> [M, 2]anchor_wh = self.anchor_size.unsqueeze(0).repeat(fmp_h*fmp_w, 1, 1)anchor_wh = anchor_wh.view(-1, 2).to(self.device)# 6、将中心点和宽高cat起来，得到的shape为[M, 4]# 其中M=13×13×5 表示feature map为13×13，每个网格有5组anchor box# 4代表anchor box的位置(x_center, y_center, w, h)# 需要注意:#     x_center, y_center是feature map上的坐标位置，需要×stride  才能得到缩放后原始图像上的中心点#     w, h是针对缩放后原始图像anchors = torch.cat([anchor_xy, anchor_wh], dim=-1)return anchors

2.1.2 解耦边界框

  • 生成先验框矩阵后，我们就能通过边界框偏移量reg_pred解耦出边界框坐标box_pred》。
  • 计算预测边界框的中心点坐标与之前计算YOLOv1是一致的，但是计算宽高发生了变化。这是因为YOLOv2中，我们引入了先验框，而且我们先验框的尺寸设定是相对于resize后图像大小，因此不需要乘stride。
    def decode_boxes(self, anchors, reg_pred):"""1、依据预测值reg_pred(t_x,t_y,t_w,t_h)结算出边界框中心点坐标c_x, c_y和宽高b_w, b_hc_x = ( grid_x + sigmoid(t_x) ) × stridec_y = ( grid_y + sigmoid(t_y) ) × strideb_w = p_w × exp(t_w)b_h = p_h × exp(t_h)其中   grid_x,grid_y,p_w,p_h为先验框的结果，即anchors结果2、转换为常用的x1y1x2y2形式。注意：预测的宽高不是相对于feature map的，而是相对于resize后图像大小，因此不需要×stride"""# 1、计算预测边界框的中心点坐标和宽高pred_ctr = (anchors[..., :2] + torch.sigmoid(reg_pred[..., :2])) * self.stridepred_wh = anchors[..., 2:] * torch.exp(reg_pred[..., 2:]) # 不需要×stride# 2、将所有bbox的中心点坐标和宽高换算成x1y1x2y2形式pred_x1y1 = pred_ctr - pred_wh * 0.5pred_x2y2 = pred_ctr + pred_wh * 0.5pred_box = torch.cat([pred_x1y1, pred_x2y2], dim=-1)return pred_box

2.2 后处理操作

  • 之前YOLOv1的后处理操作，仅仅包含了阈值筛选和非极大值抑制NMS，这里由于引入了先验框，因此我们后处理的框的数量由之前的13×13变成了13×13×5(845)个。
  • 这845个框不都是高质量的，因此我们先做一个topk，依据得分从高到低取前k个。对于COCO数据集来说，一张图片的目标数量不超过100，因此一般只需要设定topk=100。这里，作者为了提高测试的mAP，默认设置topk=1000。
  • topk操作后，继续进行阈值筛选和非极大值抑制。
    # RT-ODLab/models/detectors/yolov2/yolov2.pydef postprocess(self, obj_pred, cls_pred, reg_pred, anchors):"""后处理代码，包括topk操作、阈值筛选和非极大值抑制1、topk操作：在coco数据集中，检测对象的数量一半不会超过100，因此先选择得分最高的k个边界框，这里为了取得更高的mAP，取k=1000在实际的场景中，不需要把k值取这么大2、滤掉低得分（边界框的score低于给定的阈值）的预测边界框；3、滤掉那些针对同一目标的冗余检测。Input:obj_pred: (Tensor) [H*W*A, 1]cls_pred: (Tensor) [H*W*A, C]reg_pred: (Tensor) [H*W*A, 4]anchors:  (Tensor) [H*W*A, 4]其中，H*W*A = 13×13×5 = 845"""# (H x W x A x C,)# 13×13×5×20 = 16900scores = torch.sqrt(obj_pred.sigmoid() * cls_pred.sigmoid()).flatten()# 1、topk操作# Keep top k top scoring indices only.num_topk = min(self.topk, reg_pred.size(0))# torch.sort is actually faster than .topk (at least on GPUs)predicted_prob, topk_idxs = scores.sort(descending=True)topk_scores = predicted_prob[:num_topk]topk_idxs = topk_idxs[:num_topk]# 2、滤掉低得分（边界框的score低于给定的阈值）的预测边界框# filter out the proposals with low confidence scorekeep_idxs = topk_scores > self.conf_threshscores = topk_scores[keep_idxs]topk_idxs = topk_idxs[keep_idxs]# 获取flatten之前topk_scores所在的idx以及相应的labelanchor_idxs = torch.div(topk_idxs, self.num_classes, rounding_mode='floor')  # 获取labels = topk_idxs % self.num_classesreg_pred = reg_pred[anchor_idxs]anchors = anchors[anchor_idxs]# 解算边界框, 并归一化边界框: [H*W*A, 4]bboxes = self.decode_boxes(anchors, reg_pred)# to cpu & numpyscores = scores.cpu().numpy()labels = labels.cpu().numpy()bboxes = bboxes.cpu().numpy()#  3、滤掉那些针对同一目标的冗余检测。# nmsscores, labels, bboxes = multiclass_nms(scores, labels, bboxes, self.nms_thresh, self.num_classes, self.nms_class_agnostic)return bboxes, scores, labels

接下来，就到了正样本的匹配和损失函数计算了。

  • 原版YOLOv2会先解耦出边界框，计算边界框和目标框的IoU，只有IoU最大的才被标记为正样本，用来计算置信度损失、类别损失以及边界框位置损失，其他预测的边界框均为负样本，仅仅计算置信度损失。
  • 这样，先验框没有为正样本匹配带来直接影响，仅仅被用于解算边界框的坐标。
  • 既然先验框有边界框的先验尺寸信息，那么它可以直接参与正样本的匹配，因此我们接下来采用当下更加常用的策略来发挥先验框在标签匹配中的作用，即基于先验框的正样本匹配策略。

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

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

相关文章

压力测试+接口测试(工具jmeter)

压力测试+接口测试(工具jmeter)

jmeter是apache公司基于java开发的一款开源压力测试工具，体积小，功能全，使用方便，是一个比较轻量级的测试工具，使用起来非常简单。因 为jmeter是java开发的，所以运行的时候必须先要安装jdk才可以。jmeter是…
阅读更多...
【论文阅读】Deep Graph Contrastive Representation Learning

【论文阅读】Deep Graph Contrastive Representation Learning

目录 0、基本信息1、研究动机2、创新点3、方法论3.1、整体框架及算法流程3.2、Corruption函数的具体实现3.2.1、删除边（RE）3.2.2、特征掩盖（MF） 3.3、[编码器](https://blog.csdn.net/qq_44426403/article/details/135443921)的设…
阅读更多...
借用GitHub将typora图片文件快速上传CSDN

借用GitHub将typora图片文件快速上传CSDN

前情概要 众所周知，程序员大佬们喜欢用typora软件写代码笔记，写了很多笔记想要放到CSDN上给其他大佬分享，但是在往csdn上搬运的时候，图片总是上传出错，一张一张搞有很麻烦，咋如何搞？ 废话不多…
阅读更多...
muduo网络库剖析——监听者EpollPoller类

muduo网络库剖析——监听者EpollPoller类

muduo网络库剖析——监听者EpollPoller类 前情从muduo到my_muduo 概要epoll原理解析epoll提供的接口epoll的触发模式epoll实现多路复用 框架与细节成员函数使用方法 源码结尾 前情 从muduo到my_muduo 作为一个宏大的、功能健全的muduo库，考虑的肯定是众多情况是否…
阅读更多...
SpringBoot 更新业务场景下，如何区分null是清空属性值 还是null为vo属性默认值?

SpringBoot 更新业务场景下，如何区分null是清空属性值 还是null为vo属性默认值?

先看歧义现象 值为null 未传递此属性 所以此时如何区分null 时传递进来的的null，还是属性的默认值null? 引入方案 引入过滤器，中间截获requestBodyData并保存到HttpServletRequest，业务层从HttpServletRequest 获取到requestBodyData辅…
阅读更多...
LaTeX 多栏文档 Multiple columns如何插入图片并修改样式

LaTeX 多栏文档 Multiple columns如何插入图片并修改样式

在今天写报告的时候用到了 latex 的多栏列表，插入图片的时候感觉很无助 如果不喜欢让Latex自动安排图片位置，可以使用float包，然后可以使用\begin{figure}[H]。 记得提前导入这个包 \usepackage{float} 为了让我的图片的caption居中&#xf…
阅读更多...
市面上常见硬盘分析及对比

市面上常见硬盘分析及对比

固态硬盘 vs. 机械硬盘对比： 工作原理： 固态硬盘(SSD)： 使用非易失性存储器（NAND闪存）来存储数据，通过电子方式读写。机械硬盘(HDD)： 使用旋转的磁盘片和移动的磁头进行数据读写，依赖…
阅读更多...
django电影推荐系统

django电影推荐系统

电影推荐 启动 ./bin/pycharm.shdjango-admin startproject movie_recommendation_projectcd movie_recommendation_project/python manage.py movie_recommendation_apppython manage.py startapp movle_recommendation_applspython manage.py runserver Using the URLconf d…
阅读更多...
Python多线程爬虫——数据分析项目实现详解

Python多线程爬虫——数据分析项目实现详解

前言 「作者主页」：雪碧有白泡泡 「个人网站」：雪碧的个人网站 ChatGPT体验地址 文章目录 前言爬虫获取cookie网站爬取与启动CSDN爬虫爬虫启动将爬取内容存到文件中 多线程爬虫选择要爬取的用户 线程池 爬虫 爬虫是指一种自动化程序，能够模…
阅读更多...
Kylin 安装novnc 远程访问

Kylin 安装novnc 远程访问

noVNC可以使用浏览器直接访问服务器，而不需要使用VNC客户端。 1.初始环境 关闭防火墙或允许IP访问本机 2.安装依赖 dnf install -y tigervnc-server git 3.git下载novnc git clone https://github.com/novnc/noVNC.git 4.配置信任证书 openssl req -new -x509 …
阅读更多...
RabbitMQ使用篇

RabbitMQ使用篇

☆* o(≧▽≦)o *☆嗨~我是小奥🍹 📄📄📄个人博客：小奥的博客 📄📄📄CSDN：个人CSDN 📙📙📙Github：传送门 📅&a…
阅读更多...
USB转SPI USB转IIC 串口转SPI串口转IIC SPI I2C模块

USB转SPI USB转IIC 串口转SPI串口转IIC SPI I2C模块

一款支持USB转SPI、USB转I2C、USB转GPIO、USB转PWM、USB转ADC的模块。提供上位机工具，开发协议。 资料下载，链接：https://pan.baidu.com/s/1sw3RCMwjhrMO4qzUBq9bjA 提取码：qzjp 概述 串口转多协议模组为了客户调试一些功能…
阅读更多...
PICO Developer Center 创建和调试 ADB 命令

PICO Developer Center 创建和调试 ADB 命令

PICO 开发者中心概览 ADB 是一个轻量级的 Android 调试桥(Android Debug Bridge，简称 ADB)，用于与 Android 设备进行通信和调试。ADB提供了许多有用的功能，使开发人员能够轻松地管理和调试设备上的应用程序。 你可以使用 PDC 工具来调试系统…
阅读更多...
阿里云服务器4核8G配置收费标准及新老用户优惠价格整理

阿里云服务器4核8G配置收费标准及新老用户优惠价格整理

阿里云服务器4核8g配置云服务器u1价格是955.58元一年，4核8G配置还可以选择ECS计算型c7实例、计算型c8i实例、计算平衡增强型c6e、ECS经济型e实例、AMD计算型c8a等机型等ECS实例规格，规格不同性能不同，价格也不同，阿里云服务器网al…
阅读更多...
使用 vsCode创建GO项目

使用 vsCode创建GO项目

最近回顾了一下go的使用：具体操作看下面的参考连接，下面只描述一些踩过的坑： 1. go安装配置 安装go->配置go环境变量 推荐官网下载，速度很快； 这里需要配置五个参数：GOPATH/GOROOT/Path、GO111MODULE/…
阅读更多...
如何快速打造属于自己的接口自动化测试框架

如何快速打造属于自己的接口自动化测试框架

1 接口测试 接口测试是对系统或组件之间的接口进行测试，主要是校验数据的交换，传递和控制管理过程，以及相互逻辑依赖关系。 接口自动化相对于UI自动化来说，属于更底层的测试，这样带来的好处就是测试收益更大&#xff…
阅读更多...
WordPress设置回收站自动清理天数的插件Change Empty Trash Time

WordPress设置回收站自动清理天数的插件Change Empty Trash Time

前面boke112百科跟大家分享的『WordPress回收站自动清空时间？如何关闭回收站或设置自动清理天数？』一文，就介绍了可以添加一行代码实现关闭或设置回收站自动清理时间，也可以通过安装Change Empty Trash Time插件来实现。 今天bok…
阅读更多...
【论文阅读】One For All: Toward Training One Graph Model for All Classification Tasks

【论文阅读】One For All: Toward Training One Graph Model for All Classification Tasks

目录 0、基本信息1、研究动机2、创新点——One For All ：unique features3、准备4、具体实现4.1、用TAGs统一来自不同领域的图数据4.2、用NOI（NODES-OF-INTEREST）统一不同图任务4.2.1、NOI子图4.2.2、NOI提示结点 4.3、用于图的上下文学习&am…
阅读更多...
java大数据hadoop2.9.2 Java编写Hadoop分析平均成绩

java大数据hadoop2.9.2 Java编写Hadoop分析平均成绩

1、准备文件&#xff0c;例如score.txt&#xff0c;内容如下&#xff1a; zs k1 88 ls k1 98 ww k1 78 zs k2 88 ls k2 98 ww k2 78 zs k3 88 ls k3 98 ww k3 78 2、创建maven项目 <!-- https://mvnrepository.com/artifact/org.apache.hadoop/hadoop-common --><d…
阅读更多...
【XTuner 大模型单卡低成本微调实战】学习笔记

【XTuner 大模型单卡低成本微调实战】学习笔记

参考学习教程【XTuner 大模型单卡低成本微调实战】 理论 Finetune简介 大语言模型 微调模式 增量预训练 指令跟随微调 LoRA和QLoRA Xtuner介绍 实战 自定义微调 用 Medication QA 数据集进行微调 将数据转为 XTuner 的数据格式 目标格式&#xff1a;(.jsonL) 写提示词请C…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023