#실습
# cifar10으로 vgg16만들기
#결과치 비교
import numpy as np
from tensorflow.keras.datasets import cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
print(x_train.shape) # (50000,32,32,3)
print(x_test.shape) # (50000,1)
from tensorflow.keras.applications import VGG19
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.models import Sequential
vgg19 = VGG19(weights='imagenet', include_top=False,
input_shape=(32, 32,
3)) #원하는 사이즈는 include_top=False / 디폴트 224*224
# print(model.weights)
vgg19.trainable = False
# vgg16.summary()
# print(len(vgg16.weights)) # 26
# print(len(vgg16.trainable_weights)) # 0
model = Sequential()
model.add(vgg19)
model.add(Flatten())
model.add(Dense(10))
model.add(Dense(5))
model.add(Dense(1)) #, activation='softmax'))
model.summary()
def subvgg(self):
vgg = VGG19(input_shape=(self.hr_h, self.hr_w, 3), include_top=False, weights='imagenet')
vgg.outputs = [vgg.layers[9].output]
img_input = Input(shape=(self.hr_h, self.hr_w, 3))
img_features = vgg(img_input)
return Model(img_input, img_features)
def vgg_layers(layer_names):
vgg = VGG19(include_top=False, weights="imagenet")
vgg.trainable = False
outputs = [vgg.get_layer(name).output for name in layer_names]
return Model([vgg.input], outputs)
def __init__(
self,
dataset_name,
light,
source_domain,
target_domain,
gan_type,
epochs,
input_size,
multi_scale,
batch_size,
sample_size,
reporting_steps,
content_lambda,
style_lambda,
g_adv_lambda,
d_adv_lambda,
generator_lr,
discriminator_lr,
data_dir,
log_dir,
result_dir,
checkpoint_dir,
generator_checkpoint_prefix,
discriminator_checkpoint_prefix,
pretrain_checkpoint_prefix,
pretrain_model_dir,
model_dir,
disable_sampling,
ignore_vgg,
pretrain_learning_rate,
pretrain_epochs,
pretrain_saving_epochs,
pretrain_reporting_steps,
pretrain_generator_name,
generator_name,
discriminator_name,
debug,
**kwargs,
):
self.debug = debug
self.ascii = os.name == "nt"
self.dataset_name = dataset_name
self.light = light
self.source_domain = source_domain
self.target_domain = target_domain
self.gan_type = gan_type
self.epochs = epochs
self.input_size = input_size
self.multi_scale = multi_scale
self.batch_size = batch_size
self.sample_size = sample_size
self.reporting_steps = reporting_steps
self.content_lambda = float(content_lambda)
self.style_lambda = float(style_lambda)
self.g_adv_lambda = g_adv_lambda
self.d_adv_lambda = d_adv_lambda
self.generator_lr = generator_lr
self.discriminator_lr = discriminator_lr
self.data_dir = data_dir
self.log_dir = log_dir
self.result_dir = result_dir
self.checkpoint_dir = checkpoint_dir
self.generator_checkpoint_prefix = generator_checkpoint_prefix
self.discriminator_checkpoint_prefix = discriminator_checkpoint_prefix
self.pretrain_checkpoint_prefix = pretrain_checkpoint_prefix
self.pretrain_model_dir = pretrain_model_dir
self.model_dir = model_dir
self.disable_sampling = disable_sampling
self.ignore_vgg = ignore_vgg
self.pretrain_learning_rate = pretrain_learning_rate
self.pretrain_epochs = pretrain_epochs
self.pretrain_saving_epochs = pretrain_saving_epochs
self.pretrain_reporting_steps = pretrain_reporting_steps
self.pretrain_generator_name = pretrain_generator_name
self.generator_name = generator_name
self.discriminator_name = discriminator_name
self.logger = get_logger("Trainer", debug=debug)
# NOTE: just minimal demonstration of multi-scale training
self.sizes = [
self.input_size - 32, self.input_size, self.input_size + 32
]
if not self.ignore_vgg:
self.logger.info("Setting up VGG19 for computing content loss...")
from tensorflow.keras.applications import VGG19
from tensorflow.keras.layers import Conv2D
input_shape = (self.input_size, self.input_size, 3)
# download model using kwarg weights="imagenet"
base_model = VGG19(weights="imagenet",
include_top=False,
input_shape=input_shape)
tmp_vgg_output = base_model.get_layer("block4_conv3").output
tmp_vgg_output = Conv2D(512, (3, 3),
activation='linear',
padding='same',
name='block4_conv4')(tmp_vgg_output)
self.vgg = tf.keras.Model(inputs=base_model.input,
outputs=tmp_vgg_output)
self.vgg.load_weights(os.path.expanduser(
os.path.join(
"~", ".keras", "models",
"vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5")),
by_name=True)
else:
self.logger.info(
"VGG19 will not be used. "
"Content loss will simply imply pixel-wise difference.")
self.vgg = None
self.logger.info(
f"Setting up objective functions and metrics using {self.gan_type}..."
)
self.mae = tf.keras.losses.MeanAbsoluteError()
self.generator_loss_object = tf.keras.losses.BinaryCrossentropy(
from_logits=True)
if self.gan_type == "gan":
self.discriminator_loss_object = tf.keras.losses.BinaryCrossentropy(
from_logits=True)
elif self.gan_type == "lsgan":
self.discriminator_loss_object = tf.keras.losses.MeanSquaredError()
else:
wrong_msg = f"Non-recognized 'gan_type': {self.gan_type}"
self.logger.critical(wrong_msg)
raise ValueError(wrong_msg)
self.g_total_loss_metric = tf.keras.metrics.Mean("g_total_loss",
dtype=tf.float32)
self.g_adv_loss_metric = tf.keras.metrics.Mean("g_adversarial_loss",
dtype=tf.float32)
if self.content_lambda != 0.:
self.content_loss_metric = tf.keras.metrics.Mean("content_loss",
dtype=tf.float32)
if self.style_lambda != 0.:
self.style_loss_metric = tf.keras.metrics.Mean("style_loss",
dtype=tf.float32)
self.d_total_loss_metric = tf.keras.metrics.Mean("d_total_loss",
dtype=tf.float32)
self.d_real_loss_metric = tf.keras.metrics.Mean("d_real_loss",
dtype=tf.float32)
self.d_fake_loss_metric = tf.keras.metrics.Mean("d_fake_loss",
dtype=tf.float32)
self.d_smooth_loss_metric = tf.keras.metrics.Mean("d_smooth_loss",
dtype=tf.float32)
self.metric_and_names = [
(self.g_total_loss_metric, "g_total_loss"),
(self.g_adv_loss_metric, "g_adversarial_loss"),
(self.d_total_loss_metric, "d_total_loss"),
(self.d_real_loss_metric, "d_real_loss"),
(self.d_fake_loss_metric, "d_fake_loss"),
(self.d_smooth_loss_metric, "d_smooth_loss"),
]
if self.content_lambda != 0.:
self.metric_and_names.append(
(self.content_loss_metric, "content_loss"))
if self.style_lambda != 0.:
self.metric_and_names.append(
(self.style_loss_metric, "style_loss"))
self.logger.info("Setting up checkpoint paths...")
self.pretrain_checkpoint_prefix = os.path.join(
self.checkpoint_dir, "pretrain", self.pretrain_checkpoint_prefix)
self.generator_checkpoint_dir = os.path.join(
self.checkpoint_dir, self.generator_checkpoint_prefix)
self.generator_checkpoint_prefix = os.path.join(
self.generator_checkpoint_dir, self.generator_checkpoint_prefix)
self.discriminator_checkpoint_dir = os.path.join(
self.checkpoint_dir, self.discriminator_checkpoint_prefix)
self.discriminator_checkpoint_prefix = os.path.join(
self.discriminator_checkpoint_dir,
self.discriminator_checkpoint_prefix)
UPLOAD_FOLDER = './app/templates/static/uploads/'
SAVE_FOLDER = './app/templates/static/removal/'
STATIC_IMAGES = './app/static/assets/img/backgrounds/'
keras_weights_file = "app/pickles/model.h5"
ALLOWED_EXTENSIONS = set(['png', 'jpg', 'jpeg', 'gif'])
# provide login manager with load_user callback
custom_objects = {
'PhraseLevelFeatures': PhraseLevelFeatures,
'AttentionMaps': AttentionMaps,
'ContextVector': ContextVector
}
model = tf.keras.models.load_model(MODEL_PATH, custom_objects=custom_objects, compile=False)
vgg_model = VGG19(weights="imagenet", include_top=False, input_tensor=Input(shape=(224, 224, 3)))
stripe_keys = {
'secret_key': 'sk_test_51Hhvu4Gqfu9fIci4SWDkVj1TUUGPWPDqAC88LEU8NAzy1RAPfftG7ogYRKhqCRdW1O2Ya9czzFkpmkmQyTuqVkSK00JSrnCPHW',
'publishable_key': 'pk_test_51Hhvu4Gqfu9fIci4ulxp5s2Rx51IBlb6J3nf1mhfHcrdmv5pTimq9e31mjRGcrw9M0mpifD7oVchuAn03DoVJycR00IFXDPgFo'
}
stripe.api_key = stripe_keys['secret_key']
@lm.user_loader
def load_user(user_id):
return User.query.get(int(user_id))
@app.route('/checkout.html', methods=['POST'])
def checkout():
return render_template('accounts/checkout.html', amount=session["amount"])
def build_model(encoder='efficientnetb7', center='dac', full_skip=True, attention='sc', upscore='upall'):
MODEL_NAME = encoder
if center is not None:
MODEL_NAME = MODEL_NAME+'_'+center
if attention is not None:
MODEL_NAME = MODEL_NAME+'_'+attention
if full_skip:
MODEL_NAME = MODEL_NAME + '_fullskip'
if upscore is not None:
MODEL_NAME = MODEL_NAME + '_'+upscore
if encoder == 'resnet50':
encoder = ResNet50(input_tensor=Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3), name='data'), weights='imagenet', include_top=False)
skip_names = ['data', 'conv1_relu', 'conv2_block3_out', 'conv3_block4_out', 'conv4_block6_out']
encoder_output = encoder.get_layer('conv5_block3_out').output
# data 320x320x3
# conv1_relu 160x160x64
# conv2_block3_out 80x80x256
# conv3_block4_out 40x40x512
# conv4_block6_out 20x20x1024
# conv5_block3_out 10x10x2048 --> encoder output
elif encoder == 'resnet101':
encoder = ResNet101(input_tensor=Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3), name='data'), weights='imagenet', include_top=False)
skip_names = ['data', 'conv1_relu', 'conv2_block3_out', 'conv3_block4_out']
encoder_output = encoder.get_layer('conv4_block23_out').output
#data 320x320x3
#conv1_relu 160x160x64
#conv2_block3_out 80x80x256
#conv3_block4_out 40x40x512
#conv4_block23_out 20x20x1024 --> encoder output
#conv5_block3_out 10x10x2048
elif encoder == 'resnet50v2':
encoder = ResNet50V2(input_tensor=Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3), name='data'), weights='imagenet', include_top=False)
skip_names = ['data', 'conv1_conv', 'conv2_block3_1_relu', 'conv3_block4_1_relu', 'conv4_block6_1_relu']
encoder_output = encoder.get_layer('post_relu').output
# data 320x320x3
# conv1_conv 160x160x64
# conv2_block3_1_relu 80x80x64
# conv3_block4_1_relu 40x40x128
# conv4_block6_1_relu 20x20x256
# post_relu 10x10x2048 --> encoder output
elif encoder == 'resnet101v2':
encoder = ResNet101V2(input_tensor=Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3), name='data'), weights='imagenet', include_top=False)
skip_names = ['data', 'conv1_conv', 'conv2_block3_1_relu', 'conv3_block4_1_relu', 'conv4_block23_1_relu']
encoder_output = encoder.get_layer('post_relu').output
#data 320x320x3
#conv1_conv 160x160x64
#conv2_block3_1_relu 80x80x64
#conv3_block4_1_relu 40x40x128
#conv4_block23_1_relu 20x20x256
#post_relu 10x10x2048 --> encoder output
elif encoder == 'vgg19':
encoder = VGG19(input_shape=(IMAGE_SIZE, IMAGE_SIZE, 3), weights='imagenet', include_top=False)
skip_names = ['block1_conv2', 'block2_conv2', 'block3_conv4', 'block4_conv4', 'block5_conv4']
encoder_output = encoder.get_layer('block5_pool').output
# block1_conv2 320x320x64
# block2_conv2 160x160x128
# block3_conv4 80x80x256
# block4_conv4 40x40x512
# block5_conv4 20x20x512
# block5_pool 10x10x512 --> encoder output
elif encoder == 'efficientnetb6':
encoder = EfficientNetB6(input_tensor=Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3), name='data'), weights='imagenet', include_top=False)
skip_names = ['data', 'block2a_expand_activation', 'block3a_expand_activation', 'block4a_expand_activation']
encoder_output = encoder.get_layer('block6a_expand_activation').output
#data 320x320x3
#block2a_expand_activation 160x160x192
#block3a_expand_activation 80x80x240
#block4a_expand_activation 40x40x432
#block6a_expand_activation 20x20x1200 --> encoder output
#top_activation 10x10x2304
elif encoder == 'efficientnetb7':
encoder = EfficientNetB7(input_tensor=Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3), name='data'), weights='imagenet', include_top=False)
skip_names = ['data', 'block2a_expand_activation', 'block3a_expand_activation', 'block4a_expand_activation']
encoder_output = encoder.get_layer('block6a_expand_activation').output
#data 320x320x3
#block2a_expand_activation 160x160x192
#block3a_expand_activation 80x80x288
#block4a_expand_activation 40x40x480
#block6a_expand_activation 20x20x1344 --> encoder output
#top_activation 10x10x
elif encoder == 'mobilenetv2':
encoder = MobileNetV2(input_tensor=Input(shape=(IMAGE_SIZE, IMAGE_SIZE, 3), name='data'), weights='imagenet', include_top=False)
skip_names = ['data', 'block_1_expand_relu', 'block_3_expand_relu', 'block_6_expand_relu', 'block_13_expand_relu']
encoder_output = encoder.get_layer('out_relu').output
# data 320x320x3
# block_1_expand_relu 160x160x96
# block_3_expand_relu 80x80x144
# block_6_expand_relu 40x40x192
# block_13_expand_relu 20x20x576
# out_relu 10x10x1248 --> encoder output
skip_layers = [encoder.get_layer(i).output for i in skip_names]
# Center --------------
if center == 'atrous':
x = atrous_block(encoder_output)
elif center == 'dac':
x = dense_atrous_block(encoder_output)
elif center == 'aspp':
x = aspp_block(encoder_output)
elif center is None:
x = encoder_output
# Decoder --------------
if attention == 'se':
attn_block = se_block
elif attention == 'cbam':
attn_block = cbam_block
elif attention == 'sc':
attn_block = scSE_block
filters = [i.shape[-1] for i in skip_layers]
filters[0] = 64
scales = [2 ** i for i in range(1, len(filters))][::-1]
X = []
for i in range(1, len(filters) + 1):
X.append(x)
down = []
if full_skip:
for j in range(len(scales) - (i - 1)):
d = down_skip(skip_layers[j], scales[j + (i - 1)], filters[-1]//4)
if attention is not None:
d = attn_block(d)
down.append(d)
direct = direct_skip(skip_layers[-i], filters[-1]//4)
if attention is not None:
direct = attn_block(direct)
x = convtranspose_block(x, filters[-1]//4)
if attention is not None:
x = attn_block(x)
x = Concatenate()([x] + [direct] + down)
x = conv3_block(x, x.shape[-1])
if upscore is not None:
if upscore=='upall':
up_scales=[2 ** i for i in range(1, len(filters)+1)][::-1]
UP = [upscore_block(x, 32, up_scales[i]) for i, x in enumerate(X)]
if attention is not None:
UP = [attn_block(x) for x in UP]
up = Concatenate()(UP)
elif upscore=='upcenter':
up = upscore_block(X[0], 64, 2 ** len(filters))
if attention is not None:
up = attn_block(up)
x = Concatenate()([x, up])
x = Conv2D(1, 1, padding='same')(x)
x = Activation('sigmoid')(x)
model = Model(encoder.input, x)
metrics = [dice_coef, Recall(), Precision()]
opt = Nadam(LR)
model.compile(loss=bce_dice_loss, optimizer=opt, metrics=metrics)
return model, MODEL_NAME
def build_model(mode, model_name=None, model_path=None):
clear_session()
if mode == 'train':
img = Input(
shape=(96, 96,
3)) # ResNet50 minimum size (32,32) for others (128,128)
if model_name == 'DenseNet121': #Checked and Working
model = DenseNet121(include_top=False,
weights='imagenet',
input_tensor=img,
input_shape=None,
pooling='avg')
elif model_name == 'MobileNet': #checked, raised shape error, #Error Resolved, Now working
model = MobileNet(include_top=True,
weights='imagenet',
input_tensor=img,
input_shape=None,
pooling='avg')
elif model_name == 'Xception': #Checked and Working
model = Xception(include_top=False,
weights='imagenet',
input_tensor=img,
input_shape=None,
pooling='max')
elif model_name == 'ResNet50': #Image Dimesion size should be high eg 224x224, not sufficient GPU memory resource
model = ResNet50(include_top=False,
weights='imagenet',
input_tensor=img,
input_shape=None,
pooling='avg')
elif model_name == 'InceptionV3': #Checked and Working
model = InceptionV3(include_top=False,
weights='imagenet',
input_tensor=img,
input_shape=(None),
pooling='avg')
elif model_name == 'VGG19': #to be checked
model = InceptionV4(include_top=False,
weights='imagenet',
input_tensor=img,
input_shape=None,
pooling='avg')
elif model_name == 'VGG16': #Checked and Working
model = VGG16(include_top=False,
weights='imagenet',
input_tensor=img,
input_shape=(None),
pooling='max')
elif model_name == 'VGG19': #to be checked
model = VGG19(include_top=False,
weights='imagenet',
input_tensor=img,
input_shape=None,
pooling='avg')
final_layer = model.layers[-1].output
dense_layer_1 = Dense(128, activation='relu')(final_layer)
output_layer = Dense(4, activation='softmax')(dense_layer_1)
model = Model(inputs=[img], outputs=output_layer)
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
elif mode == 'inference':
model = load_model(model_path)
return model
y,
train_size=0.8,
shuffle=True,
random_state=42)
aaa = 1
x_train = x_train.reshape(x_train.shape[0], x_train.shape[1], x_train.shape[2],
aaa)
x_test = x_test.reshape(x_test.shape[0], x_test.shape[1], x_test.shape[2], aaa)
print(x_train.shape, y_train.shape) # (3628, 128, 862, 1) (3628,)
print(x_test.shape, y_test.shape) # (908, 128, 862, 1) (908,)
model = VGG19(
include_top=True,
input_shape=(128, 862, 1),
classes=2,
pooling=None,
weights=None,
)
model.summary()
# model.trainable = False
model.save('C:/nmb/nmb_data/h5/5s/vgg19/vgg19_adadelta_2.h5')
# 컴파일, 훈련
op = Adadelta(lr=1e-3)
batch_size = 4
es = EarlyStopping(monitor='val_loss',
patience=20,
validation_data=validation_generator)
fig, ax = plt.subplots(2, 2, sharex=True, figsize=(20, 10))
fig.set_size_inches(14., 7.)
plot_ax(ax[0][0], 'loss', 'Loss', 200)
plot_ax(ax[0][1], 'accuracy', 'Akurasi', 200)
plot_ax(ax[1][0], 'prec', 'Presisi', 200)
plot_ax(ax[1][1], 'rec', 'Recall', 200)
fig = plt.gcf()
plt.suptitle('Grafik Setiap Metrics (InceptionV3)\n(sumbu x adalah epoch)')
plt.show()
model.save('/content/drive/My Drive/Kompetisi/SATRIA DATA 2020/SEC/Inceptrans.h5')
# VGG19
vgg19_model=VGG19(input_shape=(300,300,3),include_top=False)
vgg19_model.trainable=False
vgg19_model.summary()
last_output=vgg19_model.output
print('last layer output shape: ', vgg19_model.output_shape)
# Flatten the output layer to 1 dimension
x = layers.Flatten()(last_output)
x = layers.Dense(512, activation='relu')(x)
x = layers.Dropout(0.1)(x)
x = layers.Dense(1, activation='sigmoid')(x)
model = Model(vgg19_model.input, x)
model.summary
def createGAN(generator, discriminator):
'''对抗网'''
discriminator.trainable = False
#生成器输入
lowImg = generator.input
#生成器输出
fakeHighImg = generator(lowImg)
#生成器判断
judge = discriminator(fakeHighImg)
model = Model(inputs=lowImg, outputs=[judge, fakeHighImg])
model.summary()
return model
#特征提取器
vgg19 = VGG19(include_top=False, weights='imagenet')
vgg19 = Model(vgg19.input, vgg19.output)
def restoreImg(img):
'''还原图片'''
img = (img / 2 + 0.5) * 255
return img
def contentLoss(y_true, y_pred):
'''内容损失'''
y_true = restoreImg(y_true)
y_pred = restoreImg(y_pred)
y_true = preprocess_input(y_true)
y_pred = preprocess_input(y_pred)
def uvgg19(input_size):
if input_size[-1] == 1:
input_size = (input_size[0], input_size[1], 3)
vgg19 = VGG19(include_top=False,
weights='imagenet',
input_tensor=None,
input_shape=input_size,
pooling=None)
encoder = Model(vgg19.input,
vgg19.get_layer("block5_conv4").output,
name="encoder")
d_i = Input(shape=(encoder.output.shape[1:]), name='decoder_input')
block5_up = UpSampling2D(size=(2, 2), name="block5_up")(d_i)
block4_1_conv0 = Conv2D(filters=512,
kernel_size=3,
padding='same',
activation='relu',
name="block4_1_conv0")(block5_up)
block4_merge = Concatenate(axis=-1, name="block4_merge")(
[vgg19.get_layer("block4_conv4").output, block4_1_conv0])
block4_1_conv1 = Conv2D(filters=512,
kernel_size=3,
padding='same',
activation='relu',
name="block4_1_conv1")(block4_merge)
block4_1_conv2 = Conv2D(filters=512,
kernel_size=3,
padding='same',
activation='relu',
name="block4_1_conv2")(block4_1_conv1)
block4_1_conv3 = Conv2D(filters=512,
kernel_size=3,
padding='same',
activation='relu',
name="block4_1_conv3")(block4_1_conv2)
block4_1_conv4 = Conv2D(filters=512,
kernel_size=3,
padding='same',
activation='relu',
name="block4_1_conv4")(block4_1_conv3)
block4_up = UpSampling2D(size=(2, 2), name="block4_up")(block4_1_conv4)
block3_1_conv0 = Conv2D(filters=256,
kernel_size=3,
padding='same',
activation='relu',
name="block3_1_conv0")(block4_up)
block3_merge = Concatenate(axis=-1, name="block3_merge")(
[vgg19.get_layer("block3_conv4").output, block3_1_conv0])
block3_1_conv1 = Conv2D(filters=256,
kernel_size=3,
padding='same',
activation='relu',
name="block3_1_conv1")(block3_merge)
block3_1_conv2 = Conv2D(filters=256,
kernel_size=3,
padding='same',
activation='relu',
name="block3_1_conv2")(block3_1_conv1)
block3_1_conv3 = Conv2D(filters=256,
kernel_size=3,
padding='same',
activation='relu',
name="block3_1_conv3")(block3_1_conv2)
block3_1_conv4 = Conv2D(filters=256,
kernel_size=3,
padding='same',
activation='relu',
name="block3_1_conv4")(block3_1_conv3)
block3_up = UpSampling2D(size=(2, 2), name="block3_up")(block3_1_conv4)
block2_1_conv0 = Conv2D(filters=128,
kernel_size=3,
padding='same',
activation='relu',
name="block2_1_conv0")(block3_up)
block2_merge = Concatenate(axis=-1, name="block2_merge")(
[vgg19.get_layer("block2_conv2").output, block2_1_conv0])
block2_1_conv1 = Conv2D(filters=128,
kernel_size=3,
padding='same',
activation='relu',
name="block2_1_conv1")(block2_merge)
block2_1_conv2 = Conv2D(filters=128,
kernel_size=3,
padding='same',
activation='relu',
name="block2_1_conv2")(block2_1_conv1)
block2_up = UpSampling2D(size=(2, 2), name="block2_up")(block2_1_conv2)
block1_1_conv0 = Conv2D(filters=64,
kernel_size=3,
padding='same',
activation='relu',
name="block1_1_conv0")(block2_up)
block1_merge = Concatenate(axis=-1, name="block1_merge")(
[vgg19.get_layer("block1_conv2").output, block1_1_conv0])
block1_1_conv1 = Conv2D(filters=64,
kernel_size=3,
padding='same',
activation='relu',
name="block1_1_conv1")(block1_merge)
block1_1_conv2 = Conv2D(filters=64,
kernel_size=3,
padding='same',
activation='relu',
name="block1_1_conv2")(block1_1_conv1)
block1_1_conv3 = Conv2D(filters=2,
kernel_size=3,
padding='same',
activation='relu',
name="block1_1_conv3")(block1_1_conv2)
output = Conv2D(filters=1,
kernel_size=1,
activation='sigmoid',
name="output")(block1_1_conv3)
decoder = Model([vgg19.input, d_i], output, name="decoder")
decoder_output = decoder([vgg19.input, encoder(encoder.input)])
model = Model(encoder.input, decoder_output, name=vgg19.name)
return model
import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers import numpy as np from tensorflow.keras.applications import VGG19 # graph of layers you are manipulating in the Functional API is a static datastructure vgg19 = VGG19() features_list = [layer.output for layer in vgg19.layers]
output_image = cv.cvtColor(output_image, cv.COLOR_BGR2RGB)
cam = cv.cvtColor(cam, cv.COLOR_BGR2RGB)
return output_image, cam
# %%
# Read image
img = cv.imread('./cat_dog.jpg')
img = cv.cvtColor(img, cv.COLOR_BGR2RGB)
img = cv.resize(img, (224, 224))
# %%
# Load model
model = VGG19(weights='imagenet')
model.summary()
# After prinintg, copy layer's name
# %%
# 174 tabby
# 211 German_shepherd
overlaped, cam = grad_cam(model, 'block5_pool', 174, img[np.newaxis] / 255.)
plt.figure(figsize=(15, 5))
plt.suptitle(f"About tabby")
plt.subplot(1, 3, 1)
plt.imshow(img)
plt.subplot(1, 3, 2)
C = Struct(**C)
input_shape_img = (224, 224, 3)
img_input = Input(shape=input_shape_img)
print('Loading pre-trained weights...')
if C.network == 'vgg16':
from src.architectures import vgg16 as nn
base_layers = VGG16(weights=None,
include_top=False,
input_tensor=img_input)
elif C.network == 'vgg19':
from src.architectures import vgg19 as nn
base_layers = VGG19(weights=None,
include_top=False,
input_tensor=img_input)
elif C.network == 'resnet50':
from src.architectures import resnet50 as nn
base_layers = ResNet50(weights=None,
include_top=False,
input_tensor=img_input)
elif C.network == 'resnet152':
from src.architectures import resnet152 as nn
base_layers = ResNet152(weights=None,
include_top=False,
input_tensor=img_input)
with tf.device(device):
print('Loading weights from {}'.format(options.weights))
X = tensor2numpy('./data/', train_set, srgan)
x = [X[i] for i in X.keys()]
train = np.array(x, dtype = "float64")
y = create_onehot(X)
history = cnn.fit(train, y, batch_size=32, epochs=5, callbacks=callbacks_list, validation_split=0.2)
# Plot training & validation accuracy values
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('Model loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
"""Upload, use transfer learning"""
VGG=VGG19(input_shape=(224,224,3),include_top=False,weights='imagenet')
#freeze NatNetMobile weights
for layer in VGG.layers:
layer.trainable=False
output=VGG.layers[6].output
output=Flatten()(output)
output=Dense(1024,activation='relu')(output)
output=Dense(512,activation='relu')(output)
output=Dropout(0.5)(output)
output=Dense(256,activation='relu')(output)
output=Dense(101,activation='softmax')(output)
VGG=Model(VGG.input,output)
VGG.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])
plot_model(VGG, to_file='./model.png', show_shapes=True, show_layer_names=True)
def __init__(self, content_layer):
super().__init__()
vgg = VGG19(include_top=False, weights='imagenet')
self.vgg = tf.keras.Model([vgg.input],
[vgg.get_layer(content_layer).output])
self.vgg.trainable = False
def build_vgg_extractor():
vgg = VGG19(include_top=False, weights='imagenet')
content_layers = ['block1_conv1','block1_conv2','block2_conv1','block2_conv2','block3_conv1']
lossModel = tf.keras.Model(inputs=vgg.input, outputs=[vgg.get_layer(x).output for x in content_layers])
lossModel.trainable = False
return lossModel
def CNN_model(self, learning_rate, epoch, batchsize, whether_Adam, Momentum_gamma, weight_decay, whether_load, cnn_type):
"""
Resnet model
:param learning_rate
:param epoch
:param batchsize
:param whether_Adam: whether to perform Adam optimiser, if not perform Momentum
:param Momentum gamma: a variable of Momentum
:param weight_decay: weight decay for Momentum
:param whether_load: whether to load trained Resnet model in if it exists (or cover it)
"""
test_cnn_mfcc = self.train_mfcc
test_cnn_label = self.train_label
if(isfile("model/resnet_label.hdf5") and whether_load):
self.cnn_model = load_model("model/resnet_label.hdf5")
else:
train_cnn_mfcc = self.test_mfcc
train_cnn_label = self.test_label
val_cnn_mfcc = self.validate_mfcc
val_cnn_label = self.validate_label
# input
input = Input(shape=(self.test_mfcc.shape[1], self.test_mfcc.shape[2], 1))
# Concatenate -1 dimension to be three channels, to fit the input need in ResNet50
input_concate = Concatenate()([input,input,input])
# CNN series network (VGG+Resnet)
# reference: https://keras.io/api/applications/
if(cnn_type == 'ResNet50'):
from tensorflow.keras.applications import ResNet50
cnn_output = ResNet50(pooling = 'avg')(input_concate)
elif(cnn_type == 'ResNet101'):
from tensorflow.keras.applications import ResNet101
cnn_output = ResNet101(pooling = 'avg')(input_concate)
elif(cnn_type == 'ResNet152'):
from tensorflow.keras.applications import ResNet152
cnn_output = ResNet152(pooling = 'avg')(input_concate)
elif(cnn_type == 'ResNet50V2'):
from tensorflow.keras.applications import ResNet50V2
cnn_output = ResNet50V2(pooling = 'avg')(input_concate)
elif(cnn_type == 'ResNet101V2'):
from tensorflow.keras.applications import ResNet101V2
cnn_output = ResNet101V2(pooling = 'avg')(input_concate)
elif(cnn_type == 'ResNet152V2'):
from tensorflow.keras.applications import ResNet152V2
cnn_output = ResNet152V2(pooling = 'avg')(input_concate)
elif(cnn_type == 'VGG16'):
# width and height should not smaller than 32
from tensorflow.keras.applications import VGG16
cnn_output = VGG16(include_top = False, pooling = 'avg')(input_concate)
cnn_output = Flatten()(cnn_output)
elif(cnn_type == 'VGG19'):
# width and height should not smaller than 32
from tensorflow.keras.applications import VGG19
cnn_output = VGG19(include_top = False, pooling = 'avg')(input_concate)
cnn_output = Flatten()(cnn_output)
else:
# CNN layers we design
print("No recognised CNN network. The CNN layers we designed are performed")
# convolution layers
conv_output1 = Conv2D(filters=32, strides=(1, 1), kernel_size=5, activation='relu')(input)
# pool_output1 = MaxPool2D(pool_size=(2, 2))(conv_output1)
conv_output2 = Conv2D(filters=8, strides=(2, 2), kernel_size=4, activation='relu')(conv_output1)
conv_output2 = Dropout(0.2)(conv_output2)
conv_output2_batch = BatchNormalization()(conv_output2)
cnn_output = Flatten()(conv_output2_batch)
cnn_output = Flatten()(cnn_output)
# dense with sigmoid
Dense_sigmoid = Dense(24, activation='sigmoid')(cnn_output)
Dense_sigmoid = Dropout(0.2)(Dense_sigmoid)
# dense output
output = Dense(self.test_label.shape[1], activation='softmax')(Dense_sigmoid)
# cnn model for labels recognision
self.cnn_model = Model(input, output)
# optimizer
if whether_Adam:
optimizer = optimizers.Adam(lr=learning_rate, beta_1 = Momentum_gamma, decay=weight_decay)
else:
optimizer = optimizers.SGD(lr=learning_rate, momentum=Momentum_gamma, nesterov=True, decay=weight_decay)
self.cnn_model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['mse', 'accuracy'])
start = time.time()
self.history = self.cnn_model.fit(train_cnn_mfcc, train_cnn_label, epochs=epoch, batch_size=batchsize, validation_data=[val_cnn_mfcc,val_cnn_label])
self.training_time = time.time() - start
self.cnn_model.save("model/resnet_label.hdf5")
# model evaluation
self.cnn_model.predict(test_cnn_mfcc)
self.score = self.cnn_model.evaluate(test_cnn_mfcc, test_cnn_label)
print("test loss: ", self.score[0], ", mse: ", self.score[1], ", accuracy", self.score[2])
def train_model(path,
train_images=None,
train_labels=None,
test_images=None,
test_labels=None,
model_name=None,
epochs=80,
learning_rate=0.0001,
input_shape=(224, 224, 3),
classes=2,
batch_size=16,
classifier_activation='softmax',
callbacks=None):
'''
saves the model as .h5 file\n
path = directory for saving the files
train_images = a numpy array containing the image data for training\n
train_labels = a numpy array containing the labels for training\n
test_images = a numpy array containing the image data for test\n
test_labels = a numpy array containing the labels for test\n
model_name = a string, name of the model -> "vgg19", "resnet50_v2", "inception_resnet_v2", "densenet201", "inception_v3", "xception", "mobilenet_v2"\n
epochs\n
learning_rate\n
'''
base_model = None
if model_name == 'vgg19':
base_model = VGG19(weights=None,
include_top=False,
input_shape=input_shape)
if model_name == 'resnet50_v2':
base_model = ResNet50V2(weights=None,
include_top=False,
input_shape=input_shape)
if model_name == 'inception_resnet_v2':
base_model = InceptionResNetV2(weights=None,
include_top=False,
input_shape=input_shape)
if model_name == 'densenet201':
base_model = DenseNet201(weights=None,
include_top=False,
input_shape=input_shape)
if model_name == 'inception_v3':
base_model = InceptionV3(weights=None,
include_top=False,
input_shape=input_shape)
if model_name == 'xception':
base_model = Xception(weights=None,
include_top=False,
input_shape=input_shape)
if model_name == 'mobilenet_v2':
base_model = MobileNetV2(weights=None,
include_top=False,
input_shape=input_shape)
x = base_model.output
x = tf.keras.layers.GlobalAveragePooling2D()(x)
output = tf.keras.layers.Dense(classes,
activation=classifier_activation)(x)
model = tf.keras.Model(inputs=base_model.input, outputs=output)
optimizer = Adam(learning_rate=learning_rate,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-07)
model.compile(
optimizer=optimizer,
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
results = model.fit(train_images,
train_labels,
epochs=epochs,
validation_data=(test_images, test_labels),
batch_size=batch_size,
callbacks=callbacks)
#losses = pd.DataFrame(model.history.history)
#losses[['loss','val_loss']].plot()
save_model = path + model_name + '.h5'
model.save(save_model)
return results
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.utils import to_categorical
#1. 데이터
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
x_train = x_train.reshape(x_train.shape[0], x_train.shape[1], x_train.shape[2],
3).astype('float32') / 255.
x_test = x_test.reshape(x_test.shape[0], x_test.shape[1], x_test.shape[2],
3).astype('float32') / 255.
#2. 모델
t = VGG19(weights='imagenet',
include_top=False,
input_shape=(x_train.shape[1], x_train.shape[2], 3))
t.trainable = False #학습시키지 않겠다 이미지넷 가져다가 그대로 쓰겠다
# model.trainable=True
model = Sequential()
model.add(t)
model.add(Flatten())
model.add(Dense(256))
model.add(BatchNormalization())
model.add(Dropout(0.2))
model.add(Activation('relu'))
model.add(Dense(256))
model.add(Dense(10, activation='softmax'))
model.compile(loss='categorical_crossentropy',
def generate_vgg_model_large(classes_len: int):
"""
Function to create a VGG19 model pre-trained with custom FC Layers at the start of the network plus optional layers at
the end before the fully connected ones as well
If the "advanced" command line argument is selected, adds an extra convolutional layer with extra filters to support
larger images.
This model is a larger model that starts with two more sets of convolutional layers with less filters
:param classes_len: The number of classes (labels).
:return: The VGG19 model.
"""
model_base = Sequential()
# Reconfigure single channel input into a greyscale 3 channel input
img_input = Input(shape=(config.VGG_IMG_SIZE_LARGE['HEIGHT'],
config.VGG_IMG_SIZE_LARGE['WIDTH'], 1))
img_conc = Concatenate()([img_input, img_input, img_input])
input_model = Model(inputs=img_input, outputs=img_conc)
# Generate extra convolutional layers for model to put at the beginning
model_base.add(input_model)
model_base.add(Conv2D(16, (3, 3), activation='relu', padding='same'))
model_base.add(Conv2D(16, (3, 3), activation='relu', padding='same'))
model_base.add(MaxPooling2D((2, 2), strides=(2, 2)))
model_base.add(Conv2D(32, (3, 3), activation='relu', padding='same'))
model_base.add(Conv2D(32, (3, 3), activation='relu', padding='same'))
model_base.add(MaxPooling2D((2, 2), strides=(2, 2)))
# To ensure model fits with vgg model, we can remove the first layer from the vgg model to replace with this
model_base.add(Conv2D(64, (3, 3), activation='relu', padding='same'))
# Generate a VGG19 model with pre-trained ImageNet weights, input as given above, excluded fully connected layers.
vgg_model = VGG19(include_top=False,
weights='imagenet',
input_shape=[
config.VGG_IMG_SIZE['HEIGHT'],
config.VGG_IMG_SIZE['HEIGHT'], 3
])
# Crop vgg model to exlude input layer and first convolutional layer
vgg_model_cropped = Sequential()
for layer in vgg_model.layers[2:]: # go through until last layer
vgg_model_cropped.add(layer)
# Combine the models
combined_model = Sequential()
combined_model.add(model_base)
combined_model.add(vgg_model_cropped)
# Add fully connected layers
model = Sequential()
# Start with base model consisting of convolutional layers
model.add(combined_model)
# Generate additional convolutional layers
if config.model == "advanced":
model.add(Conv2D(1024, (3, 3), activation='relu', padding='same'))
model.add(Conv2D(1024, (3, 3), activation='relu', padding='same'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
# Flatten layer to convert each input into a 1D array (no parameters in this layer, just simple pre-processing).
model.add(Flatten())
# Add fully connected hidden layers.
model.add(Dense(units=512, activation='relu', name='Dense_Intermediate_1'))
model.add(Dense(units=32, activation='relu', name='Dense_Intermediate_2'))
# Possible dropout for regularisation can be added later and experimented with:
# model.add(Dropout(0.1, name='Dropout_Regularization'))
# Final output layer that uses softmax activation function (because the classes are exclusive).
if classes_len == 2:
model.add(Dense(1, activation='sigmoid', name='Output'))
else:
model.add(Dense(classes_len, activation='softmax', name='Output'))
# Print model details if running in debug mode.
if config.verbose_mode:
model.summary()
return model
<br>
#### VGG-19
<br>
"""
# VGG-19 architecture
vgg = VGG19(include_top=False,
weights='imagenet',
input_shape=(32, 32, 3),
pooling='max',
classes=10)
# setting trainable layers in VGG-19
for layer in vgg.layers[0:15]:
layer.trainable = True
for layer in vgg.layers[15:]:
layer.trainable = False
# Summary VGG-19
print(vgg.summary())
# Build CNN
import time
from timeit import timeit
import numpy as np
import tensorflow as tf
from numpy.random import randn
from tensorflow.keras.applications import VGG19
from tensorflow.keras.losses import MAE
physical_devices = tf.config.experimental.list_physical_devices('GPU')
tf.config.experimental.set_memory_growth(physical_devices[0], True)
tf.config.optimizer.set_jit(True) # XLA enabled
m = VGG19()
m.compile(optimizer='adam', loss=MAE)
def benchmark_tensorflow(batchsize):
ip = tf.convert_to_tensor(np.array(randn(*(batchsize, 224, 224, 3)), dtype=np.float32))
# warm-up
m.predict(ip)
time.sleep(10)
# benchmark
print(timeit(lambda: m.predict(ip), number=10))
validation_set = train_datagen.flow_from_directory(train_path,
target_size=(224, 224),
batch_size=32,
class_mode='categorical',
shuffle=True,
subset='validation')
# In[4]:
from tensorflow.keras.applications import VGG19
from tensorflow.keras.layers import GlobalAveragePooling2D, Dropout
## We are initialising the input shape with 3 channels rgb and weights as imagenet and include_top as False will make to use our own custom inputs
mv = VGG19(input_shape=IMAGE_SIZE + [3], weights='imagenet', include_top=False)
# In[5]:
for layers in mv.layers:
layers.trainable = False
# In[6]:
x = Flatten()(mv.output)
prediction = Dense(3, activation='softmax')(x)
# In[7]:
model = Model(inputs=mv.input, outputs=prediction)
epochs=epochs,
validation_data=val_generator,
workers=4
)
score = model.evaluate(val_generator,verbose=2)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
"""## VGG19
"""
from tensorflow.keras.applications import VGG19
net= VGG19(include_top=False, weights='imagenet', input_tensor=Input(shape=(150,150,3)))
for layer in net.layers[:-5]:
layer.trainable = False
x = net.output
x = Flatten()(x)
x = Dropout(0.5)(x)
output_layer = Dense(1, activation='sigmoid', name='sigmoid')(x)
model = Model(inputs=net.input, outputs=output_layer)
# initiate RMSprop optimizer
opt = keras.optimizers.RMSprop(lr=0.0001, decay=1e-6)
# Train the model using RMSprop
model.compile(loss='binary_crossentropy',
from tensorflow.keras.utils import to_categorical
from sklearn.metrics import confusion_matrix
from tensorflow.keras.models import Model
import tensorflow.keras.backend as K
import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np
import os, re, cv2
import itertools
#Defining the model objects for ResNet50 and VGG19
K.clear_session()
base_model = ResNet50(include_top=False, weights='imagenet', input_shape=(32,32,3))
base_model_vgg = VGG19(include_top=False, weights='imagenet', input_shape=(32,32,3))
#Making the VGG19 Dense layers non-trainable
for layer in base_model_vgg.layers:
layer.trainable= False
base_model_vgg.summary()
#Adding some customized layers for the model
y1 = base_model_vgg.output
y1 = Flatten()(y1)
y1 = BatchNormalization()(y1)
y1 = Dense(128,activation='relu')(y1)
y1 = Dropout(0.3)(y1)
def mini_vgg(layer_names):
vgg = VGG19(weights='imagenet', include_top=False)
vgg.trainable = False
outputs = [vgg.get_layer(name).output for name in layer_names]
model = Model([vgg.input], outputs)
return model
(trainX, testX, trainY, testY) = train_test_split(imagens,
labels,
test_size=0.20,
stratify=labels,
random_state=random_state)
# DATA AUGMENTATION
train_datagen = ImageDataGenerator(rotation_range=20, zoom_range=0.2)
train_datagen.fit(trainX)
data_aug = train_datagen.flow(trainX, trainY, batch_size=batch_size)
# TRANSFER LEARNING
conv_base = VGG19(weights='imagenet',
include_top=False,
input_shape=input_shape)
conv_base.summary()
# Retreinando parte da VGG19
conv_base.trainable = True
set_trainable = False
for layer in conv_base.layers:
if layer.name == 'block5_conv1':
set_trainable = True
if set_trainable:
layer.trainable = True
else:
layer.trainable = False
x_test = scaler.transform(x_test)
x_val = scaler.transform(x_val)
#to_categorical
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
y_val = to_categorical(y_val)
#reshape
x_train = x_train.reshape(-1, 32, 32, 3)
x_test = x_test.reshape(-1, 32, 32, 3)
x_val = x_val.reshape(-1, 32, 32, 3)
print(x_train.shape, x_test.shape, x_val.shape)
#2. 모델링
vgg16 = VGG19(weights='imagenet', include_top=False,
input_shape=(32, 32, 3)) #레이어 16개
vgg16.trainable = False #훈련시키지 않고 가중치만 가져오겠다.
model = Sequential()
model.add(vgg16)
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
model.add(Dense(10,
activation='softmax')) #activation='softmax')) #mnist사용할 경우
model.summary()
print(len(vgg16.weights)) # 26
print(len(vgg16.trainable_weights)) # 0
#컴파일, 훈련
from tensorflow.keras.callbacks import EarlyStopping
def vgg_model(self):
layers = self.style_layers + self.content_layers
vgg = VGG19(include_top=False, weights="imagenet")
outputs = [vgg.get_layer(layer).output for layer in layers]
model = Model([vgg.input], outputs)
return model