def __init__(self,
incoming,
W_h=init.GlorotUniform(),
b_h=init.Constant(0.),
W_t=init.GlorotUniform(),
b_t=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
**kwargs):
super(HighwayDenseLayer, self).__init__(incoming, **kwargs)
self.nonlinearity = (nonlinearities.identity
if nonlinearity is None else nonlinearity)
num_inputs = int(np.prod(self.input_shape[1:]))
self.W_h = self.add_param(W_h, (num_inputs, num_inputs), name="W_h")
if b_h is None:
self.b_h = None
else:
self.b_h = self.add_param(b_h, (num_inputs, ),
name="b_h",
regularizable=False)
self.W_t = self.add_param(W_t, (num_inputs, num_inputs), name="W_t")
if b_t is None:
self.b_t = None
else:
self.b_t = self.add_param(b_t, (num_inputs, ),
name="b_t",
regularizable=False)
def __init__(self,
incoming,
num_labels,
mask_input=None,
W_h=init.GlorotUniform(),
W_c=init.GlorotUniform(),
b=init.Constant(0.),
**kwargs):
# This layer inherits from a MergeLayer, because it can have two
# inputs - the layer input, and the mask.
# We will just provide the layer input as incomings, unless a mask input was provided.
self.input_shape = incoming.output_shape
incomings = [incoming]
self.mask_incoming_index = -1
if mask_input is not None:
incomings.append(mask_input)
self.mask_incoming_index = 1
super(TreeAffineCRFLayer, self).__init__(incomings, **kwargs)
self.num_labels = num_labels
dim_inputs = self.input_shape[2]
# add parameters
self.W_h = self.add_param(W_h, (dim_inputs, self.num_labels),
name='W_h')
self.W_c = self.add_param(W_c, (dim_inputs, self.num_labels),
name='W_c')
if b is None:
self.b = None
else:
self.b = self.add_param(b, (self.num_labels, ),
name='b',
regularizable=False)
def __init__(self, incoming, seq_len, original_features, num_units, filter_width, pooling='f', **kwargs):
assert pooling in ['f', 'fo', 'ifo']
self.pooling = pooling
self.incoming = incoming
self.seq_len = seq_len
self.original_features = original_features
self.num_units = num_units
self.filter_width = filter_width
self.internal_seq_len = seq_len + filter_width - 1
super(QRNNLayer, self).__init__(incoming, **kwargs)
self.Z_W = self.add_param(init.GlorotUniform(),
(self.num_units, 1, self.filter_width, self.original_features), name="Z_W")
self.F_W = self.add_param(init.GlorotUniform(),
(self.num_units, 1, self.filter_width, self.original_features), name="F_W")
self.hid_init = self.add_param(init.Constant(0.), (1, self.num_units), name="hid_init",
trainable=False, regularizable=False)
if self.pooling == 'fo' or self.pooling == 'ifo':
self.O_W = self.add_param(init.GlorotUniform(),
(self.num_units, 1, self.filter_width, self.original_features), name="O_W")
if self.pooling == 'ifo':
self.I_W = self.add_param(init.GlorotUniform(),
(self.num_units, 1, self.filter_width, self.original_features), name="I_W")
def ptb_lstm(input_var, vocabulary_size, hidden_size, seq_len, num_layers,
dropout, batch_size):
l_input = L.InputLayer(shape=(batch_size, seq_len), input_var=input_var)
l_embed = L.EmbeddingLayer(l_input,
vocabulary_size,
hidden_size,
W=init.Uniform(1.0))
l_lstms = []
for i in range(num_layers):
l_lstm = L.LSTMLayer(l_embed if i == 0 else l_lstms[-1],
hidden_size,
ingate=L.Gate(W_in=init.GlorotUniform(),
W_hid=init.Orthogonal()),
forgetgate=L.Gate(W_in=init.GlorotUniform(),
W_hid=init.Orthogonal(),
b=init.Constant(1.0)),
cell=L.Gate(
W_in=init.GlorotUniform(),
W_hid=init.Orthogonal(),
W_cell=None,
nonlinearity=lasagne.nonlinearities.tanh),
outgate=L.Gate(W_in=init.GlorotUniform(),
W_hid=init.Orthogonal()))
l_lstms.append(l_lstm)
l_drop = L.DropoutLayer(l_lstms[-1], dropout)
l_out = L.DenseLayer(l_drop, num_units=vocabulary_size, num_leading_axes=2)
l_out = L.ReshapeLayer(
l_out,
(l_out.output_shape[0] * l_out.output_shape[1], l_out.output_shape[2]))
l_out = L.NonlinearityLayer(l_out,
nonlinearity=lasagne.nonlinearities.softmax)
return l_out
def __init__(
self,
incomings,
num_units,
nonlinearity=LN.tanh,
name=None,
W_xh=LI.GlorotUniform(),
W_hh=LI.GlorotUniform(),
b=LI.Constant(0.),
h0=LI.Constant(0.),
# h0_trainable=False,
):
super().__init__(incomings, name=name)
input_shape = self.input_shapes[0][1:]
input_dim = np.int(np.prod(input_shape))
# NOTE: for now, not set up to train this...probably never need to,
# but should make it noisy.
self.h0 = self.add_param(h0, (num_units, ),
name="h0",
trainable=False,
regularizable=False)
self.W_xh = self.add_param(W_xh, (input_dim, num_units), name="W_xh")
self.W_hh = self.add_param(W_hh, (num_units, num_units), name="W_hh")
self.b = self.add_param(b, (num_units, ),
name="b",
regularizable=False)
self.num_units = num_units
self.nonlinearity = nonlinearity
def __init__(self, incoming, num_units, hidden_nonlinearity,
name=None,
W_init=LI.GlorotUniform(), b_init=LI.Constant(0.), Wi_init=LI.GlorotUniform(),
hidden_init=LI.Constant(0.), hidden_init_trainable=True, **kwargs):
if hidden_nonlinearity is None:
hidden_nonlinearity = NL.identity
super(RecurrentLayer, self).__init__(incoming, name=name)
input_shape = self.input_shape[2:]
input_dim = ext.flatten_shape_dim(input_shape)
# self._name = name
# initial hidden state
self.h0 = self.add_param(hidden_init, (num_units,), name="h0", trainable=hidden_init_trainable,
regularizable=False)
# Weights from input to hidden
self.W_xh = self.add_param(Wi_init, (input_dim, num_units), name="W_xh")
self.b_h = self.add_param(b_init, (num_units,), name="b_h", regularizable=False)
# Recurrent weights
self.W_hh = self.add_param(W_init, (num_units, num_units), name="W_hh")
self.num_units = num_units
self.nonlinearity = hidden_nonlinearity
def _buildConv(self):
layer = layers.InputLayer(shape=(None, 3, 32, 32), input_var=self.X)
layer = layers.DropoutLayer(layer, p=0.2)
layer = maxoutConv(layer,
num_filters=32 * 5,
ds=5,
filter_size=(5, 5),
stride=(1, 1),
pad='same')
layer = layers.DropoutLayer(layer, p=0.5)
layer = maxoutConv(layer,
num_filters=32 * 5,
ds=5,
filter_size=(5, 5),
stride=(1, 1),
pad='same')
layer = layers.flatten(layer, outdim=2) # 不加入展开层也可以，DenseLayer自动展开
layer = layers.DropoutLayer(layer, p=0.5)
layer = layers.DenseLayer(layer,
num_units=256,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify)
layer = layers.DropoutLayer(layer, p=0.5)
layer = layers.DenseLayer(layer,
num_units=10,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.softmax)
return layer
def build_model(crop_value):
L = [
(layers.InputLayer, {
'shape': (None, 3, 64 - 2 * crop_value, 64 - 2 * crop_value)
}),
(layers.Conv2DLayer, {
'num_filters': 64,
'filter_size': (3, 3),
'pad': 0
}),
(layers.MaxPool2DLayer, {
'pool_size': (2, 2)
}),
(layers.Conv2DLayer, {
'num_filters': 128,
'filter_size': (2, 2),
'pad': 0
}),
(layers.MaxPool2DLayer, {
'pool_size': (2, 2)
}),
(layers.Conv2DLayer, {
'num_filters': 128,
'filter_size': (2, 2),
'pad': 0
}),
(layers.MaxPool2DLayer, {
'pool_size': (4, 4)
}),
(layers.DenseLayer, {
'num_units': 512,
'nonlinearity': nonlinearities.leaky_rectify,
'W': init.GlorotUniform(gain='relu')
}),
(layers.DropoutLayer, {
'p': 0.5
}),
(layers.DenseLayer, {
'num_units': 512,
'nonlinearity': nonlinearities.leaky_rectify,
'W': init.GlorotUniform(gain='relu')
}),
(layers.DenseLayer, {
'num_units': 18,
'nonlinearity': nonlinearities.softmax
}),
]
net = NeuralNet(
layers=L,
update=adagrad,
update_learning_rate=0.01,
use_label_encoder=True,
verbose=1,
max_epochs=100,
batch_iterator_train=FlipBatchIterator(batch_size=128),
on_epoch_finished=[EarlyStopping(patience=50, criterion='valid_loss')])
return net
def __init__(self,
output_dim,
hidden_sizes,
hidden_nonlinearity,
output_nonlinearity,
hidden_W_init=LI.GlorotUniform(),
hidden_b_init=LI.Constant(0.),
output_W_init=LI.GlorotUniform(),
output_b_init=LI.Constant(0.),
name=None,
input_var=None,
input_layer=None,
input_shape=None,
batch_norm=False):
Serializable.quick_init(self, locals())
if name is None:
prefix = ""
else:
prefix = name + "_"
if input_layer is None:
l_in = L.InputLayer(shape=(None, ) + input_shape,
input_var=input_var)
else:
l_in = input_layer
self._layers = [l_in]
l_hid = l_in
for idx, hidden_size in enumerate(hidden_sizes):
l_hid = L.DenseLayer(
l_hid,
num_units=hidden_size,
nonlinearity=hidden_nonlinearity,
name="%shidden_%d" % (prefix, idx),
W=hidden_W_init,
b=hidden_b_init,
)
if batch_norm:
l_hid = L.batch_norm(l_hid)
self._layers.append(l_hid)
l_out = L.DenseLayer(
l_hid,
num_units=output_dim,
nonlinearity=output_nonlinearity,
name="%soutput" % (prefix, ),
W=output_W_init,
b=output_b_init,
)
self._layers.append(l_out)
self._l_in = l_in
self._l_out = l_out
# self._input_var = l_in.input_var
self._output = L.get_output(l_out)
LasagnePowered.__init__(self, [l_out])
def __init__(self,
input_shape,
output_dim,
hidden_sizes,
hidden_nonlinearity,
output_nonlinearity,
hidden_W_init=LI.GlorotUniform(),
hidden_b_init=LI.Constant(0.),
output_W_init=LI.GlorotUniform(),
output_b_init=LI.Constant(0.),
name=None,
input_var=None,
input_layer=None):
if name is None:
prefix = ""
else:
prefix = name + "_"
if input_layer is None:
l_in = L.InputLayer(shape=(None, ) + input_shape,
input_var=input_var)
else:
l_in = input_layer
self._layers = [l_in]
l_hid = l_in
for idx, hidden_size in enumerate(hidden_sizes):
l_hid = L.DenseLayer(
l_hid,
num_units=hidden_size,
nonlinearity=hidden_nonlinearity,
name="%shidden_%d" % (prefix, idx),
W=hidden_W_init,
b=hidden_b_init,
)
self._layers.append(l_hid)
l_out = L.DenseLayer(
l_hid,
num_units=output_dim,
nonlinearity=output_nonlinearity,
name="%soutput" % (prefix, ),
W=output_W_init,
b=output_b_init,
)
self._layers.append(l_out)
self._l_in = l_in
self._l_out = l_out
self._input_var = l_in.input_var
self._output = L.get_output(l_out)
def _forward(self):
net = {}
net['input'] = layers.InputLayer(shape=(None, 1, 28, 28),
input_var=self.X)
net['dense'] = layers.DenseLayer(net['input'],
num_units=2048,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify)
net['out'] = layers.DenseLayer(net['dense'],
num_units=10,
W=init.GlorotUniform(),
b=None,
nonlinearity=nonlinearities.softmax)
return net
def __init__(self,
incoming,
num_units,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
num_leading_axes=1,
logit_posterior_mean=None,
logit_posterior_std=None,
interval=[-10.0, 0.1],
shared_axes=(),
noise_samples=None,
**kwargs):
super(DenseLogNormalDropoutLayer, self).__init__(incoming,
num_units,
W,
b,
nonlinearity,
num_leading_axes,
shared_axes=(),
noise_samples=None,
**kwargs)
self.logit_posterior_mean = logit_posterior_mean
self.logit_posterior_std = logit_posterior_std
self.interval = interval
self.init_params()
def __init__(self,
incoming,
num_units,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
num_leading_axes=1,
p=0.5,
log_sigma2=None,
shared_axes=(),
noise_samples=None,
**kwargs):
super(DenseGaussianDropoutLayer, self).__init__(incoming,
num_units,
W,
b,
nonlinearity,
num_leading_axes,
p,
shared_axes=(),
noise_samples=None,
**kwargs)
self.p = p
self.log_sigma2 = log_sigma2
self.init_params()
def __init__(self,
incoming,
num_units_per_var,
nonlinearity=nonlinearities.softmax,
**kwargs):
super(MultivariateDenseLayer, self).__init__(incoming, **kwargs)
self.nonlinearity = (nonlinearities.identity
if nonlinearity is None else nonlinearity)
self.num_units_per_var = num_units_per_var
self.num_vars = len(num_units_per_var)
num_inputs = int(np.prod(self.input_shape[1:]))
# generate Wi and bi
for i in range(self.num_vars):
# W
mem_str = "W%d" % (i)
if mem_str not in kwargs:
# default values
kwargs[mem_str] = init.GlorotUniform()
self.__dict__[mem_str] = \
self.add_param(kwargs[mem_str], (num_inputs, num_units_per_var[i]), name=mem_str)
# b
mem_str = "b%d" % (i)
if mem_str not in kwargs:
# default values
kwargs[mem_str] = init.Constant(0.)
self.__dict__[mem_str] = \
self.add_param(kwargs[mem_str], (num_units_per_var[i],), name=mem_str, regularizable=False)
def __init__(self,
incoming,
num_labels,
mask_input=None,
W=init.GlorotUniform(),
b=init.Constant(0.),
**kwargs):
# This layer inherits from a MergeLayer, because it can have two
# inputs - the layer input, and the mask.
# We will just provide the layer input as incomings, unless a mask
# input was provided.
self.input_shape = incoming.output_shape
incomings = [incoming]
self.mask_incoming_index = -1
if mask_input is not None:
incomings.append(mask_input)
self.mask_incoming_index = 1
super(CRFLayer, self).__init__(incomings, **kwargs)
self.num_labels = num_labels + 1
self.pad_label_index = num_labels
num_inputs = self.input_shape[2]
self.W = self.add_param(W,
(num_inputs, self.num_labels, self.num_labels),
name="W")
if b is None:
self.b = None
else:
self.b = self.add_param(b,
(self.num_labels, self.num_labels),
name="b",
regularizable=False)
def __init__(self,
incoming,
num_slices,
num_features,
direction='col',
W=init.GlorotUniform(gain='relu'),
nonlinearity=nonlinearities.rectify,
**kwargs):
super(DenseLayerTensorDot, self).__init__(incoming, **kwargs)
self.nonlinearity = (nonlinearities.identity
if nonlinearity is None else nonlinearity)
self.num_inputslices = self.input_shape[1]
self.num_slices = num_slices
self.num_inputfeatures = self.input_shape[3]
self.num_features = num_features
self.batch_size = self.input_shape[0]
self.num_rows = self.input_shape[2]
self.direction = direction
if direction == 'col':
self.W = self.add_param(
W, (num_slices, num_features, self.num_inputslices,
self.num_inputfeatures),
name="W4D_TensorDot_col")
self.axes = [[1, 3], [2, 3]]
elif direction == 'row':
self.W = self.add_param(W, (num_slices, num_features,
self.num_inputslices, self.num_rows),
name="W4D_TensorDot_row")
self.axes = [[1, 2], [2, 3]]
else:
raise ValueError("`direction` has to be either `row` or `col`.")
def __init__(self,
incoming,
num_filters,
filter_size,
stride=(1, 1, 1),
pad=0,
untie_biases=False,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
flip_filters=True,
convolution=T.nnet.conv3d,
**kwargs):
BaseConvLayer.__init__(self,
incoming,
num_filters,
filter_size,
stride,
pad,
untie_biases,
W,
b,
nonlinearity,
flip_filters,
n=3,
**kwargs)
self.convolution = convolution
def __init__(self,
incoming,
num_units,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
**kwargs):
"""A convenience DenseLayer that cooperates with recurrent layers.
Recurrent layers work on 3-dimensional data (batch size x time
x number of units). By default, Lasagne DenseLayer flattens
data to 2 dimensions. We could reshape the data or we could
just use this RNNDenseLayer, which is more convenient.
For documentation, refer to Lasagne's DenseLayer documenation.
"""
super(RNNDenseLayer, self).__init__(incoming, **kwargs)
self.nonlinearity = (nonlinearities.identity
if nonlinearity is None else nonlinearity)
self.num_units = num_units
num_inputs = self.input_shape[2]
self.W = self.add_param(W, (num_inputs, num_units), name="W")
if b is None:
self.b = None
else:
self.b = self.add_param(b, (num_units, ),
name="b",
regularizable=False)
def __init__(self,
incoming,
p_order,
W=init.GlorotUniform(),
num_leading_axes=1,
**kwargs):
super(PolynomialLayer, self).__init__(incoming, **kwargs)
if num_leading_axes >= len(self.input_shape):
raise ValueError(
"Got num_leading_axes=%d for a %d-dimensional input, "
"leaving no trailing axes for the dot product." %
(num_leading_axes, len(self.input_shape)))
elif num_leading_axes < -len(self.input_shape):
raise ValueError(
"Got num_leading_axes=%d for a %d-dimensional input, "
"requesting more trailing axes than there are input "
"dimensions." % (num_leading_axes, len(self.input_shape)))
self.num_leading_axes = num_leading_axes
if any(s is None for s in self.input_shape[num_leading_axes:]):
raise ValueError(
"A PolynomialLayer requires a fixed input shape (except for "
"the leading axes). Got %r for num_leading_axes=%d." %
(self.input_shape, self.num_leading_axes))
num_inputs = int(np.prod(self.input_shape[num_leading_axes:]))
self.p_order = p_order
self.W = self.add_param(W, (p_order + 1, num_inputs), name="W")
def __init__(self,
incoming,
n_slots,
d_slots,
C=init.GlorotUniform(),
M=init.Normal(),
b=init.Constant(0.),
nonlinearity_final=nonlinearities.identity,
**kwargs):
super(MemoryLayer, self).__init__(incoming, **kwargs)
self.nonlinearity_final = nonlinearity_final
self.n_slots = n_slots
self.d_slots = d_slots
num_inputs = int(np.prod(self.input_shape[1:]))
self.C = self.add_param(C, (num_inputs, n_slots),
name="C") # controller
self.M = self.add_param(M, (n_slots, d_slots),
name="M") # memory slots
if b is None:
self.b = None
else:
self.b = self.add_param(b, (n_slots, ),
name="b",
regularizable=False)
def __init__(self,
incoming,
num_units,
untie_biases=False,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
**kwargs):
super(NINLayer, self).__init__(incoming, **kwargs)
self.nonlinearity = (nonlinearities.identity
if nonlinearity is None else nonlinearity)
self.num_units = num_units
self.untie_biases = untie_biases
num_input_channels = self.input_shape[1]
self.W = self.add_param(W, (num_input_channels, num_units), name="W")
if b is None:
self.b = None
else:
if self.untie_biases:
biases_shape = (num_units, ) + self.output_shape[2:]
else:
biases_shape = (num_units, )
self.b = self.add_param(b,
biases_shape,
name="b",
regularizable=False)
def __init__(self,
incoming,
num_filters,
filter_size,
stride=(1, 1),
crop=0,
untie_biases=False,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
flip_filters=False,
**kwargs):
super(TransposedConv2DLayer, self).__init__(incoming,
num_filters,
filter_size,
stride,
crop,
untie_biases,
W,
b,
nonlinearity,
flip_filters,
n=2,
**kwargs)
# rename self.pad to self.crop:
self.crop = self.pad
del self.pad
def __init__(self,
incoming,
num_filters,
filter_size,
stride=(1, 1, 1),
crop=0,
untie_biases=False,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
flip_filters=False,
convolution=T.nnet.ConvTransp3D,
output_size=None,
**kwargs):
super(Conv3DLayerTransposed, self).__init__(incoming,
num_filters,
filter_size,
stride,
crop,
untie_biases,
W,
b,
nonlinearity,
flip_filters,
n=3,
**kwargs)
self.crop = self.pad
del self.pad
self.convolution = convolution
self.output_size = output_size
def __init__(self,
incoming,
num_filters,
filter_size,
dilation=1,
untie_biases=False,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
flip_filters=False,
convolution=conv.conv1d_mc0,
**kwargs):
self.dilation = dilation
pre_pad = (filter_size - 1) * dilation
filter_size += (filter_size - 1) * (dilation - 1)
l_pad = PadLayer(incoming, batch_ndim=2, width=[(pre_pad, 0)])
super(DilatedConv1DLayer, self).__init__(incoming=l_pad,
num_filters=num_filters,
filter_size=filter_size,
stride=1,
pad=0,
untie_biases=untie_biases,
W=W,
b=b,
nonlinearity=nonlinearity,
flip_filters=flip_filters,
convolution=convolution,
**kwargs)
def __init__(self,
incoming,
num_units,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
num_leading_axes=1,
p=0.5,
logit_p=None,
temp=0.1,
shared_axes=(),
noise_samples=None,
**kwargs):
super(DenseConcreteDropoutLayer, self).__init__(incoming,
num_units,
W,
b,
nonlinearity,
num_leading_axes,
p,
shared_axes=(),
noise_samples=None,
**kwargs)
self.temp = temp
self.logit_p = logit_p
self.init_params()
def __init__(self, incoming, num_units, hidden_nonlinearity,
gate_nonlinearity=LN.sigmoid, name=None,
W_init=LI.GlorotUniform(), b_init=LI.Constant(0.),
hidden_init=LI.Constant(0.), hidden_init_trainable=True):
if hidden_nonlinearity is None:
hidden_nonlinearity = LN.identity
if gate_nonlinearity is None:
gate_nonlinearity = LN.identity
super(GRULayer, self).__init__(incoming, name=name)
input_shape = self.input_shape[2:]
input_dim = ext.flatten_shape_dim(input_shape)
# self._name = name
# Weights for the initial hidden state
self.h0 = self.add_param(hidden_init, (num_units,), name="h0", trainable=hidden_init_trainable,
regularizable=False)
# Weights for the reset gate
self.W_xr = self.add_param(W_init, (input_dim, num_units), name="W_xr")
self.W_hr = self.add_param(W_init, (num_units, num_units), name="W_hr")
self.b_r = self.add_param(b_init, (num_units,), name="b_r", regularizable=False)
# Weights for the update gate
self.W_xu = self.add_param(W_init, (input_dim, num_units), name="W_xu")
self.W_hu = self.add_param(W_init, (num_units, num_units), name="W_hu")
self.b_u = self.add_param(b_init, (num_units,), name="b_u", regularizable=False)
# Weights for the cell gate
self.W_xc = self.add_param(W_init, (input_dim, num_units), name="W_xc")
self.W_hc = self.add_param(W_init, (num_units, num_units), name="W_hc")
self.b_c = self.add_param(b_init, (num_units,), name="b_c", regularizable=False)
self.gate_nonlinearity = gate_nonlinearity
self.num_units = num_units
self.nonlinearity = hidden_nonlinearity
def __init__(self,
incoming,
num_labels,
mask_input=None,
W=init.GlorotUniform(),
b=init.Constant(0.),
**kwargs):
self.input_shape = incoming.output_shape
incomings = [incoming]
self.mask_incoming_index = -1
if mask_input is not None:
incomings.append(mask_input)
self.mask_incoming_index = 1
super(CRFLayer, self).__init__(incomings, **kwargs)
self.num_labels = num_labels + 1
self.pad_label_index = num_labels
num_inputs = self.input_shape[2]
self.W = self.add_param(W,
(num_inputs, self.num_labels, self.num_labels),
name="W")
if b is None:
self.b = None
else:
self.b = self.add_param(b, (self.num_labels, self.num_labels),
name="b",
regularizable=False)
def __init__(self,
incoming,
num_filters,
filter_size,
stride=(1, 1),
crop=0,
untie_biases=False,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
flip_filters=False,
output_size=None,
**kwargs):
# output_size must be set before calling the super constructor
if (not isinstance(output_size, T.Variable)
and output_size is not None):
output_size = as_tuple(output_size, 2, int)
self.output_size = output_size
super(TransposedConv2DLayer, self).__init__(incoming,
num_filters,
filter_size,
stride,
crop,
untie_biases,
W,
b,
nonlinearity,
flip_filters,
n=2,
**kwargs)
# rename self.pad to self.crop:
self.crop = self.pad
del self.pad
def __init__(self,
Period=init.Uniform((10, 100)),
Shift=init.Uniform((0., 1000.)),
On_End=init.Constant(0.05),
Event_W=init.GlorotUniform(),
Event_b=init.Constant(0.),
out_W=init.GlorotUniform(),
out_b=init.Constant(0.)):
self.Period = Period
self.Shift = Shift
self.On_End = On_End
self.Event_W = Event_W
self.Event_b = Event_b
self.out_W = out_W
self.out_b = out_b
def __init__(self,
incoming_vertex,
incoming_edge,
num_filters,
filter_size,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
**kwargs):
self.vertex_shape = incoming_vertex.output_shape
self.edge_shape = incoming_edge.output_shape
self.input_shape = incoming_vertex.output_shape
incomings = [incoming_vertex, incoming_edge]
self.vertex_incoming_index = 0
self.edge_incoming_index = 1
super(GraphConvLayer, self).__init__(incomings, **kwargs)
if nonlinearity is None:
self.nonlinearity = nonlinearities.identity
else:
self.nonlinearity = nonlinearity
self.num_filters = num_filters
self.filter_size = filter_size
self.W = self.add_param(W, self.get_W_shape(), name="W")
if b is None:
self.b = None
else:
self.b = self.add_param(b, (num_filters, ),
name="b",
regularizable=False)
