Faster R-CNN源码解析(一)

目录

    • 前言
    • 训练脚本(train_mobilenetv2.py)
    • 自定义数据集(my_dataset.py)

前言

Faster R-CNN 是经典的two-stage目标检测模型, 原理上并不是很复杂,也就是RPN+Fast R-CNN,但是在代码的实现上确实有很多细节,并且源码也非常的多,所以看源码的时候也会遇到某些问题,网上完完整整从头到尾讲解的也很少,下面我将会为小伙伴们讲解哔哩哔哩上一个up主简单修改后的fast r-cnn源码,大家可以去看他的视频(源码解析),原理以及源代码真的非常详细易懂,大家也可以去学习,爆赞!!我主要是记录有些自己认为不太明白up主又没有细讲的部分(本人比较笨哈哈)以及梳理整个代码流程,由于很多源码还有debug的图片我都写在博客里,可能看起来会比较多,但是大家一定尽量看看,真的保姆级讲解,大家跟着我走一定能弄懂的!!
下面奉上源码链接(faster r-cnn源码)

训练脚本(train_mobilenetv2.py)

大家看源码之前,可以先看文件里面的README.md文件,看一下需要的配置环境以及如何使用有些指令
源码有两个三个训练脚本,我们不用管多GPU训练的脚本,以train_mobilenetv2.py为例,这个是以mobilenetv2为backbone,另一个是resnet50+FPN(特征金字塔)为backbone的脚本,大差不大,只是结构不同,参数量不同,话不多说,我们直接看main()函数

def main():
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print("Using {} device training.".format(device.type))

    # 用来保存coco_info的文件
    results_file = "results{}.txt".format(datetime.datetime.now().strftime("%Y%m%d-%H%M%S"))

    # 检查保存权重文件夹是否存在,不存在则创建
    if not os.path.exists("save_weights"):
        os.makedirs("save_weights")

    data_transform = {
        "train": transforms.Compose([transforms.ToTensor(),
                                     transforms.RandomHorizontalFlip(0.5)]),
        "val": transforms.Compose([transforms.ToTensor()])
    }

    VOC_root = r"F:\AI\deep-learning-for-image-processing-master\pytorch_object_detection\faster_rcnn"  # VOCdevkit
    aspect_ratio_group_factor = 3
    batch_size = 8

    # check voc root
    if os.path.exists(os.path.join(VOC_root, "VOCdevkit")) is False:
        raise FileNotFoundError("VOCdevkit dose not in path:'{}'.".format(VOC_root))

    # load train data set
    # VOCdevkit -> VOC2012 -> ImageSets -> Main -> train.txt
    train_dataset = VOCDataSet(VOC_root, "2012", data_transform["train"], "train.txt")
    train_sampler = None

    # 是否按图片相似高宽比采样图片组成batch
    # 使用的话能够减小训练时所需GPU显存,默认使用
    if aspect_ratio_group_factor >= 0:
        train_sampler = torch.utils.data.RandomSampler(train_dataset)
        # 统计所有图像高宽比例在bins区间中的位置索引
        group_ids = create_aspect_ratio_groups(train_dataset, k=aspect_ratio_group_factor)
        # 每个batch图片从同一高宽比例区间中取
        train_batch_sampler = GroupedBatchSampler(train_sampler, group_ids, batch_size)

    nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
    # nw = 0
    print('Using %g dataloader workers' % nw)

    # 注意这里的collate_fn是自定义的,因为读取的数据包括image和targets,不能直接使用默认的方法合成batch
    if train_sampler:
        # 如果按照图片高宽比采样图片,dataloader中需要使用batch_sampler
        train_data_loader = torch.utils.data.DataLoader(train_dataset,
                                                        batch_sampler=train_batch_sampler,
                                                        pin_memory=True,
                                                        num_workers=nw,
                                                        collate_fn=train_dataset.collate_fn)
    else:
        train_data_loader = torch.utils.data.DataLoader(train_dataset,
                                                        batch_size=batch_size,
                                                        shuffle=True,
                                                        pin_memory=True,
                                                        num_workers=nw,
                                                        collate_fn=train_dataset.collate_fn)

    # load validation data set
    # VOCdevkit -> VOC2012 -> ImageSets -> Main -> val.txt
    val_dataset = VOCDataSet(VOC_root, "2012", data_transform["val"], "val.txt")
    val_data_loader = torch.utils.data.DataLoader(val_dataset,
                                                  batch_size=1,
                                                  shuffle=False,
                                                  pin_memory=True,
                                                  num_workers=nw,
                                                  collate_fn=val_dataset.collate_fn)

    # create model num_classes equal background + 20 classes
    model = create_model(num_classes=21)
    # print(model)

    model.to(device)

    train_loss = []
    learning_rate = []
    val_map = []

    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
    #  first frozen backbone and train 5 epochs                   #
    #  首先冻结前置特征提取网络权重(backbone),训练rpn以及最终预测网络部分 #
    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
    for param in model.backbone.parameters():
        param.requires_grad = False

    # define optimizer
    params = [p for p in model.parameters() if p.requires_grad]
    optimizer = torch.optim.SGD(params, lr=0.005,
                                momentum=0.9, weight_decay=0.0005)

    init_epochs = 5
    for epoch in range(init_epochs):
        # train for one epoch, printing every 10 iterations
        mean_loss, lr = utils.train_one_epoch(model, optimizer, train_data_loader,
                                              device, epoch, print_freq=50, warmup=True)
        train_loss.append(mean_loss.item())
        learning_rate.append(lr)

        # evaluate on the test dataset
        coco_info = utils.evaluate(model, val_data_loader, device=device)

        # write into txt
        with open(results_file, "a") as f:
            # 写入的数据包括coco指标还有loss和learning rate
            result_info = [str(round(i, 4)) for i in coco_info + [mean_loss.item()]] + [str(round(lr, 6))]
            txt = "epoch:{} {}".format(epoch, '  '.join(result_info))
            f.write(txt + "\n")

        val_map.append(coco_info[1])  # pascal mAP

    torch.save(model.state_dict(), "./save_weights/pretrain.pth")

    # # # # # # # # # # # # # # # # # # # # # # # # # # # #
    #  second unfrozen backbone and train all network     #
    #  解冻前置特征提取网络权重(backbone),接着训练整个网络权重  #
    # # # # # # # # # # # # # # # # # # # # # # # # # # # #

    # 冻结backbone部分底层权重
    for name, parameter in model.backbone.named_parameters():
        split_name = name.split(".")[0]
        if split_name in ["0", "1", "2", "3"]:
            parameter.requires_grad = False
        else:
            parameter.requires_grad = True

    # define optimizer
    params = [p for p in model.parameters() if p.requires_grad]
    optimizer = torch.optim.SGD(params, lr=0.005,
                                momentum=0.9, weight_decay=0.0005)
    # learning rate scheduler
    lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
                                                   step_size=3,
                                                   gamma=0.33)
    num_epochs = 20
    for epoch in range(init_epochs, num_epochs+init_epochs, 1):
        # train for one epoch, printing every 50 iterations
        mean_loss, lr = utils.train_one_epoch(model, optimizer, train_data_loader,
                                              device, epoch, print_freq=50, warmup=True)
        train_loss.append(mean_loss.item())
        learning_rate.append(lr)

        # update the learning rate
        lr_scheduler.step()

        # evaluate on the test dataset
        coco_info = utils.evaluate(model, val_data_loader, device=device)

        # write into txt
        with open(results_file, "a") as f:
            # 写入的数据包括coco指标还有loss和learning rate
            result_info = [str(round(i, 4)) for i in coco_info + [mean_loss.item()]] + [str(round(lr, 6))]
            txt = "epoch:{} {}".format(epoch, '  '.join(result_info))
            f.write(txt + "\n")

        val_map.append(coco_info[1])  # pascal mAP

        # save weights
        # 仅保存最后5个epoch的权重
        if epoch in range(num_epochs+init_epochs)[-5:]:
            save_files = {
                'model': model.state_dict(),
                'optimizer': optimizer.state_dict(),
                'lr_scheduler': lr_scheduler.state_dict(),
                'epoch': epoch}
            torch.save(save_files, "./save_weights/mobile-model-{}.pth".format(epoch))

    # plot loss and lr curve
    if len(train_loss) != 0 and len(learning_rate) != 0:
        from plot_curve import plot_loss_and_lr
        plot_loss_and_lr(train_loss, learning_rate)

    # plot mAP curve
    if len(val_map) != 0:
        from plot_curve import plot_map
        plot_map(val_map)

代码可能看起来会有点多,数据集用的是PASCAL VOC2012,了解数据集的目录和结构之后,第一个要讲解的是图像增强部分(data_transform),这部分的图像增强方法是自己封装的,我们知道目标检测之前会事先把数据集的每一张图片的ground truth(真实框)通过人工标注出来,但是RandomHorizontalFlip(随机水平翻转)这个操作的时候,对应的真实框(左上x,左上y,右下x,右下y)的坐标也会变,所以需要自己封装进行处理在这里插入图片描述

class RandomHorizontalFlip(object):
    """随机水平翻转图像以及bboxes"""
    def __init__(self, prob=0.5):
        self.prob = prob

    def __call__(self, image, target):
        if random.random() < self.prob:
            height, width = image.shape[-2:]
            image = image.flip(-1)  # 水平翻转图片
            bbox = target["boxes"]
            # bbox: xmin, ymin, xmax, ymax
            bbox[:, [0, 2]] = width - bbox[:, [2, 0]]  # 翻转对应bbox坐标信息
            target["boxes"] = bbox
        return image, target

prob就是随机水平翻转的概率,bbox就是保存的所有真实框的坐标信息,一张图片可能不止一个目标,所以bbox应该是[N, 4]的形状, 通过bbox[:, [0, 2]] = width - bbox[:, [2, 0]]就实现了图像翻转的同时坐标也改变了,注意:上图右边翻转后的坐标位置应该还是对应左上和右下,图上标的右上和左下是不对的,其他的图像增强方式都很简单,看看就明白了,关于自定义数据集VOCDataSet类,后面会单独将,将数据集加载到设备内存后,DataLoader中有个collate_fn参数,这是一个将图片打包的操作,很简单:

    def collate_fn(batch):
        return tuple(zip(*batch))

比如说我们一个batch设置8张图片,debug到这个地方可以看看在这里插入图片描述
这就是传入的八张图片,*batch代表取列表里面的所有元素,zip进行打包并转成元组,加载数据后需要实例化模型,Pascal VOC2012只有20个类别,传入21是因为还多了一个背景

def create_model(num_classes):
    # https://download.pytorch.org/models/vgg16-397923af.pth
    # 如果使用vgg16的话就下载对应预训练权重并取消下面注释,接着把mobilenetv2模型对应的两行代码注释掉
    # vgg_feature = vgg(model_name="vgg16", weights_path="./backbone/vgg16.pth").features
    # backbone = torch.nn.Sequential(*list(vgg_feature._modules.values())[:-1])  # 删除features中最后一个Maxpool层
    # backbone.out_channels = 512

    # https://download.pytorch.org/models/mobilenet_v2-b0353104.pth
    backbone = MobileNetV2(weights_path="./backbone/mobilenet_v2.pth").features
    backbone.out_channels = 1280  # 设置对应backbone输出特征矩阵的channels

    anchor_generator = AnchorsGenerator(sizes=((32, 64, 128, 256, 512),),
                                        aspect_ratios=((0.5, 1.0, 2.0),))

    roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=['0'],  # 在哪些特征层上进行roi pooling
                                                    output_size=[7, 7],   # roi_pooling输出特征矩阵尺寸
                                                    sampling_ratio=2)  # 采样率

    model = FasterRCNN(backbone=backbone,
                       num_classes=num_classes,
                       rpn_anchor_generator=anchor_generator,
                       box_roi_pool=roi_pooler)

    return model

将所有写好的类都在这里实例化,MobileNetV2可以看这个(MobileNetV2),AnchorsGenerator后面会详细讲,MultiScaleRoIAlign是torchvision封装的类,传入特征层的名字,MobileNetV2特征提取后只会产生一个特征层,名字也是自己取的,所以传入了一个值,output_size就是通过roipooling(Region Of Interest)后输出的特征矩阵尺寸,最后组成FasterRCNN。

这里的训练方式和以往训练图像分类模型的方式有所不同,这里首先冻结前置特征提取网络权重(backbone),训练rpn以及最终预测网络部分,然后解冻前置特征提取网络权重(backbone),接着训练整个网络权重,将训练后的各个指标写入到文件中,以及最终保存权重和画图。大致的话训练流程大家应该都了解了吧,后面再细讲训练时封装的方法,大家先有个体系结构,知道整个大概流程。

自定义数据集(my_dataset.py)

在这一部分开始之前,小伙伴们需要先了解PASCAL VOC2012数据集噢(必须要了解,不然后面看不懂),了解数据集后,我们清楚了数据集的目录结构,再来看这部分代码

class VOCDataSet(Dataset):
    """读取解析PASCAL VOC2007/2012数据集"""

    def __init__(self, voc_root, year="2012", transforms=None, txt_name: str = "train.txt"):
        assert year in ["2007", "2012"], "year must be in ['2007', '2012']"
        self.root = os.path.join(voc_root, "VOCdevkit", f"VOC{year}")
        self.img_root = os.path.join(self.root, "JPEGImages")
        self.annotations_root = os.path.join(self.root, "Annotations")

        # read train.txt or val.txt file
        txt_path = os.path.join(self.root, "ImageSets", "Main", txt_name)
        assert os.path.exists(txt_path), "not found {} file.".format(txt_name)

        with open(txt_path) as read:
            self.xml_list = [os.path.join(self.annotations_root, line.strip() + ".xml")
                             for line in read.readlines() if len(line.strip()) > 0]

        # check file
        assert len(self.xml_list) > 0, "in '{}' file does not find any information.".format(txt_path)
        for xml_path in self.xml_list:
            assert os.path.exists(xml_path), "not found '{}' file.".format(xml_path)

        # read class_indict
        json_file = './pascal_voc_classes.json'
        assert os.path.exists(json_file), "{} file not exist.".format(json_file)
        json_file = open(json_file, 'r')
        self.class_dict = json.load(json_file)
        json_file.close()

        self.transforms = transforms

传入的参数
voc_root:数据集根目录
year: 哪一年的Pascal VOC数据集
transform:图像增强
txt_name: 根据训练需求传入VOCdevkit//VOC2012//ImageSets//Main文件夹中的txt文件
前面几行os.path.join()代码都是拼接需要的文件路径,方便后面使用,这里我们以train.txt为例,拿到训练集的txt文件,里面是所有训练集图片的编号,读取里面的编号并拼接为xml后缀的形式,方便在Annotations文件夹中打开,拼接完后我们debug发现txt文件的编号对应我们最后得到的xml路径下的编号在这里插入图片描述在这里插入图片描述

一直到这部分:

 json_file = './pascal_voc_classes.json'
 assert os.path.exists(json_file), "{} file not exist.".format(json_file)
 json_file = open(json_file, 'r')
 self.class_dict = json.load(json_file)
 json_file.close()

pascal_voc_classes.json这个json文件就是以字典的形式保存了Pascal VOC2012数据集的20个类别并用索引表示:在这里插入图片描述
打开这个文件并读取赋值给类变量(加载后记得close关闭文件),后面会用到。

在这里插入图片描述

注意:上面是官方的说明,因为是自定义的数据集方法,继承来自pytorch的DataSet类,要求所有的子类必须继承__len__和__getitem__方法,所以这里是必不可少的,__len__就是返回当前数据集的长度,__getitem__用于返回处理后的图片以及标签,下面再细讲。

def __getitem__(self, idx):
    # read xml
    xml_path = self.xml_list[idx]
    with open(xml_path) as fid:
        xml_str = fid.read()
    xml = etree.fromstring(xml_str)
    data = self.parse_xml_to_dict(xml)["annotation"]
    img_path = os.path.join(self.img_root, data["filename"])
    image = Image.open(img_path)
    if image.format != "JPEG":
        raise ValueError("Image '{}' format not JPEG".format(img_path))

    boxes = []
    labels = []
    iscrowd = []
    assert "object" in data, "{} lack of object information.".format(xml_path)
    for obj in data["object"]:
        xmin = float(obj["bndbox"]["xmin"])
        xmax = float(obj["bndbox"]["xmax"])
        ymin = float(obj["bndbox"]["ymin"])
        ymax = float(obj["bndbox"]["ymax"])

        # 进一步检查数据,有的标注信息中可能有w或h为0的情况,这样的数据会导致计算回归loss为nan
        if xmax <= xmin or ymax <= ymin:
            print("Warning: in '{}' xml, there are some bbox w/h <=0".format(xml_path))
            continue
        
        boxes.append([xmin, ymin, xmax, ymax])
        labels.append(self.class_dict[obj["name"]])
        if "difficult" in obj:
            iscrowd.append(int(obj["difficult"]))
        else:
            iscrowd.append(0)

    # convert everything into a torch.Tensor
    boxes = torch.as_tensor(boxes, dtype=torch.float32)
    labels = torch.as_tensor(labels, dtype=torch.int64)
    iscrowd = torch.as_tensor(iscrowd, dtype=torch.int64)
    image_id = torch.tensor([idx])
    area = (boxes[:, 3] - boxes[:, 1]) * (boxes[:, 2] - boxes[:, 0])

    target = {}
    target["boxes"] = boxes
    target["labels"] = labels
    target["image_id"] = image_id
    target["area"] = area
    target["iscrowd"] = iscrowd

    if self.transforms is not None:
        image, target = self.transforms(image, target)

    return image, target

该方法通过索引参数 idx 载入每张图片,因为类变量xml_list里面保存了所有的训练集图片的xml文件路径,打开对应的xml文件,这里我debug得到的是这个xml文件(每次debug都可能不一样,因为图片是打乱了的)在这里插入图片描述
让我们再看看原图片在这里插入图片描述
xml文件里面标注的很清楚,三个真实框的坐标以及类别,我们通过lxml.etree.fromstring先展成数再换成string的格式,调用类方法parse_xml_to_dict(),传入xml的内容,通过递归的方式循环遍历每一层,得到最后的文件内容,
我们可以看看data = self.parse_xml_to_dict(xml)[“annotation”]的debug结果在这里插入图片描述
这里我们也顺利拿出了xml文件的所有内容,接下来打开图片并判断是不是JPEG格式的,不是就会报错(原数据集都是jpeg的格式,报错说明数据集有问题),再看上面解析xml后的内容,object是我们的目标,通过列表包裹了多个字典,通过循环列表以及字典的key拿到对应的value,后面一系列操作都是将需要的内容取出来用列表存储,我解释一下这几个列表储存的都是什么:
boxes 存储的所有真实框的坐标
labels存储的真实类别的索引,也就是上面加载的json文件中的类别索引
iscrowd储存的是图片是否难以检测,0就是不难,非0就是比较难检测

再将上述三个列表以及当前图片的索引 idx 转成tensor的形式,area是计算了所有真实框的面积,后面也会用到,最最最后在用一个字典target保存上述所有的信息,debug看一下结果:在这里插入图片描述
最后图像增强一下就好了,其他的部分都差不多,自己看看就好了,至此我们第一部分的代码就讲解完了

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

面试题:Java 对象不使用时,为什么要赋值 null ?

文章目录 前言示例代码运行时栈典型的运行时栈Java的栈优化提醒 GC一瞥提醒 JVM的“BUG”总结 前言 最近&#xff0c;许多Java开发者都在讨论说&#xff0c;“不使用的对象应手动赋值为null“ 这句话&#xff0c;而且好多开发者一直信奉着这句话&#xff1b;问其原因&#xff…

专注短视频账号矩阵系统源头开发---saas工具

专注短视频账号矩阵系统源头开发---saas营销化工具&#xff0c;目前我们作为一家纯技术开发团队目前已经专注打磨开发这套系统企业版/线下版两个版本的saas营销拓客工具已经3年了&#xff0c;本套系统逻辑主要是从ai智能批量剪辑、账号矩阵全托管发布、私信触单收录、文案ai智能…

曲率半径的推导

参考文章 参考文章

5V升8.4V升压双节充电芯片WT4059

5V升8.4V升压双节充电芯片WT4059 今天给大家带来一款强大且实用的锂电池充电芯片&#xff1a;WT4059。 WT4059采用同步架构支持双节串联锂电池同步升压充电&#xff0c;它可用外部电阻配置充电电流&#xff0c;使其在应用时仅需极少的外围器件&#xff0c;有效减少整体方案尺寸…

JSP EL表达式获取list/Map集合与java Bean对象

上文 JSP EL表达式基本使用 中 我们对EL表达式做了一个基本的了解 也做了基础的字符串数据使用 那么 我们可以来看一下我们的集合 首先 list 这个比较简单 我们直接这样写代码 <% page import"java.util.ArrayList" %> <% page import"java.util.Lis…

【论文精读】HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face

HuggingGPT: Solving AI Tasks with ChatGPT and its Friends in Hugging Face 前言Abstract1 Introduction2 Related Works3 HuggingGPT3.1 Task PlanningSpecification-based InstructionDemonstration-based Parsing 3.2 Model SelectionIn-context Task-model Assignment 3…

Dubbo框架

1&#xff1a;简介 Dubbo 是阿里巴巴公司开源的一个Java高性能优秀的服务框架 Apache Dubbo 是一款 RPC 服务开发框架&#xff0c;用于解决微服务架构下的服务治理与通信问题 这是Dubbo官网的介绍&#xff0c;下面是我对这dubbo的理解 首先介绍下什么是RPC&#xff1a; 常…

重生奇迹mu迹辅助什么好

主流辅助一号选手&#xff1a;弓箭手 智弓作为最老、最有资历的辅助职业&#xff0c;一直都是各类玩家的首要选择。因为智力MM提供的辅助能力都是最基础、最有效、最直观的辅助。能够减少玩家对于装备的渴求度&#xff0c;直接提升人物的攻防&#xff0c;大大降低了玩家升级打…

python数据结构与算法-14_树与二叉树

树和二叉树 前面我们讲了两种使用分治和递归解决排序问题的归并排序和快速排序&#xff0c;堆排序先就此打住&#xff0c;因为涉及到树的概念&#xff0c;所以我们先来讲讲树。 讲完了树之后后面我们开始介绍一种有用的数据结构堆(heap)&#xff0c; 以及借助堆来实现的堆排序…

豪华程度堪比飞机头等舱?奔驰在北美发布Tourrider系列巴士

今年三月&#xff0c;奔驰工厂附近出现了一台特殊的测试车。其突出的前保险杠以及竖置双风挡等特殊配置&#xff0c;都在暗示着它并非是为欧洲市场打造。 根据特征推测&#xff0c;这台车应该是为北美市场打造。 就在昨天&#xff0c;奔驰发布了旗下全新Tourrider系列豪华客车&…

Unity中颜色空间Gamma与Linear

文章目录 前言一、人眼对光照的自适应1、光照强度与人眼所见的关系2、巧合的是&#xff0c;早期的电子脉冲显示屏也符合这条曲线3、这两条曲线都巧合的符合 y x^2.2^&#xff08;Gamma2.2空间&#xff09; 二、Gamma矫正1、没矫正前&#xff0c;人眼看电子脉冲显示屏&#xff…

二叉搜索树再升级——红黑树

二叉搜索树再升级——红黑树 红黑树的概念红黑树的插入uncle为granfather的右孩子uncle结点为红色uncle结点为空或黑色 uncle为granfather的左孩子 红黑树的概念 之前我们学习了AVL树&#xff0c;这是一种判断左右子树高度来严格控制总体树的高度的树。条件相对来说比较苛刻。…

黑马点评笔记 redis缓存三大问题解决

文章目录 缓存问题缓存穿透问题的解决思路编码解决商品查询的缓存穿透问题 缓存雪崩问题及解决思路缓存击穿问题及解决思路问题分析使用锁来解决代码实现 逻辑过期方案代码实现 缓存问题 我们熟知的是用到缓存就会遇到缓存三大问题&#xff1a; 缓存穿透缓存击穿缓存雪崩 接…

Kafka 常用功能总结(不断更新中....)

kafka 用途 业务中我们经常用来两个方面 1.发送消息 2.发送日志记录 kafka 结构组成 broker&#xff1a;可以理解成一个单独的服务器&#xff0c;所有的东西都归属到broker中 partation&#xff1a;为了增加并发度而做的拆分&#xff0c;相当于把broker拆分成不同的小块&…

基于Python实现汽车销售数据可视化+预测【500010086.1】

导入模块 import numpy as np import pandas as pd from pylab import mpl import plotly.express as px import matplotlib.pyplot as plt import seaborn as sns设置全局字体 plt.rcParams[font.sans-serif][kaiti]获取数据 total_sales_df pd.read_excel(r"./data/中…

从根到叶:随机森林模型的深入探索

一、说明 在本综合指南中&#xff0c;我们将超越基础知识。当您盯着随机森林模型的文档时&#xff0c;您将不再对“节点杂质”、“加权分数”或“成本复杂性修剪”等术语感到不知所措。相反&#xff0c;我们将剖析每个参数&#xff0c;阐明其作用和影响。通过理论和 Python 实践…

【STM32外设系列】GPS定位模块(ATGM336H)

&#x1f380; 文章作者&#xff1a;二土电子 &#x1f338; 关注公众号获取更多资料&#xff01; &#x1f438; 期待大家一起学习交流&#xff01; 文章目录 一、GPS模块简介二、使用方法2.1 引脚介绍2.2 数据帧介绍2.3 关于不同的启动方式 三、前置知识3.1 strstr函数3.2…

【洛谷算法题】P5714-肥胖问题【入门2分支结构】

&#x1f468;‍&#x1f4bb;博客主页&#xff1a;花无缺 欢迎 点赞&#x1f44d; 收藏⭐ 留言&#x1f4dd; 加关注✅! 本文由 花无缺 原创 收录于专栏 【洛谷算法题】 文章目录 【洛谷算法题】P5714-肥胖问题【入门2分支结构】&#x1f30f;题目描述&#x1f30f;输入格式&a…

实在智能携“TARS大模型”入选“2023中国数据智能产业AI大模型先锋企业”

近日&#xff0c;由数据猿与上海大数据联盟联合主办的“2023企业数智化转型升级发展论坛”在上海圆满收官。 论坛颁奖典礼上&#xff0c;《2023中国数据智能产业AI大模型先锋企业》等六大榜单正式揭晓&#xff0c;旨在表彰在AI领域为数智化升级取得卓越成就和突出贡献的企业&am…

【Flask使用】全知识md文档,4大部分60页第3篇:Flask模板使用和案例

本文的主要内容&#xff1a;flask视图&路由、虚拟环境安装、路由各种定义、状态保持、cookie、session、模板基本使用、过滤器&自定义过滤器、模板代码复用&#xff1a;宏、继承/包含、模板中特有变量和函数、Flask-WTF 表单、CSRF、数据库操作、ORM、Flask-SQLAlchemy…