def __init__(self,
model_id='mobilenet_v1',
input_shape=(256, 256, 3),
output_stride=16):
assert model_id == 'mobilenet_v1'
super(MobileNetV1, self).__init__()
self.output_stride = output_stride
self.features = EfficientNetB2(
input_shape=input_shape,
include_top=False,
weights='imagenet',
classifier_activation=None,
)
# self.features.trainable = False
self.Dblock1 = DetectionBlock(144)
self.concat1 = tf.keras.layers.Concatenate()
self.Dblock2 = DetectionBlock(144)
self.concat2 = tf.keras.layers.Concatenate()
self.Dblock3 = DetectionBlock(144)
self.conv1 = Conv2D(17, 1, 1, padding='same')
self.bn1 = BatchNormalization()
self.dconv1 = Conv2DTranspose(17, 4, 2, padding='same')
self.dconv2 = Conv2DTranspose(17, 4, 2, padding='same')
self.dconv3 = Conv2DTranspose(17, 4, 2, padding='same')
def make_model(ensemble_size=3):
input_layer = layers.Input(shape=(256, 256, 3))
ensemble = []
for i in range(ensemble_size):
ensemble.append(
EfficientNetB2(weights='imagenet',
include_top=False,
drop_connect_rate=0.4,
pooling='avg',
input_tensor=input_layer))
for layer in ensemble[i].layers:
layer._name = str(layer._name) + '_' + str(i)
freeze_model(ensemble[i], 4)
ensemble_outputs = [ensemble[i].output for i in range(ensemble_size)]
x = layers.Concatenate()(ensemble_outputs)
x = layers.GaussianNoise(1.0)(x)
x = layers.Dense(2, activation='softmax', kernel_regularizer='l1_l2')(x)
model = Model(input_layer, x)
#model.summary()
model.compile(optimizer=optimizers.Adam(1e-4),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
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(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 build_network(image_size, n_classes):
image = layers.Input([*image_size, 3], dtype=tf.float32, name='input')
effnet = EfficientNetB2(include_top=False,
weights='imagenet',
pooling='avg')
feature = effnet(image)
feature = layers.Dropout(0.5)(feature)
logit = layers.Dense(n_classes)(feature)
model = tf.keras.Model(inputs=image, outputs=logit)
return model
def make_conv_base(self, weights):
cb = EfficientNetB2(weights='imagenet',
include_top=False,
drop_connect_rate=0.4,
pooling='avg',
input_shape=(self.tile_size, self.tile_size, 3))
x = cb.output
x = layers.Dropout(0.3)(x)
x = layers.Dense(2, activation='softmax', kernel_regularizer='l1_l2')(x)
model = Model(cb.input, x)
model.compile(optimizer=optimizers.Adam(), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
model.load_weights(weights)
self.conv_base = Model(model.input, model.layers[-3].output)
def spy_model(name):
"Creates the model."
with tf.compat.v1.Session(graph=tf.Graph()) as session:
if name == "MobileNet":
model = MobileNet()
elif name == "EfficientNetB2":
model = EfficientNetB2()
else:
raise ValueError("Unknown model name %r." % name)
graph_def = tf.compat.v1.graph_util.convert_variables_to_constants(
sess=session,
input_graph_def=session.graph_def,
output_node_names=[model.output.op.name])
return graph_def, model
def make_model(weights=None):
cb = EfficientNetB2(weights='imagenet',
include_top=False,
drop_connect_rate=0.4,
pooling='avg',
input_shape=(256, 256, 3))
x = cb.output
x = layers.GaussianDropout(0.3)(x)
x = layers.Dense(2, activation='softmax', kernel_regularizer='l1_l2')(x)
model = Model(cb.input, x)
#model.summary()
model.compile(optimizer=optimizers.Adam(1e-4),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
if weights:
model.load_weights(weights)
return model
def make_model(num_classes):
reg = regularizers.l1_l2(0.01, 0.01)
cb = EfficientNetB2(weights='imagenet', include_top=False, drop_connect_rate=0.4, pooling='avg', input_shape=(256, 256, 3))
#cb.trainable = False
freeze_model(cb, 3)
x = cb.output
#x = layers.GaussianNoise(0.5)(x)
#x = layers.BatchNormalization()(x)
#x = layers.Dropout(0.3)(x)
#x = layers.Dense(128, activation='relu', kernel_regularizer=reg)(x)
x = layers.Dropout(0.4)(x)
x = layers.Dense(num_classes, activation='softmax', kernel_regularizer=reg)(x)
model = Model(cb.input, x)
#model.summary()
#pr = tf.keras.metrics.AUC(name='PR', curve='PR')
model.compile(optimizer=optimizers.Adam(1e-4), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
return model
def EfficientNetB2model(no_classes, shape):
"""
EfficientNetB2
https://keras.io/examples/vision/image_classification_efficientnet_fine_tuning/
Uses a fixed input size 224,224
"""
base_model = EfficientNetB2(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 getEfficientNetModelB2():
model = EfficientNetB2(include_top=True,
weights=None,
classes=3,
classifier_activation='softmax')
return model
def make_feature_extractor():
conv_base = EfficientNetB2(weights='imagenet',
include_top=False,
input_shape=(image_rez, image_rez, 3))
output = layers.GlobalAveragePooling2D()(conv_base.output)
return Model(conv_base.input, output), output.shape[-1]
test_value = df[df['date'] >= '2020-09-01']
x_pred = test_value.iloc[:,1:-1].astype('int64').to_numpy()
y_pred = test_value.iloc[:,-1].astype('int64').to_numpy()
x_pred = x_pred.reshape(x_pred.shape[0], 7,1,3)
def RMSE(y_test, y_predict):
return np.sqrt(mean_squared_error(y_test, y_predict))
x_train, x_val, y_train, y_val = train_test_split(x_train, y_train, train_size=0.8, random_state = 77, shuffle=True )
x_train = x_train.reshape(x_train.shape[0], 7, 1, 3)
print(x_train.shape, x_val.shape, x_pred.shape)
# 2. 모델구성
leaky_relu = tf.nn.leaky_relu
mobile = EfficientNetB2(include_top=False,weights='imagenet',input_shape=(7,1,3))
# mobile = VGG16(include_top=False,weights='imagenet',input_shape=x_train.shape[1:])
mobile.trainable = True
a = mobile.output
a = GlobalAveragePooling2D()(a)
a = Flatten()(a)
a = Dense(1024, activation= 'swish')(a)
a = Dropout(0.2)(a)
a = Dense(1, activation= 'swish')(a)
model = Model(inputs = mobile.input, outputs = a)
# 3. 컴파일 훈련
modelpath = '../data/h5/regressor_LSTM.hdf5'
# es= EarlyStopping(monitor='val_loss', patience=10)
reduce_lr = ReduceLROnPlateau(monitor='val_loss', patience=5, factor=0.5, verbose=1)
kfold = KFold(n_splits=5, shuffle=True)
train_generator = idg.flow(x_train, y_train, batch_size=32)
# seed => random_state
valid_generator = idg2.flow(x_valid, y_valid)
test_generator = x_pred
mc = ModelCheckpoint('C:/LPD_competition/lotte_m2_projcet.h5',
save_best_only=True,
verbose=1)
from tensorflow.keras.models import Model
from tensorflow.keras.layers import GlobalAveragePooling2D, Flatten, BatchNormalization, Dense, Activation
from tensorflow.keras.applications import VGG19, MobileNet, InceptionResNetV2, InceptionV3, EfficientNetB2
mobile_net = EfficientNetB2(weights="imagenet",
include_top=False,
input_shape=(128, 128, 3))
# for layer in mobile_net.layers:
# layer.trainable = False
top_model = mobile_net.output
top_model = GlobalAveragePooling2D()(top_model)
# top_model = Flatten()(top_model)
top_model = Dense(4048, activation="swish")(top_model)
# top_model = Dense(1024, activation="relu")(top_model)
# top_model = Dense(512, activation="relu")(top_model)
top_model = Dense(1000, activation="softmax")(top_model)
model = Model(inputs=mobile_net.input, outputs=top_model)
# construct the training image generator for data augmentation
aug = ImageDataGenerator(rotation_range=20,
zoom_range=0.15,
width_shift_range=0.2,
height_shift_range=0.2,
shear_range=0.15,
horizontal_flip=True,
fill_mode="nearest")
# load the MobileNetV2 network, ensuring the head FC layer sets are
# leftt off
# baseModel = MobileNetV2(weights="imagenet", include_top=False,
# input_tensor=Input(shape=(224, 224, 3)))
baseModel = EfficientNetB2(weights='imagenet',
include_top=False,
input_tensor=Input(shape=(260, 260, 3)))
# construct the head of the model that will be placed on top of the
# the base model
headModel = baseModel.output
headModel = AveragePooling2D(pool_size=(7, 7))(headModel)
headModel = Flatten(name="flatten")(headModel)
headModel = Dense(128, activation="relu")(headModel)
headModel = Dropout(0.5)(headModel)
headModel = Dense(2, activation="softmax")(headModel)
# place the head FC model on top of the base model (this will become
# the actual model we will train)
model = Model(inputs=baseModel.input, outputs=headModel)
# loop over all layers in the base model and freeze them so they will
y,
train_size=0.8,
shuffle=True,
random_state=SEED)
train_generator = idg.flow(x_train, y_train, batch_size=8)
valid_generator = idg2.flow(x_valid, y_valid)
test_generator = idg3.flow(x_pred, shuffle=False)
from keras.utils.generic_utils import get_custom_objects
from tensorflow.python.keras.activations import swish
from keras.layers import Activation
get_custom_objects().update({'swish': Activation(swish)})
md = EfficientNetB2(input_shape=IMAGE_SIZE,
weights="imagenet",
include_top=False)
for layer in md.layers:
layer.trainable = True
c = md.output
c = GlobalAveragePooling2D()(c)
c = Flatten()(c)
c = Dense(6048, activation='swish')(c)
c = Dropout(0.2)(c)
c = Dense(1000, activation="softmax")(c)
model = Model(inputs=md.input, outputs=c)
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
cp = ModelCheckpoint('C:/LPD_competition/lotte_projcet0323.h5',
#EfficientNetB0 model = EfficientNetB0() model.trainable = True model.summary() print(len(model.weights)) print(len(model.trainable_weights)) #EfficientNetB1 model = EfficientNetB1() model.trainable = True model.summary() print(len(model.weights)) print(len(model.trainable_weights)) ''' #EfficientNetB2 model = EfficientNetB2() model.trainable = True model.summary() print(len(model.weights)) print(len(model.trainable_weights))
import cv2
from PIL import Image
from tensorflow.keras.applications import EfficientNetB2
from tensorflow.keras.applications.efficientnet import preprocess_input
from keras.layers import Conv2D, Dense, Flatten, BatchNormalization,\
Activation, GaussianDropout, GlobalAveragePooling2D, Input, Dropout
from keras.models import Model
from keras.preprocessing.image import ImageDataGenerator
from keras.callbacks import EarlyStopping, ReduceLROnPlateau, ModelCheckpoint
from sklearn.model_selection import train_test_split, KFold
eff = EfficientNetB2(
include_top=False,
input_shape=(256, 256, 3)
)
eff.trainable = True
es = EarlyStopping(
monitor='val_loss',
patience=30,
verbose=1
)
rl = ReduceLROnPlateau(
monitor='val_loss',
patience=10,
verbose=1
)
def create_efficientnet(width, height, depth, model_base,
first_layers_to_freeze, num_classes, learning_rate,
epochs):
inputShape = (height, width, depth)
inputs = K.Input(shape=inputShape)
if model_base == "b0":
effnet = EfficientNetB0(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model_base == "b1":
effnet = EfficientNetB1(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model_base == "b2":
effnet = EfficientNetB2(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model_base == "b3":
effnet = EfficientNetB3(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model_base == "b4":
effnet = EfficientNetB4(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model_base == "b5":
effnet = EfficientNetB5(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model_base == "b6":
effnet = EfficientNetB6(include_top=False,
input_tensor=inputs,
weights="imagenet")
else:
effnet = EfficientNetB7(include_top=False,
input_tensor=inputs,
weights="imagenet")
# # Print architecture of effnet
# for i, layer in enumerate(effnet.layers[:]):
# print(i, layer.name, layer.output_shape)
# print(f"Effnet len: {len(effnet.layers[:])}")
# b0: 20; b2: 33; b4: 236; b6: 45; b7: 265
for i, layer in enumerate(effnet.layers[:first_layers_to_freeze]):
layer.trainable = False
for i, layer in enumerate(effnet.layers[first_layers_to_freeze:]):
if not isinstance(layer, K.layers.BatchNormalization):
layer.trainable = True
model = Sequential()
model.add(effnet)
model.add(K.layers.Dropout(0.25))
model.add(K.layers.Dense(effnet.layers[-1].output_shape[3]))
model.add(K.layers.LeakyReLU())
model.add(K.layers.GlobalAveragePooling2D())
model.add(K.layers.BatchNormalization())
model.add(K.layers.Dropout(0.5))
model.add(K.layers.Dense(num_classes, activation='softmax'))
# Freeze the batchnorm layer of our model
for i, layer in enumerate(model.layers[:]):
if isinstance(layer, K.layers.BatchNormalization):
layer.trainable = False
opt = Adam(lr=learning_rate, decay=learning_rate / epochs)
model.compile(loss="categorical_crossentropy",
optimizer=opt,
metrics=["accuracy"])
model.summary()
return model
x_train, x_valid, y_train, y_valid = train_test_split(x,
y,
train_size=0.9,
shuffle=True,
random_state=66)
train_generator = idg.flow(x_train, y_train, batch_size=28, seed=2048)
# seed => random_state
valid_generator = idg2.flow(x_valid, y_valid)
test_generator = idg2.flow(x_pred)
mc = ModelCheckpoint('C:/LPD_competition/lotte_0322_2.h5',
save_best_only=True,
verbose=1)
mobile = EfficientNetB2(include_top=False,
weights='imagenet',
input_shape=x_train.shape[1:])
mobile.trainable = True
a = mobile.output
a = GlobalAveragePooling2D()(a)
a = Flatten()(a)
a = Dense(4048, activation='swish')(a)
a = Dropout(0.2)(a)
a = Dense(1000, activation='softmax')(a)
model = Model(inputs=mobile.input, outputs=a)
# early_stopping = EarlyStopping(patience= 30)
# lr = ReduceLROnPlateau(patience= 15, factor=0.5)
# model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=0.1), metrics=['acc'])
def create_efficientnet(width, height, depth, model_base,
first_layers_to_freeze):
inputShape = (height, width, depth)
inputs = K.Input(shape=inputShape)
if model_base == "b0":
effnet = EfficientNetB0(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model_base == "b1":
effnet = EfficientNetB1(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model_base == "b2":
effnet = EfficientNetB2(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model_base == "b3":
effnet = EfficientNetB3(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model_base == "b4":
effnet = EfficientNetB4(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model_base == "b5":
effnet = EfficientNetB5(include_top=False,
input_tensor=inputs,
weights="imagenet")
elif model_base == "b6":
effnet = EfficientNetB6(include_top=False,
input_tensor=inputs,
weights="imagenet")
else:
effnet = EfficientNetB7(include_top=False,
input_tensor=inputs,
weights="imagenet")
# # Print architecture of effnet
# for i, layer in enumerate(effnet.layers[:]):
# print(i, layer.name, layer.output_shape)
# b0: 20; b2: 33; b4: 147; b6: 45; b7: 265
for i, layer in enumerate(effnet.layers[:first_layers_to_freeze]):
layer.trainable = False
for i, layer in enumerate(effnet.layers[first_layers_to_freeze:]):
layer.trainable = True
effnet.summary()
model = Sequential()
model.add(effnet)
model.add(K.layers.Dropout(0.25))
model.add(K.layers.Dense(effnet.layers[-1].output_shape[3]))
model.add(K.layers.LeakyReLU())
model.add(K.layers.GlobalAveragePooling2D())
model.add(K.layers.Dropout(0.5))
model.add(K.layers.Dense(1, activation='linear'))
return model