parameters: (self, input_layer, n_filters, filter_width, filter_height, stride_x, stride_y, weights_std, init_bias_value, nonlinearity=rectify, dropout=0., dropout_tied=False, implementation='convolution')
docstring: implementation can be:
              - convolution: use conv2d with the subsample parameter
              - unstrided: use conv2d + reshaping so the result is a convolution with strides (1, 1)
              - single_dot: use a large tensor product
              - many_dots: use a bunch of tensor products
docstring_summary: implementation can be:
              - convolution: use conv2d with the subsample parameter
              - unstrided: use conv2d + reshaping so the result is a convolution with strides (1, 1)
              - single_dot: use a large tensor product
              - many_dots: use a bunch of tensor products
docstring_tokens: implementation can be : - convolution : use conv2d with the subsample parameter - unstrided : use conv2d + reshaping so the result is a convolution with strides ( 1 1 ) - single_dot : use a large tensor product - many_dots : use a bunch of tensor products
function: def __init__(self, input_layer, n_filters, filter_width, filter_height, stride_x, stride_y, weights_std, init_bias_value, nonlinearity=rectify, dropout=0., dropout_tied=False, implementation='convolution'):
          """
          implementation can be:
              - convolution: use conv2d with the subsample parameter
              - unstrided: use conv2d + reshaping so the result is a convolution with strides (1, 1)
              - single_dot: use a large tensor product
              - many_dots: use a bunch of tensor products
          """
          self.n_filters = n_filters
          self.filter_width = filter_width
          self.filter_height = filter_height
          self.stride_x = stride_x
          self.stride_y = stride_y
          self.input_layer = input_layer
          self.weights_std = np.float32(weights_std)
          self.init_bias_value = np.float32(init_bias_value)
          self.nonlinearity = nonlinearity
          self.dropout = dropout
          self.dropout_tied = dropout_tied  # if this is on, the same dropout mask is applied across the entire input map
          self.implementation = implementation # this controls whether the convolution is computed using theano's op,
          # as a bunch of tensor products, or a single stacked tensor product.
          self.mb_size = self.input_layer.mb_size
  
          self.input_shape = self.input_layer.get_output_shape()
          ' mb_size, n_filters, filter_width, filter_height '
  
          self.filter_shape = (n_filters, self.input_shape[1], filter_width, filter_height)
  
          if self.filter_width % self.stride_x != 0:
              raise RuntimeError("Filter width is not a multiple of the stride in the X direction")
  
          if self.filter_height % self.stride_y != 0:
              raise RuntimeError("Filter height is not a multiple of the stride in the Y direction")
  
          self.W = shared_single(4) # theano.shared(np.random.randn(*self.filter_shape).astype(np.float32) * self.weights_std)
          self.b = shared_single(1) # theano.shared(np.ones(n_filters).astype(np.float32) * self.init_bias_value)
          self.params = [self.W, self.b]
          self.bias_params = [self.b]
          self.reset_params()
function_tokens: def __init__ ( self , input_layer , n_filters , filter_width , filter_height , stride_x , stride_y , weights_std , init_bias_value , nonlinearity = rectify , dropout = 0. , dropout_tied = False , implementation = 'convolution' ) : self . n_filters = n_filters self . filter_width = filter_width self . filter_height = filter_height self . stride_x = stride_x self . stride_y = stride_y self . input_layer = input_layer self . weights_std = np . float32 ( weights_std ) self . init_bias_value = np . float32 ( init_bias_value ) self . nonlinearity = nonlinearity self . dropout = dropout self . dropout_tied = dropout_tied # if this is on, the same dropout mask is applied across the entire input map self . implementation = implementation # this controls whether the convolution is computed using theano's op, # as a bunch of tensor products, or a single stacked tensor product. self . mb_size = self . input_layer . mb_size self . input_shape = self . input_layer . get_output_shape ( ) ' mb_size, n_filters, filter_width, filter_height ' self . filter_shape = ( n_filters , self . input_shape [ 1 ] , filter_width , filter_height ) if self . filter_width % self . stride_x != 0 : raise RuntimeError ( "Filter width is not a multiple of the stride in the X direction" ) if self . filter_height % self . stride_y != 0 : raise RuntimeError ( "Filter height is not a multiple of the stride in the Y direction" ) self . W = shared_single ( 4 ) # theano.shared(np.random.randn(*self.filter_shape).astype(np.float32) * self.weights_std) self . b = shared_single ( 1 ) # theano.shared(np.ones(n_filters).astype(np.float32) * self.init_bias_value) self . params = [ self . W , self . b ] self . bias_params = [ self . b ] self . reset_params ( )