def eval_it():
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
import argparse
parser = argparse.ArgumentParser(description='Train model your dataset')
parser.add_argument('--test_file',
default='test_pair.txt',
help='your train file',
type=str)
parser.add_argument('--model_weights',
default='result_PFA_FLoss/PFA_00500.h5',
help='your model weights',
type=str)
batch_size = 32
args = parser.parse_args()
model_name = args.model_weights
test_path = args.test_file
HOME = os.path.expanduser('~')
test_folder = os.path.join(
HOME,
'../ads-creative-image-algorithm/public_data/datasets/SalientDataset/DUTS/DUTS-TE'
)
if not os.path.exists(test_path):
ge_train_pair(test_path, test_folder, "DUTS-TE-Image", "DUTS-TE-Mask")
target_size = (256, 256)
f = open(test_path, 'r')
testlist = f.readlines()
f.close()
steps_per_epoch = len(testlist) / batch_size
optimizer = optimizers.SGD(lr=1e-2, momentum=0.9, decay=0)
loss = EdgeHoldLoss
metrics = [acc, pre, rec, F_value, MAE]
with_crf = False
draw_bound = False
draw_poly = False
draw_cutout = False
dropout = False
with_CPFE = True
with_CA = True
with_SA = True
if target_size[0] % 32 != 0 or target_size[1] % 32 != 0:
raise ValueError('Image height and wight must be a multiple of 32')
testgen = getTestGenerator(test_path, target_size, batch_size)
model_input = Input(shape=(target_size[0], target_size[1], 3))
model = VGG16(model_input,
dropout=dropout,
with_CPFE=with_CPFE,
with_CA=with_CA,
with_SA=with_SA)
model.load_weights(model_name, by_name=True)
for layer in model.layers:
layer.trainable = False
model.compile(optimizer=optimizer, loss=loss, metrics=metrics)
evalSal = model.evaluate_generator(testgen, steps_per_epoch - 1, verbose=1)
print(evalSal)
def create_sequential_model():
model = models.Sequential() # define a Sequential model
# adding the convelution layer
# is a 2d layer with shape (3,3)
# use the activation function rectified linear activation unit (ReLU)
# this layer summarize the presence of features in an input image
# results the down sampled feature maps to be the input for next layer
# each feature map contain the precise position of features in the input image.
model.add(
layers.Conv2D(23, (3, 3), activation="relu", input_shape=(28, 28, 1)))
# add pooling layer after theconvelution layer
# pooling layer create a new set of the same number of pooled feature maps.
# the pooled feature map size is less than the input maps.
model.add(layers.MaxPooling2D(pool_size=(2, 2)))
# Flatten layer: doesnot change the number of pooled feature map
# maps is converted to 1d lists
model.add(layers.Flatten())
# ???
model.add(layers.Dense(100, activation='relu'))
# adding the output layer with 10 nodes (0-9 classes)
model.add(layers.Dense(10, activation='softmax'))
# creat a gradient decent optimizer with learning rate equals 0.01
opt = optimizers.SGD(lr=0.003)
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def __init__(self, gui=0, training=1):
self.gui = gui
if gui:
self.gui = widgets.VBox(children=[
self.tab, self.progress_box, self.out_initial, self.out,
self.out_stats
])
display(self.init_gui())
# Images
self.test_class_indices = []
self.test_dir = None
self.init_images()
self.sgd = optimizers.SGD(lr=0.01,
decay=1e-6,
momentum=0.9,
nesterov=True)
self.predicted_class_indices_init = []
self.wrong_guesses = []
self.train_button.disabled = False
self.fine_tune_button.disabled = False
self.init_model()
if training:
self.train_model(self.train_button)
def instantiate_model(self):
self.model = create_model_resnet(
self.input_shape,
n_output=self.n_output,
normalize=self.normalize,
kernel_shape=self.kernel_shape,
size_blocks=self.size_blocks,
resnet=self.resnet,
dropout=self.dropout,
n_channels_by_block=self.n_channels_by_block,
size_dense=self.size_dense,
average_pooling=self.average_pooling,
separable_conv=self.separable_conv)
print(self.model.summary())
self.optimizer = optimizers.Adamax(lr=self.lr) if self.optimizer == 'adamax' \
else optimizers.RMSprop(lr=self.lr) if self.optimizer == 'rmsprop' \
else optimizers.SGD(lr=self.lr, momentum=.9) if self.optimizer == 'sgd' \
else optimizers.Adam(lr=self.lr) if self.optimizer == 'adam' else None
if self.zoom:
self.datagen = ImageDataGenerator(rotation_range=10,
width_shift_range=0.1,
height_shift_range=0.1,
zoom_range=0.1,
horizontal_flip=True,
fill_mode='nearest')
elif self.shift:
self.datagen = ImageDataGenerator(width_shift_range=0.1,
height_shift_range=0.1,
fill_mode='nearest')
elif self.flip:
self.datagen = ImageDataGenerator(horizontal_flip=bool(self.flip))
else:
self.datagen = None
def __init__(self, verbose=0, test=0):
self.verbose = verbose
self.test = test
if verbose:
self.gui = widgets.VBox(children=[
self.tab, self.progress_box, self.out_initial, self.out,
self.out_stats
])
# Images
self.test_class_indices = []
self.test_dir = None
self.init_images()
self.sgd = optimizers.SGD(lr=0.01,
decay=1e-6,
momentum=0.9,
nesterov=True)
self.predicted_class_indices_init = []
self.wrong_guesses = []
if not test:
display(self.init_gui())
self.train_button.disabled = False
self.fine_tune_button.disabled = False
self.init_model()
def create_model():
conv_base = ResNet50(weights='imagenet',
include_top=False,
input_shape=INPUT_SHAPE)
conv_base.trainable = False
model = models.Sequential()
model.add(conv_base)
model.add(layers.GlobalAveragePooling2D())
model.add(
layers.Dense(512,
activation='relu',
kernel_initializer='uniform',
kernel_regularizer=reg))
model.add(layers.Dropout(0.5))
model.add(
layers.Dense(512,
activation='relu',
kernel_initializer='uniform',
kernel_regularizer=reg))
model.add(layers.Dropout(0.5))
model.add(
layers.Dense(2,
activation='softmax',
kernel_initializer='uniform',
kernel_regularizer=reg))
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.SGD(lr=LEARN_RATE, momentum=0.9),
metrics=['accuracy'])
model.summary()
return model
def main(args):
# (train_x, train_y), (test_x, test_y) = iris_data.load_data()
data = load_iris()
# print(type(data))
# print(data.keys())
train_x, test_x, train_y, test_y = train_test_split(data["data"],
data["target"],
train_size=0.7)
train_y = tf.keras.utils.to_categorical(train_y, num_classes=4)
test_y = tf.keras.utils.to_categorical(test_y, num_classes=4)
model = models.Sequential()
model.add(
layers.Dense(units=32, activation=activations.relu, input_shape=(4, )))
model.add(layers.Dense(units=32, activation=activations.relu))
model.add(layers.Dense(units=4, activation=activations.softmax))
model.compile(optimizer=optimizers.SGD(),
loss=losses.categorical_crossentropy,
metrics=[metrics.categorical_accuracy])
model.summary()
iris_est = tf.keras.estimator.model_to_estimator(model,
model_dir="./models/")
iris_est.train(input_fn=lambda: my_train_input_fn(train_x, train_y, 30),
steps=100)
result = iris_est.evaluate(
input_fn=lambda: my_eval_input_fn(test_x, test_y, 30))
print(result)
def kerasModel(train_x, test_x, train_y, test_y):
model = Sequential()
model.add(Conv2D(24, (5, 5), strides=(2, 2), activation="relu", input_shape=(128, 64, 3)))
model.add(Conv2D(36, (5, 5), strides=(2, 2), activation="relu"))
model.add(Conv2D(48, (5, 5), strides=(2, 2), activation="relu"))
model.add(Conv2D(64, (3, 3), strides=(2, 2), activation="relu"))
model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(64, activation="relu"))
model.add(Dense(32, activation="relu"))
model.add(Dense(1, activation="relu"))
model.add(Activation('softmax'))
sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='mse', optimizer=sgd, metrics=['accuracy'])
model.fit(train_x, train_y, epochs=5)
# model.compile(loss='mse', optimizer=Adam(lr=0.01, decay=1e-6),metrics=[get_categorical_accuracy_keras])
# model.fit(train_x,train_y, shuffle=True, nb_epoch=5)
score = model.evaluate(test_x, test_y, verbose=0)
print("Accuracy: %.2f%%" % (score[1] * 100))
return score[1] * 100
def testNumericEquivalenceForNesterovMomentum(self):
if testing_utils.should_run_tf_function() or context.executing_eagerly():
self.skipTest(
'v1 optimizer does not run in experimental_run_tf_function mode or '
'eager mode')
np.random.seed(1331)
with self.cached_session():
train_samples = 20
input_dim = 3
num_classes = 2
(x, y), _ = testing_utils.get_test_data(
train_samples=train_samples,
test_samples=10,
input_shape=(input_dim,),
num_classes=num_classes)
y = keras.utils.to_categorical(y)
num_hidden = 5
model_k_v1 = testing_utils.get_small_sequential_mlp(
num_hidden=num_hidden, num_classes=num_classes, input_dim=input_dim)
model_k_v2 = testing_utils.get_small_sequential_mlp(
num_hidden=num_hidden, num_classes=num_classes, input_dim=input_dim)
model_k_v2.set_weights(model_k_v1.get_weights())
model_tf = testing_utils.get_small_sequential_mlp(
num_hidden=num_hidden, num_classes=num_classes, input_dim=input_dim)
model_tf.set_weights(model_k_v2.get_weights())
opt_k_v1 = optimizers.SGD(momentum=0.9, nesterov=True)
opt_k_v2 = gradient_descent.SGD(momentum=0.9, nesterov=True)
opt_tf = momentum.MomentumOptimizer(
learning_rate=0.01, momentum=0.9, use_nesterov=True)
model_k_v1.compile(
opt_k_v1,
loss='categorical_crossentropy',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
model_k_v2.compile(
opt_k_v2,
loss='categorical_crossentropy',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
model_tf.compile(
opt_tf,
loss='categorical_crossentropy',
metrics=[],
run_eagerly=testing_utils.should_run_eagerly(),
experimental_run_tf_function=testing_utils.should_run_tf_function())
hist_k_v1 = model_k_v1.fit(x, y, batch_size=5, epochs=10, shuffle=False)
hist_k_v2 = model_k_v2.fit(x, y, batch_size=5, epochs=10, shuffle=False)
hist_tf = model_tf.fit(x, y, batch_size=5, epochs=10, shuffle=False)
self.assertAllClose(model_k_v1.get_weights(), model_tf.get_weights())
self.assertAllClose(model_k_v1.get_weights(), model_k_v2.get_weights())
self.assertAllClose(opt_k_v1.get_weights(), opt_k_v2.get_weights())
self.assertAllClose(hist_k_v1.history['loss'], hist_tf.history['loss'])
self.assertAllClose(hist_k_v1.history['loss'], hist_k_v2.history['loss'])
def compile_keras_model(model, optimizer, learning_rate):
'''
Method that takes in input a model and compile it using the specific optimizer. The model is compiled
with sparse_categorical_crossentropy as loss function.
:param model: the tensorflow.keras.model implemented.
:param optimizer: there are several options: 1)sgd ; 2)Adam( I used principally for the training)
3) adadelta
:param learning_rate: float that indicates the learning rate to use with the optimizer.
:return: the model compiled.
'''
if (str.lower(optimizer) == "sgd"):
opt = optimizers.SGD(lr=learning_rate,
clipnorm=0.1,
momentum=0.95,
nesterov=True)
elif (str.lower(optimizer) == "adam"):
opt = optimizers.Adam(lr=learning_rate)
elif (str.lower(optimizer) == "adadelta"):
opt = optimizers.adadelta(lr=learning_rate)
sess = K.get_session()
init = tf.global_variables_initializer()
sess.run(init)
model.compile(loss='sparse_categorical_crossentropy',
optimizer=opt,
metrics=["acc"])
return model
def compiling(self, model):
sgd=optimizers.SGD(lr=0.01,decay=1e-6,momentum=0.9,nesterov=True)
model.compile(loss=categorical_crossentropy,optimizer=sgd,metrics=['accuracy'])
#model.compile(optimizer='adam', loss=categorical_crossentropy, metrics=['accuracy'])
#model.compile(optimizer='adam', loss=categorical_crossentropy, metrics=[self.top_2_categorical_accuracy])
#kCA- K.mean(K.equal(K.argmax(y_true, axis=-1), K.argmax(y_pred, axis=-1)))
return model
def test_pass_invalid_optimizer_with_loss_scaling(self):
with policy.policy_scope(policy.Policy('float32', loss_scale=10.)):
x = layers.Input(shape=(1, ))
y = AddLayer()(x)
model = models.Model(x, y)
with self.assertRaisesRegexp(ValueError,
'optimizer" must be an instance of '):
model.compile(optimizers.SGD(1.), 'mse')
def testOptimizersCompatibility(self, opt_str, test_weights, test_numeric):
np.random.seed(1331)
with self.cached_session():
train_samples = 20
input_dim = 3
num_classes = 2
(x,
y), _ = testing_utils.get_test_data(train_samples=train_samples,
test_samples=10,
input_shape=(input_dim, ),
num_classes=num_classes)
y = keras.utils.to_categorical(y)
num_hidden = 5
model = testing_utils.get_small_sequential_mlp(
num_hidden=num_hidden,
num_classes=num_classes,
input_dim=input_dim)
old_mode = os.environ.get('TF2_BEHAVIOR', None)
# Disable tf2 to create V1 optimizer.
disable_tf2()
if opt_str == 'momentum':
opt_v1 = optimizers.SGD(momentum=0.9)
else:
opt_v1 = optimizers.get(opt_str)
# Test compile and fit with v1 optimizer.
model.compile(opt_v1, loss='categorical_crossentropy', metrics=[])
model.fit(x, y, batch_size=5, epochs=1)
model_dir = tempfile.mkdtemp()
gfile.MakeDirs(model_dir)
file_name = os.path.join(model_dir, 'model.h5')
model.save(file_name)
enable_tf2()
# Test load and fit with v2 optimizer.
model_2 = saving.load_model(file_name)
opt_v2 = model_2.optimizer
self.assertIsInstance(opt_v2, optimizer_v2.OptimizerV2)
# set_weights is called inside load_model but exception is swallowed,
# this call checks the weights can be set correctly.
if test_weights:
opt_v2.set_weights(opt_v1.get_weights())
if test_numeric:
hist_1 = model.fit(x, y, batch_size=5, epochs=1, shuffle=False)
hist_2 = model_2.fit(x,
y,
batch_size=5,
epochs=1,
shuffle=False)
self.assertAllClose(model.get_weights(), model_2.get_weights())
self.assertAllClose(model.get_weights(), model_2.get_weights())
self.assertAllClose(hist_1.history['loss'],
hist_2.history['loss'])
if old_mode is not None:
os.environ['TF2_BEHAVIOR'] = old_mode
def compile(keras_model,
lr,
momentum,
clipnorm,
weight_decay,
loss_weights={}):
"""
编译模型，增加损失函数，L2正则化以
:param keras_model:
:param lr:
:param momentum:
:param clipnorm:
:param weight_decay
:param loss_weights:
:return:
"""
# 优化目标
optimizer = optimizers.SGD(lr=lr, momentum=momentum, clipnorm=clipnorm)
# 增加损失函数，首先清除之前的，防止重复
keras_model._losses = []
keras_model._per_input_losses = {}
loss_names = loss_weights.keys()
for name in loss_names:
layer = keras_model.get_layer(name)
if layer is None or layer.output in keras_model.losses:
continue
loss = (tf.reduce_mean(layer.output, keepdims=True) *
loss_weights.get(name, 1.))
keras_model.add_loss(loss)
# 增加L2正则化
# 跳过批标准化层的 gamma 和 beta 权重
reg_losses = [
regularizers.l2(weight_decay)(w) for w in keras_model.trainable_weights
if 'gamma' not in w.name and 'beta' not in w.name
]
keras_model.add_loss(tf.add_n(reg_losses))
# 编译
keras_model.compile(optimizer=optimizer,
loss=[None] * len(keras_model.outputs)) # 使用虚拟损失
# 为每个损失函数增加度量
for name in loss_names:
if name in keras_model.metrics_names:
continue
layer = keras_model.get_layer(name)
if layer is None:
continue
loss = (tf.reduce_mean(layer.output, keepdims=True) *
loss_weights.get(name, 1.))
keras_model.add_metric(loss, aggregation='mean', name=name)
# 正则化增加度量
keras_model.add_metric(tf.add_n(reg_losses),
aggregation='mean',
name='regular_loss')
def compile_model(model,
optimizer='adam',
loss='bce-dice',
threshold=0.5,
dice=False,
weight_decay=0.0,
exclude_bn=True,
deep_supervised=False):
if loss == 'bce':
_loss = weighted_binary_crossentropy
elif loss == 'bce-dice':
_loss = weighted_bce_dice_loss
elif loss == 'lovasz':
_loss = weighted_lovasz_hinge
elif loss == 'lovasz-dice':
_loss = weighted_lovasz_dice_loss
elif loss == 'lovasz-inv':
_loss = weighted_lovasz_hinge_inversed
elif loss == 'lovasz-double':
_loss = weighted_lovasz_hinge_double
if weight_decay != 0.0:
_l2_loss = l2_loss(weight_decay, exclude_bn)
loss = lambda true, pred: _loss(true, pred) + _l2_loss
else:
loss = _loss
if optimizer == ('msgd'):
optimizer = optimizers.SGD(momentum=0.9)
if not deep_supervised:
model.compile(optimizer=optimizer,
loss=loss,
metrics=get_metrics(threshold))
else:
loss_pixel = loss_noempty(loss)
losses = {
'output_final': loss,
'output_pixel': loss_pixel,
'output_image': bce_with_logits
}
loss_weights = {
'output_final': 1.0,
'output_pixel': 0.5,
'output_image': 0.1
}
metrics = {
'output_final': get_metrics(threshold),
'output_pixel': get_metrics(threshold),
'output_image': accuracy_with_logits
}
model.compile(optimizer=optimizer,
loss=losses,
loss_weights=loss_weights,
metrics=metrics)
return model
def test_pass_invalid_optimizer_with_loss_scaling(self):
with policy.policy_scope(policy.Policy('float32', loss_scale=10.)):
x = layers.Input(shape=(1, ))
y = mp_test_util.MultiplyLayer()(x)
model = models.Model(x, y)
if context.executing_eagerly():
error_msg = 'Use a `tf.keras` Optimizer instead'
else:
error_msg = 'optimizer" must be an instance of '
with self.assertRaisesRegexp(ValueError, error_msg):
model.compile(optimizers.SGD(1.), 'mse')
def main(args):
set_gpu_growth()
dataset = VocDataset(cfg.voc_path, class_mapping=cfg.class_mapping)
dataset.prepare()
train_img_info = [info for info in dataset.get_image_info_list() if info.type == 'trainval'] # 训练集
print("train_img_info:{}".format(len(train_img_info)))
test_img_info = [info for info in dataset.get_image_info_list() if info.type == 'test'] # 测试集
print("test_img_info:{}".format(len(test_img_info)))
m = ssd_model(cfg.feature_fn, cfg.cls_head_fn, cfg.rgr_head_fn, cfg.input_shape,
cfg.num_classes, cfg.specs, cfg.max_gt_num,
cfg.positive_iou_threshold, cfg.negative_iou_threshold,
cfg.negatives_per_positive, cfg.min_negatives_per_image)
# 加载预训练模型
init_epoch = args.init_epoch
if args.init_epoch > 0:
text = '{}-{}-{}'.format(cfg.base_model_name, args.batch_size, args.lr)
m.load_weights('/tmp/ssd-{}.{:03d}.h5'.format(text, init_epoch), by_name=True)
else:
m.load_weights(cfg.pretrained_weight_path, by_name=True)
# 生成器
transforms = TrainAugmentation(cfg.image_size, cfg.mean_pixel, cfg.std)
train_gen = Generator(train_img_info,
transforms,
cfg.input_shape,
args.batch_size,
cfg.max_gt_num)
# 生成器
val_trans = TrainAugmentation(cfg.image_size, cfg.mean_pixel, cfg.std)
val_gen = Generator(test_img_info,
val_trans,
cfg.input_shape,
args.batch_size,
cfg.max_gt_num)
optimizer = optimizers.SGD(
lr=args.lr, momentum=args.momentum,
clipnorm=args.clipnorm)
m.compile(optimizer=optimizer,
loss={"class_loss": lambda y_true, y_pred: y_pred,
"bbox_loss": lambda y_true, y_pred: y_pred})
m.summary()
# 训练
m.fit_generator(train_gen,
epochs=args.epochs,
verbose=1,
initial_epoch=init_epoch,
validation_data=val_gen,
use_multiprocessing=False,
workers=10,
callbacks=get_call_back(args.lr, args.batch_size))
def init_model(self,
input_shape,
num_classes,
**kwargs):
model = Sequential()
model.add(Conv2D(100, (3, 1), input_shape=input_shape, padding='same'))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(3, 1), strides=2, padding='same'))
model.add(Conv2D(64, (3, 1), padding='same'))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 1), strides=2, padding='same'))
model.add(Conv2D(128, (3, 1), padding='same'))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 1), strides=2, padding='same'))
model.add(Conv2D(128, (3, 1), padding='same'))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 1), strides=2, padding='same'))
model.add(Conv2D(128, (3, 1), padding='same'))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 1), strides=2, padding='same'))
model.add(Conv2D(128, (3, 1), padding='same'))
model.add(Activation('relu'))
model.add(BatchNormalization())
model.add(MaxPooling2D(pool_size=(2, 1), strides=2, padding='same'))
model.add(Flatten())
model.add(Dropout(rate=0.5))
model.add(Dense(1024, 'relu'))
model.add(Dropout(rate=0.5))
model.add(Dense(512, activation='relu'))
model.add(Dense(num_classes))
model.add(Activation('softmax'))
optimizer = optimizers.SGD(
lr=1e-4, decay=5e-5, momentum=0.9, clipnorm=4)
model.compile(loss='sparse_categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
model.summary()
self._model = model
self.is_init = True
def analyze(self):
# Transform inputs into numpy arrays (?)
Inputs = np.asarray(self.Inputs)
Targets = np.asarray(self.Targets)
# TODO: create layers with push and a for
# Create the model of layers
model = Sequential([
keras.layers.Dense(self.inputsize,
activation=tf.nn.sigmoid,
input_dim=self.inputsize),
keras.layers.Dense(self.middlesize, activation=tf.nn.tanh),
keras.layers.Dense(self.middlesize, activation=tf.nn.tanh),
keras.layers.Dense(self.outputize, activation=tf.nn.sigmoid)
])
sgd = optimizers.SGD(lr=self.lr,
decay=1e-6,
momentum=0.9,
nesterov=True)
model.compile(optimizer=sgd,
loss='mean_squared_error',
metrics=['accuracy'])
# Create a model
history = model.fit(Inputs, Targets, epochs=self.epochs)
test = np.asarray(self.test)
predictions = model.predict(test)
print("Estimaciones = ")
print(predictions)
print(np.round(predictions, 2))
# summarize history for accuracy
plt.plot(history.history['acc'])
#plt.plot(history.history['val_acc'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.show()
# summarize history for loss
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()
def testInvalidConstructorArguments(self):
with self.assertRaisesRegexp(ValueError,
'must be an instance of OptimizerV2'):
loss_scale_optimizer.LossScaleOptimizer(optimizers.SGD(), 10.)
with self.assertRaisesRegexp(ValueError, 'does not support wrapping '
'optimizers with a clipnorm'):
loss_scale_optimizer.LossScaleOptimizer(
gradient_descent.SGD(1.0, clipnorm=1.0), 10.)
with self.assertRaisesRegexp(ValueError, 'does not support wrapping '
'optimizers with a clipvalue'):
loss_scale_optimizer.LossScaleOptimizer(
gradient_descent.SGD(1.0, clipvalue=1.0), 10.)
def instantiate_model(self):
self.model = Sequential()
self.model.add(
Dense(128 * 128 * 3,
activation="relu",
input_shape=self.input_shape))
self.model.add(Dense(32, activation="relu"))
self.model.add(Dense(self.n_output, activation="softmax"))
slef.optimizer = optimizers.SGD(self.lr,
momentum=0.0,
decay=0.0,
nesterov=False)
self.model.compile(self.optimizer, self.loss, self.metrics)
def predictIncompleteFusion(x_train, y_train, x_test, y_test):
classifier = Sequential()
classifier.add(Dense(45, activation='sigmoid', kernel_initializer='random_normal', input_dim=13))
classifier.add(Dropout(0.6))
classifier.add(Dense(45, activation='sigmoid', kernel_initializer='random_normal'))
classifier.add(Dropout(0.6))
classifier.add(Dense(1, activation='sigmoid', kernel_initializer='random_normal'))
optimizer=optimizers.SGD(lr=0.9, momentum=0.4)
classifier.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])
history = classifier.fit(x_train, y_train, validation_data=(x_test, y_test), batch_size=1, epochs=250)
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title("IncomFus' accuracy graph")
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['accuracy', 'validation accuracy'], loc='upper left')
plt.show()
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title("IncomFus' loss graph")
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['loss', 'validation loss'], loc='upper left')
plt.show()
y_pred = classifier.predict(x_test)
pd.DataFrame(y_pred).to_csv("C:\\Users\\nurizdau\\Desktop\\predicted_probs_incomfus.csv")
y_pred[:] = (y_pred[:] > 0.5)
# pd.DataFrame(y_pred).to_csv("C:\\Users\\nurizdau\\Desktop\\predicted_results_incomfus.csv")
eval_model = classifier.evaluate(x_test, y_test)
resultString = "Accuracy (incomplete fusion) is printed here: " + str(eval_model[1])
new_test_y = y_test.values.flatten()
new_pred_y = y_pred.astype(int).flatten()
cm = confusion_matrix(new_test_y, new_pred_y)
print(cm)
print("accuracy of Incomplete Fusion is: ", ((cm[0][0] + cm[1][1]) / np.sum(cm)) * 100)
print("sensitivity of Incomplete Fusion is: ", (cm[0][0] / np.sum(cm[0])) * 100)
print("specificity of Incomplete Fusion is: ", (cm[1][1] / np.sum(cm[1])) * 100)
return resultString
def get_optimizer(args):
if args.optimizer == 'Adam':
kwargs = dict(
lr=args.lr,
beta_1=args.beta1,
beta_2=args.beta2,
epsilon=args.epsilon
)
optimizer = optimizers.Adam(**kwargs)
elif args.optimizer == 'SGD':
kwargs = dict(
lr=args.lr,
momentum=args.momentum
)
optimizer = optimizers.SGD(**kwargs)
else:
raise NotImplementedError('Unsupported Optimizer {}'.format(args.optimizer))
return optimizer
def createModel(learn_rate=0.01,
momentum=0,
initialization_mode='random_normal',
activation='sigmoid',
dropout_rate=0.0,
neuron=100,
loss='mean_squared_error',
optimizer='SGD'):
classifier = tf.keras.Sequential()
classifier.add(
Dense(90,
activation='sigmoid',
kernel_initializer='random_normal',
input_dim=13))
classifier.add(Dropout(0.0))
classifier.add(
Dense(1, activation='sigmoid', kernel_initializer='random_normal'))
optimizer = optimizers.SGD(lr=0.9, momentum=0.0)
classifier.compile(optimizer=optimizer, loss=loss, metrics=['accuracy'])
return classifier
def optimizer(self):
if self._optimizer == 'rms':
if not self._optim_config:
self._optim_config = {
'lr': 1e-5,
'decay': 0.9,
'rho': 0.9,
'epsilon': 1e-10
}
self._optimizer = optimizers.RMSprop(**self._optim_config)
#self._optimizer = tf.train.RMSPropOptimizer(self._optim_config)
elif self._optimizer == 'adam':
if not self._optim_config:
self._optim_config = {
'lr': 1e-5,
'beta_1': 0.9,
'beta_2': 0.999,
'epsilon': 1e-08,
'decay': 0.0,
'amsgrad': False
}
self._optimizer = optimizers.Adam(**self._optim_config)
#self._optimizer = tf.train.AdamOptimizer(self._optim_config)
elif self._optimizer == 'sgd':
if not self._optim_config:
self._optim_config = {
'lr': 1e-5,
'momentum': 0.0,
'decay': 0.8,
'nesterov': False
}
self._optimizer = optimizers.SGD(**self._optim_config)
#self._optimizer = tf.train.GradientDescentOptimizer(self._optim_config)
elif type(self._optimizer) not in [
optimizers.Adam, optimizers.SGD, optimizers.RMSprop
]:
logging.error('Unrecognized optimizer type')
return self._optimizer
def instantiate_model(self):
self.model = create_model_resnet(
self.input_shape,
n_output=self.n_output,
normalize=self.normalize,
kernel_shape=self.kernel_shape,
size_blocks=self.size_blocks,
resnet=self.resnet,
dropout=self.dropout,
n_channels_by_block=self.n_channels_by_block,
size_dense=self.size_dense,
average_pooling=self.average_pooling,
separable_conv=self.separable_conv)
print(self.model.summary())
self.optimizer = optimizers.Adamax(lr=self.lr) if self.optimizer == 'adamax' \
else optimizers.RMSprop(lr=self.lr) if self.optimizer == 'rmsprop' \
else optimizers.SGD(lr=self.lr, momentum=.9) if self.optimizer == 'sgd' \
else optimizers.Adam(lr=self.lr) if self.optimizer == 'adam' else None
# TODO
self.datagen = None
def test_pretrained_weights(self):
keras_model, (_, _), (_, _), _, _ = get_resource_for_simple_model()
keras_model.compile(
loss='categorical_crossentropy',
optimizer=tf.compat.v1.train.RMSPropOptimizer(1e-3),
metrics=['mse', keras.metrics.CategoricalAccuracy()])
keras_model.train_on_batch(
np.random.random((10,) + _INPUT_SIZE), np.random.random(
(10, _NUM_CLASS)))
weights = keras_model.get_weights()
keras_model, (_, _), (_, _), _, _ = get_resource_for_simple_model()
keras_model.set_weights(weights)
if tf.executing_eagerly():
sgd_optimizer = optimizer_v2.SGD(lr=0.0001, momentum=0.9)
else:
sgd_optimizer = optimizer_v1.SGD(lr=0.0001, momentum=0.9)
keras_model.compile(
loss='categorical_crossentropy',
optimizer=sgd_optimizer,
metrics=['mse', keras.metrics.CategoricalAccuracy()])
keras_lib.model_to_estimator(keras_model=keras_model, config=self._config)
def _model(self):
model = Sequential()
model.add(Flatten())
model.add(Dense(units=64, input_dim=self.state_size,
activation="relu"))
model.add(Dense(units=32, activation="relu"))
model.add(Dense(units=8, activation="relu"))
model.add(Dense(self.action_size, activation="softmax"))
## Define multiple optional optimizers
sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
adam = optimizers.Adam(lr=0.01,
beta_1=0.9,
beta_2=0.999,
epsilon=1,
decay=0.0,
amsgrad=False)
## Compile model with metrics
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def create_nn_classifier():
"""
Create neural network for image rendering approach
Args:
None
Returns:
Keras model (compiled) implementing corresponding interface
"""
base_model = ResNet50(weights='imagenet', include_top=False)
x = base_model.output
x = GlobalAveragePooling2D()(x)
x = Dense(1024, activation='relu')(x)
predictions = Dense(4, activation='softmax')(x)
model = Model(inputs=base_model.input, outputs=predictions)
sgd = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def __init__(self,
gui=1,
training=0,
model='ResNet50',
backend='INTERPRETER',
verbose=1):
self.gui = gui
self.verbose = verbose
self.backend = backend
ngraph_bridge.set_backend(self.backend)
if gui:
self.gui = widgets.VBox(children=[
self.tab, self.progress_box, self.out_initial, self.out,
self.out_stats
])
display(self.init_gui())
# Images
self.test_class_indices = []
self.test_dir = None
self.init_images()
self.sgd = optimizers.SGD(lr=0.01,
decay=1e-6,
momentum=0.9,
nesterov=True)
self.predicted_class_indices_init = []
self.wrong_guesses = []
self.train_button.disabled = False
self.fine_tune_button.disabled = False
self.init_model()
if training:
self.train_model(self.train_button, model=model)
