def create_classifier(classifier_name, input_shape, nb_classes, output_directory, verbose=False):
if classifier_name == 'fcn':
from classifiers import fcn
return fcn.Classifier_FCN(output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'mlp':
from classifiers import mlp
return mlp.Classifier_MLP(output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'resnet':
from classifiers import resnet
return resnet.Classifier_RESNET(output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'mcnn':
from classifiers import mcnn
return mcnn.Classifier_MCNN(output_directory, verbose)
if classifier_name == 'tlenet':
from classifiers import tlenet
return tlenet.Classifier_TLENET(output_directory, verbose)
if classifier_name == 'twiesn':
from classifiers import twiesn
return twiesn.Classifier_TWIESN(output_directory, verbose)
if classifier_name == 'encoder':
from classifiers import encoder
return encoder.Classifier_ENCODER(output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'mcdcnn':
from classifiers import mcdcnn
return mcdcnn.Classifier_MCDCNN(output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'cnn': # Time-CNN
from classifiers import cnn
return cnn.Classifier_CNN(output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'inception':
from classifiers import inception
return inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose)
def create_classifier(classifier_name, input_shape, nb_classes, output_directory, classification,
verbose=False, build=True):
if classifier_name == 'nne':
from classifiers import nne
return nne.Classifier_NNE(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'inception':
from classifiers import inception
return inception.Classifier_INCEPTION(classification, output_directory, input_shape, nb_classes, verbose, build=build)
def create_classifier(classifier_name, input_shape, nb_classes, output_directory, verbose=2):
if classifier_name == 'masked-fcn':
from classifiers import masked_fcn
return masked_fcn.Classifier_FCN(output_directory, input_shape, nb_classes, verbose=verbose, nb_epochs=30000, kernel_size=32, filters=64, batch_size=32, depth=2)
#return masked_fcn.Classifier_FCN(output_directory, input_shape, nb_classes, verbose=verbose, nb_epochs=20000)
#return masked_fcn.Classifier_FCN(output_directory, input_shape, nb_classes, verbose=verbose, nb_epochs=20000, kernel_size=21, filters=32, batch_size=128, depth=3)
if classifier_name == 'fcn':
from classifiers import fcn
return fcn.Classifier_FCN(output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'mlp':
from classifiers import mlp
return mlp.Classifier_MLP(output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'resnet':
from classifiers import resnet
return resnet.Classifier_RESNET(output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'masked-resnet':
from classifiers import masked_resnet
return masked_resnet.Classifier_RESNET(output_directory, input_shape, nb_classes, verbose, nb_epochs=20000)
if classifier_name == 'mcnn':
from classifiers import mcnn
return mcnn.Classifier_MCNN(output_directory, verbose)
if classifier_name == 'tlenet':
from classifiers import tlenet
return tlenet.Classifier_TLENET(output_directory, verbose)
if classifier_name == 'twiesn':
from classifiers import twiesn
return twiesn.Classifier_TWIESN(output_directory, verbose)
if classifier_name == 'encoder':
from classifiers import encoder
return encoder.Classifier_ENCODER(output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'mcdcnn':
from classifiers import mcdcnn
return mcdcnn.Classifier_MCDCNN(output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'cnn': # Time-CNN
from classifiers import cnn
return cnn.Classifier_CNN(output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'inception':
from classifiers import inception
return inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'masked-inception':
from classifiers import masked_inception
#return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=4, nb_filters=16, kernel_size=21, nb_epochs=40000, bottleneck_size=8)
return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=2, nb_filters=64, kernel_size=15, nb_epochs=40000, bottleneck_size=16, use_residual=False)
#return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=6, nb_filters=32, kernel_size=41, nb_epochs=60000, bottleneck_size=32)
#return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=4, nb_filters=8, kernel_size=15, nb_epochs=10000, bottleneck_size=8)
#return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=6, nb_filters=32, kernel_size=41, nb_epochs=2, bottleneck_size=32)
if classifier_name == 'xcm':
from classifiers import xcm
return xcm.Classifier_XCM(output_directory, input_shape, nb_classes, nb_epochs=20000, verbose=verbose)
if classifier_name == 'masked-xcm':
from classifiers import masked_xcm
#return masked_xcm.Classifier_XCM(output_directory, input_shape, nb_classes, nb_epochs=20000, verbose=verbose)
return masked_xcm.Classifier_XCM(output_directory, input_shape, nb_classes, nb_epochs=20000, verbose=verbose, filters=64, depth=2)
def create_classifier(args,
classifier_name,
epochs,
input_shape,
nb_classes,
output_directory,
verbose=False):
if classifier_name == 'fcn':
from classifiers import fcn
return fcn.Classifier_FCN(output_directory, input_shape, nb_classes,
verbose)
if classifier_name == 'mlp':
from classifiers import mlp
return mlp.Classifier_MLP(output_directory, input_shape, nb_classes,
verbose)
if classifier_name == 'resnet': #
from classifiers import resnet
return resnet.Classifier_RESNET(epochs, output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'mcnn':
from classifiers import mcnn
return mcnn.Classifier_MCNN(output_directory, verbose)
if classifier_name == 'tlenet':
from classifiers import tlenet
return tlenet.Classifier_TLENET(output_directory, verbose)
if classifier_name == 'twiesn':
from classifiers import twiesn
return twiesn.Classifier_TWIESN(output_directory, verbose)
if classifier_name == 'encoder': #
from classifiers import encoder
return encoder.Classifier_ENCODER(epochs, output_directory,
input_shape, nb_classes, verbose)
if classifier_name == 'mcdcnn':
from classifiers import mcdcnn
return mcdcnn.Classifier_MCDCNN(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'cnn': # Time-CNN #modified
from classifiers import cnn
from classifiers import cnnES
if args.es_patience is None:
print('without early stopping')
return cnn.Classifier_CNN(epochs, output_directory, input_shape,
nb_classes, verbose)
else:
print('with early stopping')
return cnnES.Classifier_CNN(args.es_patience, epochs,
output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'inception':
from classifiers import inception
return inception.Classifier_INCEPTION(output_directory, input_shape,
nb_classes, verbose)
def create_classifier(self,
model_name,
input_shape,
nb_classes,
output_directory,
verbose=False,
build=True):
if self.check_if_match('inception*', model_name):
from classifiers import inception
return inception.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
build=build)
def create_classifier(classifier_name,
input_shape,
nb_classes,
output_directory,
verbose=False,
input_agg=10,
dense=32):
if classifier_name == 'fcn_extension':
from classifiers import fcn_extension
return fcn_extension.Classifier_CNN_TSFRESH(output_directory,
input_shape,
nb_classes,
verbose,
input_agg=input_agg,
dense=dense)
if classifier_name == 'resnet_extension':
from classifiers import resnet_extension
return resnet_extension.Classifier_RESNET_TSFRESH(output_directory,
input_shape,
nb_classes,
verbose,
input_agg=input_agg,
dense=dense)
if classifier_name == 'inception_extension':
from classifiers import inception_extension
return inception_extension.Classifier_INCEPTION_TSFRESH(
output_directory,
input_shape,
nb_classes,
verbose,
input_agg=input_agg,
dense=dense)
if classifier_name == 'fcn':
from classifiers import fcn
return fcn.Classifier_FCN(output_directory, input_shape, nb_classes,
verbose)
if classifier_name == 'resnet':
from classifiers import resnet
return resnet.Classifier_RESNET(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'inception':
from classifiers import inception
return inception.Classifier_INCEPTION(output_directory, input_shape,
nb_classes, verbose)
temp_output_directory = create_directory(output_directory)
if temp_output_directory is None:
print('\t\t\t\t', 'Already_done')
continue
input_shape = x_train.shape[1:]
# Train the model
from classifiers import inception
classifier = inception.Classifier_INCEPTION(
output_directory,
input_shape,
nb_classes,
verbose=False,
build=True,
**kwargs)
classifier.fit(x_train, y_train, x_test, y_test, y_true)
# the creation of this directory means
create_directory(output_directory + '/DONE')
print('\t\t\t\t', 'TRAINING DONE')
# we now need to ensemble each iteration of inception (aka InceptionTime)
archive_name = config['ARCHIVE']['archive_name']
classifier_name = 'nne' # Test the model
def create_classifier(classifier_name,
input_shape,
nb_classes,
output_directory,
verbose=2):
if classifier_name == 'masked-fcn':
from classifiers import masked_fcn
#return masked_fcn.Classifier_FCN(output_directory, input_shape, nb_classes, verbose=verbose, nb_epochs=20000, kernel_size=32, filters=64, batch_size=32, depth=2)
#return masked_fcn.Classifier_FCN(output_directory, input_shape, nb_classes, verbose=verbose, nb_epochs=20000)
return masked_fcn.Classifier_FCN(output_directory,
input_shape,
nb_classes,
verbose=verbose,
nb_epochs=6000,
kernel_size=101,
filters=8,
batch_size=16,
depth=3)
#return masked_fcn.Classifier_FCN(output_directory, input_shape, nb_classes, verbose=verbose, nb_epochs=30000, kernel_size=32, filters=64, batch_size=32, depth=2)
# return masked_fcn.Classifier_FCN(output_directory, input_shape, nb_classes, verbose=verbose, nb_epochs=20000)
# return masked_fcn.Classifier_FCN(output_directory, input_shape, nb_classes, verbose=verbose, nb_epochs=20000, kernel_size=21, filters=32, batch_size=128, depth=3)
if classifier_name == 'fcn':
from classifiers import fcn
return fcn.Classifier_FCN(output_directory, input_shape, nb_classes,
verbose)
if classifier_name == 'mlp':
from classifiers import mlp
return mlp.Classifier_MLP(output_directory, input_shape, nb_classes,
verbose)
if classifier_name == 'resnet':
from classifiers import resnet
return resnet.Classifier_RESNET(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'masked-resnet':
from classifiers import masked_resnet
return masked_resnet.Classifier_RESNET(output_directory,
input_shape,
nb_classes,
verbose,
nb_epochs=20000)
if classifier_name == 'mcnn':
from classifiers import mcnn
return mcnn.Classifier_MCNN(output_directory, verbose)
if classifier_name == 'tlenet':
from classifiers import tlenet
return tlenet.Classifier_TLENET(output_directory, verbose)
if classifier_name == 'twiesn':
from classifiers import twiesn
return twiesn.Classifier_TWIESN(output_directory, verbose)
if classifier_name == 'encoder':
from classifiers import encoder
return encoder.Classifier_ENCODER(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'mcdcnn':
from classifiers import mcdcnn
return mcdcnn.Classifier_MCDCNN(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'cnn': # Time-CNN
from classifiers import cnn
return cnn.Classifier_CNN(output_directory, input_shape, nb_classes,
verbose)
if classifier_name == 'inception':
from classifiers import inception
return inception.Classifier_INCEPTION(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'masked-inception':
from classifiers import masked_inception
#return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=4, nb_filters=16, kernel_size=21, nb_epochs=40000, bottleneck_size=8)
return masked_inception.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=2,
nb_filters=64,
kernel_size=31,
nb_epochs=15000,
bottleneck_size=32,
use_residual=False)
#return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=6, nb_filters=32, kernel_size=41, nb_epochs=60000, bottleneck_size=32)
#return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=4, nb_filters=8, kernel_size=15, nb_epochs=10000, bottleneck_size=8)
#return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=6, nb_filters=32, kernel_size=41, nb_epochs=2, bottleneck_size=32)
# return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=4, nb_filters=16, kernel_size=21, nb_epochs=40000, bottleneck_size=8)
#return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=2, nb_filters=64, kernel_size=15, nb_epochs=40000, bottleneck_size=16, use_residual=False)
# return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=6, nb_filters=32, kernel_size=41, nb_epochs=60000, bottleneck_size=32)
# return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=4, nb_filters=8, kernel_size=15, nb_epochs=10000, bottleneck_size=8)
# return masked_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=6, nb_filters=32, kernel_size=41, nb_epochs=2, bottleneck_size=32)
if classifier_name == 'xcm':
from classifiers import xcm
return xcm.Classifier_XCM(output_directory,
input_shape,
nb_classes,
nb_epochs=20000,
verbose=verbose)
if classifier_name == 'masked-xcm':
from classifiers import masked_xcm
#return masked_xcm.Classifier_XCM(output_directory, input_shape, nb_classes, nb_epochs=20000, verbose=verbose)
#return masked_xcm.Classifier_XCM(output_directory, input_shape, nb_classes, nb_epochs=7000, verbose=verbose, filters=8, depth=2, decay=False, mask=True, window=141)
#return masked_xcm.Classifier_XCM(output_directory, input_shape, nb_classes, nb_epochs=7000, verbose=verbose, filters=16, depth=2, decay=False, mask=True, window=51, lr=0.001)
#return masked_xcm.Classifier_XCM(output_directory, input_shape, nb_classes, nb_epochs=20000, verbose=verbose, filters=64, depth=2)
return masked_xcm.Classifier_XCM(output_directory,
input_shape,
nb_classes,
nb_epochs=7000,
verbose=verbose,
filters=8,
depth=3,
window=41,
decay=False)
if classifier_name == 'net1d':
from classifiers import net1d
return net1d.Classifier_NET1d(output_directory,
input_shape,
nb_classes,
nb_epochs=8000,
verbose=verbose,
filters=16,
depth=2,
window=31,
decay=False,
batch_size=32)
if classifier_name == 'net1d-v2':
from classifiers import net1d_v2
return net1d_v2.Classifier_NET1d(output_directory,
input_shape,
nb_classes,
nb_epochs=7000,
verbose=verbose,
filters=32,
depth=2,
window=41,
decay=False)
if classifier_name == 'cnn2d':
from classifiers import cnn2d
return cnn2d.Classifier_CNN2D(output_directory,
input_shape,
nb_classes,
nb_epochs=8000,
verbose=verbose,
filters=4,
depth=2,
decay=False,
window=121,
batch_size=32)
#return cnn2d.Classifier_CNN2D(output_directory, input_shape, nb_classes, nb_epochs=15000, verbose=verbose, filters=64, depth=2, decay=False, window=31, batch_size=16)
#return cnn2d.Classifier_CNN2D(output_directory, input_shape, nb_classes, nb_epochs=10, verbose=verbose, filters=64, depth=3, decay=True, window=31)
if classifier_name == 'net1d-mod':
from classifiers import net1d_mod
return net1d_mod.Classifier_NET1d(output_directory,
input_shape,
nb_classes,
nb_epochs=7000,
verbose=verbose,
filters=16,
depth=2,
window=31,
decay=False,
batch_size=32)
def create_classifier(classifier_name,
input_shape,
nb_classes,
output_directory,
verbose=2,
class_weight=None):
if classifier_name == 'masked-fcn':
from classifiers import masked_fcn
return masked_fcn.Classifier_FCN(output_directory,
input_shape,
nb_classes,
verbose=verbose,
nb_epochs=5000,
kernel_size=101,
filters=8,
batch_size=16,
depth=3)
if classifier_name == 'masked-resnet':
from classifiers import masked_resnet
return masked_resnet.Classifier_RESNET(output_directory,
input_shape,
nb_classes,
verbose,
nb_epochs=5000)
if classifier_name == 'masked-resnet-mod':
from classifiers import masked_resnet_mod
return masked_resnet_mod.Classifier_RESNET(output_directory,
input_shape,
nb_classes,
verbose,
nb_epochs=5000,
batch_size=32,
n_feature_maps=64,
depth=4)
if classifier_name == 'masked-inception':
from classifiers import masked_inception
return masked_inception.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=2,
nb_filters=128,
kernel_size=31,
nb_epochs=5000,
bottleneck_size=32,
use_residual=True)
if classifier_name == 'masked-inception-mod':
from classifiers import masked_inception_mod
return masked_inception_mod.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=2,
nb_filters=128,
kernel_size=31,
nb_epochs=2000,
bottleneck_size=8,
use_residual=False,
lr=0.005)
if classifier_name == 'inception-conf':
from classifiers import inception_conf
return inception_conf.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=2,
nb_filters=128,
kernel_size=31,
nb_epochs=2000,
bottleneck_size=8,
use_residual=False,
lr=0.005)
if classifier_name == 'inception':
from classifiers import inception
return inception.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=2,
nb_filters=128,
kernel_size=31,
nb_epochs=2000,
bottleneck_size=8,
use_residual=False,
lr=0.005)
if classifier_name == 'inception-coral':
from classifiers import inception_coral
return inception_coral.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=2,
nb_filters=128,
kernel_size=31,
nb_epochs=2000,
bottleneck_size=8,
use_residual=True,
lr=0.005)
if classifier_name == 'inception-focal':
from classifiers import inception_focal
return inception_focal.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=2,
nb_filters=128,
kernel_size=31,
nb_epochs=2000,
bottleneck_size=8,
use_residual=True,
lr=0.005)
if classifier_name == 'x-inception':
from classifiers import x_inception
return x_inception.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=1,
nb_filters=32,
kernel_size=31,
nb_epochs=2000,
bottleneck_size=32,
use_residual=False,
lr=0.005,
use_bottleneck=False)
if classifier_name == 'xx-inception':
from classifiers import xx_inception
# return xx_inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=1, nb_filters=8, kernel_size=21, nb_epochs=2000, bottleneck_size=32, use_residual=False, lr=0.01, use_bottleneck=False)
return xx_inception.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=1,
nb_filters=32,
kernel_size=31,
nb_epochs=2000,
bottleneck_size=32,
use_residual=False,
lr=0.005,
use_bottleneck=False)
if classifier_name == 'xx-inception-focal':
from classifiers import xx_inception_focal
return xx_inception_focal.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=1,
nb_filters=32,
kernel_size=31,
nb_epochs=600,
bottleneck_size=32,
use_residual=False,
lr=0.005,
use_bottleneck=False)
if classifier_name == 'xx-inception-conf':
from classifiers import xx_inception_conf
return xx_inception_conf.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=1,
nb_filters=32,
kernel_size=31,
nb_epochs=2000,
bottleneck_size=32,
use_residual=False,
lr=0.005,
use_bottleneck=False)
if classifier_name == 'xx-inception-coral':
from classifiers import xx_inception_coral
# return xx_inception_coral.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=1, nb_filters=64, kernel_size=51, nb_epochs=2000, bottleneck_size=32, use_residual=False, lr=0.01, use_bottleneck=False)
return xx_inception_coral.Classifier_INCEPTION(
output_directory,
input_shape,
nb_classes,
verbose,
depth=1,
nb_filters=32,
kernel_size=31,
nb_epochs=2000,
bottleneck_size=32,
use_residual=False,
lr=0.005,
use_bottleneck=True,
class_weight=class_weight)
#return xx_inception_coral.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=1, nb_filters=64, kernel_size=15, nb_epochs=2000, bottleneck_size=32, use_residual=False, lr=0.005, use_bottleneck=False, class_weight=class_weight)
if classifier_name == 'xx-inception-reg':
from classifiers import xx_inception_reg
return xx_inception_reg.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=1,
nb_filters=32,
kernel_size=31,
nb_epochs=2000,
bottleneck_size=32,
use_residual=False,
lr=0.005,
use_bottleneck=False)
if classifier_name == 'xx-inception-evidence':
from classifiers import xx_inception_evidence
# return xx_inception_evidence.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=1, nb_filters=64, kernel_size=21, nb_epochs=2000, bottleneck_size=32, use_residual=False, lr=0.01, use_bottleneck=False)
return xx_inception_evidence.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=1,
nb_filters=32,
kernel_size=31,
nb_epochs=2000,
bottleneck_size=32,
use_residual=False,
lr=0.05,
use_bottleneck=False,
batch_size=16)
if classifier_name == 'xx-inception-coral-ext':
from classifiers import xx_inception_coral_ext
return xx_inception_coral_ext.Classifier_INCEPTION(
output_directory,
input_shape,
nb_classes,
verbose,
depth=1,
nb_filters=64,
kernel_size=21,
nb_epochs=2000,
bottleneck_size=32,
use_residual=False,
lr=0.01,
use_bottleneck=False)
if classifier_name == 'coral-inception-mod':
from classifiers import coral_inception_mod
return coral_inception_mod.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=2,
nb_filters=128,
kernel_size=31,
nb_epochs=2000,
bottleneck_size=32,
use_residual=False,
lr=0.005,
batch_size=16)
#return coral_inception_mod.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose, depth=2, nb_filters=128, kernel_size=31, nb_epochs=2000, bottleneck_size=32, use_residual=False, lr=0.005, batch_size=4)
if classifier_name == 'malstm-fcn':
from classifiers import malstm_fcn
return malstm_fcn.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=1,
nb_filters=32,
kernel_size=31,
nb_epochs=2000,
bottleneck_size=32,
use_residual=False,
lr=0.001,
use_bottleneck=False)
if classifier_name == 'xcm':
from classifiers import xcm
return xcm.Classifier_XCM(output_directory,
input_shape,
nb_classes,
nb_epochs=5000,
verbose=verbose)
if classifier_name == 'masked-xcm':
from classifiers import masked_xcm
return masked_xcm.Classifier_XCM(output_directory,
input_shape,
nb_classes,
nb_epochs=5000,
verbose=verbose,
filters=[16, 32, 64],
depth=2,
window=[51, 31, 11],
decay=False)
if classifier_name == 'masked-xcm-mod':
from classifiers import masked_xcm_mod
return masked_xcm_mod.Classifier_XCM(output_directory,
input_shape,
nb_classes,
nb_epochs=5000,
verbose=verbose,
filters=[128, 128, 64],
depth=2,
window=[41, 31, 21],
decay=False,
batch_size=32)
# return masked_xcm_mod.Classifier_XCM(output_directory, input_shape, nb_classes, nb_epochs=5000, verbose=verbose, filters=[16, 32, 64, 128], depth=2, window=[51,31,21,11], decay=False)
if classifier_name == 'masked-xcm-2d':
from classifiers import masked_xcm_2d
return masked_xcm_2d.Classifier_XCM(output_directory,
input_shape,
nb_classes,
nb_epochs=2000,
verbose=verbose,
filters=256,
depth=1,
window=41,
decay=False,
batch_size=32)
if classifier_name == 'xcm-coral':
from classifiers import xcm_coral
return xcm_coral.Classifier_XCM(output_directory,
input_shape,
nb_classes,
nb_epochs=2000,
verbose=verbose,
filters=32,
depth=2,
window=31,
decay=False,
batch_size=32,
use_bottleneck=True,
use_1d=False)
if classifier_name == 'net1d':
from classifiers import net1d
return net1d.Classifier_NET1d(output_directory,
input_shape,
nb_classes,
nb_epochs=5000,
verbose=verbose,
filters=[16, 32, 64],
depth=2,
window=[51, 31, 11],
decay=False)
if classifier_name == 'net1d-v2':
from classifiers import net1d_v2
return net1d_v2.Classifier_NET1d(output_directory,
input_shape,
nb_classes,
nb_epochs=5000,
verbose=verbose,
filters=32,
depth=2,
window=41,
decay=False)
if classifier_name == 'cnn2d':
from classifiers import cnn2d
return cnn2d.Classifier_CNN2D(output_directory,
input_shape,
nb_classes,
nb_epochs=8000,
verbose=verbose,
filters=4,
depth=2,
decay=False,
window=121,
batch_size=32)
if classifier_name == 'net1d-mod':
from classifiers import net1d_mod
return net1d_mod.Classifier_NET1d(output_directory,
input_shape,
nb_classes,
nb_epochs=5000,
verbose=verbose,
filters=[128, 128],
depth=2,
window=[51, 31],
decay=False,
batch_size=32)
def create_classifier(classifier_name,
input_shape,
nb_classes,
output_directory,
verbose=2):
if classifier_name == 'fcn-simple':
from classifiers import small_fcn
return small_fcn.Classifier_FCN(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'masked-fcn':
from classifiers import masked_fcn
return masked_fcn.Classifier_FCN(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'masked-fcn-big':
from classifiers import masked_fcn_big
return masked_fcn_big.Classifier_FCN(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'fcn':
from classifiers import fcn
return fcn.Classifier_FCN(output_directory, input_shape, nb_classes,
verbose)
if classifier_name == 'mlp':
from classifiers import mlp
return mlp.Classifier_MLP(output_directory, input_shape, nb_classes,
verbose)
if classifier_name == 'resnet':
from classifiers import resnet
return resnet.Classifier_RESNET(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'masked-resnet':
from classifiers import masked_resnet
return masked_resnet.Classifier_RESNET(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'mcnn':
from classifiers import mcnn
return mcnn.Classifier_MCNN(output_directory, verbose)
if classifier_name == 'tlenet':
from classifiers import tlenet
return tlenet.Classifier_TLENET(output_directory, verbose)
if classifier_name == 'twiesn':
from classifiers import twiesn
return twiesn.Classifier_TWIESN(output_directory, verbose)
if classifier_name == 'encoder':
from classifiers import encoder
return encoder.Classifier_ENCODER(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'mcdcnn':
from classifiers import mcdcnn
return mcdcnn.Classifier_MCDCNN(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'cnn': # Time-CNN
from classifiers import cnn
return cnn.Classifier_CNN(output_directory, input_shape, nb_classes,
verbose)
if classifier_name == 'inception':
from classifiers import inception
return inception.Classifier_INCEPTION(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'masked-inception':
from classifiers import masked_inception
return masked_inception.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
nb_filters=16)
if classifier_name == 'inception_simple':
from classifiers import inception_simple
return inception_simple.Classifier_INCEPTION(output_directory,
input_shape, nb_classes,
verbose)
def create_classifier(classifier_name,
input_shape,
nb_classes,
output_directory,
verbose=2):
if classifier_name == 'masked-fcn':
from classifiers import masked_fcn
return masked_fcn.Classifier_FCN(output_directory,
input_shape,
nb_classes,
verbose=verbose,
nb_epochs=5000,
kernel_size=101,
filters=8,
batch_size=16,
depth=3)
if classifier_name == 'fcn':
from classifiers import fcn
return fcn.Classifier_FCN(output_directory, input_shape, nb_classes,
verbose)
if classifier_name == 'mlp':
from classifiers import mlp
return mlp.Classifier_MLP(output_directory, input_shape, nb_classes,
verbose)
if classifier_name == 'resnet':
from classifiers import resnet
return resnet.Classifier_RESNET(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'masked-resnet':
from classifiers import masked_resnet
return masked_resnet.Classifier_RESNET(output_directory,
input_shape,
nb_classes,
verbose,
nb_epochs=5000)
if classifier_name == 'masked-resnet-mod':
from classifiers import masked_resnet_mod
return masked_resnet_mod.Classifier_RESNET(output_directory,
input_shape,
nb_classes,
verbose,
nb_epochs=5000,
batch_size=32,
n_feature_maps=64,
depth=4)
if classifier_name == 'mcnn':
from classifiers import mcnn
return mcnn.Classifier_MCNN(output_directory, verbose)
if classifier_name == 'tlenet':
from classifiers import tlenet
return tlenet.Classifier_TLENET(output_directory, verbose)
if classifier_name == 'twiesn':
from classifiers import twiesn
return twiesn.Classifier_TWIESN(output_directory, verbose)
if classifier_name == 'encoder':
from classifiers import encoder
return encoder.Classifier_ENCODER(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'mcdcnn':
from classifiers import mcdcnn
return mcdcnn.Classifier_MCDCNN(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'cnn': # Time-CNN
from classifiers import cnn
return cnn.Classifier_CNN(output_directory, input_shape, nb_classes,
verbose)
if classifier_name == 'inception':
from classifiers import inception
return inception.Classifier_INCEPTION(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == 'masked-inception':
from classifiers import masked_inception
return masked_inception.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=2,
nb_filters=128,
kernel_size=31,
nb_epochs=5000,
bottleneck_size=32,
use_residual=True)
if classifier_name == 'masked-inception-mod':
from classifiers import masked_inception_mod
return masked_inception_mod.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=2,
nb_filters=128,
kernel_size=41,
nb_epochs=2000,
bottleneck_size=32,
use_residual=True,
lr=0.005)
if classifier_name == 'x-inception':
from classifiers import x_inception
return x_inception.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=2,
nb_filters=32,
kernel_size=41,
nb_epochs=2000,
bottleneck_size=16,
use_residual=True,
lr=0.005)
if classifier_name == 'x-inception-coral':
from classifiers import x_inception_coral
return x_inception_coral.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=2,
nb_filters=32,
kernel_size=41,
nb_epochs=2000,
bottleneck_size=16,
use_residual=True,
lr=0.005)
if classifier_name == 'coral-inception-mod':
from classifiers import coral_inception_mod
return coral_inception_mod.Classifier_INCEPTION(output_directory,
input_shape,
nb_classes,
verbose,
depth=2,
nb_filters=128,
kernel_size=41,
nb_epochs=2000,
bottleneck_size=64,
use_residual=True,
lr=0.005)
if classifier_name == 'xcm':
from classifiers import xcm
return xcm.Classifier_XCM(output_directory,
input_shape,
nb_classes,
nb_epochs=5000,
verbose=verbose)
if classifier_name == 'masked-xcm':
from classifiers import masked_xcm
return masked_xcm.Classifier_XCM(output_directory,
input_shape,
nb_classes,
nb_epochs=5000,
verbose=verbose,
filters=[16, 32, 64],
depth=2,
window=[51, 31, 11],
decay=False)
if classifier_name == 'masked-xcm-mod':
from classifiers import masked_xcm_mod
return masked_xcm_mod.Classifier_XCM(output_directory,
input_shape,
nb_classes,
nb_epochs=5000,
verbose=verbose,
filters=[128, 128, 64],
depth=2,
window=[41, 31, 21],
decay=False,
batch_size=32)
# return masked_xcm_mod.Classifier_XCM(output_directory, input_shape, nb_classes, nb_epochs=5000, verbose=verbose, filters=[16, 32, 64, 128], depth=2, window=[51,31,21,11], decay=False)
if classifier_name == 'masked-xcm-2d':
from classifiers import masked_xcm_2d
return masked_xcm_2d.Classifier_XCM(output_directory,
input_shape,
nb_classes,
nb_epochs=2000,
verbose=verbose,
filters=128,
depth=2,
window=41,
decay=False,
batch_size=32)
if classifier_name == 'net1d':
from classifiers import net1d
return net1d.Classifier_NET1d(output_directory,
input_shape,
nb_classes,
nb_epochs=5000,
verbose=verbose,
filters=[16, 32, 64],
depth=2,
window=[51, 31, 11],
decay=False)
if classifier_name == 'net1d-v2':
from classifiers import net1d_v2
return net1d_v2.Classifier_NET1d(output_directory,
input_shape,
nb_classes,
nb_epochs=5000,
verbose=verbose,
filters=32,
depth=2,
window=41,
decay=False)
if classifier_name == 'cnn2d':
from classifiers import cnn2d
return cnn2d.Classifier_CNN2D(output_directory,
input_shape,
nb_classes,
nb_epochs=8000,
verbose=verbose,
filters=4,
depth=2,
decay=False,
window=121,
batch_size=32)
if classifier_name == 'net1d-mod':
from classifiers import net1d_mod
return net1d_mod.Classifier_NET1d(output_directory,
input_shape,
nb_classes,
nb_epochs=5000,
verbose=verbose,
filters=[128, 128],
depth=2,
window=[51, 31],
decay=False,
batch_size=32)
