p3ch15 Add missing cpp, etc. files, update p2ch14 code

Author: elistevens

p2ch11/model.py

@@ -36,13 +36,17 @@ def _init_weights(self):
                 nn.ConvTranspose2d,
                 nn.ConvTranspose3d,
             }:
-                nn.init.kaiming_normal_(m.weight.data, a=0, mode='fan_out', nonlinearity='relu')
+                nn.init.kaiming_normal_(
+                    m.weight.data, a=0, mode='fan_out', nonlinearity='relu',
+                )
                 if m.bias is not None:
-                    fan_in, fan_out = nn.init._calculate_fan_in_and_fan_out(m.weight.data)
+                    fan_in, fan_out = \
+                        nn.init._calculate_fan_in_and_fan_out(m.weight.data)
                     bound = 1 / math.sqrt(fan_out)
                     nn.init.normal_(m.bias, -bound, bound)
 
 
+
     def forward(self, input_batch):
         bn_output = self.tail_batchnorm(input_batch)
 
@@ -64,9 +68,13 @@ class LunaBlock(nn.Module):
     def __init__(self, in_channels, conv_channels):
         super().__init__()
 
-        self.conv1 = nn.Conv3d(in_channels, conv_channels, kernel_size=3, padding=1, bias=True)
+        self.conv1 = nn.Conv3d(
+            in_channels, conv_channels, kernel_size=3, padding=1, bias=True,
+        )
         self.relu1 = nn.ReLU(inplace=True)
-        self.conv2 = nn.Conv3d(conv_channels, conv_channels, kernel_size=3, padding=1, bias=True)
+        self.conv2 = nn.Conv3d(
+            conv_channels, conv_channels, kernel_size=3, padding=1, bias=True,
+        )
         self.relu2 = nn.ReLU(inplace=True)
 
         self.maxpool = nn.MaxPool3d(2, 2)

p2ch14/check_nodule_fp_rate.py

@@ -413,13 +413,15 @@ def clusterSegmentationOutput(self, series_uid,  ct, clean_g):
         clean_a = clean_g.cpu().numpy()
         candidateLabel_a, candidate_count = measure.label(clean_a)
         centerIrc_list = measure.center_of_mass(
-            ct.hu_a + 1001,
+            ct.hu_a.clip(-1000, 1000) + 1001,
             labels=candidateLabel_a,
             index=list(range(1, candidate_count+1)),
         )
 
+
         candidateInfo_list = []
         for i, center_irc in enumerate(centerIrc_list):
+            assert np.isfinite(center_irc).all(), repr([series_uid, i, candidate_count, (ct.hu_a[candidateLabel_a == i+1]).sum(), center_irc])
             center_xyz = irc2xyz(
                 center_irc,
                 ct.origin_xyz,

p2ch14/dsets.py

@@ -381,12 +381,12 @@ def __len__(self):
 
     def __getitem__(self, ndx):
         if self.ratio_int:
-            if ndx % 4 < 2:
-                candidateInfo_tup = self.mal_list[(ndx // 3) % len(self.mal_list)]
-            elif ndx % 4 == 2:
-                candidateInfo_tup = self.ben_list[(ndx // 3) % len(self.ben_list)]
+            if ndx % 2 != 0:
+                candidateInfo_tup = self.mal_list[(ndx // 2) % len(self.mal_list)]
+            elif ndx % 4 == 0:
+                candidateInfo_tup = self.ben_list[(ndx // 4) % len(self.ben_list)]
             else:
-                candidateInfo_tup = self.neg_list[(ndx // 3) % len(self.neg_list)]
+                candidateInfo_tup = self.neg_list[(ndx // 4) % len(self.neg_list)]
         else:
             if ndx >= len(self.ben_list):
                 candidateInfo_tup = self.mal_list[ndx - len(self.ben_list)]

p2ch14/model.py

@@ -20,7 +20,7 @@ def augment3d(inp):
             if random.random() > 0.5:
                 transform_t[i,i] *= -1
         if True: #'offset' in augmentation_dict:
-            offset_float = 0.1 # 8 # augmentation_dict['offset']
+            offset_float = 0.1
             random_float = (random.random() * 2 - 1)
             transform_t[3,i] = offset_float * random_float
     if True:

p2ch14/nodule_analysis.py

@@ -31,16 +31,15 @@
 logging.getLogger("p2ch14.dsets").setLevel(logging.WARNING)
 
 def print_confusion(label, confusions, do_mal):
+    row_labels = ['Non-Nodules', 'Benign', 'Malignant']
+
     if do_mal:
-        col_labels = ['', 'Complete Miss', 'Filtered', 'Benign', 'Malignant']
-        row_labels = ['Non-Nodules', 'Benign', 'Malignant']
+        col_labels = ['', 'Complete Miss', 'Filtered Out', 'Pred. Benign', 'Pred. Malignant']
     else:
-        col_labels = ['', 'Complete Miss', 'Filtered', 'Detected']
-        row_labels = ['Non-Nodules', 'Nodules']
-        confusions[-2] += confusions[-1]
+        col_labels = ['', 'Complete Miss', 'Filtered Out', 'Pred. Nodule']
         confusions[:, -2] += confusions[:, -1]
-        confusions = confusions[:-1, :-1]
-    cell_width = 14
+        confusions = confusions[:, :-1]
+    cell_width = 16
     f = '{:>' + str(cell_width) + '}'
     print(label)
     print(' | '.join([f.format(s) for s in col_labels]))
@@ -72,7 +71,7 @@ def match_and_score(detections, truth, threshold=0.5, threshold_mal=0.5):
     confusion = np.zeros((3, 4), dtype=np.int)
     if len(detected_xyz) == 0:
         for tn in true_nodules:
-            confusiion[2 if tn.isMal_bool else 1, 0] += 1
+            confusion[2 if tn.isMal_bool else 1, 0] += 1
     elif len(truth_xyz) == 0:
         for dc in detected_classes:
             confusion[0, dc] += 1
@@ -124,7 +123,7 @@ def __init__(self, sys_argv=None):
         parser.add_argument('--segmentation-path',
             help="Path to the saved segmentation model",
             nargs='?',
-            default=None,
+            default='data/part2/models/seg_2020-01-26_19.45.12_w4d3c1-bal_1_nodupe-label_pos-d1_fn8-adam.best.state',
         )
 
         parser.add_argument('--cls-model',
@@ -135,13 +134,14 @@ def __init__(self, sys_argv=None):
         parser.add_argument('--classification-path',
             help="Path to the saved classification model",
             nargs='?',
-            default=None,
+            default='data/part2/models/cls_2020-02-06_14.16.55_final-nodule-nonnodule.best.state',
         )
 
         parser.add_argument('--malignancy-model',
             help="What to model class name to use for the malignancy classifier.",
             action='store',
-            default='ModifiedLunaModel',
+            default='LunaModel',
+            # default='ModifiedLunaModel',
         )
         parser.add_argument('--malignancy-path',
             help="Path to the saved malignancy classification model",
@@ -303,7 +303,6 @@ def main(self):
         val_list = sorted(series_set & val_set)
 
 
-        candidateInfo_list = []
         candidateInfo_dict = getCandidateInfoDict()
         series_iter = enumerateWithEstimate(
             val_list + train_list,
@@ -314,10 +313,8 @@ def main(self):
             ct = getCt(series_uid)
             mask_a = self.segmentCt(ct, series_uid)
 
-            candidateInfo_list = self.clusterSegmentationOutput(
-                series_uid,
-                ct,
-                mask_a,
+            candidateInfo_list = self.groupSegmentationOutput(
+                series_uid, ct, mask_a
             )
             classifications_list = self.classifyCandidates(ct, candidateInfo_list)
 
@@ -339,7 +336,6 @@ def main(self):
         print_confusion("Total", all_confusion, self.malignancy_model is not None)
 
 
-
     def classifyCandidates(self, ct, candidateInfo_list):
         cls_dl = self.initClassificationDl(candidateInfo_list)
         classifications_list = []
@@ -348,49 +344,50 @@ def classifyCandidates(self, ct, candidateInfo_list):
 
             input_g = input_t.to(self.device)
             with torch.no_grad():
-                _, probability_g = self.cls_model(input_g)
+                _, 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_g)
+                    probability_mal_g = torch.zeros_like(probability_nodule_g)
 
-            for center_irc, prob, prob_mal in zip(center_list,
-                                                  probability_g[:,1].tolist(),
-                                                  probability_mal_g[:,1].tolist()
-                                                  ):
+            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)
-                classifications_list.append((prob, prob_mal, center_xyz, center_irc))
+                    vxSize_xyz=ct.vxSize_xyz,
+                )
+                cls_tup = (prob_nodule, prob_mal, center_xyz, center_irc)
+                classifications_list.append(cls_tup)
         return classifications_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)
             for batch_tup in seg_dl:
-                input_t = batch_tup[0]
-                ndx_list = batch_tup[4]
+                input_t, label_t, series_list, slice_ndx_list = batch_tup
 
                 input_g = input_t.to(self.device)
                 prediction_g = self.seg_model(input_g)
 
-                for i, sample_ndx in enumerate(ndx_list):
-                    output_a[sample_ndx] = prediction_g[i].cpu().numpy()
+                for i, slice_ndx in enumerate(slice_ndx_list):
+                    output_a[slice_ndx] = prediction_g[i].cpu().numpy()
 
-            # mask_a = output_a > 0.25
             mask_a = output_a > 0.5
-            # mask_a = morphology.binary_erosion(mask_a, iterations=1)
-            # mask_a = morphology.binary_dilation(mask_a, iterations=2)
+            mask_a = morphology.binary_erosion(mask_a, iterations=1)
 
         return mask_a
 
-    def clusterSegmentationOutput(self, series_uid,  ct, clean_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 + 1001,
+            ct.hu_a.clip(-1000, 1000) + 1001,
             labels=candidateLabel_a,
             index=np.arange(1, candidate_count+1),
         )

p2ch14/training.py

@@ -6,6 +6,7 @@
 import sys
 
 import numpy as np
+from matplotlib import pyplot
 
 from torch.utils.tensorboard import SummaryWriter
 
@@ -121,11 +122,19 @@ def initModel(self):
 
         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]
+            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(d['model_state'])
+            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,
+            )
             for n, p in model.named_parameters():
                 if n.split('.')[0] not in finetune_blocks:
                     p.requires_grad_(False)
@@ -138,7 +147,7 @@ def initModel(self):
 
     def initOptimizer(self):
         lr = 0.003 if self.cli_args.finetune else 0.001
-        return SGD(self.model.parameters(), weight_decay=1e-4, lr=lr)
+        return SGD(self.model.parameters(), lr=lr, weight_decay=1e-4)
         #return Adam(self.model.parameters(), lr=3e-4)
 
     def initTrainDl(self):
@@ -398,12 +407,21 @@ def logMetrics(
         metrics_dict['pr/f1_score'] = \
             2 * (precision * recall) / (precision + recall)
 
+        threshold = torch.linspace(1, 0)
+        tpr = (metrics_t[None, METRICS_PRED_P_NDX, posLabel_mask] >= threshold[:, None]).sum(1).float() / pos_count
+        fpr = (metrics_t[None, METRICS_PRED_P_NDX, negLabel_mask] >= threshold[:, None]).sum(1).float() / neg_count
+        fp_diff = fpr[1:]-fpr[:-1]
+        tp_avg  = (tpr[1:]+tpr[:-1])/2
+        auc = (fp_diff * tp_avg).sum()
+        metrics_dict['auc'] = auc
+
         log.info(
             ("E{} {:8} {loss/all:.4f} loss, "
                  + "{correct/all:-5.1f}% correct, "
                  + "{pr/precision:.4f} precision, "
                  + "{pr/recall:.4f} recall, "
-                 + "{pr/f1_score:.4f} f1 score"
+                 + "{pr/f1_score:.4f} f1 score, "
+                 + "{auc:.4f} auc"
             ).format(
                 epoch_ndx,
                 mode_str,
@@ -461,6 +479,11 @@ def logMetrics(
             key = key.replace('neg', neg)
             writer.add_scalar(key, value, self.totalTrainingSamples_count)
 
+        fig = pyplot.figure()
+        pyplot.plot(fpr, tpr)
+        writer.add_figure('roc', fig, self.totalTrainingSamples_count)
+
+        writer.add_scalar('auc', auc, self.totalTrainingSamples_count)
 # # tag::logMetrics_writer_prcurve[]
 #        writer.add_pr_curve(
 #            'pr',
@@ -485,7 +508,10 @@ def logMetrics(
             bins=bins
         )
 
-        score = metrics_dict['pr/f1_score']
+        if not self.cli_args.malignant:
+            score = metrics_dict['pr/f1_score']
+        else:
+            score = metrics_dict['auc']
 
         return score
 

p3ch15/CMakeLists.txt

@@ -0,0 +1,27 @@
+cmake_minimum_required(VERSION 3.0 FATAL_ERROR)
+project(cyclegan-jit)
+
+find_package(Torch REQUIRED)
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${TORCH_CXX_FLAGS}")
+
+add_executable(cyclegan-jit cyclegan_jit.cpp)
+target_link_libraries(cyclegan-jit pthread jpeg X11)
+target_link_libraries(cyclegan-jit "${TORCH_LIBRARIES}")
+set_property(TARGET cyclegan-jit PROPERTY CXX_STANDARD 14)
+
+add_executable(cyclegan-cpp-api cyclegan_cpp_api.cpp)
+target_link_libraries(cyclegan-cpp-api pthread jpeg X11)
+target_link_libraries(cyclegan-cpp-api "${TORCH_LIBRARIES}")
+set_property(TARGET cyclegan-cpp-api PROPERTY CXX_STANDARD 14)
+
+# The following code block is suggested to be used on Windows.
+# According to https://github.com/pytorch/pytorch/issues/25457,
+# the DLLs need to be copied to avoid memory errors.
+if (MSVC)
+  file(GLOB TORCH_DLLS "${TORCH_INSTALL_PREFIX}/lib/*.dll")
+  add_custom_command(TARGET cyclegan-jit
+                     POST_BUILD
+                     COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                     ${TORCH_DLLS}
+                     $<TARGET_FILE_DIR:example-app>)
+endif (MSVC)