[pytorch] detr源码浅析

news2024/11/24 13:08:05

[pytorch] detr源码浅析

  • 1. backbone部分
  • 2. encoder部分
  • 3. decoder部分
  • 4. 输出预测

为之后SAM的代码分析做铺垫

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

1. backbone部分

  • detr.py中的DETR class
class DETR(nn.Module):
	def __init__(self, backbone, transformer, num_classes, num_queries, aux_loss=False):
		...
	def forward(self, samples: NestedTensor):
		features, pos = self.backbone(samples)
        # 第一步,从图像提取特征
        # 返回值:特征图,pos位置编码(当前得到的特征图编码.不是对原始图像)
        # 跳到backbone - backbone.py里的Joiner函数
  • backbone.py 中的 Joiner class
class Joiner(nn.Sequential):
    def __init__(self, backbone, position_embedding):
        super().__init__(backbone, position_embedding)

    def forward(self, tensor_list: NestedTensor):
        # print(tensor_list.tensor.shape)
        xs = self[0](tensor_list)
        # 输入图像经过resnet
        # 得到特征图
        out: List[NestedTensor] = []
        pos = []
        for name, x in xs.items():
            out.append(x)
            pos.append(self[1](x).to(x.tensors.dtype))
            # 跳到position encoding.py

        return out, pos
  • position encoding.py
    第一种:Attention Is All You Need中的正余弦编码方式,不用学习,默认方法
    在这里插入图片描述
class PositionEmbeddingSine(nn.Module):
    """
    This is a more standard version of the position embedding, very similar to the one
    used by the Attention is all you need paper, generalized to work on images.
    """
    def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None):
        super().__init__()
        self.num_pos_feats = num_pos_feats
        self.temperature = temperature # 经验值
        self.normalize = normalize
        if scale is not None and normalize is False:
            raise ValueError("normalize should be True if scale is passed")
        if scale is None:
            scale = 2 * math.pi
        self.scale = scale

    def forward(self, tensor_list: NestedTensor):
        x = tensor_list.tensors
        # 输入特征图大小 batch, c, h, w    resnet50 c = 2048
        mask = tensor_list.mask
        # mask 表示实际的特征true  还是padding出来的false
        # 大小 batch,h,w
        assert mask is not None
        not_mask = ~mask
        y_embed = not_mask.cumsum(1, dtype=torch.float32) # 行方向累加 最后一位为累加的得到的最大值
        x_embed = not_mask.cumsum(2, dtype=torch.float32) # 列方向累加 最后一位为累加的得到的最大值
        if self.normalize:
            eps = 1e-6
            # 归一化
            y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
            x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale

        dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32, device=x.device)
        dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)

        pos_x = x_embed[:, :, :, None] / dim_t
        pos_y = y_embed[:, :, :, None] / dim_t
        # 算奇数维度或者偶数维度 公式不一样
        pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).flatten(3)
        pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).flatten(3)
        pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2) 
        # 前一半是pos_x 后一半是pos_y
        return pos

第二种:可学习的位置编码

class PositionEmbeddingLearned(nn.Module):
    """
    Absolute pos embedding, learned.
    """
    def __init__(self, num_pos_feats=256):
        super().__init__()
        # 行和列进行编码
        self.row_embed = nn.Embedding(50, num_pos_feats)  
        self.col_embed = nn.Embedding(50, num_pos_feats)
        # 50经验值
        self.reset_parameters()

    def reset_parameters(self):
        nn.init.uniform_(self.row_embed.weight)
        nn.init.uniform_(self.col_embed.weight)

    def forward(self, tensor_list: NestedTensor):
        x = tensor_list.tensors
        h, w = x.shape[-2:]
        i = torch.arange(w, device=x.device)
        j = torch.arange(h, device=x.device)
        x_emb = self.col_embed(i)
        y_emb = self.row_embed(j)
        pos = torch.cat([
            x_emb.unsqueeze(0).repeat(h, 1, 1),
            y_emb.unsqueeze(1).repeat(1, w, 1),
        ], dim=-1).permute(2, 0, 1).unsqueeze(0).repeat(x.shape[0], 1, 1, 1)
        return pos

2. encoder部分

  • detr.py中的DETR class
class DETR(nn.Module):
	def __init__(self, backbone, transformer, num_classes, num_queries, aux_loss=False):
		self.input_proj = nn.Conv2d(backbone.num_channels, hidden_dim, kernel_size=1)
		...
	def forward(self, samples: NestedTensor):
		features, pos = self.backbone(samples)
		src, mask = features[-1].decompose()
		# features和pos保存的都是cnn中每个block的结果,用的时候取最后一个block的结果
		# features大小 batch, c, h, w    resnet50 c = 2048
		# mask 大小 batch, h, w 是否padding
        assert mask is not None
        hs = self.transformer(self.input_proj(src), mask, self.query_embed.weight, pos[-1])[0]
        # self.input_proj降维 cnn得到的特征图维度2048太大了把它降低到256
        # 跳到 transformer.py中的Transformer class
  • transformer.py中的Transformer class
class Transformer(nn.Module):

    def __init__(self, d_model=512, nhead=8, num_encoder_layers=6,
                 num_decoder_layers=6, dim_feedforward=2048, dropout=0.1,
                 activation="relu", normalize_before=False,
                 return_intermediate_dec=False):
        super().__init__()

        encoder_layer = TransformerEncoderLayer(d_model, nhead, dim_feedforward,
                                                dropout, activation, normalize_before)
        encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
        self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)

        decoder_layer = TransformerDecoderLayer(d_model, nhead, dim_feedforward,
                                                dropout, activation, normalize_before)
        decoder_norm = nn.LayerNorm(d_model)
        self.decoder = TransformerDecoder(decoder_layer, num_decoder_layers, decoder_norm,
                                          return_intermediate=return_intermediate_dec)

        self._reset_parameters()

        self.d_model = d_model
        self.nhead = nhead

    def _reset_parameters(self):
        for p in self.parameters():
            if p.dim() > 1:
                nn.init.xavier_uniform_(p)

    def forward(self, src, mask, query_embed, pos_embed):
        # flatten NxCxHxW to HWxNxC
        bs, c, h, w = src.shape
        src = src.flatten(2).permute(2, 0, 1) # NxCxHxW to HWxNxC
        # N是batchsize大小 把特征图长×宽得到token个数
        # 输出大小 [token个数,batch size,token 长度]
        pos_embed = pos_embed.flatten(2).permute(2, 0, 1) # NxCxHxW to HWxNxC
        query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1)
        # query_embed 在decoder中用到,大小为[100,batch size,token 长度]
        mask = mask.flatten(1) # mask大小 [token个数,batch size]

        tgt = torch.zeros_like(query_embed)
        # tgt在decoder中用到
        memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed)
        # 跳到  transformer.py中的TransformerEncoderLayer class
        # encoder的输出大小 [token个数,batch size,token长度]
        hs = self.decoder(tgt, memory, memory_key_padding_mask=mask,
                          pos=pos_embed, query_pos=query_embed)
        return hs.transpose(1, 2), memory.permute(1, 2, 0).view(bs, c, h, w)
  • transformer.py中的TransformerEncoderLayer class
class TransformerEncoderLayer(nn.Module):

    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
                 activation="relu", normalize_before=False):
        super().__init__()
        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
        # Implementation of Feedforward model
        self.linear1 = nn.Linear(d_model, dim_feedforward)
        self.dropout = nn.Dropout(dropout)
        self.linear2 = nn.Linear(dim_feedforward, d_model)

        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout1 = nn.Dropout(dropout)
        self.dropout2 = nn.Dropout(dropout)

        self.activation = _get_activation_fn(activation)
        self.normalize_before = normalize_before

    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
        return tensor if pos is None else tensor + pos

    def forward_post(self,
                     src,
                     src_mask: Optional[Tensor] = None,
                     src_key_padding_mask: Optional[Tensor] = None,
                     pos: Optional[Tensor] = None):
        q = k = self.with_pos_embed(src, pos) # 只有K和Q 加入了位置编码
        # q k 的大小都为 [token个数,batch size,token长度]
        src2 = self.self_attn(q, k, value=src, attn_mask=src_mask,
                              key_padding_mask=src_key_padding_mask)[0]
        # pytorch自带函数
        # src_mask 是nlp中防止透题用的,这里不用
        # src_key_padding_mask padding为true的不计算
        # 返回值 [新的特征图,权重项] 第二项不需要
        src = src + self.dropout1(src2)
        src = self.norm1(src)
        src2 = self.linear2(self.dropout(self.activation(self.linear1(src))))
        src = src + self.dropout2(src2)
        src = self.norm2(src)
        return src
  • transformer.py中的TransformerEncoder class
    将TransformerEncoderLayer 重复多次
class TransformerEncoder(nn.Module):

    def __init__(self, encoder_layer, num_layers, norm=None):
        super().__init__()
        self.layers = _get_clones(encoder_layer, num_layers)
        self.num_layers = num_layers
        self.norm = norm

    def forward(self, src,
                mask: Optional[Tensor] = None,
                src_key_padding_mask: Optional[Tensor] = None,
                pos: Optional[Tensor] = None):
        output = src

        for layer in self.layers:
            output = layer(output, src_mask=mask,
                           src_key_padding_mask=src_key_padding_mask, pos=pos)

        if self.norm is not None:
            output = self.norm(output)

        return output

3. decoder部分

在这里插入图片描述
detr要学习的核心 100个queries向量tgt 大小[100,batch size,token长度]
第一次初始值都为0
最终输出的100个queries最后预测框
无论输入为什么,都输出100个框

  • transformer.py中的Transformer class
class Transformer(nn.Module):

    def __init__(self, d_model=512, nhead=8, num_encoder_layers=6,
                 num_decoder_layers=6, dim_feedforward=2048, dropout=0.1,
                 activation="relu", normalize_before=False,
                 return_intermediate_dec=False):
        super().__init__()

        encoder_layer = TransformerEncoderLayer(d_model, nhead, dim_feedforward,
                                                dropout, activation, normalize_before)
        encoder_norm = nn.LayerNorm(d_model) if normalize_before else None
        self.encoder = TransformerEncoder(encoder_layer, num_encoder_layers, encoder_norm)

        decoder_layer = TransformerDecoderLayer(d_model, nhead, dim_feedforward,
                                                dropout, activation, normalize_before)
        decoder_norm = nn.LayerNorm(d_model)
        self.decoder = TransformerDecoder(decoder_layer, num_decoder_layers, decoder_norm,
                                          return_intermediate=return_intermediate_dec)

        self._reset_parameters()

        self.d_model = d_model
        self.nhead = nhead

    def _reset_parameters(self):
        for p in self.parameters():
            if p.dim() > 1:
                nn.init.xavier_uniform_(p)

    def forward(self, src, mask, query_embed, pos_embed):
        # flatten NxCxHxW to HWxNxC
        bs, c, h, w = src.shape
        src = src.flatten(2).permute(2, 0, 1) # NxCxHxW to HWxNxC
        # N是batchsize大小 把特征图长×宽得到token个数
        # 输出大小 [token个数,batch size,token 长度]
        pos_embed = pos_embed.flatten(2).permute(2, 0, 1) # NxCxHxW to HWxNxC
        query_embed = query_embed.unsqueeze(1).repeat(1, bs, 1)
        # query_embed 在decoder中用到,大小为[100,batch size,token 长度]
        mask = mask.flatten(1) # mask大小 [token个数,batch size]

        tgt = torch.zeros_like(query_embed) # 一开始初始化为0
        # tgt在decoder中用到
        memory = self.encoder(src, src_key_padding_mask=mask, pos=pos_embed)
        hs = self.decoder(tgt, memory, memory_key_padding_mask=mask,
                          pos=pos_embed, query_pos=query_embed)
        # 跳到  transformer.py中的TransformerDecoderLayer class
        return hs.transpose(1, 2), memory.permute(1, 2, 0).view(bs, c, h, w)
  • transformer.py中的TransformerDecoderLayer class
class TransformerDecoderLayer(nn.Module):

    def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1,
                 activation="relu", normalize_before=False):
        super().__init__()
        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
        self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)
        # Implementation of Feedforward model
        self.linear1 = nn.Linear(d_model, dim_feedforward)
        self.dropout = nn.Dropout(dropout)
        self.linear2 = nn.Linear(dim_feedforward, d_model)

        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.norm3 = nn.LayerNorm(d_model)
        self.dropout1 = nn.Dropout(dropout)
        self.dropout2 = nn.Dropout(dropout)
        self.dropout3 = nn.Dropout(dropout)

        self.activation = _get_activation_fn(activation)
        self.normalize_before = normalize_before

    def with_pos_embed(self, tensor, pos: Optional[Tensor]):
        return tensor if pos is None else tensor + pos

    def forward_post(self, tgt, memory,
                     tgt_mask: Optional[Tensor] = None,
                     memory_mask: Optional[Tensor] = None,
                     tgt_key_padding_mask: Optional[Tensor] = None,
                     memory_key_padding_mask: Optional[Tensor] = None,
                     pos: Optional[Tensor] = None,
                     query_pos: Optional[Tensor] = None):
        q = k = self.with_pos_embed(tgt, query_pos)
        # 大小[100,batch size,token长度]
        tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask,
                              key_padding_mask=tgt_key_padding_mask)[0]
        # 先自注意力机制
        # tgt_mask 和 tgt_key_padding_mask 都为None
        tgt = tgt + self.dropout1(tgt2)
        tgt = self.norm1(tgt)
        tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos),
                                   key=self.with_pos_embed(memory, pos),
                                   value=memory, attn_mask=memory_mask,
                                   key_padding_mask=memory_key_padding_mask)[0]
        # q 是 100个queries
        # 图像提供k,v 大小[图像token个数,batch size,token 长度]
        tgt = tgt + self.dropout2(tgt2)
        tgt = self.norm2(tgt)
        tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt))))
        tgt = tgt + self.dropout3(tgt2)
        tgt = self.norm3(tgt)
        return tgt
  • transformer.py中的TransformerDecoder class
    将TransformerDecoderLayer 重复多次
    tgt 在经过第一层之后就不为0了
class TransformerDecoder(nn.Module):

    def __init__(self, decoder_layer, num_layers, norm=None, return_intermediate=False):
        super().__init__()
        self.layers = _get_clones(decoder_layer, num_layers)
        self.num_layers = num_layers
        self.norm = norm
        self.return_intermediate = return_intermediate

    def forward(self, tgt, memory,
                tgt_mask: Optional[Tensor] = None,
                memory_mask: Optional[Tensor] = None,
                tgt_key_padding_mask: Optional[Tensor] = None,
                memory_key_padding_mask: Optional[Tensor] = None,
                pos: Optional[Tensor] = None,
                query_pos: Optional[Tensor] = None):
        output = tgt

        intermediate = []

        for layer in self.layers:
            output = layer(output, memory, tgt_mask=tgt_mask,
                           memory_mask=memory_mask,
                           tgt_key_padding_mask=tgt_key_padding_mask,
                           memory_key_padding_mask=memory_key_padding_mask,
                           pos=pos, query_pos=query_pos)
            if self.return_intermediate:
                intermediate.append(self.norm(output))

        if self.norm is not None:
            output = self.norm(output)
            if self.return_intermediate:
                intermediate.pop()
                intermediate.append(output)

        if self.return_intermediate:
            return torch.stack(intermediate)

        return output.unsqueeze(0)

4. 输出预测

  • detr.py中的DETR class
    把decoder产生的100个token进行输出
    两个任务:检测(回归4个值)和分类
class DETR(nn.Module):
	def __init__(self, backbone, transformer, num_classes, num_queries, aux_loss=False):
		...
		self.class_embed = nn.Linear(hidden_dim, num_classes + 1)
        self.bbox_embed = MLP(hidden_dim, hidden_dim, 4, 3)

	def forward(self, samples: NestedTensor):
		features, pos = self.backbone(samples)
        hs = self.transformer(self.input_proj(src), mask, self.query_embed.weight, pos[-1])[0]
		# decoder输出大小 [batch size,100,token长度]
        outputs_class = self.class_embed(hs) # 分类任务
        outputs_coord = self.bbox_embed(hs).sigmoid() # 检测/回归任务,输出四个值,sigmoid让输出为正数
        out = {'pred_logits': outputs_class[-1], 'pred_boxes': outputs_coord[-1]}

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

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

相关文章

21个 JVM 技术点详解(附面试解答)

最近兄弟们面试,都逃不过被 JVM 问题轰炸的命运,为啥面试官喜欢拿 JVM 说事呢?V 哥认为,除了要问倒你,就是要压你薪水,咱绝对不能怂,俗话说的好:兵来将挡,水来土掩&#…

串行通信协议 SPI

SPI(Serial Peripheral Interface)是一种串行通信协议,常用于连接微控制器、存储器、传感器和其他外围设备。SPI通常由一个主设备(通常是微控制器)和一个或多个从设备组成。 1、SPI通信一般由四根线组成: SCLK&#x…

2024 全新测算系统网站源码 二开修复完整版

源码介绍 安装教程 环境:程序为以PHPMYSQL架构,PHP版本5.6,让系统更畅快稳定。适合linux或者windows。 修改数据库/config/inc_config.php后导入数据库 子目录绑定ffsm 后台地址/acs 后台账号admin密码114077 支持功能:微信…

NO9 蓝桥杯单片机实践之串口通信的使用

1 回顾 串口通信的代码编写结构还是与中断一样,不同的是: 初始中断函数条件涉及到串口通信相关的寄存器和定时器1相关的寄存器(定时器1用于产生波特率),但初始条件中的中断寄存器只考虑串口通信而不考虑定时器1。 vo…

利用 Claude 3 on Amazon Bedrock 和 Streamlit 的“终极组合”,开发智能对话体验

概述 通过本文,您将学会如何利用 Streamlit 框架快速搭建前端交互界面。该界面将集成图像上传功能,让用户可以方便地提交待处理图片。在后端,我们将借助 Amazon Bedrock 的 Message API,调用 Claude 3 家族中的 Sonnet 模型对图像…

Docker-镜像仓库

Docker ⛅Docker-Registry🌠分类🌠镜像仓库工作机制🌠常用的镜像仓库🌠镜像仓库命令☃️docker login☃️docker pull☃️docker push☃️docker search☃️docker logout 🌠镜像命令[部分]☃️docker images☃️docke…

突破边界:Web3开启数字化社会的新纪元

引言 随着科技的不断进步和数字化社会的发展,Web3正逐渐成为了人们关注的焦点。作为新一代互联网的演进形态,Web3具有突破传统边界、实现去中心化的特点,被认为将开启数字化社会的新纪元。本文将深入探讨Web3的概念、特点、应用场景&#xf…

如何在WSL中的ubuntu编译Linux内核并且安装使用ebpf?

如何在WSL中的ubuntu编译Linux内核并且安装使用ebpf? 步骤1 编译安装内核获取源码修改配置编译编译成功后配置重启WSL测试 步骤2 安装bcc安装依赖下载bcc,编译测试 环境: wsl2windows 11 步骤1 编译安装内核 去https://kernel.org/找你想要的版本, …

Spark-Scala语言实战(4)

在之前的文章中,我们学习了如何在scala中定义无参,带参以及匿名函数。想了解的朋友可以查看这篇文章。同时,希望我的文章能帮助到你,如果觉得我的文章写的不错,请留下你宝贵的点赞,谢谢。 Spark-Scala语言…

用css滤镜做颜色不同的数据卡片(背景图对于css滤镜的使用)

<template> <div class"xx_modal_maincon"><div class"xx_model_bt">履约起始日至计算日配额及履约情况</div><el-row><el-col :span"6"><div class"xx_modal_mod"><div class"mod…

asp.net在线租车平台

说明文档 运行前附加数据库.mdf&#xff08;或sql生成数据库&#xff09; 主要技术&#xff1a; 基于asp.net架构和sql server数据库 功能模块&#xff1a; asp.net在线租车平台 用户功能有首页 行业新闻用户注册车辆查询租车介绍访问后台 后台管理员可以进行用户管理 管…

第七届强网杯-PWN-【simpleinterpreter】

对于一个刚入门的三个月的菜鸡pwn手打算按照难度慢慢复现qwb的题目 先simpleinterpreter吧 simpleinterpreter libc 2.27 逆向 解释器相关用到的陌生函数 法1 方法1参考链接 程序实现了一个 C 语言解释器,可用的关键字如下: char else enum if int return sizeof whi…

NVIDIA 推出地球-2云平台,使用AI超级计算机的模拟技术,预测整个地球的气候变化

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…

视频无水印批量下载软件|抖音视频提取工具

视频无水印批量下载软件 在当今社交媒体充斥着大量优质视频内容的时代&#xff0c;很多用户都希望能够轻松下载自己喜爱的视频进行收藏或分享。为了满足用户的需求&#xff0c;我们特别推出了一款专业的视频无水印批量下载软件&#xff0c;让您可以方便快捷地获取喜爱的视频内容…

[C++]20:unorderedset和unorderedmap结构和封装。

unorderedset和unorderedmap结构和封装 一.哈希表&#xff1a;1.直接定址法&#xff1a;2.闭散列的开放定址法&#xff1a;1.基本结构&#xff1a;2.insert3.find4.erase5.补充&#xff1a;6.pair<k,v> k的数据类型&#xff1a; 3.开散列的拉链法/哈希桶&#xff1a;1.基…

Jackson 2.x 系列【3】解析器 JsonParser

有道无术&#xff0c;术尚可求&#xff0c;有术无道&#xff0c;止于术。 本系列Jackson 版本 2.17.0 源码地址&#xff1a;https://gitee.com/pearl-organization/study-seata-demo 文章目录 1. 前言2. 解析原理3. 案例演示3.1 创建 JsonParser3.2 解析3.3 读取3.4 测试 1. 前…

流畅的 Python 第二版(GPT 重译)(三)

第五章&#xff1a;数据类构建器 数据类就像孩子一样。它们作为一个起点是可以的&#xff0c;但要作为一个成熟的对象参与&#xff0c;它们需要承担一些责任。 马丁福勒和肯特贝克 Python 提供了几种构建简单类的方法&#xff0c;这些类只是一组字段&#xff0c;几乎没有额外功…

隐私计算实训营学习一:数据可信流通,从运维信任到技术信任

文章目录 一、数据可信流通二、数据可信流通的技术信任基础三、技术信任开启数据密态时代&#xff0c;保障广域数据可信流通 一、数据可信流通 可信数据流通体系&#xff1a;数据二十条第一次明确提出可信流通&#xff0c;建立数据来源可确认、使用范围可界定、流通过程可追溯…

【数据可视化】Echarts中的其它图表

个人主页 &#xff1a; zxctscl 如有转载请先通知 文章目录 1. 前言2. 绘制散点图2.1 绘制基本散点图2.2 绘制两个序列的散点图2.3 绘制带涟漪特效的散点图 3. 绘制气泡图3.1 绘制标准气泡图3.2 绘制各国人均寿命与GDP气泡图3.3 绘制城市A、城市B、城市C三个城市空气污染指数气…

智慧公园:AI智能分析网关V4城市公园视频智能监管方案

一、背景分析 随着天气渐渐转暖&#xff0c;城市公园的花卉也逐渐盛开&#xff0c;春暖花开时节&#xff0c;前往公园赏花游玩的城市居民也渐渐多起来&#xff0c;因此安全问题也成为相关监管部门的重要管理任务之一。随着科技的不断进步&#xff0c;智能监控技术已经成为现代…