def __init__(self, model_config):
super(CNNPredictor, self).__init__(model_config, 'CNN')
conv_config, conv_layer_config, mlp_config = load_conv_spec(
self.model_config['nnet_spec'], self.batch_size,
self.model_config['input_shape'])
activationFn = parse_activation(mlp_config['activation'])
if mlp_config['do_dropout'] or conv_config['do_dropout']:
self.model = DropoutCNN(
self.numpy_rng,
self.theano_rng,
conv_layer_configs=conv_layer_config,
batch_size=self.batch_size,
n_outs=self.model_config['n_outs'],
hidden_layer_configs=mlp_config,
hidden_activation=activationFn,
use_fast=conv_config['use_fast'],
l1_reg=mlp_config['l1_reg'],
l2_reg=mlp_config['l1_reg'],
max_col_norm=mlp_config['max_col_norm'],
input_dropout_factor=conv_config['input_dropout_factor'])
else:
self.model = CNN(self.numpy_rng,
self.theano_rng,
conv_layer_configs=conv_layer_config,
batch_size=batch_size,
n_outs=self.model_config['n_outs'],
hidden_layer_configs=mlp_config,
hidden_activation=activationFn,
use_fast=conv_config['use_fast'],
l1_reg=mlp_config['l1_reg'],
l2_reg=mlp_config['l1_reg'],
max_col_norm=mlp_config['max_col_norm'])
self.__load_model__(self.model_config['input_file'],
mlp_config['pretrained_layers'])
def runDNN(arg):
if type(arg) is dict:
model_config = arg
else :
model_config = load_model(arg,'DNN')
dnn_config = load_dnn_spec(model_config['nnet_spec'])
data_spec = load_data_spec(model_config['data_spec'],model_config['batch_size']);
#generating Random
numpy_rng = numpy.random.RandomState(model_config['random_seed'])
theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
activationFn = parse_activation(dnn_config['activation']);
#create working dir
createDir(model_config['wdir']);
batch_size = model_config['batch_size'];
n_ins = model_config['n_ins']
n_outs = model_config['n_outs']
max_col_norm = dnn_config['max_col_norm']
l1_reg = dnn_config['l1_reg']
l2_reg = dnn_config['l2_reg']
adv_activation = dnn_config['adv_activation']
hidden_layers_sizes = dnn_config['hidden_layers']
do_dropout = dnn_config['do_dropout']
logger.info('Building the model')
if do_dropout:
dropout_factor = dnn_config['dropout_factor']
input_dropout_factor = dnn_config['input_dropout_factor']
dnn = DNN_Dropout(numpy_rng=numpy_rng, theano_rng = theano_rng, n_ins=n_ins,
hidden_layers_sizes=hidden_layers_sizes, n_outs=n_outs,
activation = activationFn, dropout_factor = dropout_factor,
input_dropout_factor = input_dropout_factor, adv_activation = adv_activation,
max_col_norm = max_col_norm, l1_reg = l1_reg, l2_reg = l2_reg)
else:
dnn = DNN(numpy_rng=numpy_rng, theano_rng = theano_rng, n_ins=n_ins,
hidden_layers_sizes=hidden_layers_sizes, n_outs=n_outs,
activation = activationFn, adv_activation = adv_activation,
max_col_norm = max_col_norm, l1_reg = l1_reg, l2_reg = l2_reg)
logger.info("Loading Pretrained network weights")
try:
# pretraining
ptr_file = model_config['input_file']
pretrained_layers = dnn_config['pretrained_layers']
dnn.load(filename=ptr_file,max_layer_num = pretrained_layers, withfinal=True)
except KeyError, e:
logger.critical("KeyMissing:"+str(e));
logger.error("Pretrained network Missing in configFile")
sys.exit(2)
def runCNN3D(arg):
if type(arg) is dict:
model_config = arg
else:
model_config = load_model(arg, 'CNN')
conv_config, conv_layer_config, mlp_config = load_conv_spec(
model_config['nnet_spec'], model_config['batch_size'],
model_config['input_shape'])
#__debugPrintData__(conv_layer_config,'covolution config')
data_spec = load_data_spec(model_config['data_spec'],
model_config['batch_size'])
numpy_rng = numpy.random.RandomState(model_config['random_seed'])
theano_rng = RandomStreams(numpy_rng.randint(2**30))
logger.info('> ... building the model')
hidden_activation = parse_activation(mlp_config['activation'])
createDir(model_config['wdir'])
#create working dir
batch_size = model_config['batch_size']
cnn = CNN3D(numpy_rng,
theano_rng,
conv_layer_configs=conv_layer_config,
batch_size=batch_size,
n_outs=model_config['n_outs'],
hidden_layer_configs=mlp_config,
hidden_activation=hidden_activation,
l1_reg=mlp_config['l1_reg'],
l2_reg=mlp_config['l1_reg'],
max_col_norm=mlp_config['max_col_norm'])
########################
# Loading THE MODEL #
########################
try:
# pretraining
ptr_file = model_config['input_file']
pretrained_layers = mlp_config['pretrained_layers']
logger.info("Loading the pretrained network..")
cnn.load(filename=ptr_file,
max_layer_num=pretrained_layers,
withfinal=True)
except KeyError, e:
logger.warning(
"Pretrained network missing in working directory, skipping model loading"
)
def runCNN(arg):
if type(arg) is dict:
model_config = arg
else :
model_config = load_model(arg,'CNN')
conv_config,conv_layer_config,mlp_config = load_conv_spec(
model_config['nnet_spec'],
model_config['batch_size'],
model_config['input_shape'])
data_spec = load_data_spec(model_config['data_spec'],model_config['batch_size']);
numpy_rng = numpy.random.RandomState(89677)
theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
logger.info('> ... building the model')
activationFn = parse_activation(mlp_config['activation']);
createDir(model_config['wdir']);
#create working dir
batch_size = model_config['batch_size'];
if mlp_config['do_dropout'] or conv_config['do_dropout']:
logger.info('>Initializing dropout cnn model')
cnn = DropoutCNN(numpy_rng,theano_rng,conv_layer_configs = conv_layer_config, batch_size = batch_size,
n_outs=model_config['n_outs'],hidden_layer_configs=mlp_config,
hidden_activation = activationFn,
use_fast = conv_config['use_fast'],l1_reg = mlp_config['l1_reg'],
l2_reg = mlp_config['l1_reg'],max_col_norm = mlp_config['max_col_norm'],
input_dropout_factor=conv_config['input_dropout_factor'])
else:
cnn = CNN(numpy_rng,theano_rng,conv_layer_configs = conv_layer_config, batch_size = batch_size,
n_outs=model_config['n_outs'],hidden_layer_configs=mlp_config,
hidden_activation = activationFn,
use_fast = conv_config['use_fast'],l1_reg = mlp_config['l1_reg'],
l2_reg = mlp_config['l1_reg'],max_col_norm = mlp_config['max_col_norm'])
########################
# Loading THE MODEL #
########################
try:
# pretraining
ptr_file = model_config['input_file']
pretrained_layers = mlp_config['pretrained_layers']
logger.info("Loading the pretrained network..")
cnn.load(filename=ptr_file,max_layer_num = pretrained_layers, withfinal=True)
except KeyError, e:
logger.warning("Pretrained network missing in working directory, skipping model loading")
def __init__(self,model_config): super(CNN3dPredictor, self).__init__(model_config,'CNN3d'); conv_config,conv_layer_config,mlp_config = load_conv_spec(self.model_config['nnet_spec'], self.batch_size, self.model_config['input_shape']) activationFn = parse_activation(mlp_config['activation']); self.model = CNN3D(self.numpy_rng,self.theano_rng,conv_layer_configs = conv_layer_config, batch_size = self.batch_size, n_outs= self.model_config['n_outs'], hidden_layer_configs=mlp_config,hidden_activation = hidden_activation, l1_reg = mlp_config['l1_reg'],l2_reg = mlp_config['l1_reg'], max_col_norm = mlp_config['max_col_norm']) self.__load_model__(self.model_config['input_file'],mlp_config['pretrained_layers']);
def __init__(self, model_config):
super(DNNPredictor, self).__init__(model_config, "DNN")
mlp_config = load_dnn_spec(self.model_config["nnet_spec"])
activationFn = parse_activation(mlp_config["activation"])
n_ins = model_config["n_ins"]
n_outs = model_config["n_outs"]
max_col_norm = mlp_config["max_col_norm"]
l1_reg = mlp_config["l1_reg"]
l2_reg = mlp_config["l2_reg"]
adv_activation = mlp_config["adv_activation"]
hidden_layers_sizes = mlp_config["hidden_layers"]
do_dropout = mlp_config["do_dropout"]
if do_dropout:
dropout_factor = dnn_config["dropout_factor"]
input_dropout_factor = dnn_config["input_dropout_factor"]
self.model = DNN_Dropout(
numpy_rng=self.numpy_rng,
theano_rng=self.theano_rng,
n_ins=n_ins,
hidden_layers_sizes=hidden_layers_sizes,
n_outs=n_outs,
activation=activationFn,
dropout_factor=dropout_factor,
input_dropout_factor=input_dropout_factor,
adv_activation=adv_activation,
max_col_norm=max_col_norm,
l1_reg=l1_reg,
l2_reg=l2_reg,
)
else:
self.model = DNN(
numpy_rng=self.numpy_rng,
theano_rng=self.theano_rng,
n_ins=n_ins,
hidden_layers_sizes=hidden_layers_sizes,
n_outs=n_outs,
activation=activationFn,
adv_activation=adv_activation,
max_col_norm=max_col_norm,
l1_reg=l1_reg,
l2_reg=l2_reg,
)
self.__load_model__(self.model_config["input_file"], mlp_config["pretrained_layers"])
def runCNN3D(arg):
if type(arg) is dict:
model_config = arg
else :
model_config = load_model(arg,'CNN')
conv_config,conv_layer_config,mlp_config = load_conv_spec(
model_config['nnet_spec'],
model_config['batch_size'],
model_config['input_shape'])
#__debugPrintData__(conv_layer_config,'covolution config')
data_spec = load_data_spec(model_config['data_spec'],model_config['batch_size']);
numpy_rng = numpy.random.RandomState(model_config['random_seed'])
theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
logger.info('> ... building the model')
hidden_activation = parse_activation(mlp_config['activation']);
createDir(model_config['wdir']);
#create working dir
batch_size = model_config['batch_size'];
cnn = CNN3D(numpy_rng,theano_rng,conv_layer_configs = conv_layer_config, batch_size = batch_size,
n_outs=model_config['n_outs'],hidden_layer_configs=mlp_config,hidden_activation = hidden_activation,
l1_reg = mlp_config['l1_reg'],l2_reg = mlp_config['l1_reg'],max_col_norm = mlp_config['max_col_norm'])
########################
# Loading THE MODEL #
########################
try:
# pretraining
ptr_file = model_config['input_file']
pretrained_layers = mlp_config['pretrained_layers']
logger.info("Loading the pretrained network..")
cnn.load(filename=ptr_file,max_layer_num = pretrained_layers, withfinal=True)
except KeyError, e:
logger.warning("Pretrained network missing in working directory, skipping model loading")
def __init__(self, model_config):
super(DNNPredictor, self).__init__(model_config, 'DNN')
mlp_config = load_dnn_spec(self.model_config['nnet_spec'])
activationFn = parse_activation(mlp_config['activation'])
n_ins = model_config['n_ins']
n_outs = model_config['n_outs']
max_col_norm = mlp_config['max_col_norm']
l1_reg = mlp_config['l1_reg']
l2_reg = mlp_config['l2_reg']
adv_activation = mlp_config['adv_activation']
hidden_layers_sizes = mlp_config['hidden_layers']
do_dropout = mlp_config['do_dropout']
if do_dropout:
dropout_factor = dnn_config['dropout_factor']
input_dropout_factor = dnn_config['input_dropout_factor']
self.model = DNN_Dropout(numpy_rng=self.numpy_rng,
theano_rng=self.theano_rng,
n_ins=n_ins,
hidden_layers_sizes=hidden_layers_sizes,
n_outs=n_outs,
activation=activationFn,
dropout_factor=dropout_factor,
input_dropout_factor=input_dropout_factor,
adv_activation=adv_activation,
max_col_norm=max_col_norm,
l1_reg=l1_reg,
l2_reg=l2_reg)
else:
self.model = DNN(numpy_rng=self.numpy_rng,
theano_rng=self.theano_rng,
n_ins=n_ins,
hidden_layers_sizes=hidden_layers_sizes,
n_outs=n_outs,
activation=activationFn,
adv_activation=adv_activation,
max_col_norm=max_col_norm,
l1_reg=l1_reg,
l2_reg=l2_reg)
self.__load_model__(self.model_config['input_file'],
mlp_config['pretrained_layers'])
def runRBM(arg):
if type(arg) is dict:
model_config = arg
else:
model_config = load_model(arg, 'RBM')
rbm_config = load_rbm_spec(model_config['nnet_spec'])
data_spec = load_data_spec(model_config['data_spec'],
model_config['batch_size'])
#generating Random
numpy_rng = numpy.random.RandomState(model_config['random_seed'])
theano_rng = RandomStreams(numpy_rng.randint(2**30))
activationFn = parse_activation(rbm_config['activation'])
createDir(model_config['wdir'])
#create working dir
batch_size = model_config['batch_size']
wdir = model_config['wdir']
dbn = DBN(numpy_rng=numpy_rng,
theano_rng=theano_rng,
n_ins=model_config['n_ins'],
hidden_layers_sizes=rbm_config['hidden_layers'],
n_outs=model_config['n_outs'],
first_layer_gb=rbm_config['first_layer_gb'],
pretrainedLayers=rbm_config['pretrained_layers'],
activation=activationFn)
logger.info("Loading Pretrained network weights")
try:
# pretraining
ptr_file = model_config['input_file']
dbn.load(filename=ptr_file)
except KeyError, e:
logger.info("KeyMissing:" + str(e))
logger.info(
"Pretrained network Missing in configFile: Skipping Loading")
def __init__(self,model_config): super(CNNPredictor, self).__init__(model_config,'CNN'); conv_config,conv_layer_config,mlp_config = load_conv_spec(self.model_config['nnet_spec'], self.batch_size, self.model_config['input_shape']) activationFn = parse_activation(mlp_config['activation']); if mlp_config['do_dropout'] or conv_config['do_dropout']: self.model = DropoutCNN(self.numpy_rng,self.theano_rng,conv_layer_configs = conv_layer_config, batch_size = self.batch_size, n_outs=self.model_config['n_outs'], hidden_layer_configs=mlp_config, hidden_activation = activationFn, use_fast = conv_config['use_fast'],l1_reg = mlp_config['l1_reg'], l2_reg = mlp_config['l1_reg'],max_col_norm = mlp_config['max_col_norm'], input_dropout_factor=conv_config['input_dropout_factor']) else: self.model = CNN(self.numpy_rng,self.theano_rng,conv_layer_configs = conv_layer_config, batch_size = batch_size, n_outs=self.model_config['n_outs'], hidden_layer_configs=mlp_config, hidden_activation = activationFn, use_fast = conv_config['use_fast'],l1_reg = mlp_config['l1_reg'], l2_reg = mlp_config['l1_reg'],max_col_norm = mlp_config['max_col_norm']) self.__load_model__(self.model_config['input_file'],mlp_config['pretrained_layers']);
def runRBM(arg):
if type(arg) is dict:
model_config = arg
else :
model_config = load_model(arg,'RBM')
rbm_config = load_rbm_spec(model_config['nnet_spec'])
data_spec = load_data_spec(model_config['data_spec'],model_config['batch_size']);
#generating Random
numpy_rng = numpy.random.RandomState(model_config['random_seed'])
theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
activationFn = parse_activation(rbm_config['activation']);
createDir(model_config['wdir']);
#create working dir
batch_size = model_config['batch_size']
wdir = model_config['wdir']
dbn = DBN(numpy_rng=numpy_rng, theano_rng = theano_rng, n_ins=model_config['n_ins'],
hidden_layers_sizes=rbm_config['hidden_layers'],n_outs=model_config['n_outs'],
first_layer_gb = rbm_config['first_layer_gb'],
pretrainedLayers=rbm_config['pretrained_layers'],
activation=activationFn)
logger.info("Loading Pretrained network weights")
try:
# pretraining
ptr_file = model_config['input_file']
dbn.load(filename=ptr_file)
except KeyError, e:
logger.info("KeyMissing:"+str(e));
logger.info("Pretrained network Missing in configFile: Skipping Loading");
def __init__(self, numpy_rng, theano_rng, batch_size, n_outs,conv_layer_configs, hidden_layer_configs,
hidden_activation = T.nnet.sigmoid,l1_reg=None,l2_reg=None,max_col_norm=None):
super(CNN3D, self).__init__(conv_layer_configs, hidden_layer_configs,l1_reg,l2_reg,max_col_norm)
if not theano_rng:
theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
for i in xrange(self.conv_layer_num): # construct the convolution layer
if i == 0: #is_input layer
input = self.x
else:
input = self.layers[-1].output #output of previous layer
config = conv_layer_configs[i]
conv_activation = parse_activation(config['activation']);
conv_layer = ConvLayer(numpy_rng=numpy_rng, input=input,input_shape=config['input_shape'],
filter_shape=config['filter_shape'],poolsize=config['poolsize'],
activation = conv_activation)
self.layers.append(conv_layer)
self.conv_layers.append(conv_layer)
if config['update']==True: # only few layers of convolution layer are considered for updation
self.params.extend(conv_layer.params)
self.delta_params.extend(conv_layer.delta_params)
hidden_layers = hidden_layer_configs['hidden_layers'];
self.conv_output_dim = numpy.prod(config['output_shape'][1:])
adv_activation_configs = hidden_layer_configs['adv_activation']
#flattening the last convolution output layer
self.features = self.conv_layers[-1].output.flatten(2);
self.features_dim = self.conv_output_dim;
for i in xrange(self.hidden_layer_num): # construct the hidden layer
if i == 0: # is first sigmoidla layer
input_size = self.conv_output_dim
layer_input = self.features
else:
input_size = hidden_layers[i - 1] # number of hidden neurons in previous layers
layer_input = self.layers[-1].output
if adv_activation_configs is None:
sigmoid_layer = HiddenLayer(rng=numpy_rng, input=layer_input,n_in=input_size,
n_out = hidden_layers[i], activation=hidden_activation);
else:
sigmoid_layer = HiddenLayer(rng=numpy_rng, input=layer_input,n_in=input_size,
n_out = hidden_layers[i]*adv_activation_configs['pool_size'], activation=hidden_activation,
adv_activation_method = adv_activation_configs['method'],
pool_size = adv_activation_configs['pool_size'],
pnorm_order = adv_activation_configs['pnorm_order']);
self.layers.append(sigmoid_layer)
self.mlp_layers.append(sigmoid_layer)
if config['update']==True: # only few layers of hidden layer are considered for updation
self.params.extend(sigmoid_layer.params)
self.delta_params.extend(sigmoid_layer.delta_params)
self.logLayer = LogisticRegression(input=self.layers[-1].output,n_in=hidden_layers[-1],n_out=n_outs)
self.layers.append(self.logLayer)
self.params.extend(self.logLayer.params)
self.delta_params.extend(self.logLayer.delta_params)
self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)
self.errors = self.logLayer.errors(self.y)
self.output = self.logLayer.prediction()
#regularization
if self.l1_reg is not None:
self.__l1Regularization__(self.hidden_layer_num*2);
if self.l2_reg is not None:
self.__l2Regularization__(self.hidden_layer_num*2);
def __init__(self, numpy_rng, theano_rng, batch_size, n_outs,conv_layer_configs, hidden_layer_configs,
use_fast=False,hidden_activation = T.nnet.sigmoid,l1_reg=None,l2_reg=None,
max_col_norm=None,input_dropout_factor=0.0):
super(DropoutCNN, self).__init__(conv_layer_configs,hidden_layer_configs,l1_reg,l2_reg,max_col_norm)
self.input_dropout_factor = input_dropout_factor;
self.dropout_layers = []
if not theano_rng:
theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
for i in xrange(self.conv_layer_num): # construct the convolution layer
if i == 0: #is_input layer
conv_input = self.x
if self.input_dropout_factor > 0.0:
dropout_conv_input = _dropout_from_layer(theano_rng, self.x,self.input_dropout_factor)
else:
dropout_conv_input = self.x;
else:
conv_input = (1-conv_layer_configs[i-1]['dropout_factor'])*self.layers[-1].output #output of previous layer
dropout_conv_input = self.dropout_layers[-1].dropout_output;
config = conv_layer_configs[i]
conv_activation= parse_activation(config['activation'])
dropout_conv_layer = DropoutConvLayer(numpy_rng=numpy_rng, input=dropout_conv_input,
input_shape=config['input_shape'],filter_shape=config['filter_shape'],poolsize=config['poolsize'],
activation = conv_activation, use_fast = use_fast,dropout_factor=conv_layer_configs[i]['dropout_factor'])
conv_layer = ConvLayer(numpy_rng=numpy_rng, input=conv_input,input_shape=config['input_shape'],
filter_shape=config['filter_shape'],poolsize=config['poolsize'],activation = conv_activation,
use_fast = use_fast, W = dropout_conv_layer.W, b = dropout_conv_layer.b)
self.dropout_layers.append(dropout_conv_layer);
self.layers.append(conv_layer)
self.conv_layers.append(conv_layer)
if config['update']==True: # only few layers of convolution layer are considered for updation
self.params.extend(dropout_conv_layer.params)
self.delta_params.extend(dropout_conv_layer.delta_params)
hidden_layers = hidden_layer_configs['hidden_layers'];
self.conv_output_dim = config['output_shape'][1] * config['output_shape'][2] * config['output_shape'][3]
adv_activation_configs = hidden_layer_configs['adv_activation']
#flattening the last convolution output layer
self.dropout_features = self.dropout_layers[-1].dropout_output.flatten(2);
self.features = self.conv_layers[-1].output.flatten(2);
self.features_dim = self.conv_output_dim;
self.dropout_layers = [];
self.dropout_factor = hidden_layer_configs['dropout_factor'];
for i in xrange(self.hidden_layer_num): # construct the hidden layer
if i == 0: # is first sigmoidal layer
input_size = self.conv_output_dim
dropout_layer_input = self.dropout_features
layer_input = self.features
else:
input_size = hidden_layers[i - 1] # number of hidden neurons in previous layers
dropout_layer_input = self.dropout_layers[-1].dropout_output
layer_input = (1 - self.dropout_factor[i-1]) * self.layers[-1].output
if adv_activation_configs is None:
dropout_sigmoid_layer = DropoutHiddenLayer(rng=numpy_rng, input=layer_input,n_in=input_size,
n_out = hidden_layers[i], activation=hidden_activation,
dropout_factor = self.dropout_factor[i]);
sigmoid_layer = HiddenLayer(rng=numpy_rng, input=layer_input,n_in=input_size,
n_out = hidden_layers[i], activation=hidden_activation,
W=dropout_sigmoid_layer.W, b=dropout_sigmoid_layer.b);
else:
dropout_sigmoid_layer = DropoutHiddenLayer(rng=numpy_rng, input=layer_input,n_in=input_size,
n_out = hidden_layers[i]*adv_activation_configs['pool_size'], activation=hidden_activation,
adv_activation_method = adv_activation_configs['method'],
pool_size = adv_activation_configs['pool_size'],
pnorm_order = adv_activation_configs['pnorm_order'],
dropout_factor = self.dropout_factor[i]);
sigmoid_layer = HiddenLayer(rng=numpy_rng, input=layer_input,n_in=input_size,
n_out = hidden_layers[i]*adv_activation_configs['pool_size'], activation=hidden_activation,
adv_activation_method = adv_activation_configs['method'],
pool_size = adv_activation_configs['pool_size'],
pnorm_order = adv_activation_configs['pnorm_order'],
W=dropout_sigmoid_layer.W, b=dropout_sigmoid_layer.b);
self.layers.append(sigmoid_layer)
self.dropout_layers.append(dropout_sigmoid_layer)
self.mlp_layers.append(sigmoid_layer)
if config['update']==True: # only few layers of hidden layer are considered for updation
self.params.extend(dropout_sigmoid_layer.params)
self.delta_params.extend(dropout_sigmoid_layer.delta_params)
self.dropout_logLayer = LogisticRegression(input=self.dropout_layers[-1].dropout_output,n_in=hidden_layers[-1],n_out=n_outs)
self.logLayer = LogisticRegression(
input=(1 - self.dropout_factor[-1]) * self.layers[-1].output,
n_in=hidden_layers[-1],n_out=n_outs,
W=self.dropout_logLayer.W, b=self.dropout_logLayer.b)
self.dropout_layers.append(self.dropout_logLayer)
self.layers.append(self.logLayer)
self.params.extend(self.dropout_logLayer.params)
self.delta_params.extend(self.dropout_logLayer.delta_params)
self.finetune_cost = self.dropout_logLayer.negative_log_likelihood(self.y)
self.errors = self.logLayer.errors(self.y)
self.output = self.logLayer.prediction()
#regularization
if self.l1_reg is not None:
self.__l1Regularization__(self.hidden_layer_num*2);
if self.l2_reg is not None:
self.__l2Regularization__(self.hidden_layer_num*2);
def __init__(self,
numpy_rng,
theano_rng,
batch_size,
n_outs,
conv_layer_configs,
hidden_layer_configs,
hidden_activation=T.nnet.sigmoid,
l1_reg=None,
l2_reg=None,
max_col_norm=None):
super(CNN3D, self).__init__(conv_layer_configs, hidden_layer_configs,
l1_reg, l2_reg, max_col_norm)
if not theano_rng:
theano_rng = RandomStreams(numpy_rng.randint(2**30))
for i in xrange(
self.conv_layer_num): # construct the convolution layer
if i == 0: #is_input layer
input = self.x
else:
input = self.layers[-1].output #output of previous layer
config = conv_layer_configs[i]
conv_activation = parse_activation(config['activation'])
conv_layer = ConvLayer(numpy_rng=numpy_rng,
input=input,
input_shape=config['input_shape'],
filter_shape=config['filter_shape'],
poolsize=config['poolsize'],
activation=conv_activation)
self.layers.append(conv_layer)
self.conv_layers.append(conv_layer)
if config[
'update'] == True: # only few layers of convolution layer are considered for updation
self.params.extend(conv_layer.params)
self.delta_params.extend(conv_layer.delta_params)
hidden_layers = hidden_layer_configs['hidden_layers']
self.conv_output_dim = numpy.prod(config['output_shape'][1:])
adv_activation_configs = hidden_layer_configs['adv_activation']
#flattening the last convolution output layer
self.features = self.conv_layers[-1].output.flatten(2)
self.features_dim = self.conv_output_dim
for i in xrange(self.hidden_layer_num): # construct the hidden layer
if i == 0: # is first sigmoidla layer
input_size = self.conv_output_dim
layer_input = self.features
else:
input_size = hidden_layers[
i - 1] # number of hidden neurons in previous layers
layer_input = self.layers[-1].output
if adv_activation_configs is None:
sigmoid_layer = HiddenLayer(rng=numpy_rng,
input=layer_input,
n_in=input_size,
n_out=hidden_layers[i],
activation=hidden_activation)
else:
sigmoid_layer = HiddenLayer(
rng=numpy_rng,
input=layer_input,
n_in=input_size,
n_out=hidden_layers[i] *
adv_activation_configs['pool_size'],
activation=hidden_activation,
adv_activation_method=adv_activation_configs['method'],
pool_size=adv_activation_configs['pool_size'],
pnorm_order=adv_activation_configs['pnorm_order'])
self.layers.append(sigmoid_layer)
self.mlp_layers.append(sigmoid_layer)
if config[
'update'] == True: # only few layers of hidden layer are considered for updation
self.params.extend(sigmoid_layer.params)
self.delta_params.extend(sigmoid_layer.delta_params)
self.logLayer = LogisticRegression(input=self.layers[-1].output,
n_in=hidden_layers[-1],
n_out=n_outs)
self.layers.append(self.logLayer)
self.params.extend(self.logLayer.params)
self.delta_params.extend(self.logLayer.delta_params)
self.finetune_cost = self.logLayer.negative_log_likelihood(self.y)
self.errors = self.logLayer.errors(self.y)
self.output = self.logLayer.prediction()
#regularization
if self.l1_reg is not None:
self.__l1Regularization__(self.hidden_layer_num * 2)
if self.l2_reg is not None:
self.__l2Regularization__(self.hidden_layer_num * 2)
def runCNN(arg):
if type(arg) is dict:
model_config = arg
else:
model_config = load_model(arg, 'CNN')
conv_config, conv_layer_config, mlp_config = load_conv_spec(
model_config['nnet_spec'], model_config['batch_size'],
model_config['input_shape'])
data_spec = load_data_spec(model_config['data_spec'],
model_config['batch_size'])
numpy_rng = numpy.random.RandomState(89677)
theano_rng = RandomStreams(numpy_rng.randint(2**30))
logger.info('> ... building the model')
activationFn = parse_activation(mlp_config['activation'])
createDir(model_config['wdir'])
#create working dir
batch_size = model_config['batch_size']
if mlp_config['do_dropout'] or conv_config['do_dropout']:
logger.info('>Initializing dropout cnn model')
cnn = DropoutCNN(
numpy_rng,
theano_rng,
conv_layer_configs=conv_layer_config,
batch_size=batch_size,
n_outs=model_config['n_outs'],
hidden_layer_configs=mlp_config,
hidden_activation=activationFn,
use_fast=conv_config['use_fast'],
l1_reg=mlp_config['l1_reg'],
l2_reg=mlp_config['l1_reg'],
max_col_norm=mlp_config['max_col_norm'],
input_dropout_factor=conv_config['input_dropout_factor'])
else:
cnn = CNN(numpy_rng,
theano_rng,
conv_layer_configs=conv_layer_config,
batch_size=batch_size,
n_outs=model_config['n_outs'],
hidden_layer_configs=mlp_config,
hidden_activation=activationFn,
use_fast=conv_config['use_fast'],
l1_reg=mlp_config['l1_reg'],
l2_reg=mlp_config['l1_reg'],
max_col_norm=mlp_config['max_col_norm'])
########################
# Loading THE MODEL #
########################
try:
# pretraining
ptr_file = model_config['input_file']
pretrained_layers = mlp_config['pretrained_layers']
logger.info("Loading the pretrained network..")
cnn.load(filename=ptr_file,
max_layer_num=pretrained_layers,
withfinal=True)
except KeyError, e:
logger.warning(
"Pretrained network missing in working directory, skipping model loading"
)
def runSdA(arg):
if type(arg) is dict:
model_config = arg
else :
model_config = load_model(arg,'SDA')
sda_config = load_sda_spec(model_config['nnet_spec'])
data_spec = load_data_spec(model_config['data_spec'],model_config['batch_size']);
# numpy random generator
numpy_rng = numpy.random.RandomState(model_config['random_seed'])
#theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))
#get Activation function
activationFn = parse_activation(sda_config['activation']);
createDir(model_config['wdir']);
#create working dir
logger.info('building the model')
# construct the stacked denoising autoencoder class
sda = SDA(numpy_rng=numpy_rng, n_ins=model_config['n_ins'],
hidden_layers_sizes=sda_config['hidden_layers'],
n_outs=model_config['n_outs'],activation=activationFn)
batch_size = model_config['batch_size'];
#########################
# PRETRAINING THE MODEL #
#########################
if model_config['processes']['pretraining']:
train_sets = read_dataset(data_spec['training'])
pretraining_config = model_config['pretrain_params']
corruption_levels = sda_config['corruption_levels']
preTraining(sda,train_sets,corruption_levels,pretraining_config);
del train_sets;
########################
# FINETUNING THE MODEL #
########################
if model_config['processes']['finetuning']:
fineTunning(sda,model_config,data_spec)
########################
# TESTING THE MODEL #
########################
if model_config['processes']['testing']:
testing(sda,data_spec)
##########################
## Export Features ##
##########################
if model_config['processes']['export_data']:
exportFeatures(sda,model_config,data_spec)
# save the pretrained nnet to file
logger.info('Saving model to ' + str(model_config['output_file']) + '....')
sda.save(filename=model_config['output_file'], withfinal=True)
logger.info('Saved model to ' + str(model_config['output_file']))
