imtoken中文版手机下载|ixi

首页
ixi

imtoken中文版手机下载|ixi

作者： imtoken中文版手机下载

2024-03-07 19:23:46

IXI MEGA 官网 - 新加坡IXI MEGA Pte Ltd公司研发设计 | 音频接口

首页

产品

M2 Plus II

M4 Plus

M6 Plus

M8 Plus II

历史产品

配件

下载

新闻动态

帮助

技术教程

售后申请

品牌介绍

中文

首页

产品

M2 Plus II

M4 Plus

M6 Plus

M8 Plus II

历史产品

配件

下载

新闻动态

帮助

技术教程

售后申请

品牌介绍

返回顶部

GitHub - junyuchen245/Preprocessed_IXI_Dataset: Preprocessed IXI brain MRI dataset with subcortical segmentation

Toggle navigation

Product

Actions

Automate any workflow

Packages

Host and manage packages

Security

Find and fix vulnerabilities

Codespaces

Instant dev environments

Copilot

Write better code with AI

Code review

Manage code changes

Issues

Plan and track work

Discussions

Collaborate outside of code

Explore

All features

Documentation

GitHub Skills

Blog

Solutions

For

Enterprise

Teams

Startups

Education

By Solution

CI/CD & Automation

DevOps

DevSecOps

Resources

Learning Pathways

White papers, Ebooks, Webinars

Customer Stories

Partners

Open Source

GitHub Sponsors

Fund open source developers

The ReadME Project

GitHub community articles

Repositories

Topics

Trending

Collections

Pricing

Search or jump to...

Search code, repositories, users, issues, pull requests...

Clear

Search syntax tips

Provide feedback

We read every piece of feedback, and take your input very seriously.

Include my email address so I can be contacted

Cancel

Submit feedback

Saved searches

Use saved searches to filter your results more quickly

Name

Query

To see all available qualifiers, see our documentation.

Cancel

Create saved search

You signed in with another tab or window. Reload to refresh your session.

You signed out in another tab or window. Reload to refresh your session.

You switched accounts on another tab or window. Reload to refresh your session.

Dismiss alert

junyuchen245

Preprocessed_IXI_Dataset

Public

Notifications

Fork

Star

Preprocessed IXI brain MRI dataset with subcortical segmentation

License

View license

stars

fork

Branches

IXI 脑部图像数据集 / 数据集 / 超神经

脑部图像数据集 / 数据集 / 超神经超神经资讯教程数据集百科全站搜索TVM 中文关于IXI 脑部图像数据集日期2 年前大小27.39 GB机构发布地址brain-development.org许可协议其他标签医学图像分析图像分析图像转换分类医学诊断图像生成数据集下载aria2c 下载磁力链下载帮助

IXI 全称 IXI Brain Development Dataset，是。该数据集收集了 600 个正常健康受试者的 MRI 影像数据，每个人都同时有 T1 、 T2 、 PD 加权、 MRA 和弥散加权 5 种扫描方式。数据来自伦敦的 3 家医院。

IXI.torrent做种 1下载中 0已完成 13总下载 31IXI/README.md1000 字节README.txt1.95 KBdata/DTI images/IXI-DTI.tar3.98 GBbvals.txt3.98 GBbvecs.txt3.98 GBIXI-MRA.tar15.51 GBIXI-PD.tar19.3 GBIXI-T1.tar23.8 GBIXI-T2.tar27.39 GBIXI.xls27.39 GBHyper Newsletters订阅我们的最新资讯我们会在北京时间每周一的上午九点向您的邮箱投递本周内的最新更新订阅 MailChimp提供邮件发送服务学习、理解、实践，与社区一起构建人工智能的未来关于关于我们数据集帮助产品资讯教程数据集百科链接TVM 中文Apache TVMOpenBayes© Hyper.AI 超神经津ICP备17010941号-1京公网安备110105020388

实践教程｜使用Pytorch对MRI脑扫描的图像进行分割 - 知乎

实践教程｜使用Pytorch对MRI脑扫描的图像进行分割 - 知乎首发于极市平台切换模式写文章登录/注册实践教程｜使用Pytorch对MRI脑扫描的图像进行分割极市平台已认证账号作者丨Ines del Val来源丨DeepHub IMBA图像分割是医学图像分析中最重要的任务之一，在许多临床应用中往往是第一步也是最关键的一步。在脑MRI分析中，图像分割通常用于测量和可视化解剖结构，分析大脑变化，描绘病理区域以及手术计划和图像引导干预，分割是大多数形态学分析的先决条件。本文我们将介绍如何使用QuickNAT对人脑的图像进行分割。使用MONAI, PyTorch和用于数据可视化和计算的常见Python库，如NumPy, TorchIO和matplotlib。本文将主要设计以下几个方面：设置数据集和探索数据处理和准备数据集适当的模型训练创建一个训练循环评估模型并分析结果完整的代码会在本文最后提供。设置数据目录使用MONAI的第一步是设置MONAI_DATA_DIRECTORY环境变量指定目录，如果未指定将使用临时目录。 directory \= os.environ.get$"MONAI\_DATA\_DIRECTORY"$

root\_dir \= tempfile.mkdtemp if directory is None else directory

print$root\_dir$

设置数据集将CNN模型扩展到大脑分割的主要挑战之一是人工注释的训练数据的有限性。作者引入了一种新的训练策略，利用没有手动标签的大型数据集和有手动标签的小型数据集。首先，使用现有的软件工具(例如FreeSurfer)从大型未标记数据集中获得自动生成的分割，然后使用这些工具对网络进行预训练。在第二步中，使用更小的手动注释数据[2]对网络进行微调。IXI数据集由581个健康受试者的未标记MRI T1扫描组成。这些数据是从伦敦3家不同的医院收集来的。使用该数据集的主要缺点是标签不是公开可用的，因此为了遵循与研究论文中相同的方法，本文将使用FreeSurfer为这些MRI T1扫描生成分割。FreeSurfer是一个用于分析和可视化结构的软件包。下载和安装说明可以在这里找到。可以直接使用了“recon-all”命令来执行所有皮层重建过程。尽管FreeSurfer是一个非常有用的工具，可以利用大量未标记的数据，并以监督的方式训练网络，但是扫描生成这些标签需要长达5个小时，所以我们这里直接使用OASIS数据集来训练模型，OASIS数据集是一个较小的数据集，具有公开可用的手动注释。OASIS是一个向科学界免费提供大脑神经成像数据集的项目。OASIS-1是由39个受试者的横断面组成的数据集，获取方式如下： resource \= "https://download.nrg.wustl.edu/data/oasis\_cross-sectional\_disc1.tar.gz"

md5 \= "c83e216ef8654a7cc9e2a30a4cdbe0cc"

compressed\_file \= os.path.join$root\_dir, "oasis\_cross-sectional\_disc1.tar.gz"$

data\_dir \= os.path.join$root\_dir, "Oasis\_Data"$

if not os.path.exists$data\_dir$:

download\_and\_extract$resource, compressed\_file, data\_dir, md5$

数据探索如果你打开' oasis_crosssectional_disc1 .tar.gz '，你会发现每个主题都有不同的文件夹。例如，对于主题OAS1_0001_MR1，是这样的:镜像数据文件路径:disc1\OAS1_0001_MR1\PROCESSED\MPRAGE\T88_111\ oas1_0001_mr1_mpr_n4_anon_111_t88_masked_ggc .img标签文件：disc1\OAS1_0001_MR1\FSL_SEG\OAS1_0001_MR1_mpr_n4_anon_111_t88_masked_gfc_fseg.img数据加载和预处理下载数据集并将其提取到临时目录后，需要对其进行重构，我们希望我们的目录看起来像这样:所以需要按照下面的步骤加载数据:将img文件转换为nii文件并保存到新文件夹中：创建两个新文件夹。Oasis_Data_Processed包括每个受试者的处理过的MRI T1扫描，Oasis_Labels_Processed包括相应的标签。 new\_path\_data\= root\_dir + '/Oasis\_Data\_Processed/'

if not os.path.exists$new\_path\_data$:

os.makedirs$new\_path\_data$

new\_path\_labels\= root\_dir + '/Oasis\_Labels\_Processed/'

if not os.path.exists$new\_path\_labels$:

os.makedirs$new\_path\_labels$

然后就是对其进行操作： for i in \[x for x in range$1, 43$ if x \!= 8 and x \!= 24 and x \!= 36\]:

if i \< 7 or i \== 9:

filename \= root\_dir + '/Oasis\_Data/disc1/OAS1\_000'+ str$i$ + '\_MR1/PROCESSED/MPRAGE/T88\_111/OAS1\_000' + str$i$ + '\_MR1\_mpr\_n4\_anon\_111\_t88\_masked\_gfc.img'

elif i \== 7:

filename \= root\_dir + '/Oasis\_Data/disc1/OAS1\_000'+ str$i$ + '\_MR1/PROCESSED/MPRAGE/T88\_111/OAS1\_000' + str$i$ + '\_MR1\_mpr\_n3\_anon\_111\_t88\_masked\_gfc.img'

elif i\==15 or i\==16 or i\==20 or i\==24 or i\==26 or i\==34 or i\==38 or i\==39:

filename \= root\_dir + '/Oasis\_Data/disc1/OAS1\_00'+ str$i$ + '\_MR1/PROCESSED/MPRAGE/T88\_111/OAS1\_00' + str$i$ + '\_MR1\_mpr\_n3\_anon\_111\_t88\_masked\_gfc.img'

else:

filename \= root\_dir + '/Oasis\_Data/disc1/OAS1\_00'+ str$i$ + '\_MR1/PROCESSED/MPRAGE/T88\_111/OAS1\_00' + str$i$ + '\_MR1\_mpr\_n4\_anon\_111\_t88\_masked\_gfc.img'

img \= nib.load$filename$

nib.save$img, filename.replace\('.img', '.nii'$\)

i \= i+1

具体代码就不再粘贴了，有兴趣的看看最后的完整代码。下一步就是读取图像和标签文件名 image\_files \= sorted$glob\(os.path.join\(root\_dir + '/Oasis\_Data\_Processed', '\*.nii'$\)\)

label\_files \= sorted$glob\(os.path.join\(root\_dir + '/Oasis\_Labels\_Processed', '\*.nii'$\)\)

files \= \[\{'image': image\_name, 'label': label\_name\} for image\_name, label\_name in zip$image\_files, label\_files$\]

为了可视化带有相应标签的图像，可以使用TorchIO，这是一个Python库，用于深度学习中多维医学图像的加载、预处理、增强和采样。 image\_filename \= root\_dir + '/Oasis\_Data\_Processed/OAS1\_0001\_MR1\_mpr\_n4\_anon\_111\_t88\_masked\_gfc.nii'

label\_filename \= root\_dir + '/Oasis\_Labels\_Processed/OAS1\_0001\_MR1\_mpr\_n4\_anon\_111\_t88\_masked\_gfc\_fseg.nii'

subject \= torchio.Subject$image\=torchio.ScalarImage\(image\_filename$, label\=torchio.LabelMap$label\_filename$\)

subject.plot

下面就是将数据分成3部分——训练、验证和测试。将数据分成三个不同的类别的目的是建立一个可靠的机器学习模型，避免过拟合。我们将整个数据集分成三个部分:Train: 80\%，Validation: 10\%，Test: 10\%

train\_inds, val\_inds, test\_inds \= partition\_dataset$data \= np.arange\(len\(files$\), ratios \= \[8, 1, 1\], shuffle \= True\)

train \= \[files\[i\] for i in sorted$train\_inds$\]

val \= \[files\[i\] for i in sorted$val\_inds$\]

test \= \[files\[i\] for i in sorted$test\_inds$\]

print$f"Training count: \{len\(train$\}, Validation count: \{len$val$\}, Test count: \{len$test$\}"\)

因为模型需要的是二维切片，所以将每个切片保存在不同的文件夹中，如下图所示。这两个代码单元将训练集的每个MRI体积的切片保存为“.png”格式。 Save coronal slices for training images

dir \= root\_dir + '/TrainData'

os.makedirs$os.path.join\(dir, "Coronal"$\)

path \= root\_dir + '/TrainData/Coronal/'

for file in sorted$glob\(os.path.join\(root\_dir + '/TrainData', '\*.nii'$\)\):

image\=torchio.ScalarImage$file$

data \= image.data

filename \= os.path.basename$file$

filename \= os.path.splitext$filename$

for i in range$0, 208$:

slice \= data\[0, :, i\]

array \= slice.numpy

data\_dir \= root\_dir + '/TrainData/Coronal/' + filename\[0\] + '\_slice' + str$i$ + '.png'

plt.imsave$fname \= data\_dir, arr \= array, format \= 'png', cmap \= plt.cm.gray$

同理，下面是保存标签： dir \= root\_dir + '/TrainLabels'

os.makedirs$os.path.join\(dir, "Coronal"$\)

path \= root\_dir + '/TrainLabels/Coronal/'

for file in sorted$glob\(os.path.join\(root\_dir + '/TrainLabels', '\*.nii'$\)\):

label \= torchio.LabelMap$file$

data \= label.data

filename \= os.path.basename$file$

filename \= os.path.splitext$filename$

for i in range$0, 208$:

slice \= data\[0, :, i\]

array \= slice.numpy

data\_dir \= root\_dir + '/TrainLabels/Coronal/' + filename\[0\] + '\_slice' + str$i$ + '.png'

plt.imsave$fname \= data\_dir, arr \= array, format \= 'png'$

为训练和验证定义图像的变换处理在本例中，我们将使用Dictionary Transforms，其中数据是Python字典。 train\_images\_coronal \= \[\]

for file in sorted$glob\(os.path.join\(root\_dir + '/TrainData/Coronal', '\*.png'$\)\):

train\_images\_coronal.append$file$

train\_images\_coronal \= natsort.natsorted$train\_images\_coronal$

train\_labels\_coronal \= \[\]

for file in sorted$glob\(os.path.join\(root\_dir + '/TrainLabels/Coronal', '\*.png'$\)\):

train\_labels\_coronal.append$file$

train\_labels\_coronal\= natsort.natsorted$train\_labels\_coronal$

val\_images\_coronal \= \[\]

for file in sorted$glob\(os.path.join\(root\_dir + '/ValData/Coronal', '\*.png'$\)\):

val\_images\_coronal.append$file$

val\_images\_coronal \= natsort.natsorted$val\_images\_coronal$

val\_labels\_coronal \= \[\]

for file in sorted$glob\(os.path.join\(root\_dir + '/ValLabels/Coronal', '\*.png'$\)\):

val\_labels\_coronal.append$file$

val\_labels\_coronal \= natsort.natsorted$val\_labels\_coronal$

train\_files\_coronal \= \[\{'image': image\_name, 'label': label\_name\} for image\_name, label\_name in zip$train\_images\_coronal, train\_labels\_coronal$\]

val\_files\_coronal \= \[\{'image': image\_name, 'label': label\_name\} for image\_name, label\_name in zip$val\_images\_coronal, val\_labels\_coronal$\]

现在我们将应用以下变换:LoadImaged:加载图像数据和元数据。我们使用' PILReader '来加载图像和标签文件。ensure_channel_first设置为True，将图像数组形状转换为通道优先。Rotate90d:我们将图像和标签旋转90度，因为当我们下载它们时，它们方向是不正确的。ToTensord:将输入的图像和标签转换为张量。NormalizeIntensityd:对输入进行规范化。 train\_transforms \= Compose\(

LoadImaged$keys \= \['image', 'label'\], reader\=PILReader\(converter\=lambda image: image.convert\("L"$\), ensure\_channel\_first \= True\),

Rotate90d$keys \= \['image', 'label'\], k \= 2$,

ToTensord$keys \= \['image', 'label'\]$,

NormalizeIntensityd$keys \= \['image'\]$

val\_transforms \= Compose\(

LoadImaged$keys \= \['image', 'label'\], reader\=PILReader\(converter\=lambda image: image.convert\("L"$\), ensure\_channel\_first \= True\),

Rotate90d$keys \= \['image', 'label'\], k \= 2$,

ToTensord$keys \= \['image', 'label'\]$,

NormalizeIntensityd$keys \= \['image'\]$

MaskColorMap将我们定义了一个新的转换，将相应的像素值以一种格式映射为多个标签。这种转换在语义分割中是必不可少的，因为我们必须为每个可能的类别提供二元特征。One-Hot Encoding将对应于原始类别的每个样本的特征赋值为1。因为OASIS-1数据集只有3个大脑结构标签，对于更详细的分割，理想的情况是像他们在研究论文中那样对28个皮质结构进行注释。在OASIS-1下载说明中，可以找到使用FreeSurfer获得的更多大脑结构的标签。所以本文将分割更多的神经解剖结构。我们要将模型的参数num_classes修改为相应的标签数量，以便模型的输出是具有N个通道的特征映射，等于num_classes。为了简化本教程，我们将使用以下标签，比OASIS-1但是要比FreeSurfer的少：Label 0: BackgroundLabel 1: LeftCerebralExteriorLabel 2: LeftWhiteMatterLabel 3: LeftCerebralCortex所以MaskColorMap的代码如下： class MaskColorMap$Enum$:

Background = $30$

LeftCerebralExterior = $91$

LeftWhiteMatter = $137$

LeftCerebralCortex = $215$

数据集和数据加载数据集和数据加载器从存储中提取数据，并将其分批发送给训练循环。这里我们使用monai.data.Dataset加载之前定义的训练和验证字典，并对输入数据应用相应的转换。dataloader用于将数据集加载到内存中。我们将为训练和验证以及每个视图定义一个数据集和数据加载器。为了方便演示，我们使用通过使用torch.utils.data.Subset，在指定的索引处创建一个子集，只是用部分数据训练加快演示速度。 train\_dataset\_coronal \= Dataset$data\=train\_files\_coronal, transform \= train\_transforms$

train\_loader\_coronal \= DataLoader$train\_dataset\_coronal, batch\_size \= 1, shuffle \= True$

val\_dataset\_coronal \= Dataset$data \= val\_files\_coronal, transform \= val\_transforms$

val\_loader\_coronal \= DataLoader$val\_dataset\_coronal, batch\_size \= 1, shuffle \= False$

\# We will use a subset of the dataset

subset\_train \= list$range\(90, len\(train\_dataset\_coronal$, 120\)\)

train\_dataset\_coronal\_subset \= torch.utils.data.Subset$train\_dataset\_coronal, subset\_train$

train\_loader\_coronal\_subset \= DataLoader$train\_dataset\_coronal\_subset, batch\_size \= 1, shuffle \= True$

subset\_val \= list$range\(90, len\(val\_dataset\_coronal$, 50\)\)

val\_dataset\_coronal\_subset \= torch.utils.data.Subset$val\_dataset\_coronal, subset\_val$

val\_loader\_coronal\_subset \= DataLoader$val\_dataset\_coronal\_subset, batch\_size \= 1, shuffle \= False$

定义模型给定一组MRI脑扫描I = {I1，…In}及其对应的分割S = {S1，…Sn}，我们想要学习一个函数fseg: I -> S。我们将这个函数表示为F-CNN模型，称为QuickNAT：QuickNAT由三个二维f - cnn组成，分别在coronal, axial, sagittal视图上操作，然后通过聚合步骤推断最终的分割结果，该分割结果由三个网络的概率图组合而成。每个F-CNN都有一个编码器/解码器架构，其中有4个编码器和4个解码器，并由瓶颈层分隔。最后一层是带有softmax的分类器块。该架构还包括每个编码器/解码器块内的残差链接。class QuickNat$nn.Module$:

"""

A PyTorch implementation of QuickNAT

"""

def \_\_init\_\_$self, params$:

"""

:param params: \{'num\_channels':1,

'num\_filters':64,

'kernel\_h':5,

'kernel\_w':5,

'stride\_conv':1,

'pool':2,

'stride\_pool':2,

'num\_classes':28

'se\_block': False,

'drop\_out':0.2\}

"""

super$QuickNat, self$.\_\_init\_\_

\# from monai.networks.blocks import squeeze\_and\_excitation as se

\# self.cSE = ChannelSELayer$num\_channels, reduction\_ratio$

\# self.encode1 = sm.EncoderBlock$params, se\_block\_type=se.SELayer.CSSE$

\# params\["num\_channels"\] = params\["num\_filters"\]

\# self.encode2 = sm.EncoderBlock$params, se\_block\_type=se.SELayer.CSSE$

\# self.encode3 = sm.EncoderBlock$params, se\_block\_type=se.SELayer.CSSE$

\# self.encode4 = sm.EncoderBlock$params, se\_block\_type=se.SELayer.CSSE$

\# self.bottleneck = sm.DenseBlock$params, se\_block\_type=se.SELayer.CSSE$

\# params\["num\_channels"\] = params\["num\_filters"\] \* 2

\# self.decode1 = sm.DecoderBlock$params, se\_block\_type=se.SELayer.CSSE$

\# self.decode2 = sm.DecoderBlock$params, se\_block\_type=se.SELayer.CSSE$

\# self.decode3 = sm.DecoderBlock$params, se\_block\_type=se.SELayer.CSSE$

\# self.decode4 = sm.DecoderBlock$params, se\_block\_type=se.SELayer.CSSE$

\# self.encode1 = EncoderBlock$params, se\_block\_type=se.ChannelSELayer$

self.encode1 \= EncoderBlock$params, se\_block\_type\=se.SELayer.CSSE$

params\["num\_channels"\] \= params\["num\_filters"\]

self.encode2 \= EncoderBlock$params, se\_block\_type\=se.SELayer.CSSE$

self.encode3 \= EncoderBlock$params, se\_block\_type\=se.SELayer.CSSE$

self.encode4 \= EncoderBlock$params, se\_block\_type\=se.SELayer.CSSE$

self.bottleneck \= DenseBlock$params, se\_block\_type\=se.SELayer.CSSE$

params\["num\_channels"\] \= params\["num\_filters"\] \* 2

self.decode1 \= DecoderBlock$params, se\_block\_type\=se.SELayer.CSSE$

self.decode2 \= DecoderBlock$params, se\_block\_type\=se.SELayer.CSSE$

self.decode3 \= DecoderBlock$params, se\_block\_type\=se.SELayer.CSSE$

self.decode4 \= DecoderBlock$params, se\_block\_type\=se.SELayer.CSSE$

params\["num\_channels"\] \= params\["num\_filters"\]

self.classifier \= ClassifierBlock$params$

def forward$self, input$:

"""

:param input: X

:return: probabiliy map

"""

e1, out1, ind1 \= self.encode1.forward$input$

e2, out2, ind2 \= self.encode2.forward$e1$

e3, out3, ind3 \= self.encode3.forward$e2$

e4, out4, ind4 \= self.encode4.forward$e3$

bn \= self.bottleneck.forward$e4$

d4 \= self.decode4.forward$bn, out4, ind4$

d3 \= self.decode1.forward$d4, out3, ind3$

d2 \= self.decode2.forward$d3, out2, ind2$

d1 \= self.decode3.forward$d2, out1, ind1$

prob \= self.classifier.forward$d1$

return prob

def enable\_test\_dropout$self$:

"""

Enables test time drop out for uncertainity

:return:

"""

attr\_dict \= self.\_\_dict\_\_\["\_modules"\]

for i in range$1, 5$:

encode\_block, decode\_block \= \(

attr\_dict\["encode" + str$i$\],

attr\_dict\["decode" + str$i$\],

encode\_block.drop\_out \= encode\_block.drop\_out.apply$nn.Module.train$

decode\_block.drop\_out \= decode\_block.drop\_out.apply$nn.Module.train$

\@property

def is\_cuda$self$:

"""

Check if model parameters are allocated on the GPU.

"""

return next$self.parameters\($\).is\_cuda

def save$self, path$:

"""

Save model with its parameters to the given path. Conventionally the

path should end with '\*.model'.

Inputs:

- path: path string

"""

print$"Saving model... \%s" \% path$

torch.save$self.state\_dict\($, path\)

def predict$self, X, device\=0, enable\_dropout\=False$:

"""

Predicts the output after the model is trained.

Inputs:

- X: Volume to be predicted

"""

self.eval

print$"tensor size before transformation", X.shape$

if type$X$ is np.ndarray:

\# X = torch.tensor$X, requires\_grad=False$.type$torch.FloatTensor$

X \= \(

torch.tensor$X, requires\_grad\=False$

.type$torch.FloatTensor$

.cuda$device, non\_blocking\=True$

elif type$X$ is torch.Tensor and not X.is\_cuda:

X \= X.type$torch.FloatTensor$.cuda$device, non\_blocking\=True$

print$"tensor size ", X.shape$

if enable\_dropout:

self.enable\_test\_dropout

with torch.no\_grad:

out \= self.forward$X$

max\_val, idx \= torch.max$out, 1$

idx \= idx.data.cpu.numpy

prediction \= np.squeeze$idx$

print$"prediction shape", prediction.shape$

del X, out, idx, max\_val

return prediction

损失函数神经网络的训练需要一个损失函数来计算模型误差。训练的目标是最小化预测输出和目标输出之间的损失。我们的模型使用Dice Loss 和Weighted Logistic Loss的联合损失函数进行优化，其中权重补偿数据中的高类不平衡，并鼓励正确分割解剖边界。优化器优化算法允许我们继续更新模型的参数并最小化损失函数的值，我们设置了以下的超参数：学习率:初始设置为0.1,10次后降低1阶。这可以通过学习率调度器来实现。权重衰减:0.0001。批量大小:1。动量:设置为0.95的高值，以补偿由于小批量大小而产生的噪声梯度。训练网络现在可以训练模型了。对于QuickNAT需要在3个（coronal, axial, sagittal）2d切片上训练3个模型。然后再聚合步骤中组合三个模型的概率生成最终结果，但是本文中只演示在coronal视图的2D切片上训练一个F-CNN模型，因为其他两个与之类似。 num\_epochs \= 20

start\_epoch \= 1

val\_interval \= 1

train\_loss\_epoch\_values \= \[\]

val\_loss\_epoch\_values \= \[\]

best\_ds\_mean \= \-1

best\_ds\_mean\_epoch \= \-1

ds\_mean\_train\_values \= \[\]

ds\_mean\_val\_values \= \[\]

\# ds\_LCE\_values = \[\]

\# ds\_LWM\_values = \[\]

\# ds\_LCC\_values = \[\]

print$"START TRAINING. : model name = ", "quicknat"$

for epoch in range$start\_epoch, num\_epochs$:

print$"==== Epoch \["+ str\(epoch$ + " / "+ str$num\_epochs$+ "\] DONE ===="\)

checkpoint\_name \= CHECKPOINT\_DIR + "/checkpoint\_epoch\_" + str$epoch$ + "." + CHECKPOINT\_EXTENSION

print$checkpoint\_name$

state \= \{

"epoch": epoch,

"arch": "quicknat",

"state\_dict": model\_coronal.state\_dict,

"optimizer": optimizer.state\_dict,

"scheduler": scheduler.state\_dict,

save\_checkpoint$state \= state, filename \= checkpoint\_name$

print$"\\n==== Epoch \[ \%d / \%d \] START ====" \% \(epoch, num\_epochs$\)

steps\_per\_epoch \= len$train\_dataset\_coronal\_subset$ / train\_loader\_coronal\_subset.batch\_size

model\_coronal.train

train\_loss\_epoch \= 0

val\_loss\_epoch \= 0

step \= 0

predictions\_train \= \[\]

labels\_train \= \[\]

predictions\_val \= \[\]

labels\_val \= \[\]

for i\_batch, sample\_batched in enumerate$train\_loader\_coronal\_subset$:

inputs \= sample\_batched\['image'\].type$torch.FloatTensor$

labels \= sample\_batched\['label'\].type$torch.LongTensor$

\# print$f"Train Input Shape: \{inputs.shape\}"$

labels \= labels.squeeze$1$

\_img\_channels, \_img\_height, \_img\_width \= labels.shape

encoded\_label\= np.zeros$\(\_img\_height, \_img\_width, 1$\).astype$int$

for j, cls in enumerate$MaskColorMap$:

encoded\_label\[np.all$labels \== cls.value, axis \= 0$\] \= j

labels \= encoded\_label

labels \= torch.from\_numpy$labels$

labels \= torch.permute$labels, \(2, 1, 0$\)

\# print$f"Train Label Shape: \{labels.shape\}"$

\# plt.title$"Train Label"$

\# plt.imshow$labels\[0, :, :\]$

\# plt.show

optimizer.zero\_grad

outputs \= model\_coronal$inputs$

loss \= loss\_function$outputs, labels$

loss.backward

optimizer.step

scheduler.step

with torch.no\_grad:

\_, batch\_output \= torch.max$outputs, dim \= 1$

\# print$f"Train Prediction Shape: \{batch\_output.shape\}"$

\# plt.title$"Train Prediction"$

\# plt.imshow$batch\_output\[0, :, :\]$

\# plt.show

predictions\_train.append$batch\_output.cpu\($\)

labels\_train.append$labels.cpu\($\)

train\_loss\_epoch += loss.item

print$f"\{step\}/\{len\(train\_dataset\_coronal\_subset$ // train\_loader\_coronal\_subset.batch\_size\}, Training\_loss: \{loss.item:.4f\}"\)

step += 1

predictions\_train\_arr, labels\_train\_arr \= torch.cat$predictions\_train$, torch.cat$labels\_train$

\# print$predictions\_train\_arr.shape$

dice\_metric$predictions\_train\_arr, labels\_train\_arr$

ds\_mean\_train \= dice\_metric.aggregate.item

ds\_mean\_train\_values.append$ds\_mean\_train$

dice\_metric.reset

train\_loss\_epoch /= step

train\_loss\_epoch\_values.append$train\_loss\_epoch$

print$f"Epoch \{epoch + 1\} Train Average Loss: \{train\_loss\_epoch:.4f\}"$

if $epoch + 1$ \% val\_interval \== 0:

model\_coronal.eval

step \= 0

with torch.no\_grad:

for i\_batch, sample\_batched in enumerate$val\_loader\_coronal\_subset$:

inputs \= sample\_batched\['image'\].type$torch.FloatTensor$

labels \= sample\_batched\['label'\].type$torch.LongTensor$

\# print$f"Val Input Shape: \{inputs.shape\}"$

labels \= labels.squeeze$1$

integer\_encoded\_labels \= \[\]

\_img\_channels, \_img\_height, \_img\_width \= labels.shape

encoded\_label\= np.zeros$\(\_img\_height, \_img\_width, 1$\).astype$int$

for j, cls in enumerate$MaskColorMap$:

encoded\_label\[np.all$labels \== cls.value, axis \= 0$\] \= j

labels \= encoded\_label

labels \= torch.from\_numpy$labels$

labels \= torch.permute$labels, \(2, 1, 0$\)

\# print$f"Val Label Shape: \{labels.shape\}"$

\# plt.title$"Val Label"$

\# plt.imshow$labels\[0, :, :\]$

\# plt.show

val\_outputs \= model\_coronal$inputs$

val\_loss \= loss\_function$val\_outputs, labels$

predicted \= torch.argmax$val\_outputs, dim \= 1$

\# print$f"Val Prediction Shape: \{predicted.shape\}"$

\# plt.title$"Val Prediction"$

\# plt.imshow$predicted\[0, :, :\]$

\# plt.show

predictions\_val.append$predicted$

labels\_val.append$labels$

val\_loss\_epoch += val\_loss.item

print$f"\{step\}/\{len\(val\_dataset\_coronal\_subset$ // val\_loader\_coronal\_subset.batch\_size\}, Validation\_loss: \{val\_loss.item:.4f\}"\)

step += 1

predictions\_val\_arr, labels\_val\_arr \= torch.cat$predictions\_val$, torch.cat$labels\_val$

dice\_metric$predictions\_val\_arr, labels\_val\_arr$

\# dice\_metric\_batch$predictions\_val\_arr, labels\_val\_arr$

ds\_mean\_val \= dice\_metric.aggregate.item

ds\_mean\_val\_values.append$ds\_mean\_val$

\# ds\_mean\_val\_batch = dice\_metric\_batch.aggregate

\# ds\_LCE = ds\_mean\_val\_batch\[0\].item

\# ds\_LCE\_values.append$ds\_LCE$

\# ds\_LWM = ds\_mean\_val\_batch\[1\].item

\# ds\_LWM\_values.append$ds\_LWM$

\# ds\_LCC = ds\_mean\_val\_batch\[2\].item

\# ds\_LCC\_values.append$ds\_LCC$

dice\_metric.reset

\# dice\_metric\_batch.reset

if ds\_mean\_val \> best\_ds\_mean:

best\_ds\_mean \= ds\_mean\_val

best\_ds\_mean\_epoch \= epoch + 1

torch.save$model\_coronal.state\_dict\($, os.path.join$BESTMODEL\_DIR, "best\_metric\_model\_coronal.pth"$\)

print$"Saved new best metric model coronal"$

print\(

f"Current Epoch: \{epoch + 1\} Current Mean Dice score is: \{ds\_mean\_val:.4f\}"

f"\\nBest Mean Dice score: \{best\_ds\_mean:.4f\} "

\# f"\\nMean Dice score Left Cerebral Exterior: \{ds\_LCE:.4f\} Mean Dice score Left White Matter: \{ds\_LWM:.4f\} Mean Dice score Left Cerebral Cortex: \{ds\_LCC:.4f\} "

f"at Epoch: \{best\_ds\_mean\_epoch\}"

val\_loss\_epoch /= step

val\_loss\_epoch\_values.append$val\_loss\_epoch$

print$f"Epoch \{epoch + 1\} Average Validation Loss: \{val\_loss\_epoch:.4f\}"$

print$"FINISH."$

代码也是传统的Pytorch的训练步骤，就不详细解释了绘制损失和精度曲线训练曲线表示模型的学习情况，验证曲线表示模型泛化到未见实例的情况。我们使用matplotlib来绘制图形。还可以使用TensorBoard，它使理解和调试深度学习程序变得更容易，并且是实时的。 epoch \= range$1, num\_epochs + 1$

\# Plot Loss Curves

plt.figure$figsize\=\(18, 6$\)

plt.subplot$1, 3, 1$

plt.plot$epoch, train\_loss\_epoch\_values, label\='Training Loss'$

plt.plot$epoch, val\_loss\_epoch\_values, label\='Validation Loss'$

plt.title$'Training and Validation Loss'$

plt.xlabel$'Epoch'$

plt.legend

plt.figure

plt.show

\# Plot Train Dice Coefficient Curve

plt.figure$figsize\=\(18, 6$\)

plt.subplot$1, 3, 2$

x \= \[$i + 1$ for i in range$len\(ds\_mean\_train\_values$\)\]

plt.plot$x, ds\_mean\_train\_values, 'blue', label \= 'Train Mean Dice Score'$

plt.title$"Training Mean Dice Coefficient"$

plt.xlabel$'Epoch'$

plt.ylabel$'Mean Dice Score'$

plt.show

\# Plot Validation Dice Coefficient Curve

plt.figure$figsize\=\(18, 6$\)

plt.subplot$1, 3, 3$

x \= \[$i + 1$ for i in range$len\(ds\_mean\_val\_values$\)\]

plt.plot$x, ds\_mean\_val\_values, 'orange', label \= 'Validation Mean Dice Score'$

plt.title$"Validation Mean Dice Coefficient"$

plt.xlabel$'Epoch'$

plt.ylabel$'Mean Dice Score'$

plt.show

在曲线中，我们可以看到模型是过拟合的，因为验证损失上升而训练损失下降。这是深度学习算法中一个常见的陷阱，其中模型最终会记住训练数据，而无法对未见过的数据进行泛化。避免过度拟合的技巧:用更多的数据进行训练:更大的数据集可以减少过拟合。数据增强:如果我们不能收集更多的数据，我们可以应用数据增强来人为地增加数据集的大小。添加正则化:正则化是一种限制我们的网络学习过于复杂的模型的技术，因此可能会过度拟合。评估网络我们如何度量模型的性能?一个成功的预测是一个最大限度地扩大预测和真实之间的重叠。这一目标的两个相关但不同的指标是Dice和Intersection / Union (IoU)系数，后者也被称为Jaccard系数。两个指标都在0(无重叠)和1(完全重叠)之间。这两种指标都可以用于类似的情况，但是区别在于Dice Score倾向于平均表现，而IoU则帮助你理解最坏情况下的表现。我们可以逐个类地检查度量标准，或者取所有类的平均值。这里将使用monai.metrics.DiceMetric来计算分数。一个更通用的方法是使用torchmetrics，但是因为这里使用了monai框架，所以就直接使用它内置的函数了。我们可以看到Dice得分曲线的行为相当不寻常。主要是因为验证平均Dice得分高于1，这是不可能的，因为这个度量是在0和1之间。我们无法确定这种行为的主要原因，但我们建议在多类问题中为每个类单独提供度量计算，并始终提供可视化示例以进行可视化评估。结果分析最后我们要看看模型是如何推广到未知数据的这个模型预测的几乎所有东西都是左脑白质，一些像素是左脑皮层。尽管它的预测似乎是正确的，但仍有很大的改进空间，因为我们的模型太小了，可以选择更深的模型获得更好的效果。总结在本文中，我们介绍了如何训练QuickNAT来完成具有挑战性的大脑分割任务。我们尽可能遵循作者在他们的研究论文中解释的学习策略，这是本教程为了方便演示只在最简单的步骤上进行了演示，文本的完整代码：https://github.com/inesdv26/Brain-Segmentation往期精选数据集汇总：人脸识别常用数据集大全行人检测数据集汇总10个开源工业检测数据集汇总21个深度学习开源数据集分类汇总（持续更新）小目标检测、图像分类、图像识别等开源数据集汇总人体姿态估计相关开源数据集介绍及汇总小目标检测相关开源数据集介绍及汇总医学图像开源数据集汇总自动驾驶方向开源数据集资源汇总目标检测开源数据集汇总（二）RGB-T 相关开源数据集资源汇总图像去雾开源数据集资源汇总图像分类方向优质开源数据集汇总（附下载链接）顶会资源：CVPR'23 最新 89 篇论文分方向整理｜涵盖视频目标检测、关键点检测、异常检测、语义分割、超分辨率、图像去噪等方向CVPR'23 最新 125 篇论文分方向整理｜检测、分割、人脸、视频处理、医学影像、神经网络结构、小样本学习等方向CVPR'23 最新 70 篇论文分方向整理｜包含目标检测、图像处理、人脸、医学影像、半监督学习等方向CVPR 2023 论文速递（35篇打包下载）涵盖异常检测、语义分割、三维重建、点云、医学影像、目标跟踪、行为识别等方向CVPR 2023 论文速递（54篇打包下载）涵盖实例分割、语义分割、神经网络结构、三维重建、监督学习、图像复原等方向ECCV22 最新54篇论文分方向整理｜包含目标检测、图像分割、监督学习等（附下载）CVPR 2022 全面盘点：最新250篇论文分方向汇总 / 代码 / 解读 / 直播 / 项目（更新中）CVPR'22 最新106篇论文分方向整理｜包含目标检测、动作识别、图像处理等32个方向一文看尽 CVPR2022 最新 22 篇论文（附打包下载）17 篇 CVPR 2022 论文速递｜涵盖 3D 目标检测、医学影像、车道线检测等方向CVPR 2021 结果出炉！最新500篇CVPR'21论文分方向汇总（更新中）CVPR 2021 结果出炉！最新600篇CVPR'21论文分方向汇总（更新中）CVPR 2020 Oral 汇总：论文/代码/解读（更新中）CVPR 2019 最全整理：全部论文下载，Github源码汇总、直播视频、论文解读等CVPR 2018 论文解读集锦（9月27日更新）CVPR 2018 目标检测（object detection）算法总览ECCV 2018 目标检测（object detection）算法总览（部分含代码）CVPR 2017 论文解读集锦（12-13更新）2000 ~2020 年历届 CVPR 最佳论文汇总技术综述：万字长文 | 手把手教你优化轻量姿态估计模型（算法篇）工业应用中如何选取合适的损失函数（MAE、MSE、Huber）-Pytorch版综述：图像处理中的注意力机制搞懂Transformer结构，看这篇PyTorch实现就够了熬了一晚上，我从零实现了Transformer模型，把代码讲给你听YOLO算法最全综述：从YOLOv1到YOLOv5图像匹配大领域综述！涵盖 8 个子领域，近 20年经典方法汇总一文读懂深度学习中的各种卷积万字综述｜核心开发者全面解读Pytorch内部机制19个损失函数汇总，以Pytorch为例一文看尽深度学习中的15种损失函数14种异常检测方法总结PyTorch常用代码段合集神经网络压缩综述理论深挖：深入探讨：为什么要做特征归一化/标准化？令人“细思极恐”的Faster-R-CNN论文盘点：图像分割二十年，盘点影响力最大的10篇论文2020年54篇最新CV领域综述论文速递！涵盖14个方向：目标检测/图像分割/医学影像/人脸识别等实践/面经/求学：如何配置一台深度学习工作站？国内外优秀的计算机视觉团队汇总50种Matplotlib科研论文绘图合集，含代码实现图像处理知多少？准大厂算法工程师30+场秋招后总结的面经问题详解深度学习三十问！一位算法工程师经历30+场CV面试后总结的常见问题合集（含答案）深度学习六十问！一位算法工程师经历30+场CV面试后总结的常见问题合集下篇（含答案）一位算法工程师从30+场秋招面试中总结出的目标检测算法面经（含答案）一位算法工程师从30+场秋招面试中总结出的语义分割超强面经（含答案）Github优质资源：25个【Awsome】GitHub 资源汇总（更新中）超强合集：OCR 文本检测干货汇总（含论文、源码、demo 等资源）2019-2020年目标跟踪资源全汇总（论文、模型代码、优秀实验室）发布于 2023-05-05 10:51・IP 属地广东深度学习（Deep Learning）PyTorch图像分割赞同 5添加评论分享喜欢收藏申请转载文章被以下专栏收录极市平台原创计算机视觉技术干货分享，微信公众号：极

IXI MEGA旗舰店 - 京东

京东首页

你好，请登录免费注册

我的订单

我的京东

京东会员

企业采购

客户服务

网站导航

手机京东

更多导航服装城食品团购夺宝岛闪购金融

我的京东

加载中，请稍候...

20去购物车结算

加载中，请稍候...

首页

全部分类

所有商品

品牌介绍

售后服务

查看所有商品

多品类齐全，轻松购物

快多仓直发，极速配送

好正品行货，精致服务

省天天低价，畅选无忧

购物指南

购物流程

会员介绍

生活旅行/团购

常见问题

大家电

联系客服

配送方式

上门自提

211限时达

配送服务查询

配送费收取标准

海外配送

支付方式

货到付款

在线支付

分期付款

邮局汇款

公司转账

售后服务

售后政策

价格保护

退款说明

返修/退换货

取消订单

特色服务

夺宝岛

DIY装机

延保服务

京东E卡

京东通信

京东JD+

关于我们|

联系我们|

联系客服|

合作招商|

商家帮助|

营销中心|

手机京东|

友情链接|

销售联盟|

京东社区|

风险监测|

隐私政策|

京东公益|

English Site|

京公网安备 11000002000088号|京ICP证070359号|

互联网药品信息服务资格证编号(京)-经营性-2014-0008|新出发京零字第大120007号

互联网出版许可证编号新出网证(京)字150号|

出版物经营许可证|

网络文化经营许可证京网文[2014]2148-348号|违法和不良信息举报电话：4006561155

经营证照

(京)网械平台备字(2018)第00003号

营业执照

Global Site|

Сайт России|

Situs Indonesia|

Sitio de España|

เว็บไซต์ประเทศไทย

京东旗下网站：

京东钱包|

京东云

可信网站信用评估

网络警察提醒你

诚信网站

中国互联网举报中心

网络举报APP下载

国家知识产权公共服务网

手机扫一扫，劲爆优惠触手可得！

商品比较

IXI数据预处理 + Linux + freesurfer_ixi数据集-CSDN博客

IXI数据预处理 + Linux + freesurfer

Emily卷得动

已于 2022-11-06 22:07:01 修改

阅读量1.7k

点赞数

分类专栏：

医学图像配准

文章标签：

linux

python

于 2022-11-06 22:03:31 首次发布

本文链接：https://blog.csdn.net/Emily_Buffy/article/details/127721905

版权

医学图像配准

专栏收录该内容

2 篇文章

0 订阅

订阅专栏

1. freesurfer下载安装测试1.1 下载受阻，安装axel-2.4,多线程下载1.2 安装1.3 安装时出现的问题1.4 测试1.5 使用前注意

2. freesurfer 处理IXI2.1 freesurfer 的使用2.2 从零开始处理IXI2.2.1 命令行skull_stripping 单个.nii文件2.2.2 分析处理完成后的文件2.2.3 仿射对齐.nii2.2.4 批量处理IXI2.2.5 批skull_stripping2.2.5 批修改文件brainmask_affine.mgz类型为brain_aff.nii.gz2.2.6 批量修改文件名,移动到同一个文件夹，并重命名

总结

1. freesurfer下载安装测试

1.1 下载受阻，安装axel-2.4,多线程下载

由于网络网速受阻，一直无法下载，总是中断。于是我在linux 上安装axel -2.4 插件，支持多线程下载。参考：axel-2.4 安装教程。共计13个小时，下载完成。

1.2 安装

参考： freesurfer 安装参考1 freesurfer安装参考2

1.3 安装时出现的问题

输入sudo gedit /etc/profile 出现错误：Unable to init server: Could not connect: Connection refused 原因，使用的vscode 远程连接ubuntu 服务器，不支持图形界面，改为vi或者nano ubuntu vi 打开编辑内容后,如何保存 Ubuntu vi 打开后如何换行 Ubuntu移动和复制文件夹到另一个文件夹

1.4 测试

安装测试freesurfer

1.5 使用前注意

（1）更改 .bashrc 不要在root 下的ect/.bashrc ，在个人的/home/自己的环境名/.bashrc （2）每次使用之前都要设置环境变量 linux freesurfer

export FREESURFER_HOME=/usr/local/freesurfer

source $FREESURFER_HOME/SetUpFreeSurfer.sh

2. freesurfer 处理IXI

2.1 freesurfer 的使用

参考1 freesurfer 中文教程 freesurfer recon-all 讲解

2.2 从零开始处理IXI

2.2.1 命令行skull_stripping 单个.nii文件

安装tcsh ，因为freesurfer 的recon-all 要求在tcsh 下运行

sudo apt-get install tcsh

由于在个人的/home/xukepeng/.bashrc 添加了

export FREESURFER_HOME=/usr/local/freesurfer

source $FREESURFER_HOME/SetUpFreeSurfer.sh

每次打开bash 每次使用之前都要修改 SUBJECTS_DIR

export SUBJECTS_DIR=/data/../Learn/pytorch/IXI_T1——single

测试一个.nii文件的处理

recon-all -i pytorch/IXI_T1/*.nii -autorecon1 -subjid output

会在SUBJECTS_DIR路径下自动生成output 文件夹处理一份.nii文件，共计13分钟

2.2.2 分析处理完成后的文件

output/mri/brainmask.mgz 为生成的去除头骨后的图像 output/mri/transforms/talairach.xfm为仿射对齐矩阵将.mgz转为.nii.gz 方便查看

mri_convert brainmask.mgz brainmash.nii.gz

远程显示.nii

import SimpleITK as itk

from matplotlib import pyplot as plt

def show_nii(img):

slices=1

for i in range(0,img.shape[0],10):#注意这里的间隔选取，需要参考img.shape=[256,256,256]

plt.subplot(6,5,slices) #注意这里不能天i+1，因为i是以10增加

plt.imshow(img[i,:,:],cmap='gray')

plt.axis('off')

slices+=1

itk_img=itk.ReadImage('../Learn/pytorch/IXI_T1/output/mri/brainmash.nii.gz')

img=itk.GetArrayFromImage(itk_img)

show_nii(img)

plt.savefig('IXI_skull-stripped.jpg')

plt.show()

2.2.3 仿射对齐.nii

绝对路径，打点只是我个人为了隐去名字

cd /data/../pytorch/IXI_T1_single/output/mri

export SUBJECTS_DIR=/data/../pytorch/IXI_T1_single/output

运行：注意要指定生成的文件类型，否则报错

mri_convert brainmask.mgz --apply_transform /transforms/talairach.xfm -o /mri/brainmask_affine.mgz

brainmask_affine.mgz 在

/data/../Learn/pytorch/IXI_T1_single/output/mri/brainmask_affine.mgz

2.2.4 批量处理IXI

tar -xvf 文件名 -C 存到指定路径

批量移动文件夹

mv *.nii.gz /data/../Learn/voxelmorph/IXI_T1

screen 操作 os.path.split 分离路径和当前文件名 os.path.splitext 分离文件名和后缀 cmd & 与 && 区别

import os

import glob

images=glob.glob('/data/../Learn/voxelmorph/IXI_T1/*.nii.gz')

#print(images) #返回一堆路径

(filepath,tempfilename)=os.path.split(images[0])

print(filepath)

print(tempfilename)

(filename,extension)=os.path.splitext(tempfilename)

print(filename)

print(extension)

print(filename[:-4])

每一个单独的.nii.gz 处理后都有单独的文件夹存储

2.2.5 批skull_stripping

import os

import glob

path=r"/data/../Learn/voxelmorph/IXI_T1/"

#读取目录下的nii.gz文件

images=glob.glob('/data/../Learn/voxelmorph/IXI_T1/*.nii.gz')

#为freesurfer环境配置命令

a="export FREESURFER_HOME=/usr/local/freesurfer;"

b="source $FREESURFER_HOME/SetUpFreeSurfer.sh;"

#数据所在目录

c="export SUBJECTS_DIR=/data/../Learn/voxelmorph/IXI_T1;"

for image in images:

#将文件路径与文件名分离

(filepath,tempfilename)=os.path.split(image) #返回文件的路径和文件名

(filename,extension)=os.path.splitext(tempfilename)

#freesurfer环境配置，颅骨去除，未仿射对齐.mpz转.nii,仿射对齐，仿射对齐.mpz转.nii

cmd = a + b + c \

# + "recon-all -i " + image + " -autorecon1 -subjid " + filename[:-4] + "&&" \

# + "mri_convert /" + path + filename[:-4] + "/mri/brainmask.mgz /" + path + filename[:-4] \

# + "/mri/brainmask.nii.gz;"\

+ "mri_convert " + path + filename[:-4] + "/mri/brainmask.mgz --apply_transform " + path + filename[:-4] \

+ "/mri/transforms/talairach.xfm -o " + path + filename[:-4] + "/mri/brainmask_affine.mgz&&" \

+ "mri_convert /" + path + filename[:-4] + "/mri/brainmask_affine.mgz /" + path + filename[:-4] \

+ "/mri/brainmask_affine.nii.gz;"

os.system(cmd)

#程序中断

2.2.5 批修改文件brainmask_affine.mgz类型为brain_aff.nii.gz

python 读取不同文件夹下相似的文件名 glob 结合通配符星号（*）、问号（？）和中括号使用格式化命名format

import os

import glob

import sys

"""

1.修改文件类型为brain_aff.nii.gz #不能直接放到train_vol 会被覆盖

"""

path=r"../Learn/voxelmorph/IXI_T1/"#错误，少了单斜杠

images=glob.glob('../Learn/voxelmorph/IXI_T1/*.nii.gz')# 读取

#print(images)

a="export FREESURFER_HOME=/usr/local/freesurfer;"

b="source $FREESURFER_HOME/SetUpFreeSurfer.sh;"

#数据所在目录

c="export SUBJECTS_DIR=../project/Learn/voxelmorph/IXI_T1;"

for image in images:

#filename=image[48:54]

#print(filename)

(filepath,tempfilename)=os.path.split(image) #返回文件的路径和文件名

(filename,extension)=os.path.splitext(tempfilename)

cmd = a+b+c+ "mri_convert " + path + filename[:-4] + "/mri/brainmask_affine.mgz " + path +filename[:-4]+"/mri/brain_aff.nii.gz"

os.system(cmd)

2.2.6 批量修改文件名,移动到同一个文件夹，并重命名

import os

import glob

"""

1。批量修改文件名

2.移动到同一文件夹下

"""

#path=r"/data/../Learn/voxelmorph/IXI_T1/"

#获得编号名

#filename_list=glob.glob('/data/../Learn/voxelmorph/IXI_T1/*.nii.gz')

path_list=glob.glob('/data/../Learn/voxelmorph/IXI_T1/*T1/mri/*.nii.gz')

""""给../mri/brain_aff.nii.gz更名"""

#print(len(path_list))

# a=0

# for i in path_list:

# used_name=path_list[a]+os.sep+'mri/brain_aff.nii.gz'

# print(ssss)

# new_name=path_list[a]+os.sep+'mri/sub_'+str(a)+'.nii.gz'

# print(ssssss)

# os.rename(used_name,new_name)

# a+=1

"""复制到文件夹train_vol"""

# for path in path_list:

# (filepath,tempfilename)=os.path.split(path)

# print(filepath)

# print(tempfilename)

# cmd="cd "+filepath+";"+"sudo cp " + tempfilename+ " /data/../Learn/voxelmorph/IXI_T1/train_vol/"

# os.system(cmd)

"""格式化命名1 -> 001 ，数字补0"""

#path=input('/data/../Learn/voxelmorph/IXI_T1/train_vol/')

file_list=os.listdir(os.getcwd())

#print(len(file_list))

n=0

for f in file_list:

(filename,extension)=os.path.splitext(f)

oldname=os.getcwd()+os.sep+file_list[n]

num=filename[4:-4]

#print(name)

num='{:0>3}'.format(num) #补齐

#print(num)

newname=os.getcwd()+os.sep+'sub-'+str(num)+'.nii.gz'

os.rename(oldname,newname)

print(n)

n=n+1

总结

作为小白入门笔记记录，上面的代码基本都测试通过，或许存在更为简单的方法，也可能存在错误，欢迎指正

优惠劵

Emily卷得动

关注

踩

觉得还不错?

一键收藏

知道了

IXI数据预处理 + Linux + freesurfer

作为小白入门笔记记录，代码基本都测试通过，或许存在更为简单的方法，也可能存在错误，欢迎指正。

复制链接

扫一扫

专栏目录

8 条评论

您还未登录，请先

后发表或查看评论

使用Voxelmorph配准IXI：数据预处理之颅骨去除及仿射对齐

u014776464的博客

03-10

4747

本文是在原链接https://blog.csdn.net/qq_38302885/article/details/94045126

的基础上，增加的一些补充，对新入门的同学可能有一些启发。

关于freesurfer的具体安装和使用，可以参考

https://blog.csdn.net/uinglin/article/details/79541063

使用Freesurfer进行头骨去除和仿射对齐

...

多模态医学图像数据集

qq_61890919的博客

11-29

1677

由国际生物医学成像研讨会（ISBI）举办，是一个包含多个医学图像分析任务和数据集的竞赛平台，其中有一些任务涉及到多模态医学图像的分割、配准和融合，如head and neck cancer segmentation、domain adaptation for segmentation等。多模态医学图像数据集是指包含不同模态（如CT、MRI、PET等）的医学图像的数据集，它们可以提供更多的信息和视角，有助于医学图像分析和诊断。:其中提供了一些CT和MRI图像的数据集，可以用于医学图像融合研究。

在Windows上运行Freesurfer的简易方法（基于WSL2）

qq_45081900的博客

01-02

614

一种在Windows上运行freesurfer的方法

医学图像处理：Ubuntu16.04安装freesurfer教程

uinglin的博客

03-13

2万+

freesurfer是一个处理大脑3D数据影像的软件，用起来非常方便。安装教程如下：我的ubuntu系统是16.04，其他版本亦可作为参考。1.下载所需软件包在官网上下载安装包，链接：点击打开链接。下载需要12个小时左右。获取licence，在官网点击打开链接上注册一下，填写自己的邮箱，提交之后会收到一个邮件。打开附件，复制附件信息，新建一个licence.txt,将内容粘贴到该txt文件中。收到...

T1-数据集

03-30

No description

IXI数据集 3d切片——适用所有医学3d图像切片

qq_41174671的博客

07-13

1104

将多模态医学3d图像转成2d

FreeSurfer的安装及使用（个人踩坑记录）

IXI Dataset之脑部MR图像T1和T2(nii格式，约600个健康头部)_数据集-飞桨AI Studio星河社区

IXI数据集 3d切片——适用所有医学3d图像切片-CSDN博客

IXI数据集 3d切片——适用所有医学3d图像切片

最新推荐文章于 2023-11-29 12:00:51 发布

淡唱暮念

最新推荐文章于 2023-11-29 12:00:51 发布

阅读量1.1k

点赞数

文章标签：

图像处理

python

人工智能

计算机视觉

本文链接：https://blog.csdn.net/qq_41174671/article/details/131711889

版权

MRI 数据集切片

从x轴、y轴、z轴

import numpy as np

import os

import nibabel as nib

import imageio

from scipy.ndimage import zoom

from skimage.transform import resize

def nii_to_image(niifile):

file_list = os.listdir(niifile)

for filename in file_list:

if filename.endswith(".nii.gz"):

img_path = os.path.join(niifile, filename)

img = nib.load(img_path)

img_fdata = img.get_fdata()

# 创建保存图像的文件夹

x_folder = os.path.join(niifile, 'x_slices')

filex_folder = os.path.splitext(os.path.basename(filename))[0]

filex_folder = filename.split('.')[0]

filex_path = os.path.join(x_folder, filex_folder)

if not os.path.exists(filex_path):

os.makedirs(filex_path)

print("Created folder:", filex_path)

y_folder = os.path.join(niifile, 'y_slices')

filey_folder = os.path.splitext(os.path.basename(filename))[0]

filey_folder = filename.split('.')[0]

filey_path = os.path.join(y_folder, filey_folder)

if not os.path.exists(filey_path):

os.makedirs(filey_path)

print("Created folder:", filey_path)

z_folder = os.path.join(niifile, 'z_slices')

filez_folder = os.path.splitext(os.path.basename(filename))[0]

filez_folder = filename.split('.')[0]

filez_path = os.path.join(z_folder, filez_folder)

if not os.path.exists(filez_path):

os.makedirs(filez_path)

print("Created folder:", filez_path)

os.makedirs(x_folder, exist_ok=True)

os.makedirs(y_folder, exist_ok=True)

os.makedirs(z_folder, exist_ok=True)

# 在每个方向上分别保存2D图像切片

for i in range(img_fdata.shape[0]):

img_slice = img_fdata[i, :, :]

filename = filename[:-7]

# 保存x方向的切片

x_filename = f"{filename}_x_{i}.png"

img_slice = zoom(img_slice, (256/img_slice.shape[0], 256/img_slice.shape[1]), order=3)

img_slice =(img_slice - np.min(img_slice)) / (np.max(img_slice) - np.min(img_slice))

x_path = os.path.join(filex_path, x_filename)

imageio.imwrite(x_path, (img_slice * 255).astype(np.uint8))

#imageio.imwrite(x_path, img_slice.astype(np.uint8))

#imageio.imwrite(x_path, img_slice)

for i in range(img_fdata.shape[1]):

img_slice = img_fdata[:, i, :]

# 保存y方向的切片

y_filename = f"{filename}_y_{i}.png"

img_slice = zoom(img_slice, (256/img_slice.shape[0], 256/img_slice.shape[1]), order=3)

img_slice =(img_slice - np.min(img_slice)) / (np.max(img_slice) - np.min(img_slice))

y_path = os.path.join(filey_path, y_filename)

imageio.imwrite(y_path, (img_slice * 255).astype(np.uint8))

# imageio.imwrite(y_path, img_slice.astype(np.uint8))

for i in range(img_fdata.shape[2]):

img_slice = img_fdata[:, :, i]

# 保存z方向的切片

z_filename = f"{filename}_z_{i}.png"

img_slice = zoom(img_slice, (256/img_slice.shape[0], 256/img_slice.shape[1]), order=3)

img_slice =(img_slice - np.min(img_slice)) / (np.max(img_slice) - np.min(img_slice))

z_path = os.path.join(filez_path, z_filename)

imageio.imwrite(z_path, (img_slice * 255).astype(np.uint8))

# imageio.imwrite(z_path, img_slice.astype(np.uint8))

def normalize_image(image):

# 可选：将图像数据进行正则化

min_val = np.min(image)

max_val = np.max(image)

image = (image - min_val) / (max_val - min_val) * 255

return image

nii_to_image(IXI/T1')

会创建x,y,z 文件夹在T1下，每个nii.gz文件再创一个文件夹，将所有这个方向上的切片放到对应文件中

某个方向指定slice数量

import scipy, numpy, shutil, os, nibabel

import sys, getopt

import imageio

def niito2D(filepath):

inputfiles = os.listdir(filepath) #遍历文件夹数据

outputfile = './mc_slices/' #输出文件夹

print('Input file is ', inputfiles)

print('Output folder is ', outputfile)

for inputfile in inputfiles:

image_array = nibabel.load(filepath+inputfile).get_fdata() #数据读取

print(len(image_array.shape))

# set destination folder

if not os.path.exists(outputfile):

os.makedirs(outputfile) #不存在输出文件夹则新建

print("Created ouput directory: " + outputfile)

print('Reading NIfTI file...')

# Create a folder for each input file

file_folder = os.path.splitext(os.path.basename(inputfile))[0]

file_folder = inputfile.split('.')[0]

file_path = os.path.join(outputfile, file_folder)

if not os.path.exists(file_path):

os.makedirs(file_path)

print("Created folder:", file_path)

total_slices = 50 #总切片数

slice_counter = 50 #从第几个切片开始

# iterate through slices

for current_slice in range(50, 50+total_slices):

# alternate slices

if (slice_counter % 1) == 0:

data = image_array[:, :, current_slice] #保存该切片，可以选择不同方向。

# alternate slices and save as png

if (slice_counter % 1) == 0:

print('Saving image...')

#切片命名

image_name = inputfile[:-7] + "{:0>3}".format(str(current_slice + 1)) + ".png"

#image_name = "{:0>3}.png".format(str(current_slice + 1))

# Resize the image

resized_data = (data - np.min(data)) / (np.max(data) - np.min(data))

resized_data = (resized_data * 255).astype(np.uint8)

#保存

# Save the image inside the file folder

image_name = os.path.join(file_path, image_name)

#imageio.imwrite(image_path, resized_data)

imageio.imwrite(image_name, resized_data)

print('Saved.')

# move images to folder

# print('Moving image...')

# src = image_name

# shutil.move(src, outputfile)

slice_counter += 1

print('Moved.')

print('Finished converting images')

if __name__ == '__main__':

niito2D('/IXI/T2/')

优惠劵

淡唱暮念

关注

踩

觉得还不错?

一键收藏

知道了

IXI数据集 3d切片——适用所有医学3d图像切片

将多模态医学3d图像转成2d

复制链接

扫一扫

配准无颅骨的MR脑图像

04-01

配准后去颅骨的MR图像，具有T1，T1C，T2，Flair4种序列的脑MR图，可用于深度学习。

医学图像数据集汇总

qq_29462849的博客

01-15

1万+

前言

本文首发于公众号【3D视觉工坊】，原文请见

汇总|医学图像数据集，更多干货获取请关注公众号~

一、胰腺分割数据集

数据下载链接：http://academictorrents.com/details/80ecfefcabede760cdbdf63e38986501f7becd49

数据介绍：包含82个病例的胰腺数据集。

二、MICCAI胰腺分割数据集

数据下载链接：http://medic...

1 条评论

您还未登录，请先

后发表或查看评论

配准无颅骨的MR脑图像 .rar

08-23

配准后去颅骨的MR图像，具有T1，T1C，T2，Flair4种序列的脑MR图，可用于深度学习。

使用Voxelmorph配准IXI：数据预处理之颅骨去除及仿射对齐

u014776464的博客

03-10

4747

本文是在原链接https://blog.csdn.net/qq_38302885/article/details/94045126

的基础上，增加的一些补充，对新入门的同学可能有一些启发。

关于freesurfer的具体安装和使用，可以参考

https://blog.csdn.net/uinglin/article/details/79541063

使用Freesurfer进行头骨去除和仿射对齐

...

IXI数据预处理 + Linux + freesurfer

Emily_Buffy的博客

11-06

1788

作为小白入门笔记记录，代码基本都测试通过，或许存在更为简单的方法，也可能存在错误，欢迎指正。

Image Synthesis in Multi-Contrast MRI With Conditional Generative Adversarial Networks—论文解读

qq_42079689的博客

12-12

1634

Image Synthesis in Multi-Contrast MRI With Conditional Generative Adversarial Networks文章概述及亮点摘要介绍方法

文章概述及亮点

【1】multi-contrast如何理解

【2】registered multi-contrast images和unregistered images如何理解，理解成配准的图像和未...

基于 Amazon SageMaker 利用 MONAI 处理医疗影像数据实践

亚马逊云科技专栏

02-15

2388

介绍神经网络已被证明可有效解决复杂的计算机视觉任务，例如对象检测、图像相似性和分类。随着低成本 GPU 的发展，构建和部署神经网络的计算成本已大幅降低。然而，大多数技术旨在处理视觉媒体中常...

pytorch实现自定义医学3d图像数据集dataset

sdhdsf132452的博客

01-31

658

pytorch

Python将nii.gz的3D医学图像切片为2D图像

qq_45807235的博客

02-15

2316

python将NIFTI格式nii文件读取导出成2D图像

NIFTI格式的文件后缀为nii

没有的库就自己安装一下

命令 pip install 包名

如何读取并对nii三维数据进行切片处理、转换格式保存

Follow

imtoken中文版手机下载|ixi

imtoken中文版手机下载|ixi

IXI MEGA 官网 - 新加坡IXI MEGA Pte Ltd公司研发设计 | 音频接口

GitHub - junyuchen245/Preprocessed_IXI_Dataset: Preprocessed IXI brain MRI dataset with subcortical segmentation

IXI 脑部图像数据集 / 数据集 / 超神经

实践教程｜使用Pytorch对MRI脑扫描的图像进行分割 - 知乎

IXI MEGA旗舰店 - 京东

IXI数据预处理 + Linux + freesurfer_ixi数据集-CSDN博客

IXI Dataset之脑部MR图像T1和T2(nii格式，约600个健康头部)_数据集-飞桨AI Studio星河社区

IXI数据集 3d切片——适用所有医学3d图像切片-CSDN博客

最近的新闻

您可能喜欢的文章

imtoken钱包2022最新版|iota

比特派官网安卓版下载|jex

TP钱包能否提现？实践告诉你答案

三星区块链钱包：让你安全存储数字资产

VP区块链钱包：安全、便捷的数字资产管理工具

TP钱包是去中心化的嘛

虚拟币钱包备份方法及步骤，保障您的资产安全