图神经网络:(图像分割)3D人物图像分割

这篇具有很好参考价值的文章主要介绍了图神经网络:(图像分割)3D人物图像分割。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

文章说明:
1)参考资料:PYG的文档。文档超链。斯坦福大学的机器学习课程。课程超链。(要挂梯子)。博客原文。原文超链。(要挂梯子)。原文理论参考文献。提取码8848。
2)我在百度网盘上传这篇文章的jupyter notebook以及预训练模型。提取码8848.
3)博主水平不高,如有错误,还望批评指正
一些建议:注重理论建议直接去看文献;注重实践建议直接去看代码。他的代码会有详细注释,但实际没啥用,如果不看原文参考文献。建议手敲一遍代码,会对理解很有帮助。变量名字取得很好,如果有图神经基础,不看文献也是可以。

前言1:硬件问题

如果电脑不是很好,并不建议自己训练。我的电脑不是很好,训练大概有20分钟。最后电脑特别的烫,感觉对电脑很不好。我的电脑配置如下(应该是看这个,对于硬件我不清楚)。直接下载预训练的模型就好。图神经网络:(图像分割)3D人物图像分割,图神经网络GNN,图神经网络GNN,pytorch,深度学习,图像分类,图像分割,3D点云

前言2:有关综述

对于一般图像分割以及图像分类任务,卷积神经网络取得巨大成功。但是卷积神经网络不能处理不规则的数据结构。我们希望推广卷积神经网络到不规则数据结构。卷积神经网络博主不很了解,不所以作过多评价。图神经网络为解决问题,应孕而生。我们使用3D点云进行演示。

数据描述

我们使用两个矩阵表示数据:十分简单,看图易懂。图片自源博客。我们需要一个矩阵存储n个点的位置。我们需要一个矩阵存储点间的边关系(3点确定一个平面,这就解释为什么是3个点了)。
图神经网络:(图像分割)3D人物图像分割,图神经网络GNN,图神经网络GNN,pytorch,深度学习,图像分类,图像分割,3D点云

数据下载

提取码8848

任务描述

正如标题:一个简单分类任务。我们需要对3D点云进行分类。头部点云,躯干点云,左臂点云,左手点云,右臂点云,右手点云,左大腿点云,左小腿点云,左脚点云,右大腿点云,右小腿点云,右脚点云。

代码演示

import torch
device='cuda' if torch.cuda.is_available() else 'cpu'

路径有关注意事项1:下载数据之后不要进行解压,放在一个文件之中就可以了。
路径有关注意事项2:复制文件地址需要进行修改,可能这跟操作系统有关但是我不清楚,我就只说我的。直接复制是这样"C:\Users\19216\Desktop\project\3DImage_Classification_And_Segmentation",我们需要更改所有"\“变为”/"。

root="C:/Users/19216/Desktop/project/3DImage_Classification_And_Segmentation"

以下定义数据变换。

from torch_geometric.transforms import BaseTransform
from torch_geometric.data import Data
#BaseTransform的构造十分简单,建议自己去看源码
class NormalizeUnitSphere(BaseTransform):
	#静态方法,不依赖类(加了这个应该就不用加self了)
    @staticmethod
    def _re_center(x):
        centroid=torch.mean(x,dim=0)
        return x-centroid
    @staticmethod
    def _re_scale_to_unit_length(x):
        max_dist=torch.max(torch.norm(x,dim=1))
        return x/max_dist
    #类的默认调用方法
    def __call__(self,data:Data):
        if data.x is not None:
            data.x=self._re_scale_to_unit_length(self._re_center(data.x))
        return data
    #就是打印类的名字
    def __repr__(self):
        return "{}()".format(self.__class__.__name__)
from torch_geometric.transforms import Compose,FaceToEdge
pre_transform=Compose([FaceToEdge(remove_faces=False),NormalizeUnitSphere()])

以下加载变换数据。

from pathlib import Path
import trimesh
def load_mesh(mesh_filename:Path):
    mesh=trimesh.load_mesh(mesh_filename,process=False)
    vertices=torch.from_numpy(mesh.vertices).to(torch.float)
    faces=torch.from_numpy(mesh.faces).t().to(torch.long).contiguous()
    return vertices,faces
from torch_geometric.data import InMemoryDataset,extract_zip
from functools import lru_cache
import numpy as np

关于这部分的代码,必须看这,看了你就知道了吧。这里代码逻辑是挺有意思的,由于篇幅原因读者自行研究。我来讲下逻辑,不一定正确哈。首先train_data申请调用SegmentationFaust。父类立马开始调用四个方法(如果没有直接跳过) raw_file_names(),processed_file_names(),download(),process()。具体到这里就只有processed_file_names()、process()。父类发现文件夹中没有processed_file_names()的对应文件,立即用process()处理数据生成processed_file_names()的对应文件。然后赋值[“training.pt”,“test.pt”]给self.processed_paths。最后子类开始运作读取数据并且赋值。所有数据在第一步处理好了。

class SegmentationFaust(InMemoryDataset):
    map_seg_label_to_id=dict(head=0,torso=1,left_arm=2,left_hand=3,
                             right_arm=4,right_hand=5,left_upper_leg=6,left_lower_leg=7,
                             left_foot=8,right_upper_leg=9,right_lower_leg=10,right_foot=11)           
    def __init__(self,root,train:bool=True,pre_transform=None):
        super().__init__(root,pre_transform)
        path=self.processed_paths[0] if train else self.processed_paths[1]
        self.data,self.slices=torch.load(path)
    #将方法转换为属性
    @property
    def processed_file_names(self)->list:
        return ["training.pt","test.pt"]
    @property
    #结果缓存,提高效率
    @lru_cache(maxsize=32)
    def _segmentation_labels(self):
        path_to_labels=Path(self.root)/"MPI-FAUST"/"segmentations.npz"
        seg_labels=np.load(str(path_to_labels))["segmentation_labels"]
        return torch.from_numpy(seg_labels).type(torch.int64)
    def _mesh_filenames(self):
        path_to_meshes=Path(self.root)/"MPI-FAUST"/"meshes"
        #正则匹配
        return path_to_meshes.glob("*.ply")
    def _unzip_dataset(self):
        path_to_zip=Path(self.root)/"MPI-FAUST.zip"
        extract_zip(str(path_to_zip),self.root,log=False)
    def process(self):
        self._unzip_dataset()
        data_list=[]
        for mesh_filename in sorted(self._mesh_filenames()):
            vertices, faces=load_mesh(mesh_filename)
            data=Data(x=vertices, face=faces)
            data.segmentation_labels=self._segmentation_labels
            if self.pre_transform is not None:
                data=self.pre_transform(data)
            data_list.append(data)
        torch.save(self.collate(data_list[:80]),self.processed_paths[0])
        torch.save(self.collate(data_list[80:]),self.processed_paths[1])
train_data=SegmentationFaust(root=root,pre_transform=pre_transform)
#输出:
#Processing...
#Done!
test_data=SegmentationFaust(root=root,train=False,pre_transform=pre_transform)
from torch_geometric.loader import DataLoader
train_loader=DataLoader(train_data,shuffle=True)
test_loader=DataLoader(test_data,shuffle=False)
from itertools import tee

这段代码特别抽象,读者自行理解研究(我的意思语法抽象不指代码逻辑)

def pairwise(iterable):
    a,b=tee(iterable)
    next(b,None)
    return zip(a,b)
import torch.nn as nn

这段代码同样抽象,读者自行理解研究(我的意思语法抽象不指代码逻辑)

def get_mlp_layers(channels:list,activation,output_activation=nn.Identity):
    layers=[]
    *intermediate_layer_definitions,final_layer_definition=pairwise(channels)
    for in_ch,out_ch in intermediate_layer_definitions:
        intermediate_layer=nn.Linear(in_ch,out_ch)
        layers+=[intermediate_layer,activation()]
    layers+=[nn.Linear(*final_layer_definition),output_activation()]
    return nn.Sequential(*layers)
from torch_geometric.nn import MessagePassing
def get_conv_layers(channels:list,conv:MessagePassing,conv_params:dict):
    conv_layers=[conv(in_ch,out_ch,**conv_params) for in_ch,out_ch in pairwise(channels)]
    return conv_layers
from torch_geometric.utils import add_self_loops,remove_self_loops
import torch.nn.functional as F

最后介绍参考论文,这里暂时放下不表
以下部分均为模型建立

class FeatureSteeredConvolution(MessagePassing):
    def __init__(self,in_channels:int,out_channels:int,num_heads:int,ensure_trans_invar:bool=True,bias:bool=True,with_self_loops:bool=True):
        super().__init__(aggr="mean")
        self.in_channels=in_channels;self.out_channels=out_channels;self.num_heads=num_heads;self.with_self_loops=with_self_loops
        self.linear=torch.nn.Linear(in_features=in_channels,out_features=out_channels*num_heads,bias=False)
        self.u=torch.nn.Linear(in_features=in_channels,out_features=num_heads,bias=False)
        self.c=torch.nn.Parameter(torch.Tensor(num_heads))
        if not ensure_trans_invar:
            self.v=torch.nn.Linear(in_features=in_channels,out_features=num_heads,bias=False)
        else:
            self.register_parameter("v",None)
        if bias:
            self.bias=torch.nn.Parameter(torch.Tensor(out_channels))
        else:
            self.register_parameter("bias",None)
        self.reset_parameters()
    def reset_parameters(self):
        torch.nn.init.uniform_(self.linear.weight)
        torch.nn.init.uniform_(self.u.weight)
        torch.nn.init.normal_(self.c,mean=0.0,std=0.1)
        if self.v is not None:
            torch.nn.init.uniform_(self.v.weight)
        if self.bias is not None:
            torch.nn.init.normal_(self.bias,mean=0.0,std=0.1)
    def forward(self,x,edge_index):
        if self.with_self_loops:
            edge_index,_=remove_self_loops(edge_index)
            edge_index,_=add_self_loops(edge_index=edge_index,num_nodes=x.shape[0])
        out=self.propagate(edge_index,x=x)
        return out if self.bias is None else out+self.bias
    def _compute_attention_weights(self,x_i,x_j):
        if x_j.shape[-1]!=self.in_channels:
            raise ValueError(
                f"Expected input features with {self.in_channels} channels."
                f"Instead received features with {x_j.shape[-1]} channels."
            )
        if self.v is None:
            attention_logits=self.u(x_i-x_j)+self.c
        else:
            attention_logits=self.u(x_i)+self.b(x_j)+self.c
        return F.softmax(attention_logits,dim=1)
    def message(self,x_i,x_j):
        attention_weights=self._compute_attention_weights(x_i,x_j)
        x_j=self.linear(x_j).view(-1,self.num_heads,self.out_channels)
        return (attention_weights.view(-1,self.num_heads,1)*x_j).sum(dim=1)
class GraphFeatureEncoder(torch.nn.Module):
    def __init__(self,in_features,conv_channels,num_heads,apply_batch_norm:int=True,ensure_trans_invar:bool=True,bias:bool=True,with_self_loops:bool=True):
        super().__init__()
        self.apply_batch_norm=apply_batch_norm;conv_params=dict(num_heads=num_heads,ensure_trans_invar=ensure_trans_invar,bias=bias,with_self_loops=with_self_loops)
        conv_layers=get_conv_layers(channels=[in_features]+conv_channels,conv=FeatureSteeredConvolution,conv_params=conv_params)
        self.conv_layers=nn.ModuleList(conv_layers)
        *first_conv_channels,final_conv_channel=conv_channels
        self.batch_layers=[None for _ in first_conv_channels]
        if apply_batch_norm:
            self.batch_layers=nn.ModuleList([nn.BatchNorm1d(channel) for channel in first_conv_channels])
    def forward(self,x,edge_index):
        *first_conv_layers,final_conv_layer=self.conv_layers
        for conv_layer,batch_layer in zip(first_conv_layers,self.batch_layers):
            x=conv_layer(x,edge_index)
            x=F.relu(x)
            if batch_layer is not None:
                x=batch_layer(x)
        return final_conv_layer(x,edge_index)
class MeshSeg(torch.nn.Module):
    def __init__(self,in_features,encoder_features,conv_channels,encoder_channels,decoder_channels,num_heads,num_classes,apply_batch_norm=True):
        super().__init__()
        self.input_encoder=get_mlp_layers(channels=[in_features]+encoder_channels,activation=nn.ReLU)
        self.gnn=GraphFeatureEncoder(in_features=encoder_features,conv_channels=conv_channels,num_heads=num_heads,apply_batch_norm=apply_batch_norm)
        *_,final_conv_channel=conv_channels
        self.final_projection=get_mlp_layers([final_conv_channel]+decoder_channels+[num_classes],activation=nn.ReLU)
    def forward(self,data):
        x,edge_index=data.x,data.edge_index
        x=self.input_encoder(x)
        x=self.gnn(x,edge_index)
        return self.final_projection(x)

设定参数

model_params=dict(in_features=3,encoder_features=16,conv_channels=[32,64,128,64],encoder_channels=[16],decoder_channels=[32],num_heads=12,num_classes=12,apply_batch_norm=True)
net=MeshSeg(**model_params).to(device)
best_test_acc=0.0;num_epochs=50;lr=0.001;optimizer=torch.optim.Adam(net.parameters(),lr=lr);loss_fn=torch.nn.CrossEntropyLoss()

开始训练

def train(net,train_data,optimizer,loss_fn,device):
    net.train()
    cumulative_loss=0.0
    for data in train_data:
        data=data.to(device)
        optimizer.zero_grad()
        out=net(data)
        loss=loss_fn(out,data.segmentation_labels.squeeze())
        loss.backward()
        cumulative_loss+=loss.item()
        optimizer.step()
    return cumulative_loss/len(train_data)
def accuracy(predictions,gt_seg_labels):
    predicted_seg_labels=predictions.argmax(dim=-1,keepdim=True)
    if predicted_seg_labels.shape!=gt_seg_labels.shape:
        raise ValueError("Expected Shapes to be equivalent")
    correct_assignments=(predicted_seg_labels==gt_seg_labels).sum()
    num_assignemnts=predicted_seg_labels.shape[0]
    return float(correct_assignments/num_assignemnts)
def evaluate_performance(dataset,net,device):
    prediction_accuracies=[]
    for data in dataset:
        data=data.to(device)
        predictions=net(data)
        prediction_accuracies.append(accuracy(predictions,data.segmentation_labels))
    return sum(prediction_accuracies)/len(prediction_accuracies)
@torch.no_grad()
def test(net,train_data,test_data,device):
    net.eval()
    train_acc=evaluate_performance(train_data,net,device)
    test_acc=evaluate_performance(test_data,net,device)
    return train_acc,test_acc
from tqdm import tqdm
with tqdm(range(num_epochs),unit="Epoch") as tepochs:
    for epoch in tepochs:
        train_loss=train(net,train_loader,optimizer,loss_fn,device)
        train_acc,test_acc=test(net,train_loader,test_loader,device)
        tepochs.set_postfix(train_loss=train_loss,train_accuracy=100*train_acc,test_accuracy=100*test_acc)
        if test_acc>best_test_acc:
            best_test_acc=test_acc
            torch.save(net.state_dict(),root+"/checkpoint_best_colab")

开始画图

def load_model(model_params,path_to_checkpoint,device):
    try:
        model=MeshSeg(**model_params)
        model.load_state_dict(torch.load(str(path_to_checkpoint)),strict=True)
        model.to(device)
        return model
    except RuntimeError as err_msg:
        raise ValueError(
            f"Given checkpoint {str(path_to_checkpoint)} could not be loaded. {err_msg}"
        )
def get_best_model(model_params,device):
    path_to_trained_model=Path(root+"/checkpoint_best_colab")
    trained_model=load_model(model_params,path_to_trained_model,device)
    return trained_model
net=get_best_model(model_params,device)
segmentation_colors=dict(head=torch.tensor([255,255,255],dtype=torch.int),torso=torch.tensor([255,255,128],dtype=torch.int),
                         left_arm=torch.tensor([255,255,0],dtype=torch.int),left_hand=torch.tensor([255,128,255],dtype=torch.int),
                         right_arm=torch.tensor([255,128,128],dtype=torch.int),right_hand=torch.tensor([255,128,0],dtype=torch.int),
                         left_upper_leg=torch.tensor([255,0,255],dtype=torch.int),left_lower_leg =torch.tensor([255,0,128],dtype=torch.int),
                         left_foot=torch.tensor([255,0,0],dtype=torch.int),right_upper_leg=torch.tensor([128,255,255],dtype=torch.int),
                         right_lower_leg=torch.tensor([128,255,128],dtype=torch.int),right_foot=torch.tensor([128,255,0],dtype=torch.int)
)
map_seg_id_to_color=dict((_value,segmentation_colors[_key]) for _key,_value in train_data.map_seg_label_to_id.items())
@torch.no_grad()
def visualize_prediction(net,data,device,map_seg_id_to_color):
    def _map_seg_label_to_color(seg_ids,map_seg_id_to_color):
        return torch.vstack([map_seg_id_to_color[int(seg_ids[idx])] for idx in range(seg_ids.shape[0])])
    data=data.to(device)
    predictions=net(data)
    predicted_seg_labels=predictions.argmax(dim=-1,keepdim=True)
    mesh_colors=_map_seg_label_to_color(predicted_seg_labels,map_seg_id_to_color)
    segmented_mesh=trimesh.base.Trimesh(vertices=data.x.cpu().numpy(),faces=data.face.t().cpu().numpy(),process=False)
    segmented_mesh.visual.vertex_colors=mesh_colors.cpu().numpy()
    return segmented_mesh
segmented_meshes=[]
mesh_ids=[0,1,2,3,4,5,6,7,8,9]
for idx,mesh_id in enumerate(mesh_ids):
    segmented_mesh=visualize_prediction(net,test_data[mesh_id],device,map_seg_id_to_color)
    segmented_mesh.vertices+=[idx*1.0,0.0,0.0]
    segmented_meshes.append(segmented_mesh)
scene=trimesh.scene.Scene(segmented_meshes)
scene.show()

图神经网络:(图像分割)3D人物图像分割,图神经网络GNN,图神经网络GNN,pytorch,深度学习,图像分类,图像分割,3D点云
论文部分不想写了。以后再来吧,那就这样吧。文章来源地址https://www.toymoban.com/news/detail-519956.html

到了这里,关于图神经网络:(图像分割)3D人物图像分割的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 初探图神经网络——GNN

    title: 图神经网络(GNN) date: tags: 随笔 知识点 categories: [学习笔记] 文章来源:https://distill.pub/2021/gnn-intro/ 前言:说一下为什么要写这篇文章,因为自己最近一直听说“图神经网络”,但是一直不了解这是什么,因此这次有机会对图神经网络有一个简单的认识了解好了,开始步入

    2024年02月08日
    浏览(41)
  • 【图神经网络】图神经网络(GNN)学习笔记:Graph Embedding

    Graph广泛存在于真实世界的多种场景中,即节点和边的集合。比如社交网络中人与人之间的联系,生物中蛋白质相互作用以及通信网络中的IP地址之间的通信等等。除此之外,我们最常见的一张图片、一个句子也可以抽象地看做是一个图模型的结构,图结构可以说是无处不在。

    2024年02月08日
    浏览(44)
  • 深度学习(36)—— 图神经网络GNN(1)

    这个系列的所有代码我都会放在git上,欢迎造访 GNN考虑的事当前的点和周围点之间的关系 邻接矩阵是对称的稀疏矩阵,表示图中各个点之间的关系 图神经网络的输入是每个节点的特征和邻接矩阵 文本数据可以用图的形式表示吗? 文本数据也可以表示图的形式,邻接矩阵表

    2024年02月13日
    浏览(39)
  • Matlab遗传神经网络在图像分割中的应用(附上完整源码+数据)

    图像分割是计算机视觉领域的一个重要研究方向,它在图像处理、目标识别等领域具有广泛的应用。遗传神经网络是一种结合了遗传算法和人工神经网络的智能优化方法,具有全局搜索和并行处理的优势。本文将介绍如何利用Matlab遗传神经网络工具箱进行图像分割,并分析其

    2024年02月12日
    浏览(44)
  • 当深度强化学习(DRL)遇见图神经网络(GNN)

           本篇文章是博主在人工智能等领域学习时,用于个人学习、研究或者欣赏使用,并基于博主对人工智能等领域的一些理解而记录的学习摘录和笔记,若有不当和侵权之处,指出后将会立即改正,还望谅解。文章分类在 学习摘录和笔记专栏 :         学习摘录和

    2024年02月15日
    浏览(60)
  • 人工智能(Pytorch)搭建模型1-卷积神经网络实现简单图像分类

    本文参加新星计划人工智能(Pytorch)赛道:https://bbs.csdn.net/topics/613989052 目录 一、Pytorch深度学习框架 二、 卷积神经网络 三、代码实战 内容: 一、Pytorch深度学习框架 PyTorch是一个开源的深度学习框架,它基于Torch进行了重新实现,主要支持GPU加速计算,同时也可以在CPU上运行

    2024年02月03日
    浏览(62)
  • 【Pytorch】计算机视觉项目——卷积神经网络CNN模型识别图像分类

    在上一篇笔记《【Pytorch】整体工作流程代码详解(新手入门)》中介绍了Pytorch的整体工作流程,本文继续说明如何使用Pytorch搭建卷积神经网络(CNN模型)来给图像分类。 其他相关文章: 深度学习入门笔记:总结了一些神经网络的基础概念。 TensorFlow专栏:《计算机视觉入门

    2024年02月05日
    浏览(53)
  • 卷积神经网络(CNN):基于PyTorch的遥感影像、无人机影像的地物分类、目标检测、语义分割和点云分类

    我国高分辨率对地观测系统重大专项已全面启动,高空间、高光谱、高时间分辨率和宽地面覆盖于一体的全球天空地一体化立体对地观测网逐步形成,将成为保障国家安全的基础性和战略性资源。随着小卫星星座的普及,对地观测已具备多次以上的全球覆盖能力,遥感影像也

    2024年02月04日
    浏览(53)
  • 基于图像合成和注意力的深度神经网络从计算机断层扫描灌注图像中自动分割缺血性脑卒中病变

    Medical Image Analysis 65 (2020) 101787 从计算机断层扫描灌注( CTP )图像中分割 缺血性脑卒中病变 对于急性护理病房中准确诊断脑卒中非常重要。然而,除了病变的 复杂外观 外,它还受到灌注参数图的 低图像对比度和分辨率 的挑战。为了解决这个问题,我们提出了一种基于 CT

    2024年02月02日
    浏览(35)
  • 深度学习图像分类实战——pytorch搭建卷积神经网络(AlexNet, LeNet, ResNet50)进行场景图像分类(详细)

    目录 1  一、实验过程 1.1  实验目的 1.2  实验简介 1.3  数据集的介绍 1.4  一、LeNet5网络模型 1.5  二、AlexNet网络模型 1.6  三、ResNet50(残差网络)网络模型  二、实验代码 导入实验所需要的库  参数配置 数据预处理 重新DataSet 加载数据转为DataLoader函数 可视化一批训练

    2024年02月05日
    浏览(63)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包