def train_Keras(train_X, train_y, test_X, test_y, kwargs, cae_model_func=None, n_features=None, epochs=150):
normalization = normalization_func()
num_classes = train_y.shape[-1]
norm_train_X = normalization.fit_transform(train_X)
norm_test_X = normalization.transform(test_X)
batch_size = max(2, len(train_X) // 50)
class_weight = train_y.shape[0] / np.sum(train_y, axis=0)
class_weight = num_classes * class_weight / class_weight.sum()
sample_weight = None
print('mu :', kwargs['mu'], ', batch_size :', batch_size)
print('reps : ', reps, ', weights : ', class_weight)
if num_classes == 2:
sample_weight = np.zeros((len(norm_train_X),))
sample_weight[train_y[:, 1] == 1] = class_weight[1]
sample_weight[train_y[:, 1] == 0] = class_weight[0]
class_weight = None
model_clbks = [
callbacks.LearningRateScheduler(scheduler()),
]
if cae_model_func is not None:
svc_model = LinearSVC(nfeatures=(n_features,), **kwargs)
svc_model.create_keras_model(nclasses=num_classes)
classifier = svc_model.model
cae_model = cae_model_func(output_function=classifier, K=n_features)
start_time = time.process_time()
cae_model.fit(
norm_train_X, train_y, norm_test_X, test_y, num_epochs=800, batch_size=batch_size,
class_weight=class_weight
)
model = cae_model.model
model.indices = cae_model.get_support(True)
model.heatmap = cae_model.probabilities.max(axis=0)
model.fs_time = time.process_time() - start_time
else:
svc_model = LinearSVC(norm_train_X.shape[1:], **kwargs)
svc_model.create_keras_model(nclasses=num_classes)
model = svc_model.model
model.compile(
loss=LinearSVC.loss_function(loss_function, class_weight),
optimizer=optimizer_class(lr=initial_lr),
metrics=[LinearSVC.accuracy]
)
model.fit(
norm_train_X, train_y, batch_size=batch_size,
epochs=epochs,
callbacks=model_clbks,
validation_data=(norm_test_X, test_y),
class_weight=class_weight,
sample_weight=sample_weight,
verbose=verbose
)
model.normalization = normalization
return model
def train_Keras(train_X, train_y, test_X, test_y, kwargs, epochs=150):
normalization = normalization_func()
num_classes = train_y.shape[-1]
norm_train_X = normalization.fit_transform(train_X)
norm_test_X = normalization.transform(test_X)
batch_size = max(2, len(train_X) // 50)
class_weight = train_y.shape[0] / np.sum(train_y, axis=0)
class_weight = num_classes * class_weight / class_weight.sum()
sample_weight = None
print('mu :', kwargs['mu'], ', batch_size :', batch_size)
print('reps : ', reps, ', weights : ', class_weight)
if num_classes == 2:
sample_weight = np.zeros((len(norm_train_X), ))
sample_weight[train_y[:, 1] == 1] = class_weight[1]
sample_weight[train_y[:, 1] == 0] = class_weight[0]
class_weight = None
svc_model = LinearSVC(nfeatures=norm_train_X.shape[1:], **kwargs)
svc_model.create_keras_model(nclasses=num_classes)
model_clbks = [
callbacks.LearningRateScheduler(scheduler()),
]
fs_callbacks = []
model = svc_model.model
e2efs_layer = None
optimizer = optimizer_class(e2efs_layer, learning_rate=initial_lr)
model.compile(loss=LinearSVC.loss_function(loss_function, class_weight),
optimizer=optimizer,
metrics=[LinearSVC.accuracy])
model.fit(norm_train_X,
train_y,
batch_size=batch_size,
epochs=epochs,
callbacks=model_clbks,
validation_data=(norm_test_X, test_y),
class_weight=class_weight,
sample_weight=sample_weight,
verbose=verbose)
model.normalization = normalization
return model
def train_Keras(train_X,
train_y,
test_X,
test_y,
kwargs,
e2efs_class=None,
n_features=None,
epochs=150):
normalization = normalization_func()
num_classes = train_y.shape[-1]
norm_train_X = normalization.fit_transform(train_X)
norm_test_X = normalization.transform(test_X)
batch_size = max(2, len(train_X) // 50)
class_weight = train_y.shape[0] / np.sum(train_y, axis=0)
class_weight = num_classes * class_weight / class_weight.sum()
sample_weight = None
print('mu :', kwargs['mu'], ', batch_size :', batch_size)
print('reps : ', reps, ', weights : ', class_weight)
if num_classes == 2:
sample_weight = np.zeros((len(norm_train_X), ))
sample_weight[train_y[:, 1] == 1] = class_weight[1]
sample_weight[train_y[:, 1] == 0] = class_weight[0]
class_weight = None
svc_model = LinearSVC(nfeatures=norm_train_X.shape[1:], **kwargs)
svc_model.create_keras_model(nclasses=num_classes)
model_clbks = [
callbacks.LearningRateScheduler(scheduler()),
]
fs_callbacks = []
if e2efs_class is not None:
classifier = svc_model.model
e2efs_layer = e2efs_class(n_features,
input_shape=norm_train_X.shape[1:])
model = e2efs_layer.add_to_model(classifier,
input_shape=norm_train_X.shape[1:])
fs_callbacks.append(
clbks.E2EFSCallback(factor_func=None,
units_func=None,
verbose=verbose))
else:
model = svc_model.model
e2efs_layer = None
optimizer = optimizer_class(e2efs_layer, lr=initial_lr)
model.compile(loss=LinearSVC.loss_function(loss_function, class_weight),
optimizer=optimizer,
metrics=[LinearSVC.accuracy])
if e2efs_class is not None:
model.fs_layer = e2efs_layer
model.heatmap = e2efs_layer.moving_heatmap
start_time = time.process_time()
model.fit(norm_train_X,
train_y,
batch_size=batch_size,
epochs=200000,
callbacks=fs_callbacks,
validation_data=(norm_test_X, test_y),
class_weight=class_weight,
sample_weight=sample_weight,
verbose=verbose)
model.fs_time = time.process_time() - start_time
model.fit(norm_train_X,
train_y,
batch_size=batch_size,
epochs=epochs,
callbacks=model_clbks,
validation_data=(norm_test_X, test_y),
class_weight=class_weight,
sample_weight=sample_weight,
verbose=verbose)
model.normalization = normalization
return model
def train_Keras(train_X,
train_y,
test_X,
test_y,
kwargs,
l2x_model_func=None,
n_features=None,
epochs=150):
normalization = normalization_func()
num_classes = train_y.shape[-1]
norm_train_X = normalization.fit_transform(train_X)
norm_test_X = normalization.transform(test_X)
batch_size = max(2, len(train_X) // 50)
class_weight = train_y.shape[0] / np.sum(train_y, axis=0)
class_weight = num_classes * class_weight / class_weight.sum()
sample_weight = None
print('mu :', kwargs['mu'], ', batch_size :', batch_size)
print('reps : ', reps, ', weights : ', class_weight)
if num_classes == 2:
sample_weight = np.zeros((len(norm_train_X), ))
sample_weight[train_y[:, 1] == 1] = class_weight[1]
sample_weight[train_y[:, 1] == 0] = class_weight[0]
class_weight = None
svc_model = LinearSVC(nfeatures=norm_train_X.shape[1:], **kwargs)
svc_model.create_keras_model(nclasses=num_classes)
model_clbks = [
callbacks.LearningRateScheduler(scheduler()),
]
fs_callbacks = [
callbacks.LearningRateScheduler(scheduler(extra_epochs=extra_epochs)),
]
if l2x_model_func is not None:
classifier = svc_model.model
l2x_model = l2x_model_func(norm_train_X.shape[1:], n_features)
classifier_input = layers.Multiply()(
[l2x_model.output, l2x_model.input])
output = classifier(classifier_input)
model = models.Model(l2x_model.input, output)
else:
model = svc_model.model
l2x_model = None
optimizer = optimizer_class(lr=initial_lr)
model.compile(loss=LinearSVC.loss_function(loss_function, class_weight),
optimizer=optimizer,
metrics=[LinearSVC.accuracy])
if l2x_model is not None:
model.l2x_model = l2x_model
start_time = time.process_time()
model.fit(norm_train_X,
train_y,
batch_size=batch_size,
epochs=epochs + extra_epochs,
callbacks=fs_callbacks,
validation_data=(norm_test_X, test_y),
class_weight=class_weight,
sample_weight=sample_weight,
verbose=0)
# scores = l2x_model.predict(norm_train_X, verbose=0, batch_size=batch_size).reshape((-1, np.prod(norm_train_X.shape[1:])))
# model.heatmap = compute_median_rank(scores, k=n_features)
model.heatmap = l2x_model.predict(
norm_train_X, verbose=0, batch_size=batch_size).reshape(
(-1, np.prod(norm_train_X.shape[1:]))).sum(axis=0)
model.fs_time = time.process_time() - start_time
else:
model.fit(norm_train_X,
train_y,
batch_size=batch_size,
epochs=epochs,
callbacks=model_clbks,
validation_data=(norm_test_X, test_y),
class_weight=class_weight,
sample_weight=sample_weight,
verbose=verbose)
model.normalization = normalization
return model
