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,
verbose=False,
build=True,
load_weights=False):
if classifier_name == 'fcn':
from classifiers import fcn
return fcn.Classifier_FCN(output_directory,
input_shape,
nb_classes,
verbose,
build=build)
if classifier_name == 'mlp':
from classifiers import mlp
return mlp.Classifier_MLP(output_directory,
input_shape,
nb_classes,
verbose,
build=build)
if classifier_name == 'resnet':
from classifiers import resnet
return resnet.Classifier_RESNET(output_directory,
input_shape,
nb_classes,
verbose,
build=build,
load_weights=load_weights)
if classifier_name == 'encoder':
from classifiers import encoder
return encoder.Classifier_ENCODER(output_directory,
input_shape,
nb_classes,
verbose,
build=build)
if classifier_name == 'mcdcnn':
from classifiers import mcdcnn
return mcdcnn.Classifier_MCDCNN(output_directory,
input_shape,
nb_classes,
verbose,
build=build)
if classifier_name == 'cnn':
from classifiers import cnn
return cnn.Classifier_CNN(output_directory,
input_shape,
nb_classes,
verbose,
build=build)
if classifier_name == 'ensembletransfer':
from classifiers import ensembletransfer
return ensembletransfer.Classifier_ENSEMBLETRANSFER(
output_directory, input_shape, nb_classes, verbose)
if classifier_name == 'nne':
from classifiers import nne
return nne.Classifier_NNE(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=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,
load_weights=False):
if model_name == 'fcn':
from classifiers import fcn
return fcn.Classifier_FCN(output_directory,
input_shape,
nb_classes,
verbose,
build=build)
if model_name == 'mlp':
from classifiers import mlp
return mlp.Classifier_MLP(output_directory,
input_shape,
nb_classes,
verbose,
build=build)
if model_name == 'resnet':
from classifiers import resnet
return resnet.Classifier_RESNET(output_directory,
input_shape,
nb_classes,
verbose,
build=build,
load_weights=load_weights)
if model_name == 'encoder':
from classifiers import encoder
return encoder.Classifier_ENCODER(output_directory,
input_shape,
nb_classes,
verbose,
build=build)
if model_name == 'mcdcnn':
from classifiers import mcdcnn
return mcdcnn.Classifier_MCDCNN(output_directory,
input_shape,
nb_classes,
verbose,
build=build)
if model_name == 'cnn':
from classifiers import cnn
return cnn.Classifier_CNN(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)
def create_classifier(classifier_name, input_shape, nb_classes, output_directory, verbose = 1):
if classifier_name=='fcn':
from classifiers import fcn
return fcn.Classifier_FCN(output_directory,input_shape, nb_classes, verbose)
if classifier_name=='lstm':
from classifiers import lstm
return lstm.Classifier_LSTM(output_directory,input_shape, nb_classes, verbose)
if classifier_name=='encoder_lstm':
from classifiers import encoder_lstm
return encoder_lstm.encoder_LSTM(output_directory,input_shape, nb_classes, verbose)
if classifier_name=='encoder_fcn':
from classifiers import encoder_fcn
return encoder_fcn.encoder_FCN(output_directory,input_shape, nb_classes, verbose)
if classifier_name=='encoder_tcn':
from classifiers import encoder_tcn
return encoder_tcn.encoder_TCN(output_directory,input_shape, nb_classes, verbose)
if classifier_name=='encoder_fcn_nn':
from classifiers import encoder_fcn_nn
return encoder_fcn_nn.encoder_FCN_NN(output_directory,input_shape, nb_classes, verbose)
if classifier_name=='encoder_lstm_nn':
from classifiers import encoder_lstm_nn
return encoder_lstm_nn.encoder_LSTM_NN(output_directory,input_shape, nb_classes, verbose)
if classifier_name=='encoderEmb_lstm':
from classifiers import encoderEmb_lstm
return encoderEmb_lstm.encoderEmb_LSTM(output_directory,input_shape, nb_classes, verbose)
if classifier_name=='encoder_classic':
from classifiers import encoder_classic
return encoder_classic.encoder_CLASSIC(output_directory,input_shape, nb_classes, verbose)
if classifier_name=='encoder_classicDn':
from classifiers import encoder_classicDn
return encoder_classicDn.encoder_CLASSICDN(output_directory,input_shape, nb_classes, verbose)
if classifier_name=='tcn':
from classifiers import tcn
return tcn.Classifier_TCN(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=='encoder':
from classifiers import encoder
return encoder.Classifier_ENCODER(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)
def create_classifier(classifier_name,
input_shape,
nb_classes,
output_directory,
verbose=True):
if any(x in classifier_name for x in attention_models()):
from classifiers import attention_classifier
return attention_classifier.Classifier_Attention(classifier_name,
output_directory,
input_shape,
epoch=1,
verbose=True)
if classifier_name == 'resnet':
from classifiers import resnet
return resnet.Classifier_ResNet(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 == "cnn":
from classifiers import cnn
return cnn.Classifier_CNN(output_directory, input_shape, nb_classes,
verbose)
if classifier_name == "cnn_lstm":
from classifiers import cnn_lstm
return cnn_lstm.Classifier_CNN_LSTM(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == "fcn_lstm":
from classifiers import fcn_lstm
return fcn_lstm.Classifier_FCN_LSTM(output_directory, input_shape,
nb_classes, verbose)
if classifier_name == "resnet_lstm":
from classifiers import resnet_lstm
return resnet_lstm.Classifier_ResNet_LSTM(output_directory,
input_shape, nb_classes,
verbose)
if classifier_name == "rocket":
from classifiers import rocket
return rocket.Classifier_Rocket(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=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):
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)
