def __init__(self):
# Define some model hyperparameters to work with MNIST images!
input_size = 28*28 # dimensions of image
hidden_size = 1000 # number of hidden units - generally bigger than input size for DAE
# Now, define the symbolic input to the model (Theano)
# We use a matrix rather than a vector so that minibatch processing can be done in parallel.
x = T.matrix("X")
self.inputs = [x]
# Build the model's parameters - a weight matrix and two bias vectors
W = get_weights_uniform(shape=(input_size, hidden_size), name="W")
b0 = get_bias(shape=input_size, name="b0")
b1 = get_bias(shape=hidden_size, name="b1")
self.params = [W, b0, b1]
# Perform the computation for a denoising autoencoder!
# first, add noise (corrupt) the input
corrupted_input = salt_and_pepper_custom(input=x)
# next, run the hidden layer given the inputs (the encoding function)
hiddens = tanh(T.dot(corrupted_input, W) + b1)
# finally, create the reconstruction from the hidden layer (we tie the weights with W.T)
reconstruction = sigmoid(T.dot(hiddens, W.T) + b0)
# the training cost is reconstruction error - with MNIST this is binary cross-entropy
self.train_cost = binary_crossentropy(output=reconstruction, target=x)
# Compile everything into a Theano function for prediction!
# When using real-world data in predictions, we wouldn't corrupt the input first.
# Therefore, create another version of the hiddens and reconstruction without adding the noise
hiddens_predict = tanh(T.dot(x, W) + b1)
self.recon_predict = sigmoid(T.dot(hiddens_predict, W.T) + b0)
def __init__(self):
# Define some model hyperparameters to work with MNIST images!
input_size = 28 * 28 # dimensions of image
hidden_size = 1000 # number of hidden units - generally bigger than input size for DAE
# Now, define the symbolic input to the model (Theano)
# We use a matrix rather than a vector so that minibatch processing can be done in parallel.
x = T.matrix("X")
self.inputs = [x]
# Build the model's parameters - a weight matrix and two bias vectors
W = get_weights_uniform(shape=(input_size, hidden_size), name="W")
b0 = get_bias(shape=input_size, name="b0")
b1 = get_bias(shape=hidden_size, name="b1")
self.params = [W, b0, b1]
# Perform the computation for a denoising autoencoder!
# first, add noise (corrupt) the input
corrupted_input = salt_and_pepper(input=x, noise_level=0.4)
# next, run the hidden layer given the inputs (the encoding function)
hiddens = tanh(T.dot(corrupted_input, W) + b1)
# finally, create the reconstruction from the hidden layer (we tie the weights with W.T)
reconstruction = sigmoid(T.dot(hiddens, W.T) + b0)
# the training cost is reconstruction error - with MNIST this is binary cross-entropy
self.train_cost = binary_crossentropy(output=reconstruction, target=x)
# Compile everything into a Theano function for prediction!
# When using real-world data in predictions, we wouldn't corrupt the input first.
# Therefore, create another version of the hiddens and reconstruction without adding the noise
hiddens_predict = tanh(T.dot(x, W) + b1)
self.recon_predict = sigmoid(T.dot(hiddens_predict, W.T) + b0)
def __init__(self,
config=None,
defaults=_defaults,
inputs_hook=None,
hiddens_hook=None,
params_hook=None,
input_size=None,
hidden_size=None,
corruption_level=None,
hidden_activation=None,
visible_activation=None,
cost_function=None):
# Now, initialize with Model class to combine config and defaults!
# Here, defaults is defined via a dictionary. However, you could also
# pass a filename to a JSON or YAML file with the same format.
super(DenoisingAutoencoder, self).__init__(config=config,
defaults=defaults)
# Any parameter from the 'config' will overwrite the 'defaults' dictionary.
# These parameters are now accessible from the 'self.args' variable!
# When accessing model parameters, it is best practice to try to find the parameters
# explicitly passed first, and then go to the 'self.args' configuration.
# Define model hyperparameters
# deal with the inputs_hook and hiddens_hook for the size parameters!
# if the hook exists, grab the size from the first element of the tuple.
if inputs_hook:
input_size = inputs_hook[0]
# otherwise, grab the size from the configurations.
else:
input_size = input_size or self.args.get('input_size')
if hiddens_hook:
hidden_size = hiddens_hook[0]
else:
hidden_size = hidden_size or self.args.get('hidden_size')
corruption_level = corruption_level or self.args.get(
'corruption_level')
# use the helper methods to grab appropriate activation functions from names!
hidden_act_name = hidden_activation or self.args.get(
'hidden_activation')
hidden_activation = get_activation_function(hidden_act_name)
visible_act_name = visible_activation or self.args.get(
'visible_activation')
visible_activation = get_activation_function(visible_act_name)
# do the same for the cost function
cost_func_name = cost_function or self.args.get('cost_function')
cost_function = get_cost_function(cost_func_name)
# Now, define the symbolic input to the model (Theano)
# We use a matrix rather than a vector so that minibatch processing can be done in parallel.
# Make sure to deal with 'inputs_hook' if it exists!
if inputs_hook:
# grab the new input variable from the inputs_hook tuple
x = inputs_hook[1]
else:
x = T.fmatrix("X")
self.inputs = [x]
# Build the model's parameters - a weight matrix and two bias vectors
# Make sure to deal with 'params_hook' if it exists!
if params_hook:
# check to see if it contains the three necessary variables
assert len(params_hook
) == 3, "Not correct number of params to DAE, needs 3!"
W, b0, b1 = params_hook
else:
W = get_weights_uniform(shape=(input_size, hidden_size), name="W")
b0 = get_bias(shape=input_size, name="b0")
b1 = get_bias(shape=hidden_size, name="b1")
self.params = [W, b0, b1]
# Perform the computation for a denoising autoencoder!
# first, add noise (corrupt) the input
corrupted_input = salt_and_pepper(input=x,
corruption_level=corruption_level)
# next, compute the hidden layer given the inputs (the encoding function)
# We don't need to worry about hiddens_hook during training, because we can't
# compute a cost without having the input!
# hiddens_hook is more for the predict function and linking methods below.
hiddens = hidden_activation(T.dot(corrupted_input, W) + b1)
# finally, create the reconstruction from the hidden layer (we tie the weights with W.T)
reconstruction = visible_activation(T.dot(hiddens, W.T) + b0)
# the training cost is reconstruction error
self.train_cost = cost_function(output=reconstruction, target=x)
# Compile everything into a Theano function for prediction!
# When using real-world data in predictions, we wouldn't corrupt the input first.
# Therefore, create another version of the hiddens and reconstruction without adding the noise.
# Here is where we would handle hiddens_hook because this is a generative model!
# For the predict function, it would take in the hiddens instead of the input variable x.
if hiddens_hook:
self.hiddens = hiddens_hook[1]
else:
self.hiddens = hidden_activation(T.dot(x, W) + b1)
# make the reconstruction (generated) from the hiddens
self.recon_predict = visible_activation(T.dot(self.hiddens, W.T) + b0)
# now compile the predict function accordingly - if it used x or hiddens as the input.
if hiddens_hook:
self.f_predict = function(inputs=[self.hiddens],
outputs=self.recon_predict)
else:
self.f_predict = function(inputs=[x], outputs=self.recon_predict)
def __init__(self, inputs_hook=None, hiddens_hook=None, params_hook=None,
input_size=28*28, hidden_size=1000, noise_level=0.4,
hidden_activation='tanh', visible_activation='sigmoid', cost_function='binary_crossentropy'):
# initialize the Model superclass
super(DenoisingAutoencoder, self).__init__(
**{arg: val for (arg, val) in locals().iteritems() if arg is not 'self'}
)
# Define model hyperparameters
# deal with the inputs_hook and hiddens_hook for the size parameters!
# if the hook exists, grab the size from the first element of the tuple.
if self.inputs_hook is not None:
assert len(self.inputs_hook) == 2, "Was expecting inputs_hook to be a tuple."
self.input_size = inputs_hook[0]
if self.hiddens_hook is not None:
assert len(self.hiddens_hook) == 2, "was expecting hiddens_hook to be a tuple."
hidden_size = hiddens_hook[0]
# use the helper methods to grab appropriate activation functions from names!
hidden_activation = get_activation_function(hidden_activation)
visible_activation = get_activation_function(visible_activation)
# do the same for the cost function
cost_function = get_cost_function(cost_function)
# Now, define the symbolic input to the model (Theano)
# We use a matrix rather than a vector so that minibatch processing can be done in parallel.
# Make sure to deal with 'inputs_hook' if it exists!
if self.inputs_hook is not None:
# grab the new input variable from the inputs_hook tuple
x = self.inputs_hook[1]
else:
x = T.matrix("X")
self.inputs = [x]
# Build the model's parameters - a weight matrix and two bias vectors
# Make sure to deal with 'params_hook' if it exists!
if self.params_hook:
# check to see if it contains the three necessary variables
assert len(self.params_hook) == 3, "Not correct number of params to DAE, needs 3!"
W, b0, b1 = self.params_hook
else:
W = get_weights_uniform(shape=(self.input_size, hidden_size), name="W")
b0 = get_bias(shape=self.input_size, name="b0")
b1 = get_bias(shape=hidden_size, name="b1")
self.params = [W, b0, b1]
# Perform the computation for a denoising autoencoder!
# first, add noise (corrupt) the input
corrupted_input = salt_and_pepper(input=x, noise_level=noise_level)
# next, run the hidden layer given the inputs (the encoding function)
# We don't need to worry about hiddens_hook during training, because we can't
# run a cost without having the input!
# hiddens_hook is more for the run function and linking methods below.
hiddens = hidden_activation(T.dot(corrupted_input, W) + b1)
# finally, create the reconstruction from the hidden layer (we tie the weights with W.T)
reconstruction = visible_activation(T.dot(hiddens, W.T) + b0)
# the training cost is reconstruction error
self.train_cost = cost_function(output=reconstruction, target=x)
# Compile everything into a Theano function for prediction!
# When using real-world data in predictions, we wouldn't corrupt the input first.
# Therefore, create another version of the hiddens and reconstruction without adding the noise.
# Here is where we would handle hiddens_hook because this is a generative model!
# For the run function, it would take in the hiddens instead of the input variable x.
if self.hiddens_hook is not None:
self.hiddens = self.hiddens_hook[1]
else:
self.hiddens = hidden_activation(T.dot(x, W) + b1)
# make the reconstruction (generated) from the hiddens
self.recon_predict = visible_activation(T.dot(self.hiddens, W.T) + b0)
# now compile the run function accordingly - if it used x or hiddens as the input.
if self.hiddens_hook is not None:
self.f_run = function(inputs=[self.hiddens], outputs=self.recon_predict)
else:
self.f_run = function(inputs=[x], outputs=self.recon_predict)
def __init__(self,
inputs_hook=None,
hiddens_hook=None,
params_hook=None,
input_size=28 * 28,
hidden_size=1000,
noise_level=0.4,
hidden_activation='tanh',
visible_activation='sigmoid',
cost_function='binary_crossentropy'):
# initialize the Model superclass
super(DenoisingAutoencoder, self).__init__(**{
arg: val
for (arg, val) in locals().iteritems() if arg is not 'self'
})
# Define model hyperparameters
# deal with the inputs_hook and hiddens_hook for the size parameters!
# if the hook exists, grab the size from the first element of the tuple.
if self.inputs_hook is not None:
assert len(self.inputs_hook
) == 2, "Was expecting inputs_hook to be a tuple."
self.input_size = inputs_hook[0]
if self.hiddens_hook is not None:
assert len(self.hiddens_hook
) == 2, "was expecting hiddens_hook to be a tuple."
hidden_size = hiddens_hook[0]
# use the helper methods to grab appropriate activation functions from names!
hidden_activation = get_activation_function(hidden_activation)
visible_activation = get_activation_function(visible_activation)
# do the same for the cost function
cost_function = get_cost_function(cost_function)
# Now, define the symbolic input to the model (Theano)
# We use a matrix rather than a vector so that minibatch processing can be done in parallel.
# Make sure to deal with 'inputs_hook' if it exists!
if self.inputs_hook is not None:
# grab the new input variable from the inputs_hook tuple
x = self.inputs_hook[1]
else:
x = T.matrix("X")
self.inputs = [x]
# Build the model's parameters - a weight matrix and two bias vectors
# Make sure to deal with 'params_hook' if it exists!
if self.params_hook:
# check to see if it contains the three necessary variables
assert len(self.params_hook
) == 3, "Not correct number of params to DAE, needs 3!"
W, b0, b1 = self.params_hook
else:
W = get_weights_uniform(shape=(self.input_size, hidden_size),
name="W")
b0 = get_bias(shape=self.input_size, name="b0")
b1 = get_bias(shape=hidden_size, name="b1")
self.params = [W, b0, b1]
# Perform the computation for a denoising autoencoder!
# first, add noise (corrupt) the input
corrupted_input = salt_and_pepper(input=x, noise_level=noise_level)
# next, run the hidden layer given the inputs (the encoding function)
# We don't need to worry about hiddens_hook during training, because we can't
# run a cost without having the input!
# hiddens_hook is more for the run function and linking methods below.
hiddens = hidden_activation(T.dot(corrupted_input, W) + b1)
# finally, create the reconstruction from the hidden layer (we tie the weights with W.T)
reconstruction = visible_activation(T.dot(hiddens, W.T) + b0)
# the training cost is reconstruction error
self.train_cost = cost_function(output=reconstruction, target=x)
# Compile everything into a Theano function for prediction!
# When using real-world data in predictions, we wouldn't corrupt the input first.
# Therefore, create another version of the hiddens and reconstruction without adding the noise.
# Here is where we would handle hiddens_hook because this is a generative model!
# For the run function, it would take in the hiddens instead of the input variable x.
if self.hiddens_hook is not None:
self.hiddens = self.hiddens_hook[1]
else:
self.hiddens = hidden_activation(T.dot(x, W) + b1)
# make the reconstruction (generated) from the hiddens
self.recon_predict = visible_activation(T.dot(self.hiddens, W.T) + b0)
# now compile the run function accordingly - if it used x or hiddens as the input.
if self.hiddens_hook is not None:
self.f_run = function(inputs=[self.hiddens],
outputs=self.recon_predict)
else:
self.f_run = function(inputs=[x], outputs=self.recon_predict)
def __init__(self, inputs_hook, params_hook=None, input_shape=None, filter_shape=None, stride=None,
weights_init=None, weights_interval=None, weights_mean=None, weights_std=None, bias_init=None,
border_mode=None, activation=None, convolution=None, config=None, defaults=defaults):
# combine everything by passing to Model's init
super(Conv1D, self).__init__(**{arg: val for (arg, val) in locals().iteritems() if arg is not 'self'})
# configs can now be accessed through self dictionary
##################
# specifications #
##################
# grab info from the inputs_hook, or from parameters
# expect input to be in the form (B, C, I) (batch, channel, input data)
# inputs_hook is a tuple of (Shape, Input)
if self.inputs_hook is not None:
# make sure inputs_hook is a tuple
assert len(self.inputs_hook) == 2, "expecting inputs_hook to be tuple of (shape, input)"
self.input_shape = inputs_hook[0] or self.input_shape
self.input = inputs_hook[1]
else:
# make the input a symbolic matrix
self.input = T.ftensor3('X')
# activation function!
# if a string name was given, look up the correct function from our utils.
if isinstance(self.activation, basestring):
activation_func = get_activation_function(self.activation)
# otherwise, if a 'callable' was passed (i.e. custom function), use that directly.
else:
assert callable(self.activation), "Activation function either needs to be a string name or callable!"
activation_func = self.activation
# filter shape should be in the form (num_filters, num_channels, filter_length)
num_filters = self.filter_shape[0]
filter_length = self.filter_shape[2]
################################################
# Params - make sure to deal with params_hook! #
################################################
if self.params_hook:
# make sure the params_hook has W and b
assert len(self.params_hook) == 2, \
"Expected 2 params (W and b) for Conv1D, found {0!s}!".format(len(self.params_hook))
W, b = self.params_hook
else:
# if we are initializing weights from a gaussian
if self.weights_init.lower() == 'gaussian':
W = get_weights_gaussian(
shape=self.filter_shape, mean=self.weights_mean, std=self.weights_std, name="W"
)
# if we are initializing weights from a uniform distribution
elif self.weights_init.lower() == 'uniform':
W = get_weights_uniform(shape=self.filter_shape, interval=self.weights_interval, name="W")
# otherwise not implemented
else:
log.error("Did not recognize weights_init %s! Pleas try gaussian or uniform" %
str(self.weights_init))
raise NotImplementedError(
"Did not recognize weights_init %s! Pleas try gaussian or uniform" %
str(self.weights_init))
b = get_bias(shape=(num_filters,), name="b", init_values=self.bias_init)
# Finally have the two parameters!
self.params = [W, b]
########################
# Computational Graph! #
########################
if self.border_mode in ['valid', 'full']:
conved = convolution(self.input,
W,
subsample=(self.stride,),
image_shape=self.input_shape,
filter_shape=self.filter_shape,
border_mode=self.border_mode)
elif self.border_mode == 'same':
conved = convolution(self.input,
W,
subsample=(self.stride,),
image_shape=self.input_shape,
filter_shape=self.filter_shape,
border_mode='full')
shift = (filter_length - 1) // 2
conved = conved[:, :, shift:self.input_shape[2] + shift]
else:
log.error("Invalid border mode: '%s'" % self.border_mode)
raise RuntimeError("Invalid border mode: '%s'" % self.border_mode)
self.output = activation_func(conved + b.dimshuffle('x', 0, 'x'))
def __init__(self, inputs_hook, input_shape=None, filter_shape=None, convstride=None, padsize=None, group=None,
poolsize=None, poolstride=None, bias_init=None, local_response_normalization=None,
convolution=None, activation=None, params_hook=None, config=None, defaults=defaults):
# combine everything by passing to Model's init
super(ConvPoolLayer, self).__init__(**{arg: val for (arg, val) in locals().iteritems() if arg is not 'self'})
# configs can now be accessed through self!
# deal with the inputs coming from inputs_hook - necessary for now to give an input hook
# inputs_hook is a tuple of (Shape, Input)
if self.inputs_hook:
assert len(self.inputs_hook) == 2, "expecting inputs_hook to be tuple of (shape, input)"
self.input_shape = self.inputs_hook[0] or self.input_shape
self.input = inputs_hook[1]
else:
self.input = T.ftensor4("X")
#######################
# layer configuration #
#######################
# activation function!
# if a string name was given, look up the correct function from our utils.
if isinstance(self.activation, basestring):
self.activation_func = get_activation_function(self.activation)
# otherwise, if a 'callable' was passed (i.e. custom function), use that directly.
else:
assert callable(self.activation), "Activation function either needs to be a string name or callable!"
self.activation_func = self.activation
# expect image_shape to be bc01!
self.channel = self.input_shape[1]
# shortening a word
self.lrn = self.local_response_normalization
# if lib_conv is cudnn, it works only on square images and the grad works only when channel % 16 == 0
assert self.group in [1, 2], "group argument needs to be 1 or 2 (1 for default conv2d)"
self.filter_shape = numpy.asarray(self.filter_shape)
self.input_shape = numpy.asarray(self.input_shape)
if self.lrn:
self.lrn_func = cross_channel_normalization_bc01
################################################
# Params - make sure to deal with params_hook! #
################################################
if self.group == 1:
if self.params_hook:
# make sure the params_hook has W and b
assert len(self.params_hook) == 2, \
"Expected 2 params (W and b) for ConvPoolLayer, found {0!s}!".format(len(self.params_hook))
self.W, self.b = self.params_hook
else:
# if we are initializing weights from a gaussian
if self.weights_init.lower() == 'gaussian':
self.W = get_weights_gaussian(
shape=self.filter_shape, mean=self.weights_mean, std=self.weights_std, name="W"
)
# if we are initializing weights from a uniform distribution
elif self.weights_init.lower() == 'uniform':
self.W = get_weights_uniform(shape=self.filter_shape, interval=self.weights_interval, name="W")
# otherwise not implemented
else:
log.error("Did not recognize weights_init %s! Pleas try gaussian or uniform" %
str(self.weights_init))
raise NotImplementedError(
"Did not recognize weights_init %s! Pleas try gaussian or uniform" %
str(self.weights_init))
self.b = get_bias(shape=self.filter_shape[0], init_values=self.bias_init, name="b")
self.params = [self.W, self.b]
else:
self.filter_shape[0] = self.filter_shape[0] / 2
self.filter_shape[1] = self.filter_shape[1] / 2
self.input_shape[0] = self.input_shape[0] / 2
self.input_shape[1] = self.input_shape[1] / 2
if self.params_hook:
assert len(self.params_hook) == 4, "expected params_hook to have 4 params"
self.W0, self.W1, self.b0, self.b1 = self.params_hook
else:
self.W0 = get_weights_gaussian(shape=self.filter_shape, name="W0")
self.W1 = get_weights_gaussian(shape=self.filter_shape, name="W1")
self.b0 = get_bias(shape=self.filter_shape[0], init_values=self.bias_init, name="b0")
self.b1 = get_bias(shape=self.filter_shape[0], init_values=self.bias_init, name="b1")
self.params = [self.W0, self.b0, self.W1, self.b1]
#############################################
# build appropriate graph for conv. version #
#############################################
self.output = self.build_computation_graph()
# Local Response Normalization (for AlexNet)
if self.lrn:
self.output = self.lrn_func(self.output)
log.debug("convpool layer initialized with shape_in: %s", str(self.input_shape))
def __init__(self,
inputs_hook=None,
config=None,
defaults=default,
params_hook=None,
input_size=None,
output_size=None,
activation=None,
weights_init=None,
weights_mean=None,
weights_std=None,
weights_interval=None,
bias_init=None):
# init Model to combine the defaults and config dictionaries.
super(BasicLayer, self).__init__(config, defaults)
# all configuration parameters are now in self.args
##################
# specifications #
##################
# grab info from the inputs_hook, or from parameters
if inputs_hook: # inputs_hook is a tuple of (Shape, Input)
assert len(inputs_hook) == 2 # make sure inputs_hook is a tuple
input_size = inputs_hook[0] or input_size
self.input = inputs_hook[1]
else:
# either grab from the parameter directly or self.args config
input_size = input_size or self.args.get('input_size')
# make the input a symbolic matrix
self.input = T.fmatrix('X')
# either grab from the parameter directly, self.args config, or copy n_in
output_size = output_size or self.args.get('output_size') or input_size
# other specifications
weights_init = weights_init or self.args.get('weights_init')
# for gaussian weights
mean = weights_mean or self.args.get('weights_mean')
std = weights_std or self.args.get('weights_std')
# for uniform weights
interval = weights_interval or self.args.get('weights_interval')
# for bias
bias_init = bias_init or self.args.get('bias_init')
# activation function!
activation_name = activation or self.args.get('activation')
if isinstance(activation_name, basestring):
activation_func = get_activation_function(activation_name)
else:
assert callable(activation_name)
activation_func = activation_name
####################################################
# parameters - make sure to deal with params_hook! #
####################################################
if params_hook:
assert len(
params_hook
) == 2, "Expected 2 params (W and b) for BasicLayer, found {0!s}!".format(
len(params_hook)) # make sure the params_hook has W and b
W, b = params_hook
else:
# if we are initializing weights from a gaussian
if weights_init.lower() == 'gaussian':
W = get_weights_gaussian(shape=(input_size, output_size),
mean=mean,
std=std,
name="W")
# if we are initializing weights from a uniform distribution
elif self.args.get('weights_init').lower() == 'uniform':
W = get_weights_uniform(shape=(input_size, output_size),
interval=interval,
name="W")
# otherwise not implemented
else:
log.error(
"Did not recognize weights_init %s! Pleas try gaussian or uniform"
% str(self.args.get('weights_init')))
raise NotImplementedError(
"Did not recognize weights_init %s! Pleas try gaussian or uniform"
% str(self.args.get('weights_init')))
b = get_bias(shape=output_size, name="b", init_values=bias_init)
# Finally have the two parameters!
self.params = [W, b]
###############
# computation #
###############
# Here is the meat of the computation transforming input -> output
self.output = activation_func(T.dot(self.input, W) + b)
log.debug(
"Initialized a basic fully-connected layer with shape %s and activation: %s"
% str((input_size, output_size)), str(activation_name))
def __init__(self,
inputs_hook,
params_hook=None,
input_shape=None,
filter_shape=None,
stride=None,
weights_init=None,
weights_interval=None,
weights_mean=None,
weights_std=None,
bias_init=None,
border_mode=None,
activation=None,
convolution=None,
config=None,
defaults=defaults):
super(Conv1D, self).__init__(config=config, defaults=defaults)
# configs can now be accessed through self.args
##################
# specifications #
##################
# grab info from the inputs_hook, or from parameters
# expect input to be in the form (B, C, I) (batch, channel, input data)
# inputs_hook is a tuple of (Shape, Input)
if inputs_hook:
# make sure inputs_hook is a tuple
assert len(
inputs_hook
) == 2, "expecting inputs_hook to be tuple of (shape, input)"
input_shape = inputs_hook[0] or input_shape or self.args.get(
'input_shape')
self.input = inputs_hook[1]
else:
# either grab from the parameter directly or self.args config
input_shape = input_shape or self.args.get('input_shape')
# make the input a symbolic matrix
self.input = T.ftensor3('X')
# activation function!
activation_name = activation or self.args.get('activation')
if isinstance(activation_name, basestring):
activation_func = get_activation_function(activation_name)
else:
activation_func = activation_name
assert callable(
activation_name
), "Activation function either needs to be a string name or callable!"
# filter shape should be in the form (num_filters, num_channels, filter_length)
filter_shape = filter_shape or self.args.get('filter_shape')
num_filters = filter_shape[0]
filter_length = filter_shape[2]
stride = stride or self.args.get('stride')
border_mode = border_mode or self.args.get('border_mode')
convolution = convolution or self.args.get('convolution')
weights_init = weights_init or self.args.get('weights_init')
weights_interval = weights_interval or self.args.get(
'weights_interval')
weights_mean = weights_mean or self.args.get('weights_mean')
weights_std = weights_std or self.args.get('weights_std')
################################################
# Params - make sure to deal with params_hook! #
################################################
if params_hook:
# make sure the params_hook has W and b
assert len(
params_hook
) == 2, "Expected 2 params (W and b) for Conv1D, found {0!s}!".format(
len(params_hook))
W, b = params_hook
else:
# if we are initializing weights from a gaussian
if weights_init.lower() == 'gaussian':
W = get_weights_gaussian(shape=filter_shape,
mean=weights_mean,
std=weights_std,
name="W")
# if we are initializing weights from a uniform distribution
elif self.args.get('weights_init').lower() == 'uniform':
W = get_weights_uniform(shape=filter_shape,
interval=weights_interval,
name="W")
# otherwise not implemented
else:
log.error(
"Did not recognize weights_init %s! Pleas try gaussian or uniform"
% str(self.args.get('weights_init')))
raise NotImplementedError(
"Did not recognize weights_init %s! Pleas try gaussian or uniform"
% str(self.args.get('weights_init')))
b = get_bias(shape=(num_filters, ),
name="b",
init_values=bias_init)
# Finally have the two parameters!
self.params = [W, b]
########################
# Computational Graph! #
########################
if border_mode in ['valid', 'full']:
conved = convolution(self.input,
W,
subsample=(stride, ),
image_shape=input_shape,
filter_shape=filter_shape,
border_mode=border_mode)
elif border_mode == 'same':
conved = convolution(self.input,
W,
subsample=(stride, ),
image_shape=input_shape,
filter_shape=filter_shape,
border_mode='full')
shift = (filter_length - 1) // 2
conved = conved[:, :, shift:input_shape[2] + shift]
else:
log.error("Invalid border mode: '%s'" % border_mode)
raise RuntimeError("Invalid border mode: '%s'" % border_mode)
self.output = activation_func(conved + b.dimshuffle('x', 0, 'x'))
