pytorch经典训练流程

文章目录

    • @[toc]
      • 1. **经典训练流程和任务：监督学习**
        • **1.1 什么是监督学习？**
        • **1.2 为什么要设计训练流程？**
        • **1.3 怎么设计训练流程？**
        • **代码示例：监督学习的典型流程**
      • 2. **超参数设置**
        • **2.1 什么是超参数？**
        • **2.2 为什么要设置超参数？**
        • **2.3 怎么设置超参数？**
        • **代码示例：设置超参数**
      • 3. **数据集预处理（Pre-transform）**
        • **3.1 什么是数据集预处理？**
        • **3.2 为什么要预处理？**
        • **3.3 怎么做预处理？**
        • **代码示例：数据预处理**
      • 4. **数据集加载**
        • **4.1 什么是数据集加载？**
        • **4.2 为什么需要数据集加载器？**
        • **4.3 怎么加载数据集？**
        • **代码示例：数据加载**
      • 5. **数据集后处理（Transform）**
        • **5.1 什么是数据集后处理？**
        • **5.2 为什么需要后处理？**
        • **5.3 常见的后处理操作**
        • **代码示例：数据集后处理**
        • **可视化增强后的数据**
      • 6. **模型初始化、优化器初始化**
        • **6.1 什么是模型初始化？**
        • **6.2 为什么要初始化模型？**
        • **6.3 怎么初始化模型？**
        • **代码示例：模型初始化**
        • **优化器初始化**
      • 7. **多个 Epoch 的训练：梯度下降**
        • **7.1 什么是梯度下降？**
        • **7.2 为什么要多次训练（多个 Epoch）？**
        • **7.3 训练流程**
        • **代码示例：多个 Epoch 的训练**
      • 8. **中间结果打印 (Loss, Accuracy 等)**
        • **8.1 为什么打印中间结果？**
        • **8.2 什么是常见的中间结果？**
        • **8.3 怎么计算和打印中间结果？**
        • **代码示例：中间结果打印**
        • **8.4 增加验证过程**
        • **8.5 可视化训练曲线**

1. 经典训练流程和任务：监督学习

1.1 什么是监督学习？

监督学习是一种机器学习方法，模型通过已标注的数据（输入与输出）进行训练，从而学习从输入预测输出的映射关系。其目标是让模型能够在未标注的新数据上作出准确预测。

典型任务：

  • 分类任务：预测输入属于哪个类别（例如图像分类、垃圾邮件检测）。
  • 回归任务：预测连续的数值（例如房价预测、股票预测）。
1.2 为什么要设计训练流程？

监督学习的目标是最小化模型预测输出和真实输出之间的误差（称为损失）。一个标准的训练流程可以帮助我们：

  1. 有效利用数据 ：通过批量化处理大数据集，逐步优化模型参数。
  2. 动态调整模型 ：通过多轮迭代学习更好的参数。
  3. 评估模型性能 ：通过指标（例如准确率、损失值）判断模型效果。
1.3 怎么设计训练流程？

一个典型的监督学习训练流程包括以下步骤：

  1. 准备数据（加载、预处理）。
  2. 初始化模型。
  3. 定义损失函数和优化器。
  4. 执行多个 epoch 的训练（包括前向传播、损失计算、反向传播、参数更新）。
  5. 评估模型性能。
代码示例：监督学习的典型流程

以下是一个简单的监督学习流程，用于分类任务（例如使用 MNIST 手写数字数据集）：

# 1. 加载必要的库
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms# 2. 数据准备
transform = transforms.Compose([transforms.ToTensor(),  # 转换为张量transforms.Normalize((0.5,), (0.5,))  # 标准化
])# 加载MNIST数据集
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)# 3. 模型初始化
class SimpleNN(nn.Module):def __init__(self):super(SimpleNN, self).__init__()self.fc = nn.Sequential(nn.Flatten(),  # 展平输入nn.Linear(28 * 28, 128),  # 全连接层nn.ReLU(),  # 激活函数nn.Linear(128, 10)  # 输出层（10类别）)def forward(self, x):return self.fc(x)model = SimpleNN()# 4. 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()  # 交叉熵损失
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 随机梯度下降优化器# 5. 训练流程
epochs = 5
for epoch in range(epochs):model.train()running_loss = 0.0for batch_idx, (inputs, labels) in enumerate(train_loader):# 清除之前的梯度optimizer.zero_grad()# 前向传播outputs = model(inputs)loss = criterion(outputs, labels)# 反向传播和参数更新loss.backward()optimizer.step()running_loss += loss.item()print(f"Epoch {epoch+1}/{epochs}, Loss: {running_loss/len(train_loader):.4f}")# 6. 模型评估
model.eval()
correct = 0
total = 0
with torch.no_grad():for inputs, labels in test_loader:outputs = model(inputs)_, predicted = torch.max(outputs, 1)  # 获取最大值对应的类别correct += (predicted == labels).sum().item()total += labels.size(0)print(f"Accuracy: {100 * correct / total:.2f}%")

2. 超参数设置

2.1 什么是超参数？

超参数是那些在训练模型之前手动设置的参数，而不是通过训练自动学习的参数。超参数对模型性能和训练过程有重要影响。常见的超参数包括：

  • 学习率（learning rate）：决定每次参数更新的步长大小。
  • 批量大小（batch size）：决定一次训练中使用的样本数。
  • 训练轮数（epochs）：模型在整个数据集上训练的完整次数。
  • 隐藏层的层数和单元数（网络结构相关）。
  • 优化器类型（如 SGD, Adam）。
2.2 为什么要设置超参数？

合理的超参数设置可以：

  1. 提升训练效率 ：加速收敛，减少训练时间。
  2. 提高模型性能 ：避免欠拟合或过拟合。
  3. 改善稳定性 ：避免训练过程中的数值不稳定或发散。

超参数通常需要通过经验或网格搜索、随机搜索等方法来确定最佳值。

2.3 怎么设置超参数？

以下是常见的超参数设置和推荐值：

  1. 学习率 ：较小值（如 0.001~0.01）通常较稳定，但训练慢；较大值（如 0.1）可能加速训练，但易导致不收敛。
  2. 批量大小 ：32、64 或 128 是常用的值，GPU 通常能更好地处理较大的 batch。
  3. 训练轮数 ：视数据集大小和模型复杂度而定，通常设置为 5~100。
  4. 优化器 ：推荐从 Adam 开始，默认参数 lr=0.001。
代码示例：设置超参数

以下是一个简单的超参数设置示例，包含了常见的超参数配置：

# 超参数定义
learning_rate = 0.01  # 学习率
batch_size = 64       # 批量大小
epochs = 10           # 训练轮数# 数据加载
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)# 模型、损失函数和优化器初始化
model = SimpleNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=learning_rate)# 输出超参数设定
print(f"Hyperparameters:\n Learning Rate: {learning_rate}\n Batch Size: {batch_size}\n Epochs: {epochs}")

3. 数据集预处理（Pre-transform）

3.1 什么是数据集预处理？

数据集预处理是指在模型训练前对原始数据进行转换，使其适合输入到模型中。典型的预处理包括：

  • 图像归一化、缩放。
  • 缺失值填充。
  • 特征工程（如词嵌入、独热编码）。

在深度学习中，pre-transform 通常是一次性操作，处理后的数据保存到磁盘，后续训练直接加载以节省时间。

3.2 为什么要预处理？
  1. 提高模型训练效果 ：例如，归一化可以加快收敛速度。
  2. 减少数据噪声 ：例如，去掉异常值。
  3. 统一数据格式 ：确保数据符合模型输入要求。
3.3 怎么做预处理？

以下以 MNIST 数据集为例说明预处理：

  • 归一化：将像素值从 [0, 255] 映射到 [0, 1]。
  • 标准化：使数据均值为 0，标准差为 1。
代码示例：数据预处理
# 定义预处理操作
transform = transforms.Compose([transforms.ToTensor(),  # 转为 PyTorch 张量transforms.Normalize((0.5,), (0.5,))  # 标准化：均值为0，方差为1
])# 加载并预处理数据集
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)
test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)# 数据加载器
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)

4. 数据集加载

4.1 什么是数据集加载？

数据集加载是指将数据从存储介质中读取到内存中，并按需提供给模型训练的过程。PyTorch 提供了 DataLoader 方便进行批量化加载数据。

4.2 为什么需要数据集加载器？
  1. 批量化处理 ：分批加载可以减少内存占用，加速训练。
  2. 随机性 ：支持数据打乱（shuffle），有助于减少模型对数据顺序的依赖。
  3. 并行化 ：支持多线程加载数据，提高数据读取效率。
4.3 怎么加载数据集？
  • DataLoader 是核心工具，可以控制批量大小、是否打乱、加载线程数等。
代码示例：数据加载
from torch.utils.data import DataLoader# 批量加载数据
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=2)
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=2)# 查看一个 batch 的数据
data_iter = iter(train_loader)
images, labels = next(data_iter)print(f"Batch size: {images.size()}")  # 打印形状 (batch_size, 1, 28, 28)
print(f"Labels: {labels}")             # 打印标签

下一步，将详细讲解 数据集后处理（Transform） 和其他剩余内容。

5. 数据集后处理（Transform）

5.1 什么是数据集后处理？

数据集后处理是指在每次运行训练或推理时，对加载后的数据进行动态转换操作。这些操作和预处理（Pre-transform）不同，它们会在每次访问数据时应用，而不是一次性保存到磁盘。典型操作包括：

  • 数据增强（如随机裁剪、旋转）。
  • 数据格式转换（如将图片转换为张量）。
  • 特定模型需求的格式调整。
5.2 为什么需要后处理？
  1. 增加数据多样性 ：数据增强通过对原始数据的变换提高模型的泛化能力。
  2. 简化训练流程 ：通过动态调整避免为每种场景重新处理数据。
  3. 满足特定需求 ：根据不同模型需求生成合适的输入。
5.3 常见的后处理操作

以下列举了图像任务中常见的后处理操作：

  • 随机裁剪（RandomCrop）。
  • 随机旋转（RandomRotation）。
  • 随机翻转（RandomHorizontalFlip）。
  • 图像缩放（Resize）。
代码示例：数据集后处理

以下代码实现了动态的数据增强和标准化操作：

from torchvision import transforms# 定义数据增强和标准化操作
transform = transforms.Compose([transforms.RandomHorizontalFlip(p=0.5),  # 50%概率水平翻转transforms.RandomRotation(degrees=10),  # 随机旋转 -10 到 10 度transforms.ToTensor(),                  # 转为张量transforms.Normalize((0.5,), (0.5,))    # 标准化
])# 加载训练数据集（应用transform）
train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)# 数据加载器
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)# 查看一个经过后处理的数据样本
data_iter = iter(train_loader)
images, labels = next(data_iter)print(f"Image batch shape: {images.size()}")  # 打印形状
print(f"Label batch: {labels}")
可视化增强后的数据

你还可以可视化数据增强后的图像，直观观察后处理效果：

import matplotlib.pyplot as plt# 可视化前几个图像
for i in range(6):plt.subplot(2, 3, i+1)plt.imshow(images[i].squeeze().numpy(), cmap='gray')plt.title(f"Label: {labels[i].item()}")
plt.tight_layout()
plt.show()

6. 模型初始化、优化器初始化

6.1 什么是模型初始化？

模型初始化是定义模型结构，并为模型的参数赋初值的过程。在 PyTorch 中，模型通过继承 torch.nn.Module 来构建。模型的参数在定义时会默认随机初始化。

6.2 为什么要初始化模型？
  1. 定义网络结构 ：为任务设计合适的模型结构。
  2. 参数初始化 ：参数初始化对训练过程至关重要，好的初始化方式可以加速收敛并减少梯度消失或爆炸问题。
6.3 怎么初始化模型？
  • PyTorch 提供了多种参数初始化方式（如 Xavier 初始化、He 初始化）。
  • 模型结构在 __init__ 方法中定义，前向计算逻辑在 forward 方法中定义。
代码示例：模型初始化

以下示例构建了一个简单的卷积神经网络（CNN）：

import torch.nn as nn
import torch.nn.functional as Fclass SimpleCNN(nn.Module):def __init__(self):super(SimpleCNN, self).__init__()# 定义网络层self.conv1 = nn.Conv2d(1, 16, kernel_size=3, stride=1, padding=1)  # 输入通道1，输出通道16self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=1)self.fc1 = nn.Linear(32 * 7 * 7, 128)  # 全连接层self.fc2 = nn.Linear(128, 10)def forward(self, x):# 定义前向传播x = F.relu(self.conv1(x))x = F.max_pool2d(x, 2)  # 最大池化x = F.relu(self.conv2(x))x = F.max_pool2d(x, 2)x = x.view(x.size(0), -1)  # 展平x = F.relu(self.fc1(x))x = self.fc2(x)return x# 初始化模型
model = SimpleCNN()
print(model)
优化器初始化

优化器是用于更新模型参数的工具。在初始化时，需要指定优化器类型和学习率。

# 定义优化器
optimizer = optim.Adam(model.parameters(), lr=0.001)# 打印模型的可训练参数
for name, param in model.named_parameters():print(name, param.shape, param.requires_grad)

7. 多个 Epoch 的训练：梯度下降

7.1 什么是梯度下降？

梯度下降是深度学习中优化模型参数的核心算法。它通过计算损失函数相对于模型参数的梯度，逐步更新参数以最小化损失。

7.2 为什么要多次训练（多个 Epoch）？
  1. 充分学习数据 ：单次遍历数据（一个 epoch）通常不足以学到有效的参数。
  2. 渐进式优化 ：每次迭代（mini-batch）更新参数，多个 epoch 能够进一步减少损失。
7.3 训练流程

每个 epoch 的训练包括：

  1. 前向传播 ：计算模型输出和损失。
  2. 反向传播 ：通过梯度计算更新参数。
  3. 评估中间结果 ：打印损失、准确率等指标。
代码示例：多个 Epoch 的训练
epochs = 5
for epoch in range(epochs):model.train()total_loss = 0.0for inputs, labels in train_loader:optimizer.zero_grad()  # 清除梯度outputs = model(inputs)  # 前向传播loss = criterion(outputs, labels)  # 计算损失loss.backward()  # 反向传播optimizer.step()  # 参数更新total_loss += loss.item()print(f"Epoch {epoch+1}/{epochs}, Loss: {total_loss/len(train_loader):.4f}")

8. 中间结果打印 (Loss, Accuracy 等)

8.1 为什么打印中间结果？

在训练过程中打印中间结果（例如损失和准确率）有以下重要意义：

  1. 监控训练过程 ：可以观察模型是否正常收敛，避免梯度爆炸或梯度消失。
  2. 调试和排错 ：如果损失不减小或表现异常，可能是模型结构或超参数设置的问题。
  3. 评估性能趋势 ：通过观察准确率的变化，判断模型是否欠拟合或过拟合。
8.2 什么是常见的中间结果？
  1. 训练损失（Training Loss） ：表示模型在训练数据上的误差。
  2. 验证损失（Validation Loss） ：表示模型在验证数据上的误差，用于监控模型的泛化能力。
  3. 训练准确率（Training Accuracy） ：模型在训练数据上的分类正确率。
  4. 验证准确率（Validation Accuracy） ：模型在验证数据上的分类正确率。
8.3 怎么计算和打印中间结果？
  1. 损失计算 ：通过定义的损失函数 criterion 直接计算。
  2. 准确率计算 ：通过比较模型输出的预测值与真实标签，统计预测正确的数量。
  3. 打印格式优化 ：可以采用 print 或日志工具（如 logging）打印结果。
代码示例：中间结果打印

以下是训练过程中打印损失和准确率的完整代码示例：

# 定义一个函数计算准确率
def compute_accuracy(outputs, labels):_, predicted = torch.max(outputs, 1)  # 获取预测值的类别correct = (predicted == labels).sum().item()  # 统计正确数量accuracy = correct / labels.size(0)  # 计算准确率return accuracy# 训练过程
epochs = 5
for epoch in range(epochs):model.train()total_loss = 0.0total_accuracy = 0.0for inputs, labels in train_loader:optimizer.zero_grad()  # 清除梯度outputs = model(inputs)  # 前向传播loss = criterion(outputs, labels)  # 计算损失loss.backward()  # 反向传播optimizer.step()  # 参数更新total_loss += loss.item()  # 累积损失total_accuracy += compute_accuracy(outputs, labels)  # 累积准确率avg_loss = total_loss / len(train_loader)  # 平均损失avg_accuracy = total_accuracy / len(train_loader)  # 平均准确率print(f"Epoch {epoch+1}/{epochs}, Loss: {avg_loss:.4f}, Accuracy: {avg_accuracy:.4f}")
8.4 增加验证过程

通常，在每个 epoch 的末尾会用验证集进行评估，以监控模型的泛化性能。

# 验证过程
def validate_model(model, val_loader, criterion):model.eval()  # 设置为评估模式total_loss = 0.0total_accuracy = 0.0with torch.no_grad():  # 禁用梯度计算for inputs, labels in val_loader:outputs = model(inputs)loss = criterion(outputs, labels)total_loss += loss.item()total_accuracy += compute_accuracy(outputs, labels)avg_loss = total_loss / len(val_loader)avg_accuracy = total_accuracy / len(val_loader)return avg_loss, avg_accuracy# 在训练中加入验证
for epoch in range(epochs):# 训练model.train()train_loss = 0.0train_accuracy = 0.0for inputs, labels in train_loader:optimizer.zero_grad()outputs = model(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()train_loss += loss.item()train_accuracy += compute_accuracy(outputs, labels)# 验证val_loss, val_accuracy = validate_model(model, test_loader, criterion)# 打印训练和验证结果print(f"Epoch {epoch+1}/{epochs}")print(f"  Training  - Loss: {train_loss/len(train_loader):.4f}, Accuracy: {train_accuracy/len(train_loader):.4f}")print(f"  Validation - Loss: {val_loss:.4f}, Accuracy: {val_accuracy:.4f}")
8.5 可视化训练曲线

为了更清楚地观察训练过程中的趋势，可以通过可视化工具绘制损失和准确率曲线：

import matplotlib.pyplot as plt# 记录损失和准确率
train_losses, val_losses = [], []
train_accuracies, val_accuracies = [], []for epoch in range(epochs):# 训练model.train()train_loss = 0.0train_accuracy = 0.0for inputs, labels in train_loader:optimizer.zero_grad()outputs = model(inputs)loss = criterion(outputs, labels)loss.backward()optimizer.step()train_loss += loss.item()train_accuracy += compute_accuracy(outputs, labels)# 验证val_loss, val_accuracy = validate_model(model, test_loader, criterion)# 保存结果train_losses.append(train_loss / len(train_loader))val_losses.append(val_loss)train_accuracies.append(train_accuracy / len(train_loader))val_accuracies.append(val_accuracy)# 绘制曲线
plt.figure(figsize=(12, 5))# 损失曲线
plt.subplot(1, 2, 1)
plt.plot(range(epochs), train_losses, label='Train Loss')
plt.plot(range(epochs), val_losses, label='Validation Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.title('Loss Curve')# 准确率曲线
plt.subplot(1, 2, 2)
plt.plot(range(epochs), train_accuracies, label='Train Accuracy')
plt.plot(range(epochs), val_accuracies, label='Validation Accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.title('Accuracy Curve')plt.tight_layout()
plt.show()
  1. 中间结果打印是训练中的重要环节，可以帮助实时了解模型的训练和验证性能。
  2. 可以通过 print 或绘制曲线，直观展示损失和准确率的变化趋势。
  3. 验证集的使用能有效监控模型的泛化性能，避免过拟合。

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

如若内容造成侵权/违法违规/事实不符，请联系长河编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

UG NX二次开发(C++)-UIStyler-指定平面的对象和参数获取

UG NX二次开发(C++)-UIStyler-指定平面的对象和参数获取

文章目录 1、前言2、在UG NX中创建平面和一个长方体，3、在UI Styler中创建一个UI界面4、在VS中创建一个工程4.1 创建并添加工程文件4.2 在Update_cb方法中添加选择平面的代码4.3 编译完成并测试效果1、前言 在采用NXOpen C++进行二次开发时，采用Menu/UIStyler是一种很常见的…
阅读更多...
【软考】数据库

【软考】数据库

1. 数据模型 1.1 概念数据模型 概念数据模型一般用 E-R 图表示，常用术语如下： 实体：客观存在的事物，如：一个单位、一个职工、一个部门、一个项目。属性：学生实体有学号、姓名、出生日期等属性。码&#…
阅读更多...
【强化学习的数学原理】第04课-值迭代与策略迭代-笔记

【强化学习的数学原理】第04课-值迭代与策略迭代-笔记

学习资料：bilibili 西湖大学赵世钰老师的【强化学习的数学原理】课程。链接：强化学习的数学原理 西湖大学 赵世钰 文章目录 一、值迭代算法二、策略迭代算法三、截断策略迭代算法四、本节课内容summary 一、值迭代算法 值迭代算法主要包括两部分。 第一…
阅读更多...
jupyter notebook的 markdown相关技巧

jupyter notebook的 markdown相关技巧

目录 1 先选择为markdown类型 2 开关技巧 2.1 运行markdown 2.2 退出markdown显示效果 2.3 注意点：一定要 先选择为markdown类型 3 一些设置技巧 3.1 数学公式 3.2 制表 3.3 目录和列表 3.4 设置各种字体效果：加粗，斜体&#x…
阅读更多...
Spring Boot3远程调用工具RestClient

Spring Boot3远程调用工具RestClient

Spring Boot3.2之后web模块提供了一个新的远程调用工具RestClient，它的使用比RestTemplate方便，开箱即用，不需要单独注入到容器之中，友好的rest风格调用。下面简单的介绍一下该工具的使用。 一、写几个rest风格测试接口 RestCont…
阅读更多...
vscode可以编译通过c++项目，但头文件有红色波浪线的问题

vscode可以编译通过c++项目，但头文件有红色波浪线的问题

1、打开 VSCode 的设置，可以通过快捷键 Ctrl Shift P 打开命令面板，然后搜索并选择 “C/C: Edit Configurations (JSON)” 命令，这将在 .vscode 文件夹中创建或修改 c_cpp_properties.json 文件 {"configurations": [{"name…
阅读更多...
近源渗透|HID ATTACK从0到1

近源渗透|HID ATTACK从0到1

前言 对于“近源渗透”这一术语，相信大家已经不再感到陌生。它涉及通过伪装、社会工程学等手段，实地侵入企业办公区域，利用内部潜在的攻击面——例如Wi-Fi网络、RFID门禁、暴露的有线网口、USB接口等——获取关键信息，并以隐蔽的…
阅读更多...
Python爬取豆瓣电影全部分类数据并存入数据库

Python爬取豆瓣电影全部分类数据并存入数据库

在当今数字化的时代，网络上丰富的影视资源信息吸引着众多开发者去挖掘和利用。今天，我就来和大家分享一段有趣的代码，它能够从豆瓣电影平台获取相关数据并存储到数据库中哦。 结果展示（文末附完整代码）： 目…
阅读更多...
java: itext8.05 create pdf

java: itext8.05 create pdf

只能调用windows 已安装的字体，这样可以在系统中先预装字体，5.0 可以调用自配文件夹的字体文件。CSharp donetItext8.0 可以调用。 /*** encoding: utf-8* 版权所有 2024 ©涂聚文有限公司 言語成了邀功盡責的功臣，還需要行爲每日來值班…
阅读更多...
基于Java Springboot公园管理系统

基于Java Springboot公园管理系统

一、作品包含 源码数据库设计文档万字PPT全套环境和工具资源部署教程 二、项目技术 前端技术：Html、Css、Js、Vue、Element-ui 数据库：MySQL 后端技术：Java、Spring Boot、MyBatis 三、运行环境 开发工具：IDEA/eclipse 数据…
阅读更多...
Java中的File和IO流

Java中的File和IO流

File对象 File对象本质是一个文件或文件夹，用于写入和读取文件内容 注意：对于相对路径而言，在单元测试方法中的File是相对于Module，在main中的File是相对于Project 构造器 File(String pathname)File file1 new File("D:…
阅读更多...
(Keil)MDK-ARM各种优化选项详细说明、实际应用及拓展内容

(Keil)MDK-ARM各种优化选项详细说明、实际应用及拓展内容

参考 MDK-ARM各种优化选项详细说明、实际应用及拓展内容 本文围绕MDK-ARM优化选项，以及相关拓展知识（微库、实际应用、调试）进行讲述，希望对你今后开发项目有所帮助。 1 总述 我们所指的优化，主要两方面： 1.代码大小（Size） 2.代码性能（运行时间） 在MDK-ARM中，优…
阅读更多...
ssm实战项目──哈米音乐（二）

ssm实战项目──哈米音乐（二）

目录 1、流派搜索与分页 2、流派的添加 3、流派的修改 4、流派的删除 接上篇：ssm实战项目──哈米音乐（一），我们完成了项目的整体搭建，接下来进行后台模块的开发。 首先是流派模块： 在该模块中采用分…
阅读更多...
STM32的中断（什么是外部中断和其他中断以及中断号是什么）

STM32的中断（什么是外部中断和其他中断以及中断号是什么）

一、什么是EXTI 和NVIC EXTI（External Interrupt/Event Controller）EXTI 是外部中断/事件控制器，它负责处理外部信号变化，并将信号传递给中断控制器（如 NVIC）。主要负责以下功能： 外部事件检测…
阅读更多...
5、AI测试辅助-生成测试用例思维导图

5、AI测试辅助-生成测试用例思维导图

AI测试辅助-生成测试用例思维导图 创建测试用例两种方式1、Plantuml思维导图版本 (不推荐）2、Markdown思维导图版本（推荐） 创建测试用例两种方式 完整的测试用例通常需要包含以下的元素： 1、测试模块 2、测试标题 3、前置条件 4、…
阅读更多...
IDEA 2024安装指南（含安装包以及使用说明 cannot collect jvm options 问题 四）

IDEA 2024安装指南（含安装包以及使用说明 cannot collect jvm options 问题 四）

汉化 setting 中选择插件 完成 安装出现问题 1.可能是因为之前下载过的idea，找到连接中 文件，卸载即可。
阅读更多...
js+jquery实现经典推箱子游戏

js+jquery实现经典推箱子游戏

纯前端项目，只使用html,css,js,jquery实现经典推箱子游戏，直接下载本地双击index.html即可运行体验。 游戏展示 开始界面 完成游戏 代码展示
阅读更多...
《文件操作》

《文件操作》

一 . 文本文件和二进制文件 根据数据的组织形式，数据文件被分为了二进制文件和文本文件 数据在内存中是以二进制的形式存储，如果不加转换的输出到外存的文件中，就是二进制文件。 如果要求在外存上以ASCII 码的形式存储，则需要再存…
阅读更多...
监控报警系统的指标、规则与执行闭环

监控报警系统的指标、规则与执行闭环

随笔 从千万粉丝“何同学”抄袭开源项目说起，为何纯技术死路一条？ 数据源的统一与拆分 监控报警系统的指标、规则与执行闭环 java 老矣，尚能饭否？ 一骑红尘妃子笑，无人知是荔枝来! 有所依 我们如何知道系统交易…
阅读更多...
LLaMA-Mesh: Unifying 3D Mesh Generation with Language Models 论文解读

LLaMA-Mesh: Unifying 3D Mesh Generation with Language Models 论文解读

目录 一、概述 二、相关工作 1、LLMs到多模态 2、3D对象生成 3、自回归的Mesh生成 三、LLaMA-Mesh 1、3D表示 2、预训练模型 3、有监督的微调数据集 4、数据集演示 四、实验 1、生成的多样性 2、不同模型text-to-Mesh的比较 3、通用语境的评估 一、概述 该论文首…
阅读更多...
最新文章
推荐文章

Copyright @ 2022~2023