def build_model(trained_model_path=MODEL_PATH,
trained_model_type='weights',
input_shape=IMAGE_SHAPE,
custom_objects: dict = None,
summary=True) -> keras.Model:
"""Create keras Model and Compile."""
if trained_model_type == 'weights':
efn = EfficientNetB3(weights=None,
include_top=False,
input_shape=input_shape)
efn.load_weights(MODEL_PATH)
inp = layers.Input(shape=input_shape)
x = efn(inp)
x = layers.GlobalAveragePooling2D(name='last-pooling')(x)
# x = layers.BatchNormalization(name='last-bn')(x)
# x = layers.Dense(1024, activation='relu', name='fc')(x)
x = layers.Dropout(0.5, name='last-dropout')(x)
out = layers.Dense(NUM_CLASSES, activation='sigmoid', name='out')(x)
model = models.Model(inp, out, name='aptos-densenet')
model.compile(loss='binary_crossentropy',
optimizer=Adam(lr=0.00005),
metrics=[])
else:
model = keras.models.load_model(
trained_model_path,
custom_objects={'relu_max5': relu_max5},
)
if summary:
model.summary()
return model
def create_model(args, branch):
optz = Adam(lr=1e-5)
if args['dataset'] != Dataset.flood_heights:
if args['model'] == arguments.Model.dense_net or args[
'model'] == arguments.Model.attention_guided:
base_model = DenseNet201(include_top=False, weights='imagenet')
else:
base_model = EfficientNetB3(include_top=False, weights='imagenet')
x = base_model.output
x = GlobalAveragePooling2D(name="global_average_pooling2d_layer")(x)
if args['is_binary']:
print("Binary model.")
predictions = Dense(1, activation=activations.sigmoid)(x)
model = Model(inputs=base_model.input, outputs=predictions)
model.compile(optimizer=optz,
loss=losses.binary_crossentropy,
metrics=[metrics.binary_accuracy])
else:
print("3 number of classes.")
predictions = Dense(3, activation=activations.softmax)(x)
model = Model(inputs=base_model.input, outputs=predictions)
model.compile(optimizer=optz,
metrics=[metrics.categorical_accuracy],
loss=losses.categorical_crossentropy)
else:
if args['model'] == arguments.Model.dense_net or args[
'model'] == arguments.Model.attention_guided:
base_model = load_model(
"/home/jpereira/Tests/weights/" +
"flood_severity_3_classes_attention_guided_{}_branch_cv/".
format(branch) + "weights_fold_1_from_10.hdf5")
else:
base_model = load_model(
"/home/jpereira/Tests/weights/" +
"flood_severity_3_classes_cv/weights_fold_1_from_10.hdf5")
print("Regression model.")
output_less_1_m = Dense(1,
activation=custom_activation_less_1m,
name="less_1m")(base_model.layers[-2].output)
output_more_1_m = Dense(1,
activation=custom_activation_more_1m,
name="more_1m")(base_model.layers[-2].output)
predictions = OutputLayer()(
[base_model.layers[-1].output, output_less_1_m, output_more_1_m])
model = Model(inputs=base_model.input,
outputs=[base_model.layers[-1].output, predictions])
model.compile(
optimizer=optz,
loss=[losses.categorical_crossentropy, losses.mean_squared_error])
return model
def construct_model():
# line 1: how do we keep all layers of this model ?
model = EfficientNetB3(weights=None, include_top=False, pooling='avg')
x = model.output
x = KL.Dropout(0.1)(x)
x = KL.Dense(1, kernel_initializer=dense_kernel_initializer)(x)
new_output = KL.Activation('sigmoid')(x)
new_model = Model(model.inputs, new_output)
return new_model
def build_model(input_shape, summary=True) -> keras.Model:
"""Create keras Model and Compile."""
efn = EfficientNetB3(weights=None,
include_top=False,
input_shape=input_shape)
efn.load_weights(MODEL_PATH)
inp = layers.Input(shape=input_shape)
x = efn(inp)
x = layers.GlobalAveragePooling2D(name='last-pooling')(x)
x = layers.Dropout(0.5, name='last-dropout')(x)
out = layers.Dense(1, activation=relu_max5, name='out')(x)
model = models.Model(inp, out, name='aptos-densenet')
model.compile(loss='mse', optimizer=Adam(lr=0.00005), metrics=[])
if summary:
model.summary()
return model
def get_fe(fe, input_image):
if fe == 'effnetb0':
return EfficientNetB0(input_tensor=input_image, include_top=False), [
'swish_last', 'block5_i_MB_swish_1', 'block3_i_MB_swish_1'
]
elif fe == 'effnetb1':
return EfficientNetB1(input_tensor=input_image, include_top=False), [
'swish_last', 'block5_i_MB_swish_1', 'block3_i_MB_swish_1'
]
elif fe == 'effnetb2':
return EfficientNetB2(input_tensor=input_image, include_top=False), [
'swish_last', 'block5_i_MB_swish_1', 'block3_i_MB_swish_1'
]
elif fe == 'effnetb3':
return EfficientNetB3(input_tensor=input_image, include_top=False), [
'swish_last', 'block5_i_MB_swish_1', 'block3_i_MB_swish_1'
]
elif fe == 'effnetb4':
return EfficientNetB4(input_tensor=input_image, include_top=False), [
'swish_last', 'block5_i_MB_swish_1', 'block3_i_MB_swish_1'
]
elif fe == 'effnetb5':
return EfficientNetB5(input_tensor=input_image, include_top=False), [
'swish_last', 'block5_i_MB_swish_1', 'block3_i_MB_swish_1'
]
elif fe == 'd53':
return d53(input_image)
elif fe == 'mnetv2':
mnet = MobileNetV2(input_tensor=input_image, weights='imagenet')
return mnet, [
'out_relu', 'block_13_expand_relu', 'block_6_expand_relu'
]
elif fe == 'mnet':
mnet = MobileNet(input_tensor=input_image, weights='imagenet')
return mnet, ['conv_pw_13_relu', 'conv_pw_11_relu', 'conv_pw_5_relu']
elif fe == 'r50':
r50 = ResNet50(input_tensor=input_image, weights='imagenet')
return r50, ['activation_49', 'activation_40', 'activation_22']
raise ValueError('Pls put the correct fe')
def build_model(trained_model_path=MODEL_PATH,
trained_model_type='weights',
input_shape=IMAGE_SHAPE,
custom_objects: dict = None,
summary=True) -> keras.Model:
"""Create keras Model and Compile."""
if trained_model_type == 'weights':
efn = EfficientNetB3(weights=None,
include_top=False,
input_shape=input_shape)
efn.load_weights(MODEL_PATH)
inp = layers.Input(shape=input_shape, name='image_input')
x = efn(inp)
x = layers.GlobalAveragePooling2D(name='last-pooling')(x)
x = layers.Dropout(0.5, name='last-dropout')(x)
# x = layers.BatchNormalization(name='last-bn')(x)
x = layers.Dense(1024, activation='relu', name='fc')(x)
out = layers.Dense(1, activation='relu', name='out')(x)
model = models.Model(inp, out, name='aptos-densenet')
# import h5py
# from keras.engine.saving import load_weights_from_hdf5_group_by_name
# with h5py.File(MODEL_PATH, mode='r') as f:
# b3layer = list(filter(lambda layer: layer.name == 'efficientnet-b3', model.layers))
# load_weights_from_hdf5_group_by_name(f, b3layer)
model.compile(loss='mse', optimizer=Adam(lr=0.00005), metrics=[])
else:
model = keras.models.load_model(
trained_model_path,
custom_objects={'relu_max5': relu_max5},
)
if summary:
model.summary()
return model
def train(dataset='Fish4Knowledge',
cnn='resnet50',
batch_size=32,
epochs=50,
image_size=32,
eps=0.01):
"""
Train one checkpoint with data augmentation: random padding+cropping and horizontal flip
:param args:
:return:
"""
print(
'Dataset: %s, CNN: %s, loss: adv, epsilon: %.3f batch: %s, epochs: %s'
% (dataset, cnn, eps, batch_size, epochs))
IMAGE_SIZE = image_size
INPUT_SHAPE = (image_size, image_size, 3)
# find image folder: images are distributed in class subfolders
if dataset == 'Fish4Knowledge':
# image_path = '/home/xingjun/datasets/Fish4Knowledge/fish_image'
image_path = '/data/cephfs/punim0619/Fish4Knowledge/fish_image'
images, labels, images_val, labels_val = get_Fish4Knowledge(
image_path, train_ratio=0.8)
elif dataset == 'QUTFish':
# image_path = '/home/xingjun/datasets/QUT_fish_data'
image_path = '/data/cephfs/punim0619/QUT_fish_data'
images, labels, images_val, labels_val = get_QUTFish(image_path,
train_ratio=0.8)
elif dataset == 'WildFish':
# image_pathes = ['/home/xingjun/datasets/WildFish/WildFish_part1',
# '/home/xingjun/datasets/WildFish/WildFish_part2',
# '/home/xingjun/datasets/WildFish/WildFish_part3',
# '/home/xingjun/datasets/WildFish/WildFish_part4']
image_pathes = [
'/data/cephfs/punim0619/WildFish/WildFish_part1',
'/data/cephfs/punim0619/WildFish/WildFish_part2',
'/data/cephfs/punim0619/WildFish/WildFish_part3',
'/data/cephfs/punim0619/WildFish/WildFish_part4'
]
images, labels, images_val, labels_val = get_WildFish(image_pathes,
train_ratio=0.8)
# images, labels, images_val, labels_val = get_imagenet_googlesearch_data(image_path, num_class=NUM_CLASS)
num_classes = len(np.unique(labels))
num_images = len(images)
num_images_val = len(images_val)
print('Train: classes: %s, images: %s, val images: %s' %
(num_classes, num_images, num_images_val))
global current_index
current_index = 0
# dynamic loading a batch of data
def get_batch():
index = 1
global current_index
B = np.zeros(shape=(batch_size, IMAGE_SIZE, IMAGE_SIZE, 3))
L = np.zeros(shape=(batch_size))
while index < batch_size:
try:
img = load_img(images[current_index],
target_size=(IMAGE_SIZE, IMAGE_SIZE))
img = img_to_array(img)
img /= 255.
# if cnn == 'ResNet50': # imagenet pretrained
# mean = np.array([0.485, 0.456, 0.406])
# std = np.array([0.229, 0.224, 0.225])
# img = (img - mean)/std
## data augmentation
# random width and height shift
img = random_shift(img, 0.2, 0.2)
# random rotation
img = random_rotation(img, 10)
# random horizental flip
flip_horizontal = (np.random.random() < 0.5)
if flip_horizontal:
img = flip_axis(img, axis=1)
# # random vertical flip
# flip_vertical = (np.random.random() < 0.5)
# if flip_vertical:
# img = flip_axis(img, axis=0)
# #cutout
# eraser = get_random_eraser(v_l=0, v_h=1, pixel_level=False)
# img = eraser(img)
B[index] = img
L[index] = labels[current_index]
index = index + 1
current_index = current_index + 1
except:
traceback.print_exc()
# print("Ignore image {}".format(images[current_index]))
current_index = current_index + 1
# B = np.rollaxis(B, 3, 1)
return B, np_utils.to_categorical(L, num_classes)
global val_current_index
val_current_index = 0
# dynamic loading a batch of validation data
def get_val_batch():
index = 1
B = np.zeros(shape=(batch_size, IMAGE_SIZE, IMAGE_SIZE, 3))
L = np.zeros(shape=(batch_size))
global val_current_index
while index < batch_size:
try:
img = load_img(images_val[val_current_index],
target_size=(IMAGE_SIZE, IMAGE_SIZE))
img = img_to_array(img)
img /= 255.
# if cnn == 'ResNet50': # imagenet pretrained
# mean = np.array([0.485, 0.456, 0.406])
# std = np.array([0.229, 0.224, 0.225])
# img = (img - mean)/std
B[index] = img
L[index] = labels_val[val_current_index]
index = index + 1
val_current_index = val_current_index + 1
except:
traceback.print_exc()
# print("Ignore image {}".format(images[val_current_index]))
val_current_index = val_current_index + 1
# B = np.rollaxis(B, 3, 1)
return B, np_utils.to_categorical(L, num_classes)
# load checkpoint
if cnn == 'ResNet18':
base_model = ResNet18(input_shape=INPUT_SHAPE,
classes=num_classes,
include_top=False)
elif cnn == 'ResNet34':
base_model = ResNet34(input_shape=INPUT_SHAPE,
classes=num_classes,
include_top=False)
elif cnn == 'ResNet50':
base_model = ResNet50(include_top=False,
weights='imagenet',
input_shape=INPUT_SHAPE)
elif cnn == 'EfficientNetB1':
base_model = EfficientNetB1(input_shape=INPUT_SHAPE,
classes=num_classes,
include_top=False,
backend=keras.backend,
layers=keras.layers,
models=keras.models,
utils=keras.utils)
elif cnn == 'EfficientNetB2':
base_model = EfficientNetB2(input_shape=INPUT_SHAPE,
classes=num_classes,
include_top=False,
backend=keras.backend,
layers=keras.layers,
models=keras.models,
utils=keras.utils)
elif cnn == 'EfficientNetB3':
base_model = EfficientNetB3(input_shape=INPUT_SHAPE,
classes=num_classes,
include_top=False,
backend=keras.backend,
layers=keras.layers,
models=keras.models,
utils=keras.utils)
elif cnn == 'EfficientNetB4':
base_model = EfficientNetB4(input_shape=INPUT_SHAPE,
classes=num_classes,
include_top=False,
backend=keras.backend,
layers=keras.layers,
models=keras.models,
utils=keras.utils)
else:
warnings.warn("Error: unrecognized dataset!")
return
x = base_model.output
x = Flatten()(x)
x = Dense(num_classes, name='dense')(x)
output = Activation('softmax')(x)
model = Model(input=base_model.input, output=output, name=cnn)
# model.summary()
loss = cross_entropy
base_lr = 1e-2
sgd = SGD(lr=base_lr, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss=loss, optimizer=sgd, metrics=['accuracy'])
# AdaFGSM attack for AdvFish training
attack = AdaFGSM(model,
epsilon=float(eps),
random_start=True,
loss_func='xent',
clip_min=0.,
clip_max=1.)
# PGD attack for AdvFish training, it reduces to FGSM when set nb_iter=1
# attack = LinfPGDAttack(model,
# epsilon=float(eps),
# eps_iter=float(eps),
# nb_iter=1,
# random_start=True,
# loss_func='xent',
# clip_min=0.,
# clip_max=1.)
# always save your weights after training or during training
# create folder if not exist
if not os.path.exists('models/'):
os.makedirs('models/')
log_path = 'log/%s' % dataset
if not os.path.exists(log_path):
os.makedirs(log_path)
## loop the weight folder then load the lastest weight file continue training
model_prefix = '%s_%s_%s_%.4f_' % (dataset, cnn, 'adv', eps)
w_files = os.listdir('models/')
existing_ep = 0
# for fl in w_files:
# if model_prefix in fl:
# ep = re.search(model_prefix+"(.+?).h5", fl).group(1)
# if int(ep) > existing_ep:
# existing_ep = int(ep)
#
# if existing_ep > 0:
# weight_file = 'models/' + model_prefix + str(existing_ep) + ".h5"
# print("load previous model weights from: ", weight_file)
# model.load_weights(weight_file)
#
# log = np.load(os.path.join(log_path, 'train_log_%s_%s_%.3f.npy' % (cnn, 'adv', eps)))
#
# train_loss_log = log[0, :existing_ep+1].tolist()
# train_acc_log = log[1, :existing_ep+1].tolist()
# val_loss_log = log[2, :existing_ep+1].tolist()
# val_acc_log = log[3, :existing_ep+1].tolist()
# else:
train_loss_log = []
train_acc_log = []
val_loss_log = []
val_acc_log = []
# dynamic training
for ep in range(epochs - existing_ep):
# cosine learning rate annealing
eta_min = 1e-5
eta_max = base_lr
lr = eta_min + (eta_max -
eta_min) * (1 + math.cos(math.pi * ep / epochs)) / 2
K.set_value(model.optimizer.lr, lr)
# # step-wise learning rate annealing
# if ep in [int(epochs*0.5), int(epochs*0.75)]:
# lr = K.get_value(model.optimizer.lr)
# K.set_value(model.optimizer.lr, lr*.1)
# print("lr decayed to {}".format(lr*.1))
current_index = 0
n_step = int(num_images / batch_size)
pbar = tqdm(range(n_step))
for stp in pbar:
b, l = get_batch()
# adversarial denoising
b_adv = attack.perturb(K.get_session(), b, l, batch_size)
train_loss, train_acc = model.train_on_batch(b_adv, l)
pbar.set_postfix(acc='%.4f' % train_acc, loss='%.4f' % train_loss)
## test acc and loss at each epoch
val_current_index = 0
y_pred = []
y_true = []
while val_current_index + batch_size < num_images_val:
b, l = get_val_batch()
pred = model.predict(b)
y_pred.extend(pred.tolist())
y_true.extend(l.tolist())
y_pred = np.clip(np.array(y_pred), 1e-7, 1.)
correct_pred = (np.argmax(y_pred, axis=1) == np.argmax(y_true, axis=1))
val_acc = np.mean(correct_pred)
val_loss = -np.sum(np.mean(y_true * np.log(y_pred),
axis=1)) / val_current_index
train_loss_log.append(train_loss)
train_acc_log.append(train_acc)
val_loss_log.append(val_loss)
val_acc_log.append(val_acc)
log = np.stack((np.array(train_loss_log), np.array(train_acc_log),
np.array(val_loss_log), np.array(val_acc_log)))
# save training log
np.save(
os.path.join(log_path,
'train_log_%s_%s_%.4f.npy' % (cnn, 'adv', eps)), log)
pbar.set_postfix(acc='%.4f' % train_acc,
loss='%.4f' % train_loss,
val_acc='%.4f' % val_acc,
val_loss='%.4f' % val_loss)
print(
"Epoch %s - loss: %.4f - acc: %.4f - val_loss: %.4f - val_acc: %.4f"
% (ep, train_loss, train_acc, val_loss, val_acc))
images, labels = shuffle(images, labels)
if ((ep + existing_ep + 1) % 5
== 0) or (ep == (epochs - existing_ep - 1)):
model_file = 'models/%s_%s_%s_%.4f_%s.h5' % (dataset, cnn, 'adv',
eps, ep + existing_ep)
model.save_weights(model_file)
target_size=(height, width),
batch_size=batch_size,
color_mode='rgb',
# Since we use categorical_crossentropy loss, we need categorical labels
class_mode='binary')
validation_generator = test_datagen.flow_from_directory(validation_dir,
target_size=(height,
width),
batch_size=batch_size,
color_mode='rgb',
class_mode='binary')
#Show architecture model
# loading pretrained conv base model
conv_base = Net(weights='imagenet', include_top=False, input_shape=input_shape)
x = conv_base.output
global_average_layer = layers.GlobalAveragePooling2D()(x)
dropout_layer_1 = layers.Dropout(0.50)(global_average_layer)
prediction_layer = layers.Dense(1, activation='sigmoid')(dropout_layer_1)
model = models.Model(inputs=conv_base.input, outputs=prediction_layer)
model.summary()
# model = models.Sequential()
# model.add(conv_base)
# model.add(layers.GlobalMaxPooling2D(name="gap"))
# # model.add(layers.Flatten(name="flatten"))
# if dropout_rate > 0:
# model.add(layers.Dropout(dropout_rate, name="dropout_out"))
# # model.add(layers.Dense(256, activation='relu', name="fc1"))
def get_effnet_model(save_path,
model_res=1024,
image_size=256,
depth=1,
size=3,
activation='elu',
loss='logcosh',
optimizer='adam'):
if os.path.exists(save_path):
print('Loading model')
return load_model(save_path)
# Build model
print('Building model')
model_scale = int(2 *
(math.log(model_res, 2) - 1)) # For example, 1024 -> 18
if (size <= 0):
effnet = EfficientNetB0(include_top=False,
weights='imagenet',
input_shape=(image_size, image_size, 3))
if (size == 1):
effnet = EfficientNetB1(include_top=False,
weights='imagenet',
input_shape=(image_size, image_size, 3))
if (size == 2):
effnet = EfficientNetB2(include_top=False,
weights='imagenet',
input_shape=(image_size, image_size, 3))
if (size >= 3):
effnet = EfficientNetB3(include_top=False,
weights='imagenet',
input_shape=(image_size, image_size, 3))
layer_size = model_scale * 8 * 8 * 8
if is_square(layer_size): # work out layer dimensions
layer_l = int(math.sqrt(layer_size) + 0.5)
layer_r = layer_l
else:
layer_m = math.log(math.sqrt(layer_size), 2)
layer_l = 2**math.ceil(layer_m)
layer_r = layer_size // layer_l
layer_l = int(layer_l)
layer_r = int(layer_r)
x_init = None
inp = Input(shape=(image_size, image_size, 3))
x = effnet(inp)
if (size < 1):
x = Conv2D(model_scale * 8, 1, activation=activation)(x) # scale down
if (depth > 0):
x = Reshape((layer_r, layer_l))(
x
) # See https://github.com/OliverRichter/TreeConnect/blob/master/cifar.py - TreeConnect inspired layers instead of dense layers.
else:
if (depth < 1):
depth = 1
if (size <= 2):
x = Conv2D(model_scale * 8 * 4, 1,
activation=activation)(x) # scale down a bit
x = Reshape((layer_r * 2, layer_l * 2))(
x
) # See https://github.com/OliverRichter/TreeConnect/blob/master/cifar.py - TreeConnect inspired layers instead of dense layers.
else:
x = Reshape((384, 256))(x) # full size for B3
while (depth > 0):
x = LocallyConnected1D(layer_r, 1, activation=activation)(x)
x = Permute((2, 1))(x)
x = LocallyConnected1D(layer_l, 1, activation=activation)(x)
x = Permute((2, 1))(x)
if x_init is not None:
x = Add()([x, x_init]) # add skip connection
x_init = x
depth -= 1
if (
size >= 2
): # add unshared layers at end for different sections of the latent space
x_init = x
if layer_r % 3 == 0 and layer_l % 3 == 0:
a = LocallyConnected1D(layer_r, 1, activation=activation)(x)
b = LocallyConnected1D(layer_r, 1, activation=activation)(x)
c = LocallyConnected1D(layer_r, 1, activation=activation)(x)
a = Permute((2, 1))(a)
b = Permute((2, 1))(b)
c = Permute((2, 1))(c)
a = LocallyConnected1D(layer_l // 3, 1, activation=activation)(a)
b = LocallyConnected1D(layer_l // 3, 1, activation=activation)(b)
c = LocallyConnected1D(layer_l // 3, 1, activation=activation)(c)
x = Concatenate()([a, b, c])
else:
a = LocallyConnected1D(layer_r // 2, 1, activation=activation)(x)
b = LocallyConnected1D(layer_r // 2, 1, activation=activation)(x)
c = LocallyConnected1D(layer_r // 2, 1, activation=activation)(x)
d = LocallyConnected1D(layer_r // 2, 1, activation=activation)(x)
a = Permute((2, 1))(a)
b = Permute((2, 1))(b)
c = Permute((2, 1))(c)
d = Permute((2, 1))(d)
a = LocallyConnected1D(layer_l // 2, 1, activation=activation)(a)
b = LocallyConnected1D(layer_l // 2, 1, activation=activation)(b)
c = LocallyConnected1D(layer_l // 2, 1, activation=activation)(c)
d = LocallyConnected1D(layer_l // 2, 1, activation=activation)(d)
x = Concatenate()([a, b, c, d])
x = Add()([x, x_init]) # add skip connection
x = Reshape((model_scale, 512))(x) # train against all dlatent values
model = Model(inputs=inp, outputs=x)
model.compile(loss=loss, metrics=[], optimizer=optimizer
) # By default: adam optimizer, logcosh used for loss.
return model
def _create_model():
print('Creating model')
# load the pretrained model, without the classification (top) layers
if self.transfer_model == 'Xception':
base_model = tf.keras.applications.Xception(
weights='imagenet',
include_top=False,
input_shape=(*self.target_size, 3))
based_model_last_block = 116 # last block 126, two blocks 116
elif self.transfer_model == 'Inception_Resnet':
base_model = tf.keras.applications.InceptionResNetV2(
weights='imagenet',
include_top=False,
input_shape=(*self.target_size, 3))
based_model_last_block = 287 # last block 630, two blocks 287
elif self.transfer_model == 'Resnet':
base_model = tf.keras.applications.ResNet50(
weights='imagenet',
include_top=False,
input_shape=(*self.target_size, 3))
based_model_last_block = 155 # last block 165, two blocks 155
elif self.transfer_model == 'B0':
base_model = EfficientNetB0(weights='imagenet',
include_top=False,
input_shape=(*self.target_size, 3))
based_model_last_block = 213 # last block 229, two blocks 213
elif self.transfer_model == 'B3':
base_model = EfficientNetB3(weights='imagenet',
include_top=False,
input_shape=(*self.target_size, 3))
based_model_last_block = 354 # last block 370, two blocks 354
elif self.transfer_model == 'B5':
base_model = EfficientNetB5(weights='imagenet',
include_top=False,
input_shape=(*self.target_size, 3))
based_model_last_block = 417 # last block 559, two blocks 417
else:
base_model = tf.keras.applications.InceptionV3(
weights='imagenet',
include_top=False,
input_shape=(*self.target_size, 3))
based_model_last_block = 249 # last block 280, two blocks 249
# Set only the top layers as trainable (if we want to do fine-tuning,
# we can train the base layers as a second step)
base_model.trainable = False
# Target size infered from the base model
self.target_size = base_model.input_shape[1:3]
# Add the classification layers using Keras functional API
x = base_model.output
x = tf.keras.layers.GlobalAveragePooling2D()(x)
# Hidden layer for classification
if hidden_size == 0:
x = tf.keras.layers.Dropout(rate=dropout)(x)
elif bn_after_ac:
x = tf.keras.layers.Dense(
hidden_size,
activation=activation,
kernel_regularizer=tf.keras.regularizers.l2(
l=l2_lambda))(x)
x = tf.keras.layers.BatchNormalization()(x)
x = tf.keras.layers.Dropout(rate=dropout)(x)
else:
x = tf.keras.layers.Dense(
hidden_size,
use_bias=False,
kernel_regularizer=tf.keras.regularizers.l2(
l=l2_lambda))(x)
# scale: When the next layer is linear (also e.g. nn.relu), this can be disabled since the scaling can be done by the next layer.
x = tf.keras.layers.BatchNormalization(
scale=activation != 'relu')(x)
x = tf.keras.layers.Activation(activation=activation)(x)
x = tf.keras.layers.Dropout(rate=dropout)(x)
predictions = tf.keras.layers.Dense(len(self.categories),
activation='softmax')(
x) # Output layer
# Define the optimizer and the loss and the optimizer
loss = 'sparse_categorical_crossentropy'
metrics = ['sparse_categorical_accuracy']
optimizer = tf.keras.optimizers.Adam(lr=learning_rate)
return tf.keras.Model(
inputs=base_model.input, outputs=predictions
), base_model, based_model_last_block, loss, metrics, optimizer
lat, lon = healpix2latlon(region_classes[i], int(resolution))
aux = get_values(land_coverage, elevation, vegetation, land_coverage_data,
elevation_data, vegetation_data, lon, lat)
terrain_matrix.append(aux[0])
codes_matrix = [codes_matrix]
terrain_matrix = [terrain_matrix]
######### MODEL ################
#denseNet = densenet.DenseNet201(weights='imagenet', include_top=False, input_shape=(image_size,image_size,3), pooling = 'avg')
efficientNet = EfficientNetB3(input_shape=(image_size, image_size, 3),
classes=1000,
include_top=True,
weights='imagenet')
#build model
codes_input_matrix = layers.Input(shape=(Y2_train.shape[1], 3),
dtype='float32',
name="codes_matrix")
terrain_input_matrix = layers.Input(shape=(Y2_train.shape[1], 20),
dtype='float32',
name="terrain_matrix")
inp = layers.Input(shape=(image_size, image_size, 3))
#x = denseNet(inp)
x = efficientNet(inp)
auxiliary_output = layers.Dense(Y2_train.shape[1],
# load validation data
X_val = np.empty((len(val_paths), 300, 300, 3), dtype=np.uint8)
for i, path in tqdm_notebook(enumerate(val_paths)):
X_val[i, :, :, :] = get_image(path)
# image data generator
train_aug = ImageDataGenerator(zoom_range=0.25,
rotation_range=25,
vertical_flip=True,
horizontal_flip=True)
# Model
base_model = EfficientNetB3(weights=None,
include_top=False,
input_shape=(300, 300, 3))
base_model.load_weights(
'../input/efficientnet-keras-weights-b0b5/efficientnet-b3_imagenet_1000_notop.h5'
)
model = Sequential()
model.add(base_model)
model.add(GlobalAveragePooling2D())
model.add(Dropout(0.5))
model.add(Dense(5, activation='sigmoid'))
optimizer = Adam(lr=0.00005)
loss = "binary_crossentropy"
# callbacks - early stopping and reduce learning rate on plateau
es = EarlyStopping(monitor='val_loss',
plt.figure(figsize=(30,25))
plt.title('Confusion Matrix ')
ax =plt.subplot()
sns.heatmap(confusion_mtx, annot=True, fmt = 'd',cmap ='BuPu')
plt.show()
from efficientnet import EfficientNetB3
from keras.activations import elu
from keras.optimizers import Adam
effnet = EfficientNetB3(weights=None,
include_top=False,
input_shape=(img_height,img_width, 3))
#effnet.load_weights('../input/efficientnet-keras-weights-b0b5/efficientnet-b3_imagenet_1000_notop.h5')
def build_model():
"""
A custom implementation of EfficientNetB3
for the APTOS 2019 competition
(Regression)
"""
model = Sequential()
model.add(effnet)
model.add(GlobalAveragePooling2D())
model.add(Dropout(0.5))
model.add(Dense(5, activation=elu))
model.add(Dense(5, activation="linear"))
# In[15]:
HEIGHT = 299
WIDTH = 299
input_shape=(HEIGHT, WIDTH, 3)
dropout = 0.7
epochs = 100
swa = SWA('./keras_swa.model',epochs-3)
base_model = EfficientNetB3(weights='imagenet',
include_top=False,
input_shape=(HEIGHT, WIDTH, 3))
finetune_model = build_finetune_model(base_model,
dropout=dropout,
num_classes=196)
finetune_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
snapshot = SnapshotCallbackBuilder(nb_epochs=epochs,nb_snapshots=1,init_lr=1e-3)
history = finetune_model.fit_generator(generator=train_generator,
validation_data=validation_generator,
steps_per_epoch=150,
epochs=epochs,verbose=2,validation_steps=55,callbacks=snapshot.get_callbacks())
import timeit
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.pyplot import imread
from keras.applications.imagenet_utils import decode_predictions
from efficientnet import EfficientNetB3
from efficientnet import center_crop_and_resize, preprocess_input
# image = imread("../misc/panda.jpg")
# plt.figure(figsize=(10, 10))
# plt.imshow(image)
# plt.show()
model = EfficientNetB3(weights="imagenet")
class Params():
image_size = model.input_shape[1]
NUM_CLASSES = 1000 # classes
NUM_IMAGES = 4 # images per folder
cls = 0 # starting imagenet class
im = 0 # pointer to current image of class i
top_1_correct = 0
total_imgs = 0
# preprocess image
def predict(p):
img_file = "../../imagenetv2-matched-frequency/{}/{}.jpeg".format(