class_docstr: lasagne.layers.NINLayer_c01b(incoming, num_units, untie_biases=False,
  W=lasagne.init.GlorotUniform(), b=lasagne.init.Constant(0.),
  nonlinearity=lasagne.nonlinearities.rectify, **kwargs)
  
  Network-in-network layer with c01b axis ordering.
  
  This is a c01b version of :class:`lasagne.layers.NINLayer`.
  
  Parameters
  ----------
  incoming : a :class:`Layer` instance or a tuple
      The layer feeding into this layer, or the expected input shape
  
  num_units : int
      The number of units of the layer
  
  untie_biases : bool
      If ``False``, the network has a single bias vector similar to a dense
      layer. If ``True``, a separate bias vector is used for each spatial
      position.
  
  W : Theano shared variable, numpy array or callable
      An initializer for the weights of the layer. If a shared variable or a
      numpy array is provided the shape should be
      (num_units, num_input_channels).
      See :func:`lasagne.utils.create_param` for more information.
  
  b : Theano shared variable, numpy array, callable or None
      An initializer for the biases of the layer. If a shared variable or a
      numpy array is provided the correct shape is determined by the
      untie_biases setting. If untie_biases is ``False``, then the shape
      should be ``(num_units,)``. If untie_biases is ``True`` then the shape
      should be ``(num_units, rows, columns)``. If ``None`` is provided the
      layer will have no biases.
      See :func:`lasagne.utils.create_param` for more information.
  
  nonlinearity : callable or None
      The nonlinearity that is applied to the layer activations. If None
      is provided, the layer will be linear.
  
  **kwargs
      Any additional keyword arguments are passed to the `Layer` superclass.
code: def get_output_for(self, input, **kwargs):
      # fc * c01b... = f01b...
      out = T.tensordot(self.W, input, axes=[[1], [0]])
  
      if self.b is None:
          activation = out
      else:
          if self.untie_biases:
              bias_axes = range(input.ndim - 1) + ["x"]
          else:
              bias_axes = [0] + (["x"] * (input.ndim - 1))
          b_shuffled = self.b.dimshuffle(bias_axes)
          activation = out + b_shuffled
  
      return self.nonlinearity(activation)
  
imports: import warnings
  import numpy
  import theano
  import theano.tensor
  from ..None import init
  from ..None import nonlinearities
  from .base import Layer
  from .conv import conv_output_length, BaseConvLayer
  from .pool import pool_output_length
  from ..utils import as_tuple
  from theano.sandbox.cuda.basic_ops import gpu_contiguous
  from pylearn2.sandbox.cuda_convnet.filter_acts import FilterActs
label_desc: Use image node_id 3 for calling the NINLayer_c01b obj's underlying member method code with example usage: obj.get_output_for(input) and returns: self