def __init__(self,
incoming,
pool_size,
stride=None,
pad=(0, 0),
ignore_border=True,
mode='max',
**kwargs):
super(Pool2DLayer, self).__init__(incoming, **kwargs)
self.pool_size = as_tuple(pool_size, 2)
if len(self.input_shape) != 4:
raise ValueError("Tried to create a 2D pooling layer with "
"input shape %r. Expected 4 input dimensions "
"(batchsize, channels, 2 spatial dimensions)." %
(self.input_shape, ))
if stride is None:
self.stride = self.pool_size
else:
self.stride = as_tuple(stride, 2)
self.pad = as_tuple(pad, 2)
self.ignore_border = ignore_border
self.mode = mode
def __init__(self, incoming, pool_size, stride=None, pad=0,
ignore_border=True, mode='max', **kwargs):
super(PoolPerLine, self).__init__(incoming, **kwargs)
self.pool_size = as_tuple(pool_size, 1)
self.stride = self.pool_size if stride is None else as_tuple(stride, 1)
self.pad = as_tuple(pad, 1)
self.ignore_border = ignore_border
self.mode = mode
def __init__(self,
incoming,
num_filters,
filter_size,
stride=1,
pad=0,
untie_biases=False,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
flip_filters=True,
n=None,
**kwargs):
super(BaseConvLayer, self).__init__(incoming, **kwargs)
if nonlinearity is None:
self.nonlinearity = nonlinearities.identity
else:
self.nonlinearity = nonlinearity
if n is None:
n = len(self.input_shape) - 2
elif n != len(self.input_shape) - 2:
raise ValueError("Tried to create a %dD convolution layer with "
"input shape %r. Expected %d input dimensions "
"(batchsize, channels, %d spatial dimensions)." %
(n, self.input_shape, n + 2, n))
self.n = n
self.num_filters = num_filters
self.filter_size = as_tuple(filter_size, n, int)
self.flip_filters = flip_filters
self.stride = as_tuple(stride, n, int)
self.untie_biases = untie_biases
if pad == 'same':
if any(s % 2 == 0 for s in self.filter_size):
raise NotImplementedError(
'`same` padding requires odd filter size.')
if pad == 'valid':
self.pad = as_tuple(0, n)
elif pad in ('full', 'same'):
self.pad = pad
else:
self.pad = as_tuple(pad, n, int)
self.W = self.add_param(W, self.get_W_shape(), name="W")
if b is None:
self.b = None
else:
if self.untie_biases:
biases_shape = (num_filters, ) + self.output_shape[2:]
else:
biases_shape = (num_filters, )
self.b = self.add_param(b,
biases_shape,
name="b",
regularizable=False)
def _model_fields_set(self):
"""
Return a set containing the names of validated fields on the model.
"""
model_fields = set(field.name for field in self.model._meta.fields)
if self.fields:
return model_fields & set(as_tuple(self.fields))
return model_fields - set(as_tuple(self.exclude))
def _property_fields_set(self):
"""
Returns a set containing the names of validated properties on the model.
"""
property_fields = set(attr for attr in dir(self.model) if
isinstance(getattr(self.model, attr, None), property)
and not attr.startswith('_'))
if self.fields:
return property_fields & set(as_tuple(self.fields))
return property_fields.union(set(as_tuple(self.include))) - set(as_tuple(self.exclude))
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 _compute(self, part):
fun = JITModule(self.kernel, self.it_space, *self.args, direct=self.is_direct)
if not hasattr(self, '_jit_args'):
self._jit_args = [0, 0]
if isinstance(self._it_space._iterset, Subset):
self._jit_args.append(self._it_space._iterset._indices)
for arg in self.args:
if arg._is_mat:
self._jit_args.append(arg.data.handle.handle)
else:
for d in arg.data:
# Cannot access a property of the Dat or we will force
# evaluation of the trace
self._jit_args.append(d._data)
if arg._is_indirect or arg._is_mat:
maps = as_tuple(arg.map, Map)
for map in maps:
for m in map:
self._jit_args.append(m.values_with_halo)
for c in Const._definitions():
self._jit_args.append(c.data)
self._jit_args.extend(self.offset_args)
self._jit_args.extend(self.layer_arg)
if part.size > 0:
self._jit_args[0] = part.offset
self._jit_args[1] = part.offset + part.size
fun(*self._jit_args)
def c_addto_vector_field(self):
maps = as_tuple(self.map, Map)
nrows = maps[0].arity
ncols = maps[1].arity
dims = self.data.sparsity.dims
rmult = dims[0]
cmult = dims[1]
s = []
for i in xrange(rmult):
for j in xrange(cmult):
idx = '[%d][%d]' % (i, j)
val = "&%s%s" % (self.c_kernel_arg_name(), idx)
row = "%(m)s * %(map)s[i * %(dim)s + i_0] + %(i)s" % \
{'m': rmult,
'map': self.c_map_name(),
'dim': nrows,
'i': i}
col = "%(m)s * %(map)s2[i * %(dim)s + i_1] + %(j)s" % \
{'m': cmult,
'map': self.c_map_name(),
'dim': ncols,
'j': j}
s.append('addto_scalar(%s, %s, %s, %s, %d)'
% (self.c_arg_name(), val, row, col, self.access == WRITE))
return ';\n'.join(s)
def c_wrapper_dec(self):
if self._is_mixed_mat:
val = "Mat %(name)s = (Mat)((uintptr_t)PyLong_AsUnsignedLong(_%(name)s))" % \
{"name": self.c_arg_name()}
rows, cols = self._dat.sparsity.shape
for i in range(rows):
for j in range(cols):
val += ";\nMat %(iname)s; MatNestGetSubMat(%(name)s, %(i)d, %(j)d, &%(iname)s)" \
% {'name': self.c_arg_name(),
'iname': self.c_arg_name(i, j),
'i': i,
'j': j}
elif self._is_mat:
val = "Mat %s = (Mat)((uintptr_t)PyLong_AsUnsignedLong(_%s))" % \
(self.c_arg_name(0, 0), self.c_arg_name())
else:
val = ';\n'.join(["%(type)s *%(name)s = (%(type)s *)(((PyArrayObject *)_%(name)s)->data)"
% {'name': self.c_arg_name(i), 'type': self.ctype}
for i, _ in enumerate(self.data)])
if self._is_indirect or self._is_mat:
for i, map in enumerate(as_tuple(self.map, Map)):
for j in range(len(map)):
val += ";\nint *%(name)s = (int *)(((PyArrayObject *)_%(name)s)->data)" \
% {'name': self.c_map_name(i, j)}
if self._is_vec_map:
val += self.c_vec_dec()
return val
def c_offset_init(self):
maps = as_tuple(self.map, Map)
val = []
for i, map in enumerate(maps):
for j, m in enumerate(map):
val.append("PyObject *%s" % self.c_offset_name(i, j))
return ", " + ", ".join(val)
def c_wrapper_arg(self):
val = "PyObject *_%(name)s" % {'name': self.c_arg_name()}
if self._is_indirect or self._is_mat:
val += ", PyObject *_%(name)s" % {'name': self.c_map_name()}
maps = as_tuple(self.map, Map)
if len(maps) is 2:
val += ", PyObject *_%(name)s" % {'name': self.c_map_name() + '2'}
return val
def c_offset_decl(self):
maps = as_tuple(self.map, Map)
val = []
for i, map in enumerate(maps):
for j, _ in enumerate(map):
val.append("int *_%(cnt)s = (int *)(((PyArrayObject *)%(cnt)s)->data)" %
{'cnt': self.c_offset_name(i, j)})
return ";\n".join(val)
def c_map_decl(self):
maps = as_tuple(self.map, Map)
val = []
for i, map in enumerate(maps):
for j, m in enumerate(map):
val.append("int xtr_%(name)s[%(dim)s];" %
{'name': self.c_map_name(i, j),
'dim': m.arity})
return '\n'.join(val)+'\n'
def __init__(self, incoming, num_filters, filter_size, stride=1, pad=0,
untie_biases=False, W=init.Empty(), b=init.Empty(),
nonlinearity=nonlinearities.rectify, flip_filters=True,
conv_dim=None, **kwargs):
super().__init__(incoming, **kwargs)
if nonlinearity is None:
self.nonlinearity = nonlinearities.identity
else:
self.nonlinearity = nonlinearity
if conv_dim is None: # convolution dimension
conv_dim = len(self.input_shape) - 2
elif conv_dim != len(self.input_shape) - 2:
raise ValueError("Tried to create a %dD convolution layer with "
"input shape %r. Expected %d input dimensions "
"(batch_size, channels, %d spatial dimensions)." %
(conv_dim, self.input_shape, conv_dim+2, conv_dim))
self.conv_dim = conv_dim # convolution dimension
self.num_filters = num_filters
self.filter_size = utils.as_tuple(filter_size, conv_dim, int)
self.flip_filters = flip_filters
self.stride = utils.as_tuple(stride, conv_dim, int)
self.untie_biases = untie_biases
if pad == 'same':
if any(s % 2 == 0 for s in self.filter_size):
raise NotImplementedError('`same` padding requires odd filter size.')
if pad == 'valid':
self.pad = utils.as_tuple(0, conv_dim)
elif pad in ('full', 'same'):
self.pad = pad
else:
self.pad = utils.as_tuple(pad, conv_dim, int)
self.W = self.add_param(W, self.get_W_shape(), name='W')
# self.W = self.register_parameter(W, self.get_W_shape(), name='W')
if b is None:
self.b = None
else:
if self.untie_biases:
biases_shape = (num_filters,) + self.output_shape[2:]
else:
biases_shape = (num_filters,)
self.b = self.add_param(b, biases_shape, name='b')
def c_map_decl_itspace(self):
cdim = np.prod(self.data.cdim)
maps = as_tuple(self.map, Map)
val = []
for i, map in enumerate(maps):
for j, m in enumerate(map):
val.append("int xtr_%(name)s[%(dim_row)s];\n" %
{'name': self.c_map_name(i, j),
'dim_row': str(m.arity * cdim) if self._flatten else str(m.arity)})
return '\n'.join(val)+'\n'
def c_add_offset_map(self):
maps = as_tuple(self.map, Map)
val = []
for i, map in enumerate(maps):
for j, m in enumerate(map):
for idx in range(m.arity):
val.append("xtr_%(name)s[%(ind)s] += _%(off)s[%(ind)s];" %
{'name': self.c_map_name(i, j),
'off': self.c_offset_name(i, j),
'ind': idx})
return '\n'.join(val)+'\n'
def c_map_init(self):
maps = as_tuple(self.map, Map)
val = []
for i, map in enumerate(maps):
for j, m in enumerate(map):
for idx in range(m.arity):
val.append("xtr_%(name)s[%(ind)s] = *(%(name)s + i * %(dim)s + %(ind)s);" %
{'name': self.c_map_name(i, j),
'dim': m.arity,
'ind': idx})
return '\n'.join(val)+'\n'
def c_wrapper_arg(self):
if self._is_mat:
val = "PyObject *_%s" % self.c_arg_name()
else:
val = ', '.join(["PyObject *_%s" % self.c_arg_name(i)
for i in range(len(self.data))])
if self._is_indirect or self._is_mat:
for i, map in enumerate(as_tuple(self.map, Map)):
for j, m in enumerate(map):
val += ", PyObject *_%s" % (self.c_map_name(i, j))
return val
def c_offset_init(self):
maps = as_tuple(self.map, Map)
val = []
for i, map in enumerate(maps):
if not map.iterset._extruded:
continue
for j, m in enumerate(map):
val.append("int *%s" % self.c_offset_name(i, j))
if len(val) == 0:
return ""
return ", " + ", ".join(val)
def c_addto_scalar_field(self):
maps = as_tuple(self.map, Map)
nrows = maps[0].arity
ncols = maps[1].arity
return 'addto_vector(%(mat)s, %(vals)s, %(nrows)s, %(rows)s, %(ncols)s, %(cols)s, %(insert)d)' % \
{'mat': self.c_arg_name(),
'vals': self.c_kernel_arg_name(),
'nrows': nrows,
'ncols': ncols,
'rows': "%s + i * %s" % (self.c_map_name(), nrows),
'cols': "%s2 + i * %s" % (self.c_map_name(), ncols),
'insert': self.access == WRITE}
def __init__(self, incoming, scale_factor, mode='repeat', **kwargs):
super(Upscale2DLayer, self).__init__(incoming, **kwargs)
self.scale_factor = as_tuple(scale_factor, 2)
if self.scale_factor[0] < 1 or self.scale_factor[1] < 1:
raise ValueError('Scale factor must be >= 1, not {0}'.format(
self.scale_factor))
if mode not in {'repeat', 'dilate'}:
msg = "Mode must be either 'repeat' or 'dilate', not {0}"
raise ValueError(msg.format(mode))
self.mode = mode
def c_map_bcs(self, sign):
maps = as_tuple(self.map, Map)
val = []
# To throw away boundary condition values, we subtract a large
# value from the map to make it negative then add it on later to
# get back to the original
max_int = 10000000
need_bottom = False
# Apply any bcs on the first (bottom) layer
for i, map in enumerate(maps):
if not map.iterset._extruded:
continue
for j, m in enumerate(map):
if 'bottom' not in m.implicit_bcs:
continue
need_bottom = True
for idx in range(m.arity):
if m.bottom_mask[idx] < 0:
val.append("xtr_%(name)s[%(ind)s] %(sign)s= %(val)s;" %
{'name': self.c_map_name(i, j),
'val': max_int,
'ind': idx,
'sign': sign})
if need_bottom:
val.insert(0, "if (j_0 == 0) {")
val.append("}")
need_top = False
pos = len(val)
# Apply any bcs on last (top) layer
for i, map in enumerate(maps):
if not map.iterset._extruded:
continue
for j, m in enumerate(map):
if 'top' not in m.implicit_bcs:
continue
need_top = True
for idx in range(m.arity):
if m.top_mask[idx] < 0:
val.append("xtr_%(name)s[%(ind)s] %(sign)s= %(val)s;" %
{'name': self.c_map_name(i, j),
'val': max_int,
'ind': idx,
'sign': sign})
if need_top:
val.insert(pos, "if (j_0 == end_layer - 1) {")
val.append("}")
return '\n'.join(val)+'\n'
def c_add_offset_map_flatten(self):
cdim = np.prod(self.data.cdim)
maps = as_tuple(self.map, Map)
val = []
for i, map in enumerate(maps):
for j, m in enumerate(map):
for idx in range(m.arity):
for k in range(cdim):
val.append("xtr_%(name)s[%(ind_flat)s] += _%(off)s[%(ind)s] * %(dim)s;" %
{'name': self.c_map_name(i, j),
'off': self.c_offset_name(i, j),
'ind': idx,
'ind_flat': str(m.arity * k + idx),
'dim': str(cdim)})
return '\n'.join(val)+'\n'
def c_map_init_flattened(self):
cdim = np.prod(self.data.cdim)
maps = as_tuple(self.map, Map)
val = []
for i, map in enumerate(maps):
for j, m in enumerate(map):
for idx in range(m.arity):
for k in range(cdim):
val.append("xtr_%(name)s[%(ind_flat)s] = %(dat_dim)s * (*(%(name)s + i * %(dim)s + %(ind)s))%(offset)s;" %
{'name': self.c_map_name(i, j),
'dim': m.arity,
'ind': idx,
'dat_dim': str(cdim),
'ind_flat': str(m.arity * k + idx),
'offset': ' + '+str(k) if k > 0 else ''})
return '\n'.join(val)+'\n'
def c_map_decl(self, is_facet=False):
if self._is_mat:
dsets = self.data.sparsity.dsets
else:
dsets = (self.data.dataset,)
val = []
for i, (map, dset) in enumerate(zip(as_tuple(self.map, Map), dsets)):
for j, (m, d) in enumerate(zip(map, dset)):
dim = m.arity
if self._is_dat and self._flatten:
dim *= d.cdim
if is_facet:
dim *= 2
val.append("int xtr_%(name)s[%(dim)s];" %
{'name': self.c_map_name(i, j), 'dim': dim})
return '\n'.join(val)+'\n'
def c_map_init(self, is_top=False, layers=1, is_facet=False):
if self._is_mat:
dsets = self.data.sparsity.dsets
else:
dsets = (self.data.dataset,)
val = []
for i, (map, dset) in enumerate(zip(as_tuple(self.map, Map), dsets)):
for j, (m, d) in enumerate(zip(map, dset)):
for idx in range(m.arity):
if self._is_dat and self._flatten and d.cdim > 1:
for k in range(d.cdim):
val.append("xtr_%(name)s[%(ind_flat)s] = %(dat_dim)s * (*(%(name)s + i * %(dim)s + %(ind)s)%(off_top)s)%(offset)s;" %
{'name': self.c_map_name(i, j),
'dim': m.arity,
'ind': idx,
'dat_dim': d.cdim,
'ind_flat': m.arity * k + idx,
'offset': ' + '+str(k) if k > 0 else '',
'off_top': ' + start_layer * '+str(m.offset[idx]) if is_top else ''})
else:
val.append("xtr_%(name)s[%(ind)s] = *(%(name)s + i * %(dim)s + %(ind)s)%(off_top)s;" %
{'name': self.c_map_name(i, j),
'dim': m.arity,
'ind': idx,
'off_top': ' + start_layer * '+str(m.offset[idx]) if is_top else ''})
if is_facet:
for idx in range(m.arity):
if self._is_dat and self._flatten and d.cdim > 1:
for k in range(d.cdim):
val.append("xtr_%(name)s[%(ind_flat)s] = %(dat_dim)s * (*(%(name)s + i * %(dim)s + %(ind)s)%(off)s)%(offset)s;" %
{'name': self.c_map_name(i, j),
'dim': m.arity,
'ind': idx,
'dat_dim': d.cdim,
'ind_flat': m.arity * (k + d.cdim) + idx,
'offset': ' + '+str(k) if k > 0 else '',
'off': ' + ' + str(m.offset[idx])})
else:
val.append("xtr_%(name)s[%(ind)s] = *(%(name)s + i * %(dim)s + %(ind_zero)s)%(off_top)s%(off)s;" %
{'name': self.c_map_name(i, j),
'dim': m.arity,
'ind': idx + m.arity,
'ind_zero': idx,
'off_top': ' + start_layer' if is_top else '',
'off': ' + ' + str(m.offset[idx])})
return '\n'.join(val)+'\n'
def compute(self):
fun = JITModule(self.kernel, self.it_space.extents, *self.args)
_args = [0, 0] # start, stop
for arg in self.args:
if arg._is_mat:
_args.append(arg.data.handle.handle)
else:
_args.append(arg.data._data)
if arg._is_dat:
maybe_setflags(arg.data._data, write=False)
if arg._is_indirect or arg._is_mat:
maps = as_tuple(arg.map, Map)
for map in maps:
_args.append(map.values)
for c in Const._definitions():
_args.append(c.data)
# kick off halo exchanges
self.halo_exchange_begin()
# compute over core set elements
_args[0] = 0
_args[1] = self.it_space.core_size
fun(*_args)
# wait for halo exchanges to complete
self.halo_exchange_end()
# compute over remaining owned set elements
_args[0] = self.it_space.core_size
_args[1] = self.it_space.size
fun(*_args)
# By splitting the reduction here we get two advantages:
# - we don't double count contributions in halo elements
# - once our MPI supports the asynchronous collectives in
# MPI-3, we can do more comp/comms overlap
self.reduction_begin()
if self.needs_exec_halo:
_args[0] = self.it_space.size
_args[1] = self.it_space.exec_size
fun(*_args)
self.reduction_end()
self.maybe_set_halo_update_needed()
for arg in self.args:
if arg._is_mat:
arg.data._assemble()
def c_addto_vector_field(self, i, j, xtr=""):
maps = as_tuple(self.map, Map)
nrows = maps[0].split[i].arity
ncols = maps[1].split[j].arity
rmult, cmult = self.data.sparsity[i, j].dims
s = []
if self._flatten:
idx = '[i_0][i_1]'
val = "&%s%s" % ("buffer_" + self.c_arg_name(), idx)
row = "%(m)s * %(xtr)s%(map)s[%(elem_idx)si_0 %% %(dim)s] + (i_0 / %(dim)s)" % \
{'m': rmult,
'map': self.c_map_name(0, i),
'dim': nrows,
'elem_idx': "i * %d +" % (nrows) if xtr == "" else "",
'xtr': xtr}
col = "%(m)s * %(xtr)s%(map)s[%(elem_idx)si_1 %% %(dim)s] + (i_1 / %(dim)s)" % \
{'m': cmult,
'map': self.c_map_name(1, j),
'dim': ncols,
'elem_idx': "i * %d +" % (ncols) if xtr == "" else "",
'xtr': xtr}
return 'addto_scalar(%s, %s, %s, %s, %d)' \
% (self.c_arg_name(i, j), val, row, col, self.access == WRITE)
for r in xrange(rmult):
for c in xrange(cmult):
idx = '[i_0 + %d][i_1 + %d]' % (r, c)
val = "&%s%s" % ("buffer_" + self.c_arg_name(), idx)
row = "%(m)s * %(xtr)s%(map)s[%(elem_idx)si_0] + %(r)s" % \
{'m': rmult,
'map': self.c_map_name(0, i),
'dim': nrows,
'r': r,
'elem_idx': "i * %d +" % (nrows) if xtr == "" else "",
'xtr': xtr}
col = "%(m)s * %(xtr)s%(map)s[%(elem_idx)si_1] + %(c)s" % \
{'m': cmult,
'map': self.c_map_name(1, j),
'dim': ncols,
'c': c,
'elem_idx': "i * %d +" % (ncols) if xtr == "" else "",
'xtr': xtr}
s.append('addto_scalar(%s, %s, %s, %s, %d)'
% (self.c_arg_name(i, j), val, row, col, self.access == WRITE))
return ';\n'.join(s)
def c_addto_scalar_field(self, i, j, buf_name, extruded=None, is_facet=False):
maps = as_tuple(self.map, Map)
nrows = maps[0].split[i].arity
ncols = maps[1].split[j].arity
rows_str = "%s + i * %s" % (self.c_map_name(0, i), nrows)
cols_str = "%s + i * %s" % (self.c_map_name(1, j), ncols)
if extruded is not None:
rows_str = extruded + self.c_map_name(0, i)
cols_str = extruded + self.c_map_name(1, j)
return 'addto_vector(%(mat)s, %(vals)s, %(nrows)s, %(rows)s, %(ncols)s, %(cols)s, %(insert)d)' % \
{'mat': self.c_arg_name(i, j),
'vals': buf_name,
'nrows': nrows * (2 if is_facet else 1),
'ncols': ncols * (2 if is_facet else 1),
'rows': rows_str,
'cols': cols_str,
'insert': self.access == WRITE}
def _parse(self, stream, content_type):
"""
Parse the request content.
May raise a 415 ErrorResponse (Unsupported Media Type), or a 400 ErrorResponse (Bad Request).
"""
if stream is None or content_type is None:
return (None, None)
parsers = as_tuple(self.parsers)
for parser_cls in parsers:
parser = parser_cls(self)
if parser.can_handle_request(content_type):
return parser.parse(stream)
raise ErrorResponse(status.HTTP_415_UNSUPPORTED_MEDIA_TYPE,
{'error': 'Unsupported media type in request \'%s\'.' %
content_type})
def c_add_offset_map(self, is_facet=False):
if self._is_mat:
dsets = self.data.sparsity.dsets
else:
dsets = (self.data.dataset,)
val = []
for i, (map, dset) in enumerate(zip(as_tuple(self.map, Map), dsets)):
if not map.iterset._extruded:
continue
for j, (m, d) in enumerate(zip(map, dset)):
for idx in range(m.arity):
if self._is_dat and self._flatten and d.cdim > 1:
for k in range(d.cdim):
val.append("xtr_%(name)s[%(ind_flat)s] += %(off)s[%(ind)s] * %(dim)s;" %
{'name': self.c_map_name(i, j),
'off': self.c_offset_name(i, j),
'ind': idx,
'ind_flat': m.arity * k + idx,
'dim': d.cdim})
else:
val.append("xtr_%(name)s[%(ind)s] += %(off)s[%(ind)s];" %
{'name': self.c_map_name(i, j),
'off': self.c_offset_name(i, j),
'ind': idx})
if is_facet:
for idx in range(m.arity):
if self._is_dat and self._flatten and d.cdim > 1:
for k in range(d.cdim):
val.append("xtr_%(name)s[%(ind_flat)s] += %(off)s[%(ind)s] * %(dim)s;" %
{'name': self.c_map_name(i, j),
'off': self.c_offset_name(i, j),
'ind': idx,
'ind_flat': m.arity * (k + d.cdim) + idx,
'dim': d.cdim})
else:
val.append("xtr_%(name)s[%(ind)s] += %(off)s[%(ind_zero)s];" %
{'name': self.c_map_name(i, j),
'off': self.c_offset_name(i, j),
'ind': m.arity + idx,
'ind_zero': idx})
return '\n'.join(val)+'\n'
def __init__(self,
incoming,
num_filters,
filter_size,
dilation=(1, 1),
pad=0,
untie_biases=False,
W=init.GlorotUniform(),
b=init.Constant(0.),
nonlinearity=nonlinearities.rectify,
flip_filters=False,
**kwargs):
self.dilation = as_tuple(dilation, 2, int)
super(DilatedConv2DLayer, self).__init__(incoming,
num_filters,
filter_size,
1,
pad,
untie_biases,
W,
b,
nonlinearity,
flip_filters,
n=2,
**kwargs)
# remove self.stride:
del self.stride
# require valid convolution
if self.pad != (0, 0):
raise NotImplementedError(
"DilatedConv2DLayer requires pad=0 / (0,0) / 'valid', but "
"got %r. For a padded dilated convolution, add a PadLayer." %
(pad, ))
# require unflipped filters
if self.flip_filters:
raise NotImplementedError(
"DilatedConv2DLayer requires flip_filters=False.")
def _compute(self, part):
fun = JITModule(self.kernel, self.it_space, *self.args)
if not hasattr(self, '_jit_args'):
self._jit_args = [0, 0]
for arg in self.args:
if arg._is_mat:
self._jit_args.append(arg.data.handle.handle)
else:
self._jit_args.append(arg.data._data)
if arg._is_indirect or arg._is_mat:
maps = as_tuple(arg.map, Map)
for map in maps:
self._jit_args.append(map.values)
for c in Const._definitions():
self._jit_args.append(c.data)
self._jit_args.extend(self.offset_args())
if part.size > 0:
self._jit_args[0] = part.offset
self._jit_args[1] = part.offset + part.size
fun(*self._jit_args)
def c_addto_scalar_field(self, i, j, offsets, extruded=None):
maps = as_tuple(self.map, Map)
nrows = maps[0].split[i].arity
ncols = maps[1].split[j].arity
rows_str = "%s + i * %s" % (self.c_map_name(0, i), nrows)
cols_str = "%s + i * %s" % (self.c_map_name(1, j), ncols)
if extruded is not None:
rows_str = extruded + self.c_map_name(0, i)
cols_str = extruded + self.c_map_name(1, j)
if self._is_mat and self._is_mixed:
vals = 'scatter_buffer_' + self.c_arg_name(i, j)
else:
vals = '&buffer_' + self.c_arg_name() + "".join(["[%d]" % d for d in offsets])
return 'addto_vector(%(mat)s, %(vals)s, %(nrows)s, %(rows)s, %(ncols)s, %(cols)s, %(insert)d)' % \
{'mat': self.c_arg_name(i, j),
'vals': vals,
'nrows': nrows,
'ncols': ncols,
'rows': rows_str,
'cols': cols_str,
'insert': self.access == WRITE}
def c_map_bcs(self, top_bottom, layers, sign):
maps = as_tuple(self.map, Map)
val = []
if top_bottom is None:
return ""
# To throw away boundary condition values, we subtract a large
# value from the map to make it negative then add it on later to
# get back to the original
max_int = 10000000
if top_bottom[0]:
# We need to apply the bottom bcs
val.append("if (j_0 == 0){")
for i, map in enumerate(maps):
for j, m in enumerate(map):
for idx in range(m.arity):
val.append("xtr_%(name)s[%(ind)s] %(sign)s= %(val)s;" %
{'name': self.c_map_name(i, j),
'val': max_int if m.bottom_mask[idx] < 0 else 0,
'ind': idx,
'sign': sign})
val.append("}")
if top_bottom[1]:
# We need to apply the top bcs
val.append("if (j_0 == layer-2){")
for i, map in enumerate(maps):
for j, m in enumerate(map):
for idx in range(m.arity):
val.append("xtr_%(name)s[%(ind)s] %(sign)s= %(val)s;" %
{'name': self.c_map_name(i, j),
'val': max_int if m.top_mask[idx] < 0 else 0,
'ind': idx,
'sign': sign})
val.append("}")
return '\n'.join(val)+'\n'
def _compute(self, part):
fun = JITModule(self.kernel, self.it_space, *self.args, direct=self.is_direct, iterate=self.iteration_region)
if not hasattr(self, '_jit_args'):
self._argtypes = [ctypes.c_int, ctypes.c_int]
self._jit_args = [0, 0]
if isinstance(self._it_space._iterset, Subset):
self._argtypes.append(self._it_space._iterset._argtype)
self._jit_args.append(self._it_space._iterset._indices)
for arg in self.args:
if arg._is_mat:
self._argtypes.append(arg.data._argtype)
self._jit_args.append(arg.data.handle.handle)
else:
for d in arg.data:
# Cannot access a property of the Dat or we will force
# evaluation of the trace
self._argtypes.append(d._argtype)
self._jit_args.append(d._data)
if arg._is_indirect or arg._is_mat:
maps = as_tuple(arg.map, Map)
for map in maps:
for m in map:
self._argtypes.append(m._argtype)
self._jit_args.append(m.values_with_halo)
for c in Const._definitions():
self._argtypes.append(c._argtype)
self._jit_args.append(c.data)
for a in self.offset_args:
self._argtypes.append(ndpointer(a.dtype, shape=a.shape))
self._jit_args.append(a)
if self.iteration_region in [ON_BOTTOM]:
self._argtypes.append(ctypes.c_int)
self._argtypes.append(ctypes.c_int)
self._jit_args.append(0)
self._jit_args.append(1)
if self.iteration_region in [ON_TOP]:
self._argtypes.append(ctypes.c_int)
self._argtypes.append(ctypes.c_int)
self._jit_args.append(self._it_space.layers - 2)
self._jit_args.append(self._it_space.layers - 1)
elif self.iteration_region in [ON_INTERIOR_FACETS]:
self._argtypes.append(ctypes.c_int)
self._argtypes.append(ctypes.c_int)
self._jit_args.append(0)
self._jit_args.append(self._it_space.layers - 2)
elif self._it_space._extruded:
self._argtypes.append(ctypes.c_int)
self._argtypes.append(ctypes.c_int)
self._jit_args.append(0)
self._jit_args.append(self._it_space.layers - 1)
self._jit_args[0] = part.offset
self._jit_args[1] = part.offset + part.size
# Must call fun on all processes since this may trigger
# compilation.
with timed_region("ParLoop kernel"):
fun(*self._jit_args, argtypes=self._argtypes, restype=None)
def _compute(self, part):
fun = JITModule(self.kernel,
self.it_space,
*self.args,
direct=self.is_direct,
iterate=self.iteration_region)
if not hasattr(self, '_jit_args'):
self._argtypes = [ctypes.c_int, ctypes.c_int]
self._jit_args = [0, 0]
if isinstance(self._it_space._iterset, Subset):
self._argtypes.append(self._it_space._iterset._argtype)
self._jit_args.append(self._it_space._iterset._indices)
for arg in self.args:
if arg._is_mat:
self._argtypes.append(arg.data._argtype)
self._jit_args.append(arg.data.handle.handle)
else:
for d in arg.data:
# Cannot access a property of the Dat or we will force
# evaluation of the trace
self._argtypes.append(d._argtype)
self._jit_args.append(d._data)
if arg._is_indirect or arg._is_mat:
maps = as_tuple(arg.map, Map)
for map in maps:
for m in map:
self._argtypes.append(m._argtype)
self._jit_args.append(m.values_with_halo)
for c in Const._definitions():
self._argtypes.append(c._argtype)
self._jit_args.append(c.data)
for a in self.offset_args:
self._argtypes.append(ndpointer(a.dtype, shape=a.shape))
self._jit_args.append(a)
if self.iteration_region in [ON_BOTTOM]:
self._argtypes.append(ctypes.c_int)
self._argtypes.append(ctypes.c_int)
self._jit_args.append(0)
self._jit_args.append(1)
if self.iteration_region in [ON_TOP]:
self._argtypes.append(ctypes.c_int)
self._argtypes.append(ctypes.c_int)
self._jit_args.append(self._it_space.layers - 2)
self._jit_args.append(self._it_space.layers - 1)
elif self.iteration_region in [ON_INTERIOR_FACETS]:
self._argtypes.append(ctypes.c_int)
self._argtypes.append(ctypes.c_int)
self._jit_args.append(0)
self._jit_args.append(self._it_space.layers - 2)
elif self._it_space._extruded:
self._argtypes.append(ctypes.c_int)
self._argtypes.append(ctypes.c_int)
self._jit_args.append(0)
self._jit_args.append(self._it_space.layers - 1)
self._jit_args[0] = part.offset
self._jit_args[1] = part.offset + part.size
# Must call fun on all processes since this may trigger
# compilation.
with timed_region("ParLoop kernel"):
fun(*self._jit_args, argtypes=self._argtypes, restype=None)
