def __init__(self, in_features, out_features, hids=[16], num_heads=[8], acts=['elu'], dropout=0.6, weight_decay=5e-4, lr=0.01, bias=True): x = Input(batch_shape=[None, in_features], dtype=floatx(), name='node_attr') adj = Input(batch_shape=[None, None], dtype=floatx(), sparse=True, name='adj_matrix') h = x for hid, num_head, act in zip(hids, num_heads, acts): h = GraphAttention(hid, attn_heads=num_head, reduction='concat', use_bias=bias, activation=act, kernel_regularizer=regularizers.l2(weight_decay), attn_kernel_regularizer=regularizers.l2( weight_decay), )([h, adj]) h = Dropout(rate=dropout)(h) h = GraphAttention(out_features, use_bias=bias, attn_heads=1, reduction='average')([h, adj]) super().__init__(inputs=[x, adj], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy'])
def __init__(self, in_features, out_features, hids=[64], acts=['relu'], dropout=0.5, weight_decay=5e-3, lr=0.01, bias=False, K=10): x = Input(batch_shape=[None, in_features], dtype=floatx(), name='node_attr') adj = Input(batch_shape=[None, None], dtype=floatx(), sparse=True, name='adj_matrix') h = x for hid, act in zip(hids, acts): h = Dense(hid, use_bias=bias, activation=act, kernel_regularizer=regularizers.l2(weight_decay))(h) h = Dropout(dropout)(h) h = Dense(out_features, use_bias=bias, activation=acts[-1], kernel_regularizer=regularizers.l2(weight_decay))(h) h = Dropout(dropout)(h) h = PropConvolution(K, use_bias=bias, activation='sigmoid', kernel_regularizer=regularizers.l2(weight_decay))([h, adj]) super().__init__(inputs=[x, adj], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy'])
def __init__(self, in_features, out_features, hids=[16], acts=['relu'], dropout=0.5, weight_decay=5e-4, lr=0.01, bias=False, experimental_run_tf_function=True): x = Input(batch_shape=[None, in_features], dtype=floatx(), name='node_attr') adj = Input(batch_shape=[None, None], dtype=floatx(), sparse=True, name='adj_matrix') h = x for hid, act in zip(hids, acts): h = GraphConvolution(hid, use_bias=bias, activation=act, kernel_regularizer=regularizers.l2(weight_decay))([h, adj]) h = Dropout(rate=dropout)(h) h = GraphConvolution(out_features, use_bias=bias)([h, adj]) super().__init__(inputs=[x, adj], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy'], experimental_run_tf_function=experimental_run_tf_function)
def __init__(self, in_channels, out_channels, hiddens=[16], activations=['relu'], dropout=0.5, weight_decay=5e-4, lr=0.01, order=2, use_bias=False): x = Input(batch_shape=[None, in_channels], dtype=floatx(), name='node_attr') adj = [Input(batch_shape=[None, None], dtype=floatx(), sparse=True, name=f'adj_matrix_{i}') for i in range(order + 1)] index = Input(batch_shape=[None], dtype=intx(), name='node_index') h = x for hidden, activation in zip(hiddens, activations): h = ChebyConvolution(hidden, order=order, use_bias=use_bias, activation=activation, kernel_regularizer=regularizers.l2(weight_decay))([h, adj]) h = Dropout(rate=dropout)(h) h = ChebyConvolution(out_channels, order=order, use_bias=use_bias)([h, adj]) h = Gather()([h, index]) super().__init__(inputs=[x, *adj, index], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy'])
def __init__(self, in_channels, out_channels, hiddens=[32], activations=['relu'], dropout=0.5, l2_norm=5e-4, lr=0.01, use_bias=False): x = Input(batch_shape=[None, in_channels], dtype=floatx(), name='attr_matrix') adj = Input(batch_shape=[None, None], dtype=floatx(), sparse=True, name='adj_matrix') h = x for hidden, activation in zip(hiddens, activations): h = Dense(hidden, use_bias=use_bias, activation=activation, kernel_regularizer=regularizers.l2(l2_norm))(h) h = Dropout(rate=dropout)(h) h = GraphConvolution(out_channels, use_bias=use_bias)([h, adj]) super().__init__(inputs=[x, adj], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy'])
def __init__(self, in_channels, out_channels, hiddens=[32], n_filters=[8, 8], activations=[None, None], dropout=0.8, l2_norm=5e-4, lr=0.1, use_bias=False, K=8): x = Input(batch_shape=[None, in_channels], dtype=floatx(), name='attr_matrix') adj = Input(batch_shape=[None, None], dtype=floatx(), sparse=False, name='adj_matrix') mask = Input(batch_shape=[None], dtype='bool', name='node_mask') h = x for idx, hidden in enumerate(hiddens): h = Dropout(rate=dropout)(h) h = DenseConvolution( hidden, use_bias=use_bias, activation=activations[idx], kernel_regularizer=regularizers.l2(l2_norm))([h, adj]) for idx, n_filter in enumerate(n_filters): top_k_h = Top_k_features(K=K)([h, adj]) cur_h = LGConvolution( n_filter, kernel_size=K, use_bias=use_bias, dropout=dropout, activation=activations[idx], kernel_regularizer=regularizers.l2(l2_norm))(top_k_h) cur_h = BatchNormalization()(cur_h) h = Concatenate()([h, cur_h]) h = Dropout(rate=dropout)(h) h = DenseConvolution( out_channels, use_bias=use_bias, activation=activations[-1], kernel_regularizer=regularizers.l2(l2_norm))([h, adj]) h = Mask()([h, mask]) super().__init__(inputs=[x, adj, mask], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Nadam(lr=lr), metrics=['accuracy'])
def __init__(self, in_features, out_features, hids=[32], num_filters=[8, 8], acts=[None, None], dropout=0.8, weight_decay=5e-4, lr=0.1, bias=False, K=8): x = Input(batch_shape=[None, in_features], dtype=floatx(), name='node_attr') adj = Input(batch_shape=[None, None], dtype=floatx(), sparse=False, name='adj_matrix') h = x for idx, hid in enumerate(hids): h = Dropout(rate=dropout)(h) h = DenseConv( hid, use_bias=bias, activation=acts[idx], kernel_regularizer=regularizers.l2(weight_decay))([h, adj]) for idx, num_filter in enumerate(num_filters): top_k_h = Top_k_features(K=K)([h, adj]) cur_h = LGConv( num_filter, kernel_size=K, use_bias=bias, dropout=dropout, activation=acts[idx], kernel_regularizer=regularizers.l2(weight_decay))(top_k_h) cur_h = BatchNormalization()(cur_h) h = Concatenate()([h, cur_h]) h = Dropout(rate=dropout)(h) h = DenseConv( out_features, use_bias=bias, activation=acts[-1], kernel_regularizer=regularizers.l2(weight_decay))([h, adj]) super().__init__(inputs=[x, adj], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Nadam(lr=lr), metrics=['accuracy'])
def infer_type(x): """Infer type of the input `x`. Parameters: ---------- x: Any python object Returns: ---------- dtype: string, the converted type of `x`: 1. `graphgallery.floatx()` if `x` is floating 2. `graphgallery.intx()` if `x` is integer 3. `'bool'` if `x` is bool. """ # For tensor or variable if is_th_tensor(x): if x.dtype.is_floating_point: return floatx() elif x.dtype == torch.bool: return 'bool' elif 'int' in str(x.dtype): return intx() else: raise RuntimeError(f'Invalid input of `{type(x)}`') elif is_tf_tensor(x): if x.dtype.is_floating: return floatx() elif x.dtype.is_integer or x.dtype.is_unsigned: return intx() elif x.dtype.is_bool: return 'bool' else: raise RuntimeError(f'Invalid input of `{type(x)}`') if not hasattr(x, 'dtype'): x = np.asarray(x) if x.dtype.kind in {'f', 'c'}: return floatx() elif x.dtype.kind in {'i', 'u'}: return intx() elif x.dtype.kind == 'b': return 'bool' elif x.dtype.kind == 'O': raise RuntimeError(f'Invalid inputs of `{x}`.') else: raise RuntimeError(f'Invalid input of `{type(x)}`')
def infer_type(x: Any) -> str: """Infer the type of the input 'x'. Parameters: ---------- x: Any python object Returns: ---------- dtype: string, the proper data type of 'x': 1. 'graphgallery.floatx()' if 'x' is floating, 2. 'graphgallery.intx()' if 'x' is integer, 3. 'graphgallery.boolx()' if 'x' is boolean. """ # For tensor or variable if pytorch.is_tensor(x): if x.dtype.is_floating_point: return gg.floatx() elif x.dtype == torch.bool: return gg.boolx() elif 'int' in str(x.dtype): return gg.intx() else: raise TypeError(f"Invalid type of pytorch Tensor: '{type(x)}'") elif tensorflow.is_tensor(x): if x.dtype.is_floating: return gg.floatx() elif x.dtype.is_integer or x.dtype.is_unsigned: return gg.intx() elif x.dtype.is_bool: return gg.boolx() else: raise TypeError(f"Invalid type of tensorflow Tensor: '{type(x)}'") _x = x if not hasattr(_x, 'dtype'): _x = np.asarray(_x) if _x.dtype.kind in {'f', 'c'}: return gg.floatx() elif _x.dtype.kind in {'i', 'u'}: return gg.intx() elif _x.dtype.kind == 'b': return gg.boolx() elif _x.dtype.kind == 'O': raise TypeError(f"Invalid inputs of '{x}'.") else: raise TypeError(f"Invalid input of '{type(x).__name__}'.")
def __init__(self, in_features, out_features, hids=[16], acts=['relu'], dropout=0.5, weight_decay=5e-4, lr=0.01, bias=False): _intx = intx() _floatx = floatx() x = Input(batch_shape=[None, in_features], dtype=_floatx, name='node_attr') edge_index = Input(batch_shape=[None, 2], dtype=_intx, name='edge_index') edge_weight = Input(batch_shape=[None], dtype=_floatx, name='edge_weight') h = x for hid, act in zip(hids, acts): h = GraphEdgeConvolution(hid, use_bias=bias, activation=act, kernel_regularizer=regularizers.l2(weight_decay))([h, edge_index, edge_weight]) h = Dropout(rate=dropout)(h) h = GraphEdgeConvolution(out_features, use_bias=bias)( [h, edge_index, edge_weight]) super().__init__(inputs=[x, edge_index, edge_weight], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy'])
def add_selfloops_edge(edge_index, edge_weight, n_nodes=None, fill_weight=1.0): if n_nodes is None: n_nodes = tf.reduce_max(edge_index) + 1 if edge_weight is None: edge_weight = tf.ones([edge_index.shape[0]], dtype=floatx()) range_arr = tf.range(n_nodes, dtype=edge_index.dtype) diagnal_edge_index = tf.stack([range_arr, range_arr], axis=1) updated_edge_index = tf.concat([edge_index, diagnal_edge_index], axis=0) diagnal_edge_weight = tf.zeros([n_nodes], dtype=floatx()) + fill_weight updated_edge_weight = tf.concat([edge_weight, diagnal_edge_weight], axis=0) return updated_edge_index, updated_edge_weight
def __init__(self, in_channels, out_channels, hids=[16], acts=['relu'], dropout=0.5, weight_decay=5e-4, lr=0.01, use_bias=False, experimental_run_tf_function=True): x = Input(batch_shape=[None, in_channels], dtype=floatx(), name='node_attr') h = x for hid, act in zip(hids, acts): h = Dense(hid, use_bias=use_bias, activation=act, kernel_regularizer=regularizers.l2(weight_decay))(h) h = Dropout(rate=dropout)(h) h = Dense(out_channels, use_bias=use_bias)(h) super().__init__(inputs=x, outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy'], experimental_run_tf_function=experimental_run_tf_function)
def normalize_edge_tensor(edge_index, edge_weight=None, n_nodes=None, fill_weight=1.0, rate=-0.5): if edge_weight is None: edge_weight = tf.ones([edge_index.shape[0]], dtype=floatx()) if n_nodes is None: n_nodes = tf.reduce_max(edge_index) + 1 edge_index, edge_weight = add_selfloops_edge( edge_index, edge_weight, n_nodes=n_nodes, fill_weight=fill_weight) row, col = tf.unstack(edge_index, axis=1) deg = tf.math.unsorted_segment_sum(edge_weight, row, num_segments=n_nodes) deg_inv_sqrt = tf.pow(deg, rate) # check if exists NAN deg_inv_sqrt = tf.where( tf.math.logical_or(tf.math.is_inf(deg_inv_sqrt), tf.math.is_nan(deg_inv_sqrt)), tf.zeros_like(deg_inv_sqrt), deg_inv_sqrt ) edge_weight_norm = tf.gather( deg_inv_sqrt, row) * edge_weight * tf.gather(deg_inv_sqrt, col) return edge_index, edge_weight_norm
def sparse_edges_to_sparse_tensor(edge_index: np.ndarray, edge_weight: np.ndarray = None, shape: tuple = None) -> torch.sparse.Tensor: """ edge_index: shape [2, M] edge_weight: shape [M,] """ edge_index = T.edge_transpose(edge_index) edge_index = torch.LongTensor(edge_index) if edge_weight is None: edge_weight = torch.ones(edge_index.shape[1], dtype=getattr(torch, floatx())) else: edge_weight = torch.tensor(edge_weight) if shape is None: N = (edge_index).max() + 1 shape = (N, N) shape = torch.Size(shape) dtype = str(edge_weight.dtype) return getattr(torch.sparse, dtype_to_tensor_class(dtype))(edge_index, edge_weight, shape)
def __init__(self, in_channels, out_channels, hiddens=[32], activations=['relu'], dropout=0.5, l2_norm=5e-4, lr=0.01, use_bias=True, aggregator='mean', output_normalize=False, n_samples=[15, 5]): Agg = _AGG.get(aggregator, None) if not Agg: raise ValueError( f"Invalid value of 'aggregator', allowed values {tuple(_AGG.keys())}, but got '{aggregator}'." ) _intx = intx() x = Input(batch_shape=[None, in_channels], dtype=floatx(), name='attr_matrix') nodes = Input(batch_shape=[None], dtype=_intx, name='nodes') neighbors = [ Input(batch_shape=[None], dtype=_intx, name=f'neighbors_{hop}') for hop, n_sample in enumerate(n_samples) ] aggregators = [] for hidden, activation in zip(hiddens, activations): # you can use `GCNAggregator` instead aggregators.append( Agg(hidden, concat=True, activation=activation, use_bias=use_bias, kernel_regularizer=regularizers.l2(l2_norm))) aggregators.append(Agg(out_channels, use_bias=use_bias)) h = [tf.nn.embedding_lookup(x, node) for node in [nodes, *neighbors]] for agg_i, aggregator in enumerate(aggregators): attribute_shape = h[0].shape[-1] for hop in range(len(n_samples) - agg_i): neighbor_shape = [-1, n_samples[hop], attribute_shape] h[hop] = aggregator( [h[hop], tf.reshape(h[hop + 1], neighbor_shape)]) if hop != len(n_samples) - 1: h[hop] = Dropout(rate=dropout)(h[hop]) h.pop() h = h[0] if output_normalize: h = tf.nn.l2_normalize(h, axis=1) super().__init__(inputs=[x, nodes, *neighbors], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy'])
def call(self, inputs): edge_index, edge_weight = inputs num_nodes = tf.reduce_max(edge_index) + 1 if not edge_weight: edge_weight = tf.ones([edge_index.shape[0]], dtype=floatx()) edge_index, edge_weight = self.add_selfloops_edge( edge_index, num_nodes, edge_weight=edge_weight, fill_weight=self.fill_weight) row = tf.gather(edge_index, 0, axis=1) col = tf.gather(edge_index, 1, axis=1) deg = tf.math.unsorted_segment_sum(edge_weight, row, num_segments=num_nodes) deg_inv_sqrt = tf.pow(deg, self.rate) deg_inv_sqrt = tf.where(tf.math.is_inf(deg_inv_sqrt), tf.zeros_like(deg_inv_sqrt), deg_inv_sqrt) deg_inv_sqrt = tf.where(tf.math.is_nan(deg_inv_sqrt), tf.zeros_like(deg_inv_sqrt), deg_inv_sqrt) noremd_edge_weight = tf.gather( deg_inv_sqrt, row) * edge_weight * tf.gather(deg_inv_sqrt, col) return edge_index, noremd_edge_weight
def edge_to_sparse_adj(edge: np.ndarray, edge_weight: Optional[np.ndarray] = None, shape: Optional[tuple] = None) -> sp.csr_matrix: """Convert (edge, edge_weight) representation to a Scipy sparse matrix Parameters ---------- edge : np.ndarray edge index of sparse matrix, shape [2, M] edge_weight : Optional[np.ndarray], optional edge weight of sparse matrix, shape [M,], by default None shape : Optional[tuple], optional shape of sparse matrix, by default None Returns ------- scipy.sparse.csr_matrix """ edge = edge_transpose(edge) if edge_weight is None: edge_weight = np.ones(edge.shape[1], dtype=gg.floatx()) if shape is None: shape = maybe_shape(edge) return sp.csr_matrix((edge_weight, edge), shape=shape)
def add_selfloops_edge(edge_index, edge_weight, n_nodes=None, fill_weight=1.0): edge_index = edge_transpose(edge_index) if n_nodes is None: n_nodes = edge_index.max() + 1 if edge_weight is None: edge_weight = np.ones(edge_index.shape[1], dtype=floatx()) diagnal_edge_index = np.asarray(np.diag_indices(n_nodes)).astype( edge_index.dtype, copy=False) updated_edge_index = np.hstack([edge_index, diagnal_edge_index]) diagnal_edge_weight = np.zeros(n_nodes, dtype=floatx()) + fill_weight updated_edge_weight = np.hstack([edge_weight, diagnal_edge_weight]) return updated_edge_index, updated_edge_weight
def __init__(self, in_features, out_features, alpha=0.1, K=10, ppr_dropout=0., hids=[64], acts=['relu'], dropout=0.5, weight_decay=5e-4, lr=0.01, bias=True, approximated=True): x = Input(batch_shape=[None, in_features], dtype=floatx(), name='node_attr') adj = Input(batch_shape=[None, None], dtype=floatx(), sparse=approximated, name='adj_matrix') h = x for hid, act in zip(hids, acts): h = Dense(hid, use_bias=bias, activation=act, kernel_regularizer=regularizers.l2(weight_decay))(h) h = Dropout(rate=dropout)(h) h = Dense(out_features, use_bias=bias, kernel_regularizer=regularizers.l2(weight_decay))(h) if approximated: h = APPNPropagation(alpha=alpha, K=K, dropout=ppr_dropout)([h, adj]) else: h = PPNPropagation(dropout=ppr_dropout)([h, adj]) super().__init__(inputs=[x, adj], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy'])
def __init__(self, in_channels, out_channels, hiddens=[16], n_heads=[8], activations=['elu'], dropout=0.6, l2_norm=5e-4, lr=0.01, use_bias=True): x = Input(batch_shape=[None, in_channels], dtype=floatx(), name='attr_matrix') adj = Input(batch_shape=[None, None], dtype=floatx(), sparse=True, name='adj_matrix') index = Input(batch_shape=[None], dtype=intx(), name='node_index') h = x for hidden, n_head, activation in zip(hiddens, n_heads, activations): h = GraphAttention( hidden, attn_heads=n_head, reduction='concat', use_bias=use_bias, activation=activation, kernel_regularizer=regularizers.l2(l2_norm), attn_kernel_regularizer=regularizers.l2(l2_norm), )([h, adj]) h = Dropout(rate=dropout)(h) h = GraphAttention(out_channels, use_bias=use_bias, attn_heads=1, reduction='average')([h, adj]) h = Gather()([h, index]) super().__init__(inputs=[x, adj, index], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy'])
def __init__(self, in_features, out_features, hids=[16], acts=['relu'], num_attn=3, dropout=0.5, weight_decay=5e-4, lr=0.01, bias=False): x = Input(batch_shape=[None, in_features], dtype=floatx(), name='node_attr') adj = Input(batch_shape=[None, None], dtype=floatx(), sparse=True, name='adj_matrix') h = x for hid, act in zip(hids, acts): h = Dense(hid, use_bias=bias, activation=act, kernel_regularizer=regularizers.l2(weight_decay))(h) h = Dropout(rate=dropout)(h) # for Cora dataset, the first propagation layer is non-trainable # and beta is fixed at 0 h = SimilarityAttention(trainable=False, regularizer=regularizers.l2(weight_decay))( [h, adj]) for _ in range(1, num_attn): h = SimilarityAttention(regularizer=regularizers.l2(weight_decay))( [h, adj]) h = Dense(out_features, use_bias=bias)(h) h = Dropout(rate=dropout)(h) super().__init__(inputs=[x, adj], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy'])
def normalize_edge(edge_index, edge_weight=None, rate=-0.5, fill_weight=1.0): edge_index = asedge(edge_index) num_nodes = edge_index.max() + 1 if edge_weight is None: edge_weight = np.ones(edge_index.shape[1], dtype=gg.floatx()) if fill_weight: edge_index, edge_weight = add_selfloops_edge(edge_index, edge_weight, num_nodes=num_nodes, fill_weight=fill_weight) degree = np.bincount(edge_index[0], weights=edge_weight) degree_power = np.power(degree, rate, dtype=gg.floatx()) row, col = edge_index edge_weight_norm = degree_power[row] * edge_weight * degree_power[col] return edge_index, edge_weight_norm
def infer_type(x)->str: """Infer type of the input `x`. Parameters: ---------- x: tf.Tensor, tf.Variable, Scipy sparse matrix, Numpy array-like, etc. Returns: ---------- dtype: string, the converted type of `x`: 1. `graphgallery.floatx()` if `x` is floating 2. `graphgallery.intx()` if `x` is integer 3. `'bool'` if `x` is bool. """ # For tensor or variable if is_tf_tensor(x): if x.dtype.is_floating: return floatx() elif x.dtype.is_integer or x.dtype.is_unsigned: return intx() elif x.dtype.is_bool: return 'bool' else: raise RuntimeError(f'Invalid input of `{type(x)}`') if not hasattr(x, 'dtype'): x = np.asarray(x) if x.dtype.kind in {'f', 'c'}: return floatx() elif x.dtype.kind in {'i', 'u'}: return intx() elif x.dtype.kind == 'b': return 'bool' elif x.dtype.kind == 'O': raise RuntimeError(f'Invalid inputs of `{x}`.') else: raise RuntimeError(f'Invalid input of `{type(x)}`')
def __init__(self, in_channels, out_channels, hiddens=[64], activations=['relu'], dropout=0.5, weight_decay=5e-4, lr=0.01, kl=5e-4, gamma=1., use_bias=False): _floatx = floatx() x = Input(batch_shape=[None, in_channels], dtype=_floatx, name='node_attr') adj = [Input(batch_shape=[None, None], dtype=_floatx, sparse=True, name='adj_matrix_1'), Input(batch_shape=[None, None], dtype=_floatx, sparse=True, name='adj_matrix_2')] index = Input(batch_shape=[None], dtype=intx(), name='node_index') h = x if hiddens: mean, var = GaussionConvolution_F(hiddens[0], gamma=gamma, use_bias=use_bias, activation=activations[0], kernel_regularizer=regularizers.l2(weight_decay))([h, *adj]) if kl: KL_divergence = 0.5 * \ tf.reduce_mean(tf.math.square(mean) + var - tf.math.log(1e-8 + var) - 1, axis=1) KL_divergence = tf.reduce_sum(KL_divergence) # KL loss kl_loss = kl * KL_divergence # additional layers (usually unnecessay) for hidden, activation in zip(hiddens[1:], activations[1:]): mean, var = GaussionConvolution_D( hidden, gamma=gamma, use_bias=use_bias, activation=activation)([mean, var, *adj]) mean = Dropout(rate=dropout)(mean) var = Dropout(rate=dropout)(var) mean, var = GaussionConvolution_D( out_channels, gamma=gamma, use_bias=use_bias)([mean, var, *adj]) h = Sample()([mean, var]) h = Gather()([h, index]) super().__init__(inputs=[x, *adj, index], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy']) if hiddens and kl: self.add_loss(kl_loss)
def sparse_edges_to_sparse_tensor(edge_index: np.ndarray, edge_weight: np.ndarray = None, shape: tuple = None): """ edge_index: shape [2, M] edge_weight: shape [M,] """ if edge_weight is None: edge_weight = tf.ones(edge_index.shape[1], dtype=floatx()) if shape is None: N = np.max(edge_index) + 1 shape = (N, N) return tf.SparseTensor(edge_index.T, edge_weight, shape)
def __init__(self, in_features, out_features, hids=[16], acts=['relu'], dropout=0.5, weight_decay=5e-4, lr=0.01, K=2, bias=False): x = Input(batch_shape=[None, in_features], dtype=floatx(), name='node_attr') adj = [ Input(batch_shape=[None, None], dtype=floatx(), sparse=True, name=f'adj_matrix_{i}') for i in range(K + 1) ] h = x for hid, act in zip(hids, acts): h = ChebConv( hid, K=K, use_bias=bias, activation=act, kernel_regularizer=regularizers.l2(weight_decay))([h, adj]) h = Dropout(rate=dropout)(h) h = ChebConv(out_features, K=K, use_bias=bias)([h, adj]) super().__init__(inputs=[x, *adj], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy'])
def astensor(x, *, dtype=None, device=None, escape=None): try: if x is None or (escape is not None and isinstance(x, escape)): return x except TypeError: raise TypeError(f"argument 'escape' must be a type or tuple of types.") if dtype is None: dtype = gf.infer_type(x) if isinstance(dtype, (np.dtype, str)): dtype = data_type_dict().get(str(dtype), dtype) elif not isinstance(dtype, torch.dtype): raise TypeError( f"argument 'dtype' must be torch.dtype, np.dtype or str, but got {type(dtype)}." ) if is_tensor(x): tensor = x.to(dtype) elif gf.is_tensor(x, backend='tensorflow'): return astensor(gf.tensoras(x), dtype=dtype, device=device, escape=escape) elif sp.isspmatrix(x): if gg.backend() == "dgl_torch": import dgl tensor = dgl.from_scipy(x, idtype=getattr(torch, gg.intx())) elif gg.backend() == "pyg": edge_index, edge_weight = gf.sparse_adj_to_edge(x) return (astensor(edge_index, dtype=gg.intx(), device=device, escape=escape), astensor(edge_weight, dtype=gg.floatx(), device=device, escape=escape)) else: tensor = sparse_adj_to_sparse_tensor(x, dtype=dtype) elif any((isinstance(x, (np.ndarray, np.matrix)), gg.is_listlike(x), gg.is_scalar(x))): tensor = torch.tensor(x, dtype=dtype, device=device) else: raise TypeError( f"Invalid type of inputs. Allowed data type (Tensor, SparseTensor, Numpy array, Scipy sparse tensor, None), but got {type(x)}." ) return tensor.to(device)
def __init__(self, in_features, out_features, hids=[16], acts=['elu'], dropout=0.5, order=2, iterations=1, weight_decay=5e-5, share_weights=True, lr=0.01, bias=True): x = Input(batch_shape=[None, in_features], dtype=floatx(), name='node_attr') adj = Input(batch_shape=[None, None], dtype=floatx(), sparse=True, name='adj_matrix') h = x for hid, act in zip(hids, acts): h = ARMAConv(hid, use_bias=bias, activation=act, order=order, iterations=iterations, gcn_activation="elu", share_weights=share_weights, kernel_regularizer=regularizers.l2(weight_decay))([h, adj]) h = Dropout(rate=dropout)(h) h = ARMAConv(out_features, use_bias=bias, order=1, iterations=1, gcn_activation=None, share_weights=share_weights)([h, adj]) super().__init__(inputs=[x, adj], outputs=h) self.compile(loss=SparseCategoricalCrossentropy(from_logits=True), optimizer=Adam(lr=lr), metrics=['accuracy'])
def sparse_edge_to_sparse_tensor(edge_index: np.ndarray, edge_weight: np.ndarray = None, shape: tuple = None) -> tf.SparseTensor: """ edge_index: shape [2, M] edge_weight: shape [M,] """ edge_index = gf.edge_transpose(edge_index) if edge_weight is None: edge_weight = tf.ones(edge_index.shape[1], dtype=gg.floatx()) if shape is None: shape = gf.maybe_shape(edge_index) return tf.SparseTensor(edge_index.T, edge_weight, shape)
def sparse_edge_to_sparse_tensor(edge_index: np.ndarray, edge_weight: np.ndarray = None, shape: tuple = None) -> tf.SparseTensor: """ edge_index: shape [M, 2] or [2, M] edge_weight: shape [M,] """ edge_index = gf.asedge(edge_index, shape="row_wise") if edge_weight is None: edge_weight = tf.ones(edge_index.shape[0], dtype=gg.floatx()) if shape is None: shape = gf.maybe_shape(edge_index) return tf.SparseTensor(edge_index, edge_weight, shape)