def BGMM1_sampler(rstream, weights, mus, sigmas, low, high, draw_shape=None, ndim=None, dtype=None): rstate = rstream.new_shared_rstate() # shape prep if draw_shape is None: raise NotImplementedError() elif draw_shape is tensor.as_tensor_variable(draw_shape): shape = draw_shape if ndim is None: ndim = tensor.get_vector_length(shape) else: shape = tensor.hstack(*draw_shape) if ndim is None: ndim = len(draw_shape) assert tensor.get_vector_length(shape) == ndim # XXX: be smarter about inferring broadcastable op = BGMM1( tensor.TensorType( broadcastable=(False, ) * ndim, dtype=theano.config.floatX if dtype is None else dtype)) rs, out = op(rstate, weights, mus, sigmas, low, high, shape) rstream.add_default_update(out, rstate, rs) return out
def BGMM1_sampler(rstream, weights, mus, sigmas, low, high, draw_shape=None, ndim=None, dtype=None): rstate = rstream.new_shared_rstate() # shape prep if draw_shape is None: raise NotImplementedError() elif draw_shape is tensor.as_tensor_variable(draw_shape): shape = draw_shape if ndim is None: ndim = tensor.get_vector_length(shape) else: shape = tensor.hstack(*draw_shape) if ndim is None: ndim = len(draw_shape) assert tensor.get_vector_length(shape) == ndim # XXX: be smarter about inferring broadcastable op = BGMM1( tensor.TensorType( broadcastable=(False,) * ndim, dtype=theano.config.floatX if dtype is None else dtype)) rs, out = op(rstate, weights, mus, sigmas, low, high, shape) rstream.add_default_update(out, rstate, rs) return out
def quantized_lognormal_mixture_sampler(rstream, weights, mus, sigmas, step, draw_shape=None, ndim=None, dtype=None): rstate = rstream.new_shared_rstate() # shape prep if draw_shape is None: raise NotImplementedError() elif draw_shape is tensor.as_tensor_variable(draw_shape): shape = draw_shape if ndim is None: ndim = tensor.get_vector_length(shape) elif tuple(draw_shape) == (): ndim = 0 shape = tensor.as_tensor_variable(numpy.asarray([], dtype="int")) else: shape = tensor.stack(*draw_shape) if ndim is None: ndim = len(draw_shape) assert tensor.get_vector_length(shape) == ndim # XXX: be smarter about inferring broadcastable op = QuantizedLognormalMixture( tensor.TensorType(broadcastable=(False,) * ndim, dtype=theano.config.floatX if dtype is None else dtype) ) rs, out = op(rstate, shape, weights, mus, sigmas, step) rstream.add_default_update(out, rstate, rs) return out
def quantized_lognormal_mixture_sampler(rstream, weights, mus, sigmas, step, draw_shape=None, ndim=None, dtype=None): rstate = rstream.new_shared_rstate() # shape prep if draw_shape is None: raise NotImplementedError() elif draw_shape is tensor.as_tensor_variable(draw_shape): shape = draw_shape if ndim is None: ndim = tensor.get_vector_length(shape) elif tuple(draw_shape) == (): ndim = 0 shape = tensor.as_tensor_variable(numpy.asarray([], dtype='int')) else: shape = tensor.stack(*draw_shape) if ndim is None: ndim = len(draw_shape) assert tensor.get_vector_length(shape) == ndim # XXX: be smarter about inferring broadcastable op = QuantizedLognormalMixture( tensor.TensorType( broadcastable=(False, ) * ndim, dtype=theano.config.floatX if dtype is None else dtype)) rs, out = op(rstate, shape, weights, mus, sigmas, step) rstream.add_default_update(out, rstate, rs) return out
def DM_sampler(rstream, alpha, draw_shape=None, ndim=None, dtype=None): shape = infer_shape(rstream.dirichlet(alpha, draw_shape=draw_shape)) rstate = rstream.new_shared_rstate() op = DM(tensor.TensorType(broadcastable=(False,) * tensor.get_vector_length(shape), dtype=theano.config.floatX)) rs, out = op(rstate, alpha) rstream.add_default_update(out, rstate, rs) return out
def DM_sampler(rstream, alpha, draw_shape=None, ndim=None, dtype=None): shape = infer_shape(rstream.dirichlet(alpha, draw_shape=draw_shape)) rstate = rstream.new_shared_rstate() op = DM( tensor.TensorType(broadcastable=(False, ) * tensor.get_vector_length(shape), dtype=theano.config.floatX)) rs, out = op(rstate, alpha) rstream.add_default_update(out, rstate, rs) return out
def _infer_shape(self, size, dist_params, param_shapes=None): """Compute shapes and broadcasts values. Inspired by `tt.add.get_output_info`. """ size_len = tt.get_vector_length(size) dummy_params = tuple(p if n == 0 else tt.ones(tuple(p.shape)[:-n]) for p, n in zip(dist_params, self.ndims_params)) _, out_bcasts, bcastd_inputs = tt.add.get_output_info( tt.DimShuffle, *dummy_params) # _, out_bcasts, bcastd_inputs = tt.add.get_output_info(tt.DimShuffle, *dist_params) (bcast_ind, ) = out_bcasts ndim_ind = len(bcast_ind) shape_ind = bcastd_inputs[0].shape if self.ndim_supp == 0: shape_supp = tuple() # In the scalar case, `size` corresponds to the entire result's # shape. This implies the following: # shape_ind[-ndim_ind] == size[:ndim_ind] # TODO: How do we add this constraint/check symbolically? ndim_reps = max(size_len - ndim_ind, 0) shape_reps = tuple(size)[ndim_ind:] else: shape_supp = self.supp_shape_fn(self.ndim_supp, self.ndims_params, dist_params, param_shapes=param_shapes) ndim_reps = size_len shape_reps = size ndim_shape = self.ndim_supp + ndim_ind + ndim_reps if ndim_shape == 0: shape = tt.constant([], dtype="int64") else: shape = tuple(shape_reps) + tuple(shape_ind) + tuple(shape_supp) # if shape is None: # raise tt.ShapeError() return shape
def categorical_sampler(rstream, p, draw_shape, dtype="int32"): if not isinstance(p, theano.Variable): p = tensor._shared(numpy.asarray(p, dtype=theano.config.floatX)) if p.ndim != 1: raise NotImplementedError() if draw_shape.ndim != 1: raise TypeError() op = Categorical( False, tensor.TensorType(broadcastable=(False,) * tensor.get_vector_length(draw_shape), dtype=dtype) ) rstate = rstream.new_shared_rstate() new_rstate, out = op(rstate, p, draw_shape) rstream.add_default_update(out, rstate, new_rstate) return out
def categorical_sampler(rstream, p, draw_shape, dtype='int32'): if not isinstance(p, theano.Variable): p = tensor._shared(numpy.asarray(p, dtype=theano.config.floatX)) if p.ndim != 1: raise NotImplementedError() if draw_shape.ndim != 1: raise TypeError() op = Categorical( False, tensor.TensorType(broadcastable=(False, ) * tensor.get_vector_length(draw_shape), dtype=dtype)) rstate = rstream.new_shared_rstate() new_rstate, out = op(rstate, p, draw_shape) rstream.add_default_update(out, rstate, new_rstate) return out
def new_auto_update(cls, generator, ndim, dtype, size, seed): """ Return a symbolic sample from generator. cls dictates the random variable (e.g. uniform, normal). """ v_size = theano.tensor.as_tensor_variable(size) if ndim is None: ndim = get_vector_length(v_size) self = cls(output_type=CudaNdarrayType((False,) * ndim), seed=seed, destructive=False) o_gen, sample = self(generator, cast(v_size, "int32")) sample.generator = generator # for user sample.update = (generator, o_gen) # for CURAND_RandomStreams generator.default_update = o_gen # for pfunc uses this attribute return sample
def new_auto_update(cls, generator, ndim, dtype, size, seed): """ Return a symbolic sample from generator. cls dictates the random variable (e.g. uniform, normal) """ v_size = theano.tensor.as_tensor_variable(size) if ndim is None: ndim = get_vector_length(v_size) self = cls(output_type=CudaNdarrayType((False, ) * ndim), seed=seed, destructive=False) o_gen, sample = self(generator, cast(v_size, 'int32')) sample.generator = generator # for user sample.update = (generator, o_gen) # for CURAND_RandomStreams generator.default_update = o_gen # for pfunc uses this attribute return sample
def new(cls, rstate, ndim, dtype, size): v_size = as_tensor_variable(size) if ndim is None: ndim = get_vector_length(v_size) op = cls(CudaNdarrayType((False,)*ndim)) return op(rstate, cast(v_size, 'int32'))
def new(cls, rstate, ndim, dtype, size): v_size = as_tensor_variable(size) if ndim is None: ndim = get_vector_length(v_size) op = cls(CudaNdarrayType((False, ) * ndim)) return op(rstate, cast(v_size, 'int32'))
def new(cls, rstate, ndim, dtype, size): v_size = as_tensor_variable(size) if ndim is None: ndim = get_vector_length(v_size) op = cls(TensorType(dtype, (False,) * ndim)) return op(rstate, cast(v_size, "int32"))
def _infer_ndim_bcast(ndim, shape, *args): """ Infer the number of dimensions from the shape or the other arguments. Returns ------- (int, variable, tuple) triple, where the variable is an integer vector, and the tuple contains Booleans The first element returned is the inferred number of dimensions. The second element is the shape inferred (combining symbolic and constant informations from shape and args). The third element is a broadcasting pattern corresponding to that shape. """ # Find the minimum value of ndim required by the *args if args: args_ndim = max(arg.ndim for arg in args) else: args_ndim = 0 if isinstance(shape, (tuple, list)): # there is a convention that -1 means the corresponding shape of a # potentially-broadcasted symbolic arg # # This case combines together symbolic and non-symbolic shape # information shape_ndim = len(shape) if ndim is None: ndim = shape_ndim else: if shape_ndim != ndim: raise ValueError( "ndim should be equal to len(shape), but\n", "ndim = %s, len(shape) = %s, shape = %s" % (ndim, shape_ndim, shape), ) bcast = [] pre_v_shape = [] for i, s in enumerate(shape): if hasattr(s, "type"): # s is symbolic bcast.append(False) # todo - introspect further pre_v_shape.append(s) else: if s >= 0: pre_v_shape.append(tensor.as_tensor_variable(s)) bcast.append((s == 1)) elif s == -1: n_a_i = 0 for a in args: # ndim: _ _ _ _ _ _ # ashp: s0 s1 s2 s3 # i if i >= ndim - a.ndim: n_a_i += 1 a_i = i + a.ndim - ndim if not a.broadcastable[a_i]: pre_v_shape.append(a.shape[a_i]) bcast.append(False) break else: if n_a_i == 0: raise ValueError( ("Auto-shape of -1 must overlap" "with the shape of one of the broadcastable" "inputs")) else: pre_v_shape.append(tensor.as_tensor_variable(1)) bcast.append(True) else: ValueError("negative shape", s) # post-condition: shape may still contain both symbolic and # non-symbolic things if len(pre_v_shape) == 0: v_shape = tensor.constant([], dtype="int64") else: v_shape = tensor.stack(pre_v_shape) elif shape is None: # The number of drawn samples will be determined automatically, # but we need to know ndim if not args: raise TypeError(("_infer_ndim_bcast cannot infer shape without" " either shape or args")) template = reduce(lambda a, b: a + b, args) v_shape = template.shape bcast = template.broadcastable ndim = template.ndim else: v_shape = tensor.as_tensor_variable(shape) if v_shape.ndim != 1: raise TypeError( "shape must be a vector or list of scalar, got '%s'" % v_shape) if ndim is None: ndim = tensor.get_vector_length(v_shape) bcast = [False] * ndim if v_shape.ndim != 1: raise TypeError("shape must be a vector or list of scalar, got '%s'" % v_shape) if v_shape.dtype not in theano.tensor.integer_dtypes: raise TypeError("shape must be an integer vector or list", v_shape.dtype) if args_ndim > ndim: raise ValueError( "ndim should be at least as big as required by args value", (ndim, args_ndim), args, ) assert ndim == len(bcast) return ndim, tensor.cast(v_shape, "int64"), tuple(bcast)
def _infer_ndim_bcast(ndim, shape, *args): """ Infer the number of dimensions from the shape or the other arguments. :rtype: (int, variable, tuple) triple, where the variable is an integer vector, and the tuple contains Booleans. :returns: the first element returned is the inferred number of dimensions. The second element is the shape inferred (combining symbolic and constant informations from shape and args). The third element is a broadcasting pattern corresponding to that shape. """ # Find the minimum value of ndim required by the *args if args: args_ndim = max(arg.ndim for arg in args) else: args_ndim = 0 # there is a convention that -1 means the corresponding shape of a # potentially-broadcasted symbolic arg if (isinstance(shape, (tuple, list)) and numpy.all(numpy.asarray(shape) >= 0)): bcast = [(s == 1) for s in shape] v_shape = tensor.TensorConstant(type=tensor.lvector, data=theano._asarray(shape, dtype='int64')) shape_ndim = len(shape) if ndim is None: ndim = shape_ndim else: if shape_ndim != ndim: raise ValueError( 'ndim should be equal to len(shape), but\n', 'ndim = %s, len(shape) = %s, shape = %s' % (ndim, shape_ndim, shape)) elif isinstance(shape, (tuple, list)): # there is a convention that -1 means the corresponding shape of a # potentially-broadcasted symbolic arg # # This case combines together symbolic and non-symbolic shape # information if ndim is None: ndim = args_ndim else: ndim = max(args_ndim, ndim) ndim = max(args_ndim, len(shape)) shape = [-1] * (ndim - len(shape)) + list(shape) bcast = [] pre_v_shape = [] for i, s in enumerate(shape): if hasattr(s, 'type'): # s is symbolic bcast.append(False) # todo - introspect further pre_v_shape.append(s) else: if s >= 0: pre_v_shape.append(tensor.as_tensor_variable(s)) bcast.append((s == 1)) elif s == -1: n_a_i = 0 for a in args: # ndim: _ _ _ _ _ _ # ashp: s0 s1 s2 s3 # i if i >= ndim - a.ndim: n_a_i += 1 a_i = i + a.ndim - ndim if not a.broadcastable[a_i]: pre_v_shape.append(a.shape[a_i]) bcast.append(False) break else: if n_a_i == 0: raise ValueError( ('Auto-shape of -1 must overlap' 'with the shape of one of the broadcastable' 'inputs')) else: pre_v_shape.append(tensor.as_tensor_variable(1)) bcast.append(True) else: ValueError('negative shape', s) # post-condition: shape may still contain both symbolic and # non-symbolic things v_shape = tensor.stack(*pre_v_shape) elif shape is None: # The number of drawn samples will be determined automatically, # but we need to know ndim if not args: raise TypeError(('_infer_ndim_bcast cannot infer shape without' ' either shape or args')) template = reduce(lambda a, b: a + b, args) v_shape = template.shape bcast = template.broadcastable ndim = template.ndim else: v_shape = tensor.as_tensor_variable(shape) if ndim is None: ndim = tensor.get_vector_length(v_shape) bcast = [False] * ndim if (not (v_shape.dtype.startswith('int') or v_shape.dtype.startswith('uint'))): raise TypeError('shape must be an integer vector or list', v_shape.dtype) if args_ndim > ndim: raise ValueError( 'ndim should be at least as big as required by args value', (ndim, args_ndim), args) assert ndim == len(bcast) return ndim, tensor.cast(v_shape, 'int32'), tuple(bcast)
def _infer_shape(self, size, dist_params, param_shapes=None): """Compute shapes and broadcasts values. Inspired by `tt.add.get_output_info`. """ param_shapes = param_shapes or [p.shape for p in dist_params] def slice_ind_dims(p, ps, n): shape = tuple(ps) if n == 0: return (p, shape, p.broadcastable) ind_slice = (np.s_[:], ) * (p.ndim - n) + (0, ) * n return (p[ind_slice], shape[:-n], p.broadcastable[:-n]) # These are versions of our actual parameters with the expected # dimensions removed so that only the independent variate dimensions # are left. params_ind_slice = tuple( slice_ind_dims(p, ps, n) for p, ps, n in zip(dist_params, param_shapes, self.ndims_params)) if len(params_ind_slice) == 1: ind_param, ind_shape, ind_bcast = params_ind_slice[0] ndim_ind = len(ind_shape) shape_ind = ind_shape elif len(params_ind_slice) > 1: # When there are multiple parameters with different dimensions # *and* independent dimensions, the independent dimensions should # broadcast together. We simply add those independent dimension # slices and let `tt.add` work out the broadcasting logic. p_slices, p_shapes, p_bcasts = zip(*params_ind_slice) (shape_ind, ) = tt.add.infer_shape( tt.add(*p_slices).owner, p_shapes) ndim_ind = len(shape_ind) size_len = tt.get_vector_length(size) if self.ndim_supp == 0: shape_supp = tuple() # In the scalar case, `size` corresponds to the entire result's # shape. This implies the following: # shape_ind == size[:ndim_ind] # TODO: Do we wan to constraint/check symbolically? shape_reps = tuple(size) if ndim_ind > 0: shape_reps = shape_reps[:-ndim_ind] ndim_reps = len(shape_reps) else: shape_supp = self.supp_shape_fn(self.ndim_supp, self.ndims_params, dist_params, param_shapes=param_shapes) ndim_reps = size_len shape_reps = size ndim_shape = self.ndim_supp + ndim_ind + ndim_reps if ndim_shape == 0: shape = tt.constant([], dtype="int64") else: shape = tuple(shape_reps) + tuple(shape_ind) + tuple(shape_supp) # if shape is None: # raise tt.ShapeError() return shape
def _infer_ndim_bcast(ndim, shape, *args): """ Infer the number of dimensions from the shape or the other arguments. Returns ------- (int, variable, tuple) triple, where the variable is an integer vector, and the tuple contains Booleans The first element returned is the inferred number of dimensions. The second element is the shape inferred (combining symbolic and constant informations from shape and args). The third element is a broadcasting pattern corresponding to that shape. """ # Find the minimum value of ndim required by the *args if args: args_ndim = max(arg.ndim for arg in args) else: args_ndim = 0 if isinstance(shape, (tuple, list)): # there is a convention that -1 means the corresponding shape of a # potentially-broadcasted symbolic arg # # This case combines together symbolic and non-symbolic shape # information shape_ndim = len(shape) if ndim is None: ndim = shape_ndim else: if shape_ndim != ndim: raise ValueError('ndim should be equal to len(shape), but\n', 'ndim = %s, len(shape) = %s, shape = %s' % (ndim, shape_ndim, shape)) bcast = [] pre_v_shape = [] for i, s in enumerate(shape): if hasattr(s, 'type'): # s is symbolic bcast.append(False) # todo - introspect further pre_v_shape.append(s) else: if s >= 0: pre_v_shape.append(tensor.as_tensor_variable(s)) bcast.append((s == 1)) elif s == -1: n_a_i = 0 for a in args: # ndim: _ _ _ _ _ _ # ashp: s0 s1 s2 s3 # i if i >= ndim - a.ndim: n_a_i += 1 a_i = i + a.ndim - ndim if not a.broadcastable[a_i]: pre_v_shape.append(a.shape[a_i]) bcast.append(False) break else: if n_a_i == 0: raise ValueError(( 'Auto-shape of -1 must overlap' 'with the shape of one of the broadcastable' 'inputs')) else: pre_v_shape.append(tensor.as_tensor_variable(1)) bcast.append(True) else: ValueError('negative shape', s) # post-condition: shape may still contain both symbolic and # non-symbolic things if len(pre_v_shape) == 0: v_shape = tensor.constant([], dtype='int64') else: v_shape = tensor.stack(pre_v_shape) elif shape is None: # The number of drawn samples will be determined automatically, # but we need to know ndim if not args: raise TypeError(('_infer_ndim_bcast cannot infer shape without' ' either shape or args')) template = reduce(lambda a, b: a + b, args) v_shape = template.shape bcast = template.broadcastable ndim = template.ndim else: v_shape = tensor.as_tensor_variable(shape) if v_shape.ndim != 1: raise TypeError( "shape must be a vector or list of scalar, got '%s'" % v_shape) if ndim is None: ndim = tensor.get_vector_length(v_shape) bcast = [False] * ndim if v_shape.ndim != 1: raise TypeError("shape must be a vector or list of scalar, got '%s'" % v_shape) if v_shape.dtype not in theano.tensor.integer_dtypes: raise TypeError('shape must be an integer vector or list', v_shape.dtype) if args_ndim > ndim: raise ValueError( 'ndim should be at least as big as required by args value', (ndim, args_ndim), args) assert ndim == len(bcast) return ndim, tensor.cast(v_shape, 'int64'), tuple(bcast)
def local_dimshuffle_rv_lift(fgraph, node): """Lift `DimShuffle`s through `RandomVariable` `Op`s. For example, ``normal(mu, std).T == normal(mu.T, std.T)``. The basic idea behind this optimization is that we need to separate the `DimShuffle`ing into independent `DimShuffle`s that each occur in two distinct sub-spaces: the parameters and ``size`` (i.e. replications) sub-spaces. If a `DimShuffle` exchanges dimensions across those two sub-spaces, then we don't do anything. Otherwise, if the `DimShuffle` only exchanges dimensions within each of those sub-spaces, we can break it apart and apply the parameter-space `DimShuffle` to the `RandomVariable`'s distribution parameters, and the apply the replications-space `DimShuffle` to the `RandomVariable`'s``size`` tuple. The latter is a particularly simple rearranging of a tuple, but the former requires a little more work. """ ds_op = node.op if not isinstance(ds_op, DimShuffle): return False base_rv = node.inputs[0] rv_node = base_rv.owner if not (rv_node and isinstance(rv_node.op, RandomVariable) and rv_node.op.ndim_supp == 0): return False # If no one else is using the underlying `RandomVariable`, then we can # do this; otherwise, the graph would be internally inconsistent. if not all((n == node or isinstance(n.op, Shape)) for n, i in fgraph.clients[base_rv]): return False rv_op = rv_node.op rng, size, dtype, *dist_params = rv_node.inputs # We need to know the dimensions that were *not* added by the `size` # parameter (i.e. the dimensions corresponding to independent variates with # different parameter values) num_ind_dims = None if len(dist_params) == 1: num_ind_dims = dist_params[0].ndim else: # When there is more than one distribution parameter, assume that all # of them will broadcast to the maximum number of dimensions num_ind_dims = max(d.ndim for d in dist_params) # If the indices in `ds_new_order` are entirely within the replication # indices group or the independent variates indices group, then we can apply # this optimization. ds_new_order = ds_op.new_order # Create a map from old index order to new/`DimShuffled` index order dim_orders = [(n, d) for n, d in enumerate(ds_new_order) if isinstance(d, int)] # Find the index at which the replications/independents split occurs reps_ind_split_idx = len(dim_orders) - (num_ind_dims + rv_op.ndim_supp) ds_reps_new_dims = dim_orders[:reps_ind_split_idx] ds_ind_new_dims = dim_orders[reps_ind_split_idx:] ds_only_in_ind = ds_ind_new_dims and all(d >= reps_ind_split_idx for n, d in ds_ind_new_dims) if ds_only_in_ind: # Update the `size` array to reflect the `DimShuffle`d dimensions, # since the trailing dimensions in `size` represent the independent # variates dimensions (for univariate distributions, at least) new_size = ([ tt.constant(1, dtype="int64") if o == "x" else size[o] for o in ds_new_order ] if tt.get_vector_length(size) > 0 else size) # Compute the new axes parameter(s) for the `DimShuffle` that will be # applied to the `RandomVariable` parameters (they need to be offset) rv_params_new_order = [ d - reps_ind_split_idx if isinstance(d, int) else d for d in ds_new_order[ds_ind_new_dims[0][0]:] ] # Lift the `DimShuffle`s into the parameters # NOTE: The parameters might not be broadcasted against each other, so # we can only apply the parts of the `DimShuffle` that are relevant. new_dist_params = [] for d in dist_params: if d.ndim < len(ds_ind_new_dims): _rv_params_new_order = [ o for o in rv_params_new_order if (isinstance(o, int) and o < d.ndim) or o == "x" ] else: _rv_params_new_order = rv_params_new_order new_dist_params.append( type(ds_op)(d.type.broadcastable, _rv_params_new_order)(d)) new_node = rv_op.make_node(rng, new_size, dtype, *new_dist_params) if config.compute_test_value != "off": compute_test_value(new_node) return [new_node.outputs[1]] ds_only_in_reps = ds_reps_new_dims and all(d < reps_ind_split_idx for n, d in ds_reps_new_dims) if ds_only_in_reps: # Update the `size` array to reflect the `DimShuffle`d dimensions. # There should be no need to `DimShuffle` now. new_size = [ tt.constant(1, dtype="int64") if o == "x" else size[o] for o in ds_new_order ] new_node = rv_op.make_node(rng, new_size, dtype, *dist_params) if config.compute_test_value != "off": compute_test_value(new_node) return [new_node.outputs[1]] return False
def new(cls, rstate, ndim, dtype, size): v_size = as_tensor_variable(size) if ndim is None: ndim = get_vector_length(v_size) op = cls(GpuArrayType(dtype, (False, ) * ndim)) return op(rstate, v_size)
def new(cls, rstate, ndim, dtype, size): v_size = as_tensor_variable(size) if ndim is None: ndim = get_vector_length(v_size) op = cls(GpuArrayType(dtype, (False,) * ndim)) return op(rstate, v_size)