의료 이미지를 위한 딥러닝의 전체 코드 예: Pytorch를 사용하여 MRI 뇌 스캔에서 이미지 분할

영상 분할은 의료 영상 분석에서 가장 중요한 작업 중 하나이며, 많은 임상 응용 분야에서 첫 번째이자 가장 중요한 단계인 경우가 많습니다. 뇌 MRI 분석에서 이미지 분할은 해부학적 구조를 측정 및 시각화하고, 뇌 변화를 분석하고, 병리학적 영역을 묘사하고, 수술 계획을 세우는 데 일반적으로 사용되며, 이미지 기반 중재는 대부분의 형태학적 분석의 전제 조건입니다.

이 기사에서는 QuickNAT을 사용하여 인간 두뇌의 이미지를 분할하는 방법을 소개합니다. NumPy, TorchIO, matplotlib 등의 데이터 시각화 및 계산을 위해 MONAI, PyTorch 및 일반 Python 라이브러리를 사용하세요.

이 기사에서는 주로 다음 측면을 설계합니다.

• 데이터세트 설정 및 데이터 탐색
• 데이터세트 처리 및 준비 적절한 모델 교육
• 교육 루프 만들기
• 모델 평가 및 결과 분석

전체 코드는 이 기사의 끝부분에서 제공됩니다.

데이터 디렉터리 설정

MONAI를 사용하는 첫 번째 단계는 MONAI_DATA_DIRECTORY 환경 변수를 설정하여 디렉터리를 지정하지 않으면 임시 디렉터리가 사용됩니다.

<code>directory = os.environ.get("MONAI_DATA_DIRECTORY") root_dir = tempfile.mkdtemp() if directory is None else directory print(root_dir)</code>

데이터 세트 설정

CNN 모델을 뇌 분할로 확장하는 데 있어 주요 과제 중 하나는 사람이 주석을 추가한 훈련 데이터의 가용성이 제한적이라는 것입니다. 저자는 수동 라벨이 없는 대규모 데이터 세트와 수동 라벨이 있는 소규모 데이터 세트를 활용하는 새로운 교육 전략을 소개합니다.

먼저 기존 소프트웨어 도구(예: FreeSurfer)를 사용하여 레이블이 지정되지 않은 대규모 데이터 세트에서 자동으로 생성된 분할을 얻은 다음 이러한 도구를 사용하여 네트워크를 사전 훈련합니다. 두 번째 단계에서는 수동으로 주석이 달린 더 작은 데이터를 사용하여 네트워크를 미세 조정합니다[2].

IXI 데이터 세트는 건강한 피험자의 레이블이 지정되지 않은 MRI T1 스캔 581개로 구성됩니다. 데이터는 런던에 있는 3개의 다른 병원에서 수집되었습니다. 이 데이터 세트를 사용할 때의 가장 큰 단점은 레이블이 공개적으로 제공되지 않는다는 것입니다. 따라서 연구 논문에서와 동일한 접근 방식을 따르기 위해 이 기사에서는 FreeSurfer를 사용하여 이러한 MRI T1 스캔에 대한 분할을 생성합니다.

FreeSurfer는 구조를 분석하고 시각화하는 소프트웨어 패키지입니다. 다운로드 및 설치 지침은 여기에서 확인할 수 있습니다. 모든 피질 재구성 과정은 "recon-all" 명령을 사용하여 직접 수행할 수 있습니다.

FreeSurfer는 레이블이 지정되지 않은 대량의 데이터를 활용하고 감독 방식으로 네트워크를 교육하는 데 매우 유용한 도구이지만 이러한 레이블을 생성하기 위한 스캔에는 최대 5시간이 소요되므로 여기서는 OASIS 데이터 세트를 직접 사용하여 교육합니다. 모델에서 OASIS 데이터세트는 공개적으로 사용 가능한 수동 주석이 포함된 더 작은 데이터세트입니다.

OASIS는 뇌 신경 영상 데이터 세트를 과학계에서 무료로 사용할 수 있도록 하는 프로젝트입니다. OASIS-1은 39개 주제의 단면으로 구성된 데이터세트입니다.

<code>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)</code>

데이터 탐색

'oasis_crosssection_disc1.tar.gz'를 열면 각 주제마다 서로 다른 폴더가 있음을 알 수 있습니다. 예를 들어 OAS1_0001_MR1 항목의 경우 다음과 같습니다.

미러 데이터 파일 경로: disc1OAS1_0001_MR1PROCESSEDMPRAGET88_111 oas1_0001_mr1_mpr_n4_anon_111_t88_masked_ggc .img

태그 파일: disc1OAS1_0001_MR1FSL_SEGOAS1_0001_MR1_mpr_n4_anon_111_t88_masked_gfc_fseg.img

데이터 로드 및 전처리

데이터세트 다운로드 임시 디렉토리에 추출한 후 재구성해야 합니다. 디렉토리가 다음과 같이 보이도록 해야 합니다.

따라서 데이터를 로드하려면 아래 단계를 따라야 합니다.

것입니다. img 파일로 변환됩니다. nii 파일을 만들고 새 폴더에 저장: 두 개의 새 폴더를 만듭니다. Oasis_Data_Processed에는 각 대상에 대해 처리된 MRI T1 스캔이 포함되고 Oasis_Labels_Processed에는 해당 레이블이 포함됩니다.

<code>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)</code>

그럼 그냥 조작하세요:

<code>for i in [x for x in range(1, 43) if x != 8 and x != 24 and x != 36]: if i </code>

특정 코드는 더 이상 붙여넣지 않습니다. 관심이 있으시면 최종 완성 코드를 살펴보세요. 다음 단계는 이미지 및 라벨 파일 이름을 읽는 것입니다.

<code>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)]</code>

해당 라벨이 있는 이미지를 시각화하려면 딥 러닝을 위한 다차원 의료 이미지의 로드, 전처리, 향상 및 샘플링을 위한 Python 라이브러리인 TorchIO를 사용할 수 있습니다.

<code>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()</code>

下面就是将数据分成3部分——训练、验证和测试。将数据分成三个不同的类别的目的是建立一个可靠的机器学习模型，避免过拟合。

我们将整个数据集分成三个部分:

Train: 80%，Validation: 10%，Test: 10%

<code>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)}")</code>

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

<code>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)</code>

同理，下面是保存标签：

<code>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')</code>

为训练和验证定义图像的变换处理

在本例中，我们将使用Dictionary Transforms，其中数据是Python字典。

<code>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)]</code>

现在我们将应用以下变换:

LoadImaged:加载图像数据和元数据。我们使用' PILReader '来加载图像和标签文件。ensure_channel_first设置为True，将图像数组形状转换为通道优先。

Rotate90d:我们将图像和标签旋转90度，因为当我们下载它们时，它们方向是不正确的。

ToTensord:将输入的图像和标签转换为张量。

NormalizeIntensityd:对输入进行规范化。

<code>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'])])</code>

MaskColorMap将我们定义了一个新的转换，将相应的像素值以一种格式映射为多个标签。这种转换在语义分割中是必不可少的，因为我们必须为每个可能的类别提供二元特征。One-Hot Encoding将对应于原始类别的每个样本的特征赋值为1。

因为OASIS-1数据集只有3个大脑结构标签，对于更详细的分割，理想的情况是像他们在研究论文中那样对28个皮质结构进行注释。在OASIS-1下载说明中，可以找到使用FreeSurfer获得的更多大脑结构的标签。

所以本文将分割更多的神经解剖结构。我们要将模型的参数num_classes修改为相应的标签数量，以便模型的输出是具有N个通道的特征映射，等于num_classes。

为了简化本教程，我们将使用以下标签，比OASIS-1但是要比FreeSurfer的少：

• Label 0: Background
• Label 1: LeftCerebralExterior
• Label 2: LeftWhiteMatter
• Label 3: LeftCerebralCortex

所以MaskColorMap的代码如下：

<code>class MaskColorMap(Enum):Background = (30)LeftCerebralExterior = (91)LeftWhiteMatter = (137)LeftCerebralCortex = (215)</code>

数据集和数据加载

数据集和数据加载器从存储中提取数据，并将其分批发送给训练循环。这里我们使用monai.data.Dataset加载之前定义的训练和验证字典，并对输入数据应用相应的转换。dataloader用于将数据集加载到内存中。我们将为训练和验证以及每个视图定义一个数据集和数据加载器。

为了方便演示，我们使用通过使用torch.utils.data.Subset，在指定的索引处创建一个子集，只是用部分数据训练加快演示速度。

<code>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)</code>

定义模型

给定一组MRI脑扫描I = {I1，…In}及其对应的分割S = {S1，…Sn}，我们想要学习一个函数fseg: I -> S。我们将这个函数表示为F-CNN模型，称为QuickNAT：

QuickNAT由三个二维f - cnn组成，分别在coronal, axial, sagittal视图上操作，然后通过聚合步骤推断最终的分割结果，该分割结果由三个网络的概率图组合而成。每个F-CNN都有一个编码器/解码器架构，其中有4个编码器和4个解码器，并由瓶颈层分隔。最后一层是带有softmax的分类器块。该架构还包括每个编码器/解码器块内的残差链接。

<code>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 thepath 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</code>

损失函数

神经网络的训练需要一个损失函数来计算模型误差。训练的目标是最小化预测输出和目标输出之间的损失。我们的模型使用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模型，因为其他两个与之类似。

<code>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.")</code>

代码也是传统的Pytorch的训练步骤，就不详细解释了

绘制损失和精度曲线

训练曲线表示模型的学习情况，验证曲线表示模型泛化到未见实例的情况。我们使用matplotlib来绘制图形。还可以使用TensorBoard，它使理解和调试深度学习程序变得更容易，并且是实时的。

<code>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()</code>

在曲线中，我们可以看到模型是过拟合的，因为验证损失上升而训练损失下降。这是深度学习算法中一个常见的陷阱，其中模型最终会记住训练数据，而无法对未见过的数据进行泛化。

避免过度拟合的技巧:

• 用更多的数据进行训练:更大的数据集可以减少过拟合。
• 数据增强:如果我们不能收集更多的数据，我们可以应用数据增强来人为地增加数据集的大小。
• 添加正则化:正则化是一种限制我们的网络学习过于复杂的模型的技术，因此可能会过度拟合。

评估网络

我们如何度量模型的性能?一个成功的预测是一个最大限度地扩大预测和真实之间的重叠。

这一目标的两个相关但不同的指标是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

위 내용은 의료 이미지를 위한 딥러닝의 전체 코드 예: Pytorch를 사용하여 MRI 뇌 스캔에서 이미지 분할의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!