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)
def __init__(self, name, class_num, trans_mat_prior = None): """ Initialize the parameters of the logistic regression :type input: theano.tensor.TensorType :param input: symbolic variable that describes the input of the architecture (one minibatch) :type n_in: int :param n_in: number of input units, the dimension of the space in which the datapoints lie :type n_out: int :param n_out: number of output units, the dimension of the space in which the labels lie """ assert isinstance(name, str) and len(name) > 0 self.name = name rng = get_numpy_rng() # initialize with 0 the weights W as a matrix of shape (n_in, n_out) # self.W = theano.shared(value=np.asarray(rng.uniform(low=-2.0, high=2.0, size=(n_in, n_out)), # dtype=theano.config.floatX), # name='W', borrow=True) # initialize the baises b as a vector of n_out 0s # self.b = theano.shared(value=np.asarray(rng.uniform(low=-2.0, high=2.0, size=(n_out,)), # dtype=theano.config.floatX), # name='b', borrow=True) # trasition matrix of class tags # A_{i,j} means the transition prob from class i to class j # A_{0, i} means the prob of start with class i # self.tag_trans_matrix = theano.shared(value = np.asarray(rng.uniform(low=-2.0, high=2.0, size=(class_num + 1 ,class_num )), # dtype=theano.config.floatX), # name='tag_trans', borrow = True) if trans_mat_prior == None: self.tag_trans_matrix = theano.shared(value = np.zeros((class_num + 1 ,class_num ), dtype=theano.config.floatX), name='path_layer_trans_%s' % (self.name), borrow = True) else: self.tag_trans_matrix = theano.shared(value = np.asarray(trans_mat_prior, dtype=theano.config.floatX), name='path_layer_trans_%s' % (self.name), borrow = True)
def __init__(self, input_dim = None, output_dim = None, W = None, b = None): """ Initialize the parameters of the logistic regression :type input: theano.tensor.TensorType :param input: symbolic variable that describes the input of the architecture (one minibatch) :type n_in: int :param n_in: number of input units, the dimension of the space in which the datapoints lie :type n_out: int :param n_out: number of output units, the dimension of the space in which the labels lie """ # param_valid = (W is not None and b is not None ) or (n_in is not None and n_out is not None) # assert param_valid, "The construction param is not valid" 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") if W: self.W = theano.shared(value=W.astype(theano.config.floatX), name='softmax_W_%s' % (self.name), borrow=True) elif (n_in is not None and n_out is not None) : # initialize with 0 the weights W as a matrix of shape (n_in, n_out) rng = get_numpy_rng() W_values = numpy.asarray(rng.uniform( low=-numpy.sqrt(6. / (n_in + n_out)), high=numpy.sqrt(6. / (n_in + n_out)), size=(n_in, n_out)), dtype=theano.config.floatX) self.W = theano.shared(value=W_values, name='softmax_W_%s' % (self.name), borrow=True) if b: self.b = theano.shared(value=b.astype(theano.config.floatX), name='softmax_b_%s' % (self.name), borrow=True) elif (n_in is not None and n_out is not None) : # initialize the baises b as a vector of n_out 0s self.b = theano.shared(value=numpy.zeros((n_out,), dtype=theano.config.floatX), name='softmax_b_%s' % (self.name), borrow=True)