def __call__(self, shape, dtype=None): # print("PWMKernelInitializer shape: ", shape) pwm = pwm_list2pwm_array(self.pwm_list, shape, dtype, self.background_probs) if self.add_noise_before_Pwm2Pssm: # add noise with numpy truncnorm function pwm = _truncated_normal(mean=pwm, stddev=self.stddev, seed=self.seed) pssm = pwm_array2pssm_array(pwm, background_probs=self.background_probs) # Force sttdev to be 0, because noise already added. May just use tf.Variable(pssm) # return K.Variable(pssm) # this raise error return K.truncated_normal(shape, mean=pssm, stddev=0, dtype=dtype, seed=self.seed) else: pssm = pwm_array2pssm_array(pwm, background_probs=self.background_probs) return K.truncated_normal(shape, mean=pssm, stddev=self.stddev, dtype=dtype, seed=self.seed)
def neural_network_model(data): # Smaller initial values making training smoother hidden_1_layer = { 'weights': K.variable(K.truncated_normal([784, n_nodes_hl1], stddev=0.1)), 'biases': K.variable(K.constant(0.1, shape=[n_nodes_hl1])) } hidden_2_layer = { 'weights': K.variable(K.truncated_normal([n_nodes_hl1, n_nodes_hl2], stddev=0.1)), 'biases': K.variable(K.constant(0.1, shape=[n_nodes_hl2])) } hidden_3_layer = { 'weights': K.variable(K.truncated_normal([n_nodes_hl2, n_nodes_hl3], stddev=0.1)), 'biases': K.variable(K.constant(0.1, shape=[n_nodes_hl3])) } output_layer = { 'weights': K.variable(K.truncated_normal([n_nodes_hl3, n_classes], stddev=0.1)), 'biases': K.variable(K.constant(0.1, shape=[n_classes])) } # Matmul is matrix multiplication l1 = tf.add(K.dot(data, hidden_1_layer['weights']), hidden_1_layer['biases']) # Passes through activation function # Official definiton: Computes rectified linear and returns a Tensor l1 = tf.nn.relu(l1) # input data # √ l2 = tf.add(K.dot(l1, hidden_2_layer['weights']), hidden_2_layer['biases']) l2 = tf.nn.relu(l2) l3 = tf.add(K.dot(l2, hidden_3_layer['weights']), hidden_3_layer['biases']) l3 = tf.nn.relu(l3) output = K.dot(l3, output_layer['weights']) + output_layer['biases'] return output
def spectral_norm(w, iteration=1): #From "Spectral Normalization for GANs" paper #https://arxiv.org/pdf/1802.05957.pdf w_shape = w.shape.as_list() w = K.reshape(w, [-1, w_shape[-1]]) u = K.truncated_normal([1, w_shape[-1]]) u_hat = u v_hat = None for i in range( iteration): #power iteration, usually iteration = 1 will be enough v_ = K.dot(u_hat, K.transpose(w)) v_hat = l2_norm(v_) u_ = K.dot(v_hat, w) u_hat = l2_norm(u_) sigma = K.dot(K.dot(v_hat, w), K.transpose(u_hat)) w_norm = w / sigma w_norm = K.reshape(w_norm, w_shape) return w_norm
def __call__(self, shape, dtype=None): from keras.initializers import _compute_fans fan_in, fan_out = _compute_fans(shape) scale = self.scale if self.mode == 'fan_in': scale /= max(1., fan_in) elif self.mode == 'fan_out': scale /= max(1., fan_out) else: scale /= max(1., float(fan_in + fan_out) / 2) if self.distribution == 'normal': # 0.879... = scipy.stats.truncnorm.std(a=-2, b=2, loc=0., scale=1.) stddev = np.sqrt(scale) / .87962566103423978 init = K.truncated_normal(shape, 0., stddev, dtype=dtype, seed=self.seed) else: limit = np.sqrt(3. * scale) init = K.random_uniform(shape, -limit, limit, dtype=dtype, seed=self.seed) return init * self.tree_weight
def __call__(self, shape, dtype=None): # print("PWMKernelInitializer shape: ", shape) return K.truncated_normal(shape, mean=pwm_list2pwm_array( self.pwm_list, shape, dtype), stddev=self.stddev, dtype=dtype, seed=self.seed)
def rand_weight_like(weight): assert K.image_data_format( ) == "channels_last", "support channels last, but you are {}".format( K.image_data_format()) kw, kh, num_channel, filters = weight.shape kvar = K.truncated_normal((kw, kh, num_channel, filters), 0, 0.05) w = K.eval(kvar) b = np.zeros((filters, )) return w, b
def __call__(self, shape, dtype=None): x = K.truncated_normal(shape, self.mean, self.stddev, dtype=dtype, seed=self.seed) if self.seed is not None: self.seed += 1 return x
def call(self, x): x = Permute([2, 1])(x) k = K.variable(K.truncated_normal(shape=(20, 50, 300))) #返回具有截尾正太分布值的向量,在距离均值两个标准差之外的数据将会被截断并重新生成 x = K.conv1d(x, k, padding='same') x = K.max(x, axis=1) # x = keras.backend.permute_dimensions(x, [0, 3, 2, 1]) return x
def call(self, x): axis = (1,2) # height, widtt -> y,x conv0 = K.conv2d(x, self.kernel, padding="same") conv1 = K.conv2d(conv0, self.kernel, padding="same") dilatedConv0 = dilateTensor(conv0, axis, 0, 0) dilatedConv1 = dilateTensor(conv1, axis, 1, 1) conv1 = Add([dilatedConv0, dilatedConv1]) shape = list(self.kernel_size) + [self.out_dim, self.out_dim] weights = K.truncated_normal(shape) conv2 = K.conv2d(conv1, weights, padding="same") output = Add([conv1, conv2]) output = K.relu(output) return output
def normal_init(shape): return K.truncated_normal(shape, stddev=0.1)
def weight_variable(shape): return K.truncated_normal(shape, stddev = 0.01)
def initializer_he(shape, dtype=None): ''' He et al. initialization from https://arxiv.org/pdf/1502.01852.pdf ''' return K.truncated_normal(shape, dtype=dtype) * K.sqrt(K.constant(2. / float(shape[0])))
def weight_variable(shape): return backend.truncated_normal(shape, stddev=0.1)
def f(shape, dtype=None): return K.truncated_normal(shape, stddev=stddev, dtype=dtype)