def add_gcnLayer(adj,features,in_size,out_size,activation_function=None,adj_sparse = True,features_sparse = False): if adj_sparse: print('adj sparse') adj_ordered = tf.sparse_reorder(adj) adj = tf.sparse.to_dense(adj_ordered) if features_sparse: print('features sparse') features_ordered = tf.sparse_reorder(features) features = tf.sparse.to_dense(features_ordered) print(adj) print(features) with tf.name_scope('GraphConvLayer'): with tf.name_scope('GraphConvLayer_W'): Weights = tf.Variable(tf.truncated_normal(shape=[in_size, out_size], mean=0.1, stddev=0.1)) with tf.name_scope('GraphConvLayer_B'): biases = tf.Variable(tf.zeros(shape=[1,out_size])+0.01) with tf.name_scope('GraphConvLayer_propagate'): adjFeatures = tf.matmul(adj,features) with tf.name_scope('GraphConvLayer_conv'): Wx_plus_b = tf.matmul(adjFeatures,Weights) + biases if activation_function is None: outputs = Wx_plus_b else: outputs = activation_function(Wx_plus_b) return outputs
def build_feat(self): placeholders = self.placeholders self.plhd_inputs = [ placeholders['features'], placeholders['support'], placeholders['graph_sizes'] ] try: self.plhd_inputs[0] = tf.sparse.reorder(self.plhd_inputs[0]) self.plhd_inputs[1] = tf.sparse.reorder(self.plhd_inputs[1]) except AttributeError: self.plhd_inputs[0] = tf.sparse_reorder(self.plhd_inputs[0]) self.plhd_inputs[1] = tf.sparse_reorder(self.plhd_inputs[1]) self.plhd_activations = [] self.plhd_activations.append(self.plhd_inputs) self.plhd_graph_embs = [] # conv layers for conv_layer, pool_layer in zip(self.layers[0], self.layers[1]): hidden = conv_layer(self.plhd_activations[-1]) graph_emb = pool_layer(hidden) self.plhd_graph_embs.append(graph_emb[0]) self.plhd_activations.append(hidden) final_graph_emb = tf.concat(self.plhd_graph_embs, axis=1) self.plhd_activations.append([final_graph_emb, hidden[1], hidden[2]]) self.plhd_feat = self.plhd_activations[-1][0]
def calculate_features_wrap(self,indices): pyOutput = tf.py_func(self.calculate_features, [indices], [tf.float32, tf.int64, tf.float32, tf.int64] +\ [tf.int64]*len(self.poolRatios)+[tf.float32]*len(self.poolRatios)+\ [tf.int64]*len(self.poolRatios)) pyOutput[0].set_shape((self.N,self.C)) pyOutput[0] = tf.reshape(pyOutput[0], [self.N, self.C]) V = pyOutput[0] A = tf.sparse_reorder(tf.SparseTensor(pyOutput[1],pyOutput[2],[self.N, self.L, self.N])) if not self.sparse: A = tf.sparse_tensor_to_dense(A) pyOutput[3] = tf.one_hot(pyOutput[3],(self.numClasses)) pyOutput[3].set_shape([self.numClasses]) label = pyOutput[3] Pouts = pyOutput[4:] NUM_POOLS = len(self.poolRatios) Pidxlist = Pouts[0:NUM_POOLS] Pvallist = Pouts[NUM_POOLS:(2*NUM_POOLS)] #Pshapelist = Pouts[2*NUM_POOLS:(3*NUM_POOLS)] Plist = [] prevSize = self.N for pidx in range(NUM_POOLS): currentSize = np.floor(prevSize * self.poolRatios[pidx]).astype(np.int64) currentPSparse = tf.sparse_reorder(tf.SparseTensor(Pidxlist[pidx],Pvallist[pidx],[1,prevSize,currentSize])) #currentPSparse.set_shape([1,prevSize,currentSize]) if not self.sparse: currentPDense = tf.squeeze(tf.sparse_tensor_to_dense(currentPSparse)) currentPDense.set_shape([prevSize,currentSize]) Plist.append(currentPDense) else: Plist.append(currentPSparse) prevSize = currentSize return [V,A,label] + Plist
def transformation_tensor(self, splat_vector_tensor, weight_vector_tensor, blur_vector_tensor, n_lattice_tensor, d, n): """ Construct the transformation tensors of Gauss filtering using sparse tensor :param splat_vector_tensor: :param weight_vector_tensor: :param blur_vector_tensor: :param n_lattice_tensor: :return: """ # first construct the indices of splat matrix from splat_vector_tensor ind_tmp = np.repeat(np.arange(n), (d + 1)) ind_splat = tf.stack( [splat_vector_tensor, tf.constant(ind_tmp, dtype=tf.int64)], axis=1) splat_shape = tf.stack( [n_lattice_tensor + 1, tf.constant(n, dtype=tf.int64)]) splat_sparse_matrix = tf.sparse_reorder( tf.SparseTensor(indices=ind_splat, values=weight_vector_tensor, dense_shape=splat_shape)) # construct the list of blur matrices blur_vector_tensor_reshape = tf.reshape(blur_vector_tensor, (-1, 3)) blur_vector_tensor_split = tf.split(blur_vector_tensor_reshape, d + 1) blur_list = [] # calculate the blur weight shape_tmp = tf.stack([n_lattice_tensor, 1], axis=0) ones_tmp = tf.ones(shape=tf.to_int32(shape_tmp), dtype=tf.float32) blur_weight = tf.matmul( ones_tmp, tf.constant([[0.5, 0.25, 0.25]], shape=[1, 3], dtype=tf.float32)) blur_weight = tf.reshape(blur_weight, shape=[-1]) for i in range(d + 1): blur_vector_tensor_dim = blur_vector_tensor_split[i] ind_dim_tmp = tf.slice(blur_vector_tensor_dim, begin=[0, 0], size=[-1, 1]) ind_dim_tmp_tile = tf.tile(ind_dim_tmp, [1, 3]) ind_blur_dim = tf.stack([ tf.reshape(ind_dim_tmp_tile, [-1]), tf.reshape(blur_vector_tensor_dim, [-1]) ], axis=1) #tmp = tf.stack([n_lattice_tensor]) #blur_weight = tf.tile(tf.constant([0.5, 0.25, 0.25]), tmp) blur_shape = tf.stack([n_lattice_tensor + 1, n_lattice_tensor + 1]) blur_list.append( tf.sparse_reorder( tf.SparseTensor(indices=ind_blur_dim, values=blur_weight, dense_shape=blur_shape))) return splat_sparse_matrix, blur_list
def eval_iterator_generator(features, labels=None, test_ids=None, batch_size=2048): """An input function for evaluation or prediction""" if labels is not None: # No labels, use only features. inputs = (tf.cast(tf.sparse_reorder( convert_sparse_matrix_to_sparse_tensor(features)), dtype=tf.float32), tf.cast(tf.reshape(tf.convert_to_tensor(labels), shape=[-1, 1]), dtype=tf.float32)) else: inputs = (tf.reshape(tf.convert_to_tensor(test_ids), shape=[-1, 1]), tf.cast(tf.sparse_reorder( convert_sparse_matrix_to_sparse_tensor(features)), dtype=tf.float32)) # Convert the inputs to a Dataset. dataset = tf.data.Dataset.from_tensor_slices(inputs) # Batch the examples assert batch_size is not None, "batch_size must not be None" dataset = dataset.batch(batch_size) # Return the read end of the pipeline. return dataset.make_initializable_iterator()
def make_sparse_max_graph_pooling_layer(V, A, P, name=None): with tf.variable_scope(name, default_name='Graph-Max-Pooling') as scope: #Generate shape array for BN #oldVShapeNonTensor = V.get_shape() #Generate shape tensor for vertex pooling function I know hacky af oldVShape = tf.shape(V, out_type=tf.int64) newVShape = tf.stack([oldVShape[0], P.dense_shape[3], oldVShape[2]]) Ptranspose = tf.sparse_transpose(P, perm=[0, 1, 3, 2]) Vout = _graphcnn_max_vertex_pool_sparse_module.sparse_max_vertex_pool( V, Ptranspose.indices, Ptranspose.values, newVShape) Vout.set_shape([V.get_shape()[0].value,\ P.get_shape()[3].value,\ V.get_shape()[2].value]) #Change indices to pooled mapping print(P.indices[:, 3].get_shape()) Pcols = P.indices[:, 3] newRowidx = tf.gather(Pcols, A.indices[:, 1]) newColidx = tf.gather(Pcols, A.indices[:, 3]) newIndices = tf.stack( (A.indices[:, 0], newRowidx, A.indices[:, 2], newColidx), axis=1) newShape = tf.stack((A.dense_shape[0], P.dense_shape[3], A.dense_shape[2], P.dense_shape[3]), axis=0) Adupe = tf.sparse_reorder( tf.SparseTensor(newIndices, A.values, newShape)) #Segment sum to merge duplicate indices #Worried about this casting, but matmul doesn't support int64 for some dumb reason linearized = tf.cast( tf.matmul( tf.cast(Adupe.indices, tf.float64), tf.cast([[newShape[1] * newShape[2] * newShape[3]], [newShape[2] * newShape[3]], [newShape[3]], [1]], tf.float64)), tf.int64) print(linearized.get_shape()) y, idx = tf.unique(tf.squeeze(linearized)) # Use the positions of the unique values as the segment ids to # get the unique values print(idx.get_shape()) print(Adupe.values.get_shape()) values = tf.segment_sum(Adupe.values, idx) delinearized = tf.stack( (y // (newShape[1] * newShape[2] * newShape[3]), y // (newShape[2] * newShape[3]) % newShape[1], y // newShape[3] % newShape[2], y % newShape[3]), axis=1) Aout = tf.sparse_reorder( tf.SparseTensor(delinearized, values, newShape)) return Vout, Aout
def construct_input(data): features = tf.SparseTensor(data[0], data[1], data[2]) laplacians = tf.SparseTensor(data[3], data[4], data[5]) try: features = tf.sparse.reorder(features) laplacians = tf.sparse.reorder(laplacians) except AttributeError: features = tf.sparse_reorder(features) laplacians = tf.sparse_reorder(laplacians) return features, laplacians, data[6], data[7], data[8]
def main(unused_argv): tf.logging.info("{} Flags {}".format('*' * 15, '*' * 15)) for k, v in FLAGS.flag_values_dict().items(): tf.logging.info("FLAG `{}`: {}".format(k, v)) tf.logging.info('*' * (2 * 15 + len(' Flags '))) np.random.seed(FLAGS.seed) tf.set_random_seed(FLAGS.seed) rgat_layer = RGAT(units=FLAGS.units, relations=FLAGS.relations) features, supports = get_batch_of_features_supports_values() # Route 1: Run RGAT on each element in the batch separately and combine the # results individual_supports = [ graph_utils.relational_supports_to_support(d) for d in supports ] individual_supports = [ graph_utils.triple_from_coo(s) for s in individual_supports ] individual_supports = [ tf.SparseTensor(i, v, ds) for i, v, ds in individual_supports ] individual_supports = [tf.sparse_reorder(s) for s in individual_supports] individual_results = [ rgat_layer(inputs=f, support=s) for f, s in zip(features, individual_supports) ] individual_results = tf.concat(individual_results, axis=0) # Route 2: First combine the batch into a single graph and pass everything # through in one go combined_features = tf.concat(features, axis=0) combined_supports = graph_utils.batch_of_relational_supports_to_support( supports) combined_supports = graph_utils.triple_from_coo(combined_supports) combined_supports = tf.SparseTensor(*combined_supports) combined_supports = tf.sparse_reorder(combined_supports) combined_results = rgat_layer(inputs=combined_features, support=combined_supports) if np.allclose(combined_results, individual_results): tf.logging.info("The approaches match!") else: raise ValueError( "Doing each element in a batch independently does not produce the " "same results as doing all the batch in one go. Something has " "clearly broken. Please contact the author ASAP :).")
def batch_laplacian(v, f, return_sparse=True): # v: B x N x 3 # f: M x 3 num_b = tf.shape(v)[0] num_v = tf.shape(v)[1] num_f = tf.shape(f)[0] v_a = f[:, 0] v_b = f[:, 1] v_c = f[:, 2] a = tf.gather(v, v_a, axis=1) b = tf.gather(v, v_b, axis=1) c = tf.gather(v, v_c, axis=1) ab = a - b bc = b - c ca = c - a cot_a = -1 * tf.reduce_sum(ab * ca, axis=2) / tf.sqrt(tf.reduce_sum(tf.cross(ab, ca) ** 2, axis=-1)) cot_b = -1 * tf.reduce_sum(bc * ab, axis=2) / tf.sqrt(tf.reduce_sum(tf.cross(bc, ab) ** 2, axis=-1)) cot_c = -1 * tf.reduce_sum(ca * bc, axis=2) / tf.sqrt(tf.reduce_sum(tf.cross(ca, bc) ** 2, axis=-1)) I = tf.tile(tf.expand_dims(tf.concat((v_a, v_c, v_a, v_b, v_b, v_c), axis=0), 0), (num_b, 1)) J = tf.tile(tf.expand_dims(tf.concat((v_c, v_a, v_b, v_a, v_c, v_b), axis=0), 0), (num_b, 1)) W = 0.5 * tf.concat((cot_b, cot_b, cot_c, cot_c, cot_a, cot_a), axis=1) batch_dim = tf.tile(tf.expand_dims(tf.range(num_b), 1), (1, num_f * 6)) indices = tf.reshape(tf.stack((batch_dim, J, I), axis=2), (num_b, 6, -1, 3)) W = tf.reshape(W, (num_b, 6, -1)) l_indices = [tf.cast(tf.reshape(indices[:, i], (-1, 3)), tf.int64) for i in range(6)] shape = tf.cast(tf.stack((num_b, num_v, num_v)), tf.int64) sp_L_raw = [tf.sparse_reorder(tf.SparseTensor(l_indices[i], tf.reshape(W[:, i], (-1,)), shape)) for i in range(6)] L = sp_L_raw[0] for i in range(1, 6): L = tf.sparse_add(L, sp_L_raw[i]) dia_values = tf.sparse_reduce_sum(L, axis=-1) * -1 I = tf.tile(tf.expand_dims(tf.range(num_v), 0), (num_b, 1)) batch_dim = tf.tile(tf.expand_dims(tf.range(num_b), 1), (1, num_v)) indices = tf.reshape(tf.stack((batch_dim, I, I), axis=2), (-1, 3)) dia = tf.sparse_reorder(tf.SparseTensor(tf.cast(indices, tf.int64), tf.reshape(dia_values, (-1,)), shape)) return tf.sparse_add(L, dia)
def dense_to_sparse(value): """Convert a dense tensor to sparse tensor Args: value (Tensor): input dense Tensor Return: SparseTensor: converted sparse tensor Examples: >>> import tensorflow as tf >>> x = np.array([[1,0],[0,1]], dtype=np.float32) >>> y = dense_to_sparse(x) >>> y = tf.sparse.to_dense(y) >>> with tf.Session(): ... np.testing.assert_array_equal(y.eval(), x) """ x = tf.convert_to_tensor(value) x.shape.assert_has_rank(2) indices = tf.where(tf.not_equal(x, 0)) res = tf.SparseTensor(indices=indices, values=tf.gather_nd(x, indices), dense_shape=x.get_shape()) return tf.sparse_reorder(res)
def discriminator_dag_supervised(latent, dag, dag_bw, dag_feats, sequence_length, params, idx, weights_regularizer=None, is_training=True): # latent (N, L, D) with tf.variable_scope('discriminator'): h = tf.concat([latent, dag_feats], axis=-1) with tf.variable_scope("upward"): h = message_passing(latent=h, dag_bw=dag_bw, params=params, fully_connected_fn=sn_fully_connected, weights_regularizer=weights_regularizer, hidden_depth=params.discriminator_layers, dim=params.discriminator_dim) with tf.variable_scope("downward"): h = message_passing(latent=h, dag_bw=dag, params=params, fully_connected_fn=sn_fully_connected, weights_regularizer=weights_regularizer, hidden_depth=params.discriminator_layers, dim=params.discriminator_dim) with tf.variable_scope('output_mlp'): if params.lstm_output_discriminator: h, _ = lstm(x=h, num_units=params.decoder_dim, bidirectional=True, num_layers=params.decoder_layers, sequence_lengths=sequence_length) else: for i in range(params.discriminator_layers): h = sn_fully_connected( inputs=h, activation_fn=tf.nn.leaky_relu, weights_regularizer=weights_regularizer, num_outputs=params.discriminator_dim, scope='discriminator_output_{}'.format(i)) logits = sn_fully_connected( inputs=h, num_outputs=1, activation_fn=None, scope='discriminator_logits', weights_regularizer=weights_regularizer) # (N,L,1) logits = tf.squeeze(logits, axis=-1) # (N, L) logits_values = tf.gather_nd(params=logits, indices=idx) # (X,) sparse_logits = tf.SparseTensor(values=logits_values, indices=tf.cast(idx, tf.int64), dense_shape=tf.cast( tf.shape(logits), tf.int64)) sparse_logits = tf.sparse_reorder(sparse_logits) dis_values = tf.sparse_reduce_sum( sp_input=sparse_logits, axis=-1) / tf.cast( sequence_length, tf.float32) # (n,) return dis_values # (n,)
def to_matrix(sparse_indices, values, dense_shape): sparse_tensor = tf.sparse_reorder(tf.SparseTensor( indices=sparse_indices, values=tf.ones(sparse_indices.get_shape().as_list()[0]), #values=tf.reshape(values, [-1]), dense_shape=dense_shape)) return tf.sparse_tensor_to_dense(sparse_tensor)
def _extend_with_dummy(extend_with, to_extend, dummy_value='n/a'): """Extends one SparseTensor with dummy_values at positions of other.""" dense_shape = tf.to_int64( tf.concat( [[tf.shape(extend_with)[0]], [tf.maximum(tf.shape(extend_with)[1], tf.shape(to_extend)[1])], [tf.maximum(tf.shape(extend_with)[2], tf.shape(to_extend)[2])]], axis=0)) additional_indices = tf.sets.set_difference( tf.SparseTensor(indices=extend_with.indices, values=tf.zeros_like(extend_with.values, dtype=tf.int32), dense_shape=dense_shape), tf.SparseTensor(indices=to_extend.indices, values=tf.zeros([tf.shape(to_extend.indices)[0]], dtype=tf.int32), dense_shape=dense_shape)).indices # Supply defaults for all other indices. default = tf.tile(tf.constant([dummy_value]), multiples=[tf.shape(additional_indices)[0]]) string_value = (tf.as_string(to_extend.values) if to_extend.values.dtype != tf.string else to_extend.values) return tf.sparse_reorder( tf.SparseTensor(indices=tf.concat( [to_extend.indices, additional_indices], axis=0), values=tf.concat([string_value, default], axis=0), dense_shape=dense_shape))
def encode_sparse(self, color_channels): # sample down to output size a = zoom(color_channels[0], 1 / self.in_out_ratio) b = zoom(color_channels[1], 1 / self.in_out_ratio) color_channels = np.array([a, b]) height, width = a.shape[0], a.shape[1] dense_shape = (height, width, self.vec_size) indices, values = [], [] for y in range(height): for x in range(width): # get actual a,b values ab = np.array( [[color_channels[0][y, x], color_channels[1][y, x]]]) # find the 5 closest a,b values from the grid distances, ab_indices = self.nbrs.kneighbors(ab) vector = np.zeros((self.vec_size)) # find weights for each of the 5 closest points weights = [gaussian(d, 3) for d in distances[0]] sum_weights = sum(weights) indices += [[x, y, i] for i in ab_indices[0]] values += [w / sum_weights for w in weights] labels = tf.SparseTensor(indices=tf.constant(indices, dtype=tf.int64), values=tf.constant(values, dtype=self.dtype), dense_shape=tf.constant(dense_shape, dtype=tf.int64)) return tf.sparse_reorder(labels)
def chebyshev5(self, x, L, Fout, K): N, M, Fin = x.get_shape() N, M, Fin = int(N), int(M), int(Fin) # Rescale Laplacian and store as a TF sparse tensor. Copy to not modify the shared L. L = scipy.sparse.csr_matrix(L) L = graph.rescale_L(L, lmax=2) L = L.tocoo() indices = np.column_stack((L.row, L.col)) L = tf.SparseTensor(indices, L.data, L.shape) L = tf.sparse_reorder(L) # Transform to Chebyshev basis x0 = tf.transpose(x, perm=[1, 2, 0]) # M x Fin x N x0 = tf.reshape(x0, [M, Fin*N]) # M x Fin*N x = tf.expand_dims(x0, 0) # 1 x M x Fin*N def concat(x, x_): x_ = tf.expand_dims(x_, 0) # 1 x M x Fin*N return tf.concat([x, x_], axis=0) # filter_order x M x Fin*N if K > 1: x1 = tf.sparse_tensor_dense_matmul(L, x0) x = concat(x, x1) for k in range(2, K): x2 = 2 * tf.sparse_tensor_dense_matmul(L, x1) - x0 # M x Fin*N x = concat(x, x2) x0, x1 = x1, x2 x = tf.reshape(x, [K, M, Fin, N]) # filter_order x M x Fin x N x = tf.transpose(x, perm=[3,1,2,0]) # N x M x Fin x filter_order x = tf.reshape(x, [N*M, Fin*K]) # N*M x Fin*filter_order # Filter: Fin*Fout filters of order filter_order, i.e. one filterbank per feature pair. W = self._weight_variable([Fin*K, Fout], regularization=False) x = tf.matmul(x, W) # N*M x Fout return tf.reshape(x, [N, M, Fout]) # N x M x Fout
def get_bag_vectors(model): """ Represents snapshots as a bag of clinical observations. Specifically, returns a V-length binary vector such that the v-th index is 1 iff the v-th observation occurs in the given snapshot :param model: PRONTO model :type model: modeling.PRONTOModel :return: clinical snapshot encoding """ # 1. Evaluate which entries in model.observations are non-zero mask = tf.not_equal(model.observations, 0) where = tf.where(mask) # 2. Get the vocabulary indices for non-zero observations vocab_indices = tf.boolean_mask(model.observations, mask) vocab_indices = tf.expand_dims(vocab_indices[:], axis=-1) vocab_indices = tf.to_int64(vocab_indices) # 3. Get batch and sequence indices for non-zero observations tensor_indices = where[:, :-1] # Concat batch, sequence, and vocabulary indices indices = tf.concat([tensor_indices, vocab_indices], axis=-1) # Our sparse tensor will be 1 for observed observations, 0, otherwise ones = tf.ones_like(indices[:, 0], dtype=tf.float32) # The dense shape will be the same as model.observations, but using the entire vocabulary as the final dimension dense_shape = model.observations.get_shape().as_list() dense_shape[2] = model.vocabulary_size # Store as a sparse tensor because they're neat st = tf.SparseTensor(indices=indices, values=ones, dense_shape=dense_shape) return tf.sparse_reorder(st)
def unpooling_layer2x2(x, layer_name, raveled_argmax, out_shape): with tf.name_scope(layer_name): argmax = unravel_argmax(raveled_argmax, tf.to_int64(out_shape)) output = tf.zeros([out_shape[1], out_shape[2], out_shape[3]]) height = tf.shape(output)[0] width = tf.shape(output)[1] channels = tf.shape(output)[2] t1 = tf.to_int64(tf.range(channels)) t1 = tf.tile(t1, [((width + 1) // 2) * ((height + 1) // 2)]) t1 = tf.reshape(t1, [-1, channels]) t1 = tf.transpose(t1, perm=[1, 0]) t1 = tf.reshape(t1, [channels, (height + 1) // 2, (width + 1) // 2, 1]) t2 = tf.squeeze(argmax) t2 = tf.stack((t2[0], t2[1]), axis=0) t2 = tf.transpose(t2, perm=[3, 1, 2, 0]) t = tf.concat([t2, t1], 3) indices = tf.reshape(t, [((height + 1) // 2) * ((width + 1) // 2) * channels, 3]) x1 = tf.squeeze(x) x1 = tf.reshape(x1, [-1, channels]) x1 = tf.transpose(x1, perm=[1, 0]) values = tf.reshape(x1, [-1]) delta = tf.SparseTensor(indices, values, tf.to_int64(tf.shape(output))) return tf.expand_dims( tf.sparse_tensor_to_dense(tf.sparse_reorder(delta)), 0)
def unpool_layer2x2(self, x, argmax): x_shape = tf.shape(x) output = tf.zeros([x_shape[1] * 2, x_shape[2] * 2, x_shape[3]]) height = tf.shape(output)[0] width = tf.shape(output)[1] channels = tf.shape(output)[2] t1 = tf.to_int64(tf.range(channels)) t1 = tf.tile(t1, [(width // 2) * (height // 2)]) t1 = tf.reshape(t1, [-1, channels]) t1 = tf.transpose(t1, perm=[1, 0]) t1 = tf.reshape(t1, [channels, height // 2, width // 2, 1]) t2 = tf.squeeze(argmax) t2 = tf.pack((t2[0], t2[1]), axis=0) t2 = tf.transpose(t2, perm=[3, 1, 2, 0]) t = tf.concat(3, [t2, t1]) indices = tf.reshape(t, [(height // 2) * (width // 2) * channels, 3]) x1 = tf.squeeze(x) x1 = tf.reshape(x1, [-1, channels]) x1 = tf.transpose(x1, perm=[1, 0]) values = tf.reshape(x1, [-1]) delta = tf.SparseTensor(indices, values, tf.to_int64(tf.shape(output))) return tf.expand_dims( tf.sparse_tensor_to_dense(tf.sparse_reorder(delta)), 0)
def __init__(self, n_concepts, sparse_ancestors, sparse_ancestors_values): super(HierarchicalAggregate, self).__init__() self.n_concepts = n_concepts self.ancestry_sparse_tensor = tf.sparse_reorder( tf.SparseTensor(indices=sparse_ancestors, values=sparse_ancestors_values, dense_shape=[self.n_concepts, self.n_concepts]))
def _generate_sketch_matrix(rand_h, rand_s, output_dim): """ Return a sparse matrix used for tensor sketch operation in compact bilinear pooling Args: rand_h: an 1D numpy array containing indices in interval `[0, output_dim)`. rand_s: an 1D numpy array of 1 and -1, having the same shape as `rand_h`. output_dim: the output dimensions of compact bilinear pooling. Returns: a sparse matrix of shape [input_dim, output_dim] for tensor sketch. """ # Generate a sparse matrix for tensor count sketch rand_h = rand_h.astype(np.int64) rand_s = rand_s.astype(np.float32) assert(rand_h.ndim==1 and rand_s.ndim==1 and len(rand_h)==len(rand_s)) assert(np.all(rand_h >= 0) and np.all(rand_h < output_dim)) input_dim = len(rand_h) indices = np.concatenate((np.arange(input_dim)[..., np.newaxis], rand_h[..., np.newaxis]), axis=1) sparse_sketch_matrix = tf.sparse_reorder( tf.SparseTensor(indices, rand_s, [input_dim, output_dim])) return sparse_sketch_matrix
def chebyshev5(self, x, L, Fout, K_coeff): N, M, Fin = K.int_shape(x) # Rescale Laplacian and store as a TF sparse tensor. Copy to not modify the shared L. L = scipy.sparse.csr_matrix(L) L = self.rescale_L(L, lmax=2) L = L.tocoo() indices = np.column_stack((L.row, L.col)) L = tf.SparseTensor(indices, L.data, L.shape) L = tf.sparse_reorder(L) # Transform to Chebyshev basis x0 = tf.transpose(x, perm=[1, 2, 0]) # M x Fin x N x0 = tf.reshape(x0, [M, -1]) # M x Fin*N x = tf.expand_dims(x0, 0) # 1 x M x Fin*N def concat(x, x_): x_ = tf.expand_dims(x_, 0) # 1 x M x Fin*N return tf.concat([x, x_], axis=0) # K_coeff x M x Fin*N if K_coeff > 1: x1 = tf.sparse_tensor_dense_matmul(L, x0) x = concat(x, x1) for k in range(2, K_coeff): x2 = 2 * tf.sparse_tensor_dense_matmul(L, x1) - x0 # M x Fin*N x = concat(x, x2) x0, x1 = x1, x2 x = tf.reshape(x, [K_coeff, M, Fin, -1]) # K_coeff x M x Fin x N x = tf.transpose(x, perm=[3, 1, 2, 0]) # N x M x Fin x K_coeff x = tf.reshape(x, [-1, Fin * K_coeff]) # N*M x Fin*K_coeff # Filter: Fin*Fout filters of order K_coeff, i.e. one filterbank per feature pair. # W = self._weight_variable([Fin*K_coeff, Fout], regularization=False) x = tf.matmul(x, self.kernel) # N*M x Fout x = tf.reshape(x, [-1, M, Fout]) # N x M x Fout return x
def chebyshev5(self, x, L, Fout, K, regularization=False): N, M, Fin = x.get_shape() N, M, Fin = int(N), int(M), int(Fin) # Rescale Laplacian and store as a TF sparse tensor. Copy to not modify the shared L. L = scipy.sparse.csr_matrix(L) L = graph.rescale_L(L, lmax=2) L = L.tocoo() indices = np.column_stack((L.row, L.col)) L = tf.SparseTensor(indices, L.data, L.shape) L = tf.sparse_reorder(L) # Transform to Chebyshev basis x0 = tf.transpose(x, perm=[1, 2, 0]) # M x Fin x N x0 = tf.reshape(x0, [M, Fin*N]) # M x Fin*N x = tf.expand_dims(x0, 0) # 1 x M x Fin*N def concat(x, x_): x_ = tf.expand_dims(x_, 0) # 1 x M x Fin*N return tf.concat(0, [x, x_]) # K x M x Fin*N if K > 1: x1 = tf.sparse_tensor_dense_matmul(L, x0) x = concat(x, x1) for k in range(2, K): x2 = 2 * tf.sparse_tensor_dense_matmul(L, x1) - x0 # M x Fin*N x = concat(x, x2) x0, x1 = x1, x2 x = tf.reshape(x, [K, M, Fin, N]) # K x M x Fin x N x = tf.transpose(x, perm=[3,1,2,0]) # N x M x Fin x K x = tf.reshape(x, [N*M, Fin*K]) # N*M x Fin*K # Filter: Fin*Fout filters of order K, i.e. one filterbank per feature pair. W = self._weight_variable([Fin*K, Fout], regularization=regularization) x = tf.matmul(x, W) # N*M x Fout return tf.reshape(x, [N, M, Fout]) # N x M x Fout
def monomials(self, x, L, Fout, K): r"""Convolution on graph with monomials.""" N, M, Fin = x.get_shape() N, M, Fin = int(N), int(M), int(Fin) # Rescale Laplacian and store as a TF sparse tensor. Copy to not modify the shared L. L = sparse.csr_matrix(L) lmax = 1.02 * sparse.linalg.eigsh( L, k=1, which='LM', return_eigenvectors=False)[0] L = utils.rescale_L(L, lmax=lmax) L = L.tocoo() indices = np.column_stack((L.row, L.col)) L = tf.SparseTensor(indices, L.data, L.shape) L = tf.sparse_reorder(L) # Transform to monomial basis. x0 = tf.transpose(x, perm=[1, 2, 0]) # M x Fin x N x0 = tf.reshape(x0, [M, Fin * N]) # M x Fin*N x = tf.expand_dims(x0, 0) # 1 x M x Fin*N def concat(x, x_): x_ = tf.expand_dims(x_, 0) # 1 x M x Fin*N return tf.concat([x, x_], axis=0) # K x M x Fin*N for k in range(1, K): x1 = tf.sparse_tensor_dense_matmul(L, x0) # M x Fin*N x = concat(x, x1) x0 = x1 x = tf.reshape(x, [K, M, Fin, N]) # K x M x Fin x N x = tf.transpose(x, perm=[3, 1, 2, 0]) # N x M x Fin x K x = tf.reshape(x, [N * M, Fin * K]) # N*M x Fin*K # Filter: Fin*Fout filters of order K, i.e. one filterbank per output feature. W = self._weight_variable([Fin * K, Fout], regularization=True) x = tf.matmul(x, W) # N*M x Fout return tf.reshape(x, [N, M, Fout]) # N x M x Fout
def tok_k_masks(inputs, K): """Returns a mask for top_k op. Args: inputs: A `Tensor` K: A `int` Returns: A `Tensor` representing top_k mask """ values, indices = tf.nn.top_k(arr, k=K, sorted=False) temp_indices = tf.meshgrid(*[ tf.range(d) for d in (tf.unstack(tf.shape(arr)[:(arr.get_shape().ndims - 1)]) + [K]) ], indexing='ij') temp_indices = tf.stack(temp_indices[:-1] + [indices], axis=-1) full_indices = tf.reshape(temp_indices, [-1, arr.get_shape().ndims]) values = tf.reshape(values, [-1]) mask_st = tf.SparseTensor(indices=tf.cast(full_indices, dtype=tf.int64), values=tf.ones_like(values), dense_shape=arr.shape) return tf.sparse_tensor_to_dense(tf.sparse_reorder(mask_st))
def sparse_transpose(sp_input): transposed_indices = tf.reverse(tf.cast(sp_input.indices, tf.int32), [False, True]) transposed_values = sp_input.values transposed_shape = tf.reverse(tf.cast(sp_input.shape, tf.int32), [True]) sp_output = tf.SparseTensor(tf.cast(transposed_indices, tf.int64), transposed_values, tf.cast(transposed_shape, tf.int64)) sp_output = tf.sparse_reorder(sp_output) return sp_output
def get_multi_hop_neighbor(nodes, edge_types): """ Get multi-hop neighbors with adjacent matrix. Args: nodes: A 1-D `tf.Tensor` of `int64`. edge_types: A list of 1-D `tf.Tensor` of `int32`. Specify edge types to filter outgoing edges in each hop. Return: A tuple of list: (nodes, adjcents) nodes: A list of N + 1 `tf.Tensor` of `int64`, N is the number of hops. Specify node set of each hop, including the root. adjcents: A list of N `tf.SparseTensor` of `int64`. Specify adjacent matrix between hops. """ nodes = tf.reshape(nodes, [-1]) nodes_list = [nodes] adj_list = [] for hop_edge_types in edge_types: neighbor, weight, _ = get_full_neighbor(nodes, hop_edge_types) next_nodes, next_idx = tf.unique(neighbor.values, out_idx=tf.int64) next_indices = tf.stack([neighbor.indices[:, 0], next_idx], 1) next_values = weight.values next_shape = tf.stack([tf.size(nodes), tf.size(next_nodes)]) next_shape = tf.cast(next_shape, tf.int64) next_adj = tf.SparseTensor(next_indices, next_values, next_shape) next_adj = tf.sparse_reorder(next_adj) nodes_list.append(next_nodes) adj_list.append(next_adj) nodes = next_nodes return nodes_list, adj_list
def _do_test(self, expected_result, config=None): # Make sure that expected_result is an np array if not type(expected_result).__module__ == np.__name__: expected_result = np.array(expected_result) with tf.Graph().as_default(): inputs, indices, _ = dense_to_sparse(self.input) sparse_tensor_reordered = tf.sparse_reorder(inputs) sparse_tensor_reshaped = tf.sparse_reshape(sparse_tensor_reordered, self.input.shape) W = tf.constant(self.W1, dtype=tf.float32) b = tf.constant(self.b1, dtype=tf.float32) # Sparse layer logits = tf.sparse_tensor_dense_matmul(sparse_tensor_reshaped, W) + b # Dense layer logits = logits @ tf.constant(self.W2, tf.float32) + tf.constant(self.b2, tf.float32) explanation = lrp.lrp(inputs, logits, config) with tf.Session() as s: expl = s.run(explanation) self.assertTrue(np.all(np.equal(indices, expl.indices)), "expected indices did not equal actual indices") self.assertTrue(np.allclose(expl.values, expected_result.reshape((-1)), rtol=1.e-3, atol=1.e-3), "expected indices did not equal actual indices")
def chebyshev5(self, x, L, Fout, nK): L = L.astype(np.float32) _, M, Fin = x.get_shape().as_list() # Rescale Laplacian and store as a TF sparse tensor. Copy to not modify the shared L. L = scipy.sparse.csr_matrix(L) L = graph.rescale_L(L, lmax=2) L = L.tocoo() indices = np.column_stack((L.row, L.col)) L = tf.SparseTensor(indices, L.data, L.shape) L = tf.sparse_reorder(L) # Transform to Chebyshev basis x0 = tf.transpose(x, perm=[1, 2, 0]) # M x Fin x N x0 = tf.reshape(x0, [M, -1]) # M x Fin*N x = tf.expand_dims(x0, 0) # 1 x M x Fin*N def concat(x, x_): x_ = tf.expand_dims(x_, 0) # 1 x M x Fin*N return tf.concat([x, x_], axis=0) # K x M x Fin*N if nK > 1: x1 = tf.sparse_tensor_dense_matmul(L, x0) x = concat(x, x1) for k in range(2, nK): x2 = 2 * tf.sparse_tensor_dense_matmul(L, x1) - x0 # M x Fin*N x = concat(x, x2) x0, x1 = x1, x2 x = tf.reshape(x, [nK, M, Fin, -1]) # K x M x Fin x N x = tf.transpose(x, perm=[3, 1, 2, 0]) # N x M x Fin x K x = tf.reshape(x, [-1, Fin * nK]) # N*M x Fin*K # Filter: Fin*Fout filters of order K, i.e. one filterbank per feature pair. W = self._weight_variable x = tf.matmul(x, W) # N*M x Fout out = tf.reshape(x, [-1, M, Fout]) # N x M x Fout return out
def unpool_layer2x2_batch(self, bottom, argmax, top_shape): bottom_shape = tf.shape(bottom) batch_size = top_shape[0] height = top_shape[1] width = top_shape[2] channels = top_shape[3] argmax_shape = tf.to_int64([batch_size, height, width, channels]) argmax = self.unravel_argmax(argmax, argmax_shape) t1 = tf.to_int64(tf.range(channels)) t1 = tf.tile(t1, [batch_size*(width//1)*(height//height)]) t1 = tf.reshape(t1, [-1, channels]) t1 = tf.transpose(t1, perm=[1, 0]) t1 = tf.reshape(t1, [channels, batch_size, height//height, width//1, 1]) t1 = tf.transpose(t1, perm=[1, 0, 2, 3, 4]) t2 = tf.to_int64(tf.range(batch_size)) t2 = tf.tile(t2, [channels*(width//1)*(height//height)]) t2 = tf.reshape(t2, [-1, batch_size]) t2 = tf.transpose(t2, perm=[1, 0]) t2 = tf.reshape(t2, [batch_size, channels, height//height, width//1, 1]) t3 = tf.transpose(argmax, perm=[1, 4, 2, 3, 0]) t = tf.concat(4, [t2, t3, t1]) indices = tf.reshape(t, [(height//height)*(width//1)*channels*batch_size, 4]) x1 = tf.transpose(bottom, perm=[0, 3, 1, 2]) values = tf.reshape(x1, [-1]) delta = tf.SparseTensor(indices, values, tf.to_int64(top_shape)) return tf.sparse_add(tf.zeros(tf.to_int32(delta.shape)), tf.sparse_reorder(delta))
def unpool_layer2x2(self, x, raveled_argmax, out_shape): argmax = self.unravel_argmax(raveled_argmax, tf.to_int64(out_shape)) output = tf.zeros([out_shape[1], out_shape[2], out_shape[3]]) height = tf.shape(output)[0] width = tf.shape(output)[1] channels = tf.shape(output)[2] t1 = tf.to_int64(tf.range(channels)) t1 = tf.tile(t1, [((width + 1) // 2) * ((height + 1) // 2)]) t1 = tf.reshape(t1, [-1, channels]) t1 = tf.transpose(t1, perm=[1, 0]) t1 = tf.reshape(t1, [channels, (height + 1) // 2, (width + 1) // 2, 1]) t2 = tf.squeeze(argmax) t2 = tf.pack((t2[0], t2[1]), axis=0) t2 = tf.transpose(t2, perm=[3, 1, 2, 0]) t = tf.concat(3, [t2, t1]) indices = tf.reshape(t, [((height + 1) // 2) * ((width + 1) // 2) * channels, 3]) x1 = tf.squeeze(x) x1 = tf.reshape(x1, [-1, channels]) x1 = tf.transpose(x1, perm=[1, 0]) values = tf.reshape(x1, [-1]) delta = tf.SparseTensor(indices, values, tf.to_int64(tf.shape(output))) return tf.expand_dims(tf.sparse_tensor_to_dense(tf.sparse_reorder(delta)), 0)
def apply_neurosat(cfg, params, args): n_vars, n_lits, n_clauses = args.n_vars, 2 * args.n_vars, args.n_clauses CL = tf.sparse_reorder(tf.SparseTensor(indices=tf.cast(args.CL_idxs, tf.int64), values=tf.ones(tf.shape(args.CL_idxs)[0]), dense_shape=[tf.cast(n_clauses, tf.int64), tf.cast(n_lits, tf.int64)])) L = tf.ones(shape=[2 * n_vars, cfg['d']], dtype=tf.float32) * params.L_init_scale C = tf.ones(shape=[n_clauses, cfg['d']], dtype=tf.float32) * params.C_init_scale LC = tf.sparse_transpose(CL) def flip(lits): return tf.concat([lits[n_vars:, :], lits[0:n_vars, :]], axis=0) for t in range(cfg['n_rounds']): C_old, L_old = C, L LC_msgs = tf.sparse_tensor_dense_matmul(CL, L, adjoint_a=False) * params.LC_scale C = params.C_updates[t].forward(tf.concat([C, LC_msgs], axis=-1)) C = tf.check_numerics(C, message="C after update") C = tfutil.normalize(C, axis=cfg['norm_axis'], eps=cfg['norm_eps']) C = tf.check_numerics(C, message="C after norm") if cfg['res_layers']: C = C + C_old CL_msgs = tf.sparse_tensor_dense_matmul(LC, C, adjoint_a=False) * params.CL_scale L = params.L_updates[t].forward(tf.concat([L, CL_msgs, flip(L)], axis=-1)) L = tf.check_numerics(L, message="L after update") L = tfutil.normalize(L, axis=cfg['norm_axis'], eps=cfg['norm_eps']) L = tf.check_numerics(L, message="L after norm") if cfg['res_layers']: L = L + L_old V = tf.concat([L[0:n_vars, :], L[n_vars:, :]], axis=1) V_scores = params.V_score.forward(V) # (n_vars, 1) return NeuroSATGuesses(pi_core_var_logits=tf.squeeze(V_scores))
def _generate_sketch_matrix(rand_h, rand_s, output_dim): """ Return a sparse matrix used for tensor/count sketch operation, which is random feature projection from input_dim-->output_dim. Parameters ---------- rand_h: array, shape=(input_dim,) Vector containing indices in interval `[0, output_dim)`. rand_s: array, shape=(input_dim,) Vector containing values of 1 and -1. output_dim: int The dimensions of the count sketch vector representation. Returns ------- sparse_sketch_matrix : SparseTensor A sparse matrix of shape [input_dim, output_dim] for count sketch. """ # Generate a sparse matrix for tensor count sketch rand_h = rand_h.astype(np.int64) rand_s = rand_s.astype(np.float32) assert(rand_h.ndim==1 and rand_s.ndim==1 and len(rand_h)==len(rand_s)) assert(np.all(rand_h >= 0) and np.all(rand_h < output_dim)) input_dim = len(rand_h) indices = np.concatenate((np.arange(input_dim)[..., np.newaxis], rand_h[..., np.newaxis]), axis=1) sparse_sketch_matrix = tf.sparse_reorder( tf.SparseTensor(indices, rand_s, [input_dim, output_dim])) return sparse_sketch_matrix
def get_init_grad(self, name, num_topics, num_words, num_docs, alpha): U = tf.placeholder(dtype=tf.float32, shape=[num_words, num_topics], name="U-%s" % (name)) V = tf.placeholder(dtype=tf.float32, shape=[num_topics, num_docs], name="V-%s" % (name)) D = tf.sparse_reorder(self.D) VVT = tf.matmul(V, V, transpose_b=True) UTU = tf.matmul(U, U, transpose_a=True) DVT = self.D_mul_U(D, tf.transpose(V), num_topics) eye = tf.eye(num_topics, dtype=tf.float32) u_grads = [ # 2.0 * tf.matmul(UV - D, V, transpose_b=True), 2.0 * (tf.matmul(U, VVT) - DVT), 4.0 * alpha * tf.matmul(U, UTU - eye) ] UTD = tf.transpose(self.D_mul_U(tf.sparse_transpose(D), U, num_topics)) v_grads = [2.0 * (tf.matmul(UTU, V) - UTD)] u_grads = tf.reduce_sum(tf.stack(u_grads, axis=0), axis=0) v_grads = tf.reduce_sum(tf.stack(v_grads, axis=0), axis=0) # loss = tf.reduce_sum([ # tf.reduce_sum(tf.norm(D - UV, ord=2)), # tf.reduce_sum(tf.norm(tf.matmul(U, U, transpose_a=True) - eye, ord=2)) # ]) UV = tf.matmul(U, V[:, 0:100]) loss = tf.reduce_mean(tf.norm(self.Ds - UV, ord=2)) return u_grads, v_grads, loss, [U, V]
def testAlreadyInOrder(self): with self.test_session(use_gpu=False) as sess: input_val = self._SparseTensorValue_5x6(np.arange(6)) sp_output = tf.sparse_reorder(input_val) output_val = sess.run(sp_output) self.assertAllEqual(output_val.indices, input_val.indices) self.assertAllEqual(output_val.values, input_val.values) self.assertAllEqual(output_val.shape, input_val.shape)
def testFeedAlreadyInOrder(self): with self.test_session(use_gpu=False) as sess: sp_input = self._SparseTensorPlaceholder() input_val = self._SparseTensorValue_5x6(np.arange(6)) sp_output = tf.sparse_reorder(sp_input) output_val = sess.run(sp_output, {sp_input: input_val}) self.assertAllEqual(output_val.indices, input_val.indices) self.assertAllEqual(output_val.values, input_val.values) self.assertAllEqual(output_val.dense_shape, input_val.dense_shape)
def testOutOfOrder(self): expected_output_val = self._SparseTensorValue_5x6(np.arange(6)) with self.test_session(use_gpu=False) as sess: for _ in range(5): # To test various random permutations input_val = self._SparseTensorValue_5x6(np.random.permutation(6)) sp_output = tf.sparse_reorder(input_val) output_val = sess.run(sp_output) self.assertAllEqual(output_val.indices, expected_output_val.indices) self.assertAllEqual(output_val.values, expected_output_val.values) self.assertAllEqual(output_val.shape, expected_output_val.shape)
def __init__(self, L, F, K): super().__init__() L = graph.rescale_L(L, lmax=2) # Graph Laplacian, M x M L = L.tocoo() data = L.data indices = np.empty((L.nnz, 2)) indices[:,0] = L.row indices[:,1] = L.col L = tf.SparseTensor(indices, data, L.shape) self.L = tf.sparse_reorder(L) self.F = F # Number of filters self.K = K # Polynomial order, i.e. filter size (number of hopes)
def testGradients(self): with self.test_session(use_gpu=False): for _ in range(5): # To test various random permutations input_val = self._SparseTensorValue_5x6(np.random.permutation(6)) sp_input = tf.SparseTensor( input_val.indices, input_val.values, input_val.dense_shape) sp_output = tf.sparse_reorder(sp_input) err = tf.test.compute_gradient_error( sp_input.values, input_val.values.shape, sp_output.values, input_val.values.shape, x_init_value=input_val.values) self.assertLess(err, 1e-11)
def random_sparse_tensor(shape, sparsity, stddev=0.15, name='random-sparse'): """Returns a sparse tensor with a set sparsity but with random indices and values. Values are from a normal with mean 0 and given std deviation. Args: shape: list of ints, the final shape of the tensor. sparsity: scalar, If it is an integer > 0 it is assumed to be the number of elements in the sparse tensor, otherwise if it is a float in [0, 1] it is treated as a fraction of elements to set. stddev: the standard deviation of the values. name: the name of the tensor """ if int(sparsity) != 0: logger.info('assuming sparsity is number of elements') num_elements = int(sparsity) elif sparsity <= 0 or sparsity >= 1: raise ValueError( 'sparsity {} is out of range (0-1)'.format(sparsity)) else: logger.info('assuming sparsity (%.3f) is fraction', sparsity) size = 1 for dim in shape: size *= dim # now how many non-zero num_elements = int(size * sparsity) logger.info('(amounts to %d elements)', num_elements) # the first thing we need are random indices # it's a bit hard to do this without the possibility of repeats idces = tf.stack([tf.cast( tf.get_variable(name+'_idcs{}'.format(i), shape=[num_elements], initializer=tf.random_uniform_initializer( maxval=dim, dtype=tf.float32), dtype=tf.float32), tf.int64) for i, dim in enumerate(shape)]) idces = tf.transpose(idces) # should check for repeats? # and now values vals = tf.get_variable(name+'values', [num_elements], initializer=tf.random_normal_initializer( stddev=stddev)) return tf.sparse_reorder(tf.SparseTensor(idces, vals, shape))
def unpool_layer2x2_batch(self, x, argmax): ''' Args: x: 4D tensor of shape [batch_size x height x width x channels] argmax: A Tensor of type Targmax. 4-D. The flattened indices of the max values chosen for each output. Return: 4D output tensor of shape [batch_size x 2*height x 2*width x channels] ''' x_shape = tf.shape(x) out_shape = [x_shape[0], x_shape[1]*2, x_shape[2]*2, x_shape[3]] batch_size = out_shape[0] height = out_shape[1] width = out_shape[2] channels = out_shape[3] argmax_shape = tf.to_int64([batch_size, height, width, channels]) argmax = unravel_argmax(argmax, argmax_shape) t1 = tf.to_int64(tf.range(channels)) t1 = tf.tile(t1, [batch_size*(width//2)*(height//2)]) t1 = tf.reshape(t1, [-1, channels]) t1 = tf.transpose(t1, perm=[1, 0]) t1 = tf.reshape(t1, [channels, batch_size, height//2, width//2, 1]) t1 = tf.transpose(t1, perm=[1, 0, 2, 3, 4]) t2 = tf.to_int64(tf.range(batch_size)) t2 = tf.tile(t2, [channels*(width//2)*(height//2)]) t2 = tf.reshape(t2, [-1, batch_size]) t2 = tf.transpose(t2, perm=[1, 0]) t2 = tf.reshape(t2, [batch_size, channels, height//2, width//2, 1]) t3 = tf.transpose(argmax, perm=[1, 4, 2, 3, 0]) t = tf.concat(4, [t2, t3, t1]) indices = tf.reshape(t, [(height//2)*(width//2)*channels*batch_size, 4]) x1 = tf.transpose(x, perm=[0, 3, 1, 2]) values = tf.reshape(x1, [-1]) delta = tf.SparseTensor(indices, values, tf.to_int64(out_shape)) return tf.sparse_tensor_to_dense(tf.sparse_reorder(delta))
def transfer_fn(self,xy): # A function that takes the control pulses with a smaller timestep and interpolate between them to generate the simulation weights indices=[] values=[] shape=[self.sys_para.steps,self.sys_para.control_steps] dt=self.sys_para.dt Dt=self.sys_para.Dt # Cubic Splines for ll in range (self.sys_para.steps): jj=self.get_j(ll) tao= ll*dt - jj*Dt - 0.5*Dt if jj >= 1: indices.append([int(ll),int(jj-1)]) temp= -(tao/(2*Dt))*((tao/Dt)-1)**2 values.append(temp) if jj >= 0: indices.append([int(ll),int(jj)]) temp= 1+((3*tao**3)/(2*Dt**3))-((5*tao**2)/(2*Dt**2)) values.append(temp) if jj+1 <= self.sys_para.control_steps-1: indices.append([int(ll),int(jj+1)]) temp= ((tao)/(2*Dt))+((4*tao**2)/(2*Dt**2))-((3*tao**3)/(2*Dt**3)) values.append(temp) if jj+2 <= self.sys_para.control_steps-1: indices.append([int(ll),int(jj+2)]) temp= ((tao**3)/(2*Dt**3))-((tao**2)/(2*Dt**2)) values.append(temp) T1=tf.SparseTensor(indices, values, shape) T2=tf.sparse_reorder(T1) T=tf.sparse_tensor_to_dense(T2) temp1 = tf.matmul(T,tf.reshape(xy[0,:],[self.sys_para.control_steps,1])) temp2 = tf.matmul(T,tf.reshape(xy[1,:],[self.sys_para.control_steps,1])) xys=tf.concat(1,[temp1,temp2]) return tf.transpose(xys)
def preview_like(self, inp): """Generate a preview image of the states of the particle filter""" indicies, onscreen = self.project() indicies = tf.to_int64(tf.boolean_mask(indicies, onscreen)) probs = tf.gather_nd(inp, indicies) return tf.sparse_tensor_to_dense(tf.sparse_reorder(tf.SparseTensor(indicies, probs, inp.get_shape())), validate_indices = False)
def __init__(self, config, ont, word_model): #print("Creating the model graph") tf.reset_default_graph() self.ont = ont self.word_model = word_model ###### self.raw_data = ([(x,c) for c in self.ont.names for x in self.ont.names[c]]) self.anchors, self.anchors_len = self.phrase2vec([x[0] for x in self.raw_data], config.max_sequence_length) ## #config.concepts_size = len(self.ont.concepts) +1 ## self.config = config ### Inputs ### self.label = tf.placeholder(tf.int32, shape=[None]) self.class_weights = tf.Variable(tf.ones([config.concepts_size]), False) self.seq = tf.placeholder(tf.float32, shape=[None, config.max_sequence_length, word_model.dim]) self.seq_len = tf.placeholder(tf.int32, shape=[None]) self.lr = tf.Variable(config.lr, trainable=False) self.is_training = tf.placeholder(tf.bool) self.ancestry_sparse_tensor = tf.sparse_reorder(tf.SparseTensor(indices = ont.sparse_ancestrs, values = [1.0]*len(ont.sparse_ancestrs), dense_shape=[config.concepts_size, config.concepts_size])) ####################### ## Phrase embeddings ## ####################### ''' layer1 = tf.layers.conv1d(self.seq, self.config.cl1, 1, activation=tf.nn.elu,\ kernel_initializer=tf.random_normal_initializer(0.0,0.1),\ bias_initializer=tf.random_normal_initializer(stddev=0.01), use_bias=True) layer2 = tf.layers.dense(tf.reduce_max(layer1, [1]), self.config.cl2, activation=tf.nn.relu,\ #layer2 = tf.layers.dense(tf.reduce_max(layer1, [1]), self.config.cl2,\ kernel_initializer=tf.random_normal_initializer(0.0,stddev=0.1), bias_initializer=tf.random_normal_initializer(0.0,stddev=0.01), use_bias=True) #self.seq_embedding = tf.nn.l2_normalize(layer2 , dim=1) ''' self.seq_embedding = tf.nn.l2_normalize(tf.reduce_sum(self.seq, axis=1), axis=1) ######################## ## Concept embeddings ## ######################## ''' self.embeddings = tf.get_variable("embeddings", shape = [self.config.concepts_size, self.config.cl2], initializer = tf.random_normal_initializer(stddev=0.1)) #self.embeddings = tf.nn.l2_normalize(self.embeddings, dim=1) self.aggregated_embeddings = tf.sparse_tensor_dense_matmul(self.ancestry_sparse_tensor, self.embeddings) if config.flat: aggregated_w = self.embeddings else: aggregated_w = self.aggregated_embeddings last_layer_b = tf.get_variable('last_layer_bias', shape = [self.config.concepts_size], initializer = tf.random_normal_initializer(stddev=0.001)) self.score_layer = tf.matmul(self.seq_embedding, tf.transpose(aggregated_w)) + last_layer_b ######################## ######################## ######################## label_one_hot = tf.one_hot(self.label, config.concepts_size) self.loss = tf.reduce_mean(tf.losses.sparse_softmax_cross_entropy(self.label, self.score_layer)) #self.loss = tf.reduce_mean(tf.losses.sigmoid_cross_entropy(tf.one_hot(self.label, config.concepts_size), self.score_layer)) #self.loss = -tf.reduce_mean(tf.reduce_sum(label_one_hot*tf.log(0.001+ tf.sigmoid(self.score_layer)) + (1-label_one_hot)*tf.log(0.001+1-tf.sigmoid(self.score_layer))/(config.concepts_size-1), axis=-1)) self.pred = tf.nn.softmax(self.score_layer) #self.pred = tf.nn.sigmoid(self.score_layer) self.agg_pred, _ = tf.nn.top_k(tf.transpose(tf.sparse_tensor_dense_matmul(tf.sparse_transpose(self.ancestry_sparse_tensor), tf.transpose(self.pred))), 2) self.train_step = tf.train.AdamOptimizer(self.lr).minimize(self.loss) ''' self.sess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True)) #print("initializing") self.sess.run(tf.global_variables_initializer())
def _train_fprop(self, state_below): idx, val = state_below X = tf.SparseTensor(tf.cast(idx, 'int64'), val, shape=[self.batchsize, self.prev_dim]) X_order = tf.sparse_reorder(X) XW = tf.sparse_tensor_dense_matmul(X_order, self.W, adjoint_a=False, adjoint_b=False) return tf.add(XW, self.b)