def resnet50v2(input_shape: Tuple[int, int, int], output_shape: Tuple[int, ...], weights: str='imagenet', include_top: bool=False) -> Model:
base_model = ResNet50V2(weights=weights, include_top=include_top, input_tensor=Input(shape=input_shape))
if include_top:
return base_model
else:
# Construct the head of the model that will be placed on top of the base model
num_classes = output_shape[0]
head_model=base_model.output
head_model=AveragePooling2D(pool_size=(4, 4))(head_model)
head_model=Flatten(name='flatten')(head_model)
head_model=Dense(64, activation='relu')(head_model)
head_model=Dropout(0.5)(head_model)
if num_classes > 2:
activation = 'softmax'
else:
activation = 'sigmoid'
head_model=Dense(num_classes, activation=activation)(head_model)
# Place the head Fully Connected model on top of the base model (actual model)
model=Model(base_model.input, head_model)
# Loop over all layers in the base model and freeze them so they won't be updated during the first training process
for layer in base_model.layers:
layer.trainable=False
return model
def loader(input_shape,
num_outputs,
output_activation="log_softmax",
channel_dropout_rate=0):
inputs = Input(shape=input_shape, name="input")
x = inputs
if channel_dropout_rate > 0:
x = Dropout(rate=channel_dropout_rate,
noise_shape=(None, 1, input_shape[1]),
name="channel_dropout")(x)
x = Reshape((input_shape[0] or -1, input_shape[1], 1),
name="reshape_to_image")(x)
resnet = ResNet50V2(include_top=False, weights=None, input_tensor=x)
rows, cols, channels = resnet.output.shape[1:]
x = Reshape((rows or -1, cols * channels),
name="flatten_channels")(resnet.output)
x = FrameLayer(512, 5, 1, name="frame1")(x)
x = FrameLayer(512, 3, 2, name="frame2")(x)
x = FrameLayer(512, 3, 3, name="frame3")(x)
x = FrameLayer(512, 1, 1, name="frame4")(x)
x = FrameLayer(1500, 1, 1, name="frame5")(x)
x = GlobalMeanStddevPooling1D(name="stats_pooling")(x)
x = SegmentLayer(512, name="segment1")(x)
x = SegmentLayer(512, name="segment2")(x)
outputs = Dense(num_outputs, name="output", activation=None)(x)
if output_activation:
outputs = Activation(getattr(tf.nn, output_activation),
name=str(output_activation))(outputs)
return Model(inputs=inputs, outputs=outputs, name="resnet50-x-vector")
def loader(input_shape,
num_outputs,
core="resnet50_v2",
output_activation="softmax"):
# Normalize and regularize by adding Gaussian noise to input (during training only)
inputs = Input(shape=input_shape, name="input")
x = inputs
x = GaussianNoise(stddev=0.01, name="input_noise")(x)
x = Dropout(0.2,
noise_shape=(None, 1, input_shape[1]),
name="channel_dropout")(x)
x = Reshape((input_shape[0] or -1, input_shape[1], 1),
name="reshape_to_image")(x)
# Connect untrained Resnet50 or MobileNet architecture without inputs and outputs
if core == "mobilenet_v2":
convnet = MobileNetV2(include_top=False, weights=None, input_tensor=x)
elif core == "resnet50_v2":
convnet = ResNet50V2(include_top=False, weights=None, input_tensor=x)
# Embedding layer with timesteps
rows, cols, channels = convnet.output.shape[1:]
x = Reshape((rows or -1, cols * channels),
name="flatten_channels")(convnet.output)
x = Dense(128, activation="sigmoid", name="embedding")(x)
x = BatchNormalization(name="embedding_bn")(x)
# Pooling and output
x = GlobalAveragePooling1D(name="timesteps_pooling")(x)
outputs = Dense(num_outputs, activation=None, name="output")(x)
if output_activation:
outputs = Activation(getattr(tf.nn, output_activation),
name=str(output_activation))(outputs)
return Model(inputs=inputs,
outputs=outputs,
name="{}_extractor".format(core))
def DAFE(input_shape, n_classes):
# ResNet50 backbone (bottom-up)
resnet = ResNet50V2(weights='imagenet', include_top=False,
input_shape=input_shape)
conv2 = resnet.get_layer('pool1_pool').output
conv3 = resnet.get_layer('conv2_block3_out').output
conv4 = resnet.get_layer('conv3_block4_out').output
conv5 = resnet.get_layer('conv4_block6_out').output
# DAFE blocks (top-down)
x = sau_block([conv5, conv4], 512, name='sau1')
x = cas_block(x, [256, 512], name='cas1')
x = layers.Add(name='dafe1_out')([x, conv4])
x = sau_block([x, conv3], 256, name='sau2')
x = cas_block(x, [64, 256], name='cas2')
x = layers.Add(name='dafe2_out')([x, conv3])
x = sau_block([x, conv2], 64, name='sau3')
x = cas_block(x, [32, 64], name='cas3')
x = layers.Add(name='dafe3_out')([x, conv2])
# Classifier
x = layers.Conv2D(n_classes, (1, 1), padding='same', activation='linear',
name='conv_classifier')(x)
return tf.keras.models.Model(inputs=resnet.input, outputs=x, name='dafe')
def Resnet(input_shape=(384, 384, 3)):
resnet = ResNet50V2(input_shape=input_shape, weights='imagenet', include_top=False)
out_f1 = resnet.get_layer('conv2_block3_1_relu').output
out_f2 = resnet.get_layer('conv3_block4_1_relu').output
out_f3 = resnet.get_layer('conv4_block6_1_relu').output
model = KM.Model(resnet.inputs, [out_f1, out_f2, out_f3])
return model
def loader(input_shape,
num_outputs,
core="resnet50_v2",
embedding_dim=512,
output_activation="log_softmax",
channel_dropout_rate=0):
inputs = Input(shape=input_shape, name="input")
x = inputs
if channel_dropout_rate > 0:
x = Dropout(rate=channel_dropout_rate,
noise_shape=(None, 1, input_shape[1]),
name="channel_dropout")(x)
x = Reshape((input_shape[0] or -1, input_shape[1], 1),
name="reshape_to_image")(x)
# Connect untrained Resnet50 or MobileNet architecture without inputs and outputs
if core == "mobilenet_v2":
convnet = MobileNetV2(include_top=False, weights=None, input_tensor=x)
elif core == "resnet50_v2":
convnet = ResNet50V2(include_top=False, weights=None, input_tensor=x)
# Embedding layer with timesteps
rows, cols, channels = convnet.output.shape[1:]
x = Reshape((rows or -1, cols * channels),
name="flatten_channels")(convnet.output)
x = Dense(embedding_dim, activation=None, name="embedding")(x)
x = Activation("relu", name="embedding_relu")(x)
x = BatchNormalization(name="embedding_bn")(x)
# Pooling and output
x = GlobalAveragePooling1D(name="timesteps_pooling")(x)
outputs = Dense(num_outputs, activation=None, name="output")(x)
if output_activation:
outputs = Activation(getattr(tf.nn, output_activation),
name=str(output_activation))(outputs)
return Model(inputs=inputs,
outputs=outputs,
name="{}_extractor".format(core))
def transfer_learning(input_shape):
base_model = ResNet50V2(include_top=False, input_shape=(224, 224, 3), pooling='avg', weights='imagenet')
# Freeze the layers except the last 12 layers (which contains few sets of Conv layers and batch normalization
# layers)
count_layers = 0
for layer in base_model.layers[:-12]:
layer.trainable = False
count_layers = count_layers + 1
print(count_layers, "Number of layers in Resnet50")
# Check the trainable status of the individual layers
for layer in base_model.layers:
print(layer, layer.trainable)
base_model.summary()
# Keras input layer
inputs = keras.Input(shape=(256, 256, 3))
# preprocessing layer to resize image to 224*224, as Resnet input layer accepts 224,224,3
r_input = keras.layers.experimental.preprocessing.Resizing(224, 224)(inputs)
out = base_model(r_input)
out = keras.layers.Dense(16, activation=tf.nn.relu,kernel_regularizer=keras.regularizers.l1(0.0001))(out)
out = keras.layers.Dropout(0.6)(out)
out = keras.layers.Dense(2, activation=tf.nn.softmax)(out)
model = keras.Model(inputs, out)
# Model Summary
model.summary()
return model
def define_model(architecture, input_shape=(128, 128, 3), n_classes=4):
if architecture == 'ResNet50V2':
base_model = ResNet50V2(weights='imagenet',
include_top=False,
input_shape=input_shape)
elif architecture == 'VGG16':
base_model = VGG16(weights='imagenet',
include_top=False,
input_shape=input_shape)
elif architecture == 'VGG19':
base_model = VGG19(weights='imagenet',
include_top=False,
input_shape=input_shape)
elif architecture == 'DenseNet121':
base_model = DenseNet121(weights='imagenet',
include_top=False,
input_shape=input_shape)
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(512, activation='relu')(x)
predictions = Dense(n_classes, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=predictions)
return model
def build_model(classes=2):
inputs = Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3))
x = preprocess_input(inputs)
x = ResNet50V2(weights=None, classes=classes)(x)
model = Model(inputs=inputs, outputs=x)
model.compile(loss='categorical_crossentropy', metrics=['accuracy'])
return model
def __init__(self, model_name=None):
if model_name == 'Xception':
base_model = Xception(weights='imagenet')
self.preprocess_input = xception.preprocess_input
elif model_name == 'VGG19':
base_model = VGG19(weights='imagenet')
self.preprocess_input = vgg19.preprocess_input
elif model_name == 'ResNet50':
base_model = ResNet50(weights='imagenet')
self.preprocess_input = resnet.preprocess_input
elif model_name == 'ResNet101':
base_model = ResNet101(weights='imagenet')
self.preprocess_input = resnet.preprocess_input
elif model_name == 'ResNet152':
base_model = ResNet152(weights='imagenet')
self.preprocess_input = resnet.preprocess_input
elif model_name == 'ResNet50V2':
base_model = ResNet50V2(weights='imagenet')
self.preprocess_input = resnet_v2.preprocess_input
elif model_name == 'ResNet101V2':
base_model = ResNet101V2(weights='imagenet')
self.preprocess_input = resnet_v2.preprocess_input
elif model_name == 'ResNet152V2':
base_model = ResNet152V2(weights='imagenet')
self.preprocess_input = resnet_v2.preprocess_input
elif model_name == 'InceptionV3':
base_model = InceptionV3(weights='imagenet')
self.preprocess_input = inception_v3.preprocess_input
elif model_name == 'InceptionResNetV2':
base_model = InceptionResNetV2(weights='imagenet')
self.preprocess_input = inception_resnet_v2.preprocess_input
elif model_name == 'DenseNet121':
base_model = DenseNet121(weights='imagenet')
self.preprocess_input = densenet.preprocess_input
elif model_name == 'DenseNet169':
base_model = DenseNet169(weights='imagenet')
self.preprocess_input = densenet.preprocess_input
elif model_name == 'DenseNet201':
base_model = DenseNet201(weights='imagenet')
self.preprocess_input = densenet.preprocess_input
elif model_name == 'NASNetLarge':
base_model = NASNetLarge(weights='imagenet')
self.preprocess_input = nasnet.preprocess_input
elif model_name == 'NASNetMobile':
base_model = NASNetMobile(weights='imagenet')
self.preprocess_input = nasnet.preprocess_input
elif model_name == 'MobileNet':
base_model = MobileNet(weights='imagenet')
self.preprocess_input = mobilenet.preprocess_input
elif model_name == 'MobileNetV2':
base_model = MobileNetV2(weights='imagenet')
self.preprocess_input = mobilenet_v2.preprocess_input
else:
base_model = VGG16(weights='imagenet')
self.preprocess_input = vgg16.preprocess_input
self.model = Model(inputs=base_model.input,
outputs=base_model.layers[-2].output)
def build_model(self, weights, includeTop, inputShape):
baseModel = ResNet50V2(weights=weights,
include_top=includeTop,
input_shape=inputShape)
model = Model(inputs=baseModel.input,
outputs=baseModel.get_layer('avg_pool').output)
return model
def __init__(self,
optimizer=Adam(),
loss=categorical_crossentropy,
metrics=[top_k_categorical_accuracy]):
super().__init__(optimizer=optimizer,
loss=loss,
metrics=metrics,
MODEL_NAME=RESNET_NAME)
self.resnet = ResNet50V2()
self.resnet.layers[-1].activation = tf.keras.activations.linear
def __init__(self, network='resnet', num_classes=31):
super(Classifier, self).__init__()
self.num_classes = num_classes
if network == 'resnet':
self.feature_extractor = ResNet50V2(weights='imagenet', include_top=False, input_shape=(224, 224, 3),
pooling='avg')
else:
raise NotImplementedError(f"Network {network} is not implemented yet.")
self.label_predictor = Dense(self.num_classes)
def load_VanilaResNet50():
resnet = ResNet50V2(include_top=False, pooling="avg", weights='imagenet')
for layer in resnet.layers:
layer.trainable = False
logits = Dense(2)(resnet.layers[-1].output)
output = Activation('softmax')(logits)
model = Model(resnet.input, output)
model.load_weights("{}/resnet50best.hdf5".format(MODEL_DIR))
return model
def resnet50V2Model():
baseModel = ResNet50V2(
weights=None,
include_top=False,
input_shape=(32, 32, 3),
)
model_input = Input(shape=(32, 32, 3))
x = baseModel(model_input)
x = GlobalAveragePooling2D()(x)
model_output = Dense(10, activation="softmax")(x)
model = Model(inputs=model_input, outputs=model_output)
return model
def __call__(self):
resnet = ResNet50V2(include_top=False,
pooling="avg",
weights='imagenet')
for layer in resnet.layers:
layer.trainable = False
logits = Dense(2)(resnet.layers[-1].output)
output = Activation('softmax')(logits)
model = Model(resnet.input, output)
return model
def cifar_model(x_test, model_name='MobileNetV2', num_classes=10):
# Load model from tensorlfow
include_top = False
weights = 'imagenet'
input_tensor = Input(x_test.shape[1:], dtype='float16')
input_shape = x_test.shape[1:]
pooling = None
classes = num_classes
if model_name == 'MobileNetV2':
KerasModel = MobileNetV2(include_top=include_top,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes)
elif model_name == 'ResNet50V2':
KerasModel = ResNet50V2(include_top=include_top,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classifier_activation='softmax',
classes=classes)
elif model_name == 'ResNet50':
KerasModel = ResNet50(include_top=include_top,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classifier_activation='softmax',
classes=classes)
elif model_name == 'DenseNet121':
KerasModel = DenseNet121(include_top=include_top,
weights=weights,
input_tensor=input_tensor,
input_shape=input_shape,
pooling=pooling,
classes=classes)
inputs = KerasModel.input
output = KerasModel.output
x = GlobalAveragePooling2D()(output)
x = Flatten()(x)
x = Dense(num_classes, kernel_initializer='he_normal')(x)
outputs = Softmax(dtype='float32')(x)
# Instantiate model.
model = Model(inputs=inputs, outputs=outputs)
return model
def transfer_resnet50v2():
resnet50v2 = ResNet50V2(include_top=False,weights='imagenet',input_shape=(160,160,3))
resnet50v2_preprocess = tf.keras.applications.resnet50.preprocess_input
inputs = tf.keras.Input(shape=(160,160,3))
x = resnet50v2_preprocess(inputs)
x = resnet50v2(inputs,training=False)
x = tf.keras.layers.GlobalAveragePooling2D()(x)
outputs = tf.keras.layers.Dense(units=10,activation='sigmoid')(x)
custom_resnet50v2 = tf.keras.Model(inputs,outputs)
custom_resnet50v2.summary()
return custom_resnet50v2
def __init__(self, n_classes=2):
resnet = ResNet50V2(include_top=False,
pooling="avg",
weights='imagenet')
for layer in resnet.layers:
layer.trainable = False
fc1 = Dense(100)(resnet.layers[-1].output)
fc2 = Dense(100)(fc1)
logits = Dense(2)(fc2)
output = Activation('softmax')(logits)
model = Model(resnet.input, output)
return model
def loadModel(self, name, output_layer=None):
model = None
name = name.lower()
self._model_name = name
model = ResNet50V2(weights='imagenet', include_top=False)
self._last_dim = 7
model = Model(inputs=model.inputs,
outputs=model.layers[output_layer].output)
self._model = model
def __get_bottleneck(self, ):
if self.net == "mobilenet":
bottleneck = MobileNetV2(input_shape=self.input_shape, include_top=False, weights='imagenet')
elif self.net == "resnet":
bottleneck = ResNet50V2(input_shape=self.input_shape, include_top=False, weights='imagenet')
elif self.net == "vgg16":
bottleneck = VGG16(include_top=False, weights='imagenet', input_shape=self.input_shape)
elif self.net == "inception":
bottleneck = InceptionNetwork(
input_shape=self.input_shape,
emd_size=self.emd_size,
weights=self.kwargs.get('weights', None)
)
return bottleneck
def frozen_resnet(input_size, n_classes):
model_ = ResNet50V2(include_top=False, input_tensor=Input(shape=input_size))
# include_top = False : flatten() layer 전 층까지만 가져다 쓴다
# include_top = True : flatten() layer 까지 다 가져 와서 쓴다
for layer in model_.layers:
layer.trainable = False # frozen 상태로 가중치만 가져온다
# x = Flatten(input_shape=model_.output_shape[1:])(model_.layers[-1].output)
x = Flatten()(model_.layers[-1].output)
x = Dense(n_classes, activation='softmax')(x)
# output layer, n_classes : 클래스 개수(라벨의 개수)
frozen_model = Model(model_.input, x)
# 함수형 모델이므로 마지막에 input과 output을 Model()에 넣어준다
return frozen_model
def __get_bottleneck(self, ):
if self.net == "mobilenet":
bottleneck = MobileNetV2(input_shape=self.input_shape,
include_top=False,
weights='imagenet')
elif self.net == "resnet":
bottleneck = ResNet50V2(input_shape=self.input_shape,
include_top=False,
weights='imagenet')
elif self.net == "vgg16":
bottleneck = VGG16(include_top=False,
weights='imagenet',
input_shape=self.input_shape)
return bottleneck
def resnet50V2_build_model():
w_init = glorot_normal()
b_init = Zeros()
res_net50v2 = ResNet50V2(input_shape=(512, 512, 3),
include_top=False,
weights="imagenet",
pooling="avg")
for layer in res_net50v2.layers:
layer.trainable = False
model = Sequential()
model.add(res_net50v2)
model.add(Flatten())
model.add(Dropout(0.2))
model.add(
Dense(276,
activation='relu',
kernel_initializer=w_init,
bias_initializer=b_init,
kernel_regularizer='l2'))
model.add(BatchNormalization())
model.add(
Dense(3,
activation='softmax',
kernel_initializer=w_init,
bias_initializer=b_init,
kernel_regularizer='l2'))
model.summary()
optimizer = tf.keras.optimizers.Adam(
learning_rate=0.00001,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
amsgrad=False,
name="Adam",
)
loss = tf.keras.losses.CategoricalCrossentropy(
from_logits=False,
label_smoothing=0.05,
reduction="auto",
name="categorical_crossentropy",
)
model.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])
return model
def get_encoder_model(name, in_shape, pooling):
if name == "InceptionV3":
model = InceptionV3(include_top=False,
input_shape=in_shape,
weights=None,
pooling=pooling)
elif name == "ResNet50":
model = ResNet50(include_top=False,
input_shape=in_shape,
weights=None,
pooling=pooling)
elif name == "ResNet50V2":
model = ResNet50V2(include_top=False,
input_shape=in_shape,
weights=None,
pooling=pooling)
elif name == "ResNet101":
model = ResNet101(include_top=False,
input_shape=in_shape,
weights=None,
pooling=pooling)
elif name == "ResNet101V2":
model = ResNet101V2(include_top=False,
input_shape=in_shape,
weights=None,
pooling=pooling)
elif name == "ResNet152":
model = ResNet152(include_top=False,
input_shape=in_shape,
weights=None,
pooling=pooling)
elif name == "InceptionResNetV2":
model = InceptionResNetV2(include_top=False,
input_shape=in_shape,
weights=None,
pooling=pooling)
elif name == "DenseNet121":
model = DenseNet121(include_top=False,
input_shape=in_shape,
weights=None,
pooling=pooling)
else:
raise ValueError("model " + name + " not found")
return model
def _build_network(self, input_tensor, is_training):
"""
https://github.com/bgshih/crnn/blob/master/model/crnn_demo/config.lua
:return:
"""
net = tf.add(input_tensor, (-128.0))
net = tf.multiply(net, (1 / 128.0))
resnet = ResNet50V2(weights="imagenet",
input_tensor=net,
input_shape=(300, 40, 3),
include_top=False)
for layer in resnet.layers:
layer.trainable = False
# resnet = resnet.layers[-37].output
net = tf.squeeze(resnet.layers[-34].output, axis=1)
# net = Flatten()(net)
print(net)
self.model = net
def define_model(self):
if config.BASE_MODEL == 'ResNet50V2':
# Pre-trained model with MobileNetV2
base_model = ResNet50V2(input_shape=config.IMG_SHAPE,
include_top=False,
weights='imagenet')
print("Number of layers in the base model: ",
len(base_model.layers))
head_model = base_model
for layers in base_model.layers[:self.n_layers]:
layers.trainable = False
head_model = head_model.output
head_model = tf.keras.layers.GlobalMaxPooling2D()(head_model)
head_model = tf.keras.layers.Flatten(name="Flatten")(head_model)
head_model = tf.keras.layers.Dense(1024,
activation='relu')(head_model)
head_model = tf.keras.layers.Dropout(0.2)(head_model)
prediction_layer = tf.keras.layers.Dense(
len(config.CLASS_NAMES), activation='softmax')(head_model)
model = tf.keras.Model(inputs=base_model.input,
outputs=prediction_layer)
if config.BASE_MODEL == 'InceptionV3':
base_model = InceptionV3(input_shape=config.IMG_SHAPE,
include_top=False,
weights='imagenet')
print("Number of layers in the base model: ",
len(base_model.layers))
head_model = base_model
for layers in base_model.layers[:self.n_layers]:
layers.trainable = False
head_model = head_model.output
head_model = tf.keras.layers.GlobalMaxPooling2D()(head_model)
head_model = tf.keras.layers.Flatten(name="Flatten")(head_model)
head_model = tf.keras.layers.Dense(1024,
activation='relu')(head_model)
head_model = tf.keras.layers.Dropout(0.5)(head_model)
prediction_layer = tf.keras.layers.Dense(
len(config.CLASS_NAMES), activation='softmax')(head_model)
model = tf.keras.Model(inputs=base_model.input,
outputs=prediction_layer)
return model
def get_model(transfer_layer):
model = ResNet50V2(weights="imagenet",
include_top=False,
input_shape=(224, 224, 3))
for layer in model.layers:
layer.trainable = False
X = model.get_layer(transfer_layer).output
X = tf.keras.layers.Conv2D(64, 1)(X)
x = tf.keras.layers.BatchNormalization()(X)
X = tf.keras.layers.Activation("relu")(X)
X = tf.keras.layers.GlobalAveragePooling2D()(X)
X = tf.keras.layers.Dense(32, activation='relu')(X)
X = tf.keras.layers.Dense(classes, activation='sigmoid')(X)
new_model = tf.keras.Model(inputs=model.input, outputs=X)
Input_Layer = tf.keras.layers.Input(shape=(224, 224, 3))
In = tf.keras.layers.BatchNormalization()(Input_Layer)
out = new_model(In)
new_model = tf.keras.Model(inputs=Input_Layer, outputs=out)
return new_model
def __init__(self, n_classes, name='resnet50', weights='imagenet'):
"""
:param n_classes: int, number of classes (units in the last layer)
:param name: string, name of the model
:param weights: one of 'imagenet', or path to the pretrained weights to load
"""
super().__init__(name=name)
self._n_classes = n_classes
self._transfer_learning = weights is not None
if weights is not None and weights != 'imagenet': # weights for the whole model
load_whole = True
weights_resnet = None
else:
load_whole = False
weights_resnet = weights
self._feature_extractor = Sequential([
Rescaling(1. / 127.5, offset=-1),
ResNet50V2(include_top=False,
weights=weights_resnet,
input_shape=self.image_shape)
],
name='feature_extractor')
self._classifier = Sequential(
[GlobalAveragePooling2D(),
Dense(n_classes, activation='softmax')],
name='classifier')
if load_whole:
self.load_weights(weights)
# required for summary()
inputs = Input(shape=self.image_shape)
outputs = self.call(inputs)
super().__init__(name=name, inputs=inputs, outputs=outputs)
self.build(input_shape=(None, self.image_shape[0], self.image_shape[1],
self.image_shape[2]))
def __init__(self, weights_init, model_architecture='vgg16'):
self.weights_init = weights_init
if model_architecture == 'vgg16':
self.model = VGG16(weights=self.weights_init, include_top=False)
self.bridge_list = [2, 5, 9, 13, 17]
elif model_architecture == 'vgg19':
self.model = VGG19(weights=self.weights_init, include_top=False)
self.bridge_list = [2, 5, 10, 15, 20]
elif model_architecture == 'resnet50':
self.model = ResNet50(weights=self.weights_init, include_top=False)
self.bridge_list = [4, 38, 80, 142, -1]
elif model_architecture == 'resnet50v2':
self.model = ResNet50V2(weights=self.weights_init,
include_top=False)
self.bridge_list = [2, 27, 62, 108, -1]
elif model_architecture == 'resnet101':
self.model = ResNet101(weghts=self.weights_init, include_top=False)
self.bridge_list = [4, 38, 80, 312, -1]
elif model_architecture == 'resnet101v2':
self.model = ResNet101V2(weights=self.weights_init,
include_top=False)
self.bridge_list = [2, 27, 62, 328, -1]
elif model_architecture == 'resnet152':
self.model = ResNet152(weights=self.weights_init,
include_top=False)
self.bridge_list = [4, 38, 120, 482, -1]
elif model_architecture == 'resnet152v2':
self.model = ResNet152V2(weights=self.weights_init,
include_top=False)
self.bridge_list = [2, 27, 117, 515, -1]