小土堆-pytorch

已于 2024-01-17 11:03:12 修改
阅读量1.1k 收藏 28
点赞数 26
分类专栏： 人工智能框架 文章标签： pytorch 人工智能 python
于 2023-12-15 23:20:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77824555/article/details/135022816
版权

文章目录

一、pytroch环境

conda

查看环境下包

pip list
conda list

创建环境

conda create -n name python=3.6

激活

conda activate name

退出

conda deavtivate

pytorch

查看gpu信息

nvidia-smi
// 保持driver version版本大于396.26

pytroch可以官网执行命令，也可以下载好包在执行
包要放在pkgs在执行conda install --use -local 包名字

测试安装成功

import torch
// gpu是否可以用
print(torch.cuda.is_available())

mac验证

import torch
print(torch.backends.mps.is_available())
print(torch.backends.mps.is_built())

编译器

pycharm

官网安装
配置环境选择env中的python.exe
使用console控制台可以查看变量信息

jupyter

配置环境可以在自己环境安装Jupyter

conda install nb_conda

打开

jupyter notebook

帮助函数

dir(包)
help(函数)

二、处理数据

加载数据

torchvision数据集

import torchvision
from torchvision import transforms
trans = transforms.Compose([
    transforms.ToTensor()
])
train_set = torchvision.datasets.CIFAR10(root="./dataset",train=True,transform=trans,download=True)
test_set = torchvision.datasets.CIFAR10(root="./dataset",train=False,transform=trans,download=True)
img,target = test_set[0]
print(img) 
print(target)
print(test_set.classes[target])

Dataset

提供一种方式获取数据及label并且编号
获取每一个数据及label
告知总共多少个数据
在这里插入图片描述

from torch.utils.data import Dataset
import cv2
from PIL import Image
import os
# help(Dataset)
class mydata(Dataset):
    def __init__(self,root_dir,label_dir):
        self.root_dir = root_dir
        self.label_dir = label_dir
        self.path = os.path.join(self.root_dir,self.label_dir)
        self.img_path = os.listdir(self.path)

    def __getitem__(self, idx):
        img_name = self.img_path[idx]
        img_item_path = os.path.join(self.root_dir,self.label_dir,self.img_path)
        img = Image.open(img_item_path)
        label = self.label_dir
        return img,label
    def __len__(self):
        return len(self.img_path)
    
ants_dataset = mydata(root_dir,label_dir)
img, label = ants_dataset[0]
img.show()
bees_dataset = mydata(root_dir,label_dir)
all_train = ants_dataset+bees_dataset //拼接数据集
len(all_train)

Dataloader

为后面网络提供不同数据形式

import torchvision
from torchvision import transforms
from torch.utils.data.dataloader import DataLoader
trans = transforms.Compose([
    transforms.ToTensor()
])
train_set = torchvision.datasets.CIFAR10(root="./dataset",train=True,transform=trans,download=True)
test_set = torchvision.datasets.CIFAR10(root="./dataset",train=False,transform=trans,download=True)
print(type(test_set))
loader = DataLoader(dataset=test_set,batch_size=64,shuffle=True,num_workers=0,drop_last=False)

img,target = test_set[0]
# torch.Size([3, 32, 32])
# 3
print(img.shape)
print(target)

for data in loader:
    imgs,targets =data
    # torch.Size([64, 3, 32, 32])
    # torch.Size([64])
    print(imgs.shape)
    print(targets.shape)
    break

tensorboard

tensorboard --logdir=logs

在这里插入图片描述

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter("logs")
# writer.add_image() 
for i in range(100):
    writer.add_scalar("y=2x",2*i,i)
writer.close()

在这里插入图片描述

from torch.utils.tensorboard import SummaryWriter
from PIL import Image
import numpy as np


img_path = 'path'
img_pil = Image.open(img_path)
img_array = np.array(img_pil) # （h。w。3）
print(type(img_array))

writer = SummaryWriter("logs")
# 需要输入tensor或者numpy型
# 通道（3，h，w）
# 1代表step
writer.add_image("test",img_array,1,dataformats='HWC') 

writer.close()

transforms

对图片进行变换

from torchvision import transforms
from PIL import Image
from tensorboardX import SummaryWriter
img_path ='path'
img = Image.open(img_path)
trans = transforms.ToTensor()
img_tensor = trans(img)

writer = SummaryWriter('logs')
writer.add_image("tensor_img",img_tensor)

from torchvision import transforms
from PIL import Image
img_path ='image/a.png'
img = Image.open(img_path)
trans = transforms.Compose([
    transforms.ToTensor(),
    # 归一化，标准差。。。(x-0.5)/0.5
    transforms.Normalize([0.5,0.5,0.5,0.5],[0.5,0.5,0.5,0.5]),
    transforms.Resize((512,512)),
    # 随机裁剪
    transforms.RandomCrop((100,30))
    ]
)

img_com = trans(img)
print(img_com) # tensor

trans = transforms.ToPILImage()
trans(img_com).show()

图片操作

opencv

import cv2
img_path ='path'
cv_img = cv2.imread(img_path)

PIL

from PIL import Image
img_path = '...'
img = Image.open(img_path)
img.size //图片大小
img.show()// 显示图片

三、网络搭建

nn.Module

from torch import nn 
import torch 
class mymodel(nn.Module):
    def __init__(self) :
        super(mymodel,self).__init__()

    def forward(self,x):
        y = x+1
        return y
    
a = mymodel()
x = torch.tensor([10,20,30])
print(a(x))

import torch 
import torch.nn.functional as F
input = torch.ones([5,5])
kernel = torch.randn([3,3])

input = torch.reshape(input,(1,1,5,5))
kernel = torch.reshape(kernel,(1,1,3,3))

output = F.conv2d(input,kernel,stride=1)
print(output)
# padding会在左右都填充一个
output = F.conv2d(input,kernel,stride=2,padding=1)
print(output)

import torch 
import torchvision
import torch.nn as nn 
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.nn import ReLU
from torch.nn import Flatten
from torch.nn import Linear
from torch.nn import Sigmoid
from torch.utils.data.dataloader import DataLoader
dataset = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader  = DataLoader(dataset,batch_size=64)

class mod(nn.Module):
    def __init__(self):
        super(mod,self).__init__()
        # 卷机
        self.conv1 = Conv2d(in_channels= 3,out_channels= 6,kernel_size= 3,stride=1,padding=0)
        # 最大池话，下采样,减少数据量减少计算量
        # ceil——model如果到边缘哟啊不要保留，true保留
        self.maxpool1 = MaxPool2d(kernel_size=3,ceil_mode=True)
        # inplace是否原地变化，默认false
        self.relu = ReLU(inplace=False)
        self.sigmoid = Sigmoid()
        self.flatten = Flatten()
        self.Linear = Linear(600,10)

    def forward(self,x):
        x=self.conv1(x)
        x = self.maxpool1(x)
        x = self.relu(x)
        x = self.sigmoid(x)
        x = self.flatten(x) 
        x = self.Linear(x)
        return x

modshi = mod()
print(modshi)

for data in dataloader:
    imgs,targers = data
    out = modshi(imgs)
    print(out.shape)
    break

# mod(
#   (conv1): Conv2d(3, 6, kernel_size=(3, 3), stride=(1, 1))
#   (maxpool1): MaxPool2d(kernel_size=3, stride=3, padding=0, dilation=1, ceil_mode=True)
#   (relu): ReLU()
#   (sigmoid): Sigmoid()
#   (flatten): Flatten(start_dim=1, end_dim=-1)
#   (Linear): Linear(in_features=600, out_features=10, bias=True)
# )
# torch.Size([64, 10])

import torch 
import torchvision
import torch.nn as nn 
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.nn import ReLU
from torch.nn import Flatten
from torch.nn import Linear
from torch.nn import Sigmoid
from torch.nn import Sequential
from torch.utils.data.dataloader import DataLoader
from tensorboardX import SummaryWriter
dataset = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader  = DataLoader(dataset,batch_size=64)

class mod(nn.Module):
    def __init__(self):
        super(mod,self).__init__()
        self.conv1 = Conv2d(3,32,5,stride=1,padding=2)
        self.max_pool2d = MaxPool2d(2)
        self.conv2 = Conv2d(32,32,5,padding=2)
        self.max_pool2d2 = MaxPool2d(2)
        self.conv3 = Conv2d(32,64,5,padding=2)
        self.max_pool2d3 = MaxPool2d(2)
        self.flatten = Flatten()
        self.Linear = Linear(1024,64)
        self.Linear2 = Linear(64,10)

        self.model1 = Sequential(
            Conv2d(3,32,5,stride=1,padding=2),
            MaxPool2d(2),
            Conv2d(32,32,5,padding=2),
            MaxPool2d(2),
            Conv2d(32,64,5,padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024,64),
            Linear(64,10),
        )

    def forward(self,x):
        # x=self.conv1(x)
        # x=self.max_pool2d(x)
        # x=self.conv2(x)
        # x=self.max_pool2d2(x)
        # x=self.conv3(x)
        # x=self.max_pool2d3(x)
        # x=self.flatten(x)
        # x=self.Linear(x)
        # x=self.Linear2(x)
        x = self.model1(x)

        return x

modshi = mod()
print(modshi)

x = torch.ones((64,3,32,32))
out = modshi(x)


for data in dataloader:
    imgs,targers = data
    out = modshi(imgs)
    print(out.shape)
    break
# 可视化网络
writer = SummaryWriter("logs")
writer.add_graph(modshi,x)
writer.close()

# mod(
#   (conv1): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#   (max_pool2d): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#   (conv2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#   (max_pool2d2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#   (conv3): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#   (max_pool2d3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#   (flatten): Flatten(start_dim=1, end_dim=-1)
#   (Linear): Linear(in_features=1024, out_features=64, bias=True)
#   (Linear2): Linear(in_features=64, out_features=10, bias=True)
#   (model1): Sequential(
#     (0): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#     (1): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (2): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#     (3): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (4): Conv2d(32, 64, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))
#     (5): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
#     (6): Flatten(start_dim=1, end_dim=-1)
#     (7): Linear(in_features=1024, out_features=64, bias=True)
#     (8): Linear(in_features=64, out_features=10, bias=True)
#   )
# )
# torch.Size([64, 10])

损失函数

import torch
from torch.nn import L1Loss
from torch.nn import MSELoss
from torch.nn import CrossEntropyLoss
x = torch.tensor([1,2,3],dtype=torch.float32)
y = torch.tensor([1,2,5],dtype=torch.float32)

x = torch.reshape(x,(1,1,1,3))
y = torch.reshape(y,(1,1,1,3))

loss = L1Loss(reduce='sum')
result = loss(x,y)
print(result)

loss = MSELoss()
result = loss(x,y)
print(result)

x = torch.tensor([0.1,0.2,0.3])
y = torch.tensor([1])
x = torch.reshape(x,(1,3))
loss = CrossEntropyLoss()
result = loss(x,y)
print(result)

优化器

import torch 
import torchvision
import torch.nn as nn 
from torch.nn import Conv2d
from torch.nn import MaxPool2d
from torch.nn import ReLU
from torch.nn import Flatten
from torch.nn import Linear
from torch.nn import Sigmoid
from torch.nn import Sequential
from torch.utils.data.dataloader import DataLoader
from torch.nn import CrossEntropyLoss
from torch.optim import SGD
dataset = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader  = DataLoader(dataset,batch_size=64)

class mod(nn.Module):
    def __init__(self):
        super(mod,self).__init__()
        self.model1 = Sequential(
            Conv2d(3,32,5,stride=1,padding=2),
            MaxPool2d(2),
            Conv2d(32,32,5,padding=2),
            MaxPool2d(2),
            Conv2d(32,64,5,padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024,64),
            Linear(64,10),
        )

    def forward(self,x):
        x = self.model1(x)

        return x

modshi = mod()
loss = CrossEntropyLoss()
optim = SGD(modshi.parameters(),lr=0.01)

for epoch in range(20):
    runing_loss = 0.0
    for data in dataloader:
        imgs,targers = data
        out = modshi(imgs)
        loss1 = loss(out,targers)
        optim.zero_grad()
        loss1.backward()
        optim.step()
        runing_loss = runing_loss+loss1
    print(runing_loss)

gpu的使用

fff = model.cuda()
loss_fn = loss.cuda()
imgs = imgs.cuda()
targets = targets.cuda()

device = torch.device("cuda")
model = model.to(device)
imgs = imgs.to(device)

现有模型使用

vgg16_true = torchvision.models.vgg16(pretrained=True)
vgg16_false = torchvision.models.vgg16(pretrained=False)

dataset = torchvision.datasets.CIFAR10("./dataset",train=False,transform=torchvision.transforms.ToTensor(),
                                       download=True)
dataloader  = DataLoader(dataset,batch_size=64)
# 在最后一层加先行层从1000-》10
vgg16_true.add_module('add',nn.Linear(1000,10))
# 修改vgg最后一层
vgg16_false.classifier[6] = nn.Linear(4096,10)

保存读取网络

import torch
import torchvision

vgg16 = torchvision.models.vgg16(pretrained=True)
# 保存1,模型结构和参数,需要模型定义的代码
torch.save(vgg16,'vgg16.pth')

# 加载1
model = torch.load('vgg16.pth')
print(model)

# 保存2，保存参数字典形式
torch.save(vgg16.state_dict(),"vgg.pth")
# 加载2
model = torchvision.models.vgg16()
model.load_state_dict(torch.load('vgg.pth'))

四、完整训练验证网络

# model.py
import torch
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear



class fff(nn.Module):
    def __init__(self):
        super(fff, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, stride=1, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(1024, 64),
            Linear(64, 10),
        )

    def forward(self, x):
        x = self.model1(x)

        return x

if __name__ == '__main__':
    model = fff()
    x = torch.ones(64,3,32,32)
    y = model(x)
    print(y.shape)

# main.py
import torch
from torch import nn
from torch.utils.data import DataLoader
import torchvision
from model import fff
from tensorboardX import SummaryWriter
train_data = torchvision.datasets.CIFAR10(root='dataset', train=True, transform=torchvision.transforms.ToTensor(),
                                          download=True)
test_data = torchvision.datasets.CIFAR10(root='dataset', train=False, transform=torchvision.transforms.ToTensor(),
                                         download=True)

print("训练数据集长度为{}".format(len(train_data)))
print("测试数据集长度为{}".format(len(test_data)))

train_dataloader = DataLoader(train_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)

model = fff()

loss = nn.CrossEntropyLoss()
learn = 1e-2
optim = torch.optim.SGD(model.parameters(),lr=learn)
# 记录训练次数
total_train_step = 0
# 记录测试次数
total_test_step = 0
#训练轮数
epoch = 10
writer = SummaryWriter("logs")

for i in range(epoch):
    model.train()
    print('-------------------------{}轮开始-------------------'.format(i))
    for data in train_dataloader:
        imgs,targets = data
        y = model(imgs)
        loss1 = loss(y, targets)
        optim.zero_grad()
        loss1.backward()
        optim.step()
        total_train_step+=1
        if total_train_step % 300 == 0:
            print("第{}次,损失为{}".format(total_train_step, loss1.item()))
            writer.add_scalar("train_loss",loss1.item(),total_train_step)
    model.eval()
    total_test_loss = 0
    total_accuracy = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs ,targets = data
            y = model(imgs)
            loss1 = loss(y,targets)
            total_test_loss +=loss1
            accuracy = (y.argmax(1)==targets).sum()
            total_accuracy+=accuracy
    print("整体测试集上loss{}".format(total_test_loss))
    print("整体测试集上accuracy{}".format(total_accuracy/len(test_data)))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", total_accuracy/len(test_data), total_test_step)
    total_test_step += 1

    torch.save(model,"cif{}.pth".format(i))
    print("save over")

writer.close()

# test.py
import torch
from torch import nn
from torch.nn import Sequential, Conv2d, MaxPool2d, Flatten, Linear
import torchvision
from PIL import Image

img_path = "image/下载.jpeg"
img = Image.open(img_path)
trans = torchvision.transforms.Compose([
    torchvision.transforms.Resize((32, 32)),
    torchvision.transforms.ToTensor()
])
img = trans(img)
img = torch.reshape(img, (1, 3, 32, 32))


class fff(nn.Module):
    def __init__(self):
        super(fff, self).__init__()
        self.model1 = Sequential(
            Conv2d(3, 32, 5, stride=1, padding=2),
            MaxPool2d(2),
            Conv2d(32, 32, 5, padding=2),
            MaxPool2d(2),
            Conv2d(32, 64, 5, padding=2),
            MaxPool2d(2),
            Flatten(),
            Linear(64*4*4, 64),
            Linear(64, 10),
        )

    def forward(self, x):
        x = self.model1(x)

        return x

device = torch.device("mps")
model = torch.load("./cif9.pth").to(device)
model.eval()
with torch.no_grad():
    img = img.to(device)
    y = model(img)
    y = y.argmax(1)
    print(y)
冯-诺依曼
关注
  • 26
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pytorch入门教程（小土堆
linyuxi_loretta的博客
11-16 782
pytorch入门教程、一些基础函数的概念（参考代码），主要是带着读了一遍pytorch官方文档、另外推荐一个网站 www.paperswithcode.com，感觉很厉害的样子。
【Pytorch入门】小土堆PyTorch入门教程完整学习笔记（详细笔记并附练习代码 ipynb文件）
几度热忱的博客
03-28 3063
【Pytorch入门】小土堆PyTorch入门教程完整学习笔记（详细笔记 文末附练习代码 ipynb文件）
PyTorch入门【小土堆】
Ashley_ly的博客
10-26 1445
pyTorch小土堆
小土堆pytorch深度学习记录
最新发布
weixin_45803006的博客
05-31 810
b站小土堆深度学习课程学习记录
pytorch小土堆
yfuyu的博客
03-12 832
小土堆 基础的卷积神经网络pytorch代码学习
PyTorch深度学习快速入门教程 - 【小土堆学习笔记】
做一只猫的博客
02-14 2210
博主本人技术力不高，这篇博客可能会因为个人水平问题出现一些错误，但作为小白，还是希望能写下一些碰到的坑，尽力帮到其他小白。
（小土堆）PyTorch深度学习
qq_42283621的博客
05-24 1344
土堆视频 文章目录前言Jupyter的使用ESC 命令模式双击 编辑模式dir和help使用[Pytorch中Tensor Variable Parameter以及求导运算](https://blog.csdn.net/qq_42283621/article/details/124921414)激活函数与Pytorch损失函数和Pytorch(重要)完整的训练套路TensorBoardTransformsDatasetDataLoaderModuleF.conv2d vs. nn.Conv2DSequent
Pytorch深度学习快速入门教程【小土堆Pytorch学习笔记】
qq_54012756的博客
09-28 1043
本文的所有笔记均基于b站小土堆pytorch教程，对于视频教程中的所有内容做出了笔记记录
Python-Pytorch入门学习笔记（小土堆视频）
02-20
Python pytorch学习笔记 ***from的是一个个的包（package)*** ***import 的是一个个的py文件(file.py)*** ***所使用的一般是文件中的类(.class)*** ***第一步实例化所使用的类,然后调用类中的方法（def)*** 包含...
机器学习 Pytorch 小土堆
02-02
小土堆学习笔记
深度学习 Pytorch 小土堆笔记
02-02
小土堆Pytorch笔记
Pytorch入门实战学习笔记
04-24
根据学习b站当中的pyTorch深度学习快速入门教程（绝对通俗易懂！）【小土堆】 所做的一些笔记和代码整合。附上学习视频链接https://www.bilibili.com/video/BV1hE411t7RN?spm_id_from=333.337.search-card.all.click
10分钟快速入门 PyTorch
01-16
PyTorch是使用GPU和CPU优化的深度学习张量库。10分钟快速入门 PyTorch，是一份简单、易学的中文教程，含开发环境和示例代码。10分钟快速入门 PyTorch (0) – 基础 10分钟快速入门 PyTorch (1) – 线性回归 10分钟...
PyTorch快速入门教程【小土堆】-神经网络-完整的模型训练套路
weixin_42182290的博客
05-16 2992
PyTorch快速入门教程【小土堆】-神经网络-完整的模型训练套路
pytorch学习(小土堆)
dushib的博客
03-01 3281
b站小土堆的pytorch教学视频，实在是太好了。不光教代码的语法功能，更重要的是教你看pytorch官网。 本文作为学习笔记，将小土堆提供的GPU训练代码进行详解分析，(因为这个案例基本上综合了小土堆前面讲过的所有内容)防止自己忘了。可以随时查看。 代码 import torch import torchvision from torch.utils.tensorboard import SummaryWriter # from model import * # 准备数据集 from torch
小土堆Pytorch快速入门-ch01
欢迎大家一起交流学习！
10-25 851
小土堆Pytorch学习笔记
PyTorch深度学习快速入门教程【小土堆】 学习笔记
竦貊的博客
05-27 8360
目录学习视频地址 —— B站1 pyTorch安装和配置已经测试，速度很慢，30kB/s已经测试，最有效的办法，速度最快,3MB/s2 python 编辑器的安装pyCharm 安装注意事项pyCharm 配置检测是否正常运行新环境中安装jupyterjupyter 使用指南3 为什么 返回 false4 pyhton 学习中的两个 法宝函数 学习视频地址 —— B站 PyTorch深度学习快速入门教程（绝对通俗易懂！）【小土堆】 1 pyTorch安装和配置 anaconda 安装路径：D:\anac
土堆pytorch教程学习笔记 （所有代码笔记超详细完整版）
tlytjj的博客
11-16 911
目录一. read_data二. dataloader三. transforms四。五. conv六.conv2d七.loss八.linear九.loss-network十.pool十一.RELU十二.sqc十三.test-tensorboard十四.optim十五.model十六.test-modle十七.model-pretained十八.model-save十九.model-load二十.train二十一.train-gpu1。
小土堆-pytorch框架-P10-12
诚
08-06 95
学习哔站小土堆pytorch框架-笔记
mvsnet-pytorch版 源码 mvsnet-pytorch-master运行结果
11-17
mvsnet-pytorch是一个基于PyTorch框架实现的多视角立体匹配网络。通过该网络，可以对多个视角的输入图像进行立体匹配，从而得到深度图和三维点云数据。mvsnet-pytorch-master是对该网络的源代码进行了整理和更新，使其更加易于使用和理解。 当我们运行mvsnet-pytorch-master时，首先需要准备输入数据，包括多个视角的图像和相机参数。然后，我们可以使用训练好的模型进行深度估计和三维重构。运行结果将得到深度图和点云数据，可以用来表示视景中物体的三维形状和位置信息。 在实际运行中，mvsnet-pytorch-master的源码可以让我们更好地理解多视角立体匹配网络的原理和实现细节，也可以帮助我们进行模型的调试和改进。通过观察运行结果，我们可以评估模型的性能和准确度，同时也可以对输入数据和参数进行优化，以获得更好的深度估计和重构效果。 总的来说，mvsnet-pytorch-master的源码运行结果可以帮助我们更好地理解和应用多视角立体匹配网络，同时也可以为我们的相关研究和应用提供有力的支持。通过对该源码的运行和分析，我们可以更好地掌握立体匹配技术，为视觉领域的发展做出更大的贡献。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值