二、神经网络基础与搭建

news/2024/11/18 14:04:05/

神经网络基础

  • 前言
  • 一、神经网络
    • 1.1 基本概念
    • 1.2 工作原理
  • 二、激活函数
    • 2.1 sigmoid激活函数
      • 2.1.1 公式
      • 2.1.2 注意事项
    • 2.2 tanh激活函数
      • 2.2.1 公式
      • 2.2.2 注意事项
    • 2.3 ReLU激活函数
      • 2.3.1 公式
      • 2.3.2 注意事项
    • 2.4 SoftMax激活函数
      • 2.4.1 公式
      • 2.4.2 Softmax的性质
      • 2.4.3 Softmax的应用
      • 2.4.4 代码演示
      • 2.4.5 数学计算举例
      • 2.4.6 Softmax的注意事项
  • 三、参数初始化
    • 3.1 均匀分布初始化
    • 3.2 正态分布初始化
    • 3.3 全0初始化
    • 3.4 全1初始化
    • 3.5 固定值初始化
    • 3.6 Kaiming 初始化,也叫做 HE 初始化
      • 3.6.1 正态化的Kaiming 初始化
      • 3.6.2 均匀分布的Kaiming 初始化
    • 3.7 Xavier 初始化,也叫做 Glorot初始化
      • 3.7.1 正态化的Xavier初始化
      • 3.7.2 均匀分布的Xavier初始化
  • 四、构建简单的神经网络
  • 总结


前言


一、神经网络

  • 神经网络是一种模拟人脑神经元结构和功能的计算模型,旨在解决复杂的模式识别和预测问题

1.1 基本概念

  • 神经元:神经元是神经网络的基本组成单元,它接收输入信号,通过对输入信号的处理产生输出信号。每个神经元都有多个输入和一个输出,输入可以是其他神经元的输出,也可以是外部输入信号。

  • 层级结构神经网络由多个层级结构组成,包括输入层、隐藏层和输出层。输入层接收来自外部环境的数据,每个神经元代表一个输入特征;隐藏层负责对输入数据进行非线性变换,提取特征;输出层输出预测结果,每个神经元代表一个输出值。

  • 在这里插入图片描述

  • 连接权重:连接不同神经元之间的权重,决定信号的传递强度。这些权重在神经网络的训练过程中不断调整,以实现更好的预测性能。

  • 在这里插入图片描述

  • 激活函数:激活函数用于对神经元输出进行非线性变换,引入非线性特性。常见的激活函数包括sigmoid函数、ReLU函数、tanh函数等。不同的激活函数有不同的性质,可以根据具体的任务需求选择不同的激活函数。

1.2 工作原理

  • 层级传播:信号通过逐层传递,最终到达输出层。
  • 输出预测:输出层的神经元输出预测结果。
  • 误差反向传播:根据预测结果与真实值的误差,通过反向传播算法更新连接权重。反向传播算法通过从输出层向输入层反向传播误差,依次更新权重和偏置,使得网络的预测能力逐渐提高。

二、激活函数

  • 用于对每层的输出数据进行变换,从而为整个网络注入了非线性因素,此时的神经网络就可以拟合各种曲线,提高应对复杂问题的拟合能力。

2.1 sigmoid激活函数

2.1.1 公式

f ( x ) = 1 1 + e − x f(x)=\frac{1}{1+e^{-x}} f(x)=1+ex1

  • 求导后的公式:
    • f ′ ( x ) = ( 1 1 + e − x ) ′ = 1 1 + e − x ( 1 − 1 1 + e − x ) = f ( x ) ( 1 − f ( x ) ) f'(x)=(\frac{1}{1+e^{-x}})'=\frac{1}{1+e^{-x}}(1-\frac{1}{1+e^{-x}})=f(x)(1-f(x)) f(x)=(1+ex1)=1+ex1(11+ex1)=f(x)(1f(x))

代码演示:

python">import torch
import matplotlib.pyplot as pltplt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号# 创建画布和坐标轴
_, axes = plt.subplots(1, 2)
# sigmoid函数图像
x = torch.linspace(-20, 20, 1000)
# 输入值x通过sigmoid函数转换成激活值y
y = torch.sigmoid(x)
axes[0].plot(x, y)
axes[0].grid()
axes[0].set_title('Sigmoid 函数图像')# sigmoid导数图像
x = torch.linspace(-20, 20, 1000, requires_grad=True)
torch.sigmoid(x).sum().backward()# y = 2 * torch.dot(x, x)
# y.backward()
# x.detach():输入值x的数值
# x.grad:计算梯度,求导
axes[1].plot(x.detach(), x.grad)
axes[1].grid()
axes[1].set_title('Sigmoid 导数图像')
plt.show()
  • 函数图像如下
    在这里插入图片描述

2.1.2 注意事项

  • sigmoid函数可以将任意值的输入映射到(0,1)之间,从图中我们可以看出,当输入的值大致在 < -6 或者 >6 的时候,此时输入任何值得到的激活值都差不多,这样就会导致丢失部分信息。
  • 对于sigmoid函数而言,输入值在[-6,6]之间才会有明显差异,输入值在[-3,3]之间才会有比较好的结果
  • 由导函数的图像,导数的数值范围是(0,025),当输入*< -6 或者 >6 的时候,sigmoid激活函数图像的导数接近于0,此时网络参数将更新缓慢或者无法更新
  • 一般来说,sigmoid的网络在五层之内就会产生梯度消失的现象,而且该激活函数不以0为中心,所以在实践中,使用很少。一般只用于二分类的输出层。

2.2 tanh激活函数

2.2.1 公式

f ( x ) = 1 − e − 2 x 1 + e − 2 x f(x)=\frac{1-e^{-2x}}{1+e^{-2x}} f(x)=1+e2x1e2x

  • 求导后的公式:
    f ′ ( x ) = ( 1 − e − 2 x 1 + e − 2 x ) ′ = 1 − f 2 ( x ) f'(x)=(\frac{1-e^{-2x}}{1+e^{-2x}})'=1-f^2(x) f(x)=(1+e2x1e2x)=1f2(x)

代码演示:

python">import torch
import matplotlib.pyplot as pltplt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号# 创建画布和坐标轴
_, axes = plt.subplots(1, 2)
# 函数图像
x = torch.linspace(-20, 20, 1000)
y = torch.tanh(x)
axes[0].plot(x, y)
axes[0].grid()
axes[0].set_title('Tanh 函数图像')# 导数图像
x = torch.linspace(-20, 20, 1000, requires_grad=True)
torch.tanh(x).sum().backward()
axes[1].plot(x.detach(), x.grad)
axes[1].grid()
axes[1].set_title('Tanh 导数图像')
plt.show()
  • 在这里插入图片描述

2.2.2 注意事项

  • Tanh函数将输入映射在(-1,1)之间,图像以0为中心,在0点对称,当输入 < -3 或者 >3 的时会被映射成 -1 或者 1 。导函数的取值范围(0,1),当输入的值 < -3 或者 >3 的时,其导函数近似0。
  • 与sigmoid相比,它是以0为中心,并且梯度相对于sigmoid大,使得其收敛速度要比sigmoid快,减少迭代刺水。然而,从图中可以看出,Tanh两侧的导数也为0,同样会出现梯度消失的情况。
  • 若使用的时候,可以再隐藏层使用Tanh函数,在输出层使用sigmoid函数

2.3 ReLU激活函数

2.3.1 公式

f ( x ) = m a x ( 0 , x ) f(x)=max(0, x) f(x)=max(0,x)

  • 求导后的公式:
    f ′ ( x ) = 0 或者 1 f'(x)=0或者1 f(x)=0或者1

代码演示:

python"># 创建画布和坐标轴
import torch
from matplotlib import pyplot as pltplt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号_, axes = plt.subplots(1, 2)
# 函数图像
x = torch.linspace(-20, 20, 1000)
y = torch.relu(x)
axes[0].plot(x, y)
axes[0].grid()
axes[0].set_title('ReLU 函数图像')
# 导数图像
x = torch.linspace(-20, 20, 1000, requires_grad=True)
torch.relu(x).sum().backward()
axes[1].plot(x.detach(), x.grad)
axes[1].grid()
axes[1].set_title('ReLU 导数图像')
plt.show()
  • 在这里插入图片描述

2.3.2 注意事项

  • ReLU 激活函数将小于0的值映射为 0,而大于 0 的值则保持不变,它更加重视正信号,而忽略负信号,这种激活函数运算更为简单,能够提高模型的训练效率。
  • 当x<0时,ReLU导数为0,而当x>0时,则不存在饱和问题。所以,ReLU能够在x>0时保持梯度不衰减,从而缓解梯度消失问题。然而,随着训练的推进,部分输入会落入小于0区域,导致对应权重无法更新。这种现象被称为“神经元死亡”
  • ReLU是目前最常用的激活函数。
    • 与sigmoid相比,RELU的优势是:采用sigmoid函数,计算量大(指数运算),反向传播求误差梯度时,计算量相对大,而采用Relu激活函数,整个过程的计算量节省很多。
    • siqmoid函数反向传播时,很容易就会出现梯度消失的情况,从而无法完成深层网络的训练。
    • Relu会使一部分神经元的输出为0,这样就造成了网络的稀疏性,并且减少了参数的相互依存关系,缓解了过拟合问题的发生。

2.4 SoftMax激活函数

2.4.1 公式

  • Softmax函数的本质是一种归一化函数,它将一个数值向量归一化为一个概率分布向量,且各个概率之和为1。对于一个给定的实数向量z,Softmax函数首先计算每一个元素的指数(e的幂),然后每个元素的指数与所有元素指数总和的比值,就形成了Softmax函数的输出。
    Softmax ( z i ) = e z i ∑ j = 1 K e z j \text{Softmax}(z_i) = \frac{e^{z_i}}{\sum_{j=1}^{K} e^{z_j}} Softmax(zi)=j=1Kezjezi

  • 其中, z i z_i zi 表示输入向量 z z z 的第 i i i 个分量, K K K 是类别总数,即向量 z z z 的维度, e e e 是自然对数的底数。

  • 实际计算的时候需要输入向量减去向量中的最大值

    • 在实际应用中,直接计算 e z i e^{z_i} ezi 可能会导致数值溢出,特别是当输入值很大时。为了防止这种情况,可以在计算前减去向量中的最大值。

2.4.2 Softmax的性质

  • 归一化:Softmax保证所有输出值的和为1,使其可以被解释为概率。
  • 可微性:Softmax函数在整个定义域内可微,这使得它可以在基于梯度的优化算法中使用,例如反向传播。
  • 敏感性:Softmax对输入值非常敏感,尤其是当有一个输入远大于其他输入时。

2.4.3 Softmax的应用

  • 多类别分类问题:Softmax函数常用于多类别分类问题中,将输入向量映射为各个类别的概率。在神经网络中,Softmax通常作为输出层的激活函数,将网络的输出转换为类别概率。
  • 交叉熵损失函数:在训练神经网络时,Softmax函数通常与交叉熵损失函数结合使用。交叉熵损失函数用于衡量预测概率分布与真实标签之间的差异,从而进行模型的训练和优化。

2.4.4 代码演示

代码演示:

python">import torchscores = torch.tensor([0.2, 0.02, 0.15, 0.15, 1.3, 0.5, 0.06, 1.1, 0.05, 3.75])
# dim = 0,按行计算
probabilities = torch.softmax(scores, dim=0)
print(probabilities)

2.4.5 数学计算举例

  • 0、背景:
    • 假设我们有一个神经网络,用于识别手写数字(0 到 9)。神经网络的输出层有 10 个神经元,每个神经元对应一个数字类别。在训练完成后,对于一个新的输入图像,神经网络的输出层会产生一个 10 维的实数向量。我们需要将这个向量转换为一个概率分布,以便确定哪个数字最有可能是正确的。
  • 1、输入向量
    • z = [ 1.0 , 2.0 , 3.0 , 4.0 , 1.0 , 0.5 , 0.0 , − 1.0 , − 2.0 , − 3.0 ] z = [1.0,2.0,3.0,4.0,1.0,0.5,0.0,−1.0,−2.0,−3.0] z=[1.0,2.0,3.0,4.0,1.0,0.5,0.0,1.0,2.0,3.0]
  • 2、减去最大值
    • 为了防止数值溢出,我们先减去向量中的最大值(4.0)
    • z ′ = [ 1.0 − 4.0 , 2.0 − 4.0 , 3.0 − 4.0 , 4.0 − 4.0 , 1.0 − 4.0 , 0.5 − 4.0 , 0.0 − 4.0 , − 1.0 − 4.0 , − 2.0 − 4.0 , − 3.0 − 4.0 ] z'=[1.0−4.0,2.0−4.0,3.0−4.0,4.0−4.0,1.0−4.0,0.5−4.0,0.0−4.0,−1.0−4.0,−2.0−4.0,−3.0−4.0] z=[1.04.0,2.04.0,3.04.0,4.04.0,1.04.0,0.54.0,0.04.0,1.04.0,2.04.0,3.04.0]
    • z ′ = [ − 3.0 , − 2.0 , − 1.0 , 0.0 , − 3.0 , − 3.5 , − 4.0 , − 5.0 , − 6.0 , − 7.0 ] z' = [−3.0,−2.0,−1.0,0.0,−3.0,−3.5,−4.0,−5.0,−6.0,−7.0] z=[3.0,2.0,1.0,0.0,3.0,3.5,4.0,5.0,6.0,7.0]
  • 3、计算指数
    • e z ′ = [ e − 3.0 , e − 2.0 , e − 1.0 , e 0.0 , e − 3.0 , e − 3.5 , e − 4.0 , e − 5.0 , e − 6.0 , e − 7.0 ] e^{z'} = [e^{-3.0},e^{-2.0},e^{-1.0},e^{0.0},e^{-3.0},e^{-3.5},e^{-4.0},e^{-5.0},e^{-6.0},e^{-7.0}] ez=[e3.0,e2.0,e1.0,e0.0,e3.0,e3.5,e4.0,e5.0,e6.0,e7.0]
    python">import numpy as npz_prime = np.array([-3.0, -2.0, -1.0, 0.0, -3.0, -3.5, -4.0, -5.0, -6.0, -7.0])
    exp_z_prime = np.exp(z_prime)	
    print(exp_z_prime)
    
    • [‘0.0497870684’, ‘0.1353352832’, ‘0.3678794412’, ‘1.0000000000’, ‘0.0497870684’, ‘0.0301973834’, ‘0.0183156389’, ‘0.0067379470’, ‘0.0024787522’, ‘0.0009118820’]
  • 4、计算分母
    • ∑ i = 1 10 e z ′ = 0.0497870684 + 0.1353352832 + 0.3678794412 + 1.0000000000 + 0.0497870684 + 0.0301973834 + 0.0183156389 + 0.0067379470 + 0.0024787522 + 0.0009118820 \sum_{i=1}^{10}e^{z'}= 0.0497870684+0.1353352832+0.3678794412+1.0000000000+0.0497870684+0.0301973834+0.0183156389+0.0067379470+0.0024787522+0.0009118820 i=110ez=0.0497870684+0.1353352832+0.3678794412+1.0000000000+0.0497870684+0.0301973834+0.0183156389+0.0067379470+0.0024787522+0.0009118820
    • ∑ i = 1 10 e z ′ = 1.6614304647 \sum_{i=1}^{10}e^{z'}= 1.6614304647 i=110ez=1.6614304647
  • 5、计算Softmax
    • 将每个指数除以总和,得到概率分布
    • s o f t m a x ( z i ) = e z ′ ∑ i = 1 10 e z ′ softmax(z_i) = \frac{e^{z'}}{\sum_{i=1}^{10}e^{z'}} softmax(zi)=i=110ezez
python">sum_exp_z_prime = np.sum(exp_z_prime)
softmax_output = exp_z_prime / sum_exp_z_prime
print(softmax_output)
- 输出结果为:[0.0299663871,0.0814570854,0.2214233150,0.6018909737,0.0299663871,0.0181755325,0.0110240177,0.0040555095,0.0014919386,0.0005488535]
  • 6、结果解释
    • 第四个元素的概率最高为0.6018909737,所以预测为 数字 3
    • 其他数字概率较小,所以表示其他数字的可能性较小

2.4.6 Softmax的注意事项

  • 输入值范围:Softmax函数的输入值可以是任意实数,但通常在实际应用中,输入值是经过神经网络计算得到的logits(即未归一化的得分或置信度)。
  • 数值稳定性:在计算Softmax函数时,由于涉及到指数运算,可能会出现数值溢出或下溢的问题。为了解决这个问题,通常会对输入值进行适当的缩放或平移处理。
  • 互斥类别:Softmax函数适用于类别互斥的情况,即每个样本只能属于一个类别。如果问题是多标签分类(即一个样本可能属于多个类别),则需要使用其他方法,如sigmoid函数或其他多标签分类算法。

三、参数初始化

导包:

python">import torch
import torch.nn.functional as F
import torch.nn as nn

3.1 均匀分布初始化

  • 权重参数初始化从区间均匀随机取值。即在( − 1 d , 1 d \frac{-1}{\sqrt{d}},\frac{1}{\sqrt{d}} d 1,d 1 )均匀分布中生成当前神经元的权重,其中 d d d 为每个神经元的输入数量

代码演示:

python">linear = nn.Linear(5, 3)
# 从0-1均匀分布产生参数
nn.init.uniform_(linear.weight)
print(linear.weight.data)

3.2 正态分布初始化

  • 随机初始化从均值为0,标准差是1的高斯分布中取样,使用一些很小的值对参数 W W W 进行初始化

代码演示:

python">linear = nn.Linear(5, 3)
nn.init.normal_(linear.weight, mean=0, std=1)
print(linear.weight.data)

3.3 全0初始化

代码演示:

python">linear = nn.Linear(5, 3)
nn.init.zeros_(linear.weight)
print(linear.weight.data)

3.4 全1初始化

代码演示:

python">linear = nn.Linear(5, 3)
nn.init.ones_(linear.weight)
print(linear.weight.data)

3.5 固定值初始化

  • 神经网络中的所有权重参数初始化为某个固定值

代码演示:

python">linear = nn.Linear(5, 3)
nn.init.constant_(linear.weight, 5)  # 里边写 几 就是 用哪个值初始化
print(linear.weight.data)

3.6 Kaiming 初始化,也叫做 HE 初始化

3.6.1 正态化的Kaiming 初始化

  • s t d d e v = 2 f a n i n stddev = \sqrt{\frac{2}{fan_{in}}} stddev=fanin2
  • f a n i n fan_{in} fanin 输入神经元的个数

代码演示:

python"># kaiming 正态分布初始化
linear = nn.Linear(5, 3)
nn.init.kaiming_normal_(linear.weight)
print(linear.weight.data)

3.6.2 均匀分布的Kaiming 初始化

  • f a n i n fan_{in} fanin 输入神经元的个数
  • 它从 [ − l i m i t , l i m i t ] [-limit,limit] [limitlimit] 中的均匀分布中抽取样本, l i m i t limit limit 6 f a n i n \sqrt{\frac{6}{fan_{in}}} fanin6

代码演示:

python"># kaiming 均匀分布初始化
linear = nn.Linear(5, 3)
nn.init.kaiming_uniform_(linear.weight)
print(linear.weight.data)

3.7 Xavier 初始化,也叫做 Glorot初始化

3.7.1 正态化的Xavier初始化

  • s t d d e v = 2 f a n i n + f a n o u t stddev = \sqrt{\frac{2}{fan_{in}+fan_{out}}} stddev=fanin+fanout2
  • f a n i n fan_{in} fanin 输入神经元的个数
  • f a n o u t fan_{out} fanout 输出的神经元个数

代码演示:

python"># xavier 正态分布初始化
linear = nn.Linear(5, 3)
nn.init.xavier_normal_(linear.weight)
print(linear.weight.data)

3.7.2 均匀分布的Xavier初始化

  • 它从 [ − l i m i t , l i m i t ] [-limit,limit] [limitlimit] 中的均匀分布中抽取样本, l i m i t limit limit 6 f a n i n + f a n o u t \sqrt{\frac{6}{fan_{in}+fan_{out}}} fanin+fanout6

代码演示:

python"># xavier 均匀分布初始化
linear = nn.Linear(5, 3)
nn.init.xavier_uniform_(linear.weight)
print(linear.weight.data)

四、构建简单的神经网络

  • 案例:我们构建如下网络
    - 定义网络中的层结构,主要是全连接层,并进行初始化
  • 要求如下:
    • 第1个隐藏层:权重初始化采用标准化的xavier初始化 激活函数使用sigmoid
    • 第2个隐藏层:权重初始化采用标准化的He初始化 激活函数采用relu
    • out输出层线性层,采用 softmax 做数据分类输出

代码演示:

python">"""
在pytorch中定义深度神经网络其实就是层堆叠的过程,继承自nn.Module,实现两个方法:1、__init__方法中定义网络中的层结构,主要是全连接层,并进行初始化2、forward方法,在实例化模型的时候,底层会自动调用该函数。该函数中可以定义学习率,为初始化定义的layer传入数据等。
"""
import torch
import torch.nn as nn
from torchsummary import summary  # 计算模型参数,查看模型结构, pip install torchsummary# 创建神经网络模型类
class Model(nn.Module):# 初始化属性值def __init__(self):super(Model, self).__init__() # 调用父类的初始化属性值self.linear1 = nn.Linear(3, 3) # 创建第一个隐藏层模型, 3个输入特征,3个输出特征nn.init.xavier_normal_(self.linear1.weight) # 初始化权# 创建第二个隐藏层模型, 3个输入特征(上一层的输出特征),2个输出特征self.linear2 = nn.Linear(3, 2)# 初始化权重nn.init.kaiming_normal_(self.linear2.weight)# 创建输出层模型self.out = nn.Linear(2, 2)# 创建前向传播方法,自动执行forward()方法def forward(self, x):# 数据经过第一个线性层x = self.linear1(x)# 使用sigmoid激活函数x = torch.sigmoid(x)# 数据经过第二个线性层x = self.linear2(x)# 使用relu激活函数x = torch.relu(x)# 数据经过输出层x = self.out(x)# 使用softmax激活函数# dim=-1:每一维度行数据相加为1x = torch.softmax(x, dim=-1)return xif __name__ == "__main__":# 实例化model对象my_model = Model()# 随机产生数据my_data = torch.randn(5, 3)print("mydata shape", my_data.shape)# 数据经过神经网络模型训练output = my_model(my_data)print("output shape-->", output.shape)# 计算模型参数# 计算每层每个神经元的w和b个数总和summary(my_model, input_size=(3,), batch_size=5) # 查看模型参数print("======查看模型参数w和b======")for name, parameter in my_model.named_parameters():print(name, parameter)

总结

  • 我们通过学习了激活函数和参数初始化后,我们能实现搭建一个简单的神经网络

http://www.ppmy.cn/news/1548001.html

相关文章

【代码大模型】Compressing Pre-trained Models of Code into 3 MB论文阅读

Compressing Pre-trained Models of Code into 3 MB key word: code PLM, compression, GA算法 论文&#xff1a;https://dl.acm.org/doi/pdf/10.1145/3551349.3556964 代码&#xff1a;https://github.com/soarsmu/Compressor.git 【why】 1.问题描述&#xff1a; code LLM …

3. langgraph中的react agent使用 (在react agent添加系统提示)

环境准备 确保你已经安装了以下库&#xff1a; langchainlangchain_openailanggraph 你可以使用以下命令进行安装&#xff1a; pip install langchain langchain_openai langgraph代码实现 1. 初始化模型 首先&#xff0c;我们需要初始化智谱AI的聊天模型。 from langch…

从零到一:利用 AI 开发 iOS App 《震感》的编程之旅

在网上看到一篇关于使用AI开发的编程经历&#xff0c;分享给大家 作者是如何在没有 iOS 开发经验的情况下&#xff0c;借助 AI&#xff08;如 Claude 3 模型&#xff09;成功开发并发布《震感》iOS 应用。 正文开始 2022 年 11 月&#xff0c;ChatGPT 诞生并迅速引发全球关注。…

8. 基于 Redis 实现限流

在高并发的分布式系统中&#xff0c;限流是保证服务稳定性的重要手段之一。通过限流机制&#xff0c;可以控制系统处理请求的频率&#xff0c;避免因瞬时流量过大导致系统崩溃。Redis 是一种高效的缓存数据库&#xff0c;具备丰富的数据结构和原子操作&#xff0c;适合用来实现…

智能网页内容截图工具:AI助力内容提取与可视化

我们每天都会接触到大量的网页内容。然而&#xff0c;如何从这些内容中快速提取关键信息&#xff0c;并有效地进行整理和分享&#xff0c;一直是困扰我们的问题。本文将介绍一款我近期完成的基于AI技术的智能网页内容截图工具&#xff0c;它能够自动分析网页内容&#xff0c;截…

【Cesium】自定义材质,添加带有方向的滚动路线

【Cesium】自定义材质&#xff0c;添加带有方向的滚动路线 &#x1f356; 前言&#x1f3b6;一、实现过程✨二、代码展示&#x1f3c0;三、运行结果&#x1f3c6;四、知识点提示 &#x1f356; 前言 【Cesium】自定义材质&#xff0c;添加带有方向的滚动路线 &#x1f3b6;一、…

时序预测:多头注意力+宽度学习

✨✨ 欢迎大家来访Srlua的博文&#xff08;づ&#xffe3;3&#xffe3;&#xff09;づ╭❤&#xff5e;✨✨ &#x1f31f;&#x1f31f; 欢迎各位亲爱的读者&#xff0c;感谢你们抽出宝贵的时间来阅读我的文章。 我是Srlua小谢&#xff0c;在这里我会分享我的知识和经验。&am…

Java算法OJ(7)随机快速排序

目录 1.前言 2.正文 1. 快速排序的基本原理 2. 随机快速排序的改进 3. 随机快速排序的步骤 3.小结 1.前言 哈喽大家好吖&#xff0c;今儿给大家带来算法—随机快速排序相关知识点&#xff0c;废话不多说让我们开始。 2.正文 在了解随机快排之前&#xff0c;先了解一下…