深度学习篇---深度学习中的超参数张量转换模型训练

news2025/2/7 1:17:42

文章目录

  • 前言
  • 第一部分：深度学习中的超参数
    • 1. 学习率（Learning Rate）
      • 定义
      • 重要性
      • 常见设置
    • 2. 批处理大小（Batch Size）
      • 定义
      • 重要性
      • 常见设置
    • 3. 迭代次数（Number of Epochs）
      • 定义
      • 重要性
      • 常见设置
    • 4. 优化器（Optimizer）
      • 定义
      • 重要性
      • 常见设置
    • 5. 损失函数（Loss Function）
      • 定义
      • 重要性
      • 常见设置
    • 6. 正则化（Regularization）
      • 定义
      • 重要性
      • 常见设置
    • 7. 网络架构（Network Architecture）
      • 定义
      • 重要性
      • 常见设置
    • PaddlePaddle中的超参数设置示例
    • PyTorch中的超参数设置示例
  • 第二部分：张量转换
    • PaddlePaddle 示例
    • PyTorch 示例
  • 第三部分：模型训练流程
    • PaddlePaddle 模型训练示例
      • 程序解释
        • 1. 导入必要的库
        • 2. 定义卷积神经网络模型
        • 3. 实例化模型
        • 4. 定义损失函数和优化器
        • 5. 训练循环
        • 6. 保存模型
    • PyTorch 模型训练示例
      • 程序解释
        • 1. 导入必要的库
        • 2. 定义卷积神经网络模型
        • 3. 实例化模型
        • 4. 定义损失函数和优化器
        • 5. 训练循环
        • 6. 保存模型
  • 总结

前言

以上就是今天要讲的内容，本文简单介绍了深度学习中的超参数以及PaddlePaddle、pytorch框架下的张量转换、模型训练。

第一部分：深度学习中的超参数

在深度学习中，超参数是模型配置的一部分，它们不是通过训练数据学习得到的，而是根据经验或实验预先设定的。以下是一些常见的超参数及其在PaddlePaddle和PyTorch框架中的详细解释：

1. 学习率（Learning Rate）

定义

定义：在优化算法中更新模型权重时的步长大小。

重要性

重要性：学习率太大可能导致训练不稳定，太小则可能导致训练过程缓慢。

常见设置

常见设置：通常开始时设置一个较大的学习率，然后根据训练进度进行衰减。

2. 批处理大小（Batch Size）

定义

定义：每次训练迭代中使用的样本数量。

重要性

重要性：较大的批处理大小可以减少梯度估计的方差，但可能需要更多的内存。较小的批处理大小可能导致训练更不稳定。

常见设置

常见设置：32, 64, 128, 256等。

3. 迭代次数（Number of Epochs）

定义

定义：整个数据集被训练模型遍历的次数。

重要性

重要性：足够的迭代次数可以确保模型有足够的时间学习，但过多的迭代可能导致过拟合。

常见设置

常见设置：根据数据集大小和问题的复杂性来定。

4. 优化器（Optimizer）

定义

定义：用于更新模型权重的算法。

重要性

重要性：不同的优化器可能对模型的收敛速度和最终性能有显著影响。

常见设置

常见设置：SGD, Adam, RMSprop等。

5. 损失函数（Loss Function）

定义

定义：用于量化模型预测与真实值之间差异的函数。

重要性

重要性：损失函数的选择直接影响模型的训练过程和性能。

常见设置

常见设置：均方误差（MSE）用于回归问题，交叉熵用于分类问题。

6. 正则化（Regularization）

定义

定义：用于防止模型过拟合的技术。

重要性

重要性：通过限制模型复杂度来提高泛化能力。

常见设置

常见设置：L1正则化、L2正则化、Dropout等。

7. 网络架构（Network Architecture）

定义

定义：构成神经网络的各种层的配置。

重要性

重要性：网络架构直接影响模型的表达能力。

常见设置

常见设置：卷积神经网络（CNN）用于图像任务，循环神经网络（RNN）用于序列数据。

PaddlePaddle中的超参数设置示例

import paddle
from paddle.optimizer import Adam
from paddle.regularizer import L2Decay

#定义模型
model = paddle.vision.models.resnet50()

#设置学习率
learning_rate = 0.001

#设置批处理大小
batch_size = 64

#设置优化器
optimizer = Adam(parameters=model.parameters(), learning_rate=learning_rate, weight_decay=L2Decay(1e-4))

#设置损失函数
loss_fn = paddle.nn.CrossEntropyLoss()

PyTorch中的超参数设置示例

import torch
import torch.nn as nn
import torch.optim as optim

#定义模型
model = torch.hub.load('pytorch/vision:v0.9.0', 'resnet50', pretrained=False)

#设置学习率
learning_rate = 0.001

#设置批处理大小
batch_size = 64

#设置优化器
optimizer = optim.Adam(model.parameters(), lr=learning_rate, weight_decay=1e-4)

#设置损失函数
criterion = nn.CrossEntropyLoss()

在实际应用中，超参数的设置通常需要通过多次实验和验证来确定。此外，还可以使用超参数优化技术，如网格搜索、随机搜索、贝叶斯优化等，来寻找最佳的超参数组合。

第二部分：张量转换

PaddlePaddle 示例

在PaddlePaddle中，可以使用paddle.io.Dataset和paddle.io.DataLoader来加载数据并进行批处理。

import paddle
from paddle.io import Dataset, DataLoader
from paddle.vision.transforms import ToTensor

#定义一个自定义的数据集类
class CustomDataset(Dataset):
    def __init__(self, image_paths, transform=None):
        self.image_paths = image_paths
        self.transform = transform

    def __len__(self):
        return len(self.image_paths)

    def __getitem__(self, idx):
        # 读取图像路径
        image_path = self.image_paths[idx]
        # 使用paddle.io.read_image读取图像，并转换为HWC格式
        image = paddle.io.read_image(image_path, dtype='float32')
        # 如果定义了转换，则应用转换
        if self.transform:
            image = self.transform(image)
        return image

#图像路径列表
image_paths = ['path/to/image1.jpg', 'path/to/image2.jpg']

#定义图像预处理转换
transform = ToTensor()  # 将图像转换为张量

#创建数据集实例
dataset = CustomDataset(image_paths=image_paths, transform=transform)

#创建DataLoader
data_loader = DataLoader(dataset, batch_size=32, shuffle=True)

#使用DataLoader迭代数据
for images in data_loader:
    # 这里images已经是张量格式，可以直接用于训练
    # images的形状为[batch_size, channels, height, width]
    pass

PyTorch 示例

在PyTorch中，可以使用torch.utils.data.Dataset和torch.utils.data.DataLoader来加载数据并进行批处理。

import torch
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image

#定义一个自定义的数据集类
class CustomDataset(Dataset):
    def __init__(self, image_paths, transform=None):
        self.image_paths = image_paths
        self.transform = transform

    def __len__(self):
        return len(self.image_paths)

    def __getitem__(self, idx):
        # 读取图像路径
        image_path = self.image_paths[idx]
        # 使用PIL库读取图像
        image = Image.open(image_path)
        # 如果定义了转换，则应用转换
        if self.transform:
            image = self.transform(image)
        return image

#图像路径列表
image_paths = ['path/to/image1.jpg', 'path/to/image2.jpg']

#定义图像预处理转换
transform = transforms.Compose([
    transforms.ToTensor(),  # 将图像转换为张量
])

#创建数据集实例
dataset = CustomDataset(image_paths=image_paths, transform=transform)

#创建DataLoader
data_loader = DataLoader(dataset, batch_size=32, shuffle=True)

#使用DataLoader迭代数据
for images in data_loader:
    # 这里images已经是张量格式，可以直接用于训练
    # images的形状为[batch_size, channels, height, width]
    pass

详细解释

  1. 自定义数据集类：CustomDataset类继承自Dataset，用于定义如何从图像路径中读取数据。
  2. init 方法：初始化方法接收图像路径列表和转换函数。
  3. len 方法：返回数据集中图像的数量。
  4. getitem 方法：实现如何根据索引idx读取单个图像。
  5. 在PaddlePaddle中，使用paddle.io.read_image来读取图像
  6. 在PyTorch中，使用PIL.Image.open来读取图像。

图像预处理转换：
7. 在PaddlePaddle中，ToTensor转换用于将图像数据转换为PaddlePaddle的张量格式，其形状为**[channels, height, width]。
8. 在PyTorch中，transforms.ToTensor()同样用于将图像数据转换为PyTorch的张量格式**，其形状为**[channels, height, width]。
9. DataLoader：DataLoader用于封装数据集**，提供批量加载、打乱数据集、多线程加载等功能。
10. 迭代数据：在训练循环中，通过迭代data_loader来获取批量的图像数据，这些数据已经是张量格式，可以直接用于模型的训练。
在上述代码中，我们只进行了最基础的图像到张量的转换。在实际应用中，可能还需要进行其他预处理步骤，如调整图像大小、裁剪、翻转、标准化等。这些步骤可以通过在transforms.Compose中添加相应的转换来实现。

第三部分：模型训练流程

PaddlePaddle 模型训练示例

在PaddlePaddle中，我们首先定义一个简单的卷积神经网络模型，然后进行训练。

import paddle
import paddle.nn as nn
import paddle.optimizer as optim
from paddle.io import DataLoader

#定义一个简单的卷积神经网络
class SimpleCNN(nn.Layer):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2D(in_channels=3, out_channels=32, kernel_size=3)
        self.pool1 = nn.MaxPool2D(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2D(in_channels=32, out_channels=64, kernel_size=3)
        self.pool2 = nn.MaxPool2D(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(in_features=64*6*6, out_features=128)
        self.fc2 = nn.Linear(in_features=128, out_features=10)

    def forward(self, x):
        x = self.pool1(self.conv1(x))
        x = self.pool2(self.conv2(x))
        x = paddle.flatten(x, 1)  # 展平操作
        x = self.fc1(x)
        x = self.fc2(x)
        return x

#实例化模型
model = SimpleCNN()

#定义损失函数
loss_fn = nn.CrossEntropyLoss()

#定义优化器
optimizer = optim.Adam(parameters=model.parameters(), learning_rate=0.001)

#假设我们已经有了一个DataLoader
#data_loader = DataLoader(...)

#训练循环
for epoch in range(10):  # 进行10个训练周期
    for images, labels in data_loader:
        # 前向传播
        outputs = model(images)
        loss = loss_fn(outputs, labels)

        # 反向传播和优化
        loss.backward()
        optimizer.step()
        optimizer.clear_grad()

    print(f'Epoch [{epoch+1}/{10}], Loss: {loss.numpy()[0]}')

#保存模型
paddle.save(model.state_dict(), 'model.pdparams')

程序解释

1. 导入必要的库
import paddle
import paddle.nn as nn
import paddle.optimizer as optim
from paddle.io import DataLoader

这些是PaddlePaddle框架中用于构建和训练神经网络的必要模块。

2. 定义卷积神经网络模型
class SimpleCNN(nn.Layer):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # 第一层卷积，输入通道3（RGB图像），输出通道32，卷积核大小3x3
        self.conv1 = nn.Conv2D(in_channels=3, out_channels=32, kernel_size=3)
        # 第一层池化，池化窗口大小2x2，步长2
        self.pool1 = nn.MaxPool2D(kernel_size=2, stride=2)
        # 第二层卷积，输入通道32，输出通道64，卷积核大小3x3
        self.conv2 = nn.Conv2D(in_channels=32, out_channels=64, kernel_size=3)
        # 第二层池化，池化窗口大小2x2，步长2
        self.pool2 = nn.MaxPool2D(kernel_size=2, stride=2)
        # 全连接层，输入特征64*6*6（取决于输入图像大小和前面的层），输出特征128
        self.fc1 = nn.Linear(in_features=64*6*6, out_features=128)
        # 输出层，输入特征128，输出特征10（假设有10个类别）
        self.fc2 = nn.Linear(in_features=128, out_features=10)

    def forward(self, x):
        # 前向传播过程
        x = self.pool1(self.conv1(x))  # 第一层卷积和池化
        x = self.pool2(self.conv2(x))  # 第二层卷积和池化
        x = paddle.flatten(x, 1)        # 展平操作，将多维数据转换为一维
        x = self.fc1(x)                 # 第一层全连接
        x = self.fc2(x)                 # 输出层
        return x

在这个类中，我们定义了一个简单的CNN结构，包括两个卷积层、两个池化层和两个全连接层。

3. 实例化模型
model = SimpleCNN()

创建了一个SimpleCNN类的实例，即我们的模型。

4. 定义损失函数和优化器
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.Adam(parameters=model.parameters(), learning_rate=0.001)

损失函数使用了交叉熵损失，适用于多分类问题。优化器选择了Adam，并设置了学习率为0.001。

5. 训练循环
for epoch in range(10):  # 进行10个训练周期
    for images, labels in data_loader:
        # 前向传播
        outputs = model(images)
        loss = loss_fn(outputs, labels)
        
        # 反向传播和优化
        loss.backward()
        optimizer.step()
        optimizer.clear_grad()

    print(f'Epoch [{epoch+1}/{10}], Loss: {loss.numpy()[0]}')

这里是一个标准的训练循环，包括前向传播、计算损失、反向传播和参数更新。每个epoch结束后，打印出当前的损失值。

6. 保存模型
paddle.save(model.state_dict(), 'model.pdparams')

训练完成后，保存模型的参数，以便后续可以加载模型进行推理或继续训练。

请注意，这段代码中的data_loader是假设已经定义好的，它应该是一个DataLoader实例，用于加载数据集并提供批处理功能。实际使用时，需要根据具体的数据集来创建DataLoader。

整体来说，这段代码展示了如何使用PaddlePaddle构建、训练和保存一个简单的CNN模型。

PyTorch 模型训练示例

在PyTorch中，我们同样定义一个简单的卷积神经网络模型，并进行训练。

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader

#定义一个简单的卷积神经网络
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3)
        self.fc1 = nn.Linear(in_features=64*6*6, out_features=128)
        self.fc2 = nn.Linear(in_features=128, out_features=10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 64*6*6)  # 展平操作
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

#实例化模型
model = SimpleCNN()

#定义损失函数
loss_fn = nn.CrossEntropyLoss()

#定义优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)

#假设我们已经有了一个DataLoader
#data_loader = DataLoader(...)

#训练循环
for epoch in range(10):  # 进行10个训练周期
    for images, labels in data_loader:
        # 前向传播
        outputs = model(images)
        loss = loss_fn(outputs, labels)

        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    print(f'Epoch [{epoch+1}/{10}], Loss: {loss.item()}')

#保存模型
torch.save(model.state_dict(), 'model.pth')

程序解释

1. 导入必要的库
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader

这些是PyTorch框架中用于构建和训练神经网络的必要模块。

2. 定义卷积神经网络模型
class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # 第一层卷积，输入通道3（RGB图像），输出通道32，卷积核大小3x3
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3)
        # 池化层，池化窗口大小2x2，步长2
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        # 第二层卷积，输入通道32，输出通道64，卷积核大小3x3
        self.conv2 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3)
        # 全连接层，输入特征64*6*6（取决于输入图像大小和前面的层），输出特征128
        self.fc1 = nn.Linear(in_features=64*6*6, out_features=128)
        # 输出层，输入特征128，输出特征10（假设有10个类别）
        self.fc2 = nn.Linear(in_features=128, out_features=10)

    def forward(self, x):
        # 前向传播过程
        x = self.pool(F.relu(self.conv1(x)))  # 第一层卷积、ReLU激活和池化
        x = self.pool(F.relu(self.conv2(x)))  # 第二层卷积、ReLU激活和池化
        x = x.view(-1, 64*6*6)                 # 展平操作，将多维数据转换为一维
        x = F.relu(self.fc1(x))                # 第一层全连接和ReLU激活
        x = self.fc2(x)                        # 输出层
        return x

在这个类中，我们定义了一个简单的CNN结构，包括两个卷积层、一个池化层（两个卷积层共享同一个池化层）、两个全连接层，并在卷积层和全连接层之后使用了ReLU激活函数。

3. 实例化模型
model = SimpleCNN()

创建了一个SimpleCNN类的实例，即我们的模型。

4. 定义损失函数和优化器
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

损失函数使用了交叉熵损失，适用于多分类问题。优化器选择了Adam，并设置了学习率为0.001。

5. 训练循环
for epoch in range(10):  # 进行10个训练周期
    for images, labels in data_loader:
        # 前向传播
        outputs = model(images)
        loss = loss_fn(outputs, labels)
        
        # 反向传播和优化
        optimizer.zero_grad()  # 清空过往梯度
        loss.backward()        # 反向传播，计算当前梯度
        optimizer.step()       # 根据梯度更新网络参数

    print(f'Epoch [{epoch+1}/{10}], Loss: {loss.item()}')

这里是一个标准的训练循环，包括**前向传播、计算损失、反向传播和参数更新。**每个epoch结束后，打印出当前的损失值。

6. 保存模型
torch.save(model.state_dict(), 'model.pth')

训练完成后，保存模型的参数，以便后续可以加载模型进行推理或继续训练。

请注意，这段代码中的data_loader是假设已经定义好的，它应该是一个DataLoader实例，用于加载数据集并提供批处理功能。实际使用时，需要根据具体的数据集来创建DataLoader。另外，代码中使用了F.relu，但没有导入F模块，应该添加import torch.nn.functional as F。

整体来说，这段代码展示了如何使用PyTorch构建、训练和保存一个简单的CNN模型。

总结

以上就是今天要讲的内容，本文仅仅简单介绍了深度学习中的超参数以及PaddlePaddle、pytorch框架下的张量转换、模型训练。

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

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

相关文章

Java设计模式：行为型模式→状态模式

Java设计模式：行为型模式→状态模式

Java 状态模式详解 1. 定义 状态模式（State Pattern）是一种行为型设计模式，它允许对象在内部状态改变时改变其行为。状态模式通过将状态需要的行为封装在不同的状态类中，实现对象行为的动态改变。该模式的核心思想是分离不同状态…
阅读更多...
快速幂，错位排序笔记

快速幂，错位排序笔记

​ 记一下刚学明白的快速幂和错位排序的原理和代码 快速幂 原理： a^b (a^（b/2）) ^ 2（b为偶数） a^b a*（a^（ (b-1)/2））^2（b为奇数） 指数为偶数时…
阅读更多...
机器人基础深度学习基础

机器人基础深度学习基础

参考： （1）【具身抓取课程-1】机器人基础 （2）【具身抓取课程-2】深度学习基础 1 机器人基础 从平面二连杆理解机器人学 正运动学：从关节角度到末端执行器位置的一个映射 逆运动学：已知末端位置…
阅读更多...
Java语法进阶

Java语法进阶

目录： Object类、常用APICollection、泛型List、Set、数据结构、CollectionsMap与斗地主案例异常、线程线程、同步等待与唤醒案例、线程池、Lambda表达式File类、递归字节流、字符流缓冲流、转换流、序列化流、Files网络编程 十二、函数式接口Stream流、方法引用 一…
阅读更多...
《chatwise：DeepSeek的界面部署》

《chatwise：DeepSeek的界面部署》

ChatWise：DeepSeek的界面部署 摘要 本文详细描述了DeepSeek公司针对其核心业务系统进行的界面部署工作。从需求分析到技术实现，再到测试与优化，全面阐述了整个部署过程中的关键步骤和解决方案。通过本文，读者可以深入了解DeepSee…
阅读更多...
单节锂电池外部供电自动切换的电路学习

单节锂电池外部供电自动切换的电路学习

文章目录 前言一、原理分析：①当VBUS处有外部电源输入时②当VBUS处无外部电源输入时 二、器件选择1、二极管2、MOS管3、其他 总结 前言 学习一种广泛应用的锂电池供电自动切换电路 电路存在外部电源时，优先使用外部电源供电，并为电池供电&…
阅读更多...
数据结构-堆和PriorityQueue

数据结构-堆和PriorityQueue

1.堆&#xff08;Heap&#xff09; 1.1堆的概念 堆是一种非常重要的数据结构&#xff0c;通常被实现为一种特殊的完全二叉树 如果有一个关键码的集合K{k0,k1,k2,...,kn-1}&#xff0c;把它所有的元素按照完全二叉树的顺序存储在一个一维数组中&#xff0c;如果满足ki<k2i…
阅读更多...
如何打造一个更友好的网站结构？

如何打造一个更友好的网站结构？

在SEO优化中&#xff0c;网站的结构往往被忽略&#xff0c;但它其实是决定谷歌爬虫抓取效率的关键因素之一。一个清晰、逻辑合理的网站结构&#xff0c;不仅能让用户更方便地找到他们需要的信息&#xff0c;还能提升搜索引擎的抓取效率 理想的网站结构应该像一棵树&#xff0c;…
阅读更多...
每日Attention学习20——Group Shuffle Attention

每日Attention学习20——Group Shuffle Attention

模块出处 [MICCAI 24] [link] LB-UNet: A Lightweight Boundary-Assisted UNet for Skin Lesion Segmentation 模块名称 Group Shuffle Attention (GSA) 模块作用 轻量特征学习 模块结构 模块特点 使用分组(Group)卷积降低计算量引入External Attention机制更好的学习特征S…
阅读更多...
VUE之组件通信（二）

VUE之组件通信（二）

1、v-model v-model的底层原理&#xff1a;是:value值和input事件的结合 $event到底是啥&#xff1f;啥时候能.target 对于原生事件&#xff0c;$event就是事件对象 &#xff0c;能.target对应自定义事件&#xff0c;$event就是触发事件时&#xff0c;所传递的数据&#xff…
阅读更多...
[x86 ubuntu22.04]进入S4失败

[x86 ubuntu22.04]进入S4失败

目录 1 问题描述 2 解决过程 2.1 查看内核日志 2.2 新建一个交换分区 2.3 指定交换分区的位置 1 问题描述 CPU&#xff1a;G6900E OS&#xff1a;ubuntu22.04 Kernel&#xff1a;6.8.0-49-generic 使用“echo disk > /sys/power/state”命令进入 S4&#xff0c;但是无法…
阅读更多...
idea隐藏无关文件

idea隐藏无关文件

idea隐藏无关文件 如果你想隐藏某些特定类型的文件&#xff08;例如 .log 文件或 .tmp 文件&#xff09;&#xff0c;可以通过以下步骤设置&#xff1a; 打开设置 在菜单栏中选择 File > Settings&#xff08;Windows/Linux&#xff09;或 IntelliJ IDEA > Preference…
阅读更多...
文献阅读 250205-Global patterns and drivers of tropical aboveground carbon changes

文献阅读 250205-Global patterns and drivers of tropical aboveground carbon changes

Global patterns and drivers of tropical aboveground carbon changes 来自 <Global patterns and drivers of tropical aboveground carbon changes | Nature Climate Change> 热带地上碳变化的全球模式和驱动因素 ## Abstract: Tropical terrestrial ecosystems play …
阅读更多...
【数据结构】循环链表

【数据结构】循环链表

循环链表 单链表局限性单向循环链表判断链表是否有环思路code 找到链表入口思路代码结构与逻辑 code 单链表局限性 单链表作为一种基本的数据结构&#xff0c;虽然在很多场景下都非常有用&#xff0c;但它也存在一些局限性&#xff1a; 单向访问&#xff1a;由于每个节点仅包含…
阅读更多...
ImGui 学习笔记（二）—— 多视口

ImGui 学习笔记（二）—— 多视口

在计算机图形学中&#xff0c;视口&#xff08;Viewport&#xff09;是一个可观察的多边形区域。 将物体渲染至图像的过程中&#xff0c;会用两种区域表示。世界坐标窗口是用户所关注的区域&#xff08;即用户想要可视化的东西&#xff09;&#xff0c;坐标系由应用程序确定。…
阅读更多...
安装和卸载RabbitMQ

安装和卸载RabbitMQ

我的飞书:https://rvg7rs2jk1g.feishu.cn/docx/SUWXdDb0UoCV86xP6b3c7qtMn6b 使用Ubuntu环境进行安装 一、安装Erlang 在安装RabbitMQ之前,我们需要先安装Erlang,RabbitMQ需要Erlang的语言支持 #安装Erlang sudo apt-get install erlang 在安装的过程中,会弹出一段信息,此…
阅读更多...
Apache HttpClient

Apache HttpClient

HttpClient是apache组织下面的一个用于处理HTTP请求和响应的来源工具&#xff0c;是一个在JDK基础类库是做了更好的封装的类库。 HttpClient 使用了连接池技术来管理 TCP 连接&#xff0c;这有助于提高性能并减少资源消耗。连接池允许 HttpClient 复用已经建立的连接&#xff0…
阅读更多...
Golang 并发机制-6：掌握优雅的错误处理艺术

Golang 并发机制-6：掌握优雅的错误处理艺术

并发编程可能是提高软件系统效率和响应能力的一种强有力的技术。它允许多个工作负载同时运行&#xff0c;充分利用现代多核cpu。然而&#xff0c;巨大的能力带来巨大的责任&#xff0c;良好的错误管理是并发编程的主要任务之一。 并发代码的复杂性 并发编程增加了顺序程序所不…
阅读更多...
react使用DatePicker日期选择器

react使用DatePicker日期选择器

1、引入&#xff1a;npm i day 2、页面引入&#xff1a; import dayjs from dayjs; 3、使用 <DatePicker onChange{onChange} value{datas ? dayjs(datas) : null} /> 4、事件 const onChange (date, dateString) > {setInput(dateString)setDatas(dateString)…
阅读更多...
深度学习 Pytorch 基础网络手动搭建与快速实现

深度学习 Pytorch 基础网络手动搭建与快速实现

为了方便后续练习的展开&#xff0c;我们尝试自己创建一个数据生成器&#xff0c;用于自主生成一些符合某些条件、具备某些特性的数据集。 导入相关的包 # 随机模块 import random# 绘图模块 import matplotlib as mpl import matplotlib.pyplot as plt# 导入numpy import nu…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023