def create_model(learning_rate, num_dense_layers, num_dense_nodes):
'''This function takes in values for learning rate, number of layers and number of nodes in each layer, and creates,compiles and returns a Keras model
with those hyperparameters
Parameters
-------
learning_rate: float32
The learning rate for the optimization technique for the neural network
num_dense_layers: int32
The number of hidden layers to be implemented in the neural network
num_dense_nodes: int32
The number of hidden units per layer of the neural network
Returns
-------
model: Keras model'''
model = Sequential()
model.add(InputLayer(input_shape=(np.shape(train_data)[0], )))
for i in range(num_dense_layers):
model.add(Dense(num_dense_nodes, activation='selu'))
model.add(Dense(np.shape(train_data)[0], activation='linear'))
optimizer = RMSprop(lr=learning_rate)
model.compile(optimizer=optimizer, loss='mmse', metrics=['accuracy'])
return model
def build_simple_model():
model = Sequential()
model.add(Flatten(input_shape=(lookback // step, float_data.shape[-1])))
model.add(Dense(32, activation='relu'))
model.add(Dense(1))
model.compile(optimizer=RMSprop(), loss='mae')
return model
def build_gru_model():
model = Sequential()
#CuDNNGRU 代替GRU, 提高速度
model.add(CuDNNGRU(32, input_shape=(None, float_data.shape[-1])))
model.add(Dense(1))
model.compile(optimizer=RMSprop(), loss='mae')
return model
def create_model():
# Our input feature map is 150x150x3: 150x150 for the image pixels, and 3 for
# the three color channels: R, G, and B
img_input = layers.Input(shape=(150, 150, 3))
# Flatten feature map to a 1-dim tensor so we can add fully connected layers
x = layers.Flatten()(img_input)
# Create a fully connected layer with Sigmoid activation and 500 hidden units
x = layers.Dense(500, activation='sigmoid')(x)
# Create a second fully connected layer with Sigmoid activation and 500 hidden units
x = layers.Dense(500, activation='sigmoid')(x)
# Add a dropout rate of 0.5
x = layers.Dropout(0.5)(x)
# Create output layer with a single node and sigmoid activation
output = layers.Dense(1, activation='sigmoid')(x)
# Create model:
# input = input feature map
# output = input feature map + stacked convolution/maxpooling layers + fully
# connected layer + sigmoid output layer
model = Model(img_input, output)
model.compile(loss='binary_crossentropy',
optimizer=RMSprop(lr=0.01),
metrics=['acc'])
# model.summary()
return model
def build_model_CNN(self):
''' CNN '''
model = Sequential()
embedding_layer = Embedding(self.vocab_length,
300,
weights=[self.embedding_matrix],
input_length=self.length_long_sentence,
trainable=False)
model.add(embedding_layer)
model.add(
Conv1D(filters=150,
kernel_regularizer=l2(0.01),
kernel_size=5,
strides=1,
padding='valid'))
model.add(MaxPooling1D(2, padding='valid'))
model.add(
Conv1D(filters=150,
kernel_regularizer=l2(0.01),
kernel_size=5,
strides=1,
padding='valid'))
model.add(MaxPooling1D(2, padding='valid'))
model.add(Flatten())
model.add(Dense(80, kernel_regularizer=l2(0.01), activation='relu'))
model.add(Dense(40, kernel_regularizer=l2(0.01), activation='relu'))
model.add(Dense(20, kernel_regularizer=l2(0.01), activation='relu'))
model.add(Dense(2, activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer=RMSprop(lr=0.001),
metrics=['accuracy'])
model.summary()
def __init__(self, n_actions, n_features, eval_model, target_model):
self.params = {
'n_actions': n_actions,
'n_features': n_features,
'learning_rate': 0.01,
'reward_decay': 0.9,
'e_greedy': 0.9,
'replace_target_iter': 300,
'memory_size': 500,
'batch_size': 32,
'e_greedy_increment': None
}
# total learning step
self.learn_step_counter = 0
# initialize zero memory [s, a, r, s_]
self.epsilon = 0 if self.params[
'e_greedy_increment'] is not None else self.params['e_greedy']
self.memory = np.zeros(
(self.params['memory_size'], self.params['n_features'] * 2 + 2))
self.eval_model = eval_model
self.target_model = target_model
self.eval_model.compile(
optimizer=RMSprop(lr=self.params['learning_rate']), loss='mse')
self.cost_his = []
def create_generator():
# Create the Generator network structure
generator = Sequential()
generator.add(Dense(12544, input_dim=100))
generator.add(BatchNormalization(momentum=0.9))
generator.add(Activation('relu'))
generator.add(Reshape((7, 7, 256)))
generator.add(Dropout(0.4))
generator.add(UpSampling2D())
generator.add(Conv2DTranspose(int(128), 5, padding='same'))
generator.add(BatchNormalization(momentum=0.9))
generator.add(Activation('relu'))
generator.add(UpSampling2D())
generator.add(Conv2DTranspose(int(64), 5, padding='same'))
generator.add(BatchNormalization(momentum=0.9))
generator.add(Activation('relu'))
generator.add(Conv2DTranspose(int(32), 5, padding='same'))
generator.add(BatchNormalization(momentum=0.9))
generator.add(Activation('relu'))
generator.add(Conv2DTranspose(1, 5, padding='same'))
generator.add(Activation('sigmoid'))
generator.compile(optimizer=RMSprop(lr=0.0004, clipvalue=1.0, decay=3e-8),
loss='binary_crossentropy',
metrics=['accuracy'])
generator.summary()
return generator
def build_model():
# epoch, dropout = best_model()
epoch, dropout = 5, 0.2
print('EPOCH = ', epoch)
print('DROPOUT = ', dropout)
model = Sequential()
model.add(
Embedding(input_dim=ger_vocab_size,
output_dim=128,
input_length=11))
model.add(LSTM(128))
model.add(RepeatVector(11))
model.add(LSTM(128, return_sequences=True))
model.add(Dropout(dropout))
model.add(Dense(eng_vocab_size, activation='softmax'))
model.compile(optimizer=RMSprop(lr=0.01),
loss='sparse_categorical_crossentropy',
metrics=['acc'])
model.summary()
# Train model
history = model.fit(X_train,
y_train.reshape(y_train.shape[0],
y_train.shape[1], 1),
epochs=epoch,
batch_size=128,
verbose=1,
validation_split=0.2)
# Evaluate the model
loss, accuracy = model.evaluate(X_test,
y_test.reshape(
y_test.shape[0],
y_test.shape[1], 1),
verbose=1)
print('Accuracy: %f' % (accuracy * 100))
def display():
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()
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()
display()
def _setup(self, config):
self.train_stories, self.test_stories = read_data()
model = self.build_model()
rmsprop = RMSprop(lr=self.config.get("lr", 1e-3),
rho=self.config.get("rho", 0.9))
model.compile(optimizer=rmsprop,
loss="sparse_categorical_crossentropy",
metrics=["accuracy"])
self.model = model
def discriminator_model(self):
if self.DM:
return self.DM
optimizer = RMSprop(lr=0.0002, decay=6e-8)
self.DM = Sequential()
self.DM.add(self.discriminator())
self.DM.compile(loss='binary_crossentropy', optimizer=optimizer,\
metrics=['accuracy'])
return self.DM
def best_model():
epochs = [5, 10, 15, 20]
dropout_rate = [0.1, 0.2, 0.3]
list_of_all_scores = list()
list_of_scores = list()
list_of_dropout = list()
list_of_all_dropouts = list()
list_of_epochs = list()
for i in dropout_rate:
model = Sequential()
model.add(
Embedding(input_dim=ger_vocab_size,
output_dim=128,
input_length=11))
model.add(LSTM(128))
model.add(RepeatVector(11))
model.add(LSTM(128, return_sequences=True))
model.add(Dropout(i))
model.add(Dense(eng_vocab_size, activation='softmax'))
model.compile(optimizer=RMSprop(lr=0.01),
loss='sparse_categorical_crossentropy',
metrics=['acc'])
list_of_dropout.append(i)
for e in epochs:
list_of_all_dropouts.append(i)
list_of_epochs.append(e)
model.fit(X_train,
y_train.reshape(y_train.shape[0],
y_train.shape[1], 1),
epochs=e,
batch_size=128,
verbose=1,
validation_split=0.2)
score = model.evaluate(X_test,
y_test.reshape(
y_test.shape[0],
y_test.shape[1], 1),
verbose=1)
list_of_all_scores.append(score)
if score not in list_of_scores:
list_of_scores.append(score)
#print('Dropout:', i, '\n', 'Epoch:', e, '\n', 'Score:', float(score))
lowest = min(list_of_all_scores)
num = list_of_scores.index(lowest)
epoch = list_of_epochs[num]
dropout = list_of_all_dropouts[num]
print('Lowest score:', lowest, 'Epoch:', epoch, 'Dropout', dropout)
return epoch, dropout
def adversarial_model(self):
if self.AM:
return self.AM
optimizer = RMSprop(lr=0.0001, decay=3e-8)
self.AM = Sequential()
self.AM.add(self.generator())
self.AM.add(self.discriminator())
self.AM.compile(loss='binary_crossentropy', optimizer=optimizer,\
metrics=['accuracy'])
return self.AM
def textgenrnn_model(num_classes,
cfg,
context_size=None,
weights_path=None,
dropout=0.0,
optimizer=RMSprop(lr=4e-3, rho=0.99)):
'''
Builds the model architecture for textgenrnn_tf and
loads the specified weights for the model.
'''
input = Input(shape=(cfg['max_length'], ), name='input')
embedded = Embedding(num_classes,
cfg['dim_embeddings'],
input_length=cfg['max_length'],
name='embedding')(input)
if dropout > 0.0:
embedded = SpatialDropout1D(dropout, name='dropout')(embedded)
rnn_layer_list = []
for i in range(cfg['rnn_layers']):
prev_layer = embedded if i is 0 else rnn_layer_list[-1]
rnn_layer_list.append(new_rnn(cfg, i + 1)(prev_layer))
seq_concat = concatenate([embedded] + rnn_layer_list, name='rnn_concat')
attention = AttentionWeightedAverage(name='attention')(seq_concat)
output = Dense(num_classes, name='output', activation='softmax')(attention)
if context_size is None:
model = Model(inputs=[input], outputs=[output])
if weights_path is not None:
model.load_weights(weights_path, by_name=True)
model.compile(loss='categorical_crossentropy', optimizer=optimizer)
else:
context_input = Input(shape=(context_size, ), name='context_input')
context_reshape = Reshape((context_size, ),
name='context_reshape')(context_input)
merged = concatenate([attention, context_reshape], name='concat')
main_output = Dense(num_classes,
name='context_output',
activation='softmax')(merged)
model = Model(inputs=[input, context_input],
outputs=[main_output, output])
if weights_path is not None:
model.load_weights(weights_path, by_name=True)
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
loss_weights=[0.8, 0.2])
return model
def create_discriminator():
# Create the Discriminator network structure
discriminator = Sequential()
discriminator.add(
Conv2D(64,
kernel_size=(5, 5),
strides=2,
activation=LeakyReLU(alpha=0.2),
padding='same',
input_shape=(param['img_rows'], param['img_cols'], 1)))
discriminator.add(Dropout(0.4))
discriminator.add(
Conv2D(
128,
kernel_size=(5, 5),
strides=2,
activation=LeakyReLU(alpha=0.2),
padding='same',
))
discriminator.add(Dropout(0.4))
discriminator.add(
Conv2D(
256,
kernel_size=(5, 5),
strides=2,
activation=LeakyReLU(alpha=0.2),
padding='same',
))
discriminator.add(Dropout(0.4))
discriminator.add(
Conv2D(
256,
kernel_size=(5, 5),
strides=2,
activation=LeakyReLU(alpha=0.2),
padding='same',
))
discriminator.add(Dropout(0.4))
discriminator.add(Flatten())
discriminator.add(Dense(1, activation='sigmoid'))
# Compile it
discriminator.compile(optimizer=RMSprop(lr=0.0008,
clipvalue=1.0,
decay=6e-8),
loss='binary_crossentropy',
metrics=['accuracy'])
discriminator.summary()
return discriminator
def build_cnn_1d_model(maxlen=500):
model = Sequential()
model.add(Embedding(max_features, 128, input_length=maxlen))
model.add(Conv1D(32, 7, activation='relu'))
model.add(MaxPooling1D(5))
model.add(Conv1D(32, 7, activation='relu'))
model.add(GlobalMaxPooling1D())
model.add(Dense(1))
model.summary()
model.compile(optimizer=RMSprop(lr=1e-4),
loss='binary_crossentropy',
metrics=['acc'])
return model
def create_model():
model = Sequential()
model.add(
Dense(64,
activation='relu',
kernel_initializer='normal',
input_shape=(16, )))
model.add(Dense(64, kernel_initializer='normal', activation='relu'))
model.add(Dense(1, kernel_initializer='normal', activation='sigmoid'))
model.compile(loss="binary_crossentropy",
optimizer=RMSprop(),
metrics=['accuracy'])
return model
def trainModel(self, model, epochs, train_generator, valid_generator):
model.compile(loss='categorical_crossentropy',
optimizer=RMSprop(lr=0.001),
metrics=['acc'])
history = model.fit_generator(generator=train_generator,
steps_per_epoch=100,
epochs=epochs,
validation_data=valid_generator,
validation_steps=50,
verbose=1)
return history # the history of the trained model
def discriminator_model(self):
if self.DM:
return self.DM
optimizer = RMSprop(lr=2e-4, decay=1e-8)
self.DM = Sequential()
self.DM.add(self.discriminator())
#multi_gpu
with tf.device('/cpu:0'):
self.DM = multi_gpu_model(self.DM, gpus=4)
self.DM.compile(loss='binary_crossentropy', optimizer=optimizer,\
metrics=['accuracy'])
return self.DM
def create_model():
model = Sequential()
model.add(Dense(20, activation='relu', input_shape=(9, )))
model.add(Dropout(0.2))
model.add(Dense(15, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(5, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer=RMSprop(),
metrics=['accuracy'])
model.summary()
return model
def keras_model_fn(hyperparameters):
"""keras_model_fn receives hyperparameters from the training job and returns a compiled keras model.
The model will be transformed into a TensorFlow Estimator before training and it will be saved in a
TensorFlow Serving SavedModel at the end of training.
Args:
hyperparameters: The hyperparameters passed to the SageMaker TrainingJob that runs your TensorFlow
training script.
Returns: A compiled Keras model
"""
model = Sequential()
# TensorFlow Serving default prediction input tensor name is PREDICT_INPUTS.
# We must conform to this naming scheme.
model.add(
InputLayer(input_shape=(HEIGHT, WIDTH, DEPTH), name=PREDICT_INPUTS))
model.add(Conv2D(32, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(NUM_CLASSES))
model.add(Activation('softmax'))
_model = tf.keras.Model(inputs=model.input, outputs=model.output)
opt = RMSprop(lr=hyperparameters['learning_rate'],
decay=hyperparameters['decay'])
_model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
return _model
def __init__(self):
# Input shape
self.class_num = config.class_num
self.img_shape = config.img_shape
self.img_width = config.img_width
self.img_height = config.img_height
self.img_channel = config.img_channel
self.gf = 32
self.df = 64
self.patch = int(config.img_height // (2**4))
self.patch_size = (self.patch, self.patch, 1)
self.s1 = Dataset('./t1ce', './tice_label')
self.s2 = Dataset('./t2', './t2_label')
self.target = Dataset('./OpenBayes',
'./Openbayes_label',
need_resize=1)
optimizer = RMSprop(0.0002)
self.D = self.build_discriminator()
self.G = self.build_generator()
self.G.trainable = False
real_img = Input(shape=config.img_shape)
real_src, real_cls = self.D(real_img)
fake_cls = Input(shape=(self.class_num, ))
fake_img = self.G([real_img, fake_cls])
fake_src, fake_output = self.D(fake_img)
self.Train_D = Model([real_img, fake_cls],
[real_src, real_cls, fake_src, fake_output])
self.Train_D.compile(loss=[
'mse', self.classification_loss, 'mse', self.classification_loss
],
optimizer=optimizer,
loss_weights=[1.0, 1.0, 1.0, 1.0])
self.G.trainable = True
self.D.trainable = False
real_x = Input(shape=self.img_shape)
now_label = Input(shape=(self.class_num, ))
target_label = Input(shape=(self.class_num, ))
fake_x = self.G([real_x, target_label])
fake_out_src, fake_out_cls = self.D(fake_x)
x_rec = self.G([fake_x, now_label])
self.train_G = Model([real_x, now_label, target_label],
[fake_out_src, fake_out_cls, x_rec])
self.train_G.compile(loss=['mse', self.classification_loss, 'mae'],
optimizer=optimizer,
loss_weights=[1.0, 1.0, 1.0])
'''
def model_DenseNet():
model_dense = RGCSA.ResneXt_IN((1, img_rows, img_cols, img_channels), cardinality=8, classes=9)
RMS = RMSprop(lr=0.0003)
# Let's train the model using RMSprop
def mycrossentropy(y_true, y_pred, e=0.1):
loss1 = K.categorical_crossentropy(y_true, y_pred)
loss2 = K.categorical_crossentropy(K.ones_like(y_pred) / nb_classes, y_pred) # K.ones_like(y_pred) / nb_classes
return (1 - e) * loss1 + e * loss2
model_dense.compile(loss=mycrossentropy, optimizer=RMS, metrics=['accuracy'])
return model_dense
def get_optimizer(optimizer='sgd', learning_rate=0.1, momentum=0.9, log=True):
"""Create an optimizer and wrap it for Horovod distributed training. Default is SGD."""
if log:
print('Creating optimizer on rank ' + str(hvd.rank()))
opt = None
if optimizer == 'sgd+nesterov':
opt = SGD(lr=learning_rate, momentum=momentum, nesterov=True)
elif optimizer == 'rmsprop':
opt = RMSprop(lr=learning_rate, rho=0.9)
elif optimizer == 'adam':
opt = Adam(lr=learning_rate, beta_1=0.9, beta_2=0.999, amsgrad=False)
elif optimizer == 'adadelta':
opt = Adadelta(lr=learning_rate, rho=0.95)
else:
opt = SGD(lr=learning_rate, momentum=momentum, nesterov=False)
# Wrap optimizer for data distributed training
return hvd.DistributedOptimizer(opt)
def get_unet_64(input_shape, num_classes, filters):
inputs = Input(shape=input_shape)
# 128
down1 = Conv2D(filters, (3, 3), padding='same')(inputs)
down1 = BatchNormalization()(down1)
down1 = Activation('relu')(down1)
down1 = Conv2D(filters, (3, 3), padding='same')(down1)
down1 = BatchNormalization()(down1)
down1 = Activation('relu')(down1)
down1_pool = MaxPooling2D((2, 2), strides=(2, 2))(down1)
# 64
center = Conv2D(filters * 2, (3, 3), padding='same')(down1_pool)
center = BatchNormalization()(center)
center = Activation('relu')(center)
center = Conv2D(filters * 2, (3, 3), padding='same')(center)
center = BatchNormalization()(center)
center = Activation('relu')(center)
# center
up1 = UpSampling2D((2, 2))(center)
up1 = concatenate([down1, up1], axis=3)
up1 = Conv2D(filters, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
up1 = Conv2D(filters, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
up1 = Conv2D(filters, (3, 3), padding='same')(up1)
up1 = BatchNormalization()(up1)
up1 = Activation('relu')(up1)
# 16
classify = Conv2D(num_classes, (1, 1), activation='sigmoid')(up1)
model = Model(inputs=inputs, outputs=classify)
#model.compile(optimizer=RMSprop(lr=0.0001), loss=bce_dice_loss, metrics=[dice_coeff])
model.compile(optimizer=RMSprop(lr=0.0001),
metrics=['accuracy'],
loss='binary_crossentropy')
return model
def create_model_from_ResNet50():
model = Sequential()
model.add(vgg_model)
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1024, activation='relu'))
model.add(Dense(102, activation='softmax'))
model.layers[0].trainable = False
model.compile(loss='categorical_crossentropy',
optimizer=RMSprop(lr=0.001),
metrics=['acc']) # optimizer=RMSprop(lr=0.001)
return model
def model_DenseNet():
model_dense = RGCSA.ResneXt_IN((1, img_rows, img_cols, img_channels), classes=16)
RMS = RMSprop(lr=0.0003)
def mycrossentropy(y_true, y_pred, e=0.1):
loss1 = K.categorical_crossentropy(y_true, y_pred)
loss2 = K.categorical_crossentropy(K.ones_like(y_pred) / nb_classes, y_pred) # K.ones_like(y_pred) / nb_classes
return (1 - e) * loss1 + e * loss2
model_dense.compile(loss=mycrossentropy, optimizer=RMS, metrics=['accuracy']) # categorical_crossentropy
model_dense.summary()
# plot_model(model_dense, show_shapes=True, to_file='./model_ResNeXt_GroupChannel_Space_Attention.png')
return model_dense
def build_model_LSTM(self):
''' LSTM model '''
model = Sequential()
embedding_layer = Embedding(self.vocab_length,
300,
weights=[self.embedding_matrix],
input_length=self.length_long_sentence,
trainable=False)
model.add(embedding_layer)
model.add(LSTM(84, kernel_regularizer=l2(0.1), dropout=0.2))
model.add(Dense(64, kernel_regularizer=l2(0.1), activation='relu'))
model.add(Dense(2, activation='softmax'))
model.compile(optimizer=RMSprop(lr=0.001),
loss='binary_crossentropy',
metrics=['accuracy'])
model.summary()
return model
def build_model_FeedForward(self):
''' Feed forward model '''
model = Sequential()
embedding_layer = Embedding(self.vocab_length,
300,
weights=[self.embedding_matrix],
input_length=self.length_long_sentence,
trainable=False)
model.add(embedding_layer)
model.add(Flatten())
model.add(Dense(200, kernel_regularizer=l2(0.01), activation='relu'))
model.add(Dense(80, activation='relu'))
model.add(Dense(2, activation='softmax'))
model.compile(optimizer=RMSprop(lr=0.0001),
loss='binary_crossentropy',
metrics=['accuracy'])
return model
def check_model_score(model_name, weights, fold):
model = MODELS[model_name].factory(lock_base_model=True)
model.load_weights(weights, by_name=True)
model.compile(optimizer=RMSprop(lr=3e-4),
loss='binary_crossentropy',
metrics=['accuracy'])
dataset = SingleFrameCNNDataset(
preprocess_input_func=MODELS[model_name].preprocess_input,
batch_size=MODELS[model_name].batch_size,
validation_batch_size=4, # MODELS[model_name].batch_size,
fold=fold,
use_non_blank_frames=True)
gt = []
pred = []
steps = dataset.validation_steps() // 500
print('steps:', steps)
step = 0
for X, y in tqdm(dataset.generate_test(verbose=True)):
gt.append(y)
pred.append(model.predict_on_batch(X))
step += 1
if step >= steps:
break
# print(gt)
# print(pred)
gt = np.vstack(gt).astype(np.float64)
pred = np.vstack(pred).astype(np.float64)
print(gt.shape, pred.shape)
# print(gt)
# print(pred)
checkpoint_name = os.path.basename(weights)
out_dir = f'../output/check_model_score/gt{model_name}_{fold}_{checkpoint_name}'
os.makedirs(out_dir, exist_ok=True)
print(out_dir)
np.save(f'{out_dir}/gt.npy', gt)
np.save(f'{out_dir}/pred.npy', pred)
for clip in [0.0, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1]:
print(clip, metrics.pri_matrix_loss(gt,
np.clip(pred, clip, 1.0 - clip)))
def create_model():
# Our input feature map is 150x150x3: 150x150 for the image pixels, and 3 for
# the three color channels: R, G, and B
img_input = layers.Input(shape=(150, 150, 3))
# First convolution extracts 128 filters that are 5x5
# Convolution is followed by max-pooling layer with a 2x2 window
x = layers.Conv2D(128, 5, activation='relu')(img_input)
x = layers.MaxPooling2D(2)(x)
x = layers.Dropout(0.5)(x)
# Flatten feature map to a 1-dim tensor so we can add fully connected layers
x = layers.Flatten()(x)
x = layers.Dense(96, activation='relu')(x)
# Add a dropout rate of 0.5
x = layers.Dropout(0.25)(x)
x = layers.Dense(54, activation='relu')(x)
# Add a dropout rate of 0.5
x = layers.Dropout(0.25)(x)
# Create output layer with a single node and sigmoid activation
output = layers.Dense(1, activation='softmax')(x)
# Create model:
# input = input feature map
# output = input feature map + stacked convolution/maxpooling layers + fully
# connected layer + sigmoid output layer
model = Model(img_input, output)
model.compile(loss='binary_crossentropy',
optimizer=RMSprop(lr=0.001),
metrics=['acc'])
# model.summary()
return model
