Beispiel #1
0
    def add_module(self, *args, **kwargs):
        if 'input_spec' in kwargs:
            layer = super().add_module(*args, modules=layer_modules, **kwargs)
            self.output_spec = layer.output_spec

        else:
            if self.output_spec is None:
                if util.is_atomic_values_spec(values_spec=self.inputs_spec):
                    self.output_spec = self.inputs_spec
                elif len(self.inputs_spec) == 1:
                    self.output_spec = next(iter(self.inputs_spec.values()))
                else:
                    self.output_spec = None

            if self.output_spec is not None:
                if 'input_spec' in kwargs:
                    kwargs['input_spec'] = util.unify_value_specs(
                        value_spec1=kwargs['input_spec'],
                        value_spec2=self.output_spec)
                else:
                    kwargs['input_spec'] = self.output_spec

            layer = super().add_module(*args, modules=layer_modules, **kwargs)

            self.output_spec = layer.output_spec

        if not isinstance(layer, (Layer, Parameter)):
            raise TensorforceError.type(name='layer-based network',
                                        argument='sub-module',
                                        value=layer)

        return layer
Beispiel #2
0
    def __init__(self,
                 name,
                 input_spec=None,
                 summary_labels=None,
                 l2_regularization=None):
        super().__init__(name=name,
                         summary_labels=summary_labels,
                         l2_regularization=l2_regularization)

        self.input_spec = self.default_input_spec()
        self.input_spec = util.valid_value_spec(value_spec=self.input_spec,
                                                accept_underspecified=True,
                                                return_normalized=True)

        if input_spec is not None:
            input_spec = util.valid_value_spec(value_spec=input_spec,
                                               accept_underspecified=True,
                                               return_normalized=True)

            self.input_spec = util.unify_value_specs(
                value_spec1=self.input_spec, value_spec2=input_spec)

        # Copy so that spec can be modified
        self.output_spec = self.get_output_spec(
            input_spec=dict(self.input_spec))
        self.output_spec = util.valid_value_spec(value_spec=self.output_spec,
                                                 accept_underspecified=True,
                                                 return_normalized=True)

        # Register layer globally
        if Layer.layers is None:
            Layer.layers = OrderedDict()
        # if self.name in Layer.layers:
        #     raise TensorforceError.unexpected()
        Layer.layers[self.name] = self
    def __init__(self,
                 name,
                 input_spec=None,
                 l2_regularization=None,
                 summary_labels=None):
        """
        Layer constructor.

        Args:
            input_spec (specification): Input tensor specification.
        """
        super().__init__(name=name,
                         l2_regularization=l2_regularization,
                         summary_labels=summary_labels)

        self.input_spec = self.default_input_spec()
        self.input_spec = util.valid_value_spec(value_spec=self.input_spec,
                                                accept_underspecified=True,
                                                return_normalized=True)

        if input_spec is not None:
            input_spec = util.valid_value_spec(value_spec=input_spec,
                                               accept_underspecified=True,
                                               return_normalized=True)

            self.input_spec = util.unify_value_specs(
                value_spec1=self.input_spec, value_spec2=input_spec)

        # Copy so that spec can be modified
        self.output_spec = self.get_output_spec(
            input_spec=dict(self.input_spec))
        self.output_spec = util.valid_value_spec(value_spec=self.output_spec,
                                                 accept_underspecified=True,
                                                 return_normalized=True)