발표자: 김준호(Lunit) 발표일: 2018.1. 의료 AI 관련 중, nodule detection 문제에 대해 다뤄보고자 합니다. 의료 AI에서는 어떠한 방식으로 classication을 하고, preprocessing은 어떤식으로 진행되는지 LUNA16이라는 의료 challenge에 이용되는 데이터를 가지고 발표를 진행해보고자 합니다. 이후, 이 데이터를 이용해서 최근 2017 MICCAI (의료 영상학회에서는 높은 수준의 학회)에서 발표된 "curriculum adaptive sampling for extreme data imbalance"를 실제 구현해서 적용해보고 이 때 발생할 수 있는 문제를 어떤식으로 해결할 수 있는지에 대한 tip도 제공할 예정입니다. (Python multi-processing data load, input-pipeline) 위 논문을 선정한 이유는, 단순한 classification이 아닌, nodule이 있는 위치도 정확하게 catch하는 논문 중, performance가 상당히 높기 때문입니다.

1. 밑바닥부터 시작하는 의료AI
루닛 (Lunit)
김준호
https://github.com/taki0112

2. 2

3. 3

4. 4

5. 5






6. 6

7. 7

8. 8

9. 9

10. 10

11. 11

12. 12

13. 13

14. 14

15. 15

16. 16

17. 17

18. 18

19. 19
def read_csv(filename):
lines = []
with open(filename, 'r') as f:
csvreader = csv.reader(f)
for line in csvreader:
lines.append(line)
lines = lines[1:] # remove csv headers
annotations_dict = {}
for i in lines:
series_uid, x, y, z, diameter = i
value = {'position':[float(x),float(y),float(z)],
'diameter':float(diameter)}
if series_uid in annotations_dict.keys():
annotations_dict[series_uid].append(value)
else:
annotations_dict[series_uid] = [value]
return annotations_dict

20. 20

21. 21

22. 22
def load_itk_image(filename):
itkimage = sitk.ReadImage(filename)
numpyImage = sitk.GetArrayFromImage(itkimage)
numpyOrigin = np.array(list(reversed(itkimage.GetOrigin())))
numpySpacing = np.array(list(reversed(itkimage.GetSpacing())))
return numpyImage, numpyOrigin, numpySpacing

23. 23
def load_itk_image(filename):
itkimage = sitk.ReadImage(filename)
numpyImage = sitk.GetArrayFromImage(itkimage)
numpyOrigin = np.array(list(reversed(itkimage.GetOrigin())))
numpySpacing = np.array(list(reversed(itkimage.GetSpacing())))
return numpyImage, numpyOrigin, numpySpacing

24. 24
def load_itk_image(filename):
itkimage = sitk.ReadImage(filename)
numpyImage = sitk.GetArrayFromImage(itkimage)
numpyOrigin = np.array(list(reversed(itkimage.GetOrigin())))
numpySpacing = np.array(list(reversed(itkimage.GetSpacing())))
return numpyImage, numpyOrigin, numpySpacing

25. 25
def load_itk_image(filename):
itkimage = sitk.ReadImage(filename)
numpyImage = sitk.GetArrayFromImage(itkimage)
numpyOrigin = np.array(list(reversed(itkimage.GetOrigin())))
numpySpacing = np.array(list(reversed(itkimage.GetSpacing())))
return numpyImage, numpyOrigin, numpySpacing
def load_itk_image(filename):
itkimage = sitk.ReadImage(filename)
numpyImage = np.transpose(sitk.GetArrayFromImage(itkimage))
numpyOrigin = np.array(itkimage.GetOrigin())
numpySpacing = np.array(itkimage.GetSpacing())
return numpyImage, numpyOrigin, numpySpacing

26. 26
def load_itk_image(filename):
itkimage = sitk.ReadImage(filename)
numpyImage = sitk.GetArrayFromImage(itkimage)
numpyOrigin = np.array(list(reversed(itkimage.GetOrigin())))
numpySpacing = np.array(list(reversed(itkimage.GetSpacing())))
return numpyImage, numpyOrigin, numpySpacing
def load_itk_image(filename):
itkimage = sitk.ReadImage(filename)
numpyImage = np.transpose(sitk.GetArrayFromImage(itkimage))
numpyOrigin = np.array(itkimage.GetOrigin())
numpySpacing = np.array(itkimage.GetSpacing())
return numpyImage, numpyOrigin, numpySpacing

27. 27

28. 28

29. 29

30. 30

31. 31

32. 32

33. 33

34. 34
def resample(image, org_spacing, new_spacing=OUTPUT_SPACING):
resize_factor = org_spacing / new_spacing
new_real_shape = image.shape * resize_factor
new_shape = np.round(new_real_shape)
image = scipy.ndimage.interpolation.zoom(image, real_resize_factor, mode='nearest')
return image

35. 35
def resample(image, org_spacing, new_spacing=OUTPUT_SPACING):
resize_factor = org_spacing / new_spacing
new_real_shape = image.shape * resize_factor
new_shape = np.round(new_real_shape)
image = scipy.ndimage.interpolation.zoom(image, real_resize_factor, mode='nearest')
return image

36. 36
def resample(image, org_spacing, new_spacing=OUTPUT_SPACING):
resize_factor = org_spacing / new_spacing
new_real_shape = image.shape * resize_factor
new_shape = np.round(new_real_shape)
image = scipy.ndimage.interpolation.zoom(image, real_resize_factor, mode='nearest')
return image

37. 37
def resample(image, org_spacing, new_spacing=OUTPUT_SPACING):
resize_factor = org_spacing / new_spacing
new_real_shape = image.shape * resize_factor
new_shape = np.round(new_real_shape)
image = scipy.ndimage.interpolation.zoom(image, real_resize_factor, mode='nearest')
return image

38. 38
def resample(image, org_spacing, new_spacing=OUTPUT_SPACING):
resize_factor = org_spacing / new_spacing
new_real_shape = image.shape * resize_factor
new_shape = np.round(new_real_shape)
image = scipy.ndimage.interpolation.zoom(image, real_resize_factor, mode='nearest')
return image

39. 39
def resample(image, org_spacing, new_spacing=OUTPUT_SPACING):
resize_factor = org_spacing / new_spacing
new_real_shape = image.shape * resize_factor
new_shape = np.round(new_real_shape)
image = scipy.ndimage.interpolation.zoom(image, real_resize_factor, mode='nearest')
return image

40. 40

41. 41

42. 42

43. 43

44. 44

45. 45
def normalize_planes(npzarray):
maxHU = 400.
minHU = -1000.
npzarray = (npzarray - minHU) / (maxHU - minHU)
npzarray[npzarray > 1] = 1.
npzarray[npzarray < 0] = 0.
return npzarray

46. 46
def normalize_planes(npzarray):
maxHU = 400.
minHU = -1000.
npzarray = (npzarray - minHU) / (maxHU - minHU)
npzarray[npzarray > 1] = 1.
npzarray[npzarray < 0] = 0.
return npzarray
def zero_center(image):
PIXEL_MEAN = 0.25
image = image - PIXEL_MEAN
return image

47. 47

48. 48

49. 49

50. 50

51. 51
def load_itk_image(filename):
…
return numpyImage, numpyOrigin, numpySpacing
def read_csv(filename):
…
return annotations_dict
OUTPUT_SPACING = [1.25, 1.25, 1.25]

52. 52
def load_itk_image(filename):
…
return numpyImage, numpyOrigin, numpySpacing
def read_csv(filename):
…
return annotations_dict
OUTPUT_SPACING = [1.25, 1.25, 1.25]

53. 53
def load_itk_image(filename):
…
return numpyImage, numpyOrigin, numpySpacing
def world_2_voxel(world_coord, origin, spacing):
stretched_voxel_coord = np.absolute(world_coord - origin)
voxel_coord = stretched_voxel_coord / spacing
return voxel_coord
def read_csv(filename):
…
return annotations_dict
OUTPUT_SPACING = [1.25, 1.25, 1.25]

54. 54
def load_itk_image(filename):
…
return numpyImage, numpyOrigin, numpySpacing
def world_2_voxel(world_coord, origin, spacing):
stretched_voxel_coord = np.absolute(world_coord - origin)
voxel_coord = stretched_voxel_coord / spacing
return voxel_coord
def read_csv(filename):
…
return annotations_dict
OUTPUT_SPACING = [1.25, 1.25, 1.25]

55. 55
def load_itk_image(filename):
…
return numpyImage, numpyOrigin, numpySpacing
def world_2_voxel(world_coord, origin, spacing):
stretched_voxel_coord = np.absolute(world_coord - origin)
voxel_coord = stretched_voxel_coord / spacing
return voxel_coord
def read_csv(filename):
…
return annotations_dict
OUTPUT_SPACING = [1.25, 1.25, 1.25]

56. 56
def create_label(arr_shape, nodules, new_spacing, coord=False):
# nodules = list of dict {‘position’, ‘diameter}
for nodule in nodules:
worldCoord = nodule['position']
worldCoord = np.asarray([worldCoord[2],worldCoord[1],worldCoord[0]])
# new_spacing came from resample
voxelCoord = word_2_voxel(worldCoord, origin, new_spacing)
voxelCoord = [int(i) for i in voxelCoord]
diameter = nodule['diameter']
diameter = diameter / new_spacing[1]
label = _create_mask(arr_shape, voxelCoord, diameter)
return label

57. 57
def create_label(arr_shape, nodules, new_spacing, coord=False):
# nodules = list of dict {‘position’, ‘diameter}
for nodule in nodules:
worldCoord = nodule['position']
worldCoord = np.asarray([worldCoord[2],worldCoord[1],worldCoord[0]])
# new_spacing came from resample
voxelCoord = word_2_voxel(worldCoord, origin, new_spacing)
voxelCoord = [int(i) for i in voxelCoord]
diameter = nodule['diameter']
diameter = diameter / new_spacing[1]
label = _create_mask(arr_shape, voxelCoord, diameter)
return label

58. 58
def create_label(arr_shape, nodules, new_spacing, coord=False):
# nodules = list of dict {‘position’, ‘diameter}
for nodule in nodules:
worldCoord = nodule['position']
worldCoord = np.asarray([worldCoord[2],worldCoord[1],worldCoord[0]])
# new_spacing came from resample
voxelCoord = word_2_voxel(worldCoord, origin, new_spacing)
voxelCoord = [int(i) for i in voxelCoord]
diameter = nodule['diameter']
diameter = diameter / new_spacing[1]
label = _create_mask(arr_shape, voxelCoord, diameter)
return label

59. 59
def create_label(arr_shape, nodules, new_spacing, coord=False):
# nodules = list of dict {‘position’, ‘diameter}
for nodule in nodules:
worldCoord = nodule['position']
worldCoord = np.asarray([worldCoord[2],worldCoord[1],worldCoord[0]])
# new_spacing came from resample
voxelCoord = word_2_voxel(worldCoord, origin, new_spacing)
voxelCoord = [int(i) for i in voxelCoord]
diameter = nodule['diameter']
diameter = diameter / new_spacing[1]
label = _create_mask(arr_shape, voxelCoord, diameter)
return label

60. 60
def _create_mask(arr_shape, position, diameter):
z_dim, y_dim, x_dim = arr_shape
z_pos, y_pos, x_pos = position
z,y,x = np.ogrid[-z_pos:z_dim-z_pos,
-y_pos:y_dim-y_pos,
-x_pos:x_dim-x_pos]
mask = z**2 + y**2 + x**2 <= int(diameter//2)**2
return mask
def create_label(arr_shape, nodules, new_spacing, coord=False):
# nodules = list of dict {‘position’, ‘diameter}
for nodule in nodules:
worldCoord = nodule['position']
worldCoord = np.asarray([worldCoord[2],worldCoord[1],worldCoord[0]])
# new_spacing came from resample
voxelCoord = word_2_voxel(worldCoord, origin, new_spacing)
voxelCoord = [int(i) for i in voxelCoord]
diameter = nodule['diameter']
diameter = diameter / new_spacing[1]
label = _create_mask(arr_shape, voxelCoord, diameter)
return label

61. 61
def _create_mask(arr_shape, position, diameter):
z_dim, y_dim, x_dim = arr_shape
z_pos, y_pos, x_pos = position
z,y,x = np.ogrid[-z_pos:z_dim-z_pos,
-y_pos:y_dim-y_pos,
-x_pos:x_dim-x_pos]
mask = z**2 + y**2 + x**2 <= int(diameter//2)**2
return mask
def create_label(arr_shape, nodules, new_spacing, coord=False):
# nodules = list of dict {‘position’, ‘diameter}
for nodule in nodules:
worldCoord = nodule['position']
worldCoord = np.asarray([worldCoord[2],worldCoord[1],worldCoord[0]])
# new_spacing came from resample
voxelCoord = word_2_voxel(worldCoord, origin, new_spacing)
voxelCoord = [int(i) for i in voxelCoord]
diameter = nodule['diameter']
diameter = diameter / new_spacing[1]
label = _create_mask(arr_shape, voxelCoord, diameter)
return label
-2 -1 x 1 2

62. 62
def _create_mask(arr_shape, position, diameter):
z_dim, y_dim, x_dim = arr_shape
z_pos, y_pos, x_pos = position
z,y,x = np.ogrid[-z_pos:z_dim-z_pos,
-y_pos:y_dim-y_pos,
-x_pos:x_dim-x_pos]
mask = z**2 + y**2 + x**2 <= int(diameter//2)**2
return mask
False True x True False
def create_label(arr_shape, nodules, new_spacing, coord=False):
# nodules = list of dict {‘position’, ‘diameter}
for nodule in nodules:
worldCoord = nodule['position']
worldCoord = np.asarray([worldCoord[2],worldCoord[1],worldCoord[0]])
# new_spacing came from resample
voxelCoord = word_2_voxel(worldCoord, origin, new_spacing)
voxelCoord = [int(i) for i in voxelCoord]
diameter = nodule['diameter']
diameter = diameter / new_spacing[1]
label = _create_mask(arr_shape, voxelCoord, diameter)
return label

63. 63
def _create_mask(arr_shape, position, diameter):
z_dim, y_dim, x_dim = arr_shape
z_pos, y_pos, x_pos = position
z,y,x = np.ogrid[-z_pos:z_dim-z_pos,
-y_pos:y_dim-y_pos,
-x_pos:x_dim-x_pos]
mask = z**2 + y**2 + x**2 <= int(diameter//2)**2
return mask
False True x True False
def create_label(arr_shape, nodules, new_spacing, coord=False):
# nodules = list of dict {‘position’, ‘diameter}
for nodule in nodules:
worldCoord = nodule['position']
worldCoord = np.asarray([worldCoord[2],worldCoord[1],worldCoord[0]])
# new_spacing came from resample
voxelCoord = word_2_voxel(worldCoord, origin, new_spacing)
voxelCoord = [int(i) for i in voxelCoord]
diameter = nodule['diameter']
diameter = diameter / new_spacing[1]
label = _create_mask(arr_shape, voxelCoord, diameter)
return label

64. 64

65. 65

66. 66

67. 67

68. 68

69. 69

70. 70

71. 71

72. 72

73. 73

74. 74
offset = patch_size // 2
image = np.pad(image, offset, 'constant', constant_values=np.min(image))

75. 75
offset = patch_size // 2
image = np.pad(image, offset, 'constant', constant_values=np.min(image))

76. 76
offset = patch_size // 2
image = np.pad(image, offset, 'constant', constant_values=np.min(image))

77. 77
offset = patch_size // 2
image = np.pad(image, offset, 'constant', constant_values=np.min(image))

78. 78
offset = patch_size // 2
image = np.pad(image, offset, 'constant', constant_values=np.min(image))

79. 79
offset = patch_size // 2
image = np.pad(image, offset, 'constant', constant_values=np.min(image))

80. 80
offset = patch_size // 2
stride = 8
move = offset // stride
image = np.pad(image, offset + (stride * move), 'constant', constant_values=np.min(image))

81. 81
offset = patch_size // 2
stride = 8
move = offset // stride
image = np.pad(image, offset + (stride * move), 'constant', constant_values=np.min(image))

82. 82
offset = patch_size // 2
stride = 8
move = offset // stride
image = np.pad(image, offset + (stride * move), 'constant', constant_values=np.min(image))

83. 83
offset = patch_size // 2
stride = 8
move = offset // stride
image = np.pad(image, offset + (stride * move), 'constant', constant_values=np.min(image))

84. 84
offset = patch_size // 2
stride = 8
move = offset // stride
image = np.pad(image, offset + (stride * move), 'constant', constant_values=np.min(image))

85. 85

86. 86

87. 87

88. 88

89. 89

90. 90
with h5py.File(save_path + 'subset' + str(i) + '.h5', 'w') as hf:
hf.create_dataset('nodule', data=nodule[:], compression='lzf')
hf.create_dataset('label_nodule', data=nodule_label[:], compression='lzf')
hf.create_dataset('non_nodule', data=non_nodule[:], compression='lzf')
hf.create_dataset('label_non_nodule', data=non_nodule_label[:], compression='lzf')

91. 91

92. 92

93. 93

94. 94

95. 95
import tftables
import tensorflow as tf
def input_transform(tbl_batch):
labels = tbl_batch['nodule_label']
data = tbl_batch['nodule']
return labels, data
loader = tftables.load_dataset(filename='/data/LUNA16/subset1.h5',
dataset_path='/internal/h5/path',
input_transform=input_transform,
queue_size=256,
batch_size=16)
truth_batch, data_batch = loader.dequeue()
result = CASED(truth_batch, data_batch)
with tf.Session() as sess:
with loader.begin(sess):
for _ in range(num_iterations):
sess.run(result)

96. 96
import tftables
import tensorflow as tf
def input_transform(tbl_batch):
labels = tbl_batch['nodule_label']
data = tbl_batch['nodule']
return labels, data
loader = tftables.load_dataset(filename='/data/LUNA16/subset1.h5',
dataset_path='/internal/h5/path',
input_transform=input_transform,
queue_size=256,
batch_size=16)
truth_batch, data_batch = loader.dequeue()
result = CASED(truth_batch, data_batch)
with tf.Session() as sess:
with loader.begin(sess):
for _ in range(num_iterations):
sess.run(result)

97. 97
import tftables
import tensorflow as tf
def input_transform(tbl_batch):
labels = tbl_batch['nodule_label']
data = tbl_batch['nodule']
return labels, data
loader = tftables.load_dataset(filename='/data/LUNA16/subset1.h5',
dataset_path='/internal/h5/path',
input_transform=input_transform,
queue_size=256,
batch_size=16)
truth_batch, data_batch = loader.dequeue()
result = CASED(truth_batch, data_batch)
with tf.Session() as sess:
with loader.begin(sess):
for _ in range(num_iterations):
sess.run(result)

98. 98
import tftables
import tensorflow as tf
def input_transform(tbl_batch):
labels = tbl_batch['nodule_label']
data = tbl_batch['nodule']
return labels, data
loader = tftables.load_dataset(filename='/data/LUNA16/subset1.h5',
dataset_path='/internal/h5/path',
input_transform=input_transform,
queue_size=256,
batch_size=16)
truth_batch, data_batch = loader.dequeue()
result = CASED(truth_batch, data_batch)
with tf.Session() as sess:
with loader.begin(sess):
for _ in range(num_iterations):
sess.run(result)

99. 99
import tftables
import tensorflow as tf
def input_transform(tbl_batch):
labels = tbl_batch['nodule_label']
data = tbl_batch['nodule']
return labels, data
loader = tftables.load_dataset(filename='/data/LUNA16/subset1.h5',
dataset_path='/internal/h5/path',
input_transform=input_transform,
queue_size=256,
batch_size=16)
truth_batch, data_batch = loader.dequeue()
result = CASED(truth_batch, data_batch)
with tf.Session() as sess:
with loader.begin(sess):
for _ in range(num_iterations):
sess.run(result)

100. 100
import tftables
import tensorflow as tf
def input_transform(tbl_batch):
labels = tbl_batch['nodule_label']
data = tbl_batch['nodule']
return labels, data
loader = tftables.load_dataset(filename='/data/LUNA16/subset1.h5',
dataset_path='/internal/h5/path',
input_transform=input_transform,
queue_size=256,
batch_size=16)
truth_batch, data_batch = loader.dequeue()
result = CASED(truth_batch, data_batch)
with tf.Session() as sess:
with loader.begin(sess):
for _ in range(num_iterations):
sess.run(result)

101. 101

102. 102

103. 103

104. 104

105. 105

106. 106

107. 107

108. 108

109. 109

110. 110

111. 111

112. 112
x = scipy.ndimage.zoom(input=x, zoom=1/8, order=1) # nearest
x = np.where(x > 0, 1.0, 0.0)

113. 113
x = scipy.ndimage.zoom(input=x, zoom=1/8, order=1) # nearest
x = np.where(x > 0, 1.0, 0.0)

114. 114
x = scipy.ndimage.zoom(input=x, zoom=1/8, order=1) # nearest
x = np.where(x > 0, 1.0, 0.0)
x = skimage.measure.block_reduce(x, (9, 9, 9), np.max)

115. 115
x = scipy.ndimage.zoom(input=x, zoom=1/8, order=1) # nearest
x = np.where(x > 0, 1.0, 0.0)
x = skimage.measure.block_reduce(x, (9, 9, 9), np.max)

116. 116

117. 117

118. 118
𝒈 𝒏

119. 119
𝒈 𝒏
𝒈 𝒓

120. 120
𝒈 𝒏
𝒈 𝒓

121. 121
𝒈 𝒏
𝒈 𝒓

122. 122
𝒈 𝒏
𝒈 𝒓

123. 123
𝒈 𝒏
𝒈 𝒓

124. 124
𝒈 𝒓
𝒈 𝒏

125. 125
𝒈 𝒓
𝒈 𝒏

126. 126
𝒈 𝒓
𝒈 𝒏

127. 127
𝒈 𝒓
𝒈 𝒏

128. 128
𝒈 𝒏
𝒈 𝒓

129. 129
𝒈 𝒏
𝒈 𝒓
p_x = 1.0
for i in iteration :
p = uniform(0,1)
if p <= p_x :
# only nodule patch
g_n_index = np.random.choice(N, size=batch_size, replace=False)
batch_patch = nodule_patch[g_n_index]
batch_y = nodule_patch_y[g_n_index]
else :
# all patch
predictor_dict = Predictor(all_patch) # key = index, value = loss
g_r_index = nlargest(batch_size, predictor_dict, key=predictor_dict.get)
batch_patch = all_patch[g_r_index]
batch_y = all_patch_y[g_r_index]
p_x *= pow(1/M, 1/iteration) # p_x -> 0

130. 130

131. 131

132. 132

133. 133
CASED

134. 134
CASED OUTPUT

135. 135
CASED OUTPUT

136. 136
CASED OUTPUT

137. 137
CASED OUTPUT

138. 138
CASED OUTPUT

139. 139

140. 140
exclude.csv

141. 141
exclude.csv

142. 142
exclude.csv

143. 143
exclude.csv

144. 144
exclude.csv

145. 145
exclude.csv
def fp_per_scan(logit, label) :
fp_list = [0.125, 0.25, 0.5, 1, 2, 4, 8]
MIN_FROC = 0.125
MAX_FROC = 8
logit = np.reshape(logit, -1)
label = np.reshape(label, -1)
fpr, tpr, th = roc_curve(label, logit, pos_label=1.0)
fps = fpr * negative_samples
fps_itp = np.linspace(MIN_FROC, MAX_FROC, num=64)
sens_itp = np.interp(fps_itp, fps, tpr)

146. 146
exclude.csv
def fp_per_scan(logit, label) :
fp_list = [0.125, 0.25, 0.5, 1, 2, 4, 8]
MIN_FROC = 0.125
MAX_FROC = 8
logit = np.reshape(logit, -1)
label = np.reshape(label, -1)
fpr, tpr, th = roc_curve(label, logit, pos_label=1.0)
fps = fpr * negative_samples
fps_itp = np.linspace(MIN_FROC, MAX_FROC, num=64)
sens_itp = np.interp(fps_itp, fps, tpr)

147. 147

148. 148

149. 149

150. 150

151. 151

152. 152

153. 153

154. 154

155. 155

156. 156

157. 157

158. 158

159. 159

160. 160

161. 161

162. 162

163. 163

164. 164

165. 165

166. 166

167. 167

168. 168

169. 169
from multiprocessing import Pool
def nodule_hf(idx):
with h5py.File(image_patch, 'r') as hf:
nodule = hf['nodule'][idx:idx + get_data_num]
return nodule
process_num = 32
get_data_num = 64
with h5py.File(image_patch, 'r') as fin:
nodule_range = range(0, len(fin['nodule']), get_data_num)
pool = Pool(processes = process_num)
pool_nodule = pool.map(nodule_hf, nodule_range)
pool.close()

170. 170
from multiprocessing import Pool
def nodule_hf(idx):
with h5py.File(image_patch, 'r') as hf:
nodule = hf['nodule'][idx:idx + get_data_num]
return nodule
process_num = 32
get_data_num = 64
with h5py.File(image_patch, 'r') as fin:
nodule_range = range(0, len(fin['nodule']), get_data_num)
pool = Pool(processes = process_num)
pool_nodule = pool.map(nodule_hf, nodule_range)
pool.close()

171. 171
from multiprocessing import Pool
def nodule_hf(idx):
with h5py.File(image_patch, 'r') as hf:
nodule = hf['nodule'][idx:idx + get_data_num]
return nodule
process_num = 32
get_data_num = 64
with h5py.File(image_patch, 'r') as fin:
nodule_range = range(0, len(fin['nodule']), get_data_num)
pool = Pool(processes = process_num)
pool_nodule = pool.map(nodule_hf, nodule_range)
pool.close()

172. 172
from multiprocessing import Pool
def nodule_hf(idx):
with h5py.File(image_patch, 'r') as hf:
nodule = hf['nodule'][idx:idx + get_data_num]
return nodule
process_num = 32
get_data_num = 64
with h5py.File(image_patch, 'r') as fin:
nodule_range = range(0, len(fin['nodule']), get_data_num)
pool = Pool(processes = process_num)
pool_nodule = pool.map(nodule_hf, nodule_range)
pool.close()

173. 173
from multiprocessing import Pool
def nodule_hf(idx):
with h5py.File(image_patch, 'r') as hf:
nodule = hf['nodule'][idx:idx + get_data_num]
return nodule
process_num = 32
get_data_num = 64
with h5py.File(image_patch, 'r') as fin:
nodule_range = range(0, len(fin['nodule']), get_data_num)
pool = Pool(processes = process_num)
pool_nodule = pool.map(nodule_hf, nodule_range)
pool.close()

174. 174
from multiprocessing import Pool
def nodule_hf(idx):
with h5py.File(image_patch, 'r') as hf:
nodule = hf['nodule'][idx:idx + get_data_num]
return nodule
process_num = 32
get_data_num = 64
with h5py.File(image_patch, 'r') as fin:
nodule_range = range(0, len(fin['nodule']), get_data_num)
pool = Pool(processes = process_num)
pool_nodule = pool.map(nodule_hf, nodule_range)
pool.close()

175. 175
from multiprocessing import Pool
def nodule_hf(idx):
with h5py.File(image_patch, 'r') as hf:
nodule = hf['nodule'][idx:idx + get_data_num]
return nodule
process_num = 32
get_data_num = 64
with h5py.File(image_patch, 'r') as fin:
nodule_range = range(0, len(fin['nodule']), get_data_num)
pool = Pool(processes = process_num)
pool_nodule = pool.map(nodule_hf, nodule_range)
pool.close()

176. 176
from multiprocessing import Pool
def nodule_hf(idx):
with h5py.File(image_patch, 'r') as hf:
nodule = hf['nodule'][idx:idx + get_data_num]
return nodule
process_num = 32
get_data_num = 64
with h5py.File(image_patch, 'r') as fin:
nodule_range = range(0, len(fin['nodule']), get_data_num)
pool = Pool(processes = process_num)
pool_nodule = pool.map(nodule_hf, nodule_range)
pool.close()

177. 177
from multiprocessing import Pool
def nodule_hf(idx):
with h5py.File(image_patch, 'r') as hf:
nodule = hf['nodule'][idx:idx + get_data_num]
return nodule
process_num = 32
get_data_num = 64
with h5py.File(image_patch, 'r') as fin:
nodule_range = range(0, len(fin['nodule']), get_data_num)
pool = Pool(processes = process_num)
pool_nodule = pool.map(nodule_hf, nodule_range)
pool.close()

178. 178
from multiprocessing import Pool
def nodule_hf(idx):
with h5py.File(image_patch, 'r') as hf:
nodule = hf['nodule'][idx:idx + get_data_num]
return nodule
process_num = 32
get_data_num = 64
with h5py.File(image_patch, 'r') as fin:
nodule_range = range(0, len(fin['nodule']), get_data_num)
pool = Pool(processes = process_num)
pool_nodule = pool.map(nodule_hf, nodule_range)
pool.close()