深度学习--了解代码基本思路

前言:从github上下载代码下来,虽然能大致看到指导,但是看着里面那么多文件,还是很头大,找到一个文件没那么复杂的代码,大致弄懂了应该要怎么去写深度学习的代码。

1.单个.py文件的简单Pytorch代码

《PyTorch深度学习实践》完结合集_哔哩哔哩_bilibili

建议大家自行去看这个。

基本思路就是:

1.准备数据集

2.构造训练函数

3.构造损失函数和优化器

4.迭代训练

2.很多个文件

示例代码:aRI0U/RandLA-Net-pytorch: PyTorch implementation of RandLA-Net (github.com)

 

里面文件就是这样,右边是utils文件夹里面的内容。

2.1requirement.txt

首先,这个requirement.txt文件是用来创建环境的,里面包含满足这个代码正常运行条件的固定版本的依赖包(库?)。 这个用法,在另一篇笔记里Python学习--前期准备-CSDN博客,也可以自己ChatGPT一下,很详细的。

2.2train.py

主要的就是train.py。有些可能是main.py

就是在这里面写上,上面那4步:加载数据--用来训练的模型--构造损失函数和优化器--迭代训练,只不过复杂了一点。

直接定义一个train(函数?,这个python的很多语法我还没彻底搞懂,我编程能力很差!)

第一步 加载数据

这个在这里写的很简单,但是它是把基本的函数写在 data.py里,然后在这里实例化(反正就是引用它的意思,忘记是不是这么叫了),加载训练和验证数据集:

train_loader, val_loader = data_loaders(
    args.dataset,
    args.dataset_sampling,  # 应该是 数据采样策略 ,大概是怎么形成一个批的我猜。
    batch_size=args.batch_size,  # 每个批次中的样本数量
    num_workers=args.num_workers,  # 用于数据加载的子进程数量
    pin_memory=True  # 如果使用GPU进行训练,这个参数可以确保数据在传输到GPU之前被锁定在固定的内存区域,这有助于加速数据从CPU到GPU的传输
)

然后,写基本函数的时候是不是还不知道数据的具体路径,只是用某个参数代指一下,那在这里,为了方便,就要在前面设置一些路径:

train_path = args.dataset / args.train_dir  # 创建一个路径对象,表示训练数据的目录
val_path = args.dataset / args.val_dir  # 创建一个路径对象,表示验证数据的目录
logs_dir = args.logs_dir / args.name  # 创建一个路径对象,表示日志的目录
logs_dir.mkdir(exist_ok=True, parents=True)  # 尝试创建上述日志目录

第二步 是不是就该构造训练函数了,这里就是对训练模型进行初始化。而且这个训练模型具体的内容也不写在这里,而是写在model.py里,反正先不管它里面长啥样,我们按住ctrl再用鼠标点这个模型的名称,就跳转到它的定义那里(model.py里),看看它初始化那行(__init__)里面有啥参数:

def __init__(self, d_in, num_classes, num_neighbors=16, decimation=4, device=torch.device('cpu')):

 那我就在这边对这几个参数进行初始化:

# 模型初始化
model = RandLANet(
    d_in,  # 输入数据通道数
    num_classes,  # 类别数
    num_neighbors=args.neighbors,  # 模型中用于确定邻居节点数量的参数(应该是那个局部特征整合中的k近邻个点)
    decimation=args.decimation,  # 可能是与模型的下采样率或分辨率降低有关的参数(整合完局部后就下采样,应该是RS随机采样部分吧)
    device=args.gpu  # 指定模型应该运行在哪个设备上,通常是CPU或GPU----------------------(我要用cpu的话,是直接改成cpu吗)
)

那你看,是不是要赋予这5个参数一个具体的值,才初始化成功。那就一个一个来,最好写在这段上边:

d_in:

# 确定输入维度 (输入数据的通道数)
d_in = next(iter(train_loader))[0].size(-1)
# 获取一个批次的数据,并提取第一个数据项(通常是图像)的最后一个维度的大小。这个大小通常对应于输入图像的通道数。d_in 将被用作模型输入的大小。

 num_classes:

# determine number of classes    确定类别数
try:
    with open(args.dataset / 'classes.json') as f:
        labels = json.load(f)
        num_classes = len(labels.keys())
except FileNotFoundError:
    num_classes = int(input("Number of distinct classes in the dataset: "))

 后面3个,都用了args.,大致就是把它们放在__main__里面初始化了的意思。

第三步 构造损失函数和优化器

criterion = nn.CrossEntropyLoss(weight=weights)  # 设置损失函数为交叉熵损失(通常用于分类任务)
optimizer = torch.optim.Adam(model.parameters(), lr=args.adam_lr)
scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, args.scheduler_gamma)  # 学习率衰减策略

它这里就是多了一个scheduler,这个就是改变学习率的,就是有一定优化作用吧,不管它。那注意这三行里面的参数,这个weight是不是给了个初始值weights,那就在前面给出这个值:

# Computing weights…… 计算每个类别的权重,用于调整损失函数。
print('Computing weights...', end='\t')  # end='\t' 表示消息结束后将插入一个制表符(tab)而不是换行
samples_per_class = np.array(
    cfg.class_weights)  # 这个有点没懂,class_weights直接给了一组数,这个应该指的是指的是整个训练数据集中,每个类别/标签的点云个数。(注意:每个点都有一个标签)---------------

n_samples = torch.tensor(cfg.class_weights, dtype=torch.float, device=args.gpu)  # 把样本数(点云个数)转化为张量。
ratio_samples = n_samples / n_samples.sum()  # 计算每个类别样本数占总样本数的比例
weights = 1 / (ratio_samples + 0.02)  # 计算每个类别的权重。类别权重用于调整损失函数,以便模型更多地关注那些样本较少的类别。

print('Done.')
print('Weights:', weights)

 第四步 迭代训练

一般来说,我们直接进行for循环迭代训练就行,但是这里多了一个if。因为这是比较大的工程嘛,然后训练要比较长时间,你可能训练到一半因为某些原因停止了,所以这里是有一个 检查点 的概念的,就是每训练几个epoch或者batch我给它记录一下当前的状态(模型的参数呀,优化器,学习率……)这一段代码的大概意思就是如果你之前训练过有个状态,我就接着弄。后面接着弄的部分也要进行记录保存到日志里。

1.模型改成训练模式。(关于训练模式model.train()和评估模式model.eval()区别,下次有空,彻底搞搞清楚)

2.然后就是,遍历数据集,在一个epoch里 梯度清零,前馈,后馈,更新,算损失,精度。

3.完成一个epoch后,更新学习率,算该epoch的损失,精度。这里后面多了一个在验证集上评估精度。

4.开始结束时间。

5.结果写进日志

6.是否保存检查点(训练过程的很多东西,并不只是结果)

上面6步,就是一个epoch的内容,for一下就好了。

最后,main函数调用,前面提到的各种args要定义一下。就好了。

但是,这里没有存储最优模型的代码,后面的test.py用的检查点文件。(感觉可以改一下,但我不会)

2.3test.py

累了,就是把保存的训练好的模型数据导入进来,然后跑一遍test数据,对比标签,要算啥就算啥。

2.4其他文件

一些辅助工具,data.py里面有个main函数,我还没看。就看了train.py和test.py。

RandLA-Net是一种基于点云数据的深度学习模型,用于点云分割和场景理解。下面是使用PyTorch实现RandLA-Net的简单步骤: 1. 安装依赖库 在Python环境中安装以下库: - PyTorch - NumPy - Open3D - Scikit-learn 其中PyTorch是必须的,其余库是为了可视化和数据预处理。 2. 下载数据集 下载点云数据集,例如S3DIS数据集,该数据集包含了用于建筑物场景的点云数据。可以从官方网站下载数据集。 3. 数据预处理 使用Open3D库读取点云数据并进行预处理。具体来说,可以使用Open3D库将点云数据转换为numpy数组,然后将其分为小的块,以便在GPU上进行训练。 ```python import open3d as o3d import numpy as np import os def load_data(path): pcd = o3d.io.read_point_cloud(path) points = np.asarray(pcd.points) return points def process_data(points, block_size=3.0, stride=1.5): blocks = [] for x in range(0, points.shape[0], stride): for y in range(0, points.shape[1], stride): for z in range(0, points.shape[2], stride): block = points[x:x+block_size, y:y+block_size, z:z+block_size] if block.shape[0] == block_size and block.shape[1] == block_size and block.shape[2] == block_size: blocks.append(block) return np.asarray(blocks) # Example usage points = load_data("data/room1.pcd") blocks = process_data(points) ``` 这将生成大小为3x3x3的块,每个块之间的距离为1.5。 4. 构建模型 RandLA-Net是一个基于点云的分割模型,它使用了局部注意力机制和多层感知器(MLP)。这里给出一个简单的RandLA-Net模型的实现: ```python import torch import torch.nn as nn class RandLANet(nn.Module): def __init__(self, input_channels, num_classes): super(RandLANet, self).__init__() # TODO: Define the model architecture self.conv1 = nn.Conv1d(input_channels, 32, 1) self.conv2 = nn.Conv1d(32, 64, 1) self.conv3 = nn.Conv1d(64, 128, 1) self.conv4 = nn.Conv1d(128, 256, 1) self.conv5 = nn.Conv1d(256, 512, 1) self.mlp1 = nn.Sequential( nn.Linear(512, 256), nn.BatchNorm1d(256), nn.ReLU(), nn.Linear(256, 128), nn.BatchNorm1d(128), nn.ReLU(), nn.Linear(128, num_classes), nn.BatchNorm1d(num_classes) ) def forward(self, x): # TODO: Implement the forward pass x = self.conv1(x) x = self.conv2(x) x = self.conv3(x) x = self.conv4(x) x = self.conv5(x) x = torch.max(x, dim=-1)[0] x = self.mlp1(x) return x ``` 这个模型定义了5个卷积层和一个多层感知器(MLP)。在前向传递过程中,点云数据被送入卷积层,然后通过局部最大池化层进行处理。最后,通过MLP将数据转换为预测的类别。 5. 训练模型 在准备好数据和模型之后,可以使用PyTorch的内置函数训练模型。这里使用交叉熵损失函数和Adam优化器: ```python import torch.optim as optim device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # TODO: Initialize the model model = RandLANet(input_channels=3, num_classes=13).to(device) # TODO: Initialize the optimizer and the loss function optimizer = optim.Adam(model.parameters(), lr=0.001) loss_fn = nn.CrossEntropyLoss() # TODO: Train the model for epoch in range(num_epochs): running_loss = 0.0 for i, batch in enumerate(train_loader): # Move the batch to the GPU batch = batch.to(device) # Zero the gradients optimizer.zero_grad() # Forward pass outputs = model(batch) loss = loss_fn(outputs, batch.labels) # Backward pass and optimization loss.backward() optimizer.step() # Record the loss running_loss += loss.item() # Print the epoch and the loss print('Epoch [%d], Loss: %.4f' % (epoch+1, running_loss / len(train_loader))) ``` 这里使用Adam优化器和交叉熵损失函数进行训练。训练完成后,可以使用预测函数对新数据进行分类: ```python def predict(model, data): with torch.no_grad(): # Move the data to the GPU data = data.to(device) # Make predictions outputs = model(data) _, predicted = torch.max(outputs.data, 1) # Move the predictions back to CPU predicted = predicted.cpu().numpy() return predicted # Example usage data = load_data("data/room2.pcd") data = process_data(data) data = torch.from_numpy(data).float().permute(0, 2, 1) predicted = predict(model, data) ``` 这将返回点云数据的分类预测。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值