def create_model():
base_model = efn.EfficientNetB4(weights="imagenet",
include_top=False,
input_shape=(512, 512, 3),
pooling='avg')
x = base_model.output
x = Dense(1, activation="relu")(x)
model = Model(inputs=base_model.input, outputs=x)
model.load_weights('./Experiments/PH_1/EX_55/EX_55.hdf5')
# model.save_weights("tmp.h5")
# first: train only the top layers (which were randomly initialized)
# i.e. freeze all convolutional InceptionV3 layers
# for layer in base_model.layers:
# layer.trainable = False
# regularizer = l2(l2=0.005)
# for layer in model.layers:
# #'kernel_regularizer'
# for attr in ['bias_regularizer']:
# if hasattr(layer, attr) and layer.trainable:
# setattr(layer, attr, regularizer)
#
#
# out = model_from_json(model.to_json())
# out.load_weights("tmp.h5", by_name=True)
return model
def get_model(model='b2', shape=(320,320)):
K.clear_session()
h,w = shape
if model == 'b0':
base_model = efn.EfficientNetB0(weights='imagenet', include_top=False, pooling='avg', input_shape=(h, w, 3))
elif model == 'b1':
base_model = efn.EfficientNetB1(weights='imagenet', include_top=False, pooling='avg', input_shape=(h, w, 3))
elif model == 'b2':
base_model = efn.EfficientNetB2(weights='imagenet', include_top=False, pooling='avg', input_shape=(h, w, 3))
elif model == 'b3':
base_model = efn.EfficientNetB3(weights='imagenet', include_top=False, pooling='avg', input_shape=(h, w, 3))
elif model == 'b4':
base_model = efn.EfficientNetB4(weights='imagenet', include_top=False, pooling='avg', input_shape=(h, w, 3))
elif model == 'b5':
base_model = efn.EfficientNetB5(weights='imagenet', include_top=False, pooling='avg', input_shape=(h, w, 3))
elif model == 'b6':
base_model = efn.EfficientNetB6(weights='imagenet', include_top=False, pooling='avg', input_shape=(h, w, 3))
else:
base_model = efn.EfficientNetB7(weights='imagenet', include_top=False, pooling='avg', input_shape=(h, w, 3))
x = base_model.output
y_pred = Dense(4, activation='sigmoid')(x)
return Model(inputs=base_model.input, outputs=y_pred)
def get_efficientnet_model(
model_name='efficientnetb0',
input_shape=(224, 224, 3),
input_tensor=None,
include_top=True,
classes=1000,
weights='imagenet',
):
layer_names = [
'block3a_expand_activation', #C2
'block4a_expand_activation', #C3
'block6a_expand_activation', #C4
'top_activation' #C5
]
Args = {
'input_shape': input_shape,
'weights': weights,
'include_top': include_top,
'input_tensor': input_tensor
}
if model_name == 'efficientnetb0':
backbone = efn.EfficientNetB0(**Args)
elif model_name == 'efficientnetb1':
backbone = efn.EfficientNetB1(**Args)
elif model_name == 'efficientnetb2':
backbone = efn.EfficientNetB2(**Args)
elif model_name == 'efficientnetb3':
backbone = efn.EfficientNetB3(**Args)
elif model_name == 'efficientnetb4':
backbone = efn.EfficientNetB4(**Args)
elif model_name == 'efficientnetb5':
backbone = efn.EfficientNetB5(**Args)
elif model_name == 'efficientnetb6':
backbone = efn.EfficientNetB6(**Args)
elif model_name == 'efficientnetb7':
backbone = efn.EfficientNetB7(**Args)
else:
raise ValueError('No such model {}'.format(model_name))
several_layers = []
several_layers.append(backbone.get_layer(layer_names[0]).output)
several_layers.append(backbone.get_layer(layer_names[1]).output)
several_layers.append(backbone.get_layer(layer_names[2]).output)
several_layers.append(backbone.get_layer(layer_names[3]).output)
model = keras.models.Model(inputs=[backbone.input], outputs=several_layers)
return model
def create_model():
K.clear_session()
base_model = efn.EfficientNetB4(weights = 'imagenet', include_top = False, pooling = 'avg', input_shape = input_image_shape)
x = base_model.output
x = Dropout(0.2)(x)
y_pred = Dense(6, activation = 'sigmoid')(x)
return Model(inputs = base_model.input, outputs = y_pred)
def effnet_retinanet(num_classes, backbone='EfficientNetB0', inputs=None, modifier=None, **kwargs):
""" Constructs a retinanet model using a resnet backbone.
Args
num_classes: Number of classes to predict.
backbone: Which backbone to use (one of ('resnet50', 'resnet101', 'resnet152')).
inputs: The inputs to the network (defaults to a Tensor of shape (None, None, 3)).
modifier: A function handler which can modify the backbone before using it in retinanet (this can be used to freeze backbone layers for example).
Returns
RetinaNet model with a ResNet backbone.
"""
# choose default input
if inputs is None:
if keras.backend.image_data_format() == 'channels_first':
inputs = keras.layers.Input(shape=(3, None, None))
else:
# inputs = keras.layers.Input(shape=(224, 224, 3))
inputs = keras.layers.Input(shape=(None, None, 3))
# get last conv layer from the end of each block [28x28, 14x14, 7x7]
if backbone == 'EfficientNetB0':
model = efn.EfficientNetB0(input_tensor=inputs, include_top=False, weights=None)
elif backbone == 'EfficientNetB1':
model = efn.EfficientNetB1(input_tensor=inputs, include_top=False, weights=None)
elif backbone == 'EfficientNetB2':
model = efn.EfficientNetB2(input_tensor=inputs, include_top=False, weights=None)
elif backbone == 'EfficientNetB3':
model = efn.EfficientNetB3(input_tensor=inputs, include_top=False, weights=None)
elif backbone == 'EfficientNetB4':
model = efn.EfficientNetB4(input_tensor=inputs, include_top=False, weights=None)
elif backbone == 'EfficientNetB5':
model = efn.EfficientNetB5(input_tensor=inputs, include_top=False, weights=None)
elif backbone == 'EfficientNetB6':
model = efn.EfficientNetB6(input_tensor=inputs, include_top=False, weights=None)
elif backbone == 'EfficientNetB7':
model = efn.EfficientNetB7(input_tensor=inputs, include_top=False, weights=None)
else:
raise ValueError('Backbone (\'{}\') is invalid.'.format(backbone))
layer_outputs = ['block4a_expand_activation', 'block6a_expand_activation', 'top_activation']
layer_outputs = [
model.get_layer(name=layer_outputs[0]).output, # 28x28
model.get_layer(name=layer_outputs[1]).output, # 14x14
model.get_layer(name=layer_outputs[2]).output, # 7x7
]
# create the densenet backbone
model = keras.models.Model(inputs=inputs, outputs=layer_outputs, name=model.name)
# invoke modifier if given
if modifier:
model = modifier(model)
# create the full model
return retinanet.retinanet(inputs=inputs, num_classes=num_classes, backbone_layers=model.outputs, **kwargs)
def create_model(path):
base_model = efn.EfficientNetB4(weights=None,
include_top=False,
input_shape=(512, 512, 3), pooling='avg')
## base_model = InceptionV3(weights=None , include_top=False, input_tensor=None, input_shape=(299, 299, 3), pooling='avg')
x = base_model.output
x = Dense(1, activation="relu")(x)
model = Model(inputs = base_model.input, outputs = x)
model.summary()
model.load_weights(path)
return model
def frozen_efficientnet(input_size,
n_classes,
local_weights="/efficientnet/EfficientNetB4.h5"):
if local_weights and path.exists(local_weights):
print(f'Using {local_weights} as local weights.')
model_ = efn.EfficientNetB4(include_top=False,
input_tensor=Input(shape=input_size),
weights=local_weights)
else:
print(
f'Could not find local weights {local_weights} for ResNet. Using remote weights.'
)
model_ = efn.EfficientNetB4(include_top=False,
input_tensor=Input(shape=input_size))
for layer in model_.layers:
layer.trainable = False
x = Flatten(input_shape=model_.output_shape[1:])(model_.layers[-1].output)
x = Dense(n_classes, activation='softmax')(x)
frozen_model = Model(model_.input, x)
return frozen_model
def construct_mlp(input_size, num_classes, num_frames,
dropout_size=0.5, ef_mode=4, l2_reg=1e-5):
"""
Construct a MLP model for urban sound tagging.
Parameters
----------
num_frames
input_size
num_classes
dropout_size
ef_mode
l2_reg
Returns
-------
model
"""
# Add hidden layers
from keras.layers import Flatten, Conv1D, Conv2D, GlobalMaxPooling1D, GlobalAveragePooling1D, LSTM, Concatenate, GlobalAveragePooling2D, LeakyReLU
import efficientnet.keras as efn
if ef_mode == 0:
base_model = efn.EfficientNetB0(weights='noisy-student', include_top=False, pooling='avg')
elif ef_mode == 1:
base_model = efn.EfficientNetB1(weights='noisy-student', include_top=False, pooling='avg')
elif ef_mode == 2:
base_model = efn.EfficientNetB2(weights='noisy-student', include_top=False, pooling='avg')
elif ef_mode == 3:
base_model = efn.EfficientNetB3(weights='noisy-student', include_top=False, pooling='avg')
elif ef_mode == 4:
base_model = efn.EfficientNetB4(weights='noisy-student', include_top=False, pooling='avg') #imagenet or weights='noisy-student'
elif ef_mode == 5:
base_model = efn.EfficientNetB5(weights='noisy-student', include_top=False, pooling='avg')
elif ef_mode == 6:
base_model = efn.EfficientNetB6(weights='noisy-student', include_top=False, pooling='avg')
elif ef_mode == 7:
base_model = efn.EfficientNetB7(weights='noisy-student', include_top=False, pooling='avg')
input1 = Input(shape=input_size, dtype='float32', name='input')
input2 = Input(shape=(num_frames,85), dtype='float32', name='input2') #1621
y = TimeDistributed(base_model)(input1)
y = TimeDistributed(Dropout(dropout_size))(y)
y = Concatenate()([y, input2])
y = TimeDistributed(Dense(num_classes, activation='sigmoid', kernel_regularizer=regularizers.l2(l2_reg)))(y)
y = AutoPool1D(axis=1, name='output')(y)
m = Model(inputs=[input1, input2], outputs=y)
m.summary()
m.name = 'urban_sound_classifier'
return m
def getB4Net(self, shape, model_name):
effnet = efn.EfficientNetB4(weights=None,\
include_top=False,\
input_shape=shape)
#effnet.load_weights(self.weight_path + 'efficientnet-b4_imagenet_1000_notop.h5')
for i, layer in enumerate(effnet.layers):
effnet.layers[i].name = str(model_name) + "_" + layer.name
if "batch_normalization" in layer.name:
effnet.layers[i] = GroupNormalization(groups=self.batch_size,
axis=-1,
epsilon=0.00001)
return effnet
def model_fn(objective, optimizer, metrics):
base_model = efn.EfficientNetB4(
include_top=False,
# base_model = seresnext50(include_top=False,
# base_model = xception(include_top=False,
# base_model = densenet201(include_top=False,
# base_model = inceptionresnetv2(include_top=False,
input_shape=(input_size, input_size, 3),
classes=num_classes,
weights='imagenet',
)
x = base_model.output
x = GlobalAveragePooling2D()(x)
predictions = Dense(9, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=predictions)
model.compile(loss=objective, optimizer=optimizer, metrics=metrics)
model.summary()
return model
def get_model(EfficientNet):
K.clear_session()
dic = {
'EfficientNetB2':
efn.EfficientNetB2(weights='imagenet',
include_top=False,
pooling='avg',
input_shape=(260, 260, 3)),
'EFficientNetB4':
efn.EfficientNetB4(weights='imagenet',
include_top=False,
pooling='avg',
input_shape=(260, 260, 3))
}
base_model = dic[EfficientNet]
x = base_model.output
y_pred = Dense(4, activation='sigmoid')(x)
return Model(inputs=base_model.input, outputs=y_pred)
def get_model_effnet(img_shape, img_input, weights, effnet_version):
if effnet_version == 'B0':
effnet = efn.EfficientNetB0(include_top=False, input_tensor=img_input, weights=weights, pooling=None, input_shape=img_shape)
elif effnet_version == 'B1':
effnet = efn.EfficientNetB1(include_top=False, input_tensor=img_input, weights=weights, pooling=None, input_shape=img_shape)
elif effnet_version == 'B2':
effnet = efn.EfficientNetB2(include_top=False, input_tensor=img_input, weights=weights, pooling=None, input_shape=img_shape)
elif effnet_version == 'B3':
effnet = efn.EfficientNetB3(include_top=False, input_tensor=img_input, weights=weights, pooling=None, input_shape=img_shape)
elif effnet_version == 'B4':
effnet = efn.EfficientNetB4(include_top=False, input_tensor=img_input, weights=weights, pooling=None, input_shape=img_shape)
elif effnet_version == 'B5':
effnet = efn.EfficientNetB5(include_top=False, input_tensor=img_input, weights=weights, pooling=None, input_shape=img_shape)
elif effnet_version == 'B6':
effnet = efn.EfficientNetB6(include_top=False, input_tensor=img_input, weights=weights, pooling=None, input_shape=img_shape)
else:
effnet = efn.EfficientNetB7(include_top=False, input_tensor=img_input, weights=weights, pooling=None, input_shape=img_shape)
return effnet
def create_model(self,
total_model_weight_path=None,
base_model_weight_path=None,
bottleneck_weight_path=None,
input_layer=None):
model = en.EfficientNetB4(include_top=False,
weights=None,
input_tensor=None,
input_shape=(self.size[0], self.size[1], 3))
conf = model.layers[-3].get_config()
conf['filters'] = 64
x = model.layers[-4].output
x = Conv2D.from_config(conf)(x)
x = BatchNormalization(axis=3)(x)
x = Activation(activation='swish')(x)
x = GlobalMaxPooling2D()(x)
x = Dense(64, activation='relu')(x)
#x = Dense(256,activation='relu')(x)
predictions = Dense(1, activation='sigmoid')(x)
model = Model(model.input, predictions)
#return model
'''
l = model.layers[:]
l.append(Conv2D.from_config(conf))
l.append(BatchNormalization(axis=3))
l.append(Activation(activation='swish'))
l.append(GlobalMaxPooling2D())
l.append(Dense(64,activation='relu'))
l.append(Dense(1, activation='sigmoid'))
'''
if total_model_weight_path:
print("Load total weight from ", total_model_weight_path)
model.load_weights(total_model_weight_path)
model.summary()
self.multi_gpus = True
self.single_model = model
self.model = multi_gpu_model(model, gpus=2)
self.model.compile(loss=focal_loss(alpha=0.5, gamma=2),
optimizer=optimizers.Adam(lr=1e-3),
metrics=['accuracy'])
def EfficientUNet(input_shape):
backbone = efn.EfficientNetB4(weights=None,
include_top=False,
input_shape=input_shape)
input = backbone.input
x00 = backbone.input # (256, 512, 3)
x10 = backbone.get_layer('stem_activation').output # (128, 256, 4)
x20 = backbone.get_layer('block2d_add').output # (64, 128, 32)
x30 = backbone.get_layer('block3d_add').output # (32, 64, 56)
x40 = backbone.get_layer('block5f_add').output # (16, 32, 160)
x50 = backbone.get_layer('block7b_add').output # (8, 16, 448)
x01 = H([x00, U(x10)], 'X01')
x11 = H([x10, U(x20)], 'X11')
x21 = H([x20, U(x30)], 'X21')
x31 = H([x30, U(x40)], 'X31')
x41 = H([x40, U(x50)], 'X41')
x02 = H([x00, x01, U(x11)], 'X02')
x12 = H([x11, U(x21)], 'X12')
x22 = H([x21, U(x31)], 'X22')
x32 = H([x31, U(x41)], 'X32')
x03 = H([x00, x01, x02, U(x12)], 'X03')
x13 = H([x12, U(x22)], 'X13')
x23 = H([x22, U(x32)], 'X23')
x04 = H([x00, x01, x02, x03, U(x13)], 'X04')
x14 = H([x13, U(x23)], 'X14')
x05 = H([x00, x01, x02, x03, x04, U(x14)], 'X05')
x_out = Concatenate(name='bridge')([x01, x02, x03, x04, x05])
x_out = Conv2D(4, (3, 3),
padding="same",
name='final_output',
activation="sigmoid")(x_out)
return Model(inputs=input, outputs=x_out)
def create_base_model(base_model_name, pretrained=True, IMAGE_SIZE=[300, 300]):
if pretrained is False:
weights = None
else:
weights = "imagenet"
if base_model_name == 'B0':
base = efn.EfficientNetB0(weights=weights,
include_top=False,
input_shape=[*IMAGE_SIZE, 3])
elif base_model_name == 'B1':
base = efn.EfficientNetB1(weights=weights,
include_top=False,
input_shape=[*IMAGE_SIZE, 3])
elif base_model_name == 'B2':
base = efn.EfficientNetB2(weights=weights,
include_top=False,
input_shape=[*IMAGE_SIZE, 3])
elif base_model_name == 'B3':
base = efn.EfficientNetB3(weights=weights,
include_top=False,
input_shape=[*IMAGE_SIZE, 3])
elif base_model_name == 'B4':
base = efn.EfficientNetB4(weights=weights,
include_top=False,
input_shape=[*IMAGE_SIZE, 3])
elif base_model_name == 'B5':
base = efn.EfficientNetB5(weights=weights,
include_top=False,
input_shape=[*IMAGE_SIZE, 3])
elif base_model_name == 'B6':
base = efn.EfficientNetB6(weights=weights,
include_top=False,
input_shape=[*IMAGE_SIZE, 3])
elif base_model_name == 'B7':
base = efn.EfficientNetB7(weights=weights,
include_top=False,
input_shape=[*IMAGE_SIZE, 3])
base = remove_dropout(base)
base.trainable = True
return base
def EfficientNet_(input_shapes, num_classes):
efficient_net = efn.EfficientNetB4(include_top=False, weights="imagenet")
# x = efficient_net.output
image = Input((IMSIZE[0], IMSIZE[1], 3), name='RGB')
x = efficient_net(image).output
x = GlobalAveragePooling2D()(x)
x = Dropout(0.5)(x)
x = Dense(512,
activation='relu',
kernel_initializer=TruncatedNormal(stddev=0.01))(x)
x = Dropout(0.5)(x)
x = Dense(128,
activation='relu',
kernel_initializer=TruncatedNormal(stddev=0.01))(x)
x = Dropout(0.5)(x)
x = Dense(32,
activation='relu',
kernel_initializer=TruncatedNormal(stddev=0.01))(x)
pred = Dense(num_classes, activation='softmax')(x)
model = Model(inputs=efficient_net.input, outputs=pred)
return model
def model_fn(objective, optimizer, metrics):
base_model = efn.EfficientNetB4(
include_top=False,
# base_model = seresnext50(include_top=False,
# base_model = xception(include_top=False,
# base_model = densenet201(include_top=False,
# base_model = inceptionresnetv2(include_top=False,
input_shape=(input_size, input_size, 3),
classes=num_classes,
weights='imagenet',
)
x = base_model.output
x = GlobalAveragePooling2D()(x)
predictions = Dense(num_classes, activation='softmax')(x)
model1 = Model(inputs=base_model.input, outputs=predictions)
# model2 = multi_gpu_model(model1, gpus=3)
# model2 = model1
model1.compile(loss=objective, optimizer=optimizer, metrics=metrics)
lookahead = Lookahead(k=5, alpha=0.5) # Initialize Lookahead
lookahead.inject(model1) # add into model
model1.summary()
return model1
def model_fn(FLAGS, objective, optimizer, metrics):
# base_model = efn.EfficientNetB3(include_top=False,
# input_shape=(FLAGS.input_size, FLAGS.input_size, 3),
# classes=FLAGS.num_classes, )
# # input_size = 380
model = efn.EfficientNetB4(
include_top=False,
input_shape=(FLAGS.input_size, FLAGS.input_size, 3),
classes=FLAGS.num_classes,
)
# # input_size = 456
# base_model = efn.EfficientNetB5(include_top=False,
# input_shape=(FLAGS.input_size, FLAGS.input_size, 3),
# classes=FLAGS.num_classes, )
# # input_size = 528
# base_model = efn.EfficientNetB6(include_top=False,
# input_shape=(FLAGS.input_size, FLAGS.input_size, 3),
# classes=FLAGS.num_classes, )
# for i, layer in enumerate(model.layers):
# if "batch_normalization" in layer.name:
# model.layers[i] = GroupNormalization(groups=32, axis=-1, epsilon=0.00001)
x = model.output
# 插入双线性池化操作
# x = bilinear_pooling(x）
# x = GlobalAveragePooling2D()(x)
# x = Dropout(0.4)(x)
predictions = Dense(FLAGS.num_classes, activation='softmax')(
x) # activation="linear",activation='softmax'
model = Model(input=model.input, output=predictions)
model.compile(loss=objective, optimizer=optimizer, metrics=metrics)
model.summary()
return model
'beta_regularizer': regularizers.serialize(self.beta_regularizer),
'gamma_regularizer':
regularizers.serialize(self.gamma_regularizer),
'beta_constraint': constraints.serialize(self.beta_constraint),
'gamma_constraint': constraints.serialize(self.gamma_constraint)
}
base_config = super(GroupNormalization, self).get_config()
return dict(list(base_config.items()) + list(config.items()))
def compute_output_shape(self, input_shape):
return input_shape
# Load in EfficientNetB4
effnet = efn.EfficientNetB4(weights='imagenet',
include_top=False,
input_shape=(size, size, chinnels))
# Replace all Batch Normalization layers by Group Normalization layers
for i, layer in enumerate(effnet.layers):
if "batch_normalization" in layer.name:
effnet.layers[i] = GroupNormalization(groups=32,
axis=-1,
epsilon=0.00001)
def build_model():
"""
A custom implementation of EfficientNetB5
for the APTOS 2019 competition
(Regression)
model = None
if b_name == "0":
model = efn.EfficientNetB0(weights=weights)
if b_name == "1":
model = efn.EfficientNetB1(weights=weights)
if b_name == "2":
model = efn.EfficientNetB2(weights=weights)
if b_name == "3":
model = efn.EfficientNetB3(weights=weights)
if b_name == "4":
model = efn.EfficientNetB4(weights=weights)
if b_name == "5":
model = efn.EfficientNetB5(weights=weights)
if b_name == "6":
model = efn.EfficientNetB6(weights=weights)
if b_name == "7":
model = efn.EfficientNetB7(weights=weights)
image_size = model.input_shape[1]
def read_image(path):
try:
def create_model(dim=(256, 256), weights=np.ones(5), split=False):
f_loss = categorical_focal_loss(alpha=weights)
IMG_WIDTH, IMG_HEIGHT, CHANNELS = *dim, 3
input_shape = (IMG_WIDTH, IMG_HEIGHT, CHANNELS)
elu = keras.layers.ELU(alpha=1.0)
# create the base pre-trained model
# Load in EfficientNetB5
effnet = efn.EfficientNetB4(weights=None,
include_top=False,
input_shape=(IMG_WIDTH, IMG_HEIGHT, CHANNELS))
effnet.load_weights(
'/media/parth/DATA/datasets/aptos_2019/efficientnet-b4_imagenet_1000_notop.h5'
)
# Replace all Batch Normalization layers by Group Normalization layers
for i, layer in enumerate(effnet.layers):
if "batch_normalization" in layer.name:
effnet.layers[i] = GroupNormalization(groups=32,
axis=-1,
epsilon=0.00001)
if split == True:
input1 = Input(input_shape)
input2 = Input(input_shape)
input3 = Input(input_shape)
input4 = Input(input_shape)
conv1 = Conv2D(16, 3, padding='same')(input1)
conv2 = Conv2D(16, 3, padding='same')(input2)
conv3 = Conv2D(16, 3, padding='same')(input3)
conv4 = Conv2D(16, 3, padding='same')(input4)
concat = concatenate([conv1, conv2, conv3, conv4])
enet_input = Conv2D(3, 3, padding='same')(concat)
x = effnet(enet_input)
x = GlobalAveragePooling2D()(x)
x = Dense(256)(x)
x = Dropout(0.25)(x)
x = Dense(5)(x)
predictions = Softmax()(x)
model = Model(inputs=[input1, input2, input3, input4],
outputs=predictions)
model.compile(loss=f_loss,
optimizer=RAdam(learning_rate=0.00005),
metrics=[f_loss, 'acc'])
print(model.summary())
return model
else:
x = effnet.output
x = GlobalAveragePooling2D()(x)
x = Dense(256)(x)
x = Dropout(0.25)(x)
x = Dense(5)(x)
predictions = Softmax()(x)
model = Model(inputs=effnet.input, outputs=predictions)
model.compile(loss=f_loss,
optimizer=RAdam(lr=0.00005),
metrics=[f_loss, 'acc'])
print(model.summary())
return model
def get_backbone(name):
""" Chooses a backbone/ base network.
Args:
name: the name of the base network.
Returns:
backbone: the Keras model of the chosen network.
"""
if name == 'EfficientNetB0':
backbone = efn.EfficientNetB0(include_top=c.INCLUDE_TOP,
weights=c.WEIGHTS,
input_shape=c.INPUT_SHAPE,
pooling=c.POOLING)
elif name == 'EfficientNetB1':
backbone = efn.EfficientNetB1(include_top=c.INCLUDE_TOP,
weights=c.WEIGHTS,
input_shape=c.INPUT_SHAPE,
pooling=c.POOLING)
elif name == 'EfficientNetB2':
backbone = efn.EfficientNetB2(include_top=c.INCLUDE_TOP,
weights=c.WEIGHTS,
input_shape=c.INPUT_SHAPE,
pooling=c.POOLING)
elif name == 'EfficientNetB3':
backbone = efn.EfficientNetB3(include_top=c.INCLUDE_TOP,
weights=c.WEIGHTS,
input_shape=c.INPUT_SHAPE,
pooling=c.POOLING)
elif name == 'EfficientNetB4':
backbone = efn.EfficientNetB4(include_top=c.INCLUDE_TOP,
weights=c.WEIGHTS,
input_shape=c.INPUT_SHAPE,
pooling=c.POOLING)
elif name == 'EfficientNetB5':
backbone = efn.EfficientNetB5(include_top=c.INCLUDE_TOP,
weights=c.WEIGHTS,
input_shape=c.INPUT_SHAPE,
pooling=c.POOLING)
elif name == 'EfficientNetB6':
backbone = efn.EfficientNetB6(include_top=c.INCLUDE_TOP,
weights=c.WEIGHTS,
input_shape=c.INPUT_SHAPE,
pooling=c.POOLING)
elif name == 'EfficientNetB7':
backbone = efn.EfficientNetB7(include_top=c.INCLUDE_TOP,
weights=c.WEIGHTS,
input_shape=c.INPUT_SHAPE,
pooling=c.POOLING)
elif name == 'VGG16':
backbone = VGG16(weights=c.WEIGHTS,
include_top=c.INCLUDE_TOP,
input_shape=c.INPUT_SHAPE,
pooling=c.POOLING)
elif name == 'ResNet50':
backbone = ResNet50(include_top=c.INCLUDE_TOP,
weights=c.WEIGHTS,
input_shape=c.INPUT_SHAPE,
pooling=c.POOLING)
elif name == 'InceptionV3':
backbone = InceptionV3(include_top=c.INCLUDE_TOP,
weights=c.WEIGHTS,
input_shape=c.INPUT_SHAPE,
pooling=c.POOLING)
elif name == 'DenseNet201':
backbone = DenseNet201(weights=c.WEIGHTS,
include_top=c.INCLUDE_TOP,
input_shape=c.INPUT_SHAPE,
pooling=c.POOLING)
else:
backbone = None
try:
backbone.trainable = True
return backbone
except Exception as e:
print(str(e))
subset='validation',
target_size=(imgSize, imgSize),
batch_size=batch_size,
class_mode='categorical',
shuffle=True)
nb_train_samples = len(train_generator.filenames)
nb_validation_samples = len(val_generator.filenames)
CLASS_COUNT = len(train_generator.class_indices)
train_labels = train_generator.classes
train_labels = to_categorical(train_labels, num_classes=CLASS_COUNT)
#model
print('Generating training model...')
# base_model = ResNet50(weights='imagenet',include_top=False,input_shape=(224, 224, 3),pooling='max')
base_model = efn.EfficientNetB4(weights='imagenet',
include_top=False,
pooling='avg')
base_model.trainable = False
model = Sequential([
base_model,
# Dense(256, activation='relu'),
Dense(128, activation='relu'),
Dense(CLASS_COUNT, activation='softmax'),
])
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=0.0001, decay=1e-6),
metrics=['accuracy'])
#training data...
print('Training model...')
callbacks=[densenet_time, densenet_stopping, densenet_checkpoint]
)
# ### EfficientNet
# EfficientNet is a lightweight CNN architecture that is designed to require significantly less compute than other state of the art architectures on common transfer learning datasets.
# Pre-built EfficientNet models built in Keras are used from the efficientnet library available on [GitHub](https://github.com/qubvel/efficientnet) and installable via PyPI.
# In[24]:
efficientnet_base = efn.EfficientNetB4(
include_top=False,
weights='imagenet',
input_shape=(224, 224, 3),
pooling='avg'
)
output = Dense(15, activation='sigmoid')(efficientnet_base.output)
efficientnet = Model(input=efficientnet_base.input, outputs=output)
# In[25]:
efficientnet.summary()
# In[26]:
def model(input_form="all", aux_size=0, hyperparameters=dict()):
print("using the following hyperparameters: {}".format(hyperparameters))
if input_form == "features":
return features_model(aux_size, hyperparameters)
parameters = INPUT_FORM_PARAMETERS[input_form]
inputs = list()
outputs = list()
#retreiving the hyperparameters
DROPOUT = hyperparameters.get("dropout", 0.5)
OPTIMIZER = hyperparameters.get("optimizer", "sgd-0001-0.9")
DEEP_DENSE_TOP = hyperparameters.get("deep-dense-top", True)
CONVNET_FREEZE_PERCENT = hyperparameters.get("convnet-freeze-percent", 0.0)
#skip for now
'''
if parameters["t2"]:
convnet = applications.ResNet50(
weights="imagenet",
include_top=False,
input_shape=(config.IMAGE_SIZE, config.IMAGE_SIZE, 3),
)
for layer in convnet.layers:
layer.name = "{}_t2".format(layer.name)
apply_layer_freeze(convnet, CONVNET_FREEZE_PERCENT)
out = convnet.output
out = Flatten()(out)
inputs.append(convnet.input)
outputs.append(out)
'''
if parameters["t1"]:
# init ResNet
convnet = efn.EfficientNetB4(
weights="imagenet",
include_top=False,
input_shape=(config.IMAGE_SIZE, config.IMAGE_SIZE, 3),
)
apply_layer_freeze(convnet, CONVNET_FREEZE_PERCENT)
out = convnet.output
out = Flatten()(out)
inputs.append(convnet.input)
outputs.append(out)
if len(outputs) > 1:
out = concatenate(outputs)
else:
out = outputs[0]
out = Dense(256,
activation="relu",
kernel_regularizer=l1_l2(l1=0.01, l2=0.01))(out)
out = BatchNormalization()(out)
if DEEP_DENSE_TOP:
out = Dropout(DROPOUT)(out)
out = Dense(128,
activation="relu",
kernel_regularizer=l1_l2(l1=0.01, l2=0.01))(out)
out = BatchNormalization()(out)
out = Dropout(DROPOUT)(out)
out = Dense(64,
activation="relu",
kernel_regularizer=l1_l2(l1=0.01, l2=0.01))(out)
out = BatchNormalization()(out)
out = Dropout(DROPOUT)(out)
out = Dense(32,
activation="relu",
kernel_regularizer=l1_l2(l1=0.01, l2=0.01))(out)
out = BatchNormalization()(out)
out = Dropout(DROPOUT)(out)
if parameters["features"]:
aux_input = Input(shape=(aux_size, ), name='aux_input')
inputs.append(aux_input)
out = concatenate([out, aux_input])
out = Dense(16,
activation="relu",
kernel_regularizer=l1_l2(l1=0.01, l2=0.01))(out)
out = BatchNormalization()(out)
predictions = Dense(1,
activation="sigmoid",
kernel_regularizer=l1_l2(l1=0.01, l2=0.01))(out)
# creating the final model
if len(inputs) > 1:
model = Model(inputs=inputs, outputs=predictions)
else:
model = Model(inputs=inputs[0], outputs=predictions)
# compile the model
model.compile(loss="binary_crossentropy",
optimizer=OPTIMIZERS[OPTIMIZER](),
metrics=["accuracy"])
return model
import matplotlib.pyplot as plt
import random
from pylab import rcParams
import os
import math
policy = mixed_precision.Policy('mixed_float16')
mixed_precision.set_policy(policy)
tf.keras.regularizers.l2(l2=0.01)
datagen = ImageDataGenerator(rescale=1. / 255, horizontal_flip=True)
train_csv = pd.read_csv(r"/content/train.csv")
train_csv["label"] = train_csv["label"].astype(str)
base_model = efn.EfficientNetB4(weights='noisy-student',
input_shape=(512, 512, 3),
include_top=True)
train = train_csv.iloc[:int(len(train_csv) * 0.9), :]
test = train_csv.iloc[int(len(train_csv) * 0.9):, :]
print((len(train), len(test)))
base_model.trainable = True
fold_number = 0
n_splits = 5
oof_accuracy = []
first_decay_steps = 500
lr = (tf.keras.experimental.CosineDecayRestarts(0.04, first_decay_steps))
opt = tf.keras.optimizers.SGD(lr, momentum=0.9)
import os
import numpy as np
import efficientnet.keras as efn
from skimage.io import imread
from efficientnet.keras import center_crop_and_resize, preprocess_input
from keras.applications.imagenet_utils import decode_predictions
model = efn.EfficientNetB4(weights='noisy-student')
image_size = model.input_shape[1]
def read_image(path):
try:
return preprocess_input(
center_crop_and_resize(imread(path)[:, :, :3],
image_size=image_size))
except:
return None
from time import time
def predictor(in_paths=[], batch_size=2):
in_images = [read_image(in_path) for in_path in in_paths]
bad_indices = {
i
for i, in_image in enumerate(in_images) if in_image is None
def build_model(input_shape, args):
D = args.d
F = args.f
V = args.v
input_tensor = Input(shape=input_shape)
if args.tf == "in":
base_model = InceptionV3(weights='imagenet', include_top=False, input_tensor=input_tensor)
#pi = in_pi
elif args.tf == "inr":
base_model = InceptionResNetV2(weights='imagenet', include_top=False, input_tensor=input_tensor)
#pi = inr_pi
elif args.tf == "vg":
base_model = VGG16(weights='imagenet', include_top=False, input_tensor=input_tensor)
#pi = vg_pi
elif args.tf == "xc":
base_model = Xception(weights='imagenet', include_top=False, input_tensor=input_tensor)
#pi = xc_pi
elif args.tf == "re":
base_model = ResNet50(weights='imagenet', include_top=False, input_tensor=input_tensor)
#pi = re_pi
elif args.tf == "de":
base_model = DenseNet121(weights='imagenet', include_top=False, input_tensor=input_tensor)
#pi = de_pi
elif args.tf == "mo":
base_model = MobileNet(weights='imagenet', include_top=False, input_tensor=input_tensor)
#pi = mo_pi
elif args.tf.find("ef") > -1:
if args.tf == "ef0":
base_model = efn.EfficientNetB0(weights='imagenet', include_top=False, input_tensor=input_tensor)
elif args.tf == "ef1":
base_model = efn.EfficientNetB1(weights='imagenet', include_top=False, input_tensor=input_tensor)
elif args.tf == "ef2":
base_model = efn.EfficientNetB2(weights='imagenet', include_top=False, input_tensor=input_tensor)
elif args.tf == "ef3":
base_model = efn.EfficientNetB3(weights='imagenet', include_top=False, input_tensor=input_tensor)
elif args.tf == "ef4":
base_model = efn.EfficientNetB4(weights='imagenet', include_top=False, input_tensor=input_tensor)
elif args.tf == "ef5":
base_model = efn.EfficientNetB5(weights='imagenet', include_top=False, input_tensor=input_tensor)
elif args.tf == "ef6":
base_model = efn.EfficientNetB6(weights='imagenet', include_top=False, input_tensor=input_tensor)
elif args.tf == "ef7":
base_model = efn.EfficientNetB7(weights='imagenet', include_top=False, input_tensor=input_tensor)
else:
print("unknown network type:", args.tf)
exit()
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(F, activation='relu')(x)
if D > 0:
x = Dropout(D)(x)
pred = Dense(nb_classes, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=pred)
layer_num = len(base_model.layers)
for layer in base_model.layers[:int(layer_num * V)]:
layer.trainable = False
return model #, pi
