def find_matching_image_with_rapids():
model = EfficientNetB0(weights='imagenet',
include_top=False,
pooling='avg',
input_shape=None)
train_gen = DataGenerator(train, batch_size=128)
image_embeddings = model.predict(train_gen, verbose=1)
print('image embeddings shape is', image_embeddings.shape)
# After fitting KNN, we will display some example rows of train and their 8 closest other images in train (based EffNetB0 image embeddings).
KNN = 50
model = NearestNeighbors(n_neighbors=KNN)
model.fit(image_embeddings)
distances, indices = model.kneighbors(image_embeddings)
for k in range(180, 190):
plt.figure(figsize=(20, 3))
plt.plot(np.arange(50), cupy.asnumpy(distances[k, ]), 'o-')
plt.title('Image Distance From Train Row %i to Other Train Rows' % k,
size=16)
plt.ylabel('Distance to Train Row %i' % k, size=14)
plt.xlabel('Index Sorted by Distance to Train Row %i' % k, size=14)
plt.show()
cluster = train.loc[cupy.asnumpy(indices[k, :8])]
displayDF(cluster, random=False, ROWS=2, COLS=4)
def create_first_model():
"""Initial model prototype that I used for testing in the notebook"""
effnet = EfficientNetB0(weights="imagenet",
include_top=False,
input_shape=(224, 224, 3))
site1 = Input(shape=(224, 224, 3))
site2 = Input(shape=(224, 224, 3))
x = effnet(site1)
x = GlobalAveragePooling2D()(x)
x = Model(inputs=site1, outputs=x)
y = effnet(site2)
y = GlobalAveragePooling2D()(y)
y = Model(inputs=site2, outputs=y)
combined = concatenate([x.output, y.output])
z = Dropout(0.5)(combined)
z = Dense(1108, activation="softmax")(z)
model = Model(inputs=[x.input, y.input], outputs=z)
model.compile(
loss="sparse_categorical_crossentropy",
optimizer=Adam(0.0001),
metrics=["accuracy"],
)
model.summary()
return model
def build_model(nb_classes):
base_model = EfficientNetB0(weights='imagenet', include_top=False)
# add a global spatial average pooling layer
x = base_model.output
x = GlobalAveragePooling2D()(x)
# let's add a fully-connected layer
x = Dense(1024, activation='relu')(x)
# and a logistic layer
predictions = Dense(nb_classes, activation='softmax')(x)
# this is the model we will train
model = Model(inputs=base_model.input, outputs=predictions)
# 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 = True
Adadelta0 = optimizers.Adadelta(lr=0.13)
# compile the model (should be done *after* setting layers to non-trainable)
print("starting model compile")
#compile(model)
model.compile(optimizer=Adadelta0,
loss='sparse_categorical_crossentropy',
metrics=['sparse_categorical_accuracy'])
print("model compile done")
return model
def adapt_efficient_net() -> Model:
"""This code uses adapts the most up-to-date version of EfficientNet with NoisyStudent weights to a regression
problem. Most of this code is adapted from the official keras documentation.
Returns
-------
Model
The keras model.
"""
inputs = layers.Input(
shape=(224, 224, 3)
) # input shapes of the images should always be 224x224x3 with EfficientNetB0
# use the downloaded and converted newest EfficientNet wheights
model = EfficientNetB0(include_top=False,
input_tensor=inputs,
weights="efficientnetb0_notop.h5")
# Freeze the pretrained weights
model.trainable = False
# Rebuild top
x = layers.GlobalAveragePooling2D(name="avg_pool")(model.output)
x = layers.BatchNormalization()(x)
top_dropout_rate = 0.4
x = layers.Dropout(top_dropout_rate, name="top_dropout")(x)
outputs = layers.Dense(1, name="pred")(x)
# Compile
model = keras.Model(inputs, outputs, name="EfficientNet")
return model
def image_embeddings_extraction(test):
BASE = '../input/shopee-product-matching/test_images/'
if COMPUTE_CV:
BASE = '../input/shopee-product-matching/train_images/'
WGT = '../input/effnetb0/efficientnetb0_notop.h5'
model = EfficientNetB0(weights=WGT, include_top=False, pooling='avg', input_shape=None)
embeds = []
CHUNK = 1024 * 4
print('Computing image embeddings...')
CTS = len(test) // CHUNK
if len(test) % CHUNK != 0:
CTS += 1
for i, j in enumerate(range(CTS)):
a = j * CHUNK
b = (j + 1) * CHUNK
b = min(b, len(test))
print('chunk', a, 'to', b)
test_gen = DataGenerator(test.iloc[a:b], batch_size=32, path=BASE)
image_embeddings = model.predict(test_gen, verbose=1, use_multiprocessing=True, workers=4)
embeds.append(image_embeddings)
# if i>=1: break
del model
_ = gc.collect()
image_embeddings = np.concatenate(embeds)
print('image embeddings shape', image_embeddings.shape)
def build_model(): inputs = tf.keras.Input(shape=(RESIZE_TO, RESIZE_TO, 3)) model = EfficientNetB0(include_top=False, weights="imagenet", classes=NUM_CLASSES, input_tensor=inputs) model.trainable = False x = tf.keras.layers.GlobalAveragePooling2D()(model.output) outputs = tf.keras.layers.Dense(NUM_CLASSES, activation=tf.keras.activations.softmax)(x) return tf.keras.Model(inputs=inputs, outputs=outputs)
def build_model(): inputs = tf.keras.Input(shape=(RESIZE_TO, RESIZE_TO, 3)) x = EfficientNetB0(include_top=False, input_tensor = inputs,pooling ='avg', weights='imagenet') x.trainable = False x = tf.keras.layers.Flatten()(x.output) outputs = tf.keras.layers.Dense(NUM_CLASSES, activation=tf.keras.activations.softmax)(x) return tf.keras.Model(inputs=inputs, outputs=outputs)
def load_model(self, name_model=''):
"""Loads the model indicated by name_model.
Args:
name_model (str, optional): name of the model we want to load.
Defaults to ''.
"""
if name_model != '':
if name_model in self.name_model:
if name_model == 'VGG16':
self.MODEL = VGG16(weights='imagenet')
self.fonction_preprocessing = prepro_vg116
elif name_model == "mobile_net":
self.MODEL = MobileNet()
self.fonction_preprocessing = prepro_mobile_net
elif name_model == "efficient_net":
self.MODEL = EfficientNetB0()
self.fonction_preprocessing = prepro_efficient_net
elif name_model == "efficient_netB3":
self.MODEL = EfficientNetB3()
self.fonction_preprocessing = prepro_efficient_net
else:
raise(Exception(f"name_model not found in {self.name_model}"))
else:
self.MODEL = VGG16(weights='imagenet')
self.fonction_preprocessing = prepro_efficient_net
def build_model(num_classes):
inputs = layers.Input(shape=(IMG_SIZE, IMG_SIZE, 3))
x = img_augmentation(inputs)
model = EfficientNetB0(include_top=False,
input_tensor=x,
weights="imagenet")
# Freeze the pretrained weights
model.trainable = False
# Rebuild top
x = layers.GlobalAveragePooling2D(name="avg_pool")(model.output)
x = layers.BatchNormalization()(x)
top_dropout_rate = 0.2
x = layers.Dropout(top_dropout_rate, name="top_dropout")(x)
outputs = layers.Dense(NUM_CLASSES, activation="softmax", name="pred")(x)
# Compile
model = tf.keras.Model(inputs, outputs, name="EfficientNet")
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-2)
model.compile(optimizer=optimizer,
loss="categorical_crossentropy",
metrics=["accuracy"])
return model
def get_pca_plot(test_dataset_dir, model, classes):
IMG_SIZE = 224
NUM_CLASSES = 48
test_dataset = tf.keras.preprocessing.image_dataset_from_directory(
test_dataset_dir, seed=123, image_size=(IMG_SIZE, IMG_SIZE))
base_model = EfficientNetB0(include_top=False, weights='imagenet')
global_average_layer = tf.keras.layers.GlobalAveragePooling2D()
preprocess_input = tf.keras.applications.efficientnet.preprocess_input
prediction_layer = tf.keras.layers.Dense(NUM_CLASSES, activation='softmax')
inputs = tf.keras.Input(shape=(IMG_SIZE, IMG_SIZE, 3))
#y = rescale(inputs)
x = preprocess_input(inputs)
x = base_model(x, training=False)
outputs = global_average_layer(x)
model1 = tf.keras.Model(inputs, outputs)
model1.set_weights(model.get_weights()[:len(model1.get_weights())])
intermediates = []
labels = []
for x, y in test_dataset:
output = list(model1.predict(x))
intermediates.extend(output)
labels.extend(list(y))
output_pca_data = get_pca(intermediates)
path = plot_representations(output_pca_data, labels, classes)
return path
def __get_cnn(self):
size_sq = 224
dict_cnn = {
'resnet':
ResNet50(
weights='imagenet',
include_top=False, # remove the last layer
input_shape=(size_sq, size_sq, 3)),
'vgg':
VGG16(weights='imagenet',
include_top=False,
input_shape=(size_sq, size_sq, 3)),
'inceptV3':
InceptionV3(
weights="imagenet",
include_top=False,
input_shape=(size_sq, size_sq, 3),
),
'effnetB0':
EfficientNetB0(weights='imagenet',
include_top=False,
input_shape=(size_sq, size_sq, 3)),
'effnetB7':
EfficientNetB7(weights='imagenet',
include_top=False,
input_shape=(size_sq, size_sq, 3))
}
return dict_cnn[self.cnn_name]
def build_model(): inputs = tf.keras.Input(shape=(RESIZE_TO, RESIZE_TO, 3)) x = tf.keras.layers.experimental.preprocessing.RandomRotation(factor=(0, 0.025), fill_mode='wrap')(inputs) model = EfficientNetB0(input_tensor=x,include_top=False,pooling='avg',weights='imagenet') model.trainable=False x = tf.keras.layers.Flatten()(model.output) outputs = tf.keras.layers.Dense(NUM_CLASSES, activation=tf.keras.activations.softmax)(x) return tf.keras.Model(inputs=inputs, outputs=outputs)
def build_model(): inputs = tf.keras.Input(shape=(RESIZE_TO, RESIZE_TO, 3)) x = data_augmentation(inputs) x = EfficientNetB0(include_top=False, weights='imagenet', input_tensor = x) x.trainable = False x = tf.keras.layers.GlobalAveragePooling2D()(x.output) outputs = tf.keras.layers.Dense(NUM_CLASSES, activation=tf.keras.activations.softmax)(x) return tf.keras.Model(inputs=inputs, outputs=outputs)
def efficientnetB0(
input_shape, nclasses=2, num_dense_blocks=3, growth_rate=12, depth=100, compression_factor=0.5,
data_augmentation=True, regularization=0.
):
keras_shape = input_shape
if input_shape[-1] == 1:
keras_shape = (32, 32, 3)
keras_model = EfficientNetB0(
include_top=False,
input_shape=keras_shape,
weights=None
)
keras_model.trainable = True
# adding regularization
# regularizer = l2(regularization)
#
# for layer in keras_model.layers:
# for attr in ['kernel_regularizer']:
# if hasattr(layer, attr):
# setattr(layer, attr, regularizer)
#
# tmp_weights_path = os.path.join(tempfile.gettempdir(), 'tmp_weights.h5')
# keras_model.save_weights(tmp_weights_path)
#
# keras_json = keras_model.to_json()
# keras_model = models.model_from_json(keras_json)
# keras_model.load_weights(tmp_weights_path, by_name=True)
outputs = keras_model.output
inputs = keras_model.input
if input_shape[-1] == 1:
inputs = layers.Input(shape=input_shape)
x = layers.ZeroPadding2D(padding=(2, 2))(inputs)
output_shape = K.int_shape(x)
output_shape = output_shape[:-1] + (3,)
x = layers.Lambda(lambda x: K.tile(x, (1, 1, 1, 3)), output_shape=output_shape)(x)
outputs = keras_model(x)
outputs = layers.Flatten()(outputs)
# outputs = layers.GlobalAveragePooling2D()(outputs)
# outputs = layers.Dropout(rate=.2)(outputs)
outputs = layers.Dense(nclasses,
kernel_initializer='he_normal',
kernel_regularizer=None,
activation='softmax')(outputs)
# instantiate and compile model
# orig paper uses SGD but RMSprop works better for DenseNet
model = models.Model(inputs=inputs, outputs=outputs)
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.SGD(1e-4),
metrics=['acc'])
return model
def __init__(self):
super(Encoder, self).__init__()
self.base_model = EfficientNetB0(include_top=False, weights='imagenet')
print('Base model loaded {}'.format(EfficientNetB0.__name__))
# Create encoder model that produce final features along with multiple intermediate features
outputs = [self.base_model.outputs[-1]]
for name in ['block2a_activation', 'block3a_activation', 'block4a_activation', 'block1a_activation'] : outputs.append( self.base_model.get_layer(name).output )
self.encoder = Model(inputs=self.base_model.inputs, outputs=outputs)
def efficient_b0_2(size):
conv_base = EfficientNetB0(include_top=False,
weights=None,
input_shape=(size, size, 3))
model = conv_base.output
model = layers.GlobalAveragePooling2D()(model)
model = layers.Dense(5, activation="softmax")(model)
model = models.Model(conv_base.input, model)
return model
def EfficientNet(cfg):
regularizer = l2(cfg.TRAIN.WD)
if cfg.MODEL.SIZE == 0:
backbone = EfficientNetB0(include_top=False,
input_shape=tuple(cfg.DATASET.INPUT_SHAPE))
elif cfg.MODEL.SIZE == 1:
backbone = EfficientNetB1(include_top=False,
input_shape=tuple(cfg.DATASET.INPUT_SHAPE))
elif cfg.MODEL.SIZE == 2:
backbone = EfficientNetB2(include_top=False,
input_shape=tuple(cfg.DATASET.INPUT_SHAPE))
elif cfg.MODEL.SIZE == 3:
backbone = EfficientNetB3(include_top=False,
input_shape=tuple(cfg.DATASET.INPUT_SHAPE))
elif cfg.MODEL.SIZE == 4:
backbone = EfficientNetB4(include_top=False,
input_shape=tuple(cfg.DATASET.INPUT_SHAPE))
backbone = add_regularization(backbone, regularizer)
d, w, _ = scaling_parameters(cfg.DATASET.INPUT_SHAPE)
width_coefficient = cfg.MODEL.WIDTH_COEFFICIENT * w
depth_divisor = cfg.MODEL.DEPTH_DIVISOR
head_filters = cfg.MODEL.HEAD_CHANNELS
head_kernel = cfg.MODEL.HEAD_KERNEL
head_activation = cfg.MODEL.HEAD_ACTIVATION
keypoints = cfg.DATASET.OUTPUT_SHAPE[-1]
regularizer = l2(cfg.TRAIN.WD)
x = backbone.layers[-1].output
for i in range(cfg.MODEL.HEAD_BLOCKS):
x = layers.Conv2DTranspose(round_filters(head_filters,
width_coefficient,
depth_divisor),
head_kernel,
strides=2,
padding='same',
use_bias=False,
kernel_initializer=CONV_KERNEL_INITIALIZER,
kernel_regularizer=regularizer,
name='head_block{}_conv'.format(i + 1))(x)
x = layers.BatchNormalization(name='head_block{}_bn'.format(i + 1))(x)
x = layers.Activation(head_activation,
name='head_block{}_activation'.format(i + 1))(x)
x = layers.Conv2D(keypoints,
cfg.MODEL.FINAL_KERNEL,
padding='same',
use_bias=True,
kernel_initializer=DENSE_KERNEL_INITIALIZER,
kernel_regularizer=regularizer,
name='final_conv')(x)
return Model(backbone.input, x, name=f'EfficientNetLite_{cfg.MODEL.SIZE}')
def build_model(): inputs = tf.keras.Input(shape=(235, 235, 3)) x = tf.keras.layers.GaussianNoise(stddev = 0.6)(inputs) x = tf.keras.layers.experimental.preprocessing.RandomCrop(224,224)(x) x = tf.keras.layers.experimental.preprocessing.RandomRotation(factor = 0.02)(x) model = EfficientNetB0(include_top=False, input_tensor = x, pooling = 'avg', weights='imagenet') model.trainable = False x = tf.keras.layers.Flatten()(model.output) outputs = tf.keras.layers.Dense(NUM_CLASSES, activation = tf.keras.activations.softmax)(x) return tf.keras.Model(inputs=inputs, outputs=outputs)
def build_model(num_classes, model="B7"):
inputs = layers.Input(shape=(WIDTH, HEIGHT, 3))
if model == "B7":
model = EfficientNetB7(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model == "B6":
model = EfficientNetB6(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model == "B5":
model = EfficientNetB5(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model == "B4":
model = EfficientNetB4(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model == "B3":
model = EfficientNetB3(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model == "B2":
model = EfficientNetB2(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model == "B1":
model = EfficientNetB1(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model == "B0":
model = EfficientNetB0(include_top=False,
input_tensor=inputs,
weights="imagenet")
# Freeze the pretrained weights
model.trainable = False
# Rebuild top
x = layers.GlobalAveragePooling2D(name="avg_pool")(model.output)
x = layers.BatchNormalization()(x)
top_dropout_rate = 0.2
x = layers.Dropout(top_dropout_rate, name="top_dropout", seed=SEED)(x)
outputs = layers.Dense(num_classes,
activation="softmax",
name="predictions")(x)
# Compile
model = tf.keras.Model(inputs, outputs, name="EfficientNet")
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-2)
model.compile(
optimizer=optimizer,
loss="sparse_categorical_crossentropy",
metrics=[tf.keras.metrics.SparseTopKCategoricalAccuracy(k=1)])
return model
def get_parent(input_shape):
if input_shape[0] == 256:
parent = EfficientNetB0(include_top=False)
elif input_shape[0] == 384:
parent = EfficientNetB4(include_top=False)
elif input_shape[0] == 512:
parent = EfficientNetB5(include_top=False)
else:
print('Not a valid input shape for EfficientNet parent')
parent = None
return parent
def __init__(self, model_name="efficientnetb0"):
"""Class to abstract useful methods for extracting representations using a pretrained model.
Extend this class to use any of the dozen pretrained image analysis models on
tensorflow.keras.applications https://www.tensorflow.org/api_docs/python/tf/keras/applications .
Args:
model_name (str, optional): [description]. Defaults to "efficientnetb0".
"""
if (model_name == "efficientnetb0"):
self.model = EfficientNetB0(include_top=False)
self.image_size = 224
def newModel(self) -> tf.keras.Model:
if self.modelstr == "MobileNetV2":
base_model = MobileNetV2(weights='imagenet', include_top=False,
input_shape=(224, 224, 3))
base_model.trainable = True
inputs = tf.keras.Input(shape=(224, 224, 3), name="image_input")
x = base_model(inputs, training=True, )
x = GlobalAveragePooling2D()(x)
x = BatchNormalization()(x)
x = Dropout(0.3)(x)
x = Dense(1024, activation='relu')(x)
x = Dense(1024, activation='relu')(x)
x = Dense(512, activation='relu')(x)
x = Dense(128, activation='relu')(x)
preds = Dense(3, activation='softmax')(x)
self.model = tf.keras.Model(inputs=inputs, outputs=[preds], name="mobileNetV2")
self.model.compile(loss=losses.SparseCategoricalCrossentropy(from_logits=False),
optimizer=optimizers.Adam(learning_rate=1e-3),
metrics=['accuracy'])
else: # EfficientNet
def unfreeze_model(model):
# We unfreeze the top 20 layers while leaving BatchNorm layers frozen
for layer in model.layers[-20:]:
if not isinstance(layer, layers.BatchNormalization):
layer.trainable = True
inputs = tf.keras.Input(shape=(224, 224, 3), name="image_input")
conv_base = EfficientNetB0(input_shape=(224, 224, 3),
input_tensor=inputs, drop_connect_rate=0.4,
include_top=False)
conv_base.trainable = False
unfreeze_model(conv_base)
x = GlobalAveragePooling2D()(conv_base.output)
x = BatchNormalization()(x)
x = Dropout(0.3)(x)
x = Dense(512, activation='relu')(x)
x = Dense(256, activation='relu')(x)
x = Dense(128, activation='relu')(x)
preds = Dense(3, activation='softmax')(x)
self.model = tf.keras.Model(inputs=inputs, outputs=[preds], name="efficientNetB0")
self.model.compile(loss=losses.SparseCategoricalCrossentropy(from_logits=False),
optimizer=optimizers.Adam(learning_rate=1e-3),
metrics=['accuracy'])
return self.model
def create_model():
_model = models.Sequential()
_model.add(EfficientNetB0(include_top=False, weights='imagenet',
input_shape=(TARGET_SIZE, TARGET_SIZE, 3)))
_model.add(layers.GlobalAveragePooling2D())
_model.add(layers.Dense(5, activation="softmax"))
_model.compile(optimizer=Adam(lr=0.001),
loss="sparse_categorical_crossentropy",
metrics=["accuracy"])
return _model
def build_model():
inputs = tf.keras.Input(shape=(RESIZE_TO, RESIZE_TO, 3))
x = tf.keras.layers.experimental.preprocessing.Resizing(235, 235)(inputs)
x = tf.keras.layers.experimental.preprocessing.RandomCrop(224, 224)(x)
model = EfficientNetB0(input_tensor=x,
include_top=False,
pooling='avg',
weights='imagenet')
model.trainable = False
model = tf.keras.layers.Flatten()(model.output)
outputs = tf.keras.layers.Dense(
NUM_CLASSES, activation=tf.keras.activations.softmax)(model)
return tf.keras.Model(inputs=inputs, outputs=outputs)
def create_model(training=True):
base_model = EfficientNetB0(weights="imagenet",
include_top=False,
input_shape=(ROW, COL, 3))
x = Input(shape=(ROW, COL, 3))
out_1 = base_model(x, training=training)
out_1 = GlobalAveragePooling2D(name='encoding')(out_1)
out_1 = Dropout(0.5)(out_1)
output = Dense(934, activation="softmax")(out_1)
final_model = Model(inputs=x, outputs=output)
return final_model
def build_model():
inputs = tf.keras.Input(shape=(RESIZE_TO, RESIZE_TO, 3))
model = img_rotate(inputs)
model = img_contrast(model)
model = img_gauss(model)
model = EfficientNetB0(include_top=False,
input_tensor=inputs,
weights='imagenet')
model.trainable = False
model = tf.keras.layers.GlobalAveragePooling2D()(model.output)
model = tf.image.adjust_brightness(model, 0.3)
outputs = tf.keras.layers.Dense(
NUM_CLASSES, activation=tf.keras.activations.softmax)(model)
return tf.keras.Model(inputs=inputs, outputs=outputs)
def build_model(nb_classes):
base_model = EfficientNetB0(weights='imagenet', include_top=False)
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
predictions = Dense(nb_classes, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=predictions)
for layer in base_model.layers:
layer.trainable = True
Adadelta0 = optimizers.Adadelta(lr=0.013)
model.compile(optimizer=Adadelta0, loss='sparse_categorical_crossentropy', metrics=[
'sparse_categorical_accuracy'])
#model.load_weights("./Weight/efficientNetB0.h5")
return model
def EfficientNetClassifier():
'''
Using transfer learning, create an EfficientNetB0 model to be used. We
will update the output for the model as well as unfreeze some of the final
15 layers to be trainined and learn more low level features in our images.
'''
effnetb0 = EfficientNetB0(weights='imagenet', include_top=False, input_shape=(IMG_SIZE, IMG_SIZE, 3))
model = layers.GlobalAveragePooling2D()(effnetb0.output)
model = layers.Dropout(0.3)(model)
model = layers.Dense(4, activation='softmax')(model)
model = models.Model(inputs=effnetb0.input, outputs=model)
model.compile(optimizer='Adam', loss='categorical_crossentropy', metrics=['accuracy'])
return model
def EfficientNetB0model(no_classes, shape):
"""
EfficientNetB0
https://keras.io/examples/vision/image_classification_efficientnet_fine_tuning/
Uses a fixed input size 224,224
"""
base_model = EfficientNetB0(include_top=False,
weights='imagenet',
input_shape=shape)
base_model.trainable = False
inputs = Input(shape=shape)
x = base_model(inputs, training=False)
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
predictions = Dense(no_classes, activation='softmax',
name='predictions')(x)
model = Model(inputs, outputs=predictions)
return model
def get_efficientB0_model(config):
# https://keras.io/examples/vision/image_classification_efficientnet_fine_tuning/
size = (config['img_height'], config['img_width'])
inputs = tf.keras.layers.Input(shape=(config['img_height'],
config['img_width'], 3))
#x = tf.keras.layers.GaussianNoise(20)(inputs)
x = inputs
from tensorflow.keras.applications import EfficientNetB0
weights = 'imagenet'
if 'should_init_pretrained' in config and config[
'should_init_pretrained'] == False:
weights = None
encoder = EfficientNetB0(include_top=False,
weights=weights,
drop_connect_rate=0.2,
input_tensor=x)
encoder.trainable = False
for l in encoder.layers:
l.trainable = False
#encoder.summary()
encoded_layer_names = [
'block1a_activation', # (112,112,32)
'block3a_expand_activation', # (56,56,144)
'block4a_expand_activation', # (28,28,240)
'block5a_expand_activation' #, # (14,14,672)
#'block6a_activation' # (7,7,1152)
]
outputs = [get_decoded(config, encoder, encoded_layer_names)]
net = tf.keras.Model(inputs=encoder.inputs,
outputs=[outputs],
name="EfficientUnet")
#for l in net.layers:
# if 'block' in l.name:
# l.trainable=False
return encoder, net
