scratch lenet(12): LeNet-5输出层和损失函数的计算

news2024/11/19 19:23:52

文章目录

    • 1. 目的
    • 2. 输出层结构
      • 2.1 Gaussian Connection
      • 2.2 Gaussian Connection 的 weight 可视化
    • 3. Loss Function
      • 3.1 当前类别判断错误时，loss function 中的项（基本项）
      • 3.2 判断为其他类别时， loss function 中的项（惩罚项）
    • 4. 代码实现
      • 4.1 输出层的前向计算
      • 4.2 Loss Function 的实现
    • References

1. 目的

弄清 LeNet-5 的论文原文 LeCun-98.pdf1 中的输出层的结构，以及损失函数的计算公式。

的确网络上已经有很多 LeNet-5 的现代实现了， 但过于现代导致和原版相差太多。本篇 blog 尽可能贴合论文原文， 不希望人云亦云照搬已有结果， 根据论文进行复现追求的是“一致性”。假设没有互联网上已经存在的各种 LeNet-5 的实现， 也应该能按论文原文做出实现。

2. 输出层结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-93L5Wh2q-1687600825416)(LeNet-5_gaussian_connection_rbf.png)]

2.1 Gaussian Connection

博客2 给出了 Gaussian Connection 的白话解释：高斯连接的输出就是输出结果，不需要套用激活函数； 高斯连接需要和欧几里得径向基函数（Euclidean Radial Basic Functions）配合使用。

Finally, the output layer is composed of Euclidean Radial Basis Function units (RBF), one for each class, with 84 inputs each. The output each RBF unit y i y_i yi​ is computed as follows:
y i = ∑ j ( x j − w i j ) 2 y_i = \sum_j(x_j - w_{ij})^2 yi​=j∑​(xj​−wij​)2

2.2 Gaussian Connection 的 weight 可视化

按论文原文， Gaussian connection 的 weight 只有两种取值： 1 和 -1。不妨做一个映射，把1映射到255，把-1映射到0，就得到一幅图像。没错， Gaussian connection 的 weight 只有10个，每个代表一个 ascii 打印形式的数字（0-9），大小是 7x12 = 84 像素。

首先是制作每个数字的 ascii 表示， 然后保存为 .pgm 格式的图像.

可视化：
在这里插入图片描述

存储 pgm 图像：

void write_pgm_image(uchar* image, int width, int height, const char* filename)
{
    FILE* fout = fopen(filename, "wb");
    fprintf(fout, "P5\n%d %d\n255\n", width, height);
    fwrite(image, width * height, 1, fout);
    fclose(fout);
}

完整代码：

uchar digits[10][84];

void make_7x12_digits()
{
    uchar d[10][84] =
    {
        {
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 1, 1, 1, 0, 0,
            0, 1, 1, 0, 1, 1, 0,
            1, 1, 0, 0, 0, 1, 1,
            1, 1, 0, 0, 0, 1, 1,
            1, 1, 0, 0, 0, 1, 1,
            1, 1, 0, 0, 0, 1, 1,
            0, 1, 1, 0, 1, 1, 0,
            0, 0, 1, 1, 1, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
        },
        
        {
            0, 0, 0, 1, 1, 0, 0,
            0, 0, 1, 1, 1, 0, 0,
            0, 1, 1, 1, 1, 0, 0,
            0, 0, 0, 1, 1, 0, 0,
            0, 0, 0, 1, 1, 0, 0,
            0, 0, 0, 1, 1, 0, 0,
            0, 0, 0, 1, 1, 0, 0,
            0, 0, 0, 1, 1, 0, 0,
            0, 0, 0, 1, 1, 0, 0,
            0, 1, 1, 1, 1, 1, 1,
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
        },
        
        {
            0, 0, 0, 0, 0, 0, 0,
            0, 1, 1, 1, 1, 0, 0,
            0, 1, 1, 0, 1, 1, 1,
            1, 0, 0, 0, 1, 1, 1,
            0, 0, 0, 1, 1, 1, 0,
            0, 0, 1, 1, 1, 0, 0,
            0, 1, 1, 0, 0, 0, 0,
            0, 1, 1, 0, 0, 0, 0,
            1, 1, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 1, 1,
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
        },

        {
            0, 1, 1, 1, 1, 1, 1,
            0, 0, 0, 0, 0, 1, 1,
            0, 0, 0, 0, 1, 1, 0,
            0, 0, 0, 1, 1, 0, 0,
            0, 0, 0, 1, 0, 0, 0,
            0, 0, 1, 1, 1, 1, 0,
            0, 0, 0, 0, 0, 1, 1,
            0, 0, 0, 0, 0, 1, 1,
            0, 0, 0, 0, 0, 1, 1,
            1, 1, 0, 0, 0, 1, 1,
            0, 1, 1, 1, 1, 1, 0,
            0, 0, 0, 0, 0, 0, 0,
        },
        
        {
            0, 0, 0, 0, 0, 0, 0,
            0, 1, 1, 0, 1, 1, 0,
            0, 1, 1, 0, 1, 1, 0,
            0, 1, 1, 0, 1, 1, 0,
            0, 1, 1, 0, 1, 1, 0,
            1, 1, 0, 0, 1, 1, 0,
            1, 1, 0, 0, 1, 1, 1,
            1, 1, 1, 1, 1, 1, 1,
            0, 0, 0, 0, 1, 1, 0,
            0, 0, 0, 0, 1, 1, 0,
            0, 0, 0, 0, 1, 1, 0,
            0, 0, 0, 0, 1, 1, 0,
        },

        {
            0, 0, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 1, 1,
            1, 1, 0, 0, 0, 0, 0,
            1, 1, 0, 0, 0, 0, 0,
            1, 1, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 0, 0,
            0, 0, 1, 1, 1, 1, 1,
            0, 0, 0, 0, 0, 1, 1,
            0, 0, 0, 0, 0, 1, 1,
            1, 1, 1, 0, 0, 1, 1,
            0, 1, 1, 1, 1, 1, 0,
            0, 0, 0, 0, 0, 0, 0,
        },
     
        {
            0, 0, 0, 1, 1, 1, 0,
            0, 1, 1, 1, 0, 0, 0,
            0, 1, 0, 0, 0, 0, 0,
            1, 1, 0, 0, 0, 0, 0,
            1, 1, 0, 0, 0, 0, 0,
            1, 1, 1, 1, 1, 1, 0,
            1, 1, 0, 0, 0, 1, 1,
            1, 1, 0, 0, 0, 0, 1,
            1, 1, 0, 0, 0, 0, 1,
            0, 1, 0, 0, 0, 1, 0,
            0, 1, 1, 1, 1, 1, 0,
            0, 0, 0, 0, 0, 0, 0,
        },
         
        {
            1, 1, 1, 1, 1, 1, 1,
            0, 0, 0, 0, 0, 1, 1,
            0, 0, 0, 0, 0, 1, 1,
            0, 0, 0, 0, 1, 1, 0,
            0, 0, 0, 1, 1, 0, 0,
            0, 0, 0, 1, 1, 0, 0,
            0, 0, 1, 1, 0, 0, 0,
            0, 1, 1, 0, 0, 0, 0,
            0, 1, 1, 0, 0, 0, 0,
            0, 1, 1, 0, 0, 0, 0,
            0, 1, 1, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
        },
         
        {
            0, 1, 1, 1, 1, 1, 0,
            1, 1, 0, 0, 0, 1, 1,
            1, 1, 0, 0, 0, 1, 1,
            1, 1, 0, 0, 0, 1, 1,
            0, 1, 1, 1, 1, 1, 0,
            1, 1, 0, 0, 0, 1, 1,
            1, 1, 0, 0, 0, 0, 1,
            1, 1, 0, 0, 0, 0, 1,
            1, 1, 0, 0, 0, 0, 1,
            0, 1, 1, 1, 1, 1, 0,
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
        },

        {
            0, 1, 1, 1, 1, 1, 0,
            1, 1, 0, 0, 0, 1, 1,
            1, 1, 0, 0, 0, 1, 1,
            1, 1, 0, 0, 0, 1, 1,
            1, 1, 0, 0, 1, 1, 1,
            0, 1, 1, 1, 1, 1, 1,
            0, 0, 0, 0, 0, 1, 1,
            0, 0, 0, 0, 0, 1, 0,
            0, 0, 0, 0, 1, 1, 0,
            0, 1, 1, 1, 1, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
            0, 0, 0, 0, 0, 0, 0,
        }
    };
    memcpy(digits, d, sizeof(digits));

    for (int k = 0; k < 10; k++)
    {
        char savename[50] = { 0 };
        sprintf(savename, "RBF%d.pgm", k);

        int width = 7;
        int height = 12;
        for (int i = 0; i < height; i++)
        {
            for (int j = 0; j < width; j++)
            {
                int idx = i * width + j;
                d[k][idx] = (d[k][idx] == 1) ? 255 : 0;
            }
        }

        write_pgm_image(d[k], width, height, savename);
    }
}

3. Loss Function

关于 Loss function， 先前卡在了不理解 Loss 函数中用的符号。后来在谷歌中搜了一下这篇论文的相关解读博客3, 4，发现其实 Introduction 部分就给出了符号的说明。

3.1 当前类别判断错误时，loss function 中的项（基本项）

Z p Z^p Zp: 第 p p p 个输入

Y p Y^p Yp: Z p Z^p Zp 的被识别的类别(推理结果)

W W W: 系统中可调整的参数的集合。

D p D^p Dp: Z p Z^p Zp 的正确类别（ground truth）

推理得到结果：
Y p = F ( Z p , W ) Y^p = F(Z^p, W) Yp=F(Zp,W)

Loss Function:
E p = D ( D p , F ( W , Z p ) E^p = D(D^p, F(W, Z^p) Ep=D(Dp,F(W,Zp)

E ( W ) = 1 P ∑ p = 1 P y D p ( Z p , W ) E(W) = \frac{1}{P}\sum_{p=1}^{P}y_{D^p}(Z^p, W) E(W)=P1​p=1∑P​yDp​(Zp,W)

其中 y D p y_{D^p} yDp​j 表示输入样本 Z p Z^p Zp 在对应的真实类别 D p D^p Dp 上的得分. 比如，对于 3.pgm 来说， D p = 3 D^p=3 Dp=3, output 层算出来的 RBF 有10个结果: y 0 , . . . , y 9 y_0, ..., y_9 y0​,...,y9​, 而 y 3 y_3 y3​ 就是 y D p y_{D^p} yDp​。

实际训练时， 样本数量 P > 1 P > 1 P>1, 我们收集每个样本的损失 y D p y_{D^p} yDp​, 累加起来， 就得到 E ( W ) E(W) E(W) 了。

3.2 判断为其他类别时， loss function 中的项（惩罚项）

尽管上述 cost function 适合大多数情况， 但它缺乏3个重要的性质。

第一， 如果我们允许 RBF 层的参数改变（本来是设定为1和-1），那么 E ( W ) E(W) E(W) 会得到一个平凡的、同时完全不可接受的解。（啥意思？？）在这个解中，所有 RBF 参数向量都相等， 并且F6的状态是常量，并且和参数向量相等。这种情况下， 网络开心地忽略输入， 并且所有 RBF 输入等于0。 如果 RBF 的权值不允许改变， 这种“坍缩现象”就不会出现。

第二个问题是，类别之间没有竞争。

为了解决这两个问题， 作者提出如下修正后的损失函数：
E ( W ) = 1 P ∑ p = 1 P ( y D p ( Z p , W ) + log ⁡ ( e − j + ∑ i e − y i ( Z p , W ) ) ) E(W) = \frac{1}{P}\sum_{p=1}^{P}(y_{D^p}(Z^p, W) + \log(e^{-j} + \sum_i e^{-y_i(Z^p, W)})) E(W)=P1​p=1∑P​(yDp​(Zp,W)+log(e−j+i∑​e−yi​(Zp,W)))

其中 j j j 是一个大于0的常数（但作者没有给出具体取值）。

其中 i i i 的取值，原文没说，可以理解为 D p D^p Dp 之外的类别，因为作为惩罚项它的目的是当其他类别的 RBF 输出值较小（接近0）时，惩罚项变大：

E ( W ) = 1 P ∑ p = 1 P ( y D p ( Z p , W ) + log ⁡ ( e − j + ∑ i ! = D p e − y i ( Z p , W ) ) ) E(W) = \frac{1}{P}\sum_{p=1}^{P}(y_{D^p}(Z^p, W) + \log(e^{-j} + \sum_{i!=D^p} e^{-y_i(Z^p, W)})) E(W)=P1​p=1∑P​(yDp​(Zp,W)+log(e−j+i!=Dp∑​e−yi​(Zp,W)))

例如对于 3.pgm 输入图， D p = 3 D^p=3 Dp=3, i ∈ { 0 , 1 , 2 , 4 , 5 , 6 , 7 , 8 , 9 } i \in \{ 0, 1, 2, 4, 5, 6, 7, 8, 9 \} i∈{0,1,2,4,5,6,7,8,9}.

4. 代码实现

4.1 输出层的前向计算


void forward_output()
{
    double* x = F6_output;
    double* y = RBF_output;
    double w[10][84];

    for (int i = 0; i < 10; i++)
    {
        for (int j = 0; j < 84; j++)
        {
            w[i][j] = (digits[i][j] == 255) ? 1 : -1;
        }
    }

    // Euclidean Radial Basis Functions (RBF)
    printf("Output layer: \n");
    for (int i = 0; i < 10; i++)
    {
        double sum = 0;
        for (int j = 0; j < 84; j++)
        {
            double diff = (x[j] - w[i][j]);
            sum += diff * diff;
        }
        y[i] = sum;
        printf("  y[%d] = %lf\n", i, y[i]);
    }
}

4.2 Loss Function 的实现

简单起见， 先只考虑单个样本对应的损失函数。 也就是， P = 1 P=1 P=1 时，

E ( W ) = y D p ( Z p , W ) + log ⁡ ( e − j + ∑ i ! = D p e − y i ( Z p , W ) ) E(W) = y_{D^p}(Z^p, W) + \log(e^{-j} + \sum_{i!=D^p} e^{-y_i(Z^p, W)}) E(W)=yDp​(Zp,W)+log(e−j+i!=Dp∑​e−yi​(Zp,W))

C 语言实现如下：

// compute loss for single input pattern D^p
void compute_loss()
{
    int correct_label = 3;
    double squared_error = RBF_output[correct_label];

    // compute penalty
    int j = 1;
    double value = m_exp(j);
    for (int i = 0; i < 10; i++)
    {
        if (i != correct_label)
        {
            value += m_exp(-RBF_output[i]);
        }
    }
    double penalty = m_log(value);
    double loss = squared_error + penalty;

    printf("loss is %lf\n", loss);
}

其中 m_exp() 是 exp 函数的C实现，见 scratch lenet(8): C语言实现 exp(x) 的计算5:

double m_exp(double x)
{
    double d;
    *((int*)&d + 0) = 0;
    *((int*)&d + 1) = (int)(1512775 * x + 1072632447);
    return d;
}

以及， m_log 是自然对数 ln 的C实现，见 scratch lenet(10): C语言计算log6

// logarithm for natural number `e`
// Mostly taken from https://gist.github.com/LingDong-/7e4c4cae5cbbc44400a05fba65f06f23
float m_log(float x)
{
    // x = m * 2^p, m \in [1, 2]
    // ln(x) = ln(m * 2^p) = ln(m) + ln(2) * p
    
    // determine p
    unsigned int bx = *(unsigned int *) (&x);
    unsigned int ex = bx >> 23;
    signed int p = (signed int)ex - (signed int)127;

    // determine m
    // exp:  00000000
    // frac: 0b11111111111111111111111 = 838607
    unsigned int bm = (127 << 23) | (bx & 8388607);
    float m = *(float *) (&bm);
    // printf("m = %f\n", m); 

    // determine ln(m) by Remez algorithm for m in [1, 2]
    float ln_m_approx_4th_order = -1.7417939 + (2.8212026 + (-1.4699568 + (0.44717955 - 0.056570851 * m) * m) * m) * m;
    //float ln_m_approx_3rd_order = -1.49278 + (2.11263 +(-0.729104 + 0.10969 * m) * m) * m;
    float ln_m_approx = ln_m_approx_4th_order;

    // combine the result
    const float ln2 = 0.6931471806;
    float res = ln_m_approx + ln2 * p;
    return res;
}

References

  1. lecun-98.pdf ↩︎

  2. ADS DataScience - 高斯连接(Gaussian Connection)：LetNet-5论文里使用的高斯连接到底是个啥？ ↩︎

  3. 论文笔记：Gradient-Based Learning Applied to Document Recognition ↩︎

  4. 論文筆記 - LeCun 1998 - Gradient-Based Learning Applied to Document Recognition ↩︎

  5. scratch lenet(8): C语言实现 exp(x) 的计算 ↩︎

  6. scratch lenet(10): C语言计算log ↩︎

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

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

相关文章

Spring发展历程及其体系结构

Spring发展历程及其体系结构

⭐作者介绍&#xff1a;大二本科网络工程专业在读&#xff0c;持续学习Java&#xff0c;努力输出优质文章 ⭐作者主页&#xff1a;逐梦苍穹 ⭐所属专栏&#xff1a;Spring 目录 发展历程体系结构 发展历程 体系结构 Spring框架的体系结构的主要组成部分&#xff1a; 核心容器…
阅读更多...
idea如何集成Tomcat

idea如何集成Tomcat

&#xff08;1&#xff09;、这里应该找Add Configuration点击这里&#xff1a;如果没有标志&#xff0c;点击Exit (2)、这里可以配置一个配置项&#xff1a; &#xff08;3&#xff09;、loacl是本地&#xff0c;那个是远程&#xff1a;这里我选择本地 &#xff08;4&#xff…
阅读更多...
代码随想录算法训练营第四十二天 | 01背包理论基础，01背包理论基础（滚动数组），416. 分割等和子集

代码随想录算法训练营第四十二天 | 01背包理论基础，01背包理论基础（滚动数组），416. 分割等和子集

代码随想录算法训练营第四十二天 | 01背包理论基础&#xff0c;01背包理论基础&#xff08;滚动数组&#xff09;&#xff0c;416. 分割等和子集 1.1 01背包理论基础 01背包 回溯法&#xff1a;暴力的解法是o(2^n)指数级别的时间复杂度&#xff0c;需要动态规划的解法来进行优…
阅读更多...
如果你曾经拥有python，那么现在你应该拥抱Julia吗？

如果你曾经拥有python，那么现在你应该拥抱Julia吗？

看完本文&#xff0c;您就会有较成熟的想法。 Julia和Python的区别是什么&#xff1f;为什么Julia适合用于大规模计算和超级计算机模拟&#xff1f; 你一定听说过Julia和Python这两个编程语言。虽然它们都可以用于从简单的机器学习应用程序到巨大的超级计算机模拟的所有方面&am…
阅读更多...
Gradio的Audio组件介绍

Gradio的Audio组件介绍

❤️觉得内容不错的话&#xff0c;欢迎点赞收藏加关注&#x1f60a;&#x1f60a;&#x1f60a;&#xff0c;后续会继续输入更多优质内容❤️ &#x1f449;有问题欢迎大家加关注私戳或者评论&#xff08;包括但不限于NLP算法相关&#xff0c;linux学习相关&#xff0c;读研读博…
阅读更多...
ImGUI项目建立(cmake+MinGW64)

ImGUI项目建立(cmake+MinGW64)

Dear ImGUI ImGui是一个轻量级的C图形界面库&#xff0c;它可以用于创建各种交互式的工具和编辑器。具有跨平台、高性能的特点。 ImGUI自身不能创建窗口&#xff0c;需要使用Win32API或glfw或SDL等工具来创建窗口&#xff0c;另外需要使用OpenGL或DirectX、vulkan用于渲染图形…
阅读更多...
excel数据的编排与整理——表格结构的整理(一)

excel数据的编排与整理——表格结构的整理(一)

excel数据的编排与整理——表格结构的整理(一) 1 快速移动一列数据到指定位置 1.1 移动到相邻行 1.1.1 题目内容 1.1.2 选中年龄列➡移动到左侧直到出现十字箭头 1.1.3 按下shift键和左键➡移动到指定位置,直到出现"T"字形 1.1.4 松开鼠标左键后,移动就完成了 1.2…
阅读更多...
Debian 12中安装Rstudio

Debian 12中安装Rstudio

1.Debian 12中安装R 打开终端&#xff0c;执行命令&#xff1a;#apt search r-base (注&#xff1a;此图为安装r-base后再来截图的)&#xff0c;Debian 12官方源中默认为r-base 4.2.2,如果想安装最新版&#xff08;当前最新版为R-4.3.0&#xff09;,可参考上次写的博文“Debi…
阅读更多...
thinkphp 反序列化漏洞

thinkphp 反序列化漏洞

文章目录 配置xdebug反序列化漏洞利用链详细分析poc1&#xff08;任意文件删除&#xff09;poc2&#xff08;任意命令执行&#xff09; 补充代码 配置xdebug php.ini [Xdebug] zend_extensionD:/phpstudy_pro/Extensions/php/php7.3.4nts/ext/php_xdebug.dll xdebug.modedebu…
阅读更多...
Windows系统下安装Hadoop

Windows系统下安装Hadoop

文章目录 安装步骤环境验证 前面我们已经讲过了在 Linux下安装配置Hadoop环境&#xff0c;还没看过的可以先去了解一下安装流程。今天我们来看一下如何在Window下安装Hadoop&#xff0c;这其实和在Linux下的安装都是大同小异的。下面我们具体来看一下安装步骤。 安装步骤 首先…
阅读更多...
pytorch安装教程（Ubuntu22.04.1，Anaconda3-2023.03）

pytorch安装教程（Ubuntu22.04.1，Anaconda3-2023.03）

本文主要讲述了在Linux系统中&#xff0c;通过anaconda安装pytorch的具体步骤&#xff0c;即需要在Ubuntu已经安装好anaconda&#xff0c;其安装步骤可以参考此篇博客&#xff1a;Ubuntu安装Anaconda详细步骤&#xff08;Ubuntu22.04.1&#xff0c;Anaconda3-2023.03&#xff0…
阅读更多...
数据结构期末总结

数据结构期末总结

数据结构绪论 数据结构的概念 数据结构 &#xff1a; 数据结构是相互之间存在一种或多种特定关系的数据元素的集合数据结构研究的问题 &#xff1a;数据结构是一门研究非数值计算的程序设计问题中计算机的操作对象以及它们之间的关系和操作等的学科抽象数据类型ADT&#xff1a…
阅读更多...
JWT漏洞

JWT漏洞

JWT介绍 1.1 JWT概念 JSON Web Token(JWT) 是一个开放标准。它定义了一种紧凑而独立的方法&#xff0c;用于在各方之间安全地将信息作为JSON对象传输。由于此信息是经过数字签名的&#xff0c;因此可以被验证和信任。可以使用secret&#xff08;HMAC算法&#xff09;或使用“…
阅读更多...
SwinTransformer细节总结

SwinTransformer细节总结

SwinTransformer可以看成是披着ResNet外壳的vision transformer&#xff0c;swin 就是两个关键词&#xff1a;patch 多尺度。下面结合code来说一些重点的细节&#xff1a; 总览图 这里W-MSA缩写是window-multi head self attention&#xff0c;SW-MSA缩写是shifted window-mu…
阅读更多...
JDK 8到JDK 17都有哪些吸引人的特性？

JDK 8到JDK 17都有哪些吸引人的特性？

从JDK 8到JDK 17&#xff0c;Java语言和平台经历了许多变化和改进&#xff0c;引入了许多吸引人的新特性和功能。在这里&#xff0c;给大家列举一些我认为最有趣或最有用的新特性&#xff0c;并会以实际使用案例为大家展示新用法。希望大家多多点赞关注&#xff01;&#xff01…
阅读更多...
C语言的switch case函数

C语言的switch case函数

文章目录 1 函数结构2 执行过程3 break关键字4 补充说明参考 1 函数结构 switch 是另外一种选择结构的语句&#xff0c;用来代替简单的、拥有多个分枝的 if else 语句&#xff0c;基本格式如下&#xff1a; switch(表达式){ case 整型数值1: 语句 1; case 整型数值2: 语句 2; …
阅读更多...
极致呈现系列之：Echarts词云图的数据共振

极致呈现系列之：Echarts词云图的数据共振

目录 什么是词云图词云图的特性及应用场景词云图的特性词云图的应用场景 Echarts中词云图的常用属性vue3中创建词云图 什么是词云图 词云图&#xff08;Word Cloud&#xff09;是一种以文字的形式展示数据的可视化图表。它通过将各个文字按照一定的规则排列&#xff0c;并根据…
阅读更多...
车载软件架构 —— 闲聊几句AUTOSAR OS（六）

车载软件架构 —— 闲聊几句AUTOSAR OS（六）

我是穿拖鞋的汉子，魔都中坚持长期主义的工程师。 老规矩，分享一段喜欢的文字，避免自己成为高知识低文化的工程师： 没有人关注你。也无需有人关注你。你必须承认自己的价值，你不能站在他人的角度来反对自己。人生在世，最怕的就是把别人的眼光当成自己生活的唯一标准。到最…
阅读更多...
centos版本的EDA虚拟机搭建2

centos版本的EDA虚拟机搭建2

这次教程主要介绍centos的必备软件的安装。 0、参考博客 1、VMware下CentOS 7虚拟机的安装 2、搭建属于自己的数字IC EDA环境&#xff08;二&#xff09;&#xff1a;搭建Centos的基本使用环境和工具 3、cenos7基本配置 1、git安装 sudo yum install -y git2、gvim安装 su…
阅读更多...
从大型语言模型LLM走向人工通用智能AGI的改进方向（public）

从大型语言模型LLM走向人工通用智能AGI的改进方向（public）

从大型语言模型走向人工通用智能AGI 返回论文和资料目录 1.导读 这篇博客主要基于《Sparks of Artificial General Intelligence: Early experiments with GPT-4》文中第9和第10节、以及我自己对当前LLM和AGI的理解。给出大型语言模型走向AGI时 改进的方向。 2.14个问题及改…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023