关于yolov8的DFL模块(pytorch以及tensorrt)

先看代码

class DFL(nn.Module):
    """
    Integral module of Distribution Focal Loss (DFL).

    Proposed in Generalized Focal Loss https://ieeexplore.ieee.org/document/9792391
    """

    def __init__(self, c1=16):
        """Initialize a convolutional layer with a given number of input channels."""
        super().__init__()
        self.conv = nn.Conv2d(c1, 1, 1, bias=False).requires_grad_(False)
        x = torch.arange(c1, dtype=torch.float)
        self.conv.weight.data[:] = nn.Parameter(x.view(1, c1, 1, 1))
        self.c1 = c1

    def forward(self, x):
        """Applies a transformer layer on input tensor 'x' and returns a tensor."""
        b, c, a = x.shape  # batch, channels, anchors

        print("self.conv.weight.data[:] is : ",self.conv.weight.data[:])
        print("self.conv.weight.data[:] shape is : ",self.conv.weight.data[:].shape)
        print("x is : ",x)
        print("x.shape is : ",x.shape)
        print("x.view(b,4,self.c1,a) is : ",x.view(b,4,self.c1,a))
        print("x.view(b,4,self.c1,a).shape is : ",x.view(b,4,self.c1,a).shape)

        return self.conv(x.view(b, 4, self.c1, a).transpose(2, 1).softmax(1)).view(b, 4, a)
        # return self.conv(x.view(b, self.c1, 4, a).softmax(1)).view(b, 4, a)

这个类 DFL 是一个神经网络模块，继承自 nn.Module，是在PyTorch框架中定义自定义神经网络层的标准方式。这个 DFL 类实现了分布焦点损失（Distribution Focal Loss, DFL），这是在论文 “Generalized Focal Loss” 中提出的一个概念。下面是对这段代码的详细解释：

1、class DFL(nn.Module)：定义了一个名为 DFL 的类，它继承自 nn.Module，使其成为一个PyTorch的网络层。
2、def init(self, c1=16)：DFL 类的初始化方法。接收一个参数 c1，默认值是 16，代表输入通道的数量。
3、super().init()：调用父类 nn.Module 的初始化函数，这是在定义PyTorch模型时的标准做法。
4、self.conv = nn.Conv2d(c1, 1, 1, bias=False).requires_grad_(False)：定义了一个卷积层，该层有 c1 个输入通道，1个输出通道，卷积核大小1x1，没有偏置项，且不需要梯度更新（即在训练过程中不会更新这个卷积层的权重）。
5、x = torch.arange(c1, dtype=torch.float)：创建一个大小为 c1 的一维张量，这个张量包含了从0到 c1-1 的连续整数。
6、self.conv.weight.data[:] = nn.Parameter(x.view(1, c1, 1, 1))：初始化卷积层的权重。x 被转换成形状为 (1, c1, 1, 1) 的四维张量，并作为卷积层权重的值。
7、self.c1 = c1：存储输入通道数目的属性。
8、def forward(self, x)：定义了模块的前向传播方法，其中 x 是输入张量。
9、b, c, a = x.shape：获取输入张量 x 的形状，假设其是三维的，其中 b 是批处理大小，c 是通道数量，a 是锚点数量（注：锚点通常用于目标检测任务中）。
10、这段代码中还包含了一些打印语句，用于输出卷积层的权重和输入张量的形状等调试信息。
11、return self.conv(x.view(b, 4, self.c1, a).transpose(2, 1).softmax(1)).view(b, 4, a)：这是前向传播的关键操作。输入张量 x 首先被重塑为 (b, 4, self.c1, a)，这里假定 c 是 4*self.c1。然后 transpose(2, 1) 交换了通道和锚点的维度。softmax(1) 在第二个维度上（即原来的 self.c1 维度、现在的通道维度）应用softmax函数。最后，应用卷积操作并将结果重塑为 (b, 4, a)。

综上所述，DFL 类使用了卷积核对输入张量进行变换，旨在学习一种分布式的表示，其在目标检测等任务中可能用于学习预测概率分布。这种方法可能有利于模型更好地理解目标的不确定性。

以下是调试输出：

Ultralytics YOLOv8.1.8 🚀 Python-3.11.5 torch-2.0.0+cu118 CUDA:0 (NVIDIA GeForce RTX 3060 Laptop GPU, 6144MiB)
self.conv.weight.data[:] is :  tensor([[[[ 0.]],

         [[ 1.]],

         [[ 2.]],

         [[ 3.]],

         [[ 4.]],

         [[ 5.]],

         [[ 6.]],

         [[ 7.]],

         [[ 8.]],

         [[ 9.]],

         [[10.]],

         [[11.]],

         [[12.]],

         [[13.]],

         [[14.]],

         [[15.]]]], device='cuda:0')
self.conv.weight.data[:] shape is :  torch.Size([1, 16, 1, 1])
x is :  tensor([[[ 7.9609,  3.9328,  1.2542,  ...,  7.9261,  3.7103,  6.1628],
         [ 7.8865,  8.2141,  3.6136,  ...,  7.7927,  7.2668,  5.9885],
         [ 2.1200,  8.2323,  7.2977,  ...,  3.5018,  7.1541,  3.2515],
         ...,
         [-1.6378, -2.2544, -2.0439,  ..., -1.8033, -1.7783, -1.4680],
         [-1.9045, -2.5544, -2.3420,  ..., -2.0054, -1.9784, -1.6110],
         [-1.1409, -2.4363, -2.1418,  ..., -1.7273, -1.7041, -1.6811]]], device='cuda:0')
x.shape is :  torch.Size([1, 64, 21])
x.view(b,4,self.c1,a) is :  tensor([[[[ 7.9609,  3.9328,  1.2542,  ...,  7.9261,  3.7103,  6.1628],
          [ 7.8865,  8.2141,  3.6136,  ...,  7.7927,  7.2668,  5.9885],
          [ 2.1200,  8.2323,  7.2977,  ...,  3.5018,  7.1541,  3.2515],
          ...,
          [-1.3957, -2.2859, -2.3732,  ..., -1.6756, -1.7059, -1.4575],
          [-1.6145, -2.3682, -2.4476,  ..., -1.7892, -1.7984, -1.5309],
          [-0.8706, -1.7938, -1.8388,  ..., -1.6522, -1.6732, -1.5332]],

         [[ 8.3572,  9.8892,  9.1272,  ...,  4.1972,  4.2291,  6.8087],
          [ 8.2836,  9.8511,  9.0978,  ...,  7.4077,  7.2967,  6.6090],
          [ 2.7911,  2.6250,  2.3740,  ...,  7.2771,  7.1356,  3.5323],
          ...,
          [-1.6353, -2.0540, -1.9561,  ..., -0.9167, -1.0320, -1.4185],
          [-1.8191, -2.3518, -2.2370,  ..., -1.1207, -1.2171, -1.5694],
          [-1.1255, -2.2479, -2.0955,  ..., -0.5296, -0.6821, -1.8163]],

         [[-0.2927,  0.9935,  4.8185,  ...,  4.0401,  8.2405,  5.8280],
          [ 1.8495,  4.0922,  8.9220,  ...,  7.8240,  8.1252,  5.9634],
          [ 3.7216,  8.0900,  8.7783,  ...,  7.6322,  3.4239,  3.9682],
          ...,
          [-1.7413, -2.0473, -2.3148,  ..., -1.7863, -1.6267, -1.3612],
          [-1.9912, -2.2312, -2.4779,  ..., -1.9319, -1.7893, -1.5738],
          [-1.3506, -1.7374, -1.8736,  ..., -1.7203, -1.5202, -1.5913]],

         [[ 0.9126,  0.7135,  0.5577,  ...,  8.0598,  8.0426,  6.3850],
          [ 2.6471,  2.7828,  2.6682,  ...,  7.9502,  7.9280,  6.1044],
          [ 3.7130,  4.0446,  3.8203,  ...,  3.9169,  4.0009,  3.2179],
          ...,
          [-1.6378, -2.2544, -2.0439,  ..., -1.8033, -1.7783, -1.4680],
          [-1.9045, -2.5544, -2.3420,  ..., -2.0054, -1.9784, -1.6110],
          [-1.1409, -2.4363, -2.1418,  ..., -1.7273, -1.7041, -1.6811]]]], device='cuda:0')
x.view(b,4,self.c1,a).shape is :  torch.Size([1, 4, 16, 21])

在PyTorch框架中，x.view() 函数是非常常用来改变张量(Tensor)形状的方法。当使用x.view()时，你需要提供一个维度的新形状，而这个新形状必须要与原始张量包含的元素数量相匹配。换句话说，使用view可以在不改变数据内容的前提下，改变数据的形状。
这是 x.view() 方法的基本用法：

x.view(dim1, dim2, dim3, ...)

其中，dim1, dim2, dim3, … 是新的形状，每一个维度都是一个整数，代表了在该维度上的大小。可以使用 -1 来让PyTorch自动计算该维度的大小，但一次只能用在一个维度上。
请看以下代码中的 forward 方法里的 x.view() 的使用：

b, c, a = x.shape  # batch, channels, anchors
return self.conv(x.view(b, 4, self.c1, a).transpose(2, 1).softmax(1)).view(b, 4, a)

在这个例子中，x 是输入张量，其形状为 (b, c, a)，其中 b 是批次大小(batch size)，c 是通道数(channels)，a 是锚点数量(anchors)。这里的 c 应该等于 4*self.c1，这样才能通过 view 进行重塑。
x.view(b, 4, self.c1, a) 的意思是将 x 的形状由 (b, c, a) 改变为 (b, 4, self.c1, a)。此时，第二维度变成了 4，第三维度变成了 self.c1，而第四维度是 a。调用 view 后，张量的总元素数不变，但将这些元素按照新的形状重新排列。
在这个转换之后，x 经过了 .transpose(2, 1)，它会交换第二维和第三维。transpose(2, 1) 的结果是张量的形状变成了 (b, self.c1, 4, a)。
最后，.softmax(1) 在第二维上应用了softmax函数，它会计算该维度上的概率分布。然后经过自定义的1x1卷积核处理，并返回形状为 (b, 4, a) 的结果。
通过这种方式，x.view() 使得张量可以在不同神经网络操作中适应所需的形状，在保持数据元素不变的同时改变其结构。

tensorrt里面的dfl如下：

nvinfer1::IShuffleLayer* DFL(nvinfer1::INetworkDefinition* network, std::map<std::string, nvinfer1::Weights> weightMap, 
nvinfer1::ITensor& input, int ch, int grid, int k, int s, int p, std::string lname){

    nvinfer1::IShuffleLayer* shuffle1 = network->addShuffle(input);
    shuffle1->setReshapeDimensions(nvinfer1::Dims3{4, 16, grid});
    shuffle1->setSecondTranspose(nvinfer1::Permutation{1, 0, 2});
    nvinfer1::ISoftMaxLayer* softmax = network->addSoftMax(*shuffle1->getOutput(0));

    nvinfer1::Weights bias_empty{nvinfer1::DataType::kFLOAT, nullptr, 0};
    nvinfer1::IConvolutionLayer* conv = network->addConvolutionNd(*softmax->getOutput(0), 1, nvinfer1::DimsHW{1, 1}, weightMap[lname], bias_empty);
    conv->setStrideNd(nvinfer1::DimsHW{s, s});
    conv->setPaddingNd(nvinfer1::DimsHW{p, p});

    nvinfer1::IShuffleLayer* shuffle2 = network->addShuffle(*conv->getOutput(0));
    shuffle2->setReshapeDimensions(nvinfer1::Dims2{4, grid});

    return shuffle2;
}

下面放出DFL的onnx图：

在这里插入图片描述

tensorrtx里面处理的detect的代码为：

nvinfer1::IShuffleLayer* shuffle22_0 = network->addShuffle(*cat22_0->getOutput(0));
shuffle22_0->setReshapeDimensions(nvinfer1::Dims2{64 + kNumClass, (kInputH / 8) * (kInputW / 8)});

nvinfer1::ISliceLayer* split22_0_0 = network->addSlice(*shuffle22_0->getOutput(0), nvinfer1::Dims2{0, 0}, nvinfer1::Dims2{64, (kInputH / 8) * (kInputW / 8)}, nvinfer1::Dims2{1, 1});
nvinfer1::ISliceLayer* split22_0_1 = network->addSlice(*shuffle22_0->getOutput(0), nvinfer1::Dims2{64, 0}, nvinfer1::Dims2{kNumClass, (kInputH / 8) * (kInputW / 8)}, nvinfer1::Dims2{1, 1});
nvinfer1::IShuffleLayer* dfl22_0 = DFL(network, weightMap, *split22_0_0->getOutput(0), 4, (kInputH / 8) * (kInputW / 8), 1, 1, 0, "model.22.dfl.conv.weight");
nvinfer1::ITensor* inputTensor22_dfl_0[] = {dfl22_0->getOutput(0), split22_0_1->getOutput(0)};
nvinfer1::IConcatenationLayer* cat22_dfl_0 = network->addConcatenation(inputTensor22_dfl_0, 2);

nvinfer1::IShuffleLayer* shuffle22_1 = network->addShuffle(*cat22_1->getOutput(0));
shuffle22_1->setReshapeDimensions(nvinfer1::Dims2{64 + kNumClass, (kInputH / 16) * (kInputW / 16)});
nvinfer1::ISliceLayer* split22_1_0 = network->addSlice(*shuffle22_1->getOutput(0), nvinfer1::Dims2{0, 0}, nvinfer1::Dims2{64, (kInputH / 16) * (kInputW / 16)}, nvinfer1::Dims2{1, 1});
nvinfer1::ISliceLayer* split22_1_1 = network->addSlice(*shuffle22_1->getOutput(0), nvinfer1::Dims2{64, 0}, nvinfer1::Dims2{kNumClass, (kInputH / 16) * (kInputW / 16)}, nvinfer1::Dims2{1, 1});
nvinfer1::IShuffleLayer* dfl22_1 = DFL(network, weightMap, *split22_1_0->getOutput(0), 4, (kInputH / 16) * (kInputW / 16), 1, 1, 0, "model.22.dfl.conv.weight");
nvinfer1::ITensor* inputTensor22_dfl_1[] = {dfl22_1->getOutput(0), split22_1_1->getOutput(0)};
nvinfer1::IConcatenationLayer* cat22_dfl_1 = network->addConcatenation(inputTensor22_dfl_1, 2);

nvinfer1::IShuffleLayer* shuffle22_2 = network->addShuffle(*cat22_2->getOutput(0));
shuffle22_2->setReshapeDimensions(nvinfer1::Dims2{64 + kNumClass, (kInputH / 32) * (kInputW / 32)});
nvinfer1::ISliceLayer* split22_2_0 = network->addSlice(*shuffle22_2->getOutput(0), nvinfer1::Dims2{0, 0}, nvinfer1::Dims2{64, (kInputH / 32) * (kInputW / 32)}, nvinfer1::Dims2{1, 1});
nvinfer1::ISliceLayer* split22_2_1 = network->addSlice(*shuffle22_2->getOutput(0), nvinfer1::Dims2{64, 0}, nvinfer1::Dims2{kNumClass, (kInputH / 32) * (kInputW / 32)}, nvinfer1::Dims2{1, 1});
nvinfer1::IShuffleLayer* dfl22_2 = DFL(network, weightMap, *split22_2_0->getOutput(0), 4, (kInputH / 32) * (kInputW / 32), 1, 1, 0, "model.22.dfl.conv.weight");
nvinfer1::ITensor* inputTensor22_dfl_2[] = {dfl22_2->getOutput(0), split22_2_1->getOutput(0)};
nvinfer1::IConcatenationLayer* cat22_dfl_2 = network->addConcatenation(inputTensor22_dfl_2, 2);

nvinfer1::IPluginV2Layer* yolo = addYoLoLayer(network, std::vector<nvinfer1::IConcatenationLayer *>{cat22_dfl_0, cat22_dfl_1, cat22_dfl_2});
yolo->getOutput(0)->setName(kOutputTensorName);
network->markOutput(*yolo->getOutput(0));

tensorrtx里面的处理手段是将三个output分别经过dfl等一系列处理，再拼回去，再看onnx图：请添加图片描述

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

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

相关文章

嵌入式C语言（六）

嵌入式C语言（六）

对齐这个事情在内核中可不是个什么小事&#xff0c;内核中涉及到内存方面的都需要非常的谨慎。 上一篇我们知道了可以通过__attribute__来声明属性&#xff0c;也知道了section这个属性&#xff0c;这篇我们来看看关于内存对齐使用的两个属性–>aligned和packed 地址对齐&…
阅读更多...
Altium Designer如何对走线模式进行切换

Altium Designer如何对走线模式进行切换

AD软件提供了比较智能的走线模式切换功能&#xff0c;可以根据个人习惯进行切换&#xff0c;能有效的提高了PCB设计效率。 点击界面右上角系统参数的图标 或者在pcb界面中使用快捷键OP进入到优选项界面&#xff0c;然后选中 PCB Editor-Interactive Routing&#xff0c;在布线…
阅读更多...
ubuntu設定QGC獲取pixhawk Mini4(PX4 Mini 4) 的imu信息

ubuntu設定QGC獲取pixhawk Mini4(PX4 Mini 4) 的imu信息

ubuntu20.04 QGC使用v4.3.0的版本 飛控pixhawk Mini4 飛控上只使用一條micro USB連接電腦&#xff0c;沒有其他線 安裝命令 sudo apt-get remove modemmanager -y sudo apt install gstreamer1.0-plugins-bad gstreamer1.0-libav gstreamer1.0-gl -y sudo apt install libf…
阅读更多...
Vue：纯前端实现文件拖拽上传

Vue：纯前端实现文件拖拽上传

先看一下拖拽相关的事件&#xff1a;dragover、dragenter drop和dragleave 。 dragover事件&#xff1a;当被拖动的元素在一个可放置目标上方时&#xff0c;该事件会被触发。 通常&#xff0c;我们会使用event.preventDefault()方法来取消浏览器默认的拖放行为&#xff0c;以便…
阅读更多...
amv是什么文件格式？如何播放amv视频？

amv是什么文件格式？如何播放amv视频？

AMV文件格式源自于中国公司Actions Semiconductor&#xff0c;最初作为其MP4播放器中使用的专有视频格式。产生于数码媒体发展的需求下&#xff0c;AMV格式为小屏幕便携设备提供了一种高度压缩的视频存储方案。 AMV文件格式的主要特性与使用场景 AMV格式以其独特的特性在小尺寸…
阅读更多...
复合式统计图绘制方法（7）

复合式统计图绘制方法（7）

复合式统计图绘制方法&#xff08;7&#xff09; 常用的统计图有条形图、柱形图、折线图、曲线图、饼图、环形图、扇形图。 前几类图比较容易绘制&#xff0c;饼图环形图绘制较难。 在统计图的应用方面&#xff0c;有时候有两个关联的统计学的样本值要用统计图来表达&#xff0…
阅读更多...
运动想象 (MI) 迁移学习系列 (5) : SSMT

运动想象 (MI) 迁移学习系列 (5) : SSMT

运动想象迁移学习系列:SSMT 0. 引言1. 主要贡献2. 网络结构3. 算法4. 补充4.1 为什么设置一种新的适配器&#xff1f;4.2 动态加权融合机制究竟是干啥的&#xff1f; 5. 实验结果6. 总结欢迎来稿 论文地址&#xff1a;https://link.springer.com/article/10.1007/s11517-024-0…
阅读更多...
天府锋巢直播产业基地：直播带岗，成都直播基地奔向产业化

天府锋巢直播产业基地：直播带岗，成都直播基地奔向产业化

天府锋巢直播产业基地位于成都市天府新区科学城板块&#xff0c;是一座集直播带岗、电商孵化、产业培训、供应链整合等多功能于一体的现代化全域直播产业基地。近年来&#xff0c;随着成都直播产业的蓬勃发展&#xff0c;成都积极响应市场需求&#xff0c;致力于打造出西部地区…
阅读更多...
linux进程间通信-共享内存

linux进程间通信-共享内存

一、共享内存是什么 在Linux系统中&#xff0c;共享内存是一种IPC&#xff08;进程间通信&#xff09;方式&#xff0c;它可以让多个进程在物理内存中共享一段内存区域。 这种共享内存区域被映射到多个进程的虚拟地址空间中&#xff0c;使得多个进程可以直接访问同一段物理内存…
阅读更多...
【Python可视化系列】一文教你绘制雷达图（源码）

【Python可视化系列】一文教你绘制雷达图（源码）

这是我的第234篇原创文章。 一、引言 雷达图是以从同一点开始的轴上表示的三个或更多个定量变量的二维图表的形式显示多变量数据的图形方法&#xff0c;也称为蜘蛛图或星形图。雷达图通常用于综合分析多个指标&#xff0c;具有完整&#xff0c;清晰和直观的优点。通常由多个等…
阅读更多...
Constrained Iterative LQR 自动驾驶中使用的经典控制算法

Constrained Iterative LQR 自动驾驶中使用的经典控制算法

Motion planning 运动规划在自动驾驶领域是一个比较有挑战的部分。它既要接受来自上层的行为理解和决策的输出，也要考虑一个包含道路结构和感知所检测到的所有障碍物状态的动态世界模型。最终生成一个满足安全性和可行性约束并且具有理想驾驶体验的轨迹。 通常，motion plann…
阅读更多...
遥感影像植被波谱特征总结

遥感影像植被波谱特征总结

植被跟太阳辐射的相互关系有别于其他物质&#xff0c;如裸土、水体等&#xff0c;比如植被的“红边”现象&#xff0c;即在<700nm附近强吸收&#xff0c;>700nm高反射。很多因素影响植被对太阳辐射的吸收和反射&#xff0c;包括波长、水分含量、色素、养分、碳等。 研究…
阅读更多...
Kubernetes--ingress实现七层负载

Kubernetes--ingress实现七层负载

目录 一、传统方式&#xff1a;不借助ingress实现七层代理 二、nginx-ingress 三、使用ingress实现七层代理 四、部署ingrss-nginx及功能 五、样例 1.Ingress-nginx HTTP代理访问 2.Ingress HTTPS代理访问&#xff08;会话卸载层&#xff09; 3.Nginx进行BasicAuth&…
阅读更多...
亚马逊店铺解决和预防订单下滑的技巧

亚马逊店铺解决和预防订单下滑的技巧

1. 保持账号的良好表现。不要销售侵权产品&#xff0c;发货要及时&#xff0c;能有追踪号的就带可查询追踪号&#xff0c;能发FBA的就通过FBA发货。 2. 持续做好产品优化工作&#xff0c;及时留意大环境的变化和平台政策变动。遇到编辑权限受限&#xff0c;可开case咨询或申请…
阅读更多...
【数据库】软件测试之MySQL数据库练习题目

【数据库】软件测试之MySQL数据库练习题目

有表如下&#xff1a; Student 学生表 SC 成绩表 Course 课程表 Teacher 老师表 每个学生可以学习多门课程&#xff0c;每一个课程都有得分&#xff0c;每一门课程都有老师来教&#xff0c;一个老师可以教多个学生 1、查询姓‘朱’的学生名单 select * from Student whe…
阅读更多...
vb机试考试成绩分析与统计,设计与实现(高数概率统计)-141-(代码+程序说明)

vb机试考试成绩分析与统计,设计与实现(高数概率统计)-141-(代码+程序说明)

转载地址http://www.3q2008.com/soft/search.asp?keyword141 前言: 为何口出狂言,作任何VB和ASP的系统, 这个就是很好的一个证明 :) 又有些狂了... 数据库操作谁都会,接触的多了也没什么难的,VB编程难在哪?算法上,这个是一个算法题的毕业设计,里面涉及到对试卷的 平均分,最…
阅读更多...
AI编程已有公司纳入绩效，你的AI编程工具是什么？

AI编程已有公司纳入绩效，你的AI编程工具是什么？

自从ChatGPT带动全球AI热潮&#xff0c;AI席卷着各行各业。编程界也不例外&#xff0c;最出名的摸过OpenAI与GitHub联合开发的Github Copilot。Github Copilot带动了一大堆AI编程工具的出现。后来Github Copilot付费了&#xff0c;再加上网络方面的问题&#xff0c;在国内使用G…
阅读更多...
基于PHP的店家服务与管理交互平台

基于PHP的店家服务与管理交互平台

目 录 摘 要 I Abstract II 引 言 1 1相关技术 3 1.1 PHP 3 1.2 ThinkPHP框架 3 1.2.1 Struts结构 3 1.2.2 MVC 3 1.2 Tomcat服务器 3 1.3 MySQL数据库 3 1.4 LayUI框架 4 1.5 ECharts 4 1.6 本章小结 4 2 系统分析 5 2.1 功能需求 5 2.2 用例分析 6 2.3 非功能需求 8 2.4 本章…
阅读更多...
MySQL--索引类型详解

MySQL--索引类型详解

索引的类型 主键索引&#xff1a; PRIMARY KEY&#xff0c;当一张表的某个列是主键的时候&#xff0c;该列就是主键索引&#xff0c;一张表只允许有一个主键索引&#xff0c;主键所在的列不能为空。 创建主键索引的SQL语法&#xff1a; # 给user表中的id字段创建名为id_ind…
阅读更多...
【Datawhale学习笔记】从大模型到AgentScope

【Datawhale学习笔记】从大模型到AgentScope

从大模型到AgentScope AgentScope是一款全新的Multi-Agent框架&#xff0c;专为应用开发者打造&#xff0c;旨在提供高易用、高可靠的编程体验&#xff01; 高易用&#xff1a;AgentScope支持纯Python编程&#xff0c;提供多种语法工具实现灵活的应用流程编排&#xff0c;内置…
阅读更多...
最新文章

Copyright @ 2022~2023