├── Industry Demo Using CNNs with Flowers Images
    └── resnet.py
└── Industry Demo Using CNNs with X-ray Images
    ├── resnet.py
    └── Working_With_Chest_XRay_Images-.ipynb


/Industry Demo Using CNNs with Flowers Images/resnet.py:
--------------------------------------------------------------------------------
  1 | import six
  2 | from tensorflow.keras.models import Model
  3 | from tensorflow.keras.layers import (
  4 |     Input,
  5 |     Activation,
  6 |     Dense,
  7 |     Flatten,
  8 |     add,
  9 |     BatchNormalization,
 10 |     Conv2D,
 11 |     MaxPooling2D,
 12 |     AveragePooling2D
 13 | )
 14 | 
 15 | from tensorflow.keras.regularizers import l2
 16 | from tensorflow.keras import backend as K
 17 | 
 18 | 
 19 | def _bn_relu(input):
 20 |     """Helper to build a BN -> relu block
 21 |     """
 22 |     norm = BatchNormalization(axis=CHANNEL_AXIS)(input)
 23 |     return Activation("relu")(norm)
 24 | 
 25 | 
 26 | def _conv_bn_relu(**conv_params):
 27 |     """Helper to build a conv -> BN -> relu block
 28 |     """
 29 |     filters = conv_params["filters"]
 30 |     kernel_size = conv_params["kernel_size"]
 31 |     strides = conv_params.setdefault("strides", (1, 1))
 32 |     kernel_initializer = conv_params.setdefault("kernel_initializer", "he_normal")
 33 |     padding = conv_params.setdefault("padding", "same")
 34 |     kernel_regularizer = conv_params.setdefault("kernel_regularizer", l2(1.e-4))
 35 | 
 36 |     def f(input):
 37 |         conv = Conv2D(filters=filters, kernel_size=kernel_size,
 38 |                       strides=strides, padding=padding,
 39 |                       kernel_initializer=kernel_initializer,
 40 |                       kernel_regularizer=kernel_regularizer)(input)
 41 |         return _bn_relu(conv)
 42 | 
 43 |     return f
 44 | 
 45 | 
 46 | def _bn_relu_conv(**conv_params):
 47 |     """Helper to build a BN -> relu -> conv block.
 48 |     This is an improved scheme proposed in http://arxiv.org/pdf/1603.05027v2.pdf
 49 |     """
 50 |     filters = conv_params["filters"]
 51 |     kernel_size = conv_params["kernel_size"]
 52 |     strides = conv_params.setdefault("strides", (1, 1))
 53 |     kernel_initializer = conv_params.setdefault("kernel_initializer", "he_normal")
 54 |     padding = conv_params.setdefault("padding", "same")
 55 |     kernel_regularizer = conv_params.setdefault("kernel_regularizer", l2(1.e-4))
 56 | 
 57 |     def f(input):
 58 |         activation = _bn_relu(input)
 59 |         return Conv2D(filters=filters, kernel_size=kernel_size,
 60 |                       strides=strides, padding=padding,
 61 |                       kernel_initializer=kernel_initializer,
 62 |                       kernel_regularizer=kernel_regularizer)(activation)
 63 | 
 64 |     return f
 65 | 
 66 | 
 67 | def _shortcut(input, residual):
 68 |     """Adds a shortcut between input and residual block and merges them with "sum"
 69 |     """
 70 |     # Expand channels of shortcut to match residual.
 71 |     # Stride appropriately to match residual (width, height)
 72 |     # Should be int if network architecture is correctly configured.
 73 |     input_shape = K.int_shape(input)
 74 |     residual_shape = K.int_shape(residual)
 75 |     stride_width = int(round(input_shape[ROW_AXIS] / residual_shape[ROW_AXIS]))
 76 |     stride_height = int(round(input_shape[COL_AXIS] / residual_shape[COL_AXIS]))
 77 |     equal_channels = input_shape[CHANNEL_AXIS] == residual_shape[CHANNEL_AXIS]
 78 | 
 79 |     shortcut = input
 80 |     # 1 X 1 conv if shape is different. Else identity.
 81 |     if stride_width > 1 or stride_height > 1 or not equal_channels:
 82 |         shortcut = Conv2D(filters=residual_shape[CHANNEL_AXIS],
 83 |                           kernel_size=(1, 1),
 84 |                           strides=(stride_width, stride_height),
 85 |                           padding="valid",
 86 |                           kernel_initializer="he_normal",
 87 |                           kernel_regularizer=l2(0.0001))(input)
 88 | 
 89 |     return add([shortcut, residual])
 90 | 
 91 | 
 92 | def _residual_block(block_function, filters, repetitions, is_first_layer=False):
 93 |     """Builds a residual block with repeating bottleneck blocks.
 94 |     """
 95 |     def f(input):
 96 |         for i in range(repetitions):
 97 |             init_strides = (1, 1)
 98 |             if i == 0 and not is_first_layer:
 99 |                 init_strides = (2, 2)
100 |             input = block_function(filters=filters, init_strides=init_strides,
101 |                                    is_first_block_of_first_layer=(is_first_layer and i == 0))(input)
102 |         return input
103 | 
104 |     return f
105 | 
106 | 
107 | def basic_block(filters, init_strides=(1, 1), is_first_block_of_first_layer=False):
108 |     """Basic 3 X 3 convolution blocks for use on resnets with layers <= 34.
109 |     Follows improved proposed scheme in http://arxiv.org/pdf/1603.05027v2.pdf
110 |     """
111 |     def f(input):
112 | 
113 |         if is_first_block_of_first_layer:
114 |             # don't repeat bn->relu since we just did bn->relu->maxpool
115 |             conv1 = Conv2D(filters=filters, kernel_size=(3, 3),
116 |                            strides=init_strides,
117 |                            padding="same",
118 |                            kernel_initializer="he_normal",
119 |                            kernel_regularizer=l2(1e-4))(input)
120 |         else:
121 |             conv1 = _bn_relu_conv(filters=filters, kernel_size=(3, 3),
122 |                                   strides=init_strides)(input)
123 | 
124 |         residual = _bn_relu_conv(filters=filters, kernel_size=(3, 3))(conv1)
125 |         return _shortcut(input, residual)
126 | 
127 |     return f
128 | 
129 | 
130 | def bottleneck(filters, init_strides=(1, 1), is_first_block_of_first_layer=False):
131 |     """Bottleneck architecture for > 34 layer resnet.
132 |     Follows improved proposed scheme in http://arxiv.org/pdf/1603.05027v2.pdf
133 |     Returns:
134 |         A final conv layer of filters * 4
135 |     """
136 |     def f(input):
137 | 
138 |         if is_first_block_of_first_layer:
139 |             # don't repeat bn->relu since we just did bn->relu->maxpool
140 |             conv_1_1 = Conv2D(filters=filters, kernel_size=(1, 1),
141 |                               strides=init_strides,
142 |                               padding="same",
143 |                               kernel_initializer="he_normal",
144 |                               kernel_regularizer=l2(1e-4))(input)
145 |         else:
146 |             conv_1_1 = _bn_relu_conv(filters=filters, kernel_size=(1, 1),
147 |                                      strides=init_strides)(input)
148 | 
149 |         conv_3_3 = _bn_relu_conv(filters=filters, kernel_size=(3, 3))(conv_1_1)
150 |         residual = _bn_relu_conv(filters=filters * 4, kernel_size=(1, 1))(conv_3_3)
151 |         return _shortcut(input, residual)
152 | 
153 |     return f
154 | 
155 | 
156 | def _handle_dim_ordering():
157 |     global ROW_AXIS
158 |     global COL_AXIS
159 |     global CHANNEL_AXIS
160 |     #if K.image_dim_ordering() == 'tf':
161 |     ROW_AXIS = 1
162 |     COL_AXIS = 2
163 |     CHANNEL_AXIS = 3
164 |     #else:
165 |     #CHANNEL_AXIS = 1
166 |     #ROW_AXIS = 2
167 |     #COL_AXIS = 3
168 | 
169 | 
170 | def _get_block(identifier):
171 |     if isinstance(identifier, six.string_types):
172 |         res = globals().get(identifier)
173 |         if not res:
174 |             raise ValueError('Invalid {}'.format(identifier))
175 |         return res
176 |     return identifier
177 | 
178 | 
179 | class ResnetBuilder(object):
180 |     @staticmethod
181 |     def build(input_shape, num_outputs, block_fn, repetitions):
182 |         """Builds a custom ResNet like architecture.
183 |         Args:
184 |             input_shape: The input shape in the form (nb_channels, nb_rows, nb_cols)
185 |             num_outputs: The number of outputs at final softmax layer
186 |             block_fn: The block function to use. This is either `basic_block` or `bottleneck`.
187 |                 The original paper used basic_block for layers < 50
188 |             repetitions: Number of repetitions of various block units.
189 |                 At each block unit, the number of filters are doubled and the input size is halved
190 |         Returns:
191 |             The keras `Model`.
192 |         """
193 |         _handle_dim_ordering()
194 |         if len(input_shape) != 3:
195 |             raise Exception("Input shape should be a tuple (nb_channels, nb_rows, nb_cols)")
196 | 
197 |         # Permute dimension order if necessary
198 |         # if K.image_dim_ordering() == 'tf':
199 |         input_shape = (input_shape[1], input_shape[2], input_shape[0])
200 | 
201 |         # Load function from str if needed.
202 |         block_fn = _get_block(block_fn)
203 | 
204 |         input = Input(shape=input_shape)
205 |         conv1 = _conv_bn_relu(filters=64, kernel_size=(7, 7), strides=(2, 2))(input)
206 |         pool1 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="same")(conv1)
207 | 
208 |         block = pool1
209 |         filters = 64
210 |         for i, r in enumerate(repetitions):
211 |             block = _residual_block(block_fn, filters=filters, repetitions=r, is_first_layer=(i == 0))(block)
212 |             filters *= 2
213 | 
214 |         # Last activation
215 |         block = _bn_relu(block)
216 | 
217 |         # Classifier block
218 |         block_shape = K.int_shape(block)
219 |         pool2 = AveragePooling2D(pool_size=(block_shape[ROW_AXIS], block_shape[COL_AXIS]),
220 |                                  strides=(1, 1))(block)
221 |         flatten1 = Flatten()(pool2)
222 |         dense = Dense(units=num_outputs, kernel_initializer="he_normal",
223 |                       activation="softmax")(flatten1)
224 | 
225 |         model = Model(inputs=input, outputs=dense)
226 |         return model
227 | 
228 |     @staticmethod
229 |     def build_resnet_18(input_shape, num_outputs):
230 |         return ResnetBuilder.build(input_shape, num_outputs, basic_block, [2, 2, 2, 2])
231 | 
232 |     @staticmethod
233 |     def build_resnet_34(input_shape, num_outputs):
234 |         return ResnetBuilder.build(input_shape, num_outputs, basic_block, [3, 4, 6, 3])
235 | 
236 |     @staticmethod
237 |     def build_resnet_50(input_shape, num_outputs):
238 |         return ResnetBuilder.build(input_shape, num_outputs, bottleneck, [3, 4, 6, 3])
239 | 
240 |     @staticmethod
241 |     def build_resnet_101(input_shape, num_outputs):
242 |         return ResnetBuilder.build(input_shape, num_outputs, bottleneck, [3, 4, 23, 3])
243 | 
244 |     @staticmethod
245 |     def build_resnet_152(input_shape, num_outputs):
246 |         return ResnetBuilder.build(input_shape, num_outputs, bottleneck, [3, 8, 36, 3])


--------------------------------------------------------------------------------
/Industry Demo Using CNNs with X-ray Images/resnet.py:
--------------------------------------------------------------------------------
  1 | import six
  2 | from tensorflow.keras.models import Model
  3 | from tensorflow.keras.layers import (
  4 |     Input,
  5 |     Activation,
  6 |     Dense,
  7 |     Flatten,
  8 |     add,
  9 |     BatchNormalization,
 10 |     Conv2D,
 11 |     MaxPooling2D,
 12 |     AveragePooling2D
 13 | )
 14 | 
 15 | from tensorflow.keras.regularizers import l2
 16 | from tensorflow.keras import backend as K
 17 | 
 18 | 
 19 | def _bn_relu(input):
 20 |     """Helper to build a BN -> relu block
 21 |     """
 22 |     norm = BatchNormalization(axis=CHANNEL_AXIS)(input)
 23 |     return Activation("relu")(norm)
 24 | 
 25 | 
 26 | def _conv_bn_relu(**conv_params):
 27 |     """Helper to build a conv -> BN -> relu block
 28 |     """
 29 |     filters = conv_params["filters"]
 30 |     kernel_size = conv_params["kernel_size"]
 31 |     strides = conv_params.setdefault("strides", (1, 1))
 32 |     kernel_initializer = conv_params.setdefault("kernel_initializer", "he_normal")
 33 |     padding = conv_params.setdefault("padding", "same")
 34 |     kernel_regularizer = conv_params.setdefault("kernel_regularizer", l2(1.e-4))
 35 | 
 36 |     def f(input):
 37 |         conv = Conv2D(filters=filters, kernel_size=kernel_size,
 38 |                       strides=strides, padding=padding,
 39 |                       kernel_initializer=kernel_initializer,
 40 |                       kernel_regularizer=kernel_regularizer)(input)
 41 |         return _bn_relu(conv)
 42 | 
 43 |     return f
 44 | 
 45 | 
 46 | def _bn_relu_conv(**conv_params):
 47 |     """Helper to build a BN -> relu -> conv block.
 48 |     This is an improved scheme proposed in http://arxiv.org/pdf/1603.05027v2.pdf
 49 |     """
 50 |     filters = conv_params["filters"]
 51 |     kernel_size = conv_params["kernel_size"]
 52 |     strides = conv_params.setdefault("strides", (1, 1))
 53 |     kernel_initializer = conv_params.setdefault("kernel_initializer", "he_normal")
 54 |     padding = conv_params.setdefault("padding", "same")
 55 |     kernel_regularizer = conv_params.setdefault("kernel_regularizer", l2(1.e-4))
 56 | 
 57 |     def f(input):
 58 |         activation = _bn_relu(input)
 59 |         return Conv2D(filters=filters, kernel_size=kernel_size,
 60 |                       strides=strides, padding=padding,
 61 |                       kernel_initializer=kernel_initializer,
 62 |                       kernel_regularizer=kernel_regularizer)(activation)
 63 | 
 64 |     return f
 65 | 
 66 | 
 67 | def _shortcut(input, residual):
 68 |     """Adds a shortcut between input and residual block and merges them with "sum"
 69 |     """
 70 |     # Expand channels of shortcut to match residual.
 71 |     # Stride appropriately to match residual (width, height)
 72 |     # Should be int if network architecture is correctly configured.
 73 |     input_shape = K.int_shape(input)
 74 |     residual_shape = K.int_shape(residual)
 75 |     stride_width = int(round(input_shape[ROW_AXIS] / residual_shape[ROW_AXIS]))
 76 |     stride_height = int(round(input_shape[COL_AXIS] / residual_shape[COL_AXIS]))
 77 |     equal_channels = input_shape[CHANNEL_AXIS] == residual_shape[CHANNEL_AXIS]
 78 | 
 79 |     shortcut = input
 80 |     # 1 X 1 conv if shape is different. Else identity.
 81 |     if stride_width > 1 or stride_height > 1 or not equal_channels:
 82 |         shortcut = Conv2D(filters=residual_shape[CHANNEL_AXIS],
 83 |                           kernel_size=(1, 1),
 84 |                           strides=(stride_width, stride_height),
 85 |                           padding="valid",
 86 |                           kernel_initializer="he_normal",
 87 |                           kernel_regularizer=l2(0.0001))(input)
 88 | 
 89 |     return add([shortcut, residual])
 90 | 
 91 | 
 92 | def _residual_block(block_function, filters, repetitions, is_first_layer=False):
 93 |     """Builds a residual block with repeating bottleneck blocks.
 94 |     """
 95 |     def f(input):
 96 |         for i in range(repetitions):
 97 |             init_strides = (1, 1)
 98 |             if i == 0 and not is_first_layer:
 99 |                 init_strides = (2, 2)
100 |             input = block_function(filters=filters, init_strides=init_strides,
101 |                                    is_first_block_of_first_layer=(is_first_layer and i == 0))(input)
102 |         return input
103 | 
104 |     return f
105 | 
106 | 
107 | def basic_block(filters, init_strides=(1, 1), is_first_block_of_first_layer=False):
108 |     """Basic 3 X 3 convolution blocks for use on resnets with layers <= 34.
109 |     Follows improved proposed scheme in http://arxiv.org/pdf/1603.05027v2.pdf
110 |     """
111 |     def f(input):
112 | 
113 |         if is_first_block_of_first_layer:
114 |             # don't repeat bn->relu since we just did bn->relu->maxpool
115 |             conv1 = Conv2D(filters=filters, kernel_size=(3, 3),
116 |                            strides=init_strides,
117 |                            padding="same",
118 |                            kernel_initializer="he_normal",
119 |                            kernel_regularizer=l2(1e-4))(input)
120 |         else:
121 |             conv1 = _bn_relu_conv(filters=filters, kernel_size=(3, 3),
122 |                                   strides=init_strides)(input)
123 | 
124 |         residual = _bn_relu_conv(filters=filters, kernel_size=(3, 3))(conv1)
125 |         return _shortcut(input, residual)
126 | 
127 |     return f
128 | 
129 | 
130 | def bottleneck(filters, init_strides=(1, 1), is_first_block_of_first_layer=False):
131 |     """Bottleneck architecture for > 34 layer resnet.
132 |     Follows improved proposed scheme in http://arxiv.org/pdf/1603.05027v2.pdf
133 |     Returns:
134 |         A final conv layer of filters * 4
135 |     """
136 |     def f(input):
137 | 
138 |         if is_first_block_of_first_layer:
139 |             # don't repeat bn->relu since we just did bn->relu->maxpool
140 |             conv_1_1 = Conv2D(filters=filters, kernel_size=(1, 1),
141 |                               strides=init_strides,
142 |                               padding="same",
143 |                               kernel_initializer="he_normal",
144 |                               kernel_regularizer=l2(1e-4))(input)
145 |         else:
146 |             conv_1_1 = _bn_relu_conv(filters=filters, kernel_size=(1, 1),
147 |                                      strides=init_strides)(input)
148 | 
149 |         conv_3_3 = _bn_relu_conv(filters=filters, kernel_size=(3, 3))(conv_1_1)
150 |         residual = _bn_relu_conv(filters=filters * 4, kernel_size=(1, 1))(conv_3_3)
151 |         return _shortcut(input, residual)
152 | 
153 |     return f
154 | 
155 | 
156 | def _handle_dim_ordering():
157 |     global ROW_AXIS
158 |     global COL_AXIS
159 |     global CHANNEL_AXIS
160 |     #if K.image_dim_ordering() == 'tf':
161 |     ROW_AXIS = 1
162 |     COL_AXIS = 2
163 |     CHANNEL_AXIS = 3
164 |     #else:
165 |     #CHANNEL_AXIS = 1
166 |     #ROW_AXIS = 2
167 |     #COL_AXIS = 3
168 | 
169 | 
170 | def _get_block(identifier):
171 |     if isinstance(identifier, six.string_types):
172 |         res = globals().get(identifier)
173 |         if not res:
174 |             raise ValueError('Invalid {}'.format(identifier))
175 |         return res
176 |     return identifier
177 | 
178 | 
179 | class ResnetBuilder(object):
180 |     @staticmethod
181 |     def build(input_shape, num_outputs, block_fn, repetitions):
182 |         """Builds a custom ResNet like architecture.
183 |         Args:
184 |             input_shape: The input shape in the form (nb_channels, nb_rows, nb_cols)
185 |             num_outputs: The number of outputs at final softmax layer
186 |             block_fn: The block function to use. This is either `basic_block` or `bottleneck`.
187 |                 The original paper used basic_block for layers < 50
188 |             repetitions: Number of repetitions of various block units.
189 |                 At each block unit, the number of filters are doubled and the input size is halved
190 |         Returns:
191 |             The keras `Model`.
192 |         """
193 |         _handle_dim_ordering()
194 |         if len(input_shape) != 3:
195 |             raise Exception("Input shape should be a tuple (nb_channels, nb_rows, nb_cols)")
196 | 
197 |         # Permute dimension order if necessary
198 |         # if K.image_dim_ordering() == 'tf':
199 |         input_shape = (input_shape[1], input_shape[2], input_shape[0])
200 | 
201 |         # Load function from str if needed.
202 |         block_fn = _get_block(block_fn)
203 | 
204 |         input = Input(shape=input_shape)
205 |         conv1 = _conv_bn_relu(filters=64, kernel_size=(7, 7), strides=(2, 2))(input)
206 |         pool1 = MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding="same")(conv1)
207 | 
208 |         block = pool1
209 |         filters = 64
210 |         for i, r in enumerate(repetitions):
211 |             block = _residual_block(block_fn, filters=filters, repetitions=r, is_first_layer=(i == 0))(block)
212 |             filters *= 2
213 | 
214 |         # Last activation
215 |         block = _bn_relu(block)
216 | 
217 |         # Classifier block
218 |         block_shape = K.int_shape(block)
219 |         pool2 = AveragePooling2D(pool_size=(block_shape[ROW_AXIS], block_shape[COL_AXIS]),
220 |                                  strides=(1, 1))(block)
221 |         flatten1 = Flatten()(pool2)
222 |         dense = Dense(units=num_outputs, kernel_initializer="he_normal",
223 |                       activation="softmax")(flatten1)
224 | 
225 |         model = Model(inputs=input, outputs=dense)
226 |         return model
227 | 
228 |     @staticmethod
229 |     def build_resnet_18(input_shape, num_outputs):
230 |         return ResnetBuilder.build(input_shape, num_outputs, basic_block, [2, 2, 2, 2])
231 | 
232 |     @staticmethod
233 |     def build_resnet_34(input_shape, num_outputs):
234 |         return ResnetBuilder.build(input_shape, num_outputs, basic_block, [3, 4, 6, 3])
235 | 
236 |     @staticmethod
237 |     def build_resnet_50(input_shape, num_outputs):
238 |         return ResnetBuilder.build(input_shape, num_outputs, bottleneck, [3, 4, 6, 3])
239 | 
240 |     @staticmethod
241 |     def build_resnet_101(input_shape, num_outputs):
242 |         return ResnetBuilder.build(input_shape, num_outputs, bottleneck, [3, 4, 23, 3])
243 | 
244 |     @staticmethod
245 |     def build_resnet_152(input_shape, num_outputs):
246 |         return ResnetBuilder.build(input_shape, num_outputs, bottleneck, [3, 8, 36, 3])


--------------------------------------------------------------------------------
/Industry Demo Using CNNs with X-ray Images/Working_With_Chest_XRay_Images-.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "markdown",
  5 |    "metadata": {},
  6 |    "source": [
  7 |     "# Analysis of Chest X-Ray images"
  8 |    ]
  9 |   },
 10 |   {
 11 |    "cell_type": "markdown",
 12 |    "metadata": {},
 13 |    "source": [
 14 |     "Neural networks have revolutionised image processing in several different domains. Among these is the field of medical imaging. In the following notebook, we will get some hands-on experience in working with Chest X-Ray (CXR) images.\n",
 15 |     "\n",
 16 |     "The objective of this exercise is to identify images where an \"effusion\" is present. This is a classification problem, where we will be dealing with two classes - 'effusion' and 'nofinding'. Here, the latter represents a \"normal\" X-ray image.\n",
 17 |     "\n",
 18 |     "This same methodology can be used to spot various other illnesses that can be detected via a chest x-ray. For the scope of this demonstration, we will specifically deal with \"effusion\"."
 19 |    ]
 20 |   },
 21 |   {
 22 |    "cell_type": "markdown",
 23 |    "metadata": {},
 24 |    "source": [
 25 |     "## 1. Data Pre-processing"
 26 |    ]
 27 |   },
 28 |   {
 29 |    "cell_type": "markdown",
 30 |    "metadata": {},
 31 |    "source": [
 32 |     "Our data is in the form of grayscale (black and white) images of chest x-rays. To perform our classification task effectively, we need to perform some pre-processing of the data.\n",
 33 |     "\n",
 34 |     "First, we load all the relevant libraries."
 35 |    ]
 36 |   },
 37 |   {
 38 |    "cell_type": "code",
 39 |    "execution_count": 1,
 40 |    "metadata": {},
 41 |    "outputs": [],
 42 |    "source": [
 43 |     "from skimage import io\n",
 44 |     "import os\n",
 45 |     "import glob\n",
 46 |     "import numpy as np\n",
 47 |     "import matplotlib.pyplot as plt\n",
 48 |     "\n",
 49 |     "import warnings\n",
 50 |     "warnings.simplefilter('ignore')"
 51 |    ]
 52 |   },
 53 |   {
 54 |    "cell_type": "code",
 55 |    "execution_count": 5,
 56 |    "metadata": {},
 57 |    "outputs": [],
 58 |    "source": [
 59 |     "DATASET_PATH = '/home/datasets/CXR_data'\n",
 60 |     "\n",
 61 |     "# There are two classes of images that we will deal with\n",
 62 |     "disease_cls = ['effusion', 'nofinding']"
 63 |    ]
 64 |   },
 65 |   {
 66 |    "cell_type": "markdown",
 67 |    "metadata": {},
 68 |    "source": [
 69 |     "Next, we read the \"effusion\" and \"nofinding\" images."
 70 |    ]
 71 |   },
 72 |   {
 73 |    "cell_type": "code",
 74 |    "execution_count": 6,
 75 |    "metadata": {},
 76 |    "outputs": [
 77 |     {
 78 |      "data": {
 79 |       "text/plain": [
 80 |        "<matplotlib.image.AxesImage at 0x7f0d4de85e80>"
 81 |       ]
 82 |      },
 83 |      "execution_count": 6,
 84 |      "metadata": {},
 85 |      "output_type": "execute_result"
 86 |     },
 87 |     {
 88 |      "data": {
 89 |       "image/png": "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\n",
 90 |       "text/plain": [
 91 |        "<Figure size 720x288 with 2 Axes>"
 92 |       ]
 93 |      },
 94 |      "metadata": {
 95 |       "needs_background": "light"
 96 |      },
 97 |      "output_type": "display_data"
 98 |     }
 99 |    ],
100 |    "source": [
101 |     "effusion_path = os.path.join(DATASET_PATH, disease_cls[0], '*')\n",
102 |     "effusion = glob.glob(effusion_path)\n",
103 |     "effusion = io.imread(effusion[0])\n",
104 |     "\n",
105 |     "normal_path = os.path.join(DATASET_PATH, disease_cls[1], '*')\n",
106 |     "normal = glob.glob(normal_path)\n",
107 |     "normal = io.imread(normal[0])\n",
108 |     "\n",
109 |     "f, axes = plt.subplots(1, 2, sharey=True)\n",
110 |     "f.set_figwidth(10)\n",
111 |     "    \n",
112 |     "axes[0].imshow(effusion, cmap='gray')\n",
113 |     "axes[1].imshow(normal, cmap='gray')"
114 |    ]
115 |   },
116 |   {
117 |    "cell_type": "code",
118 |    "execution_count": 7,
119 |    "metadata": {},
120 |    "outputs": [
121 |     {
122 |      "data": {
123 |       "text/plain": [
124 |        "(1024, 1024)"
125 |       ]
126 |      },
127 |      "execution_count": 7,
128 |      "metadata": {},
129 |      "output_type": "execute_result"
130 |     }
131 |    ],
132 |    "source": [
133 |     "effusion.shape"
134 |    ]
135 |   },
136 |   {
137 |    "cell_type": "code",
138 |    "execution_count": 8,
139 |    "metadata": {},
140 |    "outputs": [
141 |     {
142 |      "data": {
143 |       "text/plain": [
144 |        "(1024, 1024)"
145 |       ]
146 |      },
147 |      "execution_count": 8,
148 |      "metadata": {},
149 |      "output_type": "execute_result"
150 |     }
151 |    ],
152 |    "source": [
153 |     "normal.shape"
154 |    ]
155 |   },
156 |   {
157 |    "cell_type": "markdown",
158 |    "metadata": {},
159 |    "source": [
160 |     "### Data Augmentation ###\n",
161 |     "\n",
162 |     "Now that we have read the images, the next step is data augmentation. We use the concept of a \"data generator\" that you learnt in the last section."
163 |    ]
164 |   },
165 |   {
166 |    "cell_type": "code",
167 |    "execution_count": 9,
168 |    "metadata": {},
169 |    "outputs": [],
170 |    "source": [
171 |     "from skimage.transform import rescale\n",
172 |     "from tensorflow.keras.preprocessing.image import ImageDataGenerator\n",
173 |     "\n",
174 |     "datagen = ImageDataGenerator(\n",
175 |     "    featurewise_center=True,\n",
176 |     "    featurewise_std_normalization=True,\n",
177 |     "    rotation_range=10,\n",
178 |     "    width_shift_range=0,\n",
179 |     "    height_shift_range=0,\n",
180 |     "    vertical_flip=False,)\n",
181 |     "\n",
182 |     "def preprocess_img(img, mode):\n",
183 |     "    img = (img - img.min())/(img.max() - img.min())\n",
184 |     "    img = rescale(img, 0.25, multichannel=True, mode='constant')\n",
185 |     "    \n",
186 |     "    if mode == 'train':\n",
187 |     "        if np.random.randn() > 0:\n",
188 |     "            img = datagen.random_transform(img)\n",
189 |     "    return img"
190 |    ]
191 |   },
192 |   {
193 |    "cell_type": "markdown",
194 |    "metadata": {},
195 |    "source": [
196 |     "## 2. Model building"
197 |    ]
198 |   },
199 |   {
200 |    "cell_type": "markdown",
201 |    "metadata": {},
202 |    "source": [
203 |     "We will be using a Resnet in this (you learnt about Resnets previously). \n",
204 |     "\n",
205 |     "For this to work, the script that defines the resnet model (resnet.py) should reside in the same folder as this notebook"
206 |    ]
207 |   },
208 |   {
209 |    "cell_type": "code",
210 |    "execution_count": 12,
211 |    "metadata": {},
212 |    "outputs": [],
213 |    "source": [
214 |     "import resnet\n",
215 |     "\n",
216 |     "img_channels = 1\n",
217 |     "img_rows = 256\n",
218 |     "img_cols = 256\n",
219 |     "\n",
220 |     "nb_classes = 2"
221 |    ]
222 |   },
223 |   {
224 |    "cell_type": "code",
225 |    "execution_count": 13,
226 |    "metadata": {},
227 |    "outputs": [],
228 |    "source": [
229 |     "import numpy as np\n",
230 |     "import tensorflow as tf\n",
231 |     "\n",
232 |     "class AugmentedDataGenerator(tf.keras.utils.Sequence):\n",
233 |     "    'Generates data for Keras'\n",
234 |     "    def __init__(self, mode='train', ablation=None, disease_cls = ['nofinding', 'effusion'], \n",
235 |     "                 batch_size=32, dim=(256, 256), n_channels=1, shuffle=True):\n",
236 |     "        'Initialization'\n",
237 |     "        self.dim = dim\n",
238 |     "        self.batch_size = batch_size\n",
239 |     "        self.labels = {}\n",
240 |     "        self.list_IDs = []\n",
241 |     "        self.mode = mode\n",
242 |     "        \n",
243 |     "        for i, cls in enumerate(disease_cls):\n",
244 |     "            paths = glob.glob(os.path.join(DATASET_PATH, cls, '*'))\n",
245 |     "            brk_point = int(len(paths)*0.8)\n",
246 |     "            if self.mode == 'train':\n",
247 |     "                paths = paths[:brk_point]\n",
248 |     "            else:\n",
249 |     "                paths = paths[brk_point:]\n",
250 |     "            if ablation is not None:\n",
251 |     "                paths = paths[:int(len(paths)*ablation/100)]\n",
252 |     "            self.list_IDs += paths\n",
253 |     "            self.labels.update({p:i for p in paths})\n",
254 |     "        \n",
255 |     "            \n",
256 |     "        self.n_channels = n_channels\n",
257 |     "        self.n_classes = len(disease_cls)\n",
258 |     "        self.shuffle = shuffle\n",
259 |     "        self.on_epoch_end()\n",
260 |     "\n",
261 |     "    def __len__(self):\n",
262 |     "        'Denotes the number of batches per epoch'\n",
263 |     "        return int(np.floor(len(self.list_IDs) / self.batch_size))\n",
264 |     "\n",
265 |     "    def __getitem__(self, index):\n",
266 |     "        'Generate one batch of data'\n",
267 |     "\n",
268 |     "        indexes = self.indexes[index*self.batch_size:(index+1)*self.batch_size]\n",
269 |     "        list_IDs_temp = [self.list_IDs[k] for k in indexes]\n",
270 |     "\n",
271 |     "        X, y = self.__data_generation(list_IDs_temp)\n",
272 |     "\n",
273 |     "        return X, y\n",
274 |     "\n",
275 |     "    def on_epoch_end(self):\n",
276 |     "        'Updates indexes after each epoch'\n",
277 |     "        self.indexes = np.arange(len(self.list_IDs))\n",
278 |     "        if self.shuffle == True:\n",
279 |     "            np.random.shuffle(self.indexes)\n",
280 |     "\n",
281 |     "    def __data_generation(self, list_IDs_temp):\n",
282 |     "        'Generates data containing batch_size samples' # X : (n_samples, *dim, n_channels)\n",
283 |     "        # Initialization\n",
284 |     "        X = np.empty((self.batch_size, *self.dim, self.n_channels))\n",
285 |     "        y = np.empty((self.batch_size), dtype=int)\n",
286 |     "        \n",
287 |     "        delete_rows = []\n",
288 |     "\n",
289 |     "        # Generate data\n",
290 |     "        for i, ID in enumerate(list_IDs_temp):\n",
291 |     "            img = io.imread(ID)\n",
292 |     "            img = img[:, :, np.newaxis]\n",
293 |     "            if img.shape == (1024, 1024,1):\n",
294 |     "                img = preprocess_img(img, self.mode)\n",
295 |     "                X[i,] = img\n",
296 |     "                y[i] = self.labels[ID]\n",
297 |     "            else:\n",
298 |     "                delete_rows.append(i)\n",
299 |     "                continue\n",
300 |     "                \n",
301 |     "        X = np.delete(X, delete_rows, axis=0)\n",
302 |     "        y = np.delete(y, delete_rows, axis=0)\n",
303 |     "        \n",
304 |     "        return X, tf.keras.utils.to_categorical(y, num_classes=self.n_classes)"
305 |    ]
306 |   },
307 |   {
308 |    "cell_type": "markdown",
309 |    "metadata": {},
310 |    "source": [
311 |     "## 3. Ablation Run"
312 |    ]
313 |   },
314 |   {
315 |    "cell_type": "markdown",
316 |    "metadata": {},
317 |    "source": [
318 |     "In the previous notebook, you learnt about Ablation. Briefly, an ablation run is when you systematically modify certain parts of the input, in order to observe the equivalent change in the input.\n",
319 |     "\n",
320 |     "For the following section, we'll be using the Data Generator concept that you previously worked on."
321 |    ]
322 |   },
323 |   {
324 |    "cell_type": "code",
325 |    "execution_count": 14,
326 |    "metadata": {},
327 |    "outputs": [
328 |     {
329 |      "name": "stdout",
330 |      "output_type": "stream",
331 |      "text": [
332 |       "1/1 [==============================] - 0s 4ms/step - loss: 1.5078 - accuracy: 0.8750\n"
333 |      ]
334 |     },
335 |     {
336 |      "data": {
337 |       "text/plain": [
338 |        "<tensorflow.python.keras.callbacks.History at 0x7f0cd002c0f0>"
339 |       ]
340 |      },
341 |      "execution_count": 14,
342 |      "metadata": {},
343 |      "output_type": "execute_result"
344 |     }
345 |    ],
346 |    "source": [
347 |     "model = resnet.ResnetBuilder.build_resnet_18((img_channels, img_rows, img_cols), nb_classes)\n",
348 |     "model.compile(loss='categorical_crossentropy',optimizer='SGD',\n",
349 |     "              metrics=['accuracy'])\n",
350 |     "training_generator = AugmentedDataGenerator('train', ablation=5)\n",
351 |     "validation_generator = AugmentedDataGenerator('val', ablation=5)\n",
352 |     "\n",
353 |     "model.fit(training_generator, epochs=1, validation_data=validation_generator)"
354 |    ]
355 |   },
356 |   {
357 |    "cell_type": "code",
358 |    "execution_count": 15,
359 |    "metadata": {},
360 |    "outputs": [
361 |     {
362 |      "name": "stdout",
363 |      "output_type": "stream",
364 |      "text": [
365 |       "Epoch 1/5\n",
366 |       "1/1 [==============================] - 0s 2ms/step - loss: 3.1320 - accuracy: 0.0938\n",
367 |       "Epoch 2/5\n",
368 |       "1/1 [==============================] - 0s 3ms/step - loss: 2.2083 - accuracy: 0.0625\n",
369 |       "Epoch 3/5\n",
370 |       "1/1 [==============================] - 0s 33ms/step - loss: 1.6588 - accuracy: 0.6250\n",
371 |       "Epoch 4/5\n",
372 |       "1/1 [==============================] - 0s 34ms/step - loss: 1.4274 - accuracy: 0.9375\n",
373 |       "Epoch 5/5\n",
374 |       "1/1 [==============================] - 0s 35ms/step - loss: 1.3586 - accuracy: 0.9062\n"
375 |      ]
376 |     },
377 |     {
378 |      "data": {
379 |       "text/plain": [
380 |        "<tensorflow.python.keras.callbacks.History at 0x7f0cd307ab38>"
381 |       ]
382 |      },
383 |      "execution_count": 15,
384 |      "metadata": {},
385 |      "output_type": "execute_result"
386 |     }
387 |    ],
388 |    "source": [
389 |     "model = resnet.ResnetBuilder.build_resnet_18((img_channels, img_rows, img_cols), nb_classes)\n",
390 |     "model.compile(loss='categorical_crossentropy',optimizer='SGD',\n",
391 |     "              metrics=['accuracy'])\n",
392 |     "\n",
393 |     "training_generator = AugmentedDataGenerator('train', ablation=5)\n",
394 |     "validation_generator = AugmentedDataGenerator('val', ablation=5)\n",
395 |     "\n",
396 |     "model.fit(training_generator, epochs=5, validation_data=None)"
397 |    ]
398 |   },
399 |   {
400 |    "cell_type": "code",
401 |    "execution_count": 16,
402 |    "metadata": {},
403 |    "outputs": [],
404 |    "source": [
405 |     "from sklearn.metrics import roc_auc_score\n",
406 |     "from tensorflow.keras import optimizers\n",
407 |     "from tensorflow.keras.callbacks import *\n",
408 |     "\n",
409 |     "class roc_callback(Callback):\n",
410 |     "    \n",
411 |     "    def on_train_begin(self, logs={}):\n",
412 |     "        logs['val_auc'] = 0\n",
413 |     "\n",
414 |     "    def on_epoch_end(self, epoch, logs={}):\n",
415 |     "        y_p = []\n",
416 |     "        y_v = []\n",
417 |     "        for i in range(len(validation_generator)):\n",
418 |     "            x_val, y_val = validation_generator[i]\n",
419 |     "            y_pred = self.model.predict(x_val)\n",
420 |     "            y_p.append(y_pred)\n",
421 |     "            y_v.append(y_val)\n",
422 |     "        y_p = np.concatenate(y_p)\n",
423 |     "        y_v = np.concatenate(y_v)\n",
424 |     "        roc_auc = roc_auc_score(y_v, y_p)\n",
425 |     "        print ('\\nVal AUC for epoch{}: {}'.format(epoch, roc_auc))\n",
426 |     "        logs['val_auc'] = roc_auc"
427 |    ]
428 |   },
429 |   {
430 |    "cell_type": "code",
431 |    "execution_count": 17,
432 |    "metadata": {},
433 |    "outputs": [
434 |     {
435 |      "name": "stdout",
436 |      "output_type": "stream",
437 |      "text": [
438 |       "Epoch 1/5\n",
439 |       "5/5 [==============================] - ETA: 0s - loss: 1.5658 - accuracy: 0.6938\n",
440 |       "Val AUC for epoch0: 0.4166666666666667\n",
441 |       "5/5 [==============================] - 12s 2s/step - loss: 1.5658 - accuracy: 0.6938 - val_loss: 3.9691 - val_accuracy: 0.9000\n",
442 |       "Epoch 2/5\n",
443 |       "5/5 [==============================] - ETA: 0s - loss: 1.2951 - accuracy: 0.9062\n",
444 |       "Val AUC for epoch1: 0.4423076923076923\n",
445 |       "5/5 [==============================] - 9s 2s/step - loss: 1.2951 - accuracy: 0.9062 - val_loss: 3.1814 - val_accuracy: 0.9032\n",
446 |       "Epoch 3/5\n",
447 |       "5/5 [==============================] - ETA: 0s - loss: 1.2675 - accuracy: 0.9062\n",
448 |       "Val AUC for epoch2: 0.3472222222222222\n",
449 |       "5/5 [==============================] - 9s 2s/step - loss: 1.2675 - accuracy: 0.9062 - val_loss: 2.8700 - val_accuracy: 0.8966\n",
450 |       "Epoch 4/5\n",
451 |       "5/5 [==============================] - ETA: 0s - loss: 1.2728 - accuracy: 0.9000\n",
452 |       "Val AUC for epoch3: 0.34375\n",
453 |       "5/5 [==============================] - 9s 2s/step - loss: 1.2728 - accuracy: 0.9000 - val_loss: 2.9257 - val_accuracy: 0.8710\n",
454 |       "Epoch 5/5\n",
455 |       "5/5 [==============================] - ETA: 0s - loss: 1.2812 - accuracy: 0.8938\n",
456 |       "Val AUC for epoch4: 0.31845238095238093\n",
457 |       "5/5 [==============================] - 9s 2s/step - loss: 1.2812 - accuracy: 0.8938 - val_loss: 1.7745 - val_accuracy: 0.9333\n"
458 |      ]
459 |     },
460 |     {
461 |      "data": {
462 |       "text/plain": [
463 |        "<tensorflow.python.keras.callbacks.History at 0x7f0d6e4790f0>"
464 |       ]
465 |      },
466 |      "execution_count": 17,
467 |      "metadata": {},
468 |      "output_type": "execute_result"
469 |     }
470 |    ],
471 |    "source": [
472 |     "model = resnet.ResnetBuilder.build_resnet_18((img_channels, img_rows, img_cols), nb_classes)\n",
473 |     "model.compile(loss='categorical_crossentropy',optimizer='SGD',\n",
474 |     "              metrics=['accuracy'])\n",
475 |     "\n",
476 |     "training_generator = AugmentedDataGenerator('train', ablation=20)\n",
477 |     "validation_generator = AugmentedDataGenerator('val', ablation=20)\n",
478 |     "\n",
479 |     "auc_logger = roc_callback()\n",
480 |     "\n",
481 |     "model.fit(training_generator, epochs=5, validation_data=validation_generator, callbacks=[auc_logger])"
482 |    ]
483 |   },
484 |   {
485 |    "cell_type": "code",
486 |    "execution_count": 18,
487 |    "metadata": {},
488 |    "outputs": [],
489 |    "source": [
490 |     "from functools import partial\n",
491 |     "import tensorflow.keras.backend as K\n",
492 |     "from itertools import product\n",
493 |     "\n",
494 |     "def w_categorical_crossentropy(y_true, y_pred, weights):\n",
495 |     "    nb_cl = len(weights)\n",
496 |     "    final_mask = K.zeros_like(y_pred[:, 0])\n",
497 |     "    y_pred_max = K.max(y_pred, axis=1)\n",
498 |     "    y_pred_max = K.reshape(y_pred_max, (K.shape(y_pred)[0], 1))\n",
499 |     "    y_pred_max_mat = K.cast(K.equal(y_pred, y_pred_max), K.floatx())\n",
500 |     "    for c_p, c_t in product(range(nb_cl), range(nb_cl)):\n",
501 |     "        final_mask += (weights[c_t, c_p] * y_pred_max_mat[:, c_p] * y_true[:, c_t])\n",
502 |     "    cross_ent = K.categorical_crossentropy(y_true, y_pred, from_logits=False)\n",
503 |     "    return cross_ent * final_mask\n",
504 |     "\n",
505 |     "bin_weights = np.ones((2,2))\n",
506 |     "bin_weights[0, 1] = 5\n",
507 |     "bin_weights[1, 0] = 5\n",
508 |     "ncce = partial(w_categorical_crossentropy, weights=bin_weights)\n",
509 |     "ncce.__name__ ='w_categorical_crossentropy'"
510 |    ]
511 |   },
512 |   {
513 |    "cell_type": "code",
514 |    "execution_count": 19,
515 |    "metadata": {},
516 |    "outputs": [
517 |     {
518 |      "name": "stdout",
519 |      "output_type": "stream",
520 |      "text": [
521 |       "1/1 [==============================] - 0s 34ms/step - loss: 4.8093 - accuracy: 0.1875\n"
522 |      ]
523 |     },
524 |     {
525 |      "data": {
526 |       "text/plain": [
527 |        "<tensorflow.python.keras.callbacks.History at 0x7f0bcc431320>"
528 |       ]
529 |      },
530 |      "execution_count": 19,
531 |      "metadata": {},
532 |      "output_type": "execute_result"
533 |     }
534 |    ],
535 |    "source": [
536 |     "model = resnet.ResnetBuilder.build_resnet_18((img_channels, img_rows, img_cols), nb_classes)\n",
537 |     "model.compile(loss=ncce, optimizer='SGD',\n",
538 |     "              metrics=['accuracy'])\n",
539 |     "\n",
540 |     "training_generator = AugmentedDataGenerator('train', ablation=5)\n",
541 |     "validation_generator = AugmentedDataGenerator('val', ablation=5)\n",
542 |     "\n",
543 |     "model.fit(training_generator, epochs=1, validation_data=None)"
544 |    ]
545 |   },
546 |   {
547 |    "cell_type": "markdown",
548 |    "metadata": {},
549 |    "source": [
550 |     "## 4. Final Run"
551 |    ]
552 |   },
553 |   {
554 |    "cell_type": "markdown",
555 |    "metadata": {},
556 |    "source": [
557 |     "After deeply examining our data and building some preliminary models, we are finally ready to build a model that will perform our prediction task."
558 |    ]
559 |   },
560 |   {
561 |    "cell_type": "code",
562 |    "execution_count": 20,
563 |    "metadata": {},
564 |    "outputs": [],
565 |    "source": [
566 |     "class DecayLR(tf.keras.callbacks.Callback):\n",
567 |     "    def __init__(self, base_lr=0.01, decay_epoch=1):\n",
568 |     "        super(DecayLR, self).__init__()\n",
569 |     "        self.base_lr = base_lr\n",
570 |     "        self.decay_epoch = decay_epoch \n",
571 |     "        self.lr_history = []\n",
572 |     "        \n",
573 |     "    def on_train_begin(self, logs={}):\n",
574 |     "        K.set_value(self.model.optimizer.lr, self.base_lr)\n",
575 |     "\n",
576 |     "    def on_epoch_end(self, epoch, logs={}):\n",
577 |     "        new_lr = self.base_lr * (0.5 ** (epoch // self.decay_epoch))\n",
578 |     "        self.lr_history.append(K.get_value(self.model.optimizer.lr))\n",
579 |     "        K.set_value(self.model.optimizer.lr, new_lr)"
580 |    ]
581 |   },
582 |   {
583 |    "cell_type": "code",
584 |    "execution_count": 23,
585 |    "metadata": {},
586 |    "outputs": [],
587 |    "source": [
588 |     "!mkdir models"
589 |    ]
590 |   },
591 |   {
592 |    "cell_type": "code",
593 |    "execution_count": 25,
594 |    "metadata": {},
595 |    "outputs": [
596 |     {
597 |      "name": "stdout",
598 |      "output_type": "stream",
599 |      "text": [
600 |       "Epoch 1/10\n",
601 |       "13/13 [==============================] - ETA: 0s - loss: 2.4460 - accuracy: 0.5181 - auc: 0.5580\n",
602 |       "Val AUC for epoch0: 0.415625\n",
603 |       "\n",
604 |       "Epoch 00001: val_auc improved from -inf to 0.87577, saving model to models/best_model.hdf5\n",
605 |       "13/13 [==============================] - 29s 2s/step - loss: 2.4460 - accuracy: 0.5181 - auc: 0.5580 - val_loss: 6.6954 - val_accuracy: 0.8989 - val_auc: 0.8758\n",
606 |       "Epoch 2/10\n",
607 |       "13/13 [==============================] - ETA: 0s - loss: 2.1545 - accuracy: 0.5759 - auc: 0.6016\n",
608 |       "Val AUC for epoch1: 0.3613916947250281\n",
609 |       "\n",
610 |       "Epoch 00002: val_auc improved from 0.87577 to 0.90328, saving model to models/best_model.hdf5\n",
611 |       "13/13 [==============================] - 28s 2s/step - loss: 2.1545 - accuracy: 0.5759 - auc: 0.6016 - val_loss: 4.7157 - val_accuracy: 0.9091 - val_auc: 0.9033\n",
612 |       "Epoch 3/10\n",
613 |       "13/13 [==============================] - ETA: 0s - loss: 2.0952 - accuracy: 0.6530 - auc: 0.7382\n",
614 |       "Val AUC for epoch2: 0.3481012658227848\n",
615 |       "\n",
616 |       "Epoch 00003: val_auc did not improve from 0.90328\n",
617 |       "13/13 [==============================] - 28s 2s/step - loss: 2.0952 - accuracy: 0.6530 - auc: 0.7382 - val_loss: 3.0479 - val_accuracy: 0.8804 - val_auc: 0.8463\n",
618 |       "Epoch 4/10\n",
619 |       "13/13 [==============================] - ETA: 0s - loss: 2.0880 - accuracy: 0.7542 - auc: 0.8327\n",
620 |       "Val AUC for epoch3: 0.4641975308641975\n",
621 |       "\n",
622 |       "Epoch 00004: val_auc did not improve from 0.90328\n",
623 |       "13/13 [==============================] - 28s 2s/step - loss: 2.0880 - accuracy: 0.7542 - auc: 0.8327 - val_loss: 2.3818 - val_accuracy: 0.1685 - val_auc: 0.1119\n",
624 |       "Epoch 5/10\n",
625 |       "13/13 [==============================] - ETA: 0s - loss: 2.0780 - accuracy: 0.6795 - auc: 0.7546\n",
626 |       "Val AUC for epoch4: 0.4474358974358974\n",
627 |       "\n",
628 |       "Epoch 00005: val_auc did not improve from 0.90328\n",
629 |       "13/13 [==============================] - 28s 2s/step - loss: 2.0780 - accuracy: 0.6795 - auc: 0.7546 - val_loss: 2.4245 - val_accuracy: 0.1209 - val_auc: 0.1070\n",
630 |       "Epoch 6/10\n",
631 |       "13/13 [==============================] - ETA: 0s - loss: 2.0750 - accuracy: 0.6241 - auc: 0.6893\n",
632 |       "Val AUC for epoch5: 0.4484375\n",
633 |       "\n",
634 |       "Epoch 00006: val_auc did not improve from 0.90328\n",
635 |       "13/13 [==============================] - 27s 2s/step - loss: 2.0750 - accuracy: 0.6241 - auc: 0.6893 - val_loss: 2.5354 - val_accuracy: 0.1364 - val_auc: 0.1085\n",
636 |       "Epoch 7/10\n",
637 |       "13/13 [==============================] - ETA: 0s - loss: 2.0614 - accuracy: 0.6410 - auc: 0.7082\n",
638 |       "Val AUC for epoch6: 0.5175000000000001\n",
639 |       "\n",
640 |       "Epoch 00007: val_auc did not improve from 0.90328\n",
641 |       "13/13 [==============================] - 27s 2s/step - loss: 2.0614 - accuracy: 0.6410 - auc: 0.7082 - val_loss: 2.5695 - val_accuracy: 0.1023 - val_auc: 0.0816\n",
642 |       "Epoch 8/10\n",
643 |       "13/13 [==============================] - ETA: 0s - loss: 2.0605 - accuracy: 0.6627 - auc: 0.7206\n",
644 |       "Val AUC for epoch7: 0.5512082853855005\n",
645 |       "\n",
646 |       "Epoch 00008: val_auc did not improve from 0.90328\n",
647 |       "13/13 [==============================] - 28s 2s/step - loss: 2.0605 - accuracy: 0.6627 - auc: 0.7206 - val_loss: 2.5710 - val_accuracy: 0.1333 - val_auc: 0.1194\n",
648 |       "Epoch 9/10\n",
649 |       "13/13 [==============================] - ETA: 0s - loss: 2.0411 - accuracy: 0.6683 - auc: 0.7181\n",
650 |       "Val AUC for epoch8: 0.583916083916084\n",
651 |       "\n",
652 |       "Epoch 00009: val_auc did not improve from 0.90328\n",
653 |       "13/13 [==============================] - 28s 2s/step - loss: 2.0411 - accuracy: 0.6683 - auc: 0.7181 - val_loss: 2.5345 - val_accuracy: 0.1556 - val_auc: 0.1417\n",
654 |       "Epoch 10/10\n",
655 |       "13/13 [==============================] - ETA: 0s - loss: 2.0472 - accuracy: 0.6578 - auc: 0.7172\n",
656 |       "Val AUC for epoch9: 0.6101265822784809\n",
657 |       "\n",
658 |       "Epoch 00010: val_auc did not improve from 0.90328\n",
659 |       "13/13 [==============================] - 27s 2s/step - loss: 2.0472 - accuracy: 0.6578 - auc: 0.7172 - val_loss: 2.5038 - val_accuracy: 0.1348 - val_auc: 0.1477\n"
660 |      ]
661 |     },
662 |     {
663 |      "data": {
664 |       "text/plain": [
665 |        "<tensorflow.python.keras.callbacks.History at 0x7f07c5f4f978>"
666 |       ]
667 |      },
668 |      "execution_count": 25,
669 |      "metadata": {},
670 |      "output_type": "execute_result"
671 |     }
672 |    ],
673 |    "source": [
674 |     "model = resnet.ResnetBuilder.build_resnet_18((img_channels, img_rows, img_cols), nb_classes)\n",
675 |     "sgd = optimizers.SGD(lr=0.005)\n",
676 |     "\n",
677 |     "bin_weights = np.ones((2,2))\n",
678 |     "bin_weights[1, 1] = 10\n",
679 |     "bin_weights[1, 0] = 10\n",
680 |     "ncce = partial(w_categorical_crossentropy, weights=bin_weights)\n",
681 |     "ncce.__name__ ='w_categorical_crossentropy'\n",
682 |     "\n",
683 |     "model.compile(loss=ncce,optimizer= sgd,\n",
684 |     "              metrics=['accuracy', 'AUC'])\n",
685 |     "training_generator = AugmentedDataGenerator('train', ablation=50)\n",
686 |     "validation_generator = AugmentedDataGenerator('val', ablation=50)\n",
687 |     "\n",
688 |     "auc_logger = roc_callback()\n",
689 |     "filepath = 'models/best_model.hdf5'\n",
690 |     "checkpoint = ModelCheckpoint(filepath, monitor='val_auc', verbose=1, save_best_only=True, mode='max')\n",
691 |     "\n",
692 |     "decay = DecayLR()\n",
693 |     "\n",
694 |     "model.fit(training_generator, epochs=10, validation_data=validation_generator, callbacks=[auc_logger, decay, checkpoint])"
695 |    ]
696 |   },
697 |   {
698 |    "cell_type": "markdown",
699 |    "metadata": {},
700 |    "source": [
701 |     "## 5. Making a Prediction"
702 |    ]
703 |   },
704 |   {
705 |    "cell_type": "code",
706 |    "execution_count": 26,
707 |    "metadata": {},
708 |    "outputs": [],
709 |    "source": [
710 |     "val_model = resnet.ResnetBuilder.build_resnet_18((img_channels, img_rows, img_cols), nb_classes)\n",
711 |     "val_model.load_weights('models/best_model.hdf5')"
712 |    ]
713 |   },
714 |   {
715 |    "cell_type": "code",
716 |    "execution_count": 27,
717 |    "metadata": {},
718 |    "outputs": [
719 |     {
720 |      "data": {
721 |       "text/plain": [
722 |        "<matplotlib.image.AxesImage at 0x7f07b85e0278>"
723 |       ]
724 |      },
725 |      "execution_count": 27,
726 |      "metadata": {},
727 |      "output_type": "execute_result"
728 |     },
729 |     {
730 |      "data": {
731 |       "image/png": "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\n",
732 |       "text/plain": [
733 |        "<Figure size 432x288 with 1 Axes>"
734 |       ]
735 |      },
736 |      "metadata": {
737 |       "needs_background": "light"
738 |      },
739 |      "output_type": "display_data"
740 |     }
741 |    ],
742 |    "source": [
743 |     "effusion_path = os.path.join(DATASET_PATH, disease_cls[0], '*')\n",
744 |     "effusion = glob.glob(effusion_path)\n",
745 |     "effusion = io.imread(effusion[-8])\n",
746 |     "plt.imshow(effusion,cmap='gray')"
747 |    ]
748 |   },
749 |   {
750 |    "cell_type": "code",
751 |    "execution_count": 28,
752 |    "metadata": {},
753 |    "outputs": [
754 |     {
755 |      "data": {
756 |       "text/plain": [
757 |        "array([[0.9566385 , 0.04336146]], dtype=float32)"
758 |       ]
759 |      },
760 |      "execution_count": 28,
761 |      "metadata": {},
762 |      "output_type": "execute_result"
763 |     }
764 |    ],
765 |    "source": [
766 |     "img = preprocess_img(effusion[:, :, np.newaxis], 'validation')\n",
767 |     "val_model.predict(img[np.newaxis,:])"
768 |    ]
769 |   },
770 |   {
771 |    "cell_type": "code",
772 |    "execution_count": null,
773 |    "metadata": {},
774 |    "outputs": [],
775 |    "source": []
776 |   }
777 |  ],
778 |  "metadata": {
779 |   "anaconda-cloud": {},
780 |   "kernelspec": {
781 |    "display_name": "Python 3",
782 |    "language": "python",
783 |    "name": "python3"
784 |   },
785 |   "language_info": {
786 |    "codemirror_mode": {
787 |     "name": "ipython",
788 |     "version": 3
789 |    },
790 |    "file_extension": ".py",
791 |    "mimetype": "text/x-python",
792 |    "name": "python",
793 |    "nbconvert_exporter": "python",
794 |    "pygments_lexer": "ipython3",
795 |    "version": "3.7.4"
796 |   }
797 |  },
798 |  "nbformat": 4,
799 |  "nbformat_minor": 4
800 | }
801 | 


--------------------------------------------------------------------------------