def __setstate__(self, state): assert state['type'] == "perception", "The layer type is not match" self.W = theano.shared(value=state['W'].astype(theano.config.floatX), name='W', borrow=True) self.b = theano.shared(value=state['b'].astype(theano.config.floatX), name='b', borrow=True) self.input_dim = state['input_dim'] self.output_dim = state['output_dim'] self.activator_type = state['activator_type'] self.activator = get_activation(self.activator_type)
def __init__(self, activator_type="linear", input_dim = None, output_dim = None, W=None, b=None, ): # `W` is initialized with `W_values` which is uniformely sampled # from sqrt(-6./(n_in+n_hidden)) and sqrt(6./(n_in+n_hidden)) # for tanh activation function # the output of uniform if converted using asarray to dtype # theano.config.floatX so that the code is runable on GPU # Note : optimal initialization of weights is dependent on the # activation function used (among other things). # For example, results presented in [Xavier10] suggest that you # should use 4 times larger initial weights for sigmoid # compared to tanh # We have no info for other function, so we use the same as # tanh. assert activator_type is not None, "Activation must be provided" self.activator_type = activator_type self.activator = get_activation(self.activator_type) if input_dim is not None and output_dim is not None: if W is None: rng = get_numpy_rng() W = numpy.asarray(rng.uniform( low=-numpy.sqrt(6. / (input_dim + output_dim)), high=numpy.sqrt(6. / (input_dim + output_dim)), size=(input_dim, output_dim)), dtype=theano.config.floatX) if self.activator == theano.tensor.nnet.sigmoid: W *= 4 else: assert input_dim == W.shape[0] and input_dim == W.shape[1] if b is None: b = numpy.zeros((output_dim,), dtype=theano.config.floatX) else: assert output_dim == b.shape[0] self.W = theano.shared(value=W, borrow=True) self.b = theano.shared(value=b, borrow=True) self.input_dim_, self.output_dim_ = W.shape elif W is not None and b is not None: self.W = theano.shared(value=W, borrow=True) self.b = theano.shared(value=b, borrow=True) self.input_dim_, self.output_dim_ = W.shape else: raise Exception("Perception Layer needs parameter " "in pair of (W,b) or (n_in, n_out) besides activation")
def __init__(self, activator_type="linear", tensor_shape = None, init_W=None, init_b=None, ): assert activator_type is not None, "Activation must be provided" self.activator_type = activator_type self.activator = get_activation(self.activator_type) if init_W is not None and tensor_shape is not None: assert init_W.shape == tensor_shape, "init tensor size is not equal to the given tensor shape" # Input: a 4D tensor corresponding to a mini-batch of input images with shape: # [mini-batch size, number of input feature maps, image height, image width]. # Weight: a 4D tensor with shape : # [number of feature maps at layer m, number of feature maps at layer m-1, filter height, filter width] rng = get_numpy_rng() if init_W is None and tensor_shape is None: raise Exception("neither W now tensor shape is provided.") elif init_W is not None: self.W = theano.shared(init_W.astype(theano.config.floatX), borrow=True) self.tensor_shape = init_W.shape elif init_W is None: self.tensor_shape = tensor_shape (output_feature_map_num, input_feature_map_num, conv_window , filter_width) = tensor_shape w_bound = np.sqrt(input_feature_map_num * filter_width) init_W = rng.uniform(low=-1.0 / w_bound, high=1.0 / w_bound, size=tensor_shape) self.W = theano.shared(init_W.astype(theano.config.floatX), borrow=True) if init_b is None and tensor_shape is None: raise Exception("neither b now tensor shape is provided.") elif init_b is not None: self.b = theano.shared(init_b.astype(theano.config.floatX), borrow=True) elif init_b is None: (output_feature_map_num, input_feature_map_num, conv_window , filter_width) = tensor_shape b_shape = (output_feature_map_num,) init_b = rng.uniform(low=-.5, high=.5, size=b_shape) self.b = theano.shared(init_b.astype(theano.config.floatX), borrow=True)