def efn():
inputs = Inputs(shape=(*IMAGE_SIZE, 3))
model = EfficientNetB0(include_top=False,
input_tensor=inputs,
weights='imagenet')
model.trainable = False
for layer in model.layers[-12:]:
if not isinstance(layer, BatchNormalization):
layer.trainable = True
x = GlobalAveragePooling2D(name='avg_pool')(model.output)
x = BatchNormalization()(x)
top_dropout_rate = 0.2
x = Dropout(top_dropout_rate, name='top_dropout')(x)
outputs = Dense(5, activation='softmax', name='prediction')(x)
# Compile
model = tf.keras.Model(inputs, outputs, name='EfficientNet')
optimizer = Adam(learning_rate=1.5e-3)
model_metrics = [tf.keras.metrics.SparseCategoricalAccuracy(name='spa')]
model_loss = tf.keras.losses.SparseCategoricalCrossentropy(name='scc')
model.compile(optimizer=optimizer, loss=model_loss, metrics=model_metrics)
return model
def build_efficent_nets(n_classes,
type_eff='b0',
regularizer=None,
target_size=(224, 224)):
# Clear memory for new model
K.clear_session()
img_input = Input(shape=(target_size[0], target_size[1], 3))
label = Input(shape=(n_classes, ))
if type_eff == 'b0':
base_model = EfficientNetB0(weights='imagenet',
include_top=False,
input_tensor=img_input)
elif type_eff == 'b3':
base_model = EfficientNetB3(weights='imagenet',
include_top=False,
input_tensor=img_input)
elif type_eff == 'b6':
base_model = EfficientNetB6(weights='imagenet',
include_top=False,
input_tensor=img_input)
# Custom top
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dropout(0.5)(x)
output = ArcFace(n_classes=11, regularizer=regularizer)([x, label])
return Model([img_input, label], output)
def get_efficeintNet_model(): output_classes=2 base_model = EfficientNetB0(weights='imagenet', include_top=False, input_shape=(1024,1024, 3)) x = base_model.output x = BatchNormalization()(x) x=Flatten()(x) predictions = Dense(2, activation='softmax')(x) model = Model(inputs=base_model.input, outputs=predictions) return model
def _EffnetB0():
model = EfficientNetB0(input_shape=(224, 224, 3),
include_top=False,
weights='imagenet')
input = Input((224, 224, 3))
x = model(input)
x = GlobalAveragePooling2D()(x)
x = LeakyReLU(0.1)(x)
x = Dense(1, activation='sigmoid')(x)
model = Model(inputs=input, outputs=x)
model.summary()
plot_model(model, to_file='effnet.png', show_shapes=True)
return model
def efficientnet_B0(input, num_class = None):
#input_layer = Input(shape = (None, None, input_channel_num))
dense = EfficientNetB0(include_top = False, weights = None, input_tensor = input, pooling = 'max')
x = dense.get_layer('swish_16').output
x = Permute((2, 1, 3), name='permute')(x) #(b, None, 8, 240)
x = TimeDistributed(Flatten(), name='flatten')(x)
# add blstm layers
rnnunit = 256
x = Bidirectional(LSTM(rnnunit, return_sequences=True, implementation=2), name='blstm1')(x)
#x = Dense(rnnunit, name='blstm1_out', activation='linear')(x)
x = Bidirectional(LSTM(rnnunit, return_sequences=True, implementation=2), name='blstm2')(x)
# softmax output layer
y_pred = Dense(num_class, name='out', activation='softmax')(x)
return y_pred
def efficient_yolo_body(inputs, num_anchors, num_classes):
# efficientnet
efficientnet_modle = EfficientNetB0(input_tensor=inputs,
weights='imagenet',
include_top=False)
# input: 416 x 416 x 3
# conv_pw_13_relu :13 x 13 x 1280
# conv_pw_11_relu :26 x 26 x 672
# conv_pw_5_relu : 52 x 52 x 240
f1 = efficientnet_modle.get_layer('swish_49').output
x, y1 = make_last_layers(f1, 640, num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(320, (1, 1)), UpSampling2D(2))(x)
f2 = efficientnet_modle.get_layer('swish_34').output
x = Concatenate()([x, f2])
x, y2 = make_last_layers(x, 336, num_anchors * (num_classes + 5))
x = compose(DarknetConv2D_BN_Leaky(168, (1, 1)), UpSampling2D(2))(x)
f3 = efficientnet_modle.get_layer('swish_16').output
x = Concatenate()([x, f3])
x, y3 = make_last_layers(x, 120, num_anchors * (num_classes + 5))
return Model(inputs=inputs, outputs=[y1, y2, y3])
from keras.preprocessing import image
from keras.applications import imagenet_utils
from keras.preprocessing.image import ImageDataGenerator
from sklearn.metrics import confusion_matrix
import itertools
import matplotlib.pyplot as plt
from keras_efficientnets import EfficientNetB0
train_path='C:/Users/legend698/Desktop/train'
test_path='C:/Users/legend698/Desktop/ANIMESH/python/Cats-and-Dogs/test'
valid_path='C:/Users/legend698/Desktop/valid'
train_batches=ImageDataGenerator().flow_from_directory(train_path,target_size=(224,224),classes=['dog','cat'],batch_size=10)
test_batches =ImageDataGenerator().flow_from_directory(test_path,target_size=(224,224),classes=['dog','cat'],batch_size=10)
valid_batches=ImageDataGenerator().flow_from_directory(valid_path,target_size=(224,224),classes=['dog','cat'],batch_size=10)
eff_model=EfficientNetB0()
eff_model.summary()
x=eff_model.layers[-3].output
prediction=Dense(2,activation='softmax')(x)
model=Model(inputs=eff_model.input,outputs=prediction)
model.summary()
# model.add(Dense(2,activation='softmax'))
#model=EfficientNetB0((224,224,3),classes=['cat','dog'])
model.compile(Adam(lr=0.0001),loss='categorical_crossentropy',metrics=['accuracy'])
model.fit_generator(train_batches,steps_per_epoch=2500,validation_data=valid_batches,validation_steps=40,epochs=10,verbose=2)
model.save('effnet.h5')
def cnn_model(model_name, img_size):
"""
Model definition using Xception net architecture
"""
input_size = (img_size, img_size, 3)
if model_name == "xception":
print("Loading Xception wts...")
baseModel = Xception(weights="imagenet",
include_top=False,
input_shape=(img_size, img_size, 3))
elif model_name == "iv3":
baseModel = InceptionV3(weights="imagenet",
include_top=False,
input_shape=(img_size, img_size, 3))
elif model_name == "irv2":
baseModel = InceptionResNetV2(weights="imagenet",
include_top=False,
input_shape=(img_size, img_size, 3))
elif model_name == "resnet":
baseModel = ResNet50(weights="imagenet",
include_top=False,
input_shape=(img_size, img_size, 3))
elif model_name == "nasnet":
baseModel = NASNetLarge(weights="imagenet",
include_top=False,
input_shape=(img_size, img_size, 3))
elif model_name == "ef0":
baseModel = EfficientNetB0(input_size,
weights="imagenet",
include_top=False)
elif model_name == "ef5":
baseModel = EfficientNetB5(input_size,
weights="imagenet",
include_top=False)
headModel = baseModel.output
headModel = GlobalAveragePooling2D()(headModel)
headModel = Dense(512, activation="relu",
kernel_initializer="he_uniform")(headModel)
headModel = Dropout(0.4)(headModel)
# headModel = Dense(512, activation="relu", kernel_initializer="he_uniform")(
# headModel
# )
# headModel = Dropout(0.5)(headModel)
predictions = Dense(5,
activation="softmax",
kernel_initializer="he_uniform")(headModel)
model = Model(inputs=baseModel.input, outputs=predictions)
for layer in baseModel.layers:
layer.trainable = False
optimizer = Nadam(lr=0.002,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
schedule_decay=0.004)
model.compile(loss="categorical_crossentropy",
optimizer=optimizer,
metrics=["accuracy"])
return model
def efficientnet_retinanet(num_classes,
backbone='efficientnet-b0',
inputs=None,
modifier=None,
**kwargs):
""" Constructs a retinanet model using a vgg backbone.
Args
num_classes: Number of classes to predict.
backbone: Which backbone to use (one of ('vgg16', 'vgg19')).
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 VGG backbone.
"""
# choose default input
if inputs is None:
inputs = keras.layers.Input(shape=(None, None, 3))
# create the vgg backbone
if backbone == 'efficientnet-b0':
efficientnet = EfficientNetB0(input_tensor=inputs,
include_top=False,
weights='imagenet')
layer_names = ["swish_16", "swish_34", "swish_49"]
elif backbone == 'efficientnet-b1':
efficientnet = EfficientNetB1(input_tensor=inputs,
include_top=False,
weights='imagenet')
layer_names = ["swish_24", "swish_48", "swish_69"]
elif backbone == 'efficientnet-b2':
efficientnet = EfficientNetB2(input_tensor=inputs,
include_top=False,
weights='imagenet')
layer_names = ["swish_24", "swish_48", "swish_69"]
elif backbone == 'efficientnet-b3':
efficientnet = EfficientNetB3(input_tensor=inputs,
include_top=False,
weights='imagenet')
layer_names = ["swish_24", "swish_54", "swish_78"]
elif backbone == 'efficientnet-b4':
efficientnet = EfficientNetB4(input_tensor=inputs,
include_top=False,
weights='imagenet')
layer_names = ["swish_30", "swish_66", "swish_96"]
elif backbone == 'efficientnet-b':
efficientnet = EfficientNetB4(input_tensor=inputs,
include_top=False,
weights='imagenet')
layer_names = ["swish_30", "swish_66", "swish_96"]
else:
raise ValueError("Backbone '{}' not recognized.".format(backbone))
if modifier:
efficientnet = modifier(efficientnet)
efficientnet.summary()
# create the full model
layer_outputs = [
efficientnet.get_layer(name).output for name in layer_names
]
return retinanet.retinanet(inputs=inputs,
num_classes=num_classes,
backbone_layers=layer_outputs,
**kwargs)
def build(size, seq_len , learning_rate ,
optimizer_class ,\
initial_weights ,\
cnn_class ,\
pre_weights , \
lstm_conf , \
cnn_train_type, classes = 1, dropout = 0.0):
input_layer = Input(shape=(seq_len, size, size, 3))
if(cnn_train_type!='train'):
if cnn_class.__name__ == "ResNet50":
cnn = cnn_class(weights=pre_weights, include_top=False,input_shape =(size, size, 3))
elif cnn_class.__name__=="MobileNetV3_Large":
cnn=cnn_class(shape =(size, size, 3),n_class=2,include_top=False).build()
elif cnn_class.__name__=='MobileNetV3_Small':
cnn=cnn_class(shape =(size, size, 3),n_class=2,include_top=False).build()
elif cnn_class.__name__=='efn.EfficientNetB0':
cnn = EfficientNetB0(input_shape=(size,size,3), classes=2, include_top=False, weights='imagenet')
elif cnn_class.__name__=='efn.EfficientNetB1':
cnn = EfficientNetB1(input_shape=(size,size,3), classes=2, include_top=False, weights='imagenet')
elif cnn_class.__name__=="ShuffleNetV2":
cnn=ShuffleNetV2(include_top=False,input_shape=(224, 224, 3),bottleneck_ratio=1)
else:
cnn = cnn_class(weights=pre_weights,include_top=False)
else:
cnn = cnn_class(include_top=False)
#control Train_able of CNNN
if(cnn_train_type=='static'):
for layer in cnn.layers:
layer.trainable = False
if(cnn_train_type=='retrain'):
for layer in cnn.layers:
layer.trainable = True
cnn = TimeDistributed(cnn)(input_layer)
print(cnn)
#the resnet output shape is 1,1,20148 and need to be reshape for the ConvLSTM filters
# if cnn_class.__name__ == "ResNet50":
# cnn = Reshape((seq_len,4, 4, 128), input_shape=(seq_len,1, 1, 2048))(cnn)
# print(lstm_conf)
# print(lstm_conf[0])
# print(lstm_conf[1])
lstm = lstm_conf[0](**lstm_conf[1])(cnn)
lstm = MaxPooling2D(pool_size=(2, 2))(lstm)
attention_mul = attention_3d_block(lstm)
# print(lstm)
# lstm = MaxPooling2D(pool_size=(2, 2))(lstm)
flat = Flatten()(attention_mul)
flat = BatchNormalization()(flat)
# flag=LayerNormalization()(flat)
flat = Dropout(dropout)(flat)
linear = Dense(512)(flat)
relu = Activation('relu')(linear)
linear = Dense(256)(relu)
linear = Dropout(dropout)(linear)
relu = Activation('relu')(linear)
linear = Dense(10)(relu)
linear = Dropout(dropout)(linear)
relu = Activation('relu')(linear)
activation = 'sigmoid'
loss_func = 'binary_crossentropy'
if classes > 1:
activation = 'softmax'
loss_func = 'categorical_crossentropy'
predictions = Dense(classes, activation=activation)(relu)
model = Model(inputs=input_layer, outputs=predictions)
optimizer = optimizer_class[0](lr=learning_rate, **optimizer_class[1])
model.compile(optimizer=optimizer, loss=loss_func,metrics=['acc'])
print(model.summary())
plot_model(model,show_shapes=True,to_file="model.png")
return model
def build_efficientNetSTN(self):
inp = Input(shape=(self.config.model.img_width,
self.config.model.img_height, 3),
name='main_input')
detedction_window_w = int(0.5 * self.config.model.img_width)
detedction_window_h = int(0.5 * self.config.model.img_height)
base_model1 = EfficientNetB0(
(detedction_window_w, detedction_window_h, 3),
include_top=False,
weights='imagenet')
base_model2 = EfficientNetB0(
(detedction_window_w, detedction_window_h, 3),
include_top=False,
weights='imagenet')
base_model_loc = EfficientNetB0(
(detedction_window_w, detedction_window_h, 3),
include_top=False,
weights='imagenet')
inp_downsize = AvgPool2D(pool_size=(2, 2))(inp)
locnet = base_model_loc(inp_downsize)
locnet = Conv2D(128, (1, 1),
activation='relu',
name='loc2',
kernel_regularizer=self.regularizer)(locnet)
locnet = Flatten()(locnet)
locnet = Dense(128,
activation='relu',
name='loc3',
kernel_regularizer=self.regularizer)(locnet)
weights = get_initial_weights_translation_only(128)
locnet = Dense(4,
weights=weights,
name='loc4',
kernel_regularizer=self.regularizer)(locnet)
# locnet = MaxPool2D(pool_size=(2, 2))(inp)
# locnet = Conv2D(100, (5, 5),activation='relu', name='loc1')(locnet) # 20
# locnet = MaxPool2D(pool_size=(4, 4))(locnet) # 2, 2
# locnet = Conv2D(200, (5, 5), activation='relu',name='loc2')(locnet) # 20
# # locnet = MaxPool2D(pool_size=(2, 2))(locnet)
# locnet = Flatten()(locnet)
# locnet = Dense(20, name='loc3')(locnet) # 50
# locnet = Activation('relu')(locnet)
# weights = get_initial_weights_translation_only(20) # 50
# locnet = Dense(4, weights=weights, name='loc4')(locnet)
self.STN_id = 1
transform1 = Lambda(self.convert_to_transform_matrix)([locnet, inp])
self.STN_id = 2
transform2 = Lambda(self.convert_to_transform_matrix)([locnet, inp])
stn1 = BilinearInterpolation(
(detedction_window_w, detedction_window_h),
name='stn1')([inp, transform1])
stn2 = BilinearInterpolation(
(detedction_window_w, detedction_window_h),
name='stn2')([inp, transform2])
x1 = base_model1(stn1)
x2 = base_model2(stn2)
embeddings1 = GlobalAveragePooling2D(name='embeddings1')(x1)
embeddings2 = GlobalAveragePooling2D(name='embeddings2')(x2)
embeddings = concatenate([embeddings1, embeddings2],
axis=1,
name='embeddings')
x = Dense(int(self.config.data_loader.num_of_classes), )(embeddings)
out = Activation("softmax", name='out')(x)
# if self.config.model.num_of_fc_at_net_end == 2:
# x = GlobalAveragePooling2D(name='gpa_f')(x)
# x = Dropout(0.5)(x)
# embeddings = Dense(int(self.config.model.embedding_dim), name='embeddings')(x)
# x = Dense(int(self.config.data_loader.num_of_classes), )(embeddings)
# out = Activation("softmax", name='out')(x)
# else:
# embeddings = GlobalAveragePooling2D(name='embeddings')(x)
# x = Dense(int(self.config.data_loader.num_of_classes), )(embeddings)
# out = Activation("softmax", name='out')(x)
self.model = Model(
inputs=inp,
outputs=[embeddings, out, transform1, transform2, stn1, stn2])
# -*- coding: utf-8 -*-
"""
@author: 代码医生工作室
@公众号：xiangyuejiqiren （内有更多优秀文章及学习资料）
@来源: <TensorFlow项目实战2.x>配套代码
@配套代码技术支持：bbs.aianaconda.com
"""
import numpy as np
from keras.preprocessing import image
from keras.applications.imagenet_utils import decode_predictions, preprocess_input
from keras_efficientnets import EfficientNetB0
# from keras_efficientnets import EfficientNetB4
#6.7.10节 动态图
#tf.enable_eager_execution() #启动动态图
#model = EfficientNetB4(weights='efficientnet-b4.h5')
model = EfficientNetB0(weights='efficientnet-b0.h5')
img_path = 'dog.jpg'
img = image.load_img(img_path, target_size=(224, 224))
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
preds = model.predict(x)
print('Predicted:', decode_predictions(preds, top=3)[0])
#6.7.10节 动态图
#preds = model(x)
#print('Predicted:', decode_predictions(preds.numpy(), top=3)[0])
def model_confirm(self, choosed_model):
if choosed_model == 'VGG16':
model = MODEL(self.config).VGG16()
elif choosed_model == 'VGG19':
model = MODEL(self.config).VGG19()
elif choosed_model == 'AlexNet':
model = MODEL(self.config).AlexNet()
elif choosed_model == 'LeNet':
model = MODEL(self.config).LeNet()
elif choosed_model == 'ZF_Net':
model = MODEL(self.config).ZF_Net()
elif choosed_model == 'ResNet18':
model = ResnetBuilder().build_resnet18(self.config)
elif choosed_model == 'ResNet34':
model = ResnetBuilder().build_resnet34(self.config)
elif choosed_model == 'ResNet101':
model = ResnetBuilder().build_resnet101(self.config)
elif choosed_model == 'ResNet152':
model = ResnetBuilder().build_resnet152(self.config)
elif choosed_model == 'mnist_net':
model = MODEL(self.config).mnist_net()
elif choosed_model == 'TSL16':
model = MODEL(self.config).TSL16()
elif choosed_model == 'ResNet50':
model = keras.applications.ResNet50(include_top=True,
weights=None,
input_tensor=None,
input_shape=(self.normal_size,
self.normal_size,
self.channles),
pooling='max',
classes=self.classNumber)
elif choosed_model == 'InceptionV3':
model = keras.applications.InceptionV3(
include_top=True,
weights=None,
input_tensor=None,
input_shape=(self.normal_size, self.normal_size,
self.channles),
pooling='max',
classes=self.classNumber)
elif choosed_model == 'Xception':
model = keras.applications.Xception(include_top=True,
weights=None,
input_tensor=None,
input_shape=(self.normal_size,
self.normal_size,
self.channles),
pooling='max',
classes=self.classNumber)
elif choosed_model == 'MobileNet':
model = keras.applications.MobileNet(include_top=True,
weights=None,
input_tensor=None,
input_shape=(self.normal_size,
self.normal_size,
self.channles),
pooling='max',
classes=self.classNumber)
elif choosed_model == 'InceptionResNetV2':
model = keras.applications.InceptionResNetV2(
include_top=True,
weights=None,
input_tensor=None,
input_shape=(self.normal_size, self.normal_size,
self.channles),
pooling='max',
classes=self.classNumber)
elif choosed_model == 'SEResNetXt':
model = SEResNetXt(self.config).model
elif choosed_model == 'DenseNet':
depth = 40
nb_dense_block = 3
growth_rate = 12
nb_filter = 12
bottleneck = False
reduction = 0.0
dropout_rate = 0.0
img_dim = (self.channles, self.normal_size
) if K.image_data_format == 'channels_last' else (
self.normal_size, self.normal_size, self.channles)
model = densenet.DenseNet(img_dim,
classNumber=self.classNumber,
depth=depth,
nb_dense_block=nb_dense_block,
growth_rate=growth_rate,
nb_filter=nb_filter,
dropout_rate=dropout_rate,
bottleneck=bottleneck,
reduction=reduction,
weights=None)
elif choosed_model == 'SENet':
model = sm.Unet('senet154',
input_shape=(self.normal_size, self.normal_size,
self.channles),
classes=4,
activation='softmax',
encoder_weights=None)
#model.summary()
elif choosed_model == 'EfficientNetB5':
model = EfficientNetB5(input_shape=(self.normal_size,
self.normal_size,
self.channles),
classes=4,
weights=None)
elif choosed_model == 'EfficientNetB4':
model = EfficientNetB4(input_shape=(self.normal_size,
self.normal_size,
self.channles),
classes=4,
weights=None)
elif choosed_model == 'EfficientNetB3':
model = EfficientNetB3(input_shape=(self.normal_size,
self.normal_size,
self.channles),
classes=4,
weights=None)
elif choosed_model == 'EfficientNetB2':
model = EfficientNetB2(input_shape=(self.normal_size,
self.normal_size,
self.channles),
classes=4,
weights=None)
elif choosed_model == 'EfficientNetB1':
model = EfficientNetB1(input_shape=(self.normal_size,
self.normal_size,
self.channles),
classes=4,
weights=None)
elif choosed_model == 'EfficientNetB0':
model = EfficientNetB0(input_shape=(self.normal_size,
self.normal_size,
self.channles),
classes=4,
weights=None)
elif choosed_model == 'MobileNetV3_Large':
model = MobileNetV3_Large(shape=(self.normal_size,
self.normal_size, self.channles),
n_class=4).build()
elif choosed_model == 'MobileNetV3_Small':
model = MobileNetV3_Small(shape=(self.normal_size,
self.normal_size, self.channles),
n_class=4).build()
elif choosed_model == 'NASNetLarge':
model = NASNetLarge(input_shape=(self.normal_size,
self.normal_size, self.channles),
weights=None,
use_auxiliary_branch=False,
classes=4)
elif choosed_model == 'NASNetMobile':
model = NASNetMobile(input_shape=(self.normal_size,
self.normal_size, self.channles),
weights=None,
use_auxiliary_branch=False,
classes=4)
elif choosed_model == 'NASNetMiddle':
model = NASNetMiddle(input_shape=(self.normal_size,
self.normal_size, self.channles),
weights=None,
use_auxiliary_branch=False,
classes=4)
elif choosed_model == 'ShuffleNet':
model = ShuffleNet(input_shape=(self.normal_size, self.normal_size,
self.channles),
classes=4)
elif choosed_model == 'ShuffleNetV2':
model = ShuffleNetV2(input_shape=(self.normal_size,
self.normal_size, self.channles),
classes=4)
return model
img_path = x[0]
user = x[1]
img = cv2.imread(img_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img = cv2.resize(img, (96, 96))
img = img / 255.
img = np.reshape(img, [1, 96, 96, 3])
vgg_model = load_model("ml_models/vgg16_2_model.hdf5")
vgg_prob = vgg_model.predict(img)
################################################################################################################################
effb0_model = EfficientNetB0(include_top=False,
weights='ml_models/efficientnet-b0_notop.h5',
pooling='avg',
input_shape=(96, 96, 3))
x = effb0_model.output
x = Dense(32)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Dropout(0.25)(x)
x = Dense(16)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Dropout(0.25)(x)
x = Dense(8)(x)
x = BatchNormalization()(x)
from keras.models import Sequential
from keras.layers import Dense, Activation, Dropout, Flatten, Conv2D, MaxPooling2D, BatchNormalization
from keras import backend as K
from PIL import Image
img_width, img_height = 224, 224
"""
if K.image_data_format() == 'channels_first':
input_shape = (1, img_width, img_height)
else:
input_shape = (img_width, img_height, 1)
"""
from keras_efficientnets import EfficientNetB0
model = EfficientNetB0(include_top=False,
weights='imagenet',
pooling='avg',
input_shape=(224, 224, 3))
for layer in model.layers[0:-1]:
layer.trainable = True
x = model.output
x = Dense(64)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
x = Dropout(0.3)(x)
x = Dense(32)(x)
x = BatchNormalization()(x)
x = Activation('relu')(x)
preprocessing_function=preprocess_input,
# Below are the parameters used for crop
# zoom_range=[0.8, 1.2],
# width_shift_range=[-50,50]
# Below are the parameters used for no crop
zoom_range=[0.7, 1.3],
# width shift means up and down
width_shift_range=0.2,
height_shift_range=0.2)
train_generator = train_datagen.flow_from_directory(TRAIN_DIR,
target_size=(HEIGHT,
WIDTH),
batch_size=BATCH_SIZE)
base_model = EfficientNetB0(input_shape=(HEIGHT, WIDTH, 3),
include_top=False,
weights='imagenet')
# base_model = ResNet50(weights='imagenet',
# include_top=False,
# input_shape=(HEIGHT, WIDTH, 3))
base_output = base_model.layers[-1].output
# base_output = base_model.layers[5].output
# base_output = Flatten()(base_output)
base_model = Model(base_model.input, output=base_output)
# for layer in base_model.layers:
# layer.trainable = False
# base_model.trainable = True
# set_trainable = False
# for layer in base_model.layers:
train_labels = objCount.tolist() #train_labels #print(len(train_labels)) # 116 from keras.utils import to_categorical train_labels = to_categorical(train_labels) train_labels #!pip install -U efficientnet !pip install keras_efficientnets import keras from keras_efficientnets import EfficientNetB0 new_input = keras.Input(shape=(400, 320, 3)) base_model = EfficientNetB0(weights="imagenet", include_top=False, input_tensor=new_input) print(base_model.summary()) from keras.models import Sequential from keras.layers import Dense, Dropout, Flatten from keras.layers import Conv2D, MaxPooling2D from keras.utils import to_categorical model = Sequential() model.add(base_model) base_model.trainable = False #model.add(Dense(units = 120, activation='relu')) #model.add(Dense(units = 120, activation = 'relu')) model.add(Dense(units = 1, activation='relu')) model.compile(loss='binary_crossentropy',optimizer='Adam',metrics=['accuracy']) #model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))
def train(epoch, FRAME_NUM, _num, batch_size, _random=False):
FRAME_NUM = FRAME_NUM
HEIGHT = 224
WIDTH = 224
CHANNEL = 3
base = EfficientNetB0(input_shape=(224, 224, 3),
include_top=False,
weights='imagenet')
base_ = Model(base.inputs, base.outputs)
# base = load_model('../models/nt/efficientb0-weights-improvement-027-0.9912.hdf5')
# base_ = Model(base.get_layer('model_1').inputs, base.get_layer('model_1').outputs)
seq_input = Input((FRAME_NUM, HEIGHT, WIDTH, CHANNEL))
x = TimeDistributed(base_)(seq_input)
# x = DepthwiseConv3D(kernel_size=(3,3,3),strides = (1,1,1),depth_multiplier=1)(x)
# x = LeakyReLU(0.1)(x)
# x = DepthwiseConv3D(kernel_size=(4,3,3),strides = (1,1,1),depth_multiplier=1)(x)
# x = LeakyReLU(0.1)(x)
# x = DepthwiseConv3D(kernel_size=(3,3,3), depth_multiplier=1)(x)
# x = LeakyReLU(0.1)(x)
# x = GlobalAveragePooling3D()(x)
# x = LeakyReLU(0.1)(x)
# base method
x = Lambda(feature_reset)(x)
x = TimeDistributed(BatchNormalization())(x)
x = TimeDistributed(Conv2D(filters=128, kernel_size=(3, 3)))(x)
x = TimeDistributed(BatchNormalization())(x)
x = LeakyReLU(0.1)(x)
x = TimeDistributed(Conv2D(filters=64, kernel_size=(3, 3)))(x)
x = LeakyReLU(0.1)(x)
x = TimeDistributed(Conv2D(filters=1, kernel_size=(3, 3)))(x)
x = LeakyReLU(0.1)(x)
##
# x = Flatten()(x)
x = Dense(1, activation='sigmoid')(x)
model_ = Model(inputs=seq_input, outputs=x, name='FJWnet')
multi_model = multi_gpu_model(model_, gpus=4)
model_.summary()
multi_model.compile(loss='binary_crossentropy',
metrics=['accuracy'],
optimizer=SGD(0.01, momentum=0.9,
decay=0.0095 / epoch))
train_gen = make_videoclips_4dfdc(model='train',
batch_size=batch_size,
FRAME_NUM=FRAME_NUM,
_random=_random)
test_gen = make_videoclips_4dfdc(model='test',
batch_size=batch_size,
FRAME_NUM=FRAME_NUM,
_random=_random)
if _random == False:
filepath = r"../models/NewIdea/dfdc_f=" + _num + r"/efficientb0-weights-improvement-{epoch:03d}-{val_acc:.4f}.hdf5"
else:
filepath = r"../models/NewIdea/dfdc_f=" + _num + r"/random_efficientb0-weights-improvement-{epoch:03d}-{val_acc:.4f}.hdf5"
checkpoint = ModelCheckpoint(filepath,
monitor='val_acc',
verbose=1,
save_best_only=True,
save_weights_only=False,
mode='auto')
Checkpoint = ParallelModelCheckpoint(model_,
filepath,
monitor='val_acc',
verbose=1,
save_best_only=True,
save_weights_only=False,
mode='auto')
history = multi_model.fit_generator(train_gen,
class_weight={
0: 1.,
1: 1.
},
steps_per_epoch=100,
validation_steps=200,
validation_data=test_gen,
epochs=epoch,
verbose=1,
callbacks=[Checkpoint])
if _random == False:
WriteIN(
history, r'../records/dfdc_efficientb0-new_' + _num +
r'_frames_224_0-40.txt')
else:
WriteIN(
history, r'../records/dfdc_efficientb0-shuffled_new_' + _num +
r'_frames_224_0-40.txt')
