def main():
import os
os.environ['CUDA_VISIBLE_DEVICES'] = str(3)
from netgraph.nx.netgraph import NetGraph, HDF5Graph
import numpy as np
import pandas as pd
# import holoviews as hv
import networkx as nx
from holoviews import opts
import matplotlib.pyplot as plt
from tqdm.autonotebook import tqdm
from keras import backend as K
from keras.preprocessing import image
from keras.applications.resnet50 import preprocess_input, decode_predictions
from pathlib import Path
input_name = 'input_1'
image_size = (64, 64)
from keras.applications.resnet import ResNet50
net = ResNet50(input_shape=(*image_size, 3), include_top=False)
imagenet_dir = Path('/media/disk1/anerinovsky/datasets/fvs/imagenette-320/')
img = image.load_img(imagenet_dir/'val'/'n01440764'/'ILSVRC2012_val_00000293.JPEG',
# target_size=(224, 224),
target_size=image_size
)
x = image.img_to_array(img)
x = np.expand_dims(x, axis=0)
x = preprocess_input(x)
sess = K.get_session()
ng = NetGraph(sess=sess,
feed_dict={ sess.graph.get_tensor_by_name(input_name + ':0') : x },
graph=HDF5Graph(
file='~/data/ng/resnet50.hdf5',
node_attrs=['activation', 'tensor_name'],
edge_attrs=['comp_weight', 'mult_weight']
))
from netgraph.nx.nets.resnet import ResNet50
ResNet50(ng)
def extract_feature(X, cnn_arch="resnet50"):
if cnn_arch == "resnet50":
from keras.applications.resnet import preprocess_input
cnn = ResNet50(include_top=False, weights='imagenet')
elif cnn_arch == "resnet50v2":
from keras.applications.resnet_v2 import preprocess_input
cnn = ResNet50V2(include_top=False, weights='imagenet')
elif cnn_arch == "inceptionv3":
from keras.applications.inception_v3 import preprocess_input
cnn = InceptionV3(include_top=False, weights='imagenet')
X = np.array([resize(X, (299, 299, 3)) for x in X])
import ipdb
ipdb.set_trace()
else:
raise ValueError(f"Not supported cnn_arch {cnn_arch}")
input = Input(shape=X.shape[1:], name='image_input')
x = cnn(input)
x = Flatten()(x)
model = Model(inputs=input, outputs=x)
X = preprocess_input(X)
return model.predict(X, batch_size=64)
def resnet(self, epochs=100):
model = ResNet50(include_top=False,
input_shape=(self._height, self._width, 3))
last_layer = model.output
x = Flatten(name='flatten')(last_layer)
out = Dense(self._nb_classes, activation='softmax', name='fc8')(x)
train_model = Model(model.input, out)
train_model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=1e-5),
metrics=['accuracy'])
steps_per_epoch = self._train_genrator.n // self._batch_size
validation_steps = self._vali_generator.n // self._batch_size
#callbacks =[self._checkpoint, self._monitor]
callbacks = [self._checkpoint]
train_model.fit_generator(self._train_genrator,
steps_per_epoch=steps_per_epoch,
epochs=epochs,
validation_data=self._vali_generator,
validation_steps=validation_steps,
callbacks=callbacks)
def extract_features(imgs_np,
pretrained_model="resnet50",
pooling_method='avg'):
print('Input images shape: ', imgs_np.shape)
pretrained_model = pretrained_model.lower()
assert pretrained_model in ['resnet50', 'inception_v3', 'vgg19']
assert pooling_method in ['avg', 'max']
model_args = {
'weights': 'imagenet',
'include_top': False,
'input_shape': imgs_np[0].shape
}
if pretrained_model == "resnet50":
base = ResNet50(**model_args)
from keras.applications.resnet50 import preprocess_input
elif pretrained_model == "inception_v3":
base = InceptionV3(**model_args)
from keras.applications.inception_v3 import preprocess_input
elif pretrained_model == "vgg19":
base = VGG19(**model_args)
from keras.applications.vgg19 import preprocess_input
feat_extractor = create_feat_extractor(base, pooling_method=pooling_method)
imgs_np = preprocess_input(imgs_np)
embeddings_np = feat_extractor.predict(imgs_np)
print('Features shape: ', embeddings_np.shape)
return embeddings_np
def create_nn(num_classes):
print("CREATING MODEL: "+config.model_name)
model = Sequential(name=config.model_name)
if config.model_name == 'resnet50':
model.add(ResNet50(pooling='avg', weights='imagenet')) # input_shape = (224,224,3)
opt = Adam(lr=0.0001)
if config.model_name == 'inceptionv3':
model.add(InceptionV3(pooling='avg', weights='imagenet')) # input_shape = (299,299,3)
opt = Adam(lr=0.0001)
if config.model_name == 'mobilenetv2':
model.add(MobileNetV2(pooling='avg', weights='imagenet')) # input_shape = (224,224,3)
opt = Adam(lr=0.0001)
if config.model_name == 'nasnetmobile':
model.add(NASNetMobile(pooling='avg', weights='imagenet')) # input_shape = (224,224,3)
opt = Adam(lr=0.0001)
model.add(Dropout(0.2))
model.add(Dense(500, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(250, activation='relu'))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(Dense(num_classes, activation='softmax'))
# model.layers[0].trainable = False
model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
model.summary()
return model
def cnn(input_shape, kernel_shape, pool_shape, classes):
"""
Model definition. Has the following features:
- Transfer Learning
"""
embedded_dims = 512
resnet = ResNet50(input_shape=(FRAME_LENGTH, FRAME_WIDTH, CHANNELS),
weights="imagenet",
include_top=False,
pooling='avg')
for layer in resnet.layers:
layer.trainable = False
cnn = Model(inputs=resnet.input, outputs=resnet.output)
cnn.summary()
input_ = Input(shape=input_shape)
x = TimeDistributed(cnn)(input_)
x = Lambda(function=lambda x: K.mean(x, axis=1),
output_shape=lambda shape: (shape[0], ) + shape[2:])(x)
outputs = Dense(classes, name='output', activation='sigmoid')(x)
model = Model(inputs=[input_], outputs=outputs)
model.summary()
return model
def load_model(self):
FACTOR = 0.70
HEIGHT = 137
WIDTH = 236
HEIGHT_NEW = int(HEIGHT * FACTOR)
WIDTH_NEW = int(WIDTH * FACTOR)
HEIGHT_NEW = 224
WIDTH_NEW = 224
base_model=ResNet50(include_top=False, weights='imagenet', input_tensor=None, input_shape=(HEIGHT_NEW,WIDTH_NEW,3), pooling=None, classes=1000)
# base_model.trainable=False
x = base_model.output
x = layers.GlobalAveragePooling2D()(x)
grapheme_root = layers.Dense(168, activation = 'softmax', name = 'root')(x)
vowel_diacritic = layers.Dense(11, activation = 'softmax', name = 'vowel')(x)
consonant_diacritic = layers.Dense(7, activation = 'softmax', name = 'consonant')(x)
model = Model(inputs=base_model.input,outputs = [grapheme_root, vowel_diacritic, consonant_diacritic])
for layer in base_model.layers:
layer.trainable = True
model.compile(optimizer='adam', loss = {'root' : 'categorical_crossentropy',
'vowel' : 'categorical_crossentropy',
'consonant': 'categorical_crossentropy'},
loss_weights = {'root' : 0.5,
'vowel' : 0.25,
'consonant': 0.25},
metrics={'root' : 'accuracy',
'vowel' : 'accuracy',
'consonant': 'accuracy'})
# print(model.summary())
return model
def load_model(self):
base_model=ResNet50(include_top=False, weights='imagenet', input_tensor=None, input_shape=(137,236,3), pooling=None, classes=1000)
# base_model.trainable=False
x = base_model.output
x = layers.GlobalAveragePooling2D()(x)
x = layers.BatchNormalization()(x)
x = layers.Dropout(0.3)(x)
x = layers.Dense(256, activation='relu')(x)
x = layers.BatchNormalization()(x)
x = layers.Dropout(0.3)(x)
grapheme_root = layers.Dense(168, activation = 'softmax', name = 'root')(x)
vowel_diacritic = layers.Dense(11, activation = 'softmax', name = 'vowel')(x)
consonant_diacritic = layers.Dense(7, activation = 'softmax', name = 'consonant')(x)
model = Model(inputs=base_model.input,outputs = [grapheme_root, vowel_diacritic, consonant_diacritic])
for layer in base_model.layers:
layer.trainable = True
model.compile(optimizer='adam', loss = {'root' : 'categorical_crossentropy',
'vowel' : 'categorical_crossentropy',
'consonant': 'categorical_crossentropy'},
loss_weights = {'root' : 0.5,
'vowel' : 0.25,
'consonant': 0.25},
metrics={'root' : 'accuracy',
'vowel' : 'accuracy',
'consonant': 'accuracy'})
# print(model.summary())
return model
def load_pretrained_ResNet50(lay_of_interest='avg_pool',
trainable_after_layer=17):
# Todo
model = ResNet50(include_top=True, weights='imagenet')
transfer_layer = model.get_layer(lay_of_interest)
resnet50_model = Model(inputs=model.input, outputs=transfer_layer.output)
for layer in resnet50_model.layers[0:trainable_after_layer]:
layer.trainable = False
return resnet50_model
def load_classification_model():
global classification_model
global graph
global session
session = get_session()
init = tf.global_variables_initializer()
session.run(init)
graph = tf.get_default_graph()
classification_model = ResNet50(weights="imagenet")
# https://github.com/keras-team/keras/issues/6124
classification_model._make_predict_function()
def transfer2(*, input_shape = None) -> Model:
if input_shape is None:
input_shape = (None, None, 3)
resnet = ResNet50(
include_top=False,
weights='imagenet',
input_shape=input_shape,
) # type: Model
resnet.trainable = False
model = Sequential()
model.add(resnet)
model.add(Conv2DTranspose(
filters=512,
kernel_size=3,
strides=2,
padding='same',
))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Conv2DTranspose(
filters=128,
kernel_size=3,
strides=2,
padding='same',
))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Conv2DTranspose(
filters=32,
kernel_size=3,
strides=2,
padding='same',
))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Conv2D(
filters=1,
kernel_size=3,
strides=1,
padding='same',
))
return model
def create_model(img_shape=(128, 64, 3), n_att=27, n_ids=1501):
"""
INPUT
"""
img_input = Input(shape=img_shape)
cnn_backbone = ResNet50(include_top=False)(img_input)
"""
FEATURES
"""
features = Flatten()(cnn_backbone)
features = Dense(512)(features)
features = BatchNormalization()(features)
features = Dropout(0.5)(features)
features = Activation('relu', name='img_features')(features)
"""
ATTRIBUTES
"""
attributes = Dense(n_att, activation='sigmoid',
name='attributes_output')(features)
"""
REWEIGHTING
"""
attributes_r = Dense(n_att, activation='sigmoid')(attributes)
attributes_r = Multiply()([attributes, attributes_r])
"""
ID PREDICTION
"""
ids = Concatenate()([features, attributes_r])
ids = Dense(1024)(attributes)
ids = BatchNormalization()(ids)
ids = Dropout(0.5)(ids)
ids = Activation('relu')(ids)
ids = Dense(n_ids, activation='softmax', name='ids_output')(ids)
"""
FULL MODEL
"""
model = Model(inputs=img_input, outputs=[attributes, ids])
losses = {
'attributes_output': 'binary_crossentropy',
'ids_output': 'categorical_crossentropy'
}
losses_weights = {'attributes_output': 0.1, 'ids_output': 0.9}
optimizer = SGD(learning_rate=0.01)
model.compile(optimizer=optimizer,
loss=losses,
loss_weights=losses_weights,
metrics=['accuracy'])
return model
def cnn_model(model_name):
"""
Model definition using Xception net architecture
"""
if model_name == "xception":
baseModel = Xception(weights="imagenet",
include_top=False,
input_shape=(160, 160, 3))
elif model_name == "iv3":
baseModel = InceptionV3(weights="imagenet",
include_top=False,
input_shape=(160, 160, 3))
elif model_name == "irv2":
baseModel = InceptionResNetV2(weights="imagenet",
include_top=False,
input_shape=(160, 160, 3))
elif model_name == "resnet":
baseModel = ResNet50(weights="imagenet",
include_top=False,
input_shape=(160, 160, 3))
headModel = baseModel.output
headModel = MaxPooling2D(pool_size=(3, 3))(headModel)
headModel = Flatten(name="flatten")(headModel)
headModel = Dense(512, activation="relu",
kernel_initializer="he_uniform")(headModel)
headModel = Dense(512, activation="relu",
kernel_initializer="he_uniform")(headModel)
headModel = Dropout(0.5)(headModel)
headModel = Dense(512, activation="relu",
kernel_initializer="he_uniform")(headModel)
headModel = Dropout(0.5)(headModel)
predictions = Dense(2,
activation="softmax",
kernel_initializer="he_uniform")(headModel)
model = Model(inputs=baseModel.input, outputs=predictions)
for layer in baseModel.layers:
layer.trainable = True
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 gen_resnet(img_height, img_width, num_classes):
base_model = ResNet50(weights=None,
include_top=False,
input_shape=(img_height, img_width, 1))
x = base_model.layers[-1].output
x = Conv2D(filters=64, kernel_size=(3, 3), activation='relu')(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Flatten()(x)
x = Dense(256, activation='relu')(x)
x = Dense(256, activation='relu')(x)
x = Dense(256, activation='relu')(x)
predictions = Dense(num_classes, activation='softmax')(x)
return Model(inputs=base_model.input, outputs=predictions)
def make_encoder(input, name='resnet50', pretrained=True):
if name == 'resnet18':
from classification_models.keras import Classifiers
ResNet18, _ = Classifiers.get('resnet18')
model = ResNet18(
weights='imagenet' if pretrained else None,
input_tensor=input,
include_top=False
)
elif name == 'resnet50':
from keras.applications.resnet import ResNet50
model = ResNet50(
weights='imagenet' if pretrained else None,
input_tensor=input,
include_top=False
)
elif name == 'resnet101':
from keras.applications.resnet import ResNet101
model = ResNet101(
weights='imagenet' if pretrained else None,
input_tensor=input,
include_top=False
)
elif name == 'resnet152':
from keras.applications.resnet import ResNet152
model = ResNet152(
weights='imagenet' if pretrained else None,
input_tensor=input,
include_top=False
)
elif name == 'vgg16':
from keras.applications.vgg16 import VGG16
model = VGG16(
weights='imagenet' if pretrained else None,
input_tensor=input,
include_top=False
)
elif name == 'vgg19':
from keras.applications.vgg19 import VGG19
model = VGG19(
weights='imagenet' if pretrained else None,
input_tensor=input,
include_top=False
)
else:
raise Exception(f'unknown encoder {name}')
return model
def get_image_features(img_abs_path):
'''
Given the path where the image is stored,
pass it through a ResNet50 imagenet trained model and
return the features for the same
'''
model = ResNet50() # Instantiate a ResNet50 model
model.layers.pop() # Remove the last layer of pretrained ImageNet data
Image_Feature_Generator = Model(inputs = model.inputs, outputs = model.layers[-1].output) # Redefine the model after removing the last layer
img = load_img(img_abs_path, target_size = (224, 224)) # Load the image from the path and resize to (224,224) for passing it through the ResNet pretrained model
img = img_to_array(img) # Convert the image into a numpy array
rows, columns, channels = img.shape # Extract the dimensions of the image
img = img.reshape((1, rows, columns, channels)) # Redefine the image dimensions in a batch format
img = preprocess_input(img) # Preprocess the input in order to bring it in a similar format as the imagenet preprocessing steps in original ResNet architecture
features = Image_Feature_Generator.predict(img) # Generate features from the image
return features
def get_model_body(input_tensor, net='vgg16', trainable=True):
if net == config.network[0]:
pre_model = VGG16(input_tensor=input_tensor, include_top=False)
elif net == config.network[1]:
pre_model = ResNet50(input_tensor=input_tensor, include_top=False)
elif net == config.network[2]:
pre_model = InceptionV3(input_tensor=input_tensor, include_top=False)
else:
raise ValueValidException('%s not defined yet, please choose another' %
net)
# 默认是不可以训练的 如果需要训练可以放开
if not trainable:
for layer in pre_model.layers:
layer.trainable = False
model = Model(inputs=pre_model.input,
outputs=pre_model.get_layer(index=-2).output)
return model
def generate_xBD_baseline_model(dire):
#weights = dire+'/resnet50_weight.h5'
inputs = Input(shape=(128, 128, 3))
base_model = ResNet50(include_top=False,
weights=dire + '/resnet50_weight.h5')
for layer in base_model.layers:
layer.trainable = False
x = Conv2D(32, (5, 5),
strides=(1, 1),
padding='same',
activation='relu',
input_shape=(128, 128, 3))(inputs)
x = MaxPooling2D(pool_size=(2, 2),
strides=None,
padding='valid',
data_format=None)(x)
x = Conv2D(64, (3, 3), strides=(1, 1), padding='same',
activation='relu')(x)
x = MaxPooling2D(pool_size=(2, 2),
strides=None,
padding='valid',
data_format=None)(x)
x = Conv2D(64, (3, 3), strides=(1, 1), padding='same',
activation='relu')(x)
x = MaxPooling2D(pool_size=(2, 2),
strides=None,
padding='valid',
data_format=None)(x)
x = Flatten()(x)
base_resnet = base_model(inputs)
base_resnet = Flatten()(base_resnet)
concated_layers = concatenate([x, base_resnet])
concated_layers = Dense(2024, activation='relu')(concated_layers)
concated_layers = Dense(524, activation='relu')(concated_layers)
concated_layers = Dense(124, activation='relu')(concated_layers)
output = Dense(4, activation='softmax')(concated_layers)
model = Model(inputs=inputs, outputs=output)
return model
def create_model(input_shape=(92, 92, 3),
n_radiomics=len(r_train[0]),
n_clinicals=len(c_train[0])):
"""
SCANS
"""
scans_input = ResNet50(input_shape=input_shape, include_top=False)
scans_features = Flatten()(scans_input.output)
scans_features = Dropout(0.5)(scans_features)
scans_features = Dense(64)(scans_features)
scans_features = BatchNormalization()(scans_features)
scans_features = Activation('relu')(scans_features)
"""
RADIOMICS DATA
"""
rad_input = Input(shape=(n_radiomics, ))
rad_features = Dense(n_radiomics)(rad_input)
rad_features = BatchNormalization()(rad_features)
rad_features = Dropout(0.5)(rad_features)
rad_features = Activation('relu')(rad_features)
"""
CLINICALS DATA
"""
cl_input = Input(shape=(n_clinicals, ))
cl_features = Dense(n_clinicals)(cl_input)
cl_features = BatchNormalization()(cl_features)
cl_features = Dropout(0.5)(cl_features)
cl_features = Activation('relu')(cl_features)
hazard = Concatenate()([scans_features, rad_features, cl_features])
hazard = Dropout(0.2)(hazard)
hazard = Dense(64)(hazard)
hazard = BatchNormalization()(hazard)
hazard = Activation('relu')(hazard)
hazard = Dense(10)(hazard)
model_output = Dense(1)(hazard)
model_output = Activation('linear')(model_output)
model = Model(inputs=[scans_input.input, rad_input, cl_input],
outputs=model_output)
model.compile(optimizer='rmsprop',
loss=negative_log_likelihood(events_train))
model.summary()
return model
def build_resnet_model(initializer=None):
base_model = ResNet50(include_top=False,
pooling='max',
weights="imagenet",
input_shape=(224, 224, 3))
model = Sequential()
model.add(base_model)
model.add(Flatten())
model.add(Dropout(0.2))
model.add(Dense(256, activation='relu', kernel_initializer=initializer))
model.add(Dropout(0.2))
model.add(Dense(6, activation='softmax', kernel_regularizer=l1(0.01)))
model.summary()
opt = SGD(lr=0.001, momentum=0.6)
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def prep_model(weight=None):
"""
Loads a model for tile encoding. This function
can optionnaly take a different weight path to load.
Parameters
----------
weight: string,
path to weight folder
Returns
-------
A keras model to encode.
"""
shape = (224, 224, 3)
model = ResNet50(include_top=False,
weights="imagenet",
input_shape=shape,
pooling='avg')
if weight != "imagenet":
print('loading')
model.load_weights(weight, by_name=True)
return model
def UNetFromResNet(input_shape=(256, 256, 3), n_classes=3):
#This models a decoder block
def DecoderBlock(filters, x, skip):
x = UpSampling2D(size=2)(x)
# print(skip.output_shape)
x = Concatenate()([x, skip])
x = Conv2D(filters, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
x = Conv2D(filters, (3, 3), activation='relu', padding='same')(x)
x = BatchNormalization()(x)
return x
backbone = ResNet50(input_shape=input_shape,
include_top=False,
weights='imagenet',
pooling='avg')
model_input = backbone.input
#We eliminate the last average pooling
x = backbone.layers[-2].output
#Layers were we are going to do skip connections.
feature_layers = [142, 80, 38, 4, 0]
filters = [1024, 512, 256, 64, 32]
for i in range(len(feature_layers)):
skip = backbone.layers[feature_layers[i]].output
x = DecoderBlock(filters[i], x, skip)
#Final Convolution
x = Conv2D(n_classes, (3, 3), activation='sigmoid', padding='same')(x)
model_output = x
model = Model(model_input, model_output)
return model
def ResNet(input_shape = (const.X_Height, const.X_Width, const.X_Channels), classes = const.Y_Classes, Layers = 50, source = 'keras', weights = 'imagenet'):
"""
create RestNet model
Arguments:
input_shape = Height, Width and channels for each input image
classes = how many classes model will be trainned on
Layers: how many layers; should be one of [18, 34, 50, 101, 152]
source: 'keras' (use built-in model) or 'manual' (use my custom model above)
weights: 'imagenet' (load weights from keras lib) or None (no weights loading)
'imagenet' only available if layers in [50,101,152]
"""
# validate parameters
if (Layers not in [18, 34, 50, 101, 152]):
raise ValueError('Invalid layer number: ' + str(Layers) + ' (must be one of [18, 34, 50, 101, 152]).')
if (source not in ['keras', 'manual']):
raise ValueError('Invalid model source: ' + str(source) + " (must be 'keras' or 'manual'.")
if (weights not in [None, 'imagenet']):
raise ValueError('Invalid weights definition: ' + str(weights) + " (must be None or 'imagenet'.")
if (Layers in [18, 34]):
if (source == 'keras'):
raise ValueError("No keras model available for small ResNets. 'source' parameter must be 'manual' when layers are 18 or 34.")
if (weights != None):
raise ValueError("No weights available for small ResNets. 'weights' Parameter must be None when layers are 18 or 34.")
# build model
if (source == 'keras'):
# load base model from keras
if (Layers == 50):
from keras.applications.resnet import ResNet50
baseModel = ResNet50(include_top = False, weights = weights, input_shape = input_shape)
elif (Layers == 101):
from keras.applications.resnet import ResNet101
baseModel = ResNet101(include_top = False, weights = weights, input_shape = input_shape)
elif (Layers == 152):
from keras.applications.resnet import ResNet152
baseModel = ResNet152(include_top = False, weights = weights, input_shape = input_shape)
elif (source == 'manual'):
# load model from my implementation
if (Layers in [18,34]):
baseModel = ResNetSmall(input_shape=input_shape, classes=classes, Layers=Layers)
else:
baseModel = ResNetLarge(input_shape=input_shape, classes=classes, Layers=Layers, weights=weights)
# add final layers to built-in keras model
from keras.models import Model
from keras.layers import Dense, Flatten, AveragePooling2D
X = baseModel.output
X = AveragePooling2D(pool_size=(2, 2), strides=None, padding='valid', data_format=None)(X)
X = Flatten()(X)
Preds = Dense(const.Y_Classes, activation='softmax', name='fc' + str(const.Y_Classes))(X)
model = Model(inputs=baseModel.input, outputs=Preds)
# return the model
return model
def load_model(name, classes=2, dropout=0.5, batch_size=6):
if name == 'resnet50':
basemodel = ResNet50(include_top=False, weights='imagenet', pooling='avg', classes=classes)
# construct the head of the model that will be placed on top of the
# the base model
headModel = Dense(512, activation="relu")(basemodel.output)
headModel = Dropout(0.5)(headModel)
headModel = Dense(classes, activation="softmax")(headModel)
model = Model(inputs=basemodel.input, outputs=headModel)
elif name == 'resnet50conv':
basemodel = ResNet50(include_top=False, weights='imagenet', pooling=None, classes=classes)
headModel = Conv2D(512, (7,7), activation='relu')(basemodel.output)
if dropout:
headModel = Dropout(dropout)(headModel)
headModel = Conv2D(512, (1,1), activation='relu')(headModel)
if dropout:
headModel = Dropout(dropout)(headModel)
headModel = Conv2D(classes, (1,1), activation='softmax')(headModel)
model = Model(inputs=basemodel.input, outputs=headModel)
elif name == 'resnet50convflat':
basemodel = ResNet50(input_shape=(),
include_top=False,
weights='imagenet',
pooling=None,
classes=classes)
headModel = Conv2D(512, (7,7), activation='relu')(basemodel.output)
if dropout:
headModel = Dropout(dropout)(headModel)
headModel = Conv2D(512, (1,1), activation='relu')(headModel)
if dropout:
headModel = Dropout(dropout)(headModel)
headModel = Conv2D(classes, (1,1), activation='softmax')(headModel)
# headModel = Flatten()(headModel)
headModel = Lambda(lambda x: x[:,0,0,:], input_shape=(batch_size, classes))(headModel)
model = Model(inputs=basemodel.input, outputs=headModel)
elif name == 'resnet50convflatfreeze':
basemodel = ResNet50(input_shape=(),
include_top=False,
weights='imagenet',
pooling=None,
classes=classes)
headModel = Conv2D(512, (7,7), activation='relu')(basemodel.output)
if dropout:
headModel = Dropout(dropout)(headModel)
headModel = Conv2D(512, (1,1), activation='relu')(headModel)
if dropout:
headModel = Dropout(dropout)(headModel)
headModel = Conv2D(classes, (1,1), activation='softmax')(headModel)
# headModel = Flatten()(headModel)
headModel = Lambda(lambda x: x[:,0,0,:], input_shape=(batch_size, classes))(headModel)
model = Model(inputs=basemodel.input, outputs=headModel)
for layer in model.layers[4:-4]:
layer.trainable = False
elif name == 'custom_simple':
pass
return model
parser.add_argument(
'--batch_size',
type=int,
default=64,
help='Training batch size (larger batches are usually more efficient on GPUs)',
)
flags = parser.parse_args()
return flags
flags = parse_args()
num_classes = 7 # number of classes
epochs = 20
model = Sequential()
resNet = ResNet50(include_top=False, pooling='avg', weights='imagenet') # pretrained model
# froze layers in resnet
if flags.layers_fine_tune != 0:
layers_fine_tune = -flags.layers_fine_tune
for layer in resNet.layers[:layers_fine_tune]:
layer.trainable = False
else:
for layer in resNet.layers:
layer.trainable = False
model.add(resNet)
model.add(Dense(num_classes, activation='softmax')) # Classification layer
# Compiling the model
adam = Adam(lr=flags.learning_rate)
model.compile(optimizer=adam, loss='categorical_crossentropy', metrics=['accuracy'])
model = imagenet_model(base_model=mod)
#train
H = model.fit(
trainX, trainY,
validation_data=(testX, testY),
epochs=EPOCHS,
verbose=0)
histories.append(H)
X,Y = next(imagenet_gen)
trainX, testX, trainY, testY = train_test_split(X, Y, test_size=0.25)
from keras.layers import GlobalAveragePooling2D
import tensorflow.keras.backend as K
baseModel = ResNet50(weights="imagenet", include_top=False,
input_tensor=Input(shape=(224, 224, 3)),layers=tf.keras.layers)
for layer in model.layers:
if hasattr(layer, 'moving_mean') and hasattr(layer, 'moving_variance'):
layer.trainable = True
K.eval(K.update(layer.moving_mean, K.zeros_like(layer.moving_mean)))
K.eval(K.update(layer.moving_variance, K.ones_like(layer.moving_variance)))
else:
layer.trainable = False
headModel = baseModel.output
headModel = AveragePooling2D()(headModel)
headModel = Flatten(name="flatten")(headModel)
headModel = Dense(2, activation="softmax")(headModel)
model = Model(inputs=baseModel.input, outputs=headModel)
opt = Adam(lr=1e-5, decay=INIT_LR / EPOCHS)
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
from keras.optimizers import Adam from keras.applications import NASNetLarge #setting train, validation and test dataset path train_data_path = 'sanket/train' validation_data_path = 'sanket/valid' test_data_path = 'sanket_test/test' #Setting some parameters for training the model batch_size = 8 NUM_CLASSES = 1 img_rows, img_cols = 512, 512 img_channels = 3 #loading Resnet50 from keras application with imagenet weights base_model = ResNet50(include_top=False, weights="imagenet") #adding few more layers to make the model work according to current problem statement x = base_model.output x = GlobalAveragePooling2D()(x) x = (Dropout(0.5))(x) # let's add a fully-connected layer x = Dense(512, activation='relu')(x) predictions = Dense(1, activation='sigmoid')(x) #join all the layers and create a fully connected layer model = Model(inputs=base_model.input, outputs=predictions) #Setting train, validation and test Image generator
print('y_train shape:', y_train.shape)
# Convert class vectors to binary class matrices.
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
if args.resume:
print('resume from checkpoint')
model = keras.models.load_model(save_file)
else:
print('train from start')
model = models.Sequential()
if '50' in args_model:
base_model = ResNet50(weights=None,
include_top=False,
input_shape=(32, 32, 3),
pooling=None)
elif '101' in args_model:
base_model = ResNet101(weights=None,
include_top=False,
input_shape=(32, 32, 3),
pooling=None)
elif '152' in args_model:
base_model = ResNet152(weights=None,
include_top=False,
input_shape=(32, 32, 3),
pooling=None)
#base_model.summary()
#pdb.set_trace()
broj_na_klasi = 133 # broj na klasi
"""# Create your model architecture"""
from keras.applications.xception import Xception
from keras.applications.densenet import DenseNet169
from keras.applications.resnet import ResNet50
from keras.models import Model
from keras.layers import Dense, Activation, Conv2D, Flatten, MaxPooling2D, AveragePooling2D, Dropout, GlobalAveragePooling2D
from keras.layers.normalization import BatchNormalization
from keras.models import Sequential
# YOUR ARCHITECTURE HERE
model = Sequential()
model = ResNet50(include_top=False, input_shape=(224,224,3), weights='imagenet')
#layer = model.get_layer('conv3_block1_1_conv')
av_pool = GlobalAveragePooling2D()(model.output)
class1 = Dense(490, activation='relu')(av_pool)
normaliz = BatchNormalization()(class1)
class2 = Dense(520, activation='relu')(normaliz)
normaliz1 = BatchNormalization()(class2)
outputs = Dense(133, activation='softmax')(normaliz1)
model = Model(inputs=model.inputs, outputs=outputs)
model.summary()
"""# Print summary of your model"""
