9b2940f5c418a0315f6de32239021fa1532db319,tensorlayer/models/core.py,Model,__call__,#Model#Any#Any#,76

Before Change

                    z = memory[layer.name]
                else:
                    // FIXME: not sure if there is a better way
                    if is_train is not None:
                        layer.is_train = is_train
                    else:
                        layer.is_train = self.is_train
                    // FIXME: assume each layer has only one prev layer
                    // z = layer.forward(z)
                    z = layer(z)
                    memory[layer.name] = z
            results.append(z.outputs)

After Change

            inputs = tf.convert_to_tensor(inputs)

        // FIXME: currently using self._outputs to judge static network or dynamic network
        if self._outputs is not None:
            // self._inputs and self._outputs are defined when the model is created

            // convert inputs to list for convenience
            // inputs_list = inputs if isinstance(inputs, list) else [inputs]
            outputs_list = self._outputs if isinstance(self._outputs, list) else [self._outputs]
            results = list()
            memory = dict()

            for out in outputs_list:
                stacked_layers = list()
                current = out
                while current is not None:
                    stacked_layers.append(current)
                    // FIXME: assume each layer has only one prev layer
                    current = current._input_layer

                if isinstance(self.inputs, list):
                    idx_of_input = self._find_idx_of_inputs(stacked_layers[-1])
                    z = inputs[idx_of_input]
                else:
                    z = inputs

                for layer in stacked_layers[::-1]:
                    if layer.name in memory:
                        z = memory[layer.name]
                    else:
                        // FIXME: not sure if there is a better way
                        layer.is_train = is_train if is_train is not None else self.is_train
                        // FIXME: assume each layer has only one prev layer
                        // z = layer.forward(z)
                        z = layer(z)
                        memory[layer.name] = z
                results.append(z)

            if not isinstance(self._outputs, list):
                return results[0]
            else:
                return results
        else:
            // self._inputs and self._outputs are NOT defined when self is created (eager mode)

            attr_list = [attr for attr in dir(self) if attr[:2] != "__"]
            attr_list.remove("weights")
            for idx, attr in enumerate(attr_list):
                try:
                    if isinstance(getattr(self, attr), Layer):
                        getattr(self, attr).is_train = is_train if is_train is not None else self.is_train
                except Exception:
                    pass

            return self.forward(inputs, **kwargs)


    @property
    def weights(self):
        if self._weights is not None and len(self._weights) > 0:
            // self._weights already extracted, so do nothing

Instances