def cnn():
cnn = Sequential([
Input(shape=(200, 4)),
Reshape((200, 4, 1)),
Conv2D(128, kernel_size=(10, 2), activation="relu"),
Conv2D(128, kernel_size=(10, 2), activation="relu"),
Dropout(0.4),
Conv2D(64, kernel_size=(10, 2), strides=(2, 1), activation="relu"),
Conv2D(64, kernel_size=(10, 1), activation="relu"),
Conv2D(64, kernel_size=(10, 1), activation="relu"),
Dropout(0.4),
Flatten(),
Dense(64, activation="relu"),
Dense(32, activation="relu"),
Dense(1, activation="sigmoid")
], "CNN")
cnn.compile(
optimizer="nadam",
loss="binary_crossentropy",
metrics=[
"accuracy",
AUC(curve="ROC", name="auroc"),
AUC(curve="PR", name="auprc"),
]
)
return cnn
def get_metrics(y, y_pred):
cnf_matrix = confusion_matrix(y, y_pred)
false_positive = cnf_matrix.sum(
axis=0) - np.diag(cnf_matrix).astype(float)
false_negative = cnf_matrix.sum(
axis=1) - np.diag(cnf_matrix).astype(float)
true_positive = np.diag(cnf_matrix).astype(float)
true_negative = (
cnf_matrix.sum() -
(false_positive + false_negative + true_positive)).astype(float)
y = to_categorical(y, num_classes=5)
y_pred = to_categorical(y_pred, num_classes=5)
auc = AUC()
_ = auc.update_state(y, y_pred)
acc = CategoricalAccuracy()
_ = acc.update_state(y, y_pred)
return {
'accuracy': acc.result().numpy(),
'auc': auc.result().numpy(),
'sensitivity': true_positive / (true_positive + false_negative),
'specificity': true_negative / (true_negative + false_positive)
}
def get_cnn(shape_value):
shape_v = (shape_value, 4)
cnn = Sequential([
Input(shape=shape_v),
Reshape((*shape_v, 1)),
Conv2D(64, kernel_size=(10, 2), activation="relu"),
Dropout(0.3),
Conv2D(32, kernel_size=(10, 2), strides=(2, 1), activation="relu"),
Conv2D(32, kernel_size=(10, 1), activation="relu"),
Dropout(0.3),
Flatten(),
Dense(32, activation="relu"),
Dense(16, activation="relu"),
Dense(1, activation="sigmoid")
], "CNN")
cnn.compile(optimizer="nadam",
loss="binary_crossentropy",
metrics=[
"accuracy",
AUC(curve="ROC", name="auroc"),
AUC(curve="PR", name="auprc")
])
return cnn
def FFNN():
ffnn = Sequential([
Input(shape=(200, 4)),
Flatten(),
Dense(1024, activation="relu"),
Dense(512, activation="relu"),
BatchNormalization(),
Dropout(0.4),
Dense(256, activation="relu"),
Dense(128, activation="relu"),
BatchNormalization(),
Dense(64, activation="relu"),
Dropout(0.4),
Dense(32, activation="relu"),
Dense(1, activation="sigmoid")
], "FFNN")
ffnn.compile(
optimizer="nadam",
loss="binary_crossentropy",
metrics=[
"accuracy",
AUC(curve="ROC", name="auroc"),
AUC(curve="PR", name="auprc")
]
)
ffnn.summary()
return ffnn
def get_model(
input_shape: Tuple[int],
name: str = None,
optimizer: str = get_default('optimizer'),
loss: str = get_default('loss'),
metrics: List = None,
epochs: int = get_default('epochs'),
batch_size: int = get_default('batch_size'),
validation_split: float = get_default('validation_split'),
shuffle: bool = get_default('shuffle'),
verbose: bool = get_default('verbose'),
**kwargs):
name = name or default_name
input_layers = (Input(shape=input_shape), )
output_layers = (Dense(1, activation="sigmoid"), )
layers = (*input_layers, *hidden_layers, *output_layers)
model = Sequential(layers, name)
metrics = metrics or [
"accuracy",
AUC(curve="ROC", name="auroc"),
AUC(curve="PR", name="auprc")
]
model.compile(optimizer=optimizer, loss=loss, metrics=metrics)
kwargs.update({
'epochs': epochs,
'batch_size': batch_size,
'validation_split': validation_split,
'shuffle': shuffle,
'verbose': verbose
})
model.summary()
return Model(name, model, **kwargs)
def evaluate_legacy(model, weights, test_gen, loss, optimiser, loss_weights):
# Get loss weights
metrics = [
'accuracy',
AUC(curve='ROC', name='auroc'),
AUC(curve='PR', name='aupr')
]
# Compile model
model.compile(loss=loss,
optimizer=optimiser,
metrics=metrics,
loss_weights=loss_weights)
# Evaluate
print(f'Evaluating weights file: {weights}')
output = model.evaluate(test_gen.dataset)
# Report results
loss = output[0]
audio_acc = output[4]
video_acc = output[7]
av_acc = output[10]
auroc = output[11]
aupr = output[12]
print_results(weights, loss, audio_acc, video_acc, av_acc, auroc, aupr)
def _compile_model(self) -> Model:
self._model.compile(optimizer="nadam",
loss="binary_crossentropy",
metrics=[
"accuracy",
AUC(curve="ROC", name="auroc"),
AUC(curve="PR", name="auprc")
])
def get_minimal_multiclass_metrics() -> List[Union[AUC, str, BinaryMetric]]:
"""Return minimal list of multiclass metrics.
The set of metrics includes accuracy, AUROC and AUPRC.
"""
return [
"accuracy",
Recall(name="recall"),
Precision(name="precision"),
AUC(curve="roc", name="AUROC"),
AUC(curve="pr", name="AUPRC")
]
def train():
train_data, valid_data, test_data = load_data()
mirrored_strategy = tf.distribute.MirroredStrategy()
with mirrored_strategy.scope():
model = music_sincnet()
csv_logger = CSVLogger("./checkpoint/log.csv", append=True)
checkpointer = make_checkpoint()
for i in range(4):
if i == 0:
optimizer = Adam(learning_rate=1e-4)
epoch = 60
elif i == 1:
optimizer = SGD(learning_rate=0.001,
momentum=0.9,
nesterov=True)
epoch = 20
elif i == 2:
optimizer = SGD(learning_rate=0.0001,
momentum=0.9,
nesterov=True)
epoch = 20
else:
optimizer = SGD(learning_rate=0.00001,
momentum=0.9,
nesterov=True)
epoch = 100
model.compile(
loss="binary_crossentropy",
optimizer=optimizer,
metrics=[AUC(name='roc_auc'),
AUC(name='pr_auc', curve='PR')])
model.fit(
train_data,
batch_size=16,
epochs=epoch,
callbacks=[checkpointer, csv_logger],
)
loss, roc_auc, pr_auc = model.evaluate(valid_data)
print('roc_auc : {}, pr_auc : {}, loss : {}'.format(
roc_auc, pr_auc, loss))
model.save("../models/model" + str(i) + ".h5")
loss, roc_auc, pr_auc = model.evaluate(test_data)
print('@TEST RESULT\n roc_auc : {}, pr_auc : {}, loss : {}'.format(
roc_auc, pr_auc, loss))
def train(epochs):
train_ds, test_ds, field_dict, field_index = get_data()
model = DeepFM(embedding_size=config.EMBEDDING_SIZE, num_feature=len(field_index),
num_field=len(field_dict), field_index=field_index)
optimizer = tf.keras.optimizers.SGD(learning_rate=0.01)
print("Start Training: Batch Size: {}, Embedding Size: {}".format(config.BATCH_SIZE, config.EMBEDDING_SIZE))
start = perf_counter()
for i in range(epochs):
acc = BinaryAccuracy(threshold=0.5)
auc = AUC()
loss_history = []
for x, y in train_ds:
loss = train_on_batch(model, optimizer, acc, auc, x, y)
loss_history.append(loss)
print("Epoch {:03d}: 누적 Loss: {:.4f}, Acc: {:.4f}, AUC: {:.4f}".format(
i, np.mean(loss_history), acc.result().numpy(), auc.result().numpy()))
test_acc = BinaryAccuracy(threshold=0.5)
test_auc = AUC()
for x, y in test_ds:
y_pred = model(x)
test_acc.update_state(y, y_pred)
test_auc.update_state(y, y_pred)
print("테스트 ACC: {:.4f}, AUC: {:.4f}".format(test_acc.result().numpy(), test_auc.result().numpy()))
print("Batch Size: {}, Embedding Size: {}".format(config.BATCH_SIZE, config.EMBEDDING_SIZE))
print("걸린 시간: {:.3f}".format(perf_counter() - start))
model.save_weights('weights/weights-epoch({})-batch({})-embedding({}).h5'.format(
epochs, config.BATCH_SIZE, config.EMBEDDING_SIZE))
def SegNet3D(shape, weights=None):
inputs = Input(shape)
conv, pool = inputs, inputs
# encoder
for numOfFilters in [4, 8, 16, 32]:
conv = SegNet3DBlock(pool, layers=2, filters=numOfFilters)
pool = MaxPooling3D((2, 2, 2))(conv)
conv = SegNet3DBlock(pool, layers=3, filters=128)
# decoder
for numOfFilters in [64, 32, 16, 8]:
upsam = UpSampling3D((2, 2, 2))(conv)
conv = SegNet3DBlock(upsam, layers=2, filters=numOfFilters)
conv = SegNet3DBlock(upsam, layers=2, filters=4)
outputs = Conv3D(1, 1, activation='sigmoid')(conv)
model = Model(inputs=inputs, outputs=outputs)
model.compile(optimizer=Adam(learning_rate=1e-4), loss='binary_crossentropy',
metrics=[Precision(), Recall(), AUC(), Accuracy()])
model.summary()
return model
def buildModel():
inp = Input((MAXIMUM_SEQ_LEN, ))
#use embeddings
emb = Embedding(VOCAB_LENGTH,
EMBEDDING_DIM,
weights=[embedding_matrix],
trainable=False)(inp)
#to drop some embedding instead of particular cells
emb = SpatialDropout1D(0.2)(emb)
#generate 100(fwd) + 100(bwd) hidden states
hidden_states = Bidirectional(
LSTM(100, return_sequences=True, dropout=0.1,
recurrent_dropout=0.1))(emb)
#on each hidden state use 100*64 kernels of size 3
conv = Conv1D(64,
kernel_size=3,
padding="valid",
kernel_initializer="glorot_uniform")(hidden_states)
#take maximum for each cell of all hidden state
x1 = GlobalMaxPool1D()(conv)
x2 = GlobalAvgPool1D()(conv)
#cocatenate both polling
x = Concatenate()([x1, x2])
x = Dropout(0.2)(x)
x = Dense(50, activation='relu')(x)
x = Dropout(0.1)(x)
out = Dense(6, activation='sigmoid')(x)
model = Model(inp, out)
model.compile(loss="binary_crossentropy",
optimizer="adam",
metrics=[AUC(name="auc")])
def prepare_model(img_rows, img_cols, img_channels, nb_classes):
cnn = Sequential()
cnn.add(
Conv2D(32, (3, 3),
padding='same',
activation='relu',
input_shape=(img_rows, img_cols, img_channels)))
cnn.add(MaxPooling2D(pool_size=(2, 2)))
cnn.add(Conv2D(
64,
(3, 3),
padding='same',
activation='relu',
))
cnn.add(MaxPooling2D(pool_size=(2, 2)))
cnn.add(Conv2D(
128,
(3, 3),
padding='same',
activation='relu',
))
cnn.add(MaxPooling2D(pool_size=(2, 2)))
cnn.add(Flatten())
cnn.add(Dense(512))
cnn.add(Dense(512))
cnn.add(Dense(nb_classes, activation='sigmoid'))
cnn.compile(optimizer='sgd',
loss='binary_crossentropy',
metrics=['accuracy', AUC(name='auc')])
print(cnn.summary())
return cnn
def get_conv_model():
"""
Create convolutional neural network with keras. Layers already set and only adjustable through source file.
"""
model = Sequential()
model.add(Conv2D(filters=16, kernel_size=(2,2), kernel_regularizer=l2(0.0001),
input_shape=(num_rows, num_columns, num_channels), activation='relu'))
model.add(MaxPooling2D(pool_size=2))
model.add(Conv2D(filters=32, kernel_size=(2,2), kernel_regularizer=l2(0.0001), activation='relu'))
model.add(Dropout(0.2))
model.add(Conv2D(filters=64, kernel_size=(3,3), kernel_regularizer=l2(0.0001), activation='relu'))
model.add(MaxPooling2D(pool_size=2))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_labels, activation='softmax'))
model.compile(loss='categorical_crossentropy', metrics=['accuracy', AUC()], optimizer='adam')
return model
def build_model(hp, input_dim1, input_dim2, output_dim, first_layer=False):
params = hp.values.copy()
ci = Input((input_dim1, ))
si = Input((input_dim2, ))
s = si
for i in range(hp.Int('num_layers', 0, 2)):
s = Dense(hp.Choice('branching_units' + str(i + 1),
units,
default=units[0]),
activation='relu')(s)
s = Dropout(0.2)(s)
x = Concatenate(axis=-1)([ci, s])
x1 = Dense(hp.Choice('units_' + str(1), [16, 8], default=16),
activation='relu')(x)
x = Dense(output_dim, activation='softmax', name='output_1')(x1)
model = Model(inputs=[ci, si], outputs=[x])
model.compile(optimizer=Adam(learning_rate=0.001),
loss={'output_1': 'categorical_crossentropy'},
metrics=['acc', f1, f2,
Precision(),
Recall(),
AUC()])
return model
def train_nfm(mode=1):
# ========================= Hyper Parameters =======================
dnn_dropout = 0.5
hidden_units = [256, 128, 64]
learning_rate = 0.001
batch_size = 4096
epochs = 10
# ========================== Create dataset =======================
feature_columns, train, test = criteo.build_dataset(mode=mode)
train_X, train_y = train
test_X, test_y = test
# ============================Build Model==========================
model = NFM(feature_columns, hidden_units, dnn_dropout=dnn_dropout)
# model.summary()
# =========================Compile============================
model.compile(loss=binary_crossentropy, optimizer=Adam(learning_rate=learning_rate),
metrics=[AUC()])
# ===========================Fit==============================
model.fit(
train_X,
train_y,
epochs=epochs,
callbacks=[EarlyStopping(
monitor='val_loss', patience=2, restore_best_weights=True)], # checkpoint
batch_size=batch_size,
validation_split=0.1
)
# ===========================Test==============================
print('test AUC: %f' % model.evaluate(test_X, test_y)[1])
def compiled_model(INPUT_SHAPE: list, QNT_CLASS: int) -> tf.keras.Model:
"""
A função retorna o modelo compilado.
Return a compiled model.
"""
INPUT_SHAPE = tuple(INPUT_SHAPE)
base_model = MobileNetV2(include_top=False,
weights='imagenet',
input_tensor=Input(shape=INPUT_SHAPE,
name='inputs'))
for layer in base_model.layers:
layer.trainable = False
mod = base_model.output
mod = AveragePooling2D()(mod)
mod = Flatten()(mod)
mod = Dropout(0.5)(mod)
mod = Dense(QNT_CLASS, activation='softmax')(mod)
mod_retorno = Model(inputs=base_model.input, outputs=mod)
mod_retorno.compile(
loss=CategoricalCrossentropy(),
optimizer=Adagrad(),
metrics=[Accuracy(), Precision(),
AUC(), FalseNegatives()])
return mod_retorno
def UNet3DPatch(shape, weights=None):
conv_encoder = []
encoder_filters = np.array([8, 16, 32, 32])
mid_filters = 32
decoder_filters = np.array([64, 32, 16, 8])
bottom_filters = 4
inputs = Input(shape)
# encoder
x = inputs
for filters in encoder_filters:
conv = UNet3DBlock(x, layers=2, filters=filters)
x = MaxPooling3D(pool_size=(2, 2, 2))(conv)
conv_encoder.append(conv)
x = UNet3DBlock(x, layers=1, filters=mid_filters)
# decoder
for filters in decoder_filters:
x = UNet3DBlock(x, layers=2, filters=filters)
x = UpSampling3D(size=(2, 2, 2))(x)
x = concatenate([conv_encoder.pop(), x])
x = UNet3DBlock(x, layers=2, filters=bottom_filters)
outputs = Conv3D(1, 1, activation='sigmoid')(x)
model = Model(inputs=inputs, outputs=outputs)
model.compile(optimizer=Adam(learning_rate=1e-4),
loss='binary_crossentropy',
metrics=[AUC(), dice_coef])
model.summary()
return model
def build(self):
model = models.Sequential()
model.add(
layers.Dense(500,
input_shape=(self.vector_size, ),
activation='relu'))
model.add(layers.Dense(700, activation='relu'))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(1000, activation='relu'))
model.add(layers.Dense(500, activation='relu'))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(250, activation='relu'))
model.add(layers.Dense(100, activation='relu'))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(50, activation='relu'))
model.add(layers.Dense(self.num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=[
'acc',
Precision(name="prec"),
Recall(name="rec"),
AUC(name='auc')
])
return model
def load_model(arch, LR, X, y, L1_coef, encoder=None):
print('CREATING NEURAL NET')
opt = Adam(learning_rate=LR)
model = None
if encoder == None:
inputs = Input(shape=(X.shape[1], ))
h = layers.Dense(arch[0],
kernel_regularizer=l1_l2(l1=L1_coef, l2=0.0),
activation='relu')(inputs)
h = layers.BatchNormalization()(h)
h = layers.Dense(arch[1], activation='relu')(h)
h = layers.BatchNormalization()(h)
h = layers.Dense(arch[2], activation='relu')(h)
h = layers.BatchNormalization()(h)
h = layers.Dense(arch[3], activation='relu')(h)
h = layers.BatchNormalization()(h)
h = layers.Dense(arch[4], activation='relu')(h)
output = layers.Dense(5, activation='softmax')(h)
model = Model(inputs=inputs, outputs=output)
else:
print('Transfer encoder to classifier and fine-tuning...')
model = Sequential([encoder, layers.Dense(5, activation='softmax')])
model.compile(
optimizer=opt,
loss=tf.keras.losses.CategoricalCrossentropy(),
metrics=['acc', AUC(), Recall(), Precision()],
)
return model
def define_stacked_model(neural_nets, features, trainable=True):
if trainable == False:
for model in neural_nets:
for layer in model.layers:
layer.trainable = False
ensemble_visible = [model.input for model in neural_nets]
ensemble_outputs = [model.layers[14].output for model in neural_nets
] # The final dense layer of size 16.
merge = layers.concatenate(ensemble_outputs)
hidden = layers.Dense(32, activation='relu')(merge)
hidden_drop = layers.Dropout(0.2)(hidden)
hidden2 = layers.Dense(16, activation='relu')(hidden_drop)
hidden3 = layers.Dense(4, activation='relu')(hidden2)
output = layers.Dense(1, activation='sigmoid')(hidden3)
model = Model(inputs=ensemble_visible, outputs=output)
model.compile(
loss='binary_crossentropy',
optimizer=Adam(learning_rate=0.001),
metrics=['accuracy',
AUC(), Specificity, Sensitivity, F1_metric])
return model
def classifier(X, Y, clusters):
X_train = X.sample(frac=0.8)
Y_train = Y.loc[X_train.index]
X_val = X.drop(X_train.index)
Y_val = Y.drop(X_train.index)
c_w = compute_class_weight('balanced', np.unique(clusters), clusters)
c_w = dict(enumerate(c_w))
METRICS = [Recall(name='recall'), AUC(name='auc', multi_label=False)]
es = EarlyStopping(monitor='weighted_recall',
mode='max',
verbose=0,
patience=6)
model = Sequential()
model.add(Dense(32, input_dim=X_train.shape[1], activation='relu'))
model.add(Dense(16, activation='relu'))
model.add(Dense(Y_train.shape[1], activation='softmax'))
# Compile model
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=METRICS,
weighted_metrics=METRICS)
model.fit(X_train,
Y_train,
epochs=500,
batch_size=128,
validation_data=(X_val, Y_val),
shuffle=False,
verbose=1,
callbacks=[es],
class_weight=c_w)
return model
def main():
""" Main function. """
# datasets = Datasets('../project_data/classificationProcessed')
datasets = Datasets(ARGS.basepath)
model = ChestClassModel()
model(tf.keras.Input(shape=(512, 512, 3)))
checkpoint_path = "./classificationWeights5/"
print(model.summary())
if ARGS.load_checkpoint is not None:
model.load_weights(ARGS.load_checkpoint)
# Compile model graph
# optimizer = tf.keras.optimizers.Adam(learning_rate=0.00001)
optimizer = tf.keras.optimizers.Adam(learning_rate=ARGS.learningrate)
#changed from sparse_categorical
model.compile(optimizer=optimizer,
loss="categorical_crossentropy",
metrics=[AUC(multi_label=True), "acc", "binary_accuracy"])
if ARGS.evaluate:
test(model, datasets.test_data)
else:
train(model, datasets, checkpoint_path)
model.save_weights('./classificationWeights5/allWeights.h5')
def calculate(self, *args):
# prepare data
train_X, train_Y = self.trainset
test_X, test_Y = self.testset
# build model
mirrored_strategy = tf.distribute.MirroredStrategy()
with mirrored_strategy.scope():
self.model = DeepFM_model(self.feature_columns)
self.model.summary()
# ======== model checkpoint ===
# check_path = '../save/fm_weights.epoch_{epoch:04d}.val_loss_{val_loss:.4f}.ckpt'
# checkpoint = tf.keras.callbacks.ModelCheckpoint(check_path, save_weights_only=True,
# verbose=1, period=5)
# ======== compile
self.model.compile(loss = binary_crossentropy,optimizer=Adam(learning_rate = global_args.learning_rate), \
metrics = [AUC()])
# ======== model fit
import pdb
pdb.set_trace()
self.model.fit(train_X,
train_Y,
epochs=global_args.epochs,
callbacks=[
EarlyStopping(monitor='val_loss',
patience=1,
restore_best_weights=True)
],
batch_size=global_args.batch_size,
validation_split=0.1)
# ======== evaluate
print('test AUC: %f' % self.model.evaluate(
test_X, test_Y, batch_size=global_args.batch_size)[1])
return 'done'
def build(self):
model = models.Sequential()
model.add(
layers.Conv2D(32, (3, 3),
activation='relu',
input_shape=(self.input_width_height,
self.input_width_height,
self.channels)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dropout(0.5)) # Dropout for regularization
model.add(layers.Dense(512, activation='relu'))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(self.num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=[
'acc',
Precision(name="prec"),
Recall(name="rec"),
AUC(name='auc')
])
return model
def main(learning_rate, epochs, hidden_units):
"""
feature_columns is a list and contains two dict：
- dense_features: {feat: dense_feature_name}
- sparse_features: {feat: sparse_feature_name, feat_num: the number of this feature}
train_X: [dense_train_X, sparse_train_X]
test_X: [dense_test_X, sparse_test_X]
"""
feature_columns, train_X, test_X, train_y, test_y = create_dataset()
# ============================Build Model==========================
model = Deep_Crossing(feature_columns, hidden_units)
model.summary()
# ============================model checkpoint======================
check_path = 'save/deep_crossing_weights.epoch_{epoch:04d}.val_loss_{val_loss:.4f}.ckpt'
checkpoint = tf.keras.callbacks.ModelCheckpoint(check_path,
save_weights_only=True,
verbose=1,
period=5)
# =========================Compile============================
model.compile(loss=binary_crossentropy,
optimizer=Adam(learning_rate=learning_rate),
metrics=[AUC()])
# ===========================Fit==============================
model.fit(train_X,
train_y,
epochs=epochs,
callbacks=[checkpoint],
batch_size=128,
validation_split=0.2)
# ===========================Test==============================
print('test AUC: %f' % model.evaluate(test_X, test_y)[1])
def create_cnn(num_classes: int = 2) -> tf.keras.Model:
x = Input(shape=(256, ), dtype="int64")
h = Embedding(en2vec.corpus_size + 1, 128, input_length=256)(x)
conv1 = Convolution1D(filters=256, kernel_size=10, activation="tanh")(h)
conv2 = Convolution1D(filters=256, kernel_size=7, activation="tanh")(h)
conv3 = Convolution1D(filters=256, kernel_size=5, activation="tanh")(h)
conv4 = Convolution1D(filters=256, kernel_size=3, activation="tanh")(h)
h = Concatenate()([
GlobalMaxPooling1D()(conv1),
GlobalMaxPooling1D()(conv2),
GlobalMaxPooling1D()(conv3),
GlobalMaxPooling1D()(conv4),
])
h = Dense(1024, activation="selu", kernel_initializer="lecun_normal")(h)
h = AlphaDropout(0.1)(h)
h = Dense(1024, activation="selu", kernel_initializer="lecun_normal")(h)
h = AlphaDropout(0.1)(h)
y = Dense(num_classes, activation="softmax")(h)
model = Model(x, y)
model.compile(optimizer="adam",
loss="categorical_crossentropy",
metrics=["accuracy", AUC()])
return model
def train_model(self, themes_weight: ThemeWeights,
dataset: TrainValidationDataset, voc_size: int,
keras_callback: LambdaCallback):
article_length = dataset.article_length
theme_count = dataset.theme_count
model = tf.keras.Sequential([
keras.layers.Embedding(input_dim=voc_size,
input_length=article_length,
output_dim=self.embedding_output_dim,
mask_zero=True),
Dropout(0.3),
keras.layers.Conv1D(filters=64,
kernel_size=3,
input_shape=(voc_size,
self.embedding_output_dim),
activation=tf.nn.relu),
#keras.layers.MaxPooling1D(3),
#keras.layers.Bidirectional(keras.layers.LSTM(64)),
keras.layers.GlobalAveragePooling1D(),
Dropout(0.3),
keras.layers.Dense(theme_count, activation=tf.nn.sigmoid)
])
model.compile(optimizer=tf.keras.optimizers.Adam(clipnorm=1),
loss=WeightedBinaryCrossEntropy(
themes_weight.weight_array()),
metrics=[
AUC(multi_label=True),
BinaryAccuracy(),
TruePositives(),
TrueNegatives(),
FalseNegatives(),
FalsePositives(),
Recall(),
Precision()
],
run_eagerly=True)
model.summary()
self.__model__ = model
if self.__plot_directory is not None:
self.plot_model(self.__plot_directory)
# Fix for https://github.com/tensorflow/tensorflow/issues/38988
model._layers = [
layer for layer in model._layers if not isinstance(layer, dict)
]
callbacks = [ManualInterrupter(), keras_callback]
model.fit(dataset.trainData,
epochs=self.epochs,
steps_per_epoch=dataset.train_batch_count,
validation_data=dataset.validationData,
validation_steps=dataset.validation_batch_count,
callbacks=callbacks)
def __init__(self, model, data, config):
self.model_train = model['train']
self.model_eval = model['eval']
self.data = data
self.config = config
self.loss_fn = BinaryCrossentropy()
self.optimizer = Adam(learning_rate=self.config.learning_rate)
self.metrics = ['accuracy', AUC()]
def get_mlp_epi2(shape_value):
mlp = Sequential([
Input(shape=(shape_value, )),
Dense(256, activation="relu"),
Dense(128, activation="relu"),
Dense(32, activation="relu"),
Dense(1, activation="sigmoid")
], "MLP2")
mlp.compile(optimizer="nadam",
loss="binary_crossentropy",
metrics=[
"accuracy",
AUC(curve="ROC", name="auroc"),
AUC(curve="PR", name="auprc")
])
return mlp