def __init__(self, name, type, value, strict, allow_downcast=None, container=None): super(SharedVariable, self).__init__(type=type, name=name, owner=None, index=None) if container is not None: self.container = container if (value is not None) or (strict is not None): raise TypeError('value and strict are ignored if you pass ' 'a container here') else: self.container = Container(self, storage=[ type.filter( value, strict=strict, allow_downcast=allow_downcast) ], readonly=False, strict=strict, allow_downcast=allow_downcast)
def allocate(self, memo): """override `Component.allocate` """ for old_r, new_r in self.random_state_variables: if old_r in memo: assert memo[old_r].update is new_r else: memo[old_r] = In(old_r, value=Container(old_r, storage=[None]), update=new_r, mutable=True)
def __init__(self, name, type, value, strict, allow_downcast=None, container=None): """ :param name: The name for this variable (see `Variable`). :param type: The type for this variable (see `Variable`). :param value: A value to associate with this variable (a new container will be created). :param strict: True -> assignments to .value will not be cast or copied, so they must have the correct type. :param allow_downcast: Only applies if `strict` is False. True -> allow assigned value to lose precision when cast during assignment. False -> never allow precision loss. None -> only allow downcasting of a Python float to a scalar floatX. :param container: The container to use for this variable. Illegal to pass this as well as a value. :note: For more user-friendly constructor, see `shared` """ super(SharedVariable, self).__init__(type=type, name=name, owner=None, index=None) if container is not None: self.container = container if (value is not None) or (strict is not None): raise TypeError( 'value and strict are ignored if you pass a container here' ) else: if container is not None: raise TypeError('Error to specify both value and container') self.container = Container(self, storage=[ type.filter( value, strict=strict, allow_downcast=allow_downcast) ], readonly=False, strict=strict, allow_downcast=allow_downcast)
def allocate(self, memo): """ Allocates a Container for each input in the kit. Sets a key in the memo that maps the SymbolicInputKit to the list of Containers. """ for input in self.kit.sinputs: r = input.variable if r not in memo: input = copy(input) input.value = Container(r, storage=[None]) memo[r] = input
def clone_get_equiv(i, o, replaced_inputs=[]): """ WRITEME :type i: list :param i: input L{Variable}s :type o: list :param o: output L{Variable}s :type copy_inputs_and_orphans: bool :param copy_inputs_and_orphans: if True, the inputs and the orphans will be replaced in the cloned graph by copies available in the equiv dictionary returned by the function (copy_inputs_and_orphans defaults to True) :rtype: a dictionary :return: equiv mapping each L{Variable} and L{Op} in the graph delimited by i and o to a copy (akin to deepcopy's memo). """ from theano.gof.graph import io_toposort from theano.gof import Container from copy import deepcopy copy_inputs_and_orphans = True d = {} for input in i: if input in replaced_inputs: cpy = input.clone() # deep-copying the container, otherwise the copied input's container will point to the same place cont = input.container cpy.container = Container( cpy, storage=[ input.type.filter(deepcopy(cpy.value), strict=cont.strict, allow_downcast=cont.allow_downcast) ], readonly=cont.readonly, strict=cont.strict, allow_downcast=cont.allow_downcast) cpy.owner = None cpy.index = None d[input] = cpy else: d[input] = input for apply in io_toposort(i, o): for input in apply.inputs: if input not in d: if copy_inputs_and_orphans and input in replaced_inputs: # TODO: not quite sure what to do here cpy = input.clone() d[input] = cpy else: d[input] = input new_apply = apply.clone_with_new_inputs([d[i] for i in apply.inputs]) d[apply] = new_apply for output, new_output in zip(apply.outputs, new_apply.outputs): d[output] = new_output for output in o: if output not in d: d[output] = output.clone() return d