手写西瓜书bp神经网络 mnist10 c#版本

本文根据西瓜书第五章中给出的公式编写,书中给出了全连接神经网络的实现逻辑,本文在此基础上编写了Mnist10手写10个数字的案例,网上也有一些其他手写的例子参考。demo使用unity进行编写,方便且易于查错。
该案例仅作为学习,博主也只是业余时间自学一些机器学习知识,欢迎各位路过的大佬留下建议~

测试效果:
在这里插入图片描述

源码下载地址:
https://download.csdn.net/download/grayrail/87802798

1.符号的意义

首先理顺西瓜书第五章中的各符号的意义:

  • x x x 输入的原始值
  • y y y 输出的原始值
  • y ^ \hat{y} y^ 输出的预测值
  • η eta,学习率,取值在0-1之间
  • d d d 输入层神经元的个数
  • q q q 隐层神经元的个数
  • l l l 输出层神经元的个数
  • i i i 输入层相关的下标索引
  • h h h 隐层相关的下标索引
  • j j j 输出层相关的下标索引
  • v i , h v_{i,h} vi,h 输入层隐层神经元的连接权
  • w i , h w_{i,h} wi,h 隐层神经元到输出层神经元的连接权
  • γ h γ_{h} γh gamma, 隐层神经元的阈值(阈值即y=ax+b中的b)
  • θ j θ_{j} θj theta, 输出层神经元的阈值(阈值即y=ax+b中的b)
  • α h α_{h} αh alpha, 隐层接收到的输入,书中公式 α h = ∑ i = 1 d v i , h x i α_{h}=\sum_{i=1}^{d} v_{i,h}x_{i} αh=i=1dvi,hxi
  • β j β_{j} βj beta,输出层接收到的输入,书中公式 β j = ∑ h = 1 q w h , j b h β_{j}=\sum_{h=1}^{q} w_{h,j}b_{h} βj=h=1qwh,jbh
  • b h b_{h} bh 存放隐层经过激活函数后的值,数组长度是隐层长度
  • y h a t s yhats yhats 存放输出层经过激活函数后的值,数组长度是输出层长度,书中没有,但是需要这样一个集合
  • g j g_{j} gj 反向传播g项,数组长度是输出层长度
  • e j e_{j} ej 反向传播e项,数组长度是隐层长度

2.正向传播(ForwardPropagation)

西瓜书第五章直接讲了反向传播,所以在这之前简单讲一下正向传播。

输入层(d)
x1
x2
x3
隐层(q)
可能性1
x1*vi1
x2*vi1
可能性2
x1*vi2
x2*vi2
...
输出层(l)
yhat1
yhat2
yhat3
yhat4

做了一个图讲下常规3层神经网络,输入层通常就是输入的信息,输入层的维度可以是n * 1,隐层用于超参数与中间环节计算,隐层的维度是n * m,n是输入层的数据自身维度,m就是m种可能性,假设隐层的第二个维度是50,就是假设了50种可能性进行训练。

基于此,那么正向传播的流程如下:

  1. 初始化隐层的连接权重v,维度1是输入数据的长度,维度2是有多少种可能性,维度2可以自己填一个适合的值。
  2. 以隐层的长度q进行循环,对每个h维度下的集合进行点乘求和,每个元素 x i x_{i} xi乘以 v i , h v_{i,h} vi,h(即西瓜书中: α h = ∑ i = 1 d v i , h x i α_{h}=\sum_{i=1}^{d} v_{i,h}x_{i} αh=i=1dvi,hxi),然后减去阈值γ并传入激活函数,写入b集合。
  3. 以输出层的长度l进行循环,每个l维度下的存放着所有可能性的点乘结果(博主自己的理解),即西瓜书中的: β j = ∑ i = 1 q w h , j b h β_{j}=\sum_{i=1}^{q} w_{h,j}b_{h} βj=i=1qwh,jbh。然后减去阈值θ并传入激活函数,写入yhats集合。
  4. 可以再对yhats加一个softmax操作,筛选集合中的最大值返回下标索引,即输出结果。

3.反向传播(BackPropagation)

反向传播的难点之一是链式求导,西瓜书中已经帮我们把求导过程写好了,这里我先讲tips,再梳理反向传播流程。

3.1 E的公式乘以1/2的问题

在这里插入图片描述
这个直接问chat gpt:
∂ M S E ∂ w i j = ∂ ∂ w i j [ 1 2 n ∑ k = 1 n ( y k − y ^ k ) 2 ] = − 1 n ( y i − y ^ i ) f ′ ( β j ) x i \frac{\partial MSE}{\partial w_{ij}} = \frac{\partial}{\partial w_{ij}} \left[ \frac{1}{2n} \sum_{k=1}^n (y_k - \hat{y}_k)^2 \right] = -\frac{1}{n}(y_i - \hat{y}_i)f'(\beta_j)x_i wijMSE=wij[2n1k=1n(yky^k)2]=n1(yiy^i)f(βj)xi

ChatGPT:显然,在这个偏导数公式中出现了一个因子 1 n \frac{1}{n} n1
,而这个因子的存在是由于我们将MSE除以了2所致。如果不将MSE除以2,那么这个因子就会变成 1 2 n \frac{1}{2n} 2n1
,这在后续计算中会带来一些不必要的复杂性和麻烦。

3.2 公式梳理

书中的公式有点乱,下面给出按照顺序的梳理图:

3.2.1 W对于E的偏导数

在这里插入图片描述

3.2.2 V对于E的偏导数

在这里插入图片描述
这一部分应该是精髓所在,不是非常了解,不多加评论。

3.2.3 流程梳理

基于此,那么反向传播的流程如下:

  1. 单独对 g g g项求值并存入数组,用真实值 y y y和预测值 y ^ \hat{y} y^带入Sigmoid的导数公式
  2. 单独对 e e e项求值并存入数组
  3. 计算阈值(bias偏置) θ θ θ的delta量并赋值, Δ θ j = − η g j Δθ_{j}=-ηg_{j} Δθj=ηgj
  4. 计算 w w w的delta量并赋值, Δ w h , j = η g j b h Δw_{h,j}=ηg_{j}b_{h} Δwh,j=ηgjbh(注意这里的b是上一层的最终输出,不是bias)
  5. 计算阈值(bias偏置) γ γ γ的delta量并赋值, Δ γ j = − η e h Δγ_{j}=-ηe_{h} Δγj=ηeh
  6. 计算 v v v的delta量并赋值, Δ v i , h = η e h x i Δv_{i,h}=ηe_{h}x_{i} Δvi,h=ηehxi

4.代码实现

以Mnist案例为例,该案例使用神经网络识别27x27像素内图片的0-9个手写数字,接下来给出C#版本的Mnist代码实现,脚本挂载后有3种模式:
在这里插入图片描述

  • Draw Image Mode 用于绘制0-9个数字
  • User Mode 使用已经训练好的神经网络进行数字识别(没有做缓存的功能,需要手动先训练几次)
  • Train Mode 训练模式,DataPath中填入图片路径,图片格式首先取前缀,例如:3_04,表明这个图片真实值数字是3,是第三个数字是4的图片

该案例在西瓜书的基础上又加入了momentum动量、softmax、初始随机值范围修改(-1,1),softmax使用《深度学习入门 基于PYTHON的理论与实现》一书中提供的公式。经过一些轮次训练后的运行结果:
在这里插入图片描述

c#代码如下:

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEngine;

public class TestMnist10Watermelon : MonoBehaviour
{
    public enum EMode { Train, DrawImage, User }

    /// <summary>
    /// d个输入神经元
    /// </summary>
    int d;

    /// <summary>
    /// q个隐层神经元
    /// </summary>
    int q;

    /// <summary>
    /// l个输出神经元
    /// </summary>
    int l;

    /// <summary>
    /// 输入层原始值
    /// </summary>
    float[] x;

    /// <summary>
    /// 输入层到隐层神经元的连接权
    /// </summary>
    float[][] v;

    /// <summary>
    /// 缓存上一次的v权值
    /// </summary>
    float[][] lastVMomentum;

    /// <summary>
    /// 隐层神经元到输出层神经元的连接权
    /// </summary>
    float[][] w;

    /// <summary>
    /// 缓存上一次的w权值
    /// </summary>
    float[][] lastWMomentum;

    /// <summary>
    /// 反向传播g项
    /// </summary>
    float[] g;

    /// <summary>
    /// 反向传播e项
    /// </summary>
    float[] e;

    /// <summary>
    /// 隐层接收到的输入(通常List长度是隐层长度)
    /// </summary>
    List<float> b;

    /// <summary>
    /// 输出层接收到的输入(通常List长度是输出层长度)
    /// </summary>
    List<float> yhats;

    /// <summary>
    /// 输出层神经元的阈值
    /// </summary>
    float[] theta;

    /// <summary>
    /// 隐层神经元的阈值
    /// </summary>
    float[] gamma;


    public void Init(int inputLayerCount, int hiddenLayerCount, int outputLayerCount)
    {
        d = inputLayerCount;
        q = hiddenLayerCount;
        l = outputLayerCount;

        x = new float[inputLayerCount];
        b = new List<float>(1024);
        yhats = new List<float>(1024);

        e = new float[hiddenLayerCount];
        g = new float[outputLayerCount];

        v = GenDimsArray(typeof(float), new int[] { q, d }, 0, () => UnityEngine.Random.Range(-1f, 1f)) as float[][];
        w = GenDimsArray(typeof(float), new int[] { l, q }, 0, () => UnityEngine.Random.Range(-1f, 1f)) as float[][];

        lastVMomentum = GenDimsArray(typeof(float), new int[] { q, d }, 0, null) as float[][];
        lastWMomentum = GenDimsArray(typeof(float), new int[] { q, d }, 0, null) as float[][];

        theta = GenDimsArray(typeof(float), new int[] { l }, 0, () => UnityEngine.Random.Range(-1f, 1f)) as float[];
        gamma = GenDimsArray(typeof(float), new int[] { q }, 0, () => UnityEngine.Random.Range(-1f, 1f)) as float[];
    }

    public void ForwardPropagation(float[] input, out int output)
    {
        x = input;

        b.Clear();
        for (int hIndex = 0; hIndex < q; ++hIndex)
        {
            var sum = 0f;
            for (int iIndex = 0; iIndex < d; ++iIndex)
            {
                var u = input[iIndex] * v[hIndex][iIndex];
                sum += u;
            }
            var alpha = sum - gamma[hIndex];
            b.Add(Sigmoid(alpha));
        }

        yhats.Clear();
        for (int jIndex = 0; jIndex < l; ++jIndex)
        {
            var sum = 0f;
            for (int hIndex = 0; hIndex < q; ++hIndex)
            {
                var u = b[hIndex] * w[jIndex][hIndex];
                sum += u;
            }
            var beta = sum - theta[jIndex];
            yhats.Add(Sigmoid(beta));
        }

        var softmaxResult = Softmax(yhats.ToArray());
        for (int i = 0; i < yhats.Count; i++)
        {
            yhats[i] = softmaxResult[i];
        }

        int index = 0;
        float maxValue = -999999f;
        for (int jIndex = 0; jIndex < l; ++jIndex)
        {
            if (yhats[jIndex] > maxValue)
            {
                maxValue = yhats[jIndex];
                index = jIndex;
            }
        }
        output = index;
    }

    public void BackPropagation(float[] correct)
    {
        const float kEta1 = 0.03f;
        const float kEta2 = 0.01f;

        const float kMomentum = 0.3f;

        for (int jIndex = 0; jIndex < l; ++jIndex)
        {
            var yhat = this.yhats[jIndex];
            var y = correct[jIndex];
            g[jIndex] = yhat * (1f - yhat) * (y - yhat);
        }

        for (int hIndex = 0; hIndex < q; ++hIndex)
        {
            var bh = b[hIndex];
            var sum = 0f;
            //这个for循环的内容,个人感觉是精妙之处,可以拿到别的神经元的梯度。
            for (int jIndex = 0; jIndex < l; ++jIndex)
                sum += w[jIndex][hIndex] * g[jIndex];
            e[hIndex] = bh * (1f - bh) * sum;
        }

        for (int jIndex = 0; jIndex < l; ++jIndex)
        {
            theta[jIndex] += -kEta1 * g[jIndex];
        }

        for (int hIndex = 0; hIndex < q; ++hIndex)
        {
            for (int jIndex = 0; jIndex < l; ++jIndex)
            {
                var bh = b[hIndex];
                var delta = kMomentum * lastWMomentum[jIndex][hIndex] + kEta1 * g[jIndex] * bh;
                w[jIndex][hIndex] += delta;
                lastWMomentum[jIndex][hIndex] = delta;
            }
        }

        for (int hIndex = 0; hIndex < q; ++hIndex)
        {
            gamma[hIndex] += -kEta2 * e[hIndex];
        }

        for (int hIndex = 0; hIndex < q; ++hIndex)
        {
            for (int iIndex = 0; iIndex < d; ++iIndex)
            {
                var delta = kMomentum * lastVMomentum[hIndex][iIndex] + kEta2 * e[hIndex] * x[iIndex];
                v[hIndex][iIndex] += delta;
                lastVMomentum[hIndex][iIndex] = delta;
            }
        }
    }

    void Start()
    {
        Init(784, 64, 10);
    }

    EMode mMode;
    int[] mDrawNumberImage;

    string mDataPath;

    float Sigmoid(float val)
    {
        return 1f / (1f + Mathf.Exp(-val));
    }

    float[] Softmax(float[] inputs)
    {
        float[] outputs = new float[inputs.Length];
        float maxInput = inputs.Max();

        for (int i = 0; i < inputs.Length; i++)
        {
            outputs[i] = Mathf.Exp(inputs[i] - maxInput);
        }

        float expSum = outputs.Sum();
        for (int i = 0; i < outputs.Length; i++)
        {
            outputs[i] /= expSum;
        }

        return outputs;
    }

    float[] GetOneHot(string input)
    {
        if (input.StartsWith("0"))
            return new float[] { 1, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
        if (input.StartsWith("1"))
            return new float[] { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 };
        if (input.StartsWith("2"))
            return new float[] { 0, 0, 1, 0, 0, 0, 0, 0, 0, 0 };
        if (input.StartsWith("3"))
            return new float[] { 0, 0, 0, 1, 0, 0, 0, 0, 0, 0 };
        if (input.StartsWith("4"))
            return new float[] { 0, 0, 0, 0, 1, 0, 0, 0, 0, 0 };
        if (input.StartsWith("5"))
            return new float[] { 0, 0, 0, 0, 0, 1, 0, 0, 0, 0 };
        if (input.StartsWith("6"))
            return new float[] { 0, 0, 0, 0, 0, 0, 1, 0, 0, 0 };
        if (input.StartsWith("7"))
            return new float[] { 0, 0, 0, 0, 0, 0, 0, 1, 0, 0 };
        if (input.StartsWith("8"))
            return new float[] { 0, 0, 0, 0, 0, 0, 0, 0, 1, 0 };
        else
            return new float[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 };
    }

    void Shuffle<T>(List<T> cardList)
    {
        int tempIndex = 0;
        T temp = default;
        for (int i = 0; i < cardList.Count; ++i)
        {
            tempIndex = UnityEngine.Random.Range(0, cardList.Count);
            temp = cardList[tempIndex];
            cardList[tempIndex] = cardList[i];
            cardList[i] = temp;
        }
    }

    /// <summary>
    /// 快速得到多维数组
    /// </summary>
    Array GenDimsArray(Type type, int[] sims, int deepIndex, Func<object> initFunc = null)
    {
        if (deepIndex < sims.Length - 1)
        {
            var sub_template = GenDimsArray(type, sims, deepIndex + 1, null);
            var current = Array.CreateInstance(sub_template.GetType(), sims[deepIndex]);

            for (int i = 0; i < sims[deepIndex]; ++i)
            {
                var sub = GenDimsArray(type, sims, deepIndex + 1, initFunc);
                current.SetValue(sub, i);
            }

            return current;
        }
        else
        {
            var arr = Array.CreateInstance(type, sims[deepIndex]);
            if (initFunc != null)
            {
                for (int i = 0; i < arr.Length; ++i)
                    arr.SetValue(initFunc(), i);
            }

            return arr;
        }
    }

    void OnGUI()
    {
        if (mDrawNumberImage == null)
            mDrawNumberImage = new int[784];

        GUILayout.BeginHorizontal();
        if (GUILayout.Button("Draw Image Mode"))
        {
            mMode = EMode.DrawImage;

            Array.Clear(mDrawNumberImage, 0, mDrawNumberImage.Length);
        }
        if (GUILayout.Button("User Mode"))
        {
            mMode = EMode.User;

            Array.Clear(mDrawNumberImage, 0, mDrawNumberImage.Length);
        }
        if (GUILayout.Button("Train Mode"))
        {
            mMode = EMode.Train;
            mDataPath = Directory.GetCurrentDirectory() + "/TrainData";
        }
        GUILayout.EndHorizontal();

        var lastRect = GUILayoutUtility.GetLastRect();

        switch (mMode)
        {
            case EMode.Train:
                {
                    GUILayout.BeginHorizontal();
                    GUILayout.Label("Data Path: ");
                    mDataPath = GUILayout.TextField(mDataPath);
                    GUILayout.EndHorizontal();

                    if (GUILayout.Button("Train 10"))
                    {
                        var files = Directory.GetFiles(mDataPath);
                        List<(string, float[])> datas = new(512);
                        for (int i = 0; i < files.Length; ++i)
                        {
                            var strArr = File.ReadAllText(files[i]).Split(',');
                            datas.Add((Path.GetFileNameWithoutExtension(files[i]), Array.ConvertAll(strArr, m => float.Parse(m))));
                        }

                        for (int s = 0; s < 10; ++s)
                        {
                            Shuffle(datas);

                            for (int i = 0; i < datas.Count; ++i)
                            {
                                ForwardPropagation(datas[i].Item2, out int output);
                                UnityEngine.Debug.Log("<color=#00ff00> Input Number: " + datas[i].Item1 + " output: " + output + "</color>");
                                BackPropagation(GetOneHot(datas[i].Item1));
                                //break;
                            }
                        }
                    }
                }
                break;
            case EMode.DrawImage:
                {
                    lastRect.y += 50f;
                    var size = 20f;
                    var spacing = 2f;
                    var mousePosition = Event.current.mousePosition;
                    var mouseLeftIsPress = Input.GetMouseButton(0);
                    var mouseRightIsPress = Input.GetMouseButton(1);
                    var containSpacingSize = size + spacing;

                    for (int y = 0, i = 0; y < 27; ++y)
                    {
                        for (int x = 0; x < 27; ++x)
                        {
                            var rect = new Rect(lastRect.x + x * containSpacingSize, lastRect.y + y * containSpacingSize, size, size);
                            GUI.DrawTexture(rect, mDrawNumberImage[i] == 1 ? Texture2D.blackTexture : Texture2D.whiteTexture);

                            if (rect.Contains(mousePosition))
                            {
                                if (mouseLeftIsPress)
                                    mDrawNumberImage[i] = 1;
                                else if (mouseRightIsPress)
                                    mDrawNumberImage[i] = 0;
                            }

                            ++i;
                        }
                    }

                    if (GUILayout.Button("Save"))
                    {
                        File.WriteAllText(Directory.GetCurrentDirectory() + "/Assets/tmp.txt", string.Join(",", mDrawNumberImage));
                    }
                }
                break;
            case EMode.User:
                {
                    lastRect.y += 150f;
                    var size = 20f;
                    var spacing = 2f;
                    var mousePosition = Event.current.mousePosition;
                    var mouseLeftIsPress = Input.GetMouseButton(0);
                    var mouseRightIsPress = Input.GetMouseButton(1);
                    var containSpacingSize = size + spacing;

                    for (int y = 0, i = 0; y < 27; ++y)
                    {
                        for (int x = 0; x < 27; ++x)
                        {
                            var rect = new Rect(lastRect.x + x * containSpacingSize, lastRect.y + y * containSpacingSize, size, size);
                            GUI.DrawTexture(rect, mDrawNumberImage[i] == 1 ? Texture2D.blackTexture : Texture2D.whiteTexture);

                            if (rect.Contains(mousePosition))
                            {
                                if (mouseLeftIsPress)
                                    mDrawNumberImage[i] = 1;
                                else if (mouseRightIsPress)
                                    mDrawNumberImage[i] = 0;
                            }

                            ++i;
                        }
                    }

                    if (GUILayout.Button("Recognize"))
                    {
                        ForwardPropagation(Array.ConvertAll(mDrawNumberImage, m => (float)m), out int output);
                        Debug.Log("output: " + output);
                    }
                    break;
                }
        }
    }
}

参考文章

  • Java实现BP神经网络MNIST手写数字识别https://www.cnblogs.com/baby7/p/java_bp_neural_network_number_identification.html
  • 反向传播算法对照 https://zhuanlan.zhihu.com/p/605765790

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

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

相关文章

ROS学习(1)——ROS1和ROS2的区别

因为机器人是一个系统工程&#xff0c;它包括了机械臂结构&#xff0c;电子电路&#xff0c;驱动程序&#xff0c;通信框架&#xff0c;组装集成&#xff0c;调试和各种感知决策算法等方面&#xff0c;任何一个人甚至是一个公司都不可能完成机器人系统的研发工作 。但是我们又希…

TMP的阴影性能如何

1&#xff09;TMP的阴影性能如何 ​2&#xff09;CommandBuffer.DrawMeshInstanced无法画阴影问题 3&#xff09;Unity编辑器在Require大量加载Lua文件时&#xff0c;经常报出not enough memory 4&#xff09;场景制作的时候&#xff0c;2D资源受后处理调色影响比较大 这是第33…

数据结构:栈和队列

朋友们、伙计们&#xff0c;我们又见面了&#xff0c;本期来给大家解读一下栈和队列方面的相关知识点&#xff0c;如果看完之后对你有一定的启发&#xff0c;那么请留下你的三连&#xff0c;祝大家心想事成&#xff01; C 语 言 专 栏&#xff1a;C语言&#xff1a;从入门到精通…

面试了一个00后,绝对能称为是内卷届的天花板

前言 公司前段缺人&#xff0c;也面了不少测试&#xff0c;结果竟然没有一个合适的。一开始瞄准的就是中级的水准&#xff0c;也没指望来大牛&#xff0c;提供的薪资也不低&#xff0c;面试的人很多&#xff0c;但平均水平很让人失望。令我印象最深的是一个00后测试员&#xf…

期刊介绍|骨科老牌期刊,无版面费,审稿极速,毕业不二之选!

今天给大家介绍一本中药方面的期刊&#xff1a;JOURNAL OF ORTHOPAEDIC RESEARCH 一、基本信息 1、期刊名称&#xff1a;JOURNAL OF ORTHOPAEDIC RESEARCH&#xff1b; 2、期刊ISSN: 0736-0266&#xff1b; 3、研究方向&#xff1a;医学-整形外科&#xff1b; 4、出版社&#x…

Maven多环境配置与使用、跳过测试的三种方法

文章目录 1 多环境开发步骤1:父工程配置多个环境,并指定默认激活环境步骤2:执行安装查看env_dep环境是否生效步骤3:切换默认环境为生产环境步骤4:执行安装并查看env_pro环境是否生效步骤5:命令行实现环境切换步骤6:执行安装并查看env_test环境是否生效 2 跳过测试方式1:IDEA工具…

(转载)从0开始学matlab(第9天)—第一阶段总结

1.编程实例 下面的例子将向大家介绍如何用 MATLAB 解决问题。 例1 温度转换程序 问题&#xff1a; 设计一个 MATLAB 程序&#xff0c;读取一个华氏温度的输入&#xff0c;输出开尔文温度。 答案&#xff1a; 华氏温度和开尔文温度的转换关系式可在物理学课本中找到。其关系式…

JVM面试题(一)

JVM内存分哪几个区&#xff0c;每个区的作用是什么? java虚拟机主要分为以下几个区: JVM中方法区和堆空间是线程共享的&#xff0c;而虚拟机栈、本地方法栈、程序计数器是线程独享的。 &#xff08;1&#xff09;方法区&#xff1a; a. 有时候也成为永久代&#xff0c;在该区内…

电极法测污水常规五参数(PH、电导率、溶解氧、温度、浊度)

检测水质常规五参数的意义&#xff1a; pH&#xff1a;地表水水质中pH值的变化会影响藻类对氧气的摄入能力及动物对食物的摄取敏感度&#xff1b; 电导率&#xff1a;主要是测水的导电性&#xff0c;监测水体中总的离子浓度。包含了各种化学物质、重金属、杂质等等各种导电性物…

低代码,或将颠覆开发行业?

前言 传统的软件开发过程往往需要耗费大量的时间和精力&#xff0c;因为开发人员需编写复杂的代码以完成各种功能。 低代码行业的发展&#xff0c;正好解决了这个问题&#xff0c;让复杂的代码编写一去不复返了。 文章目录 前言引入强大的平台总结 引入 低代码平台 是一种通过可…

超级独角兽 Databricks 的崛起之路

在数据扩张以及 AI 兴起的时代&#xff0c;数据存储和分析平台拥有巨大价值和能量。 随着互联网数据的爆炸性增长&#xff0c;数据已经成为企业的新型资源&#xff0c;犹如石油般重要。越来越多的企业希望利用各种结构化和非结构化数据来发挥自己的优势。 然而&#xff0c;他…

通过关键字搜索接口获取alibaba国际站商品列表

作为一名技术爱好者&#xff0c;我们总会遇到各种各样的技术问题&#xff0c;需要寻找合适的技术解决方案。而在互联网时代&#xff0c;我们可以快速通过搜索引擎获取丰富的技术资源和解决方案。然而&#xff0c;在不同的技术分享中&#xff0c;我们常常会遇到质量参差不齐的文…

计算机网络第一章(谢希仁第8版学习)

作者&#xff1a;爱塔居 专栏&#xff1a;计算机网络 作者简介&#xff1a;大三学生&#xff0c;希望和大家一起加油 文章目录 目录 文章目录 一、网络、互连网、互联网&#xff08;因特网&#xff09;的概念 二、因特网的组成 三、交换方式 3.1 电路交换 3.2 分组交换 3.3 电路…

微信小程序nodejs+vue校园二手商城交易(积分兑换)38gw6

随着我国经济迅速发展&#xff0c;人们对手机的需求越来越大&#xff0c;各种手机软件也都在被广泛应用&#xff0c;但是对于手机进行数据信息管理&#xff0c;对于手机的各种软件也是备受用户的喜爱&#xff0c;校园二手交易被用户普遍使用&#xff0c;为方便用户能够可以随时…

实操带你使用Mybatis_plus(2)

文章目录 一、通用ServiceService CRUD 接口a> IServiceb>创建Service接口和实现类测试 二、常用注解1、TableName2、TableId雪花算法3、TableField4、TableLogic 一、通用Service Service CRUD 接口 通用 Service CRUD 封装IService 接口&#xff0c;进一步封装 CRUD …

大模型高效调参—PEFT库( Parameter-Efficient Fine-Tuning)

介绍 在面对特定的下游任务时&#xff0c;如果进行Full FineTuning&#xff08;即对预训练模型中的所有参数都进行微调&#xff09;&#xff0c;太过低效&#xff1b;而如果采用固定预训练模型的某些层&#xff0c;只微调接近下游任务的那几层参数&#xff0c;又难以达到较好的…

桥梁安全监测,智能化桥梁结构健康监测方案

桥梁是现代城市交通网络中不可或缺的组成部分&#xff0c;但由于长期受到自然环境和人为因素的影响&#xff0c;桥梁的安全问题一直备受关注。传统的桥梁检测方式主要是靠人力进行巡查&#xff0c;这种方式效率低下、成本高&#xff0c;而且难以全面掌握桥梁结构的真实情况。随…

软件测试外包干了4年,感觉废了..

先说一下自己的情况&#xff0c;大专生&#xff0c;18年通过校招进入湖南某软件公司&#xff0c;干了接近4年的功能测试&#xff0c;今年年初&#xff0c;感觉自己不能够在这样下去了&#xff0c;长时间呆在一个舒适的环境会让一个人堕落!而我已经在一个企业干了四年的功能测试…

国考省考行测:资料分析,两年复合增长率

国考省考行测&#xff1a;资料分析&#xff0c;两年复合增长率 2022找工作是学历、能力和运气的超强结合体! 公务员特招重点就是专业技能&#xff0c;附带行测和申论&#xff0c;而常规国考省考最重要的还是申论和行测&#xff0c;所以大家认真准备吧&#xff0c;我讲一起屡屡…

聊一聊适配器模式

接口不能用&#xff1f;行&#xff0c;我帮你适配 一、概述 适配器模式&#xff08;Adapter&#xff09;&#xff0c;是23种设计模式中的结构型模式之一&#xff1b;它就像我们电脑上接口不够时&#xff0c;需要用到的拓展坞&#xff0c;起到转接的作用。它可以将新的功能和原…