Python tensorflow.matmul() Examples
The following are 30
code examples of tensorflow.matmul().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
tensorflow
, or try the search function
.
Example #1
Source File: slicenet.py From fine-lm with MIT License | 6 votes |
def rank_loss(sentence_emb, image_emb, margin=0.2): """Experimental rank loss, thanks to kkurach@ for the code.""" with tf.name_scope("rank_loss"): # Normalize first as this is assumed in cosine similarity later. sentence_emb = tf.nn.l2_normalize(sentence_emb, 1) image_emb = tf.nn.l2_normalize(image_emb, 1) # Both sentence_emb and image_emb have size [batch, depth]. scores = tf.matmul(image_emb, tf.transpose(sentence_emb)) # [batch, batch] diagonal = tf.diag_part(scores) # [batch] cost_s = tf.maximum(0.0, margin - diagonal + scores) # [batch, batch] cost_im = tf.maximum( 0.0, margin - tf.reshape(diagonal, [-1, 1]) + scores) # [batch, batch] # Clear diagonals. batch_size = tf.shape(sentence_emb)[0] empty_diagonal_mat = tf.ones_like(cost_s) - tf.eye(batch_size) cost_s *= empty_diagonal_mat cost_im *= empty_diagonal_mat return tf.reduce_mean(cost_s) + tf.reduce_mean(cost_im)
Example #2
Source File: memory.py From DOTA_models with Apache License 2.0 | 6 votes |
def get_hint_pool_idxs(self, normalized_query): """Get small set of idxs to compute nearest neighbor queries on. This is an expensive look-up on the whole memory that is used to avoid more expensive operations later on. Args: normalized_query: A Tensor of shape [None, key_dim]. Returns: A Tensor of shape [None, choose_k] of indices in memory that are closest to the queries. """ # look up in large memory, no gradients with tf.device(self.nn_device): similarities = tf.matmul(tf.stop_gradient(normalized_query), self.mem_keys, transpose_b=True, name='nn_mmul') _, hint_pool_idxs = tf.nn.top_k( tf.stop_gradient(similarities), k=self.choose_k, name='nn_topk') return hint_pool_idxs
Example #3
Source File: test_attacks_tf.py From neural-fingerprinting with BSD 3-Clause "New" or "Revised" License | 6 votes |
def test_fgm_gradient_max(self): input_dim = 2 num_classes = 3 batch_size = 4 rng = np.random.RandomState([2017, 8, 23]) x = tf.placeholder(tf.float32, [batch_size, input_dim]) weights = tf.placeholder(tf.float32, [input_dim, num_classes]) logits = tf.matmul(x, weights) probs = tf.nn.softmax(logits) adv_x = fgm(x, probs) random_example = rng.randint(batch_size) random_feature = rng.randint(input_dim) output = tf.slice(adv_x, [random_example, random_feature], [1, 1]) dx, = tf.gradients(output, x) # The following line catches GitHub issue #243 self.assertIsNotNone(dx) dx = self.sess.run(dx, feed_dict=random_feed_dict(rng, [x, weights])) ground_truth = np.zeros((batch_size, input_dim)) ground_truth[random_example, random_feature] = 1. self.assertClose(dx, ground_truth)
Example #4
Source File: madry_mnist_model.py From neural-fingerprinting with BSD 3-Clause "New" or "Revised" License | 6 votes |
def fprop(self, x): output = OrderedDict() # first convolutional layer h_conv1 = tf.nn.relu(self._conv2d(x, self.W_conv1) + self.b_conv1) h_pool1 = self._max_pool_2x2(h_conv1) # second convolutional layer h_conv2 = tf.nn.relu( self._conv2d(h_pool1, self.W_conv2) + self.b_conv2) h_pool2 = self._max_pool_2x2(h_conv2) # first fully connected layer h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64]) h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, self.W_fc1) + self.b_fc1) # output layer logits = tf.matmul(h_fc1, self.W_fc2) + self.b_fc2 output = deterministic_dict(locals()) del output["self"] output[self.O_PROBS] = tf.nn.softmax(logits=logits) return output
Example #5
Source File: mnist_histogram.py From deep-learning-note with MIT License | 6 votes |
def nn_layer(input_tensor, input_dim, output_dim, layer_name, act=tf.nn.relu): # 同一层神经网络放在一个统一的命名空间下 with tf.name_scope(layer_name): with tf.name_scope('weights'): # 权重及监控变量 weights = tf.Variable(tf.truncated_normal([input_dim, output_dim], stddev=0.1)) variable_summaries(weights, layer_name+'/weights') with tf.name_scope('biases'): # 偏置及监控变量 biases = tf.Variable(tf.constant(0.0, shape=[output_dim])) variable_summaries(biases, layer_name + '/biases') with tf.name_scope('Wx_plus_b'): preactivate = tf.matmul(input_tensor, weights) + biases # 记录神经网络输出节点在经过激活函数之前的分布 tf.summary.histogram(layer_name + '/pre_activations', preactivate) activations = act(preactivate, name='activation') # 记录神经网络输出节点在经过激活函数之后的分布 tf.summary.histogram(layer_name + '/activations', activations) return activations
Example #6
Source File: 2_tf_linear.py From deep-learning-note with MIT License | 6 votes |
def createLinearModel(dimension): np.random.seed(1024) # 定义 x 和 y x = tf.placeholder(tf.float64, shape=[None, dimension], name='x') # 写成矩阵形式会大大加快运算速度 y = tf.placeholder(tf.float64, shape=[None, 1], name='y') # 定义参数估计值和预测值 betaPred = tf.Variable(np.random.random([dimension, 1])) yPred = tf.matmul(x, betaPred, name='y_pred') # 定义损失函数 loss = tf.reduce_mean(tf.square(yPred - y)) model = { 'loss_function': loss, 'independent_variable': x, 'dependent_variable': y, 'prediction': yPred, 'model_params': betaPred } return model
Example #7
Source File: gru_cell.py From DOTA_models with Apache License 2.0 | 6 votes |
def __call__(self, inputs, state, scope=None): """GRU cell with layer normalization.""" input_dim = inputs.get_shape().as_list()[1] num_units = self._num_units with tf.variable_scope(scope or "gru_cell"): with tf.variable_scope("gates"): w_h = tf.get_variable( "w_h", [num_units, 2 * num_units], initializer=self._w_h_initializer()) w_x = tf.get_variable( "w_x", [input_dim, 2 * num_units], initializer=self._w_x_initializer(input_dim)) z_and_r = (_layer_norm(tf.matmul(state, w_h), scope="layer_norm/w_h") + _layer_norm(tf.matmul(inputs, w_x), scope="layer_norm/w_x")) z, r = tf.split(tf.sigmoid(z_and_r), 2, 1) with tf.variable_scope("candidate"): w = tf.get_variable( "w", [input_dim, num_units], initializer=self._w_initializer) u = tf.get_variable( "u", [num_units, num_units], initializer=self._u_initializer) h_hat = (r * _layer_norm(tf.matmul(state, u), scope="layer_norm/u") + _layer_norm(tf.matmul(inputs, w), scope="layer_norm/w")) new_h = (1 - z) * state + z * self._activation(h_hat) return new_h, new_h
Example #8
Source File: vision_baseline_lstm.py From DOTA_models with Apache License 2.0 | 6 votes |
def combine_setup(name, combine_type, embed_img, embed_goal, num_img_neuorons=None, num_goal_neurons=None): with tf.name_scope(name + '_' + combine_type): if combine_type == 'add': # Simple concat features from goal and image out = embed_img + embed_goal elif combine_type == 'multiply': # Multiply things together re_embed_img = tf.reshape( embed_img, shape=[-1, num_img_neuorons / num_goal_neurons, num_goal_neurons]) re_embed_goal = tf.reshape(embed_goal, shape=[-1, num_goal_neurons, 1]) x = tf.matmul(re_embed_img, re_embed_goal, transpose_a=False, transpose_b=False) out = slim.flatten(x) elif combine_type == 'none' or combine_type == 'imgonly': out = embed_img elif combine_type == 'goalonly': out = embed_goal else: logging.fatal('Undefined combine_type: %s', combine_type) return out
Example #9
Source File: network_units.py From DOTA_models with Apache License 2.0 | 6 votes |
def pass_through_embedding_matrix(act_block, embedding_matrix, step_idx): """Passes the activations through the embedding_matrix. Takes care to handle out of bounds lookups. Args: act_block: matrix of activations. embedding_matrix: matrix of weights. step_idx: vector containing step indices, with -1 indicating out of bounds. Returns: the embedded activations. """ # Indicator vector for out of bounds lookups. step_idx_mask = tf.expand_dims(tf.equal(step_idx, -1), -1) # Pad the last column of the activation vectors with the indicator. act_block = tf.concat([act_block, tf.to_float(step_idx_mask)], 1) return tf.matmul(act_block, embedding_matrix)
Example #10
Source File: policy.py From DOTA_models with Apache License 2.0 | 6 votes |
def get_cell(self): self.cell_input_dim = self.internal_dim def mlp(cell_input, prev_internal_state): w1 = tf.get_variable('w1', [self.cell_input_dim, self.internal_dim]) b1 = tf.get_variable('b1', [self.internal_dim]) w2 = tf.get_variable('w2', [self.internal_dim, self.internal_dim]) b2 = tf.get_variable('b2', [self.internal_dim]) w3 = tf.get_variable('w3', [self.internal_dim, self.internal_dim]) b3 = tf.get_variable('b3', [self.internal_dim]) proj = tf.get_variable( 'proj', [self.internal_dim, self.output_dim]) hidden = cell_input hidden = tf.tanh(tf.nn.bias_add(tf.matmul(hidden, w1), b1)) hidden = tf.tanh(tf.nn.bias_add(tf.matmul(hidden, w2), b2)) output = tf.matmul(hidden, proj) return output, hidden return mlp
Example #11
Source File: utils.py From DOTA_models with Apache License 2.0 | 6 votes |
def gaussian_kernel_matrix(x, y, sigmas): r"""Computes a Guassian Radial Basis Kernel between the samples of x and y. We create a sum of multiple gaussian kernels each having a width sigma_i. Args: x: a tensor of shape [num_samples, num_features] y: a tensor of shape [num_samples, num_features] sigmas: a tensor of floats which denote the widths of each of the gaussians in the kernel. Returns: A tensor of shape [num_samples{x}, num_samples{y}] with the RBF kernel. """ beta = 1. / (2. * (tf.expand_dims(sigmas, 1))) dist = compute_pairwise_distances(x, y) s = tf.matmul(beta, tf.reshape(dist, (1, -1))) return tf.reshape(tf.reduce_sum(tf.exp(-s), 0), tf.shape(dist))
Example #12
Source File: ops.py From tensorflow-alexnet with MIT License | 6 votes |
def fc(inputs, output_size, init_bias=0.0, activation_func=tf.nn.relu, stddev=0.01): input_shape = inputs.get_shape().as_list() if len(input_shape) == 4: fc_weights = tf.Variable( tf.random_normal([input_shape[1] * input_shape[2] * input_shape[3], output_size], dtype=tf.float32, stddev=stddev), name='weights') inputs = tf.reshape(inputs, [-1, fc_weights.get_shape().as_list()[0]]) else: fc_weights = tf.Variable(tf.random_normal([input_shape[-1], output_size], dtype=tf.float32, stddev=stddev), name='weights') fc_biases = tf.Variable(tf.constant(init_bias, shape=[output_size], dtype=tf.float32), name='biases') fc_layer = tf.matmul(inputs, fc_weights) fc_layer = tf.nn.bias_add(fc_layer, fc_biases) if activation_func: fc_layer = activation_func(fc_layer) return fc_layer
Example #13
Source File: transformer_nat.py From fine-lm with MIT License | 6 votes |
def vq_nearest_neighbor(x, hparams): """Find the nearest element in means to elements in x.""" bottleneck_size = 2**hparams.bottleneck_bits means = hparams.means x_norm_sq = tf.reduce_sum(tf.square(x), axis=-1, keepdims=True) means_norm_sq = tf.reduce_sum(tf.square(means), axis=-1, keepdims=True) scalar_prod = tf.matmul(x, means, transpose_b=True) dist = x_norm_sq + tf.transpose(means_norm_sq) - 2 * scalar_prod if hparams.bottleneck_kind == "em": x_means_idx = tf.multinomial(-dist, num_samples=hparams.num_samples) x_means_hot = tf.one_hot( x_means_idx, depth=bottleneck_size) x_means_hot = tf.reduce_mean(x_means_hot, axis=1) else: x_means_idx = tf.argmax(-dist, axis=-1) x_means_hot = tf.one_hot(x_means_idx, depth=bottleneck_size) x_means = tf.matmul(x_means_hot, means) e_loss = tf.reduce_mean(tf.square(x - tf.stop_gradient(x_means))) return x_means_hot, e_loss
Example #14
Source File: TensorFlowInterface.py From IntroToDeepLearning with MIT License | 5 votes |
def setupOutput(self): if len(self.input.get_shape()) > 2: input = tf.reshape(self.input,[-1,self.inputShape]) # flatten reduced image into a vector else: input = self.input self.output = tf.matmul(input,self.W)
Example #15
Source File: TensorFlowInterface.py From IntroToDeepLearning with MIT License | 5 votes |
def setupOutput(self): if len(self.input.get_shape()) > 2: input = tf.reshape(self.input,[-1,self.inputShape]) # flatten reduced image into a vector else: input = self.input self.output = tf.matmul(input,self.W)
Example #16
Source File: TensorFlowInterface.py From IntroToDeepLearning with MIT License | 5 votes |
def setupOutput(self): if len(self.input.get_shape()) > 2: input = tf.reshape(self.input,[-1,self.inputShape]) # flatten reduced image into a vector else: input = self.input self.output = tf.nn.relu(tf.matmul(input,self.W) + self.b)
Example #17
Source File: TensorFlowInterface.py From IntroToDeepLearning with MIT License | 5 votes |
def setupOutput(self): if len(self.input.get_shape()) > 2: input = tf.reshape(self.input,[-1,self.inputShape]) # flatten reduced image into a vector else: input = self.input self.output = tf.nn.softmax(tf.matmul(input,self.W) + self.b)
Example #18
Source File: utils.py From DOTA_models with Apache License 2.0 | 5 votes |
def linear(x, out_size, do_bias=True, alpha=1.0, identity_if_possible=False, normalized=False, name=None, collections=None): """Linear (affine) transformation, y = x W + b, for a variety of configurations. Args: x: input The tensor to tranformation. out_size: The integer size of non-batch output dimension. do_bias (optional): Add a learnable bias vector to the operation. alpha (optional): A multiplicative scaling for the weight initialization of the matrix, in the form \alpha * 1/\sqrt{x.shape[1]}. identity_if_possible (optional): just return identity, if x.shape[1] == out_size. normalized (optional): Option to divide out by the norms of the rows of W. name (optional): The name prefix to add to variables. collections (optional): List of additional collections. (Placed in tf.GraphKeys.GLOBAL_VARIABLES already, so no need for that.) Returns: In the equation, y = x W + b, returns the tensorflow op that yields y. """ in_size = int(x.get_shape()[1]) # from Dimension(10) -> 10 stddev = alpha/np.sqrt(float(in_size)) mat_init = tf.random_normal_initializer(0.0, stddev) wname = (name + "/W") if name else "/W" if identity_if_possible and in_size == out_size: # Sometimes linear layers are nothing more than size adapters. return tf.identity(x, name=(wname+'_ident')) W,b = init_linear(in_size, out_size, do_bias=do_bias, alpha=alpha, normalized=normalized, name=name, collections=collections) if do_bias: return tf.matmul(x, W) + b else: return tf.matmul(x, W)
Example #19
Source File: box_list_ops.py From DOTA_models with Apache License 2.0 | 5 votes |
def sq_dist(boxlist1, boxlist2, scope=None): """Computes the pairwise squared distances between box corners. This op treats each box as if it were a point in a 4d Euclidean space and computes pairwise squared distances. Mathematically, we are given two matrices of box coordinates X and Y, where X(i,:) is the i'th row of X, containing the 4 numbers defining the corners of the i'th box in boxlist1. Similarly Y(j,:) corresponds to boxlist2. We compute Z(i,j) = ||X(i,:) - Y(j,:)||^2 = ||X(i,:)||^2 + ||Y(j,:)||^2 - 2 X(i,:)' * Y(j,:), Args: boxlist1: BoxList holding N boxes boxlist2: BoxList holding M boxes scope: name scope. Returns: a tensor with shape [N, M] representing pairwise distances """ with tf.name_scope(scope, 'SqDist'): sqnorm1 = tf.reduce_sum(tf.square(boxlist1.get()), 1, keep_dims=True) sqnorm2 = tf.reduce_sum(tf.square(boxlist2.get()), 1, keep_dims=True) innerprod = tf.matmul(boxlist1.get(), boxlist2.get(), transpose_a=False, transpose_b=True) return sqnorm1 + tf.transpose(sqnorm2) - 2.0 * innerprod
Example #20
Source File: sequence.py From icme2019 with MIT License | 5 votes |
def call(self, inputs, mask=None, **kwargs): if self.supports_masking: if mask is None: raise ValueError( "When supports_masking=True,input must support masking") queries, keys = inputs key_masks = tf.expand_dims(mask[-1], axis=1) else: queries, keys, keys_length = inputs hist_len = keys.get_shape()[1] key_masks = tf.sequence_mask(keys_length, hist_len) attention_score = LocalActivationUnit( self.hidden_size, self.activation, 0, 1, False, 1024,)([queries, keys]) outputs = tf.transpose(attention_score, (0, 2, 1)) if self.weight_normalization: paddings = tf.ones_like(outputs) * (-2 ** 32 + 1) else: paddings = tf.zeros_like(outputs) outputs = tf.where(key_masks, outputs, paddings) if self.weight_normalization: outputs = tf.nn.softmax(outputs) outputs = tf.matmul(outputs, keys) return outputs
Example #21
Source File: utils.py From DOTA_models with Apache License 2.0 | 5 votes |
def BatchClipByL2norm(t, upper_bound, name=None): """Clip an array of tensors by L2 norm. Shrink each dimension-0 slice of tensor (for matrix it is each row) such that the l2 norm is at most upper_bound. Here we clip each row as it corresponds to each example in the batch. Args: t: the input tensor. upper_bound: the upperbound of the L2 norm. name: optional name. Returns: the clipped tensor. """ assert upper_bound > 0 with tf.name_scope(values=[t, upper_bound], name=name, default_name="batch_clip_by_l2norm") as name: saved_shape = tf.shape(t) batch_size = tf.slice(saved_shape, [0], [1]) t2 = tf.reshape(t, tf.concat(axis=0, values=[batch_size, [-1]])) upper_bound_inv = tf.fill(tf.slice(saved_shape, [0], [1]), tf.constant(1.0/upper_bound)) # Add a small number to avoid divide by 0 l2norm_inv = tf.rsqrt(tf.reduce_sum(t2 * t2, [1]) + 0.000001) scale = tf.minimum(l2norm_inv, upper_bound_inv) * upper_bound clipped_t = tf.matmul(tf.diag(scale), t2) clipped_t = tf.reshape(clipped_t, saved_shape, name=name) return clipped_t
Example #22
Source File: inception_score.py From ArtGAN with BSD 3-Clause "New" or "Revised" License | 5 votes |
def _init_inception(): global softmax if not os.path.exists(MODEL_DIR): os.makedirs(MODEL_DIR) filename = DATA_URL.split('/')[-1] filepath = os.path.join(MODEL_DIR, filename) if not os.path.exists(filepath): def _progress(count, block_size, total_size): sys.stdout.write('\r>> Downloading %s %.1f%%' % ( filename, float(count * block_size) / float(total_size) * 100.0)) sys.stdout.flush() filepath, _ = urllib.urlretrieve(DATA_URL, filepath, _progress) print() statinfo = os.stat(filepath) print('Succesfully downloaded', filename, statinfo.st_size, 'bytes.') tarfile.open(filepath, 'r:gz').extractall(MODEL_DIR) with tf.gfile.FastGFile(os.path.join( MODEL_DIR, 'classify_image_graph_def.pb'), 'rb') as f: graph_def = tf.GraphDef() graph_def.ParseFromString(f.read()) _ = tf.import_graph_def(graph_def, name='') # Works with an arbitrary minibatch size. with tf.Session() as sess: pool3 = sess.graph.get_tensor_by_name('pool_3:0') ops = pool3.graph.get_operations() for op_idx, op in enumerate(ops): for o in op.outputs: shape = o.get_shape() shape = [s.value for s in shape] new_shape = [] for j, s in enumerate(shape): if s == 1 and j == 0: new_shape.append(None) else: new_shape.append(s) o._shape = tf.TensorShape(new_shape) w = sess.graph.get_operation_by_name("softmax/logits/MatMul").inputs[1] logits = tf.matmul(tf.squeeze(pool3), w) softmax = tf.nn.softmax(logits)
Example #23
Source File: layers.py From ArtGAN with BSD 3-Clause "New" or "Revised" License | 5 votes |
def linear(x, nout, std=0.02, use_b=False, init_b=0.0, name='linear'): with tf.variable_scope(name): W = tf.get_variable('W', [x.get_shape()[-1], nout], initializer=tf.random_normal_initializer(stddev=std)) lout = tf.matmul(x, W) if use_b: b = tf.get_variable('b', [nout], initializer=tf.constant_initializer(init_b)) lout = tf.nn.bias_add(lout, b) print lout.name + ': ' + str(lout.get_shape().as_list()) return lout
Example #24
Source File: layers.py From ArtGAN with BSD 3-Clause "New" or "Revised" License | 5 votes |
def pullaway_loss(embeddings): """ Pull Away loss calculation :param embeddings: The embeddings to be orthogonalized for varied faces. Shape [batch_size, embeddings_dim] :return: pull away term loss """ norm = tf.sqrt(tf.reduce_sum(tf.square(embeddings), 1, keep_dims=True)) normalized_embeddings = embeddings / norm similarity = tf.matmul( normalized_embeddings, normalized_embeddings, transpose_b=True) similarity -= tf.diag(tf.diag_part(similarity)) batch_size = tf.cast(tf.shape(embeddings)[0], tf.float32) pt_loss = tf.reduce_sum(similarity) / (batch_size * (batch_size - 1)) return pt_loss
Example #25
Source File: network_units.py From DOTA_models with Apache License 2.0 | 5 votes |
def attention(self, last_layer, attention_tensor): """Compute the attention term for the network unit.""" h_tensor = attention_tensor # Compute the attentions. # Using feed-forward net to map the two inputs into the same dimension focus_tensor = tf.nn.tanh( tf.matmul( h_tensor, self._component.get_variable('attention_weights_pm_0'), name='h_x_pm') + self._component.get_variable('attention_bias_0')) context_tensor = tf.nn.tanh( tf.matmul( last_layer, self._component.get_variable('attention_weights_hm_0'), name='l_x_hm') + self._component.get_variable('attention_bias_1')) # The tf.multiply in the following expression broadcasts along the 0 dim: z_vec = tf.reduce_sum(tf.multiply(focus_tensor, context_tensor), 1) p_vec = tf.nn.softmax(tf.reshape(z_vec, [1, -1])) # The tf.multiply in the following expression broadcasts along the 1 dim: r_vec = tf.expand_dims( tf.reduce_sum( tf.multiply( h_tensor, tf.reshape(p_vec, [-1, 1]), name='time_together2'), 0), 0) return tf.matmul( r_vec, self._component.get_variable('attention_weights_pu'), name='time_together3')
Example #26
Source File: interaction.py From icme2019 with MIT License | 5 votes |
def call(self, inputs, **kwargs): if K.ndim(inputs) != 3: raise ValueError( "Unexpected inputs dimensions %d, expect to be 3 dimensions" % (K.ndim(inputs))) querys = tf.tensordot(inputs, self.W_Query, axes=(-1, 0)) # None F D*head_num keys = tf.tensordot(inputs, self.W_key, axes=(-1, 0)) values = tf.tensordot(inputs, self.W_Value, axes=(-1, 0)) # head_num None F D querys = tf.stack(tf.split(querys, self.head_num, axis=2)) keys = tf.stack(tf.split(keys, self.head_num, axis=2)) values = tf.stack(tf.split(values, self.head_num, axis=2)) inner_product = tf.matmul( querys, keys, transpose_b=True) # head_num None F F self.normalized_att_scores = tf.nn.softmax(inner_product) result = tf.matmul(self.normalized_att_scores, values) # head_num None F D result = tf.concat(tf.split(result, self.head_num, ), axis=-1) result = tf.squeeze(result, axis=0) # None F D*head_num if self.use_res: result += tf.tensordot(inputs, self.W_Res, axes=(-1, 0)) result = tf.nn.relu(result) return result
Example #27
Source File: networks.py From disentangling_conditional_gans with MIT License | 5 votes |
def dense(x, fmaps, gain=np.sqrt(2), use_wscale=False): if len(x.shape) > 2: x = tf.reshape(x, [-1, np.prod([d.value for d in x.shape[1:]])]) w = get_weight([x.shape[1].value, fmaps], gain=gain, use_wscale=use_wscale) w = tf.cast(w, x.dtype) return tf.matmul(x, w) #---------------------------------------------------------------------------- # Convolutional layer.
Example #28
Source File: tf_logits.py From Black-Box-Audio with MIT License | 5 votes |
def compute_mfcc(audio, **kwargs): """ Compute the MFCC for a given audio waveform. This is identical to how DeepSpeech does it, but does it all in TensorFlow so that we can differentiate through it. """ batch_size, size = audio.get_shape().as_list() audio = tf.cast(audio, tf.float32) # 1. Pre-emphasizer, a high-pass filter audio = tf.concat((audio[:, :1], audio[:, 1:] - 0.97*audio[:, :-1], np.zeros((batch_size,1000),dtype=np.float32)), 1) # 2. windowing into frames of 320 samples, overlapping windowed = tf.stack([audio[:, i:i+400] for i in range(0,size-320,160)],1) # 3. Take the FFT to convert to frequency space ffted = tf.spectral.rfft(windowed, [512]) ffted = 1.0 / 512 * tf.square(tf.abs(ffted)) # 4. Compute the Mel windowing of the FFT energy = tf.reduce_sum(ffted,axis=2)+1e-30 filters = np.load("filterbanks.npy").T feat = tf.matmul(ffted, np.array([filters]*batch_size,dtype=np.float32))+1e-30 # 5. Take the DCT again, because why not feat = tf.log(feat) feat = tf.spectral.dct(feat, type=2, norm='ortho')[:,:,:26] # 6. Amplify high frequencies for some reason _,nframes,ncoeff = feat.get_shape().as_list() n = np.arange(ncoeff) lift = 1 + (22/2.)*np.sin(np.pi*n/22) feat = lift*feat width = feat.get_shape().as_list()[1] # 7. And now stick the energy next to the features feat = tf.concat((tf.reshape(tf.log(energy),(-1,width,1)), feat[:, :, 1:]), axis=2) return feat
Example #29
Source File: memory.py From DOTA_models with Apache License 2.0 | 5 votes |
def __init__(self, key_dim, memory_size, vocab_size, choose_k=256, alpha=0.1, correct_in_top=1, age_noise=8.0, var_cache_device='', nn_device=''): self.key_dim = key_dim self.memory_size = memory_size self.vocab_size = vocab_size self.choose_k = min(choose_k, memory_size) self.alpha = alpha self.correct_in_top = correct_in_top self.age_noise = age_noise self.var_cache_device = var_cache_device # Variables are cached here. self.nn_device = nn_device # Device to perform nearest neighbour matmul. caching_device = var_cache_device if var_cache_device else None self.update_memory = tf.constant(True) # Can be fed "false" if needed. self.mem_keys = tf.get_variable( 'memkeys', [self.memory_size, self.key_dim], trainable=False, initializer=tf.random_uniform_initializer(-0.0, 0.0), caching_device=caching_device) self.mem_vals = tf.get_variable( 'memvals', [self.memory_size], dtype=tf.int32, trainable=False, initializer=tf.constant_initializer(0, tf.int32), caching_device=caching_device) self.mem_age = tf.get_variable( 'memage', [self.memory_size], dtype=tf.float32, trainable=False, initializer=tf.constant_initializer(0.0), caching_device=caching_device) self.recent_idx = tf.get_variable( 'recent_idx', [self.vocab_size], dtype=tf.int32, trainable=False, initializer=tf.constant_initializer(0, tf.int32)) # variable for projecting query vector into memory key self.query_proj = tf.get_variable( 'memory_query_proj', [self.key_dim, self.key_dim], dtype=tf.float32, initializer=tf.truncated_normal_initializer(0, 0.01), caching_device=caching_device)
Example #30
Source File: blocks_std.py From DOTA_models with Apache License 2.0 | 5 votes |
def _Apply(self, x): if not self._matrix: shape = [int(x.get_shape()[-1]), self._depth] self._matrix = self._CreateKernel(shape, x.dtype) return tf.matmul(x, self._matrix)