Source code for tensorlayer.layers.core

#! /usr/bin/python
# -*- coding: utf-8 -*-

import inspect
import six

from abc import ABCMeta, abstractmethod

import numpy as np

import tensorflow as tf

from tensorlayer.layers.utils import list_remove_repeat

from tensorlayer import logging

from tensorlayer.decorators import deprecated_alias
from tensorlayer.decorators import protected_method
from tensorlayer.decorators import private_method

__all__ = [

class LayersConfig(object):

    tf_dtype = tf.float32  # TensorFlow DType
    set_keep = {}  # A dictionary for holding tf.placeholders

    def __init__(self):


[docs]class Layer(object): """The basic :class:`Layer` class represents a single layer of a neural network. It should be subclassed when implementing new types of layers. Because each layer can keep track of the layer(s) feeding into it, a network's output :class:`Layer` instance can double as a handle to the full network. Parameters ---------- prev_layer : :class:`Layer` or None Previous layer (optional), for adding all properties of previous layer(s) to this layer. act : activation function (None by default) The activation function of this layer. name : str or None A unique layer name. Methods --------- print_params(details=True, session=None) Print all parameters of this network. print_layers() Print all outputs of all layers of this network. count_params() Return the number of parameters of this network. get_all_params() Return the parameters in a list of array. Examples --------- - Define model >>> import tensorflow as tf >>> import tensorlayer as tl >>> x = tf.placeholder("float32", [None, 100]) >>> n = tl.layers.InputLayer(x, name='in') >>> n = tl.layers.DenseLayer(n, 80, name='d1') >>> n = tl.layers.DenseLayer(n, 80, name='d2') - Get information >>> print(n) Last layer is: DenseLayer (d2) [None, 80] >>> n.print_layers() [TL] layer 0: d1/Identity:0 (?, 80) float32 [TL] layer 1: d2/Identity:0 (?, 80) float32 >>> n.print_params(False) [TL] param 0: d1/W:0 (100, 80) float32_ref [TL] param 1: d1/b:0 (80,) float32_ref [TL] param 2: d2/W:0 (80, 80) float32_ref [TL] param 3: d2/b:0 (80,) float32_ref [TL] num of params: 14560 >>> n.count_params() 14560 - Slicing the outputs >>> n2 = n[:, :30] >>> print(n2) Last layer is: Layer (d2) [None, 30] - Iterating the outputs >>> for l in n: >>> print(l) Tensor("d1/Identity:0", shape=(?, 80), dtype=float32) Tensor("d2/Identity:0", shape=(?, 80), dtype=float32) """ # Added to allow auto-completion @deprecated_alias(layer='prev_layer', end_support_version=1.9) # TODO remove this line for the 1.9 release def __init__(self, prev_layer, act=None, name=None, *args, **kwargs): self.inputs = None self.outputs = None self.all_layers = list() self.all_params = list() self.all_drop = dict() if name is None: raise ValueError('Layer must have a name.') for key in kwargs.keys(): setattr(self, key, self._argument_dict_checkup(kwargs[key])) self.act = act if act not in [None, tf.identity] else None scope_name = tf.get_variable_scope().name = scope_name + '/' + name if scope_name else name if isinstance(prev_layer, Layer): # 1. for normal layer have only 1 input i.e. DenseLayer # Hint : list(), dict() is pass by value (shallow), without them, # it is pass by reference. self.inputs = prev_layer.outputs self._add_layers(prev_layer.all_layers) self._add_params(prev_layer.all_params) self._add_dropout_layers(prev_layer.all_drop) elif isinstance(prev_layer, list): # 2. for layer have multiply inputs i.e. ConcatLayer self.inputs = [layer.outputs for layer in prev_layer] self._add_layers(sum([l.all_layers for l in prev_layer], [])) self._add_params(sum([l.all_params for l in prev_layer], [])) self._add_dropout_layers(sum([list(l.all_drop.items()) for l in prev_layer], [])) elif isinstance(prev_layer, tf.Tensor) or isinstance(prev_layer, tf.Variable): # placeholders if self.__class__.__name__ not in ['InputLayer', 'OneHotInputLayer', 'Word2vecEmbeddingInputlayer', 'EmbeddingInputlayer', 'AverageEmbeddingInputlayer']: raise RuntimeError("Please use `tl.layers.InputLayer` to convert Tensor/Placeholder to a TL layer") self.inputs = prev_layer elif prev_layer is not None: # 4. tl.models self._add_layers(prev_layer.all_layers) self._add_params(prev_layer.all_params) self._add_dropout_layers(prev_layer.all_drop) if hasattr(prev_layer, "outputs"): self.inputs = prev_layer.outputs
[docs] def print_params(self, details=True, session=None): """Print all info of parameters in the network""" for i, p in enumerate(self.all_params): if details: try: val = p.eval(session=session) " param {:3}: {:20} {:15} {} (mean: {:<18}, median: {:<18}, std: {:<18}) ". format(i,, str(val.shape),, val.mean(), np.median(val), val.std()) ) except Exception as e: raise Exception( "Hint: print params details after tl.layers.initialize_global_variables(sess) " "or use network.print_params(False)." ) else:" param {:3}: {:20} {:15} {}".format(i,, str(p.get_shape())," num of params: %d" % self.count_params())
[docs] def print_layers(self): """Print all info of layers in the network.""" for i, layer in enumerate(self.all_layers): #" layer %d: %s" % (i, str(layer))) " layer {:3}: {:20} {:15} {}".format(i,, str(layer.get_shape()), )
[docs] def count_params(self): """Returns the number of parameters in the network.""" n_params = 0 for _i, p in enumerate(self.all_params): n = 1 # for s in p.eval().shape: for s in p.get_shape(): try: s = int(s) except Exception: s = 1 if s: n = n * s n_params = n_params + n return n_params
[docs] def get_all_params(self, session=None): """Return the parameters in a list of array.""" _params = [] for p in self.all_params: if session is None: _params.append(p.eval()) else: _params.append( return _params
def __str__(self): return " Last layer is: %s (%s) %s" % (self.__class__.__name__,, self.outputs.get_shape().as_list()) def __getitem__(self, key): net_new = Layer(prev_layer=None, = + '_indexing' net_new.inputs = self.inputs net_new.outputs = self.outputs[key] net_new._add_layers(self.all_layers[:-1]) net_new._add_layers(net_new.outputs) net_new._add_params(self.all_params) net_new._add_dropout_layers(self.all_drop) return net_new def __setitem__(self, key, item): raise TypeError("The Layer API does not allow to use the method: `__setitem__`") def __delitem__(self, key): raise TypeError("The Layer API does not allow to use the method: `__delitem__`") def __iter__(self): for x in self.all_layers: yield x def __len__(self): return len(self.all_layers) @protected_method def _get_init_args(self, skip=4): """Get all arguments of current layer for saving the graph.""" stack = inspect.stack() if len(stack) < skip + 1: raise ValueError("The length of the inspection stack is shorter than the requested start position.") args, _, _, values = inspect.getargvalues(stack[skip][0]) params = {} for arg in args: # some args dont need to be saved into the graph. e.g. the input placeholder if values[arg] is not None and arg not in ['self', 'prev_layer', 'inputs']: val = values[arg] # change function (e.g. act) into dictionary of module path and function name if inspect.isfunction(val): params[arg] = {"module_path": val.__module__, "func_name": val.__name__} # ignore more args e.g. TF class elif arg.endswith('init'): continue # for other data type, save them directly else: params[arg] = val return params @protected_method def _add_layers(self, layers): if isinstance(layers, list): try: # list of class Layer new_layers = [layer.outputs for layer in layers] self.all_layers.extend(list(new_layers)) except AttributeError: # list of tf.Tensor self.all_layers.extend(list(layers)) else: self.all_layers.append(layers) self.all_layers = list_remove_repeat(self.all_layers) @protected_method def _add_params(self, params): if isinstance(params, list): self.all_params.extend(list(params)) else: self.all_params.append(params) self.all_params = list_remove_repeat(self.all_params) @protected_method def _add_dropout_layers(self, drop_layers): if isinstance(drop_layers, dict) or isinstance(drop_layers, list): self.all_drop.update(dict(drop_layers)) elif isinstance(drop_layers, tuple): self.all_drop.update(list(drop_layers)) else: raise ValueError() @private_method def _apply_activation(self, logits, **kwargs): if not kwargs: kwargs = {} return self.act(logits, **kwargs) if self.act is not None else logits @private_method def _argument_dict_checkup(self, args): if not isinstance(args, dict) and args is not None: raise AssertionError( "One of the argument given to %s should be formatted as a dictionary" % self.__class__.__name__ ) return args if args is not None else {}
# def __getstate__(self): # pickle save # return {'version': 0.1, # # 'outputs': self.outputs, # } # # def __setstate__(self, state): # pickle restore # self.outputs = state['outputs']