新手入门python实现神经网络，超级简单!

news2024/11/28 6:26:17

前言：

这篇文章完全是为新手准备的。我们会通过用Python从头实现一个神经网络来理解神经网络的原理。

文章目录

  • 神经元
    • 1、一个简单的例子
    • 2、编码一个神经元
  • 把神经元组装成网络
    • 1、例子：前馈
    • 2、编码神经网络：前馈
  • 训练神经网络 第一部分
    • 1、损失
    • 2、损失计算例子
    • 3、代码：MSE损失
  • 训练神经网络 第二部分
    • 1、例子：计算偏导数
    • 2、训练：随机梯度下降
  • 代码：一个完整的神经网络

神经元

首先让我们看看神经网络的基本单位，神经元。神经元接受输入，对其做一些数据操作，然后产生输出。例如，这是一个2-输入神经元：
在这里插入图片描述
这里发生了三个事情。首先，每个输入都跟一个权重相乘（红色）：
在这里插入图片描述然后，加权后的输入求和，加上一个偏差b（绿色）：
在这里插入图片描述
最后，这个结果传递给一个激活函数f：
在这里插入图片描述
激活函数的用途是将一个无边界的输入，转变成一个可预测的形式。常用的激活函数就是S型函数：

在这里插入图片描述
S型函数的值域是(0, 1)。简单来说，就是把(−∞, +∞)压缩到(0, 1) ，很大的负数约等于0，很大的正数约等于1。

1、一个简单的例子

在这里插入图片描述

2、编码一个神经元

让我们来实现一个神经元！用Python的NumPy库来完成其中的数学计算：

import numpy as np

def sigmoid(x):
  # 我们的激活函数: f(x) = 1 / (1 + e^(-x))
  return 1 / (1 + np.exp(-x))

class Neuron:
  def __init__(self, weights, bias):
    self.weights = weights
    self.bias = bias

  def feedforward(self, inputs):
    # 加权输入，加入偏置，然后使用激活函数
    total = np.dot(self.weights, inputs) + self.bias
    return sigmoid(total)

weights = np.array([0, 1]) # w1 = 0, w2 = 1
bias = 4                   # b = 4
n = Neuron(weights, bias)

x = np.array([2, 3])       # x1 = 2, x2 = 3
print(n.feedforward(x))    # 0.9990889488055994

还记得这个数字吗？就是我们前面算出来的例子中的0.999。

把神经元组装成网络

所谓的神经网络就是一堆神经元。这就是一个简单的神经网络：
在这里插入图片描述

隐藏层就是输入层和输出层之间的层，隐藏层可以是多层的。

1、例子：前馈

在这里插入图片描述

2、编码神经网络：前馈

接下来我们实现这个神经网络的前馈机制，还是这个图：
在这里插入图片描述

import numpy as np

def sigmoid(x):
# 我们的激活函数：f(x)=1/(1+e^(-x))
    return 1/(1+np.exp(-x))
# 单个神经元
class Neuron:
    def __init__(self,weights,bias):
        self.weights=weights
        self.bias=bias
    def feedforward(self,inputs):
        total=np.dot(self.weights,inputs)+self.bias
        return sigmoid(total)

class OurNeuralNetwork:
  '''
  A neural network with:
    - 2 inputs
    - a hidden layer with 2 neurons (h1, h2)
    - an output layer with 1 neuron (o1)
  Each neuron has the same weights and bias:
    - w = [0, 1]
    - b = 0
  '''
  def __init__(self):
    weights = np.array([0, 1])
    bias = 0

    # 这里是来自前一节的神经元类
    self.h1 = Neuron(weights, bias)
    self.h2 = Neuron(weights, bias)
    self.o1 = Neuron(weights, bias)

  def feedforward(self, x):
    out_h1 = self.h1.feedforward(x)
    out_h2 = self.h2.feedforward(x)

    # o1的输入是h1和h2的输出
    out_o1 = self.o1.feedforward(np.array([out_h1, out_h2]))

    return out_o1

network = OurNeuralNetwork()
x = np.array([2, 3])
print(network.feedforward(x)) # 0.7216325609518421

结果正确，看上去没问题。

训练神经网络 第一部分

现在有这样的数据：
在这里插入图片描述
接下来我们用这个数据来训练神经网络的权重和截距项，从而可以根据身高体重预测性别：
在这里插入图片描述
我们用0和1分别表示男性（M）和女性（F），并对数值做了转化：
在这里插入图片描述

我这里是随意选取了135和66来标准化数据，通常会使用平均值。

1、损失

在训练网络之前，我们需要量化当前的网络是『好』还是『坏』，从而可以寻找更好的网络。这就是定义损失的目的。
我们在这里用平均方差（MSE）损失： ，让我们仔细看看：
在这里插入图片描述
在这里插入图片描述
被称为方差（squared error）。我们的损失函数就是所有方差的平均值。预测效果越好，损失就越少。
更好的预测 = 更少的损失！

训练网络 = 最小化它的损失。

2、损失计算例子

假设我们的网络总是输出0，换言之就是认为所有人都是男性。损失如何？
在这里插入图片描述

3、代码：MSE损失

下面是计算MSE损失的代码：

import numpy as np

def mse_loss(y_true, y_pred):
  # y_true and y_pred are numpy arrays of the same length.
  return ((y_true - y_pred) ** 2).mean()

y_true = np.array([1, 0, 0, 1])
y_pred = np.array([0, 0, 0, 0])

print(mse_loss(y_true, y_pred)) # 0.5

如果你不理解这段代码，可以看看NumPy的快速入门中关于数组的操作。

好的，继续。

训练神经网络 第二部分

现在我们有了一个明确的目标：最小化神经网络的损失。通过调整网络的权重和截距项，我们可以改变其预测结果，但如何才能逐步地减少损失？
为了简化问题，假设我们的数据集中只有Alice：假设我们的网络总是输出0，换言之就是认为所有人都是男性。损失如何？
在这里插入图片描述
那均方差损失就只是Alice的方差：
也可以把损失看成是权重和截距项的函数。让我们给网络标上权重和截距项：
在这里插入图片描述
这样我们就可以把网络的损失表示为：
在这里插入图片描述

1、例子：计算偏导数

我们还是看数据集中只有Alice的情况：
在这里插入图片描述

2、训练：随机梯度下降

现在训练神经网络已经万事俱备了！我们会使用名为随机梯度下降法的优化算法来优化网络的权重和截距项，实现损失的最小化。核心就是这个更新公式：
在这里插入图片描述

代码：一个完整的神经网络

我们终于可以实现一个完整的神经网络了：
在这里插入图片描述

import numpy as np

def sigmoid(x):
  # Sigmoid activation function: f(x) = 1 / (1 + e^(-x))
  return 1 / (1 + np.exp(-x))

def deriv_sigmoid(x):
  # Derivative of sigmoid: f'(x) = f(x) * (1 - f(x))
  fx = sigmoid(x)
  return fx * (1 - fx)

def mse_loss(y_true, y_pred):
  # y_true和y_pred是相同长度的numpy数组。
  return ((y_true - y_pred) ** 2).mean()

class OurNeuralNetwork:
  '''
  A neural network with:
    - 2 inputs
    - a hidden layer with 2 neurons (h1, h2)
    - an output layer with 1 neuron (o1)

  *** 免责声明 ***:
    下面的代码是为了简单和演示，而不是最佳的。
    真正的神经网络代码与此完全不同。不要使用此代码。
    相反，读/运行它来理解这个特定的网络是如何工作的。
  '''
  def __init__(self):
    # 权重，Weights
    self.w1 = np.random.normal()
    self.w2 = np.random.normal()
    self.w3 = np.random.normal()
    self.w4 = np.random.normal()
    self.w5 = np.random.normal()
    self.w6 = np.random.normal()

    # 截距项，Biases
    self.b1 = np.random.normal()
    self.b2 = np.random.normal()
    self.b3 = np.random.normal()

  def feedforward(self, x):
    # X是一个有2个元素的数字数组。
    h1 = sigmoid(self.w1 * x[0] + self.w2 * x[1] + self.b1)
    h2 = sigmoid(self.w3 * x[0] + self.w4 * x[1] + self.b2)
    o1 = sigmoid(self.w5 * h1 + self.w6 * h2 + self.b3)
    return o1

  def train(self, data, all_y_trues):
    '''
    - data is a (n x 2) numpy array, n = # of samples in the dataset.
    - all_y_trues is a numpy array with n elements.
      Elements in all_y_trues correspond to those in data.
    '''
    learn_rate = 0.1
    epochs = 1000 # 遍历整个数据集的次数

    for epoch in range(epochs):
      for x, y_true in zip(data, all_y_trues):
        # --- 做一个前馈(稍后我们将需要这些值)
        sum_h1 = self.w1 * x[0] + self.w2 * x[1] + self.b1
        h1 = sigmoid(sum_h1)

        sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2
        h2 = sigmoid(sum_h2)

        sum_o1 = self.w5 * h1 + self.w6 * h2 + self.b3
        o1 = sigmoid(sum_o1)
        y_pred = o1

        # --- 计算偏导数。
        # --- Naming: d_L_d_w1 represents "partial L / partial w1"
        d_L_d_ypred = -2 * (y_true - y_pred)

        # Neuron o1
        d_ypred_d_w5 = h1 * deriv_sigmoid(sum_o1)
        d_ypred_d_w6 = h2 * deriv_sigmoid(sum_o1)
        d_ypred_d_b3 = deriv_sigmoid(sum_o1)

        d_ypred_d_h1 = self.w5 * deriv_sigmoid(sum_o1)
        d_ypred_d_h2 = self.w6 * deriv_sigmoid(sum_o1)

        # Neuron h1
        d_h1_d_w1 = x[0] * deriv_sigmoid(sum_h1)
        d_h1_d_w2 = x[1] * deriv_sigmoid(sum_h1)
        d_h1_d_b1 = deriv_sigmoid(sum_h1)

        # Neuron h2
        d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2)
        d_h2_d_w4 = x[1] * deriv_sigmoid(sum_h2)
        d_h2_d_b2 = deriv_sigmoid(sum_h2)

        # --- 更新权重和偏差
        # Neuron h1
        self.w1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w1
        self.w2 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w2
        self.b1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_b1

        # Neuron h2
        self.w3 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w3
        self.w4 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w4
        self.b2 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_b2

        # Neuron o1
        self.w5 -= learn_rate * d_L_d_ypred * d_ypred_d_w5
        self.w6 -= learn_rate * d_L_d_ypred * d_ypred_d_w6
        self.b3 -= learn_rate * d_L_d_ypred * d_ypred_d_b3

      # --- 在每次epoch结束时计算总损失 
      if epoch % 10 == 0:
        y_preds = np.apply_along_axis(self.feedforward, 1, data)
        loss = mse_loss(all_y_trues, y_preds)
        print("Epoch %d loss: %.3f" % (epoch, loss))

# 定义数据集
data = np.array([
  [-2, -1],  # Alice
  [25, 6],   # Bob
  [17, 4],   # Charlie
  [-15, -6], # Diana
])
all_y_trues = np.array([
  1, # Alice
  0, # Bob
  0, # Charlie
  1, # Diana
])

# 训练我们的神经网络!
network = OurNeuralNetwork()
network.train(data, all_y_trues)

随着网络的学习，损失在稳步下降。
在这里插入图片描述
现在我们可以用这个网络来预测性别了：

# 做一些预测
emily = np.array([-7, -3]) # 128 磅, 63 英寸
frank = np.array([20, 2])  # 155 磅, 68 英寸
print("Emily: %.3f" % network.feedforward(emily)) # 0.951 - F
print("Frank: %.3f" % network.feedforward(frank)) # 0.039 - M

把这段代码插入到上述完整的神经网络代码中：

import numpy as np
def sigmoid(x):
 # Sigmoid激活函数：f(x)=1/(1+e^(-x))
    return 1/(1+np.exp(-x))
def deriv_sigmoid(x):
  # Derivative of sigmoid: f'(x)=f(x)*(1-f(x))
  fx=sigmoid(x)
  return fx*(1-fx)
def mse_loss(y_true,y_pred):
  # y_true和y_pred是相同长度的numpy数组
  return ((y_true-y_pred)**2).mean()

class OurNeuralNetwork:
  '''
  A neural network with:
    - 2 inputs
    - a hidden layer with 2 neurons (h1, h2)
    - an output layer with 1 neuron (o1)

  *** 免责声明 ***:
    下面的代码是为了简单和演示，而不是最佳的。
    真正的神经网络代码与此完全不同。不要使用此代码。
    相反，读/运行它来理解这个特定的网络是如何工作的。
  '''
  def __init__(self):
    # 权重，Weights
    self.w1=np.random.normal()
    self.w2=np.random.normal()
    self.w3=np.random.normal()
    self.w4=np.random.normal()
    self.w5=np.random.normal()
    self.w6=np.random.normal()
    # 截距项 Biaes
    self.b1=np.random.normal()
    self.b2=np.random.normal()
    self.b3=np.random.normal()
  def feedforward(self,x):
    # X是一个有2个元素的数组。
    h1=sigmoid(self.w1 * x[0] + self.w2 * x[1] + self.b1)
    h2=sigmoid(self.w3*x[0]+self.w4*x[1]+self.b2)
    o1=sigmoid(self.w5*h1+self.w6*h2+self.b3)
    return o1
  def train(self,data,all_y_trues):
    '''
    - data is a(nx2)numpy array,n=#of samples in the dataset.
    - all_y_trues is a numpy array with n elements
    Elements in all_y_trues correspond to those in data.
    '''
    learn_rate=0.1
    epochs=1000 #遍历整个数组的次数

    for epoch in range(epochs): 
      for x,y_true in zip(data,all_y_trues):
        # ---做一个前馈（稍后我们将需要这些值）
        sum_h1=self.w1*x[0]+self.w2*x[1]+self.b1
        h1=sigmoid(sum_h1)
        sum_h2 = self.w3 * x[0] + self.w4 * x[1] + self.b2
        h2 = sigmoid(sum_h2)

        sum_o1 = self.w5 * h1 + self.w6 * h2 + self.b3
        o1 = sigmoid(sum_o1)
        y_pred=o1

        # ---计算偏导数
        # ---Naming:d_L_d_w1 represents "partial L/partial w1"
        d_L_d_ypred=-2*(y_true-y_pred)

        # Neuron o1
        d_ypred_d_w5 = h1*deriv_sigmoid(sum_o1)
        d_ypred_d_w6 = h2 * deriv_sigmoid(sum_o1)
        d_ypred_d_b3 = deriv_sigmoid(sum_o1)

        d_ypred_d_h1=self.w5* deriv_sigmoid(sum_o1)
        d_ypred_d_h2=self.w6 * deriv_sigmoid(sum_o1)

        # Neuron h1
        d_h1_d_w1=x[0]*deriv_sigmoid(sum_h1)
        d_h1_d_w2=x[1]*deriv_sigmoid(sum_h1)
        d_h1_d_b1=deriv_sigmoid(sum_h1)

        # Neuron h2
        d_h2_d_w3 = x[0] * deriv_sigmoid(sum_h2)
        d_h2_d_w4 = x[1] * deriv_sigmoid(sum_h2)
        d_h2_d_b2 = deriv_sigmoid(sum_h2)

        # --- 更新权重和偏差
        # Neuron h1
        self.w1 -=learn_rate*d_L_d_ypred*d_ypred_d_h1*d_h1_d_w1
        self.w2 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_w2
        self.b1 -= learn_rate * d_L_d_ypred * d_ypred_d_h1 * d_h1_d_b1
        # Neuron h2
        self.w3 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w3
        self.w4 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_w4
        self.b2 -= learn_rate * d_L_d_ypred * d_ypred_d_h2 * d_h2_d_b2
        # Neuron o1
        self.w5 -= learn_rate * d_L_d_ypred * d_ypred_d_w5
        self.w6 -= learn_rate * d_L_d_ypred * d_ypred_d_w6
        self.b3 -= learn_rate * d_L_d_ypred * d_ypred_d_b3

      # --- 在每次epoch结束时计算总损失
      if epoch % 10==0:
        y_preds=np.apply_along_axis(self.feedforward, 1, data)
        loss=mse_loss(all_y_trues, y_preds)
        print("Epoch %d loss: %.3f"%(epoch,loss))
# 定义数据集
data=np.array([
  [-2,1],#Alice
  [25,6],#Bob
  [17,4],#Charlie
  [-15,-6],#Diana
])
all_y_trues=np.array([
  1,#Alice
  0,#Bob
  0,#Charlie
  1,#Diana
])

network=OurNeuralNetwork()

#训练我们的神经网络
network.train(data, all_y_trues)

#做一些预测
emily=np.array([-7,-3])#128磅，63英寸
frank=np.array([20,2])#155磅，68英寸
print("Emily:%.3f"%network.feedforward(emily))
print("Emily:%.3f"%network.feedforward(frank))

以上代码都可以直接运行

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

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

相关文章

C51---串口发送指令,控制LED灯亮灭

C51---串口发送指令,控制LED灯亮灭

1.Code: #include "reg52.h" #include "intrins.h" sfr AUXR 0x8E; sbit D5 P3^7; void UartInit(void) //9600bps11.0592MHz { //PCON & 0x7F; //波特率不倍速 AUXR 0x01; SCON 0x50; //8位数据,可变波…
阅读更多...
Spark-RDD 转换算子（双 Value 类型、Key - Value 类型）

Spark-RDD 转换算子（双 Value 类型、Key - Value 类型）

双 Value 类型 1、intersection（交集） 2、union（并集） 3、subtract（差集） 4、zip（拉链） Key - Value 类型 1、partitionBy 2、reduceByKey 3、groupByKey 4、aggregateByK…
阅读更多...
FinOps首次超越安全成为企业头等大事｜云计算趋势报告

FinOps首次超越安全成为企业头等大事｜云计算趋势报告

随着云计算在过去十年中的广泛应用，云计算用户所面临的一个持续不变的趋势是：安全一直是用户面临的首要挑战。然而，这种情况正在发生转变。 知名IT软件企业 Flexera 对云计算决策者进行年度调研已经持续12年，而今年安全问题首次…
阅读更多...
3.初识Vue

3.初识Vue

目录 1 vue 浏览器调试工具 1.1 安装 1.2 配置 2 数据驱动视图与双向数据绑定 3 简单使用 3.1 下载 3.2 将信息渲染到DOM上 4 使用vue浏览器调试工具 5 vue指令 1 vue 浏览器调试工具 chrome可能是我浏览器的原因，装上用不了，我们使…
阅读更多...
javaWeb核心05-FilterListenerAjax

javaWeb核心05-FilterListenerAjax

文章目录Filter&Listener&Ajax1，Filter1.1 Filter概述1.2 Filter快速入门1.2.1 开发步骤1.2.2 代码演示1.3 Filter执行流程1.4 Filter拦截路径配置1.5 过滤器链1.5.1 概述1.5.2 代码演示1.5.3 问题1.6 案例1.6.1 需求1.6.2 分析1.6.3 代码实现1.6.3.1 创建F…
阅读更多...
JavaScript Date（日期）对象

JavaScript Date（日期）对象

日期对象用于处理日期和时间。在线实例返回当日的日期和时间如何使用 Date() 方法获得当日的日期。getFullYear()使用 getFullYear() 获取年份。getTime()getTime() 返回从 1970 年 1 月 1 日至今的毫秒数。setFullYear()如何使用 setFullYear() 设置具体的日期。toUTCString()…
阅读更多...
要做一个关于DDD的内部技术分享，记录下用到的资源，学习笔记（未完）

要做一个关于DDD的内部技术分享，记录下用到的资源，学习笔记（未完）

最后更新于2023年3月10日 14:28:08 问题建模》软件分层》具体结构，是层层递进的关系。有了问题建模，才能进行具体的软件分层的讨论，再有了分层，才能讨论在domain里面应该怎么实现具体结构。 1、问题建模：Domain、Mod…
阅读更多...
手写模拟SpringMvc源码

手写模拟SpringMvc源码

MVC框架MVC是一种设计模式（设计模式就是日常开发中编写代码的一种好的方法和经验的总结）。模型（model）-视图（view）-控制器（controller），三层架构的设计模式。用于实现前端…
阅读更多...
无公网IP快解析实现移动app访问内网应用

无公网IP快解析实现移动app访问内网应用

随着移动化的发展，国内各大管理软件厂商纷纷推出相应的移动应用服务。移动端为企业提供了不一样的办公方式，从碎片化应用到一体化，同时也为企业办公提供了更高效便捷办公体验。 移动办公和传统pc端在服务器端部署时并没有太大的区别。企业为了…
阅读更多...
数据、数据资源及数据资产管理的区别

数据、数据资源及数据资产管理的区别

整理不易，转发请注明出处，请勿直接剽窃！ 点赞、关注、不迷路！ 摘要：数据、数据资源、数据资产 数据、数据资源及数据资产的区别 举例 CRM系统建设完成后会有很多数据，这些数据就是原始数据，业务…
阅读更多...
线程(操作系统408)

线程(操作系统408)

基本概念 我们说引入进程的目的是更好的使用多道程序并发执行，提高资源的利用率和系统吞吐量；而引入线程的目的则是减小程序在并发执行的时候所付出的时间开销，提高操作系统的并发性能。 线程可以理解成"轻量级进程"，…
阅读更多...
Request和Response的概述

Request和Response的概述

⭐作者介绍：大二本科网络工程专业在读，持续学习Java，输出优质文章⭐作者主页：︶ㄣ释然⭐如果觉得文章写的不错，欢迎点个关注😉有写的不好的地方也欢迎指正，一同进步😁Request和Respo…
阅读更多...
Flink之Source

Flink之Source

Flink 可以从各种来源获取数据，然后构建 DataStream 进行转换处理。一般将数据的输入来源称为数据源，而读取数据的算子就是源算子（Source）。所以，Source 就是我们整个处理程序的输入端。Flink 代码中通用的添加 Source…
阅读更多...
【零基础入门学习Python---Python的五大数据类型之数字类型】

【零基础入门学习Python---Python的五大数据类型之数字类型】

一.Python的五大数据类型之数字类型 在Python中，变量用于存储数据。变量名可以是任何字母、数字和下划线的组合。Python支持多种数据类型，包括数字、字符串、列表、元组和字典。这篇文章我们就来学习一下五大数据类型中的数字类型。 1.1 数字类型 Python 中的数字类型主要…
阅读更多...
【C语言蓝桥杯每日一题】—— 单词分析

【C语言蓝桥杯每日一题】—— 单词分析

【C语言蓝桥杯每日一题】—— 单词分析😎前言🙌单词分析🙌总结撒花💞😎博客昵称：博客小梦 😊最喜欢的座右铭：全神贯注的上吧！！！ 😊作者…
阅读更多...
JSP电动车充电运营管理系统用myeclipse定制开发mysql数据库mvc模式java编程servlet

JSP电动车充电运营管理系统用myeclipse定制开发mysql数据库mvc模式java编程servlet

一、源码特点 JSP 电动车充电运营管理系统 是一套完善的系统源码，对理解JSP java serlvet MVC编程开发语言有帮助，系统具有完整的源代码和数据库，系统主要采用B/S模式开发。 研究的基本内容是基于Web的电动车充电运营管理系统&#xf…
阅读更多...
论文笔记 | 标准误聚类问题

论文笔记 | 标准误聚类问题

关于标准误的选择，如是否选择稳健性标准误、是否采取聚类标准误。之前一直是困惑的，惯用的做法是类似主题的文献做法。所以这一次，借计量经济学课程之故，较深入学习了标准误的选择问题。 在开始之前推荐一个知乎博主。他阅读了很…
阅读更多...
ssl/tsl 加密原理

ssl/tsl 加密原理

ssl/tsl 加密原理 对称加密 对称加密：即加密和解密用的都是同一个秘钥，主要优势就是速度比非对称加密快 非对称加密 非对称加密： 即加密和解密用的是不同的秘钥，例如：在服务端存在一对公钥和私钥，服务…
阅读更多...
JWT令牌解析及刷新令牌(十一)

JWT令牌解析及刷新令牌(十一)

写在前面：各位看到此博客的小伙伴，如有不对的地方请及时通过私信我或者评论此博客的方式指出，以免误人子弟。多谢！如果我的博客对你有帮助，欢迎进行评论✏️✏️、点赞👍👍、收藏⭐️⭐️&#…
阅读更多...
mmdetection3d-之（三）--FCOS3d训练waymo数据集

mmdetection3d-之（三）--FCOS3d训练waymo数据集

本内容分为两部分 1. waymo数据集转KITTI格式2. FCOS3D训练KITTI格式的waymo数据集1 waymo数据集转kitti格式 1.1 waymo数据集简介 1.1.1 waymo数据集下载 waymo数据集v1.2.0可以从这里下载。其中，train（32个压缩包），test&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023