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 fit(self, X, Y=None, val_X=None, val_Y=None, num_epochs=300, batch_size=None, start_temp=10.0,
min_temp=0.1, tryout_limit=1, class_weight=None):
if Y is None:
Y = X
assert len(X) == len(Y)
validation_data = None
if val_X is not None and val_Y is not None:
assert len(val_X) == len(val_Y)
validation_data = (val_X, val_Y)
if batch_size is None:
batch_size = max(len(X) // 256, 16)
steps_per_epoch = (len(X) + batch_size - 1) // batch_size
for i in range(tryout_limit):
K.set_learning_phase(1)
inputs = layers.Input(shape=X.shape[1:])
alpha = np.exp(np.log(min_temp / start_temp) / (num_epochs * steps_per_epoch))
self.concrete_select = ConcreteSelect(self.K, start_temp, min_temp, alpha, name='concrete_select')
selected_features = self.concrete_select(inputs)
outputs = self.output_function(selected_features)
self.model = models.Model(inputs, outputs)
self.model.compile(
loss=LinearSVC.loss_function(loss_function, class_weight),
optimizer=optimizer_class(lr=initial_lr),
metrics=[LinearSVC.accuracy]
)
print(self.model.summary())
stopper_callback = StopperCallback()
hist = self.model.fit(X, Y, batch_size, num_epochs, verbose=0, callbacks=[stopper_callback],
validation_data=validation_data) # , validation_freq = 10)
if K.get_value(
K.mean(K.max(K.softmax(self.concrete_select.logits, axis=-1)))) >= stopper_callback.mean_max_target:
break
num_epochs *= 2
self.probabilities = K.get_value(K.softmax(self.model.get_layer('concrete_select').logits))
self.indices = K.get_value(K.argmax(self.model.get_layer('concrete_select').logits))
return self
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
