27 | 使用PyTorch完成医疗图像识别大项目：实现端到端模型方案

run('test14ch.prepcache.LunaPrepCacheApp')

run('test14ch.training.ClassificationTrainingApp', f'--epochs=100', 'nodule-nonnodule')

#取一个uid        for _, series_uid in series_iter:#然后获取对应的CT数据
            ct = getCt(series_uid)#紧接着跑分割模型
            mask_a = self.segmentCt(ct, series_uid)#给分割模型预测到的结节数据进行分组
            candidateInfo_list = self.groupSegmentationOutput(
                series_uid, ct, mask_a)#最后跑分类模型，决定是不是结节
            classifications_list = self.classifyCandidates(
                ct, candidateInfo_list)

    def segmentCt(self, ct, series_uid):#预测不需要更新，关闭自动梯度计算
        with torch.no_grad():#用来存储输出结果
            output_a = np.zeros_like(ct.hu_a, dtype=np.float32)#初始化数据加载器
            seg_dl = self.initSegmentationDl(series_uid) #遍历整个CT
            for input_t, _, _, slice_ndx_list in seg_dl:#发送到GPU
                input_g = input_t.to(self.device)#运行分割模型
                prediction_g = self.seg_model(input_g)#把结果存起来
                for i, slice_ndx in enumerate(slice_ndx_list):
                    output_a[slice_ndx] = prediction_g[i].cpu().numpy()#构建掩码结果
            mask_a = output_a > 0.5
            mask_a = morphology.binary_erosion(mask_a, iterations=1)#返回
        return mask_a

    def groupSegmentationOutput(self, series_uid,  ct, clean_a):

        candidateLabel_a, candidate_count = measurements.label(clean_a)
        centerIrc_list = measurements.center_of_mass(
            ct.hu_a.clip(-1000, 1000) + 1001,
            labels=candidateLabel_a,
            index=np.arange(1, candidate_count+1),
        )#把识别到的数据转化分类模型要用的数据。
        candidateInfo_list = []
        for i, center_irc in enumerate(centerIrc_list):
            center_xyz = irc2xyz(
                center_irc,
                ct.origin_xyz,
                ct.vxSize_xyz,
                ct.direction_a,
            )
            assert np.all(np.isfinite(center_irc)), repr(['irc', center_irc, i, candidate_count])
            assert np.all(np.isfinite(center_xyz)), repr(['xyz', center_xyz])
            candidateInfo_tup = \
                CandidateInfoTuple(False, False, False, 0.0, series_uid, center_xyz)
            candidateInfo_list.append(candidateInfo_tup)

        return candidateInfo_list

    def classifyCandidates(self, ct, candidateInfo_list):# 初始化dataloader
        cls_dl = self.initClassificationDl(candidateInfo_list)
        classifications_list = []
        for batch_ndx, batch_tup in enumerate(cls_dl):
            input_t, _, _, series_list, center_list = batch_tup#发送到GPU上
            input_g = input_t.to(self.device)
            with torch.no_grad():#运行分类模型
                _, probability_nodule_g = self.cls_model(input_g)#这里还有一个分是否恶性的模型，现在我们还没开发，先留下这个位置
                if self.malignancy_model is not None:
                    _, probability_mal_g = self.malignancy_model(input_g)
                else:
                    probability_mal_g = torch.zeros_like(probability_nodule_g)

            zip_iter = zip(center_list,
                probability_nodule_g[:,1].tolist(),
                probability_mal_g[:,1].tolist())#转换坐标
            for center_irc, prob_nodule, prob_mal in zip_iter:
                center_xyz = irc2xyz(center_irc,
                    direction_a=ct.direction_a,
                    origin_xyz=ct.origin_xyz,
                    vxSize_xyz=ct.vxSize_xyz,
                )
                cls_tup = (prob_nodule, prob_mal, center_xyz, center_irc)
                classifications_list.append(cls_tup)
        return classifications_list

#这个cli_args.run_validation参数是用来判断是否跑验证集数据的，如果不是验证集数据，而是单个输入uid，那么就执行下面的信息显示功能
            if not self.cli_args.run_validation:
                print(f"found nodule candidates in {series_uid}:")
                for prob, prob_mal, center_xyz, center_irc in classifications_list:
                    if prob > 0.5:#如果我们找到的结节概率超过0.5，就输出信息到屏幕上，给医生看
                        s = f"nodule prob {prob:.3f}, "
                        if self.malignancy_model:
                            s += f"malignancy prob {prob_mal:.3f}, "
                        s += f"center xyz {center_xyz}"
                        print(s)#这里输出混淆矩阵
            if series_uid in candidateInfo_dict:
                one_confusion = match_and_score(
                    classifications_list, candidateInfo_dict[series_uid]
                )
                all_confusion += one_confusion
                print_confusion(
                    series_uid, one_confusion, self.malignancy_model is not None
                )

        print_confusion(
            "Total", all_confusion, self.malignancy_model is not None
        )

python -m test14ch.nodule_analysis 1.3.6.1.4.1.14519.5.2.1.6279.6001.592821488053137951302246128864

pip install pylidc

import torch%matplotlib inlinefrom matplotlib import pyplotimport test14ch.dsetsimport test14ch.model#这里获取带有恶性结节标记的数据集ds = test14ch.dsets.MalignantLunaDataset(val_stride=10, isValSet_bool=True)  nodules = ds.ben_list + ds.mal_list#获取是否恶性结节的状态和直径is_mal = torch.tensor([n.isMal_bool for n in nodules]) diam  = torch.tensor([n.diameter_mm for n in nodules])#恶性和良性数目num_mal = is_mal.sum()  num_ben = len(is_mal) - num_mal#设置阈值，取结节直径的最大最小值，并分成100份threshold = torch.linspace(diam.max(), diam.min(), steps=100)#使用直径来判断是否恶性结节predictions = (diam[None] >= threshold[:, None])  计算真阳率和假阳率
tp_diam = (predictions & is_mal[None]).sum(1).float() / num_mal  
fp_diam = (predictions & ~is_mal[None]).sum(1).float() / num_ben#计算aucfp_diam_diff =  fp_diam[1:] - fp_diam[:-1]tp_diam_avg  = (tp_diam[1:] + tp_diam[:-1])/2auc_diam = (fp_diam_diff * tp_diam_avg).sum()#fill用于后面绘图使用fp_fill = torch.ones((fp_diam.shape[0] + 1,))fp_fill[:-1] = fp_diam

tp_fill = torch.zeros((tp_diam.shape[0] + 1,))tp_fill[:-1] = tp_diamprint(threshold)print(fp_diam)print(tp_diam)for i in range(threshold.shape[0]):
    print(i, threshold[i], fp_diam[i], tp_diam[i])pyplot.figure(figsize=(7,5), dpi=1200)for i in [62, 88]:
    pyplot.scatter(fp_diam[i], tp_diam[i], color='red')
    print(f'diam: {round(threshold[i].item(), 2)}, x: {round(fp_diam[i].item(), 2)}, y: {round(tp_diam[i].item(), 2)}')pyplot.fill(fp_fill, tp_fill, facecolor='#0077bb', alpha=0.25)pyplot.plot(fp_diam, tp_diam, label=f'diameter baseline, AUC={auc_diam:.3f}')pyplot.title(f'ROC diameter baseline, AUC={auc_diam:.3f}')pyplot.ylabel('true positive rate')pyplot.xlabel('false positive rate')pyplot.savefig('roc_diameter_baseline.png')

#判断是否开启微调模式
        if self.cli_args.finetune:#加载模型
            d = torch.load(self.cli_args.finetune, map_location='cpu')#获取所有层
            model_blocks = [
                n for n, subm in model.named_children()
                if len(list(subm.parameters())) > 0
            ]#获取需要微调的层
            finetune_blocks = model_blocks[-self.cli_args.finetune_depth:]
            log.info(f"finetuning from {self.cli_args.finetune}, blocks {' '.join(finetune_blocks)}")#加载保存的状态
            model.load_state_dict(
                {
                    k: v for k,v in d['model_state'].items()
                    if k.split('.')[0] not in model_blocks[-1]
                },
                strict=False,
            )#只在需要finetune的层上进行梯度计算
            for n, p in model.named_parameters():
                if n.split('.')[0] not in finetune_blocks:
                    p.requires_grad_(False)

run('test14ch.training.ClassificationTrainingApp', f'--epochs=40', '--malignant', '--dataset=MalignantLunaDataset',
    '--finetune=''D:/pytorchtest/data-unversioned/part2/models/p2ch14/cls_2022-06-27_21.59.28_nodule-nonnodule.best.state',
    'finetune-head')

run('test14ch.training.ClassificationTrainingApp', f'--epochs=40', '--malignant', '--dataset=MalignantLunaDataset',
    '--finetune=''D:/pytorchtest/data-unversioned/part2/models/p2ch14/cls_2022-06-27_21.59.28_nodule-nonnodule.best.state',
    '--finetune-depth=2',
    'finetune-depth2')