def Bisnet(input_height, input_width, n_classes=20):
input_image = tf.keras.Input(shape=(input_height, input_width, 3),
name="input_image",
dtype=tf.float32)
# x = Lambda(lambda image: preprocess_input(image))(inputs)
x = input_image
xception = Xception(weights='imagenet', input_tensor=x, include_top=False)
tail_prev = xception.get_layer('block13_pool').output
tail = xception.output
layer_13, layer_14 = tail_prev, tail
x = ConvAndBatch(x, 32, strides=2)
x = ConvAndBatch(x, 64, strides=2)
x = ConvAndBatch(x, 156, strides=2)
# context path
cp = ContextPath(layer_13, layer_14)
# fusion = self.FeatureFusionModule(cp, x, 32)
fusion = FeatureFusionModule(cp, x, n_classes)
ans = UpSampling2D(size=(8, 8), interpolation='bilinear')(fusion)
output = tf.keras.layers.Softmax(axis=3, dtype=tf.float32)(ans)
return tf.keras.Model(inputs=input_image, outputs=output, name="bisnet")
def create_model(shape):
from keras import layers
# from keras import models
from keras import optimizers
# from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
from tensorflow.keras import Model
# from tensorflow.keras.initializers import glorot_uniform
from tensorflow.keras.regularizers import l2
# from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.applications import Xception
model = Xception(input_shape = (shape, shape, 3), include_top = False, weights = 'imagenet')
x = model.output
x = layers.AveragePooling2D(pool_size = (2, 2))(x)
x = layers.Dense(32, activation = 'relu')(x)
x = layers.Flatten()(x)
# spostato dopo Flatten
x = layers.Dropout(0.1)(x)
# a caso
x = layers.Dense(128)(x)
x = layers.Dense(4, activation = 'softmax', kernel_regularizer = l2(.0005))(x)
model = Model(inputs = model.inputs, outputs = x)
opt = optimizers.SGD(lr = 0.0001, momentum = .9)
model.compile(loss = 'categorical_crossentropy', optimizer = opt, metrics = ['accuracy'])
return model
def __init__(self):
with graph.as_default():
self.model = Xception(
weights="imagenet",
classes=1000,
classifier_activation="softmax",
)
def xception_model(num_classes, input_shape, dropout_rate=0.25):
"""
xception_model(num_classes, input_shape, dropout_rate=0.25)
This function creates an implementation of a convolutional deep learning model for estimating
a discrete category based on xception, trained from scratch
INPUTS:
* num_classes = number of classes (output nodes on classification layer)
* input_shape = size of input layer (i.e. image tensor)
OPTIONAL INPUTS:
* dropout_rate = proportion of neurons to randomly set to zero, after the pooling layer
GLOBAL INPUTS: None
OUTPUTS: keras model instance
"""
EXTRACTOR = Xception(weights=None, include_top=False,
input_shape=input_shape)
EXTRACTOR.trainable = True
# Construct the head of the model that will be placed on top of the
# the base model
class_head = EXTRACTOR.output
class_head = tf.keras.layers.GlobalAveragePooling2D()(class_head)
class_head = tf.keras.layers.Dense(256, activation="relu")(class_head)
class_head = tf.keras.layers.Dropout(dropout_rate)(class_head)
class_head = tf.keras.layers.Dense(num_classes, activation="softmax")(class_head)
# Create the new model
model = tf.keras.Model(inputs=EXTRACTOR.input, outputs=class_head)
return model
def build_Xception_FT(img_shape=(128,128),num_classes=1):
base_model = Xception(include_top=False, input_shape = img_shape,weights='imagenet')
base_model.trainable = True
fine_tune_at = 130
for layer in base_model.layers[:fine_tune_at]:
layer.trainable = False
x = Flatten()(base_model.output)
x = Dense(4096)(x)
x = ReLU()(x)
x = Dropout(0.2)(x)
x = Dense(512)(x)
x = ReLU()(x)
outputs = Dense(num_classes
,kernel_initializer = "he_normal"
, activation='sigmoid')(x)
finetuning = Model(inputs=[base_model.input], outputs=[outputs])
adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0)
finetuning.compile(optimizer=adam, loss='binary_crossentropy', metrics=['accuracy'])
return finetuning
def cnn_model():
takemodel = Xception(include_top=False, input_shape=(1024, 1024, 3))
takemodel.trainable = False
model = Sequential()
model.add(takemodel)
model.add(Flatten())
model.add(Dense(12, activation='softmax'))
model.summary()
return model
def predict(img):
model = Xception(weights="imagenet",
include_top=True,
input_tensor=Input(shape=(224, 224, 3)))
img = img_to_array(img)
img = img.reshape((-1, img.shape[0], img.shape[1], 3)) / 255
rez = model.predict(img)
rez = pd.DataFrame(decode_predictions(rez)[0],
columns=['_', 'breed',
'prct']).drop(columns='_').sort_values(
by='prct', ascending=False)
np.array(rez)
return rez
def deep_lstm_model(image_shape, sequence_length, classes):
(h, w, c) = image_shape
sequence_shape = (sequence_length, h, w, c)
video = Input(shape=sequence_shape)
# cnn_base = VGG16(input_shape=image_shape,
# weights="imagenet",
# include_top=False)
extractor_base = Xception(
include_top=False,
weights='imagenet',
input_shape=image_shape,
pooling='avg',
)
# cnn_out = GlobalAveragePooling2D()(cnn_base.output)
extractor = Model(extractor_base.input, extractor_base.output)
extractor.trainable = False
encoded_frames = TimeDistributed(extractor)(video)
encoded_sequences = LSTM(64, return_sequences=True)(encoded_frames)
encoded_sequence = LSTM(64)(encoded_sequences)
hidden_layer = Dense(256, activation="relu")(encoded_sequence)
outputs = Dense(classes, activation="softmax")(hidden_layer)
model = Model(video, outputs)
optimizer = Nadam(lr=0.002,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
schedule_decay=0.004)
model.compile(loss="sparse_categorical_crossentropy",
optimizer=optimizer,
metrics=["categorical_accuracy"])
return model
def transferlearning(modelname, learning_rate, image_shape, training_path, epoch):
train_datagen = ImageDataGenerator(
rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True,
validation_split=0.2)
train_generator = train_datagen.flow_from_directory(
training_path,
target_size=(image_shape, image_shape),
batch_size=128,
class_mode='categorical',
subset='training',
shuffle=True)
validation_generator = train_datagen.flow_from_directory(
training_path,
target_size=(image_shape, image_shape),
batch_size=128,
class_mode='categorical',
subset='validation')
num_classes = train_generator.num_classes
if modelname == 'VGG19':
base_model = VGG19(input_shape=(image_shape, image_shape, 3),
include_top=False, weights='imagenet')
elif modelname == 'MobileNetV2':
base_model = MobileNetV2(
input_shape=(image_shape, image_shape, 3), include_top=False, weights='imagenet')
elif modelname == 'DenseNet201':
base_model = DenseNet201(
input_shape=(image_shape, image_shape, 3), include_top=False, weights='imagenet')
elif modelname == 'InceptionV3':
base_model = InceptionV3(
input_shape=(image_shape, image_shape, 3), include_top=False, weights='imagenet')
elif modelname == 'ResNet50':
base_model = ResNet50(input_shape=(image_shape, image_shape, 3),
include_top=False, weights='imagenet')
elif modelname == 'Xception':
base_model = Xception(input_shape=(image_shape, image_shape, 3),
include_top=False, weights='imagenet')
base_model.output
global_layer = keras.layers.GlobalAveragePooling2D()(base_model.output)
prediction_layer = keras.layers.Dense(
num_classes, activation='softmax')(global_layer)
model = keras.models.Model(
inputs=base_model.input, outputs=prediction_layer)
model.summary()
model.compile(optimizer=Adam(lr=learning_rate),
loss='categorical_crossentropy', metrics=["acc"])
history = model.fit_generator(
train_generator,
epochs=epoch,
validation_data=validation_generator,
validation_steps=1000)
return history
class FeatureExtractor:
def __init__(self):
with graph.as_default():
self.model = Xception(
weights="imagenet",
classes=1000,
classifier_activation="softmax",
)
def extract(self, img):
"""
Extract a deep feature from an input image
Args:
img: from PIL.Image.open(path) or tensorflow.keras.preprocessing.image.load_img(path)
Returns:
feature (np.ndarray): deep feature with the shape=(4096, )
"""
img = Image.open(img)
img = img.resize(
(299, 299)) # Xception must take a 299x299 img as an input
img = img.convert('RGB') # Make sure img is color
x = image.img_to_array(
img) # To np.array. Height x Width x Channel. dtype=float32
x = np.expand_dims(
x, axis=0
) # (H, W, C)->(1, H, W, C), where the first elem is the number of img
x = preprocess_input(x) # Subtracting avg values for each pixel
with graph.as_default():
set_session(sess)
feature = self.model.predict(x)[0] # (1, 4096) -> (4096, )
return feature / np.linalg.norm(feature) # Normalize
def buildNihModel(self, img_size, label_len):
"""
This function builds a base Xception model for pretraining with the NIH
dataset.
Parameters:
img_size (int): the size of input images (img_size, img_size).
label_len (int): the length of the labels from the NIH dataset.
Returns:
model (class): the Xception model used in pretraining.
"""
base_model = Xception(weights='imagenet',
include_top=False,
input_shape=(img_size, img_size, 3))
x = base_model.output
x = layers.GlobalAveragePooling2D()(x)
predictions = layers.Dense(label_len,
activation='sigmoid',
name='last')(x)
model = Model(inputs=base_model.input, outputs=predictions)
if not self.weights == 'imagenet':
model.load_weights(self.weights)
return model
def xception(input_shape: Tuple[int, int, int],
output_shape: Tuple[int, ...],
weights: str = 'imagenet',
include_top: bool = False) -> Model:
base_model = Xception(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 create_model():
base_model = Xception(
weights='imagenet',
include_top=False,
pooling='avg'
)
# Add new fully connected layers for ifcb
# dense layer to classify with softmax
model_output = base_model.output
model_output = Dense(1024, activation='relu')(model_output)
model_output = Dense(50, activation='softmax')(model_output)
model = Model(inputs=base_model.input, outputs=model_output)
# Only train the dense layers, user transfer learning for the rest
for layer in model.layers[:-2]:
layer.trainable = False
for layer in model.layers[-2::]:
layer.trainable = True
model.compile(
optimizer='Adam',
loss='categorical_crossentropy',
metrics=['categorical_accuracy'],
)
return model
def make_model():
base_model = Xception(include_top=False,
input_shape=(71, 71, 3),
weights=None)
for layer in base_model.layers:
layer.trainable = True
model = base_model.output
model = Flatten()(model)
model = Dense(512, kernel_initializer='he_uniform')(model)
model = Dropout(0.2)(model)
model = BatchNormalization()(model)
model = Activation('relu')(model)
model = Dense(128, kernel_initializer='he_uniform')(model)
model = Dropout(0.2)(model)
model = BatchNormalization()(model)
model = Activation('relu')(model)
model = Dense(52, kernel_initializer='he_uniform')(model)
model = Dropout(0.2)(model)
model = BatchNormalization()(model)
model = Activation('relu')(model)
model = Dense(16, kernel_initializer='he_uniform')(model)
model = Dropout(0.2)(model)
model = BatchNormalization()(model)
model = Activation('relu')(model)
output = Dense(7, activation='softmax')(model)
return Model(inputs=base_model.input, outputs=output)
def build_model(classes=2):
inputs = Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3))
x = preprocess_input(inputs)
x = Xception(weights=None, classes=classes)(x)
model = Model(inputs=inputs, outputs=x)
model.compile(loss='categorical_crossentropy', metrics=['accuracy'])
return model
def get_feature_extractor(weights_file):
""""""
from tensorflow.keras.applications import Xception
xception = Xception(include_top=False, weights=weights_file)
outputs = keras.layers.GlobalAveragePooling2D(name="avg_pool")(xception.output)
model = keras.Model(xception.input, outputs)
return model
def pretrainedmodel(classes,
name_model='VGG16',
use_l2=True,
is_trainable=False):
models = ['VGG16', 'ResNet50', 'InceptionV3', 'Xception']
if name_model not in models:
print('Name model not found. Try {}'.format(models))
return
if name_model == 'VGG16':
expected_dim = (224, 224, 3)
vgg16 = VGG16(weights='imagenet', include_top=False, pooling='avg')
basemodel = Model(inputs=vgg16.inputs,
outputs=vgg16.get_layer(index=-1).output)
if name_model == 'ResNet50':
expected_dim = (224, 224, 3)
resnet = ResNet50(weights='imagenet', include_top=False, pooling='avg')
basemodel = Model(inputs=resnet.inputs,
outputs=resnet.get_layer(index=-1).output)
if name_model == 'InceptionV3':
expected_dim = (299, 299, 3)
iv3 = InceptionV3(weights='imagenet', include_top=False, pooling='avg')
basemodel = Model(inputs=iv3.inputs,
outputs=iv3.get_layer(index=-1).output)
if name_model == 'Xception':
expected_dim = (299, 299, 3)
xcep = Xception(weights='imagenet', include_top=False, pooling='avg')
basemodel = Model(inputs=xcep.inputs,
outputs=xcep.get_layer(index=-1).output)
# freeze weights
basemodel.trainable = is_trainable
x = basemodel.output
# add l2-norm constraint
if use_l2:
x = L2Layer()(x)
# predictions
y = Dense(classes, activation='softmax', name='predictions')(x)
model = Model(inputs=basemodel.input, outputs=y)
return model, expected_dim
def build_Xception_pretrain(img_shape=(128,128,3),num_classes=1, lr=0.001):
base_model = Xception(include_top=False, input_shape = img_shape,weights='imagenet')
base_model.trainable = False
x = base_model.get_layer('avg_pool').output
outputs = Dense(num_classes
,kernel_initializer = "he_normal"
, activation='sigmoid')(x)
final_model = Model(inputs=[base_model.input], outputs=[outputs])
adam = Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-08, decay=0)
final_model.compile(optimizer=adam, loss='binary_crossentropy', metrics=['accuracy'])
return final_model
def buildTunerModel(self, img_size):
"""
This function builds a base Xception model for keras tuner
Parameters:
img_size (int): the size of input images (img_size, img_size).
Returns:
model (class): the Xception model used for keras tuner.
"""
base_model = Xception(weights='imagenet',
include_top=False,
input_shape=(img_size, img_size, 3))
if not self.weights == 'imagenet':
base_model.load_weights(self.weights, by_name=True)
return base_model
def build_model(input_shape, num_classes):
base_model = Xception(weights='imagenet', include_top=False, input_shape=input_shape)
base_model.trainable = True
for _i, _layer in enumerate(base_model.layers):
if _i < 100:
_layer.trainable = False
else:
_layer.trainable = True
model = Sequential()
model.add(base_model)
model.add(GlobalAveragePooling2D())
model.add(Dense(num_classes, activation='softmax'))
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 __init__(self, layer_name='add_3', weight_decay=0.005):
super(FTCF_Net, self).__init__()
self.weight_decay = weight_decay
self.layer_name = layer_name
self.basemodel = Xception(weights='imagenet',
input_shape=(224, 224, 3),
include_top=False)
# Feature Extractor for Every Frames
self.backbone = tf.keras.Model(inputs=self.basemodel.input,
outputs=self.basemodel.get_layer(
self.layer_name).output)
self.backbone.trainable = False
self.cbm1 = CBM(filters=364, kernel=(1, 1, 2))
# Fusion Stage 1
self.ftcf1 = FTCF_Block(32)
self.avgpooling3d_1 = AveragePooling3D((2, 2, 2),
strides=(2, 2, 2),
padding='same')
# Fusion Stage 2
self.ftcf2 = FTCF_Block(32)
self.avgpooling3d_2 = AveragePooling3D((2, 2, 2),
strides=(2, 2, 2),
padding='same')
# Fusion Stage 3
self.ftcf3 = FTCF_Block(64)
self.avgpooling3d_3 = AveragePooling3D((2, 2, 2),
strides=(2, 2, 2),
padding='same')
self.cbm2 = CBM(filters=128, kernel=(2, 2, 2), padding='valid')
self.globalpooling3d = GlobalAveragePooling3D()
self.dense_2 = Dense(512,
activation='relu',
kernel_regularizer=l2(self.weight_decay))
self.dropout_2 = Dropout(0.5)
self.output_tensor = Dense(2,
activation='softmax',
kernel_regularizer=l2(self.weight_decay))
def __init__(self, conf):
super(MNISTDigitClassifier, self).__init__()
# Design layers.
input_shape = (28, 28, 1)
self.nobody_convnet2d = NobodyConvNet2D(conf, input_shape)
self.xception = Xception(include_top=False, weights=None)
self.flatten = Flatten()
self.dense = Dense(10)
def create_transfer_model(input_size, n_categories, weights = 'imagenet'):
# note that the "top" is not included in the weights below
base_model = Xception(weights=weights,
include_top=False,
input_shape=input_size)
model = base_model.output
model = GlobalAveragePooling2D()(model)
predictions = Dense(n_categories, activation='softmax')(model)
model = Model(inputs=base_model.input, outputs=predictions)
return model
def create_xception_layer(x,
weights='imagenet',
include_top=False,
classes=100,
activation='softmax'):
model = Xception(input_tensor=x,
include_top=include_top,
classes=classes,
classifier_activation=activation,
weights=weights)
return model.output
def build_xception_encoder(image_shape=(320, 320, 3), embedding_length=16):
encoder_input = Input(image_shape)
# we are using xception as our base encoder
# Xception output shape ?, 10, 10, 2048
pre_trained = Xception(include_top=False,
weights="imagenet",
input_tensor=encoder_input,
input_shape=image_shape)
pre_trained.trainable = False
# after xception we are adding conv layers
# we are using 1x1 convolutions to reduce volume to flat vector
# using 1x1 convolutions because it is easier to ensure output shape with varying input
first = add_inception_module(pre_trained.output,
channel_multiplier=32,
layer_name_prefix="encoder_1",
activation="tanh")
second = Conv2D(256, (3, 3), activation="selu", name="encoder_2")(first)
third = add_inception_module(second,
channel_multiplier=16,
layer_name_prefix="encoder_3",
activation="tanh")
forth = Conv2D(128, (3, 3), activation="selu", name="encoder_4")(third)
fifth = add_inception_module(forth,
channel_multiplier=8,
layer_name_prefix="encoder_5",
activation="tanh")
sixth = Conv2D(64, (2, 2), activation="selu", name="encoder_6")(fifth)
seventh = Conv2D(embedding_length, (3, 3),
activation="selu",
name="encoder_7")(sixth)
# output layer
embedding = Flatten()(seventh)
# wrap the whole thing in a keras.Model instance
encoder_model = Model(inputs=[encoder_input], outputs=[embedding])
return encoder_model
def get_model(weight_dir, out_dir, fullyconnected=False, finetune=False):
"""
Creates custom model on top of Xception for user engagement
recognition.
Returns:
model for the training.
"""
weights = Path(weight_dir)
if finetune:
if fullyconnected:
base_model = load_model(str(out_dir) + "/Xception_on_DAiSEE_fc.h5")
else:
base_model = load_model(str(out_dir) + "/Xception_on_DAiSEE.h5")
base_model.trainable = True
for layer in base_model.layers[:finetune_at]:
layer.trainable = False
return base_model
else:
xception = "xception_weights_tf_dim_ordering_tf_kernels_notop.h5"
weights = weights / xception
base_model = Xception(weights=str(weights),
include_top=False,
input_shape=(img_width, img_height, 3))
base_model.trainable = False
x = GlobalAveragePooling2D()(base_model.output)
if fullyconnected:
x = Dense(128, activation="relu", name="fc1")(x)
x = Dense(64, activation="relu", name="fc2")(x)
boredom = Dense(4, name="y1")(x)
engagement = Dense(4, name="y2")(x)
confusion = Dense(4, name="y3")(x)
frustration = Dense(4, name="y4")(x)
model = Model(inputs=base_model.input,
outputs=[boredom, engagement, confusion, frustration])
return model
def transfer_model(input_size, weights = 'imagenet'):
# note that the "top" is not included in the weights below
base_model = Xception(weights=weights,
include_top=False,
input_shape=input_size)
model = base_model.output
# add new head
model = GlobalAveragePooling2D()(model)
predictions = Dense(1, activation='sigmoid', name='visualized_layer')(model)
model = Model(inputs=base_model.input, outputs=predictions)
return model
def xception_build_model():
w_init = glorot_normal()
b_init = Zeros()
xception = Xception(input_shape=(512, 512, 3),
include_top=False,
weights="imagenet",
pooling="avg")
for layer in xception.layers:
layer.trainable = False
model = Sequential()
model.add(xception)
model.add(Flatten())
model.add(Dropout(0.2))
model.add(
Dense(512,
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 build_xception_model(self):
conv_base = Xception(
weights='imagenet',
include_top=False,
input_shape=self.INPUT_SHAPE)
disable_training_layers(conv_base)
flattened = layers.Flatten()(conv_base.output)
x = layers.Dense(128, activation='relu')(flattened)
x = layers.Dropout(rate=0.5)(x)
x = layers.Dense(64, activation='relu')(x)
answer = layers.Dense(1, activation='sigmoid')(x)
model = models.Model(conv_base.input, answer)
return model
