Add files using upload-large-folder tool

deeprobust/graph/defense_pyg/__init__.py

@@ -0,0 +1,15 @@
+try:
+    from .gcn import GCN
+    from .gat import GAT
+    from .appnp import APPNP
+    from .sage import SAGE
+    from .gpr import GPRGNN
+    from .airgnn import AirGNN
+except ImportError as e:
+    print(e)
+    warnings.warn("Please install pytorch geometric if you " +
+                  "would like to use the datasets from pytorch " +
+                  "geometric. See details in https://pytorch-geom" +
+                  "etric.readthedocs.io/en/latest/notes/installation.html")
+
+__all__ = ["GCN", "GAT", "APPNP", "SAGE", "GPRGNN", "AirGNN"]

deeprobust/graph/defense_pyg/appnp.py

@@ -0,0 +1,79 @@
+import torch.nn as nn
+import torch.nn.functional as F
+import math
+import torch
+from torch.nn.parameter import Parameter
+from torch.nn.modules.module import Module
+from torch_geometric.nn import APPNP as APPNPConv
+from torch.nn import Linear
+from .base_model import BaseModel
+
+
+class APPNP(BaseModel):
+
+    def __init__(self, nfeat, nhid, nclass, K=10, alpha=0.1, dropout=0.5, lr=0.01,
+                with_bn=False, weight_decay=5e-4, with_bias=True, device=None):
+
+        super(APPNP, self).__init__()
+
+        assert device is not None, "Please specify 'device'!"
+        self.device = device
+
+
+        self.lin1 = Linear(nfeat, nhid)
+        if with_bn:
+            self.bn1 = nn.BatchNorm1d(nhid)
+            self.bn2 = nn.BatchNorm1d(nclass)
+
+        self.lin2 = Linear(nhid, nclass)
+        self.prop1 = APPNPConv(K, alpha)
+
+        self.dropout = dropout
+        self.weight_decay = weight_decay
+        self.lr = lr
+        self.output = None
+        self.best_model = None
+        self.best_output = None
+        self.name = 'APPNP'
+        self.with_bn = with_bn
+
+    def forward(self, x, edge_index, edge_weight=None):
+        x = F.dropout(x, p=self.dropout, training=self.training)
+        x = self.lin1(x)
+        if self.with_bn:
+            x = self.bn1(x)
+        x = F.relu(x)
+        x = F.dropout(x, p=self.dropout, training=self.training)
+        x = self.lin2(x)
+        if self.with_bn:
+            x = self.bn2(x)
+        x = self.prop1(x, edge_index, edge_weight)
+        return F.log_softmax(x, dim=1)
+
+
+    def initialize(self):
+        self.lin1.reset_parameters()
+        self.lin2.reset_parameters()
+        if self.with_bn:
+            self.bn1.reset_parameters()
+            self.bn2.reset_parameters()
+
+
+if __name__ == "__main__":
+    from deeprobust.graph.data import Dataset, Dpr2Pyg
+    data = Dataset(root='/tmp/', name='cora', setting='gcn')
+    adj, features, labels = data.adj, data.features, data.labels
+    idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+    model = GCN(nfeat=features.shape[1],
+          nhid=16,
+          nclass=labels.max().item() + 1,
+          dropout=0.5, device='cuda')
+    model = model.to('cuda')
+    pyg_data = Dpr2Pyg(data)[0]
+
+    import ipdb
+    ipdb.set_trace()
+
+    model.fit(pyg_data, verbose=True) # train with earlystopping
+    model.test()
+    print(model.predict())

deeprobust/graph/defense_pyg/base_model.py

@@ -0,0 +1,206 @@
+import torch.optim as optim
+import torch.nn as nn
+import torch.nn.functional as F
+from copy import deepcopy
+from deeprobust.graph import utils
+import torch
+
+
+class BaseModel(nn.Module):
+    def __init__(self):
+        super(BaseModel, self).__init__()
+        pass
+
+    def fit(self, pyg_data, train_iters=1000, initialize=True, verbose=False, patience=100, **kwargs):
+        if initialize:
+            self.initialize()
+
+        # self.data = pyg_data[0].to(self.device)
+        self.data = pyg_data.to(self.device)
+        # By default, it is trained with early stopping on validation
+        self.train_with_early_stopping(train_iters, patience, verbose)
+
+    def finetune(self, edge_index, edge_weight, feat=None, train_iters=10, verbose=True):
+        if verbose:
+            print(f'=== finetuning {self.name} model ===')
+        optimizer = optim.Adam(self.parameters(), lr=self.lr, weight_decay=self.weight_decay)
+        labels = self.data.y
+        if feat is None:
+            x = self.data.x
+        else:
+            x = feat
+        train_mask, val_mask = self.data.train_mask, self.data.val_mask
+        best_loss_val = 100
+        best_acc_val = 0
+        for i in range(train_iters):
+            self.train()
+            optimizer.zero_grad()
+            output = self.forward(x, edge_index, edge_weight)
+            loss_train = F.nll_loss(output[train_mask], labels[train_mask])
+            loss_train.backward()
+            optimizer.step()
+
+            if verbose and i % 50 == 0:
+                print('Epoch {}, training loss: {}'.format(i, loss_train.item()))
+
+            self.eval()
+            with torch.no_grad():
+                output = self.forward(x, edge_index)
+            loss_val = F.nll_loss(output[val_mask], labels[val_mask])
+            acc_val = utils.accuracy(output[val_mask], labels[val_mask])
+
+            # if best_loss_val > loss_val:
+            #     best_loss_val = loss_val
+            #     best_output = output
+            #     weights = deepcopy(self.state_dict())
+
+            if best_acc_val < acc_val:
+                best_acc_val = acc_val
+                best_output = output
+                weights = deepcopy(self.state_dict())
+
+        print('best_acc_val:', best_acc_val.item())
+        self.load_state_dict(weights)
+        return best_output
+
+
+    def _fit_with_val(self, pyg_data, train_iters=1000, initialize=True, verbose=False, **kwargs):
+        if initialize:
+            self.initialize()
+
+        # self.data = pyg_data[0].to(self.device)
+        self.data = pyg_data.to(self.device)
+        if verbose:
+            print(f'=== training {self.name} model ===')
+        optimizer = optim.Adam(self.parameters(), lr=self.lr, weight_decay=self.weight_decay)
+
+        labels = self.data.y
+        train_mask, val_mask = self.data.train_mask, self.data.val_mask
+
+        x, edge_index = self.data.x, self.data.edge_index
+        for i in range(train_iters):
+            self.train()
+            optimizer.zero_grad()
+            output = self.forward(x, edge_index)
+            loss_train = F.nll_loss(output[train_mask+val_mask], labels[train_mask+val_mask])
+            loss_train.backward()
+            optimizer.step()
+
+            if verbose and i % 50 == 0:
+                print('Epoch {}, training loss: {}'.format(i, loss_train.item()))
+
+    def fit_with_val(self, pyg_data, train_iters=1000, initialize=True, patience=100, verbose=False, **kwargs):
+        if initialize:
+            self.initialize()
+
+        self.data = pyg_data.to(self.device)
+        self.data.train_mask = self.data.train_mask + self.data.val1_mask
+        self.data.val_mask = self.data.val2_mask
+        self.train_with_early_stopping(train_iters, patience, verbose)
+
+    def train_with_early_stopping(self, train_iters, patience, verbose):
+        """early stopping based on the validation loss
+        """
+        if verbose:
+            print(f'=== training {self.name} model ===')
+        optimizer = optim.Adam(self.parameters(), lr=self.lr, weight_decay=self.weight_decay)
+
+        labels = self.data.y
+        train_mask, val_mask = self.data.train_mask, self.data.val_mask
+
+        early_stopping = patience
+        best_loss_val = 100
+        best_acc_val = 0
+        best_epoch = 0
+
+        x, edge_index = self.data.x, self.data.edge_index
+        for i in range(train_iters):
+            self.train()
+            optimizer.zero_grad()
+
+            output = self.forward(x, edge_index)
+
+            loss_train = F.nll_loss(output[train_mask], labels[train_mask])
+            loss_train.backward()
+            optimizer.step()
+
+            if verbose and i % 50 == 0:
+                print('Epoch {}, training loss: {}'.format(i, loss_train.item()))
+
+            self.eval()
+            output = self.forward(x, edge_index)
+            loss_val = F.nll_loss(output[val_mask], labels[val_mask])
+            acc_val = utils.accuracy(output[val_mask], labels[val_mask])
+            # print(acc)
+
+            # if best_loss_val > loss_val:
+            #     best_loss_val = loss_val
+            #     self.output = output
+            #     weights = deepcopy(self.state_dict())
+            #     patience = early_stopping
+            #     best_epoch = i
+            # else:
+            #     patience -= 1
+
+            if best_acc_val < acc_val:
+                best_acc_val = acc_val
+                self.output = output
+                weights = deepcopy(self.state_dict())
+                patience = early_stopping
+                best_epoch = i
+            else:
+                patience -= 1
+
+            if i > early_stopping and patience <= 0:
+                break
+
+        if verbose:
+             # print('=== early stopping at {0}, loss_val = {1} ==='.format(best_epoch, best_loss_val) )
+             print('=== early stopping at {0}, acc_val = {1} ==='.format(best_epoch, best_acc_val) )
+        self.load_state_dict(weights)
+
+    def test(self):
+        """Evaluate model performance on test set.
+        Parameters
+        ----------
+        idx_test :
+            node testing indices
+        """
+        self.eval()
+        test_mask = self.data.test_mask
+        labels = self.data.y
+        output = self.forward(self.data.x, self.data.edge_index)
+        # output = self.output
+        loss_test = F.nll_loss(output[test_mask], labels[test_mask])
+        acc_test = utils.accuracy(output[test_mask], labels[test_mask])
+        print("Test set results:",
+              "loss= {:.4f}".format(loss_test.item()),
+              "accuracy= {:.4f}".format(acc_test.item()))
+        return acc_test.item()
+
+    def predict(self, x=None, edge_index=None, edge_weight=None):
+        """
+        Returns
+        -------
+        torch.FloatTensor
+            output (log probabilities)
+        """
+        self.eval()
+        if x is None or edge_index is None:
+            x, edge_index = self.data.x, self.data.edge_index
+        return self.forward(x, edge_index, edge_weight)
+
+    def _ensure_contiguousness(self,
+                               x,
+                               edge_idx,
+                               edge_weight):
+        if not x.is_sparse:
+            x = x.contiguous()
+        if hasattr(edge_idx, 'contiguous'):
+            edge_idx = edge_idx.contiguous()
+        if edge_weight is not None:
+            edge_weight = edge_weight.contiguous()
+        return x, edge_idx, edge_weight
+
+
+

deeprobust/graph/defense_pyg/gpr.py

@@ -0,0 +1,135 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch_sparse import SparseTensor, matmul
+from torch_geometric.nn import GCNConv, SAGEConv, GATConv, APPNP, MessagePassing
+from torch_geometric.nn.conv.gcn_conv import gcn_norm
+import scipy.sparse
+import numpy as np
+from .base_model import BaseModel
+
+
+class GPRGNN(BaseModel):
+    """GPRGNN, from original repo https://github.com/jianhao2016/GPRGNN"""
+
+    def __init__(self, nfeat, nhid, nclass, Init='PPR', dprate=.5, dropout=.5,
+            lr=0.01, weight_decay=0, device='cpu',
+            K=10, alpha=.1, Gamma=None, ppnp='GPR_prop'):
+        super(GPRGNN, self).__init__()
+        self.lin1 = nn.Linear(nfeat, nhid)
+        self.lin2 = nn.Linear(nhid, nclass)
+
+        if ppnp == 'PPNP':
+            self.prop1 = APPNP(K, alpha)
+        elif ppnp == 'GPR_prop':
+            self.prop1 = GPR_prop(K, alpha, Init, Gamma)
+
+        self.Init = Init
+        self.dprate = dprate
+        self.dropout = dropout
+        self.name = "GPR"
+        self.weight_decay = weight_decay
+        self.lr = lr
+        self.device=device
+
+    def initialize(self):
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        self.lin1.reset_parameters()
+        self.lin2.reset_parameters()
+        self.prop1.reset_parameters()
+
+    def forward(self, x, edge_index, edge_weight=None):
+
+        x = F.dropout(x, p=self.dropout, training=self.training)
+        x = F.relu(self.lin1(x))
+        x = F.dropout(x, p=self.dropout, training=self.training)
+        x = self.lin2(x)
+
+        if edge_weight is not None:
+            adj = SparseTensor.from_edge_index(edge_index, edge_weight, sparse_sizes=2 * x.shape[:1])
+            if self.dprate == 0.0:
+                x = self.prop1(x, adj)
+            else:
+                x = F.dropout(x, p=self.dprate, training=self.training)
+                x = self.prop1(x, adj)
+        else:
+            if self.dprate == 0.0:
+                x = self.prop1(x, edge_index, edge_weight)
+            else:
+                x = F.dropout(x, p=self.dprate, training=self.training)
+                x = self.prop1(x, edge_index, edge_weight)
+
+        return F.log_softmax(x, dim=1)
+
+
+class GPR_prop(MessagePassing):
+    '''
+    GPRGNN, from original repo https://github.com/jianhao2016/GPRGNN
+    propagation class for GPR_GNN
+    '''
+
+    def __init__(self, K, alpha, Init, Gamma=None, bias=True, **kwargs):
+        super(GPR_prop, self).__init__(aggr='add', **kwargs)
+        self.K = K
+        self.Init = Init
+        self.alpha = alpha
+
+        assert Init in ['SGC', 'PPR', 'NPPR', 'Random', 'WS']
+        if Init == 'SGC':
+            # SGC-like
+            TEMP = 0.0*np.ones(K+1)
+            TEMP[alpha] = 1.0
+        elif Init == 'PPR':
+            # PPR-like
+            TEMP = alpha*(1-alpha)**np.arange(K+1)
+            TEMP[-1] = (1-alpha)**K
+        elif Init == 'NPPR':
+            # Negative PPR
+            TEMP = (alpha)**np.arange(K+1)
+            TEMP = TEMP/np.sum(np.abs(TEMP))
+        elif Init == 'Random':
+            # Random
+            bound = np.sqrt(3/(K+1))
+            TEMP = np.random.uniform(-bound, bound, K+1)
+            TEMP = TEMP/np.sum(np.abs(TEMP))
+        elif Init == 'WS':
+            # Specify Gamma
+            TEMP = Gamma
+
+        self.temp = nn.Parameter(torch.tensor(TEMP))
+
+    def reset_parameters(self):
+        nn.init.zeros_(self.temp)
+        for k in range(self.K+1):
+            self.temp.data[k] = self.alpha*(1-self.alpha)**k
+        self.temp.data[-1] = (1-self.alpha)**self.K
+
+    def forward(self, x, edge_index, edge_weight=None):
+        if isinstance(edge_index, torch.Tensor):
+            edge_index, norm = gcn_norm(
+                edge_index, edge_weight, num_nodes=x.size(0), dtype=x.dtype)
+        elif isinstance(edge_index, SparseTensor):
+            edge_index = gcn_norm(
+                edge_index, edge_weight, num_nodes=x.size(0), dtype=x.dtype)
+            norm = None
+
+        hidden = x*(self.temp[0])
+        for k in range(self.K):
+            x = self.propagate(edge_index, x=x, norm=norm)
+            gamma = self.temp[k+1]
+            hidden = hidden + gamma*x
+        return hidden
+
+    def message(self, x_j, norm):
+        return norm.view(-1, 1) * x_j
+
+    def message_and_aggregate(self, adj_t, x):
+        return matmul(adj_t, x, reduce=self.aggr)
+
+    def __repr__(self):
+        return '{}(K={}, temp={})'.format(self.__class__.__name__, self.K,
+                                          self.temp)
+
+

deeprobust/graph/defense_pyg/mygat_conv.py

@@ -0,0 +1,198 @@
+"""Slightly modified torch_geometric.nn.GATConv to fit the structure learning module"""
+from typing import Union, Tuple, Optional
+from torch_geometric.typing import (OptPairTensor, Adj, Size, NoneType,
+                                    OptTensor)
+
+import torch
+from torch import Tensor
+import torch.nn.functional as F
+from torch.nn import Parameter, Linear
+from torch_sparse import SparseTensor, set_diag
+from torch_geometric.nn.conv import MessagePassing
+from torch_geometric.utils import remove_self_loops, add_self_loops, softmax
+
+from torch_geometric.nn.inits import glorot, zeros
+
+
+class GATConv(MessagePassing):
+    r"""The graph attentional operator from the `"Graph Attention Networks"
+    <https://arxiv.org/abs/1710.10903>`_ paper
+
+    .. math::
+        \mathbf{x}^{\prime}_i = \alpha_{i,i}\mathbf{\Theta}\mathbf{x}_{i} +
+        \sum_{j \in \mathcal{N}(i)} \alpha_{i,j}\mathbf{\Theta}\mathbf{x}_{j},
+
+    where the attention coefficients :math:`\alpha_{i,j}` are computed as
+
+    .. math::
+        \alpha_{i,j} =
+        \frac{
+        \exp\left(\mathrm{LeakyReLU}\left(\mathbf{a}^{\top}
+        [\mathbf{\Theta}\mathbf{x}_i \, \Vert \, \mathbf{\Theta}\mathbf{x}_j]
+        \right)\right)}
+        {\sum_{k \in \mathcal{N}(i) \cup \{ i \}}
+        \exp\left(\mathrm{LeakyReLU}\left(\mathbf{a}^{\top}
+        [\mathbf{\Theta}\mathbf{x}_i \, \Vert \, \mathbf{\Theta}\mathbf{x}_k]
+        \right)\right)}.
+
+    Args:
+        in_channels (int or tuple): Size of each input sample. A tuple
+            corresponds to the sizes of source and target dimensionalities.
+        out_channels (int): Size of each output sample.
+        heads (int, optional): Number of multi-head-attentions.
+            (default: :obj:`1`)
+        concat (bool, optional): If set to :obj:`False`, the multi-head
+            attentions are averaged instead of concatenated.
+            (default: :obj:`True`)
+        negative_slope (float, optional): LeakyReLU angle of the negative
+            slope. (default: :obj:`0.2`)
+        dropout (float, optional): Dropout probability of the normalized
+            attention coefficients which exposes each node to a stochastically
+            sampled neighborhood during training. (default: :obj:`0`)
+        add_self_loops (bool, optional): If set to :obj:`False`, will not add
+            self-loops to the input graph. (default: :obj:`True`)
+        bias (bool, optional): If set to :obj:`False`, the layer will not learn
+            an additive bias. (default: :obj:`True`)
+        **kwargs (optional): Additional arguments of
+            :class:`torch_geometric.nn.conv.MessagePassing`.
+    """
+    _alpha: OptTensor
+
+    def __init__(self, in_channels: Union[int, Tuple[int, int]],
+                 out_channels: int, heads: int = 1, concat: bool = True,
+                 negative_slope: float = 0.2, dropout: float = 0.,
+                 add_self_loops: bool = True, bias: bool = True, **kwargs):
+        kwargs.setdefault('aggr', 'add')
+        super(GATConv, self).__init__(node_dim=0, **kwargs)
+
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.heads = heads
+        self.concat = concat
+        self.negative_slope = negative_slope
+        self.dropout = dropout
+        self.add_self_loops = add_self_loops
+
+        if isinstance(in_channels, int):
+            self.lin_l = Linear(in_channels, heads * out_channels, bias=False)
+            self.lin_r = self.lin_l
+        else:
+            self.lin_l = Linear(in_channels[0], heads * out_channels, False)
+            self.lin_r = Linear(in_channels[1], heads * out_channels, False)
+
+        self.att_l = Parameter(torch.Tensor(1, heads, out_channels))
+        self.att_r = Parameter(torch.Tensor(1, heads, out_channels))
+
+        if bias and concat:
+            self.bias = Parameter(torch.Tensor(heads * out_channels))
+        elif bias and not concat:
+            self.bias = Parameter(torch.Tensor(out_channels))
+        else:
+            self.register_parameter('bias', None)
+
+        self._alpha = None
+
+        self.reset_parameters()
+        self.edge_weight = None
+
+    def reset_parameters(self):
+        glorot(self.lin_l.weight)
+        glorot(self.lin_r.weight)
+        glorot(self.att_l)
+        glorot(self.att_r)
+        zeros(self.bias)
+
+    def forward(self, x: Union[Tensor, OptPairTensor], edge_index: Adj, edge_weight=None,
+                size: Size = None, return_attention_weights=None):
+        # type: (Union[Tensor, OptPairTensor], Tensor, Size, NoneType) -> Tensor  # noqa
+        # type: (Union[Tensor, OptPairTensor], SparseTensor, Size, NoneType) -> Tensor  # noqa
+        # type: (Union[Tensor, OptPairTensor], Tensor, Size, bool) -> Tuple[Tensor, Tuple[Tensor, Tensor]]  # noqa
+        # type: (Union[Tensor, OptPairTensor], SparseTensor, Size, bool) -> Tuple[Tensor, SparseTensor]  # noqa
+        r"""
+
+        Args:
+            return_attention_weights (bool, optional): If set to :obj:`True`,
+                will additionally return the tuple
+                :obj:`(edge_index, attention_weights)`, holding the computed
+                attention weights for each edge. (default: :obj:`None`)
+        """
+        H, C = self.heads, self.out_channels
+
+        x_l: OptTensor = None
+        x_r: OptTensor = None
+        alpha_l: OptTensor = None
+        alpha_r: OptTensor = None
+        if isinstance(x, Tensor):
+            assert x.dim() == 2, 'Static graphs not supported in `GATConv`.'
+            x_l = x_r = self.lin_l(x).view(-1, H, C)
+            alpha_l = (x_l * self.att_l).sum(dim=-1)
+            alpha_r = (x_r * self.att_r).sum(dim=-1)
+        else:
+            x_l, x_r = x[0], x[1]
+            assert x[0].dim() == 2, 'Static graphs not supported in `GATConv`.'
+            x_l = self.lin_l(x_l).view(-1, H, C)
+            alpha_l = (x_l * self.att_l).sum(dim=-1)
+            if x_r is not None:
+                x_r = self.lin_r(x_r).view(-1, H, C)
+                alpha_r = (x_r * self.att_r).sum(dim=-1)
+
+        assert x_l is not None
+        assert alpha_l is not None
+
+        if self.add_self_loops:
+            if isinstance(edge_index, Tensor):
+                num_nodes = x_l.size(0)
+                if x_r is not None:
+                    num_nodes = min(num_nodes, x_r.size(0))
+                if size is not None:
+                    num_nodes = min(size[0], size[1])
+                # edge_index, _ = remove_self_loops(edge_index)
+                # edge_index, _ = add_self_loops(edge_index, num_nodes=num_nodes)
+                edge_index, edge_weight = remove_self_loops(edge_index, edge_weight)
+                edge_index, edge_weight = add_self_loops(edge_index, edge_weight, num_nodes=num_nodes)
+                self.edge_weight = edge_weight
+
+            elif isinstance(edge_index, SparseTensor):
+                edge_index = set_diag(edge_index)
+
+        # propagate_type: (x: OptPairTensor, alpha: OptPairTensor)
+        out = self.propagate(edge_index, x=(x_l, x_r),
+                             alpha=(alpha_l, alpha_r), size=size)
+
+        alpha = self._alpha
+        self._alpha = None
+
+        if self.concat:
+            out = out.view(-1, self.heads * self.out_channels)
+        else:
+            out = out.mean(dim=1)
+
+        if self.bias is not None:
+            out += self.bias
+
+        if isinstance(return_attention_weights, bool):
+            assert alpha is not None
+            if isinstance(edge_index, Tensor):
+                return out, (edge_index, alpha)
+            elif isinstance(edge_index, SparseTensor):
+                return out, edge_index.set_value(alpha, layout='coo')
+        else:
+            return out
+
+    def message(self, x_j: Tensor, alpha_j: Tensor, alpha_i: OptTensor,
+                index: Tensor, ptr: OptTensor,
+                size_i: Optional[int]) -> Tensor:
+        alpha = alpha_j if alpha_i is None else alpha_j + alpha_i
+        alpha = F.leaky_relu(alpha, self.negative_slope)
+        alpha = softmax(alpha, index, ptr, size_i)
+        self._alpha = alpha
+        alpha = F.dropout(alpha, p=self.dropout, training=self.training)
+
+        if self.edge_weight is not None:
+            x_j = self.edge_weight.view(-1, 1, 1) * x_j
+        return x_j * alpha.unsqueeze(-1)
+
+    def __repr__(self):
+        return '{}({}, {}, heads={})'.format(self.__class__.__name__,
+                                             self.in_channels,
+                                             self.out_channels, self.heads)

deeprobust/graph/rl/env.py

@@ -0,0 +1,258 @@
+"""
+    Adversarial Attacks on Neural Networks for Graph Data. ICML 2018.
+        https://arxiv.org/abs/1806.02371
+    Author's Implementation
+       https://github.com/Hanjun-Dai/graph_adversarial_attack
+    This part of code is adopted from the author's implementation (Copyright (c) 2018 Dai, Hanjun and Li, Hui and Tian, Tian and Huang, Xin and Wang, Lin and Zhu, Jun and Song, Le) but modified
+    to be integrated into the repository.
+"""
+
+import os
+import sys
+import numpy as np
+import torch
+import networkx as nx
+import random
+from torch.nn.parameter import Parameter
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from tqdm import tqdm
+from copy import deepcopy
+import pickle as cp
+from deeprobust.graph.utils import *
+import scipy.sparse as sp
+from scipy.sparse.linalg import eigsh
+from deeprobust.graph import utils
+
+class StaticGraph(object):
+    graph = None
+
+    @staticmethod
+    def get_gsize():
+        return torch.Size( (len(StaticGraph.graph), len(StaticGraph.graph)) )
+
+class GraphNormTool(object):
+
+    def __init__(self, normalize, gm, device):
+        self.adj_norm = normalize
+        self.gm = gm
+        g = StaticGraph.graph
+        edges = np.array(g.edges(), dtype=np.int64)
+        rev_edges = np.array([edges[:, 1], edges[:, 0]], dtype=np.int64)
+
+        # self_edges = np.array([range(len(g)), range(len(g))], dtype=np.int64)
+        # edges = np.hstack((edges.T, rev_edges, self_edges))
+        edges = np.hstack((edges.T, rev_edges))
+        idxes = torch.LongTensor(edges)
+        values = torch.ones(idxes.size()[1])
+
+        self.raw_adj = torch.sparse.FloatTensor(idxes, values, StaticGraph.get_gsize())
+        self.raw_adj = self.raw_adj.to(device)
+
+        self.normed_adj = self.raw_adj.clone()
+        if self.adj_norm:
+            if self.gm == 'gcn':
+                self.normed_adj = utils.normalize_adj_tensor(self.normed_adj, sparse=True)
+                # GraphLaplacianNorm(self.normed_adj)
+            else:
+
+                self.normed_adj = utils.degree_normalize_adj_tensor(self.normed_adj, sparse=True)
+                # GraphDegreeNorm(self.normed_adj)
+
+    def norm_extra(self, added_adj = None):
+        if added_adj is None:
+            return self.normed_adj
+
+        new_adj = self.raw_adj + added_adj
+        if self.adj_norm:
+            if self.gm == 'gcn':
+                new_adj = utils.normalize_adj_tensor(new_adj, sparse=True)
+            else:
+                new_adj = utils.degree_normalize_adj_tensor(new_adj, sparse=True)
+
+        return new_adj
+
+
+class ModifiedGraph(object):
+
+    def __init__(self, directed_edges = None, weights = None):
+        self.edge_set = set()  #(first, second)
+        self.node_set = set(range(StaticGraph.get_gsize()[0]))
+        self.node_set = np.arange(StaticGraph.get_gsize()[0])
+        if directed_edges is not None:
+            self.directed_edges = deepcopy(directed_edges)
+            self.weights = deepcopy(weights)
+        else:
+            self.directed_edges = []
+            self.weights = []
+
+    def add_edge(self, x, y, z):
+        assert x is not None and y is not None
+        if x == y:
+            return
+        for e in self.directed_edges:
+            if e[0] == x and e[1] == y:
+                return
+            if e[1] == x and e[0] == y:
+                return
+        self.edge_set.add((x, y)) # (first, second)
+        self.edge_set.add((y, x)) # (second, first)
+        self.directed_edges.append((x, y))
+        # assert z < 0
+        self.weights.append(z)
+
+    def get_extra_adj(self, device):
+        if len(self.directed_edges):
+            edges = np.array(self.directed_edges, dtype=np.int64)
+            rev_edges = np.array([edges[:, 1], edges[:, 0]], dtype=np.int64)
+            edges = np.hstack((edges.T, rev_edges))
+
+            idxes = torch.LongTensor(edges)
+            values = torch.Tensor(self.weights + self.weights)
+
+            added_adj = torch.sparse.FloatTensor(idxes, values, StaticGraph.get_gsize())
+
+            added_adj = added_adj.to(device)
+            return added_adj
+        else:
+            return None
+
+    def get_possible_nodes(self, target_node):
+        # connected = set()
+        connected = [target_node]
+        for n1, n2 in self.edge_set:
+            if n1 == target_node:
+                # connected.add(target_node)
+                connected.append(n2)
+        return np.setdiff1d(self.node_set, np.array(connected))
+
+        # return self.node_set - connected
+
+class NodeAttackEnv(object):
+    """Node attack environment. It executes an action and then change the
+    environment status (modify the graph).
+    """
+
+    def __init__(self, features, labels, all_targets, list_action_space, classifier, num_mod=1, reward_type='binary'):
+
+        self.classifier = classifier
+        self.list_action_space = list_action_space
+        self.features = features
+        self.labels = labels
+        self.all_targets = all_targets
+        self.num_mod = num_mod
+        self.reward_type = reward_type
+
+    def setup(self, target_nodes):
+        self.target_nodes = target_nodes
+        self.n_steps = 0
+        self.first_nodes = None
+        self.rewards = None
+        self.binary_rewards = None
+        self.modified_list = []
+        for i in range(len(self.target_nodes)):
+            self.modified_list.append(ModifiedGraph())
+
+        self.list_acc_of_all = []
+
+    def step(self, actions):
+        """run actions and get rewards
+        """
+        if self.first_nodes is None: # pick the first node of edge
+            assert self.n_steps % 2 == 0
+            self.first_nodes = actions[:]
+        else:
+            for i in range(len(self.target_nodes)):
+                # assert self.first_nodes[i] != actions[i]
+                # deleta an edge from the graph
+                self.modified_list[i].add_edge(self.first_nodes[i], actions[i], -1.0)
+            self.first_nodes = None
+            self.banned_list = None
+        self.n_steps += 1
+
+        if self.isTerminal():
+            # only calc reward when its terminal
+            acc_list = []
+            loss_list = []
+            # for i in tqdm(range(len(self.target_nodes))):
+            for i in (range(len(self.target_nodes))):
+                device = self.labels.device
+                extra_adj = self.modified_list[i].get_extra_adj(device=device)
+                adj = self.classifier.norm_tool.norm_extra(extra_adj)
+
+                output = self.classifier(self.features, adj)
+
+                loss, acc = loss_acc(output, self.labels, self.all_targets, avg_loss=False)
+                # _, loss, acc = self.classifier(self.features, Variable(adj), self.all_targets, self.labels, avg_loss=False)
+
+                cur_idx = self.all_targets.index(self.target_nodes[i])
+                acc = np.copy(acc.double().cpu().view(-1).numpy())
+                loss = loss.data.cpu().view(-1).numpy()
+                self.list_acc_of_all.append(acc)
+                acc_list.append(acc[cur_idx])
+                loss_list.append(loss[cur_idx])
+
+            self.binary_rewards = (np.array(acc_list) * -2.0 + 1.0).astype(np.float32)
+            if self.reward_type == 'binary':
+                self.rewards = (np.array(acc_list) * -2.0 + 1.0).astype(np.float32)
+            else:
+                assert self.reward_type == 'nll'
+                self.rewards = np.array(loss_list).astype(np.float32)
+
+    def sample_pos_rewards(self, num_samples):
+        assert self.list_acc_of_all is not None
+        cands = []
+
+        for i in range(len(self.list_acc_of_all)):
+            succ = np.where( self.list_acc_of_all[i] < 0.9 )[0]
+
+            for j in range(len(succ)):
+
+                cands.append((i, self.all_targets[succ[j]]))
+
+        if num_samples > len(cands):
+            return cands
+        random.shuffle(cands)
+        return cands[0:num_samples]
+
+    def uniformRandActions(self):
+        # TODO: here only support deleting edges
+        # seems they sample first node from 2-hop neighbours
+        act_list = []
+        offset = 0
+        for i in range(len(self.target_nodes)):
+            cur_node = self.target_nodes[i]
+            region = self.list_action_space[cur_node]
+
+            if self.first_nodes is not None and self.first_nodes[i] is not None:
+                region = self.list_action_space[self.first_nodes[i]]
+
+            if region is None:  # singleton node
+                cur_action = np.random.randint(len(self.list_action_space))
+            else: # select from neighbours or 2-hop neighbours
+                cur_action = region[np.random.randint(len(region))]
+
+            act_list.append(cur_action)
+        return act_list
+
+    def isTerminal(self):
+        if self.n_steps == 2 * self.num_mod:
+            return True
+        return False
+
+    def getStateRef(self):
+        cp_first = [None] * len(self.target_nodes)
+        if self.first_nodes is not None:
+            cp_first = self.first_nodes
+
+        return zip(self.target_nodes, self.modified_list, cp_first)
+
+    def cloneState(self):
+        cp_first = [None] * len(self.target_nodes)
+        if self.first_nodes is not None:
+            cp_first = self.first_nodes[:]
+
+        return list(zip(self.target_nodes[:], deepcopy(self.modified_list), cp_first))
+
+

deeprobust/graph/rl/q_net_node.py

@@ -0,0 +1,228 @@
+'''
+    Adversarial Attacks on Neural Networks for Graph Data. ICML 2018.
+        https://arxiv.org/abs/1806.02371
+    Author's Implementation
+       https://github.com/Hanjun-Dai/graph_adversarial_attack
+    This part of code is adopted from the author's implementation (Copyright (c) 2018 Dai, Hanjun and Li, Hui and Tian, Tian and Huang, Xin and Wang, Lin and Zhu, Jun and Song, Le) but modified
+    to be integrated into the repository.
+'''
+import os
+import sys
+import numpy as np
+import torch
+import networkx as nx
+import random
+from torch.nn.parameter import Parameter
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.optim as optim
+from tqdm import tqdm
+from deeprobust.graph.rl.env import GraphNormTool
+
+class QNetNode(nn.Module):
+
+    def __init__(self, node_features, node_labels, list_action_space, bilin_q=1, embed_dim=64, mlp_hidden=64, max_lv=1, gm='mean_field', device='cpu'):
+        '''
+        bilin_q: bilinear q or not
+        mlp_hidden: mlp hidden layer size
+        mav_lv: max rounds of message passing
+        '''
+        super(QNetNode, self).__init__()
+        self.node_features = node_features
+        self.node_labels = node_labels
+        self.list_action_space = list_action_space
+        self.total_nodes = len(list_action_space)
+
+        self.bilin_q = bilin_q
+        self.embed_dim = embed_dim
+        self.mlp_hidden = mlp_hidden
+        self.max_lv = max_lv
+        self.gm = gm
+
+        if bilin_q:
+            last_wout = embed_dim
+        else:
+            last_wout = 1
+            self.bias_target = Parameter(torch.Tensor(1, embed_dim))
+
+        if mlp_hidden:
+            self.linear_1 = nn.Linear(embed_dim * 2, mlp_hidden)
+            self.linear_out = nn.Linear(mlp_hidden, last_wout)
+        else:
+            self.linear_out = nn.Linear(embed_dim * 2, last_wout)
+
+        self.w_n2l = Parameter(torch.Tensor(node_features.size()[1], embed_dim))
+        self.bias_n2l = Parameter(torch.Tensor(embed_dim))
+        self.bias_picked = Parameter(torch.Tensor(1, embed_dim))
+        self.conv_params = nn.Linear(embed_dim, embed_dim)
+        self.norm_tool = GraphNormTool(normalize=True, gm=self.gm, device=device)
+        weights_init(self)
+
+    def make_spmat(self, n_rows, n_cols, row_idx, col_idx):
+        idxes = torch.LongTensor([[row_idx], [col_idx]])
+        values = torch.ones(1)
+
+        sp = torch.sparse.FloatTensor(idxes, values, torch.Size([n_rows, n_cols]))
+        if next(self.parameters()).is_cuda:
+            sp = sp.cuda()
+        return sp
+
+    def forward(self, time_t, states, actions, greedy_acts=False, is_inference=False):
+
+        if self.node_features.data.is_sparse:
+            input_node_linear = torch.spmm(self.node_features, self.w_n2l)
+        else:
+            input_node_linear = torch.mm(self.node_features, self.w_n2l)
+
+        input_node_linear += self.bias_n2l
+
+        # TODO the number of target nodes is batch_size, it actually parallizes
+        target_nodes, batch_graph, picked_nodes = zip(*states)
+
+        list_pred = []
+        prefix_sum = []
+        for i in range(len(batch_graph)):
+            region = self.list_action_space[target_nodes[i]]
+
+            node_embed = input_node_linear.clone()
+            if picked_nodes is not None and picked_nodes[i] is not None:
+                with torch.set_grad_enabled(mode=not is_inference):
+                    picked_sp =  self.make_spmat(self.total_nodes, 1, picked_nodes[i], 0)
+                    node_embed += torch.spmm(picked_sp, self.bias_picked)
+                    region = self.list_action_space[picked_nodes[i]]
+
+            if not self.bilin_q:
+                with torch.set_grad_enabled(mode=not is_inference):
+                # with torch.no_grad():
+                    target_sp = self.make_spmat(self.total_nodes, 1, target_nodes[i], 0)
+                    node_embed += torch.spmm(target_sp, self.bias_target)
+
+            with torch.set_grad_enabled(mode=not is_inference):
+                device = self.node_features.device
+                adj = self.norm_tool.norm_extra( batch_graph[i].get_extra_adj(device))
+
+                lv = 0
+                input_message = node_embed
+
+                node_embed = F.relu(input_message)
+                while lv < self.max_lv:
+                    n2npool = torch.spmm(adj, node_embed)
+                    node_linear = self.conv_params( n2npool )
+                    merged_linear = node_linear + input_message
+                    node_embed = F.relu(merged_linear)
+                    lv += 1
+
+                target_embed = node_embed[target_nodes[i], :].view(-1, 1)
+                if region is not None:
+                    node_embed = node_embed[region]
+
+                graph_embed = torch.mean(node_embed, dim=0, keepdim=True)
+
+                if actions is None:
+                    graph_embed = graph_embed.repeat(node_embed.size()[0], 1)
+                else:
+                    if region is not None:
+                        act_idx = region.index(actions[i])
+                    else:
+                        act_idx = actions[i]
+                    node_embed = node_embed[act_idx, :].view(1, -1)
+
+                embed_s_a = torch.cat((node_embed, graph_embed), dim=1)
+                if self.mlp_hidden:
+                    embed_s_a = F.relu( self.linear_1(embed_s_a) )
+                raw_pred = self.linear_out(embed_s_a)
+
+                if self.bilin_q:
+                    raw_pred = torch.mm(raw_pred, target_embed)
+                list_pred.append(raw_pred)
+
+        if greedy_acts:
+            actions, _ = node_greedy_actions(target_nodes, picked_nodes, list_pred, self)
+
+        return actions, list_pred
+
+class NStepQNetNode(nn.Module):
+
+    def __init__(self, num_steps, node_features, node_labels, list_action_space, bilin_q=1, embed_dim=64, mlp_hidden=64, max_lv=1, gm='mean_field', device='cpu'):
+
+        super(NStepQNetNode, self).__init__()
+        self.node_features = node_features
+        self.node_labels = node_labels
+        self.list_action_space = list_action_space
+        self.total_nodes = len(list_action_space)
+
+        list_mod = []
+        for i in range(0, num_steps):
+            # list_mod.append(QNetNode(node_features, node_labels, list_action_space))
+            list_mod.append(QNetNode(node_features, node_labels, list_action_space, bilin_q, embed_dim, mlp_hidden, max_lv, gm=gm, device=device))
+
+        self.list_mod = nn.ModuleList(list_mod)
+        self.num_steps = num_steps
+
+    def forward(self, time_t, states, actions, greedy_acts = False, is_inference=False):
+        assert time_t >= 0 and time_t < self.num_steps
+
+        return self.list_mod[time_t](time_t, states, actions, greedy_acts, is_inference)
+
+
+def glorot_uniform(t):
+    if len(t.size()) == 2:
+        fan_in, fan_out = t.size()
+    elif len(t.size()) == 3:
+        # out_ch, in_ch, kernel for Conv 1
+        fan_in = t.size()[1] * t.size()[2]
+        fan_out = t.size()[0] * t.size()[2]
+    else:
+        fan_in = np.prod(t.size())
+        fan_out = np.prod(t.size())
+
+    limit = np.sqrt(6.0 / (fan_in + fan_out))
+    t.uniform_(-limit, limit)
+
+
+def _param_init(m):
+    if isinstance(m, Parameter):
+        glorot_uniform(m.data)
+    elif isinstance(m, nn.Linear):
+        m.bias.data.zero_()
+        glorot_uniform(m.weight.data)
+
+def weights_init(m):
+    for p in m.modules():
+        if isinstance(p, nn.ParameterList):
+            for pp in p:
+                _param_init(pp)
+        else:
+            _param_init(p)
+
+    for name, p in m.named_parameters():
+        if not '.' in name: # top-level parameters
+            _param_init(p)
+
+def node_greedy_actions(target_nodes, picked_nodes, list_q, net):
+    assert len(target_nodes) == len(list_q)
+
+    actions = []
+    values = []
+    for i in range(len(target_nodes)):
+        region = net.list_action_space[target_nodes[i]]
+        if picked_nodes is not None and picked_nodes[i] is not None:
+            region = net.list_action_space[picked_nodes[i]]
+        if region is None:
+            assert list_q[i].size()[0] == net.total_nodes
+        else:
+            assert len(region) == list_q[i].size()[0]
+
+        val, act = torch.max(list_q[i], dim=0)
+        values.append(val)
+        if region is not None:
+            act = region[act.data.cpu().numpy()[0]]
+            # act = Variable(torch.LongTensor([act]))
+            act = torch.LongTensor([act])
+            actions.append(act)
+        else:
+            actions.append(act)
+
+    return torch.cat(actions, dim=0).data, torch.cat(values, dim=0).data
+
+

deeprobust/image/evaluation_attack.py

@@ -0,0 +1,226 @@
+import requests
+import torch
+from torchvision import datasets,models,transforms
+import torch.nn.functional as F
+import os
+
+import numpy as np
+import argparse
+import matplotlib.pyplot as plt
+import random
+
+from deeprobust.image import utils
+
+def run_attack(attackmethod, batch_size, batch_num, device, test_loader, random_targeted = False, target_label = -1, **kwargs):
+    test_loss = 0
+    correct = 0
+    samplenum = 1000
+    count = 0
+    classnum = 10
+    for count, (data, target) in enumerate(test_loader):
+        if count == batch_num:
+            break
+        print('batch:{}'.format(count))
+
+        data, target = data.to(device), target.to(device)
+        if(random_targeted == True):
+            r = list(range(0, target)) + list(range(target+1, classnum))
+            target_label = random.choice(r)
+            adv_example = attackmethod.generate(data, target, target_label = target_label, **kwargs)
+
+        elif(target_label >= 0):
+            adv_example = attackmethod.generate(data, target, target_label = target_label, **kwargs)
+
+        else:
+            adv_example = attackmethod.generate(data, target, **kwargs)
+
+        output = model(adv_example)
+        test_loss += F.nll_loss(output, target, reduction='sum').item()  # sum up batch loss
+
+        pred = output.argmax(dim = 1, keepdim = True)  # get the index of the max log-probability.
+
+        correct += pred.eq(target.view_as(pred)).sum().item()
+
+    batch_num = count+1
+    test_loss /= len(test_loader.dataset)
+    print("===== ACCURACY =====")
+    print('Attack Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
+        test_loss, correct, batch_num * batch_size,
+        100. * correct / (batch_num * batch_size)))
+
+def load_net(attack_model, filename, path):
+    if(attack_model == "CNN"):
+        from deeprobust.image.netmodels.CNN import Net
+
+        model = Net()
+    if(attack_model == "ResNet18"):
+        import deeprobust.image.netmodels.resnet as Net
+        model = Net.ResNet18()
+
+    model.load_state_dict(torch.load(path + filename))
+    model.eval()
+    return model
+
+def generate_dataloader(dataset, batch_size):
+    if(dataset == "MNIST"):
+        test_loader = torch.utils.data.DataLoader(
+                        datasets.MNIST('deeprobust/image/data', train = False,
+                        download = True,
+                        transform = transforms.Compose([transforms.ToTensor()])),
+                        batch_size = args.batch_size,
+                        shuffle = True)
+        print("Loading MNIST dataset.")
+
+    elif(dataset == "CIFAR" or args.dataset == 'CIFAR10'):
+        test_loader = torch.utils.data.DataLoader(
+                        datasets.CIFAR10('deeprobust/image/data', train = False,
+                        download = True,
+                        transform = transforms.Compose([transforms.ToTensor()])),
+                        batch_size = args.batch_size,
+                        shuffle = True)
+        classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
+        print("Loading CIFAR10 dataset.")
+
+    elif(dataset == "ImageNet"):
+        test_loader = torch.utils.data.DataLoader(
+                        datasets.CIFAR10('deeprobust/image/data', train=False,
+                        download = True,
+                        transform = transforms.Compose([transforms.ToTensor()])),
+                        batch_size = args.batch_size,
+                        shuffle = True)
+        print("Loading ImageNet dataset.")
+    return test_loader
+
+def parameter_parser():
+    parser = argparse.ArgumentParser(description = "Run attack algorithms.", usage ='Use -h for more information.')
+
+    parser.add_argument("--attack_method",
+                        default = 'PGD',
+                        help = "Choose a attack algorithm from: PGD(default), FGSM, LBFGS, CW, deepfool, onepixel, Nattack")
+    parser.add_argument("--attack_model",
+                        default = "CNN",
+                        help = "Choose network structure from: CNN, ResNet")
+    parser.add_argument("--path",
+                        default = "./trained_models/",
+                        help = "Type the path where the model is saved.")
+    parser.add_argument("--file_name",
+                        default = 'MNIST_CNN_epoch_20.pt',
+                        help = "Type the file_name of the model that is to be attack. The model structure should be matched with the ATTACK_MODEL parameter.")
+    parser.add_argument("--dataset",
+                        default = 'MNIST',
+                        help = "Choose a dataset from: MNIST(default), CIFAR(or CIFAR10), ImageNet")
+    parser.add_argument("--epsilon", type = float, default = 0.3)
+    parser.add_argument("--batch_num", type = int, default = 1000)
+    parser.add_argument("--batch_size", type = int, default = 1000)
+    parser.add_argument("--num_steps", type = int, default = 40)
+    parser.add_argument("--step_size", type = float, default = 0.01)
+    parser.add_argument("--random_targeted", type = bool, default = False,
+                        help = "default: False. By setting this parameter be True, the program would random generate target labels for the input samples.")
+    parser.add_argument("--target_label", type = int, default = -1,
+                        help = "default: -1. Generate all attack Fixed target label.")
+    parser.add_argument("--device", default = 'cuda',
+                        help = "Choose the device.")
+
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    # read arguments
+    args = parameter_parser() # read argument and creat an argparse object
+
+    # download example model
+    example_model_path = './trained_models/MNIST_CNN_epoch_20.pt'
+    if not (os.path.exists('./trained_models')):
+        os.mkdir('./trained_models')
+        print('create path: ./trained_models')
+    model_url = "https://github.com/I-am-Bot/deeprobust_trained_model/blob/master/MNIST_CNN_epoch_20.pt?raw=true"
+    r = requests.get(model_url)
+    print('Downloading example model...')
+    with open(example_model_path,'wb') as f:
+        f.write(r.content)
+    print('Downloaded.')
+    # load model
+    model = load_net(args.attack_model, args.file_name, args.path)
+
+    print("===== START ATTACK =====")
+    if(args.attack_method == "PGD"):
+        from deeprobust.image.attack.pgd import PGD
+        test_loader = generate_dataloader(args.dataset, args.batch_size)
+        attack_method = PGD(model, args.device)
+        utils.tab_printer(args)
+        run_attack(attack_method, args.batch_size, args.batch_num, args.device, test_loader, epsilon = args.epsilon)
+
+    elif(args.attack_method == "FGSM"):
+        from deeprobust.image.attack.fgsm import FGSM
+        test_loader = generate_dataloader(args.dataset, args.batch_size)
+        attack_method = FGSM(model, args.device)
+        utils.tab_printer(args)
+        run_attack(attack_method, args.batch_size, args.batch_num, args.device, test_loader, epsilon = args.epsilon)
+
+    elif(args.attack_method == "LBFGS"):
+        from deeprobust.image.attack.lbfgs import LBFGS
+        try:
+            if (args.batch_size >1):
+                raise ValueError("batch_size shouldn't be larger than 1.")
+        except ValueError:
+            args.batch_size = 1
+
+        try:
+            if (args.random_targeted == 0 and args.target_label == -1):
+                raise ValueError("No target label assigned. Random generate target for each input.")
+        except ValueError:
+            args.random_targeted = True
+
+        utils.tab_printer(args)
+        test_loader = generate_dataloader(args.dataset, args.batch_size)
+        attack_method = LBFGS(model, args.device)
+        run_attack(attack_method, 1, args.batch_num, args.device, test_loader, random_targeted = args.random_targeted, target_label = args.target_label)
+
+    elif(args.attack_method == "CW"):
+        from deeprobust.image.attack.cw import CarliniWagner
+        attack_method = CarliniWagner(model, args.device)
+        try:
+            if (args.batch_size > 1):
+                raise ValueError("batch_size shouldn't be larger than 1.")
+        except ValueError:
+            args.batch_size = 1
+
+        try:
+            if (args.random_targeted == 0 and args.target_label == -1):
+                raise ValueError("No target label assigned. Random generate target for each input.")
+        except ValueError:
+            args.random_targeted = True
+
+        utils.tab_printer(args)
+        test_loader = generate_dataloader(args.dataset, args.batch_size)
+        run_attack(attack_method, 1, args.batch_num, args.device, test_loader, random_targeted = args.random_targeted, target_label = args.target_label)
+
+    elif(args.attack_method == "deepfool"):
+        from deeprobust.image.attack.deepfool import DeepFool
+        attack_method = DeepFool(model, args.device)
+        try:
+            if (args.batch_size > 1):
+                raise ValueError("batch_size shouldn't be larger than 1.")
+        except ValueError:
+            args.batch_size = 1
+
+        utils.tab_printer(args)
+        test_loader = generate_dataloader(args.dataset, args.batch_size)
+        run_attack(attack_method, args.batch_size, args.batch_num, args.device, test_loader)
+
+    elif(args.attack_method == "onepixel"):
+        from deeprobust.image.attack.onepixel import Onepixel
+        attack_method = Onepixel(model, args.device)
+        try:
+            if (args.batch_size > 1):
+                raise ValueError("batch_size shouldn't be larger than 1.")
+        except ValueError:
+            args.batch_size = 1
+
+        utils.tab_printer(args)
+        test_loader = generate_dataloader(args.dataset, args.batch_size)
+        run_attack(attack_method, args.batch_size, args.batch_num, args.device, test_loader)
+
+    elif(args.attack_method == "Nattack"):
+        pass
+

deeprobust/image/netmodels/CNN.py

@@ -0,0 +1,125 @@
+"""
+This is an implementatio of a Convolution Neural Network with 2 Convolutional layer.
+"""
+
+from __future__ import print_function
+import argparse
+import torch
+import torch.nn as nn
+import torch.nn.functional as F #233
+import torch.optim as optim
+from torchvision import datasets, transforms
+import numpy as np
+from PIL import Image
+
+class Net(nn.Module):
+    """Model counterparts.
+    """
+
+    def __init__(self, in_channel1 = 1, out_channel1 = 32, out_channel2 = 64, H = 28, W = 28):
+        super(Net, self).__init__()
+        self.H = H
+        self.W = W
+        self.out_channel2 = out_channel2
+
+        ## define two convolutional layers
+        self.conv1 = nn.Conv2d(in_channels = in_channel1,
+                               out_channels = out_channel1,
+                               kernel_size = 5,
+                               stride= 1,
+                               padding = (2,2))
+        self.conv2 = nn.Conv2d(in_channels = out_channel1,
+                               out_channels = out_channel2,
+                               kernel_size = 5,
+                               stride = 1,
+                               padding = (2,2))
+
+        ## define two linear layers
+        self.fc1 = nn.Linear(int(self.H/4) * int(self.W/4) * out_channel2, 1024)
+        self.fc2 = nn.Linear(1024, 10)
+
+    def forward(self, x):
+
+        x = F.relu(self.conv1(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = F.relu(self.conv2(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = x.view(-1, int(self.H/4) * int(self.W/4) * self.out_channel2)
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+        return x
+
+    def get_logits(self, x):
+        x = F.relu(self.conv1(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = F.relu(self.conv2(x))
+        x = F.max_pool2d(x, 2, 2)
+        x = x.view(-1, int(self.H/4) * int(self.W/4) * self.out_channel2)
+        x = F.relu(self.fc1(x))
+        x = self.fc2(x)
+        return x
+
+def train(model, device, train_loader, optimizer, epoch):
+    """train network.
+
+    Parameters
+    ----------
+    model :
+        model
+    device :
+        device(option:'cpu','cuda')
+    train_loader :
+        training data loader
+    optimizer :
+        optimizer
+    epoch :
+        epoch
+    """
+    model.train()
+    for batch_idx, (data, target) in enumerate(train_loader):
+        data, target = data.to(device), target.to(device)
+        optimizer.zero_grad()
+        output = model(data)
+        loss = F.cross_entropy(output, target)
+        loss.backward()
+        optimizer.step()
+
+        #print every 10
+        if batch_idx % 10 == 0:
+            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
+                epoch, batch_idx * len(data), len(train_loader.dataset),
+                       100. * batch_idx / len(train_loader), loss.item()))
+
+
+def test(model, device, test_loader):
+    """test network.
+
+    Parameters
+    ----------
+    model :
+        model
+    device :
+        device(option:'cpu', 'cuda')
+    test_loader :
+        testing data loader
+    """
+    model.eval()
+
+    test_loss = 0
+    correct = 0
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = data.to(device), target.to(device)
+            output = model(data)
+            test_loss += F.cross_entropy(output, target, reduction='sum').item()  # sum up batch loss
+            pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability
+            correct += pred.eq(target.view_as(pred)).sum().item()
+
+    test_loss /= len(test_loader.dataset)
+
+    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
+        test_loss, correct, len(test_loader.dataset),
+        100. * correct / len(test_loader.dataset)))
+
+
+

deeprobust/image/netmodels/CNN_multilayer.py

@@ -0,0 +1,122 @@
+"""
+This is an implementation of Convolution Neural Network with multi conv layer.
+"""
+
+from __future__ import print_function
+import argparse
+import torch
+import torch.nn as nn
+import torch.nn.functional as F #233
+import torch.optim as optim
+from torchvision import datasets, transforms
+import numpy as np
+from PIL import Image
+
+class Net(nn.Module):
+    def __init__(self, in_channel1 = 1, out_channel1 = 32, out_channel2 = 64, H = 28, W = 28):
+        super(Net, self).__init__()
+        self.H = H
+        self.W = W
+        self.out_channel2 = out_channel2
+        
+        ## define two convolutional layers
+        self.conv1 = nn.Conv2d(in_channels = in_channel1,
+                               out_channels = out_channel1,
+                               kernel_size = 5,
+                               stride= 1,
+                               padding = (2,2))
+        self.conv2 = nn.Conv2d(in_channels = out_channel1,
+                               out_channels = out_channel2,
+                               kernel_size = 5,
+                               stride = 1,
+                               padding = (2,2))
+
+        ## define two linear layers
+        self.fc1 = nn.Linear(int(H/4)*int(W/4)* out_channel2, 1024)
+        self.fc2 = nn.Linear(1024, 10)
+
+    def forward(self, x):
+        self.layers[0] = F.relu(self.conv1(x))
+        self.layers[1] = F.max_pool2d(x, 2, 2)
+        self.layers[2] = F.relu(self.conv2(x))
+        self.layers[3] = F.max_pool2d(x, 2, 2)
+        self.layers[4] = x.view(-1, int(self.H/4) * int(self.W/4) * self.out_channel2)
+        self.layers[5] = F.relu(self.fc1(x))
+        self.layers[6] = self.fc2(x)
+        return F.log_softmax(layers[6], dim=1)
+
+    #def get_logits(self, x):
+        #x = F.relu(self.conv1(x))
+        #x = F.max_pool2d(x, 2, 2)
+        #x = F.relu(self.conv2(x))
+        #x = F.max_pool2d(x, 2, 2)
+        #x = x.view(-1, 4* 4 * 50)
+        #x = F.relu(self.fc1(x))
+        #x = self.fc2(x)
+        #return x
+
+
+def train(model, device, train_loader, optimizer, epoch):
+    """train.
+
+    Parameters
+    ----------
+    model :
+        model
+    device :
+        device
+    train_loader :
+        train_loader
+    optimizer :
+        optimizer
+    epoch :
+        epoch
+    """
+    model.train()
+    for batch_idx, (data, target) in enumerate(train_loader):
+        data, target = data.to(device), target.to(device)
+        optimizer.zero_grad()
+        output = model(data)
+        loss = F.nll_loss(output, target)
+        loss.backward()
+        optimizer.step()
+
+        #print every 10
+        if batch_idx % 10 == 0:
+            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
+                epoch, batch_idx * len(data), len(train_loader.dataset),
+                       100. * batch_idx / len(train_loader), loss.item()))
+
+
+def test(model, device, test_loader):
+    """test.
+
+    Parameters
+    ----------
+    model :
+        model
+    device :
+        device
+    test_loader :
+        test_loader
+    """
+    model.eval()
+
+    test_loss = 0
+    correct = 0
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = data.to(device), target.to(device)
+            output = model(data)
+            test_loss += F.nll_loss(output, target, reduction='sum').item()  # sum up batch loss
+            pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability
+            correct += pred.eq(target.view_as(pred)).sum().item()
+
+    test_loss /= len(test_loader.dataset)
+
+    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
+        test_loss, correct, len(test_loader.dataset),
+        100. * correct / len(test_loader.dataset)))
+
+
+

deeprobust/image/netmodels/YOPOCNN.py

@@ -0,0 +1,70 @@
+"""
+Model for YOPO.
+
+Reference
+---------
+..[1]https://github.com/a1600012888/YOPO-You-Only-Propagate-Once
+
+"""
+
+from collections import OrderedDict
+import torch.nn as nn
+
+
+class Net(nn.Module):
+    def __init__(self, drop=0.5):
+        super(Net, self).__init__()
+
+        self.num_channels = 1
+        self.num_labels = 10
+
+        activ = nn.ReLU(True)
+        self.conv1 = nn.Conv2d(self.num_channels, 32, 3)
+        self.layer_one = nn.Sequential(OrderedDict([
+            ('conv1', self.conv1),
+            ('relu1', activ),]))
+
+        self.feature_extractor = nn.Sequential(OrderedDict([
+            ('conv2', nn.Conv2d(32, 32, 3)),
+            ('relu2', activ),
+            ('maxpool1', nn.MaxPool2d(2, 2)),
+            ('conv3', nn.Conv2d(32, 64, 3)),
+            ('relu3', activ),
+            ('conv4', nn.Conv2d(64, 64, 3)),
+            ('relu4', activ),
+            ('maxpool2', nn.MaxPool2d(2, 2)),
+        ]))
+
+        self.classifier = nn.Sequential(OrderedDict([
+            ('fc1', nn.Linear(64 * 4 * 4, 200)),
+            ('relu1', activ),
+            ('drop', nn.Dropout(drop)),
+            ('fc2', nn.Linear(200, 200)),
+            ('relu2', activ),
+            ('fc3', nn.Linear(200, self.num_labels)),
+        ]))
+        self.other_layers = nn.ModuleList()
+        self.other_layers.append(self.feature_extractor)
+        self.other_layers.append(self.classifier)
+
+        for m in self.modules():
+            if isinstance(m, (nn.Conv2d)):
+                nn.init.kaiming_normal_(m.weight)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+            elif isinstance(m, nn.BatchNorm2d):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+        nn.init.constant_(self.classifier.fc3.weight, 0)
+        nn.init.constant_(self.classifier.fc3.bias, 0)
+
+    def forward(self, input):
+        y = self.layer_one(input)
+        self.layer_one_out = y
+        self.layer_one_out.requires_grad_()
+        self.layer_one_out.retain_grad()
+        features = self.feature_extractor(y)
+        logits = self.classifier(features.view(-1, 64 * 4 * 4))
+        return logits
+
+

deeprobust/image/netmodels/resnet.py

@@ -0,0 +1,168 @@
+'''
+Properly implemented ResNet-s for CIFAR10 as described in paper [1].
+
+This implementation is from Yerlan Idelbayev.
+
+Reference
+---------
+..[1] Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
+    Deep Residual Learning for Image Recognition. arXiv:1512.03385
+..[2] https://github.com/pytorch/vision/blob/master/torchvision/models/resnet.py
+
+'''
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class BasicBlock(nn.Module):
+    expansion = 1
+
+    def __init__(self, in_planes, planes, stride=1):
+        super(BasicBlock, self).__init__()
+        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_planes != self.expansion*planes:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(self.expansion*planes)
+            )
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.bn2(self.conv2(out))
+        out += self.shortcut(x)
+        out = F.relu(out)
+        return out
+
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, in_planes, planes, stride=1):
+        super(Bottleneck, self).__init__()
+        self.conv1 = nn.Conv2d(in_planes, planes, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(planes)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(planes)
+        self.conv3 = nn.Conv2d(planes, self.expansion*planes, kernel_size=1, bias=False)
+        self.bn3 = nn.BatchNorm2d(self.expansion*planes)
+
+        self.shortcut = nn.Sequential()
+        if stride != 1 or in_planes != self.expansion*planes:
+            self.shortcut = nn.Sequential(
+                nn.Conv2d(in_planes, self.expansion*planes, kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm2d(self.expansion*planes)
+            )
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = F.relu(self.bn2(self.conv2(out)))
+        out = self.bn3(self.conv3(out))
+        out += self.shortcut(x)
+        out = F.relu(out)
+        return out
+
+
+class Net(nn.Module):
+    def __init__(self, block, num_blocks, num_classes=10):
+        """__init__.
+
+        Parameters
+        ----------
+        block :
+            block
+        num_blocks :
+            num_blocks
+        num_classes :
+            num_classes
+        """
+        super(Net, self).__init__()
+        self.in_planes = 64
+
+        self.conv1 = nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(64)
+        self.layer1 = self._make_layer(block, 64, num_blocks[0], stride=1)
+        self.layer2 = self._make_layer(block, 128, num_blocks[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, num_blocks[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, num_blocks[3], stride=2)
+        self.linear = nn.Linear(512*block.expansion, num_classes)
+
+    def _make_layer(self, block, planes, num_blocks, stride):
+        strides = [stride] + [1]*(num_blocks-1)
+        layers = []
+        for stride in strides:
+            layers.append(block(self.in_planes, planes, stride))
+            self.in_planes = planes * block.expansion
+        return nn.Sequential(*layers)
+
+    def forward(self, x):
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.layer1(out)
+        out = self.layer2(out)
+        out = self.layer3(out)
+        out = self.layer4(out)
+        out = F.avg_pool2d(out, 4)
+        out = out.view(out.size(0), -1)
+        out = self.linear(out)
+        return out
+
+
+def ResNet18():
+    return Net(BasicBlock, [2,2,2,2])
+
+def ResNet34():
+    return Net(BasicBlock, [3,4,6,3])
+
+def ResNet50():
+    return Net(Bottleneck, [3,4,6,3])
+
+def ResNet101():
+    return Net(Bottleneck, [3,4,23,3])
+
+def ResNet152():
+    return Net(Bottleneck, [3,8,36,3])
+
+
+def test(model, device, test_loader):
+    model.eval()
+
+    test_loss = 0
+    correct = 0
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = data.to(device), target.to(device)
+            output = model(data)
+            #test_loss += F.nll_loss(output, target, reduction='sum').item()  # sum up batch loss
+            loss = F.cross_entropy(output, target)
+            pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability
+            correct += pred.eq(target.view_as(pred)).sum().item()
+
+    test_loss /= len(test_loader.dataset)
+
+    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
+        test_loss, correct, len(test_loader.dataset),
+        100. * correct / len(test_loader.dataset)))
+
+def train(model, device, train_loader, optimizer, epoch):
+    model.train()
+
+    # lr = util.adjust_learning_rate(optimizer, epoch, args) # don't need it if we use Adam
+
+    for batch_idx, (data, target) in enumerate(train_loader):
+        data, target = torch.tensor(data).to(device), torch.tensor(target).to(device)
+        optimizer.zero_grad()
+        output = model(data)
+        # loss = F.nll_loss(output, target)
+        loss = F.cross_entropy(output, target)
+        loss.backward()
+        optimizer.step()
+        if batch_idx % 10 == 0:
+            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
+                epoch, batch_idx * len(data), len(train_loader.dataset),
+                100. * batch_idx / len(train_loader), loss.item()))

deeprobust/image/netmodels/train_model.py

@@ -0,0 +1,146 @@
+"""
+This function help to train model of different archtecture easily. Select model archtecture and training data, then output corresponding model.
+
+"""
+from __future__ import print_function
+import os
+import argparse
+import torch
+import torch.nn as nn
+import torch.nn.functional as F #233
+import torch.optim as optim
+from torchvision import datasets, transforms
+import numpy as np
+from PIL import Image
+
+def train(model, data, device, maxepoch, data_path = './', save_per_epoch = 10, seed = 100):
+    """train.
+
+    Parameters
+    ----------
+    model :
+        model(option:'CNN', 'ResNet18', 'ResNet34', 'ResNet50', 'densenet', 'vgg11', 'vgg13', 'vgg16', 'vgg19')
+    data :
+        data(option:'MNIST','CIFAR10')
+    device :
+        device(option:'cpu', 'cuda')
+    maxepoch :
+        training epoch
+    data_path :
+        data path(default = './')
+    save_per_epoch :
+        save_per_epoch(default = 10)
+    seed :
+        seed
+
+    Examples
+    --------
+    >>>import deeprobust.image.netmodels.train_model as trainmodel
+    >>>trainmodel.train('CNN', 'MNIST', 'cuda', 20)
+    """
+
+    torch.manual_seed(seed)
+
+    train_loader, test_loader = feed_dataset(data, data_path)
+
+    if (model == 'CNN'):
+        import deeprobust.image.netmodels.CNN as MODEL
+        #from deeprobust.image.netmodels.CNN import Net
+        train_net = MODEL.Net().to(device)
+
+    elif (model == 'ResNet18'):
+        import deeprobust.image.netmodels.resnet as MODEL
+        train_net = MODEL.ResNet18().to(device)
+
+    elif (model == 'ResNet34'):
+        import deeprobust.image.netmodels.resnet as MODEL
+        train_net = MODEL.ResNet34().to(device)
+
+    elif (model == 'ResNet50'):
+        import deeprobust.image.netmodels.resnet as MODEL
+        train_net = MODEL.ResNet50().to(device)
+
+    elif (model == 'densenet'):
+        import deeprobust.image.netmodels.densenet as MODEL
+        train_net = MODEL.densenet_cifar().to(device)
+
+    elif (model == 'vgg11'):
+        import deeprobust.image.netmodels.vgg as MODEL
+        train_net = MODEL.VGG('VGG11').to(device)
+    elif (model == 'vgg13'):
+        import deeprobust.image.netmodels.vgg as MODEL
+        train_net = MODEL.VGG('VGG13').to(device)
+    elif (model == 'vgg16'):
+        import deeprobust.image.netmodels.vgg as MODEL
+        train_net = MODEL.VGG('VGG16').to(device)
+    elif (model == 'vgg19'):
+        import deeprobust.image.netmodels.vgg as MODEL
+        train_net = MODEL.VGG('VGG19').to(device)
+
+
+
+    optimizer = optim.SGD(train_net.parameters(), lr= 0.1, momentum=0.5)
+    scheduler = optim.lr_scheduler.StepLR(optimizer, step_size = 100, gamma = 0.1)
+    save_model = True
+    for epoch in range(1, maxepoch + 1):     ## 5 batches
+
+        print(epoch)
+        MODEL.train(train_net, device, train_loader, optimizer, epoch)
+        MODEL.test(train_net, device, test_loader)
+
+        if (save_model and (epoch % (save_per_epoch) == 0 or epoch == maxepoch)):
+            if os.path.isdir('./trained_models/'):
+                print('Save model.')
+                torch.save(train_net.state_dict(), os.path.join('trained_models', data + "_" + model + "_epoch_" + str(epoch) + ".pt"))
+            else:
+                os.mkdir('./trained_models/')
+                print('Make directory and save model.')
+                torch.save(train_net.state_dict(), os.path.join('trained_models', data + "_" + model + "_epoch_" + str(epoch) + ".pt"))
+        scheduler.step()
+
+def feed_dataset(data, data_dict):
+    if(data == 'CIFAR10'):
+        transform_train = transforms.Compose([
+                transforms.RandomCrop(32, padding=5),
+                transforms.RandomHorizontalFlip(),
+                transforms.ToTensor(),
+                #transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+                ])
+
+        transform_val = transforms.Compose([
+                transforms.ToTensor(),
+                #transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
+                ])
+
+        train_loader = torch.utils.data.DataLoader(
+                 datasets.CIFAR10(data_dict, train=True, download = True,
+                        transform=transform_train),
+                 batch_size= 128, shuffle=True) #, **kwargs)
+
+        test_loader  = torch.utils.data.DataLoader(
+                 datasets.CIFAR10(data_dict, train=False, download = True,
+                        transform=transform_val),
+                batch_size= 1000, shuffle=True) #, **kwargs)
+
+    elif(data == 'MNIST'):
+        train_loader = torch.utils.data.DataLoader(
+                 datasets.MNIST(data_dict, train=True, download = True,
+                 transform=transforms.Compose([transforms.ToTensor(),
+                 transforms.Normalize((0.1307,), (0.3081,))])),
+                 batch_size=128,
+                 shuffle=True)
+
+        test_loader = torch.utils.data.DataLoader(
+                datasets.MNIST(data_dict, train=False, download = True,
+                transform=transforms.Compose([transforms.ToTensor(),
+                transforms.Normalize((0.1307,), (0.3081,))])),
+                batch_size=1000,
+                shuffle=True)
+
+    elif(data == 'ImageNet'):
+        pass
+
+    return train_loader, test_loader
+
+
+

deeprobust/image/netmodels/train_resnet.py

@@ -0,0 +1,39 @@
+from __future__ import print_function
+import argparse
+import torch
+import torch.nn as nn
+import torch.nn.functional as F #233
+import torch.optim as optim
+from torchvision import datasets, transforms
+import numpy as np
+from PIL import Image
+import CNNmodel 
+
+torch.manual_seed(100)
+device = torch.device("cuda")
+
+train_loader = torch.utils.data.DataLoader(
+    datasets.MNIST('../data', train=True, download=True,
+                 transform=transforms.Compose([transforms.ToTensor(),
+                 transforms.Normalize((0.1307,), (0.3081,))])),
+    batch_size=64,
+    shuffle=True)
+
+test_loader = torch.utils.data.DataLoader(
+    datasets.MNIST('../data', train=False,
+                transform=transforms.Compose([transforms.ToTensor(),
+                transforms.Normalize((0.1307,), (0.3081,))])),
+    batch_size=1000,
+    shuffle=True)
+
+model = CNNmodel.Net().to(device)
+optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)
+
+save_model = True
+for epoch in range(1, 5 + 1):     ## 5 batches
+    print(epoch)
+    CNNmodel.train(model, device, train_loader, optimizer, epoch)
+    CNNmodel.test(model, device, test_loader)
+
+    if (save_model):
+        torch.save(model.state_dict(), "mnist_cnn.pt")

deeprobust/image/netmodels/vgg.py

@@ -0,0 +1,116 @@
+"""
+This is an implementation of VGG net.
+
+Reference
+---------
+..[1]Simonyan, Karen, and Andrew Zisserman. "Very deep convolutional networks for large-scale image recognition." arXiv preprint arXiv:1409.1556 (2014).
+..[2]Original implementation: https://github.com/kuangliu/pytorch-cifar
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+cfg = {
+    'VGG11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
+    'VGG13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
+    'VGG16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
+    'VGG19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
+}
+
+
+class VGG(nn.Module):
+    """VGG.
+    """
+
+    def __init__(self, vgg_name):
+        super(VGG, self).__init__()
+        self.features = self._make_layers(cfg[vgg_name])
+        self.classifier = nn.Linear(512, 10)
+
+    def forward(self, x):
+        out = self.features(x)
+        out = out.view(out.size(0), -1)
+        out = self.classifier(out)
+        return out
+
+    def _make_layers(self, cfg):
+        layers = []
+        in_channels = 3
+        for x in cfg:
+            if x == 'M':
+                layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
+            else:
+                layers += [nn.Conv2d(in_channels, x, kernel_size=3, padding=1),
+                           nn.BatchNorm2d(x),
+                           nn.ReLU(inplace=True)]
+                in_channels = x
+        layers += [nn.AvgPool2d(kernel_size=1, stride=1)]
+        return nn.Sequential(*layers)
+
+
+
+def test(model, device, test_loader):
+    """test.
+
+    Parameters
+    ----------
+    model :
+        model
+    device :
+        device
+    test_loader :
+        test_loader
+    """
+    model.eval()
+
+    test_loss = 0
+    correct = 0
+    with torch.no_grad():
+        for data, target in test_loader:
+            data, target = data.to(device), target.to(device)
+            output = model(data)
+            #test_loss += F.nll_loss(output, target, reduction='sum').item()  # sum up batch loss
+
+            test_loss += F.cross_entropy(output, target)
+            pred = output.argmax(dim=1, keepdim=True)  # get the index of the max log-probability
+            correct += pred.eq(target.view_as(pred)).sum().item()
+
+    test_loss /= len(test_loader.dataset)
+
+    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
+        test_loss, correct, len(test_loader.dataset),
+        100. * correct / len(test_loader.dataset)))
+
+def train(model, device, train_loader, optimizer, epoch):
+    """train.
+
+    Parameters
+    ----------
+    model :
+        model
+    device :
+        device
+    train_loader :
+        train_loader
+    optimizer :
+        optimizer
+    epoch :
+        epoch
+    """
+    model.train()
+
+    # lr = util.adjust_learning_rate(optimizer, epoch, args) # don't need it if we use Adam
+
+    for batch_idx, (data, target) in enumerate(train_loader):
+        data, target = torch.tensor(data).to(device), torch.tensor(target).to(device)
+        optimizer.zero_grad()
+        output = model(data)
+        # loss = F.nll_loss(output, target)
+        loss = F.cross_entropy(output, target)
+        loss.backward()
+        optimizer.step()
+        if batch_idx % 10 == 0:
+            print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
+                epoch, batch_idx * len(data), len(train_loader.dataset),
+                100. * batch_idx / len(train_loader), loss.item()/data.shape[0]))

deeprobust/image/synset_words.txt

@@ -0,0 +1,1000 @@
+n01440764 tench, Tinca tinca
+n01443537 goldfish, Carassius auratus
+n01484850 great white shark, white shark, man-eater, man-eating shark, Carcharodon carcharias
+n01491361 tiger shark, Galeocerdo cuvieri
+n01494475 hammerhead, hammerhead shark
+n01496331 electric ray, crampfish, numbfish, torpedo
+n01498041 stingray
+n01514668 cock
+n01514859 hen
+n01518878 ostrich, Struthio camelus
+n01530575 brambling, Fringilla montifringilla
+n01531178 goldfinch, Carduelis carduelis
+n01532829 house finch, linnet, Carpodacus mexicanus
+n01534433 junco, snowbird
+n01537544 indigo bunting, indigo finch, indigo bird, Passerina cyanea
+n01558993 robin, American robin, Turdus migratorius
+n01560419 bulbul
+n01580077 jay
+n01582220 magpie
+n01592084 chickadee
+n01601694 water ouzel, dipper
+n01608432 kite
+n01614925 bald eagle, American eagle, Haliaeetus leucocephalus
+n01616318 vulture
+n01622779 great grey owl, great gray owl, Strix nebulosa
+n01629819 European fire salamander, Salamandra salamandra
+n01630670 common newt, Triturus vulgaris
+n01631663 eft
+n01632458 spotted salamander, Ambystoma maculatum
+n01632777 axolotl, mud puppy, Ambystoma mexicanum
+n01641577 bullfrog, Rana catesbeiana
+n01644373 tree frog, tree-frog
+n01644900 tailed frog, bell toad, ribbed toad, tailed toad, Ascaphus trui
+n01664065 loggerhead, loggerhead turtle, Caretta caretta
+n01665541 leatherback turtle, leatherback, leathery turtle, Dermochelys coriacea
+n01667114 mud turtle
+n01667778 terrapin
+n01669191 box turtle, box tortoise
+n01675722 banded gecko
+n01677366 common iguana, iguana, Iguana iguana
+n01682714 American chameleon, anole, Anolis carolinensis
+n01685808 whiptail, whiptail lizard
+n01687978 agama
+n01688243 frilled lizard, Chlamydosaurus kingi
+n01689811 alligator lizard
+n01692333 Gila monster, Heloderma suspectum
+n01693334 green lizard, Lacerta viridis
+n01694178 African chameleon, Chamaeleo chamaeleon
+n01695060 Komodo dragon, Komodo lizard, dragon lizard, giant lizard, Varanus komodoensis
+n01697457 African crocodile, Nile crocodile, Crocodylus niloticus
+n01698640 American alligator, Alligator mississipiensis
+n01704323 triceratops
+n01728572 thunder snake, worm snake, Carphophis amoenus
+n01728920 ringneck snake, ring-necked snake, ring snake
+n01729322 hognose snake, puff adder, sand viper
+n01729977 green snake, grass snake
+n01734418 king snake, kingsnake
+n01735189 garter snake, grass snake
+n01737021 water snake
+n01739381 vine snake
+n01740131 night snake, Hypsiglena torquata
+n01742172 boa constrictor, Constrictor constrictor
+n01744401 rock python, rock snake, Python sebae
+n01748264 Indian cobra, Naja naja
+n01749939 green mamba
+n01751748 sea snake
+n01753488 horned viper, cerastes, sand viper, horned asp, Cerastes cornutus
+n01755581 diamondback, diamondback rattlesnake, Crotalus adamanteus
+n01756291 sidewinder, horned rattlesnake, Crotalus cerastes
+n01768244 trilobite
+n01770081 harvestman, daddy longlegs, Phalangium opilio
+n01770393 scorpion
+n01773157 black and gold garden spider, Argiope aurantia
+n01773549 barn spider, Araneus cavaticus
+n01773797 garden spider, Aranea diademata
+n01774384 black widow, Latrodectus mactans
+n01774750 tarantula
+n01775062 wolf spider, hunting spider
+n01776313 tick
+n01784675 centipede
+n01795545 black grouse
+n01796340 ptarmigan
+n01797886 ruffed grouse, partridge, Bonasa umbellus
+n01798484 prairie chicken, prairie grouse, prairie fowl
+n01806143 peacock
+n01806567 quail
+n01807496 partridge
+n01817953 African grey, African gray, Psittacus erithacus
+n01818515 macaw
+n01819313 sulphur-crested cockatoo, Kakatoe galerita, Cacatua galerita
+n01820546 lorikeet
+n01824575 coucal
+n01828970 bee eater
+n01829413 hornbill
+n01833805 hummingbird
+n01843065 jacamar
+n01843383 toucan
+n01847000 drake
+n01855032 red-breasted merganser, Mergus serrator
+n01855672 goose
+n01860187 black swan, Cygnus atratus
+n01871265 tusker
+n01872401 echidna, spiny anteater, anteater
+n01873310 platypus, duckbill, duckbilled platypus, duck-billed platypus, Ornithorhynchus anatinus
+n01877812 wallaby, brush kangaroo
+n01882714 koala, koala bear, kangaroo bear, native bear, Phascolarctos cinereus
+n01883070 wombat
+n01910747 jellyfish
+n01914609 sea anemone, anemone
+n01917289 brain coral
+n01924916 flatworm, platyhelminth
+n01930112 nematode, nematode worm, roundworm
+n01943899 conch
+n01944390 snail
+n01945685 slug
+n01950731 sea slug, nudibranch
+n01955084 chiton, coat-of-mail shell, sea cradle, polyplacophore
+n01968897 chambered nautilus, pearly nautilus, nautilus
+n01978287 Dungeness crab, Cancer magister
+n01978455 rock crab, Cancer irroratus
+n01980166 fiddler crab
+n01981276 king crab, Alaska crab, Alaskan king crab, Alaska king crab, Paralithodes camtschatica
+n01983481 American lobster, Northern lobster, Maine lobster, Homarus americanus
+n01984695 spiny lobster, langouste, rock lobster, crawfish, crayfish, sea crawfish
+n01985128 crayfish, crawfish, crawdad, crawdaddy
+n01986214 hermit crab
+n01990800 isopod
+n02002556 white stork, Ciconia ciconia
+n02002724 black stork, Ciconia nigra
+n02006656 spoonbill
+n02007558 flamingo
+n02009229 little blue heron, Egretta caerulea
+n02009912 American egret, great white heron, Egretta albus
+n02011460 bittern
+n02012849 crane
+n02013706 limpkin, Aramus pictus
+n02017213 European gallinule, Porphyrio porphyrio
+n02018207 American coot, marsh hen, mud hen, water hen, Fulica americana
+n02018795 bustard
+n02025239 ruddy turnstone, Arenaria interpres
+n02027492 red-backed sandpiper, dunlin, Erolia alpina
+n02028035 redshank, Tringa totanus
+n02033041 dowitcher
+n02037110 oystercatcher, oyster catcher
+n02051845 pelican
+n02056570 king penguin, Aptenodytes patagonica
+n02058221 albatross, mollymawk
+n02066245 grey whale, gray whale, devilfish, Eschrichtius gibbosus, Eschrichtius robustus
+n02071294 killer whale, killer, orca, grampus, sea wolf, Orcinus orca
+n02074367 dugong, Dugong dugon
+n02077923 sea lion
+n02085620 Chihuahua
+n02085782 Japanese spaniel
+n02085936 Maltese dog, Maltese terrier, Maltese
+n02086079 Pekinese, Pekingese, Peke
+n02086240 Shih-Tzu
+n02086646 Blenheim spaniel
+n02086910 papillon
+n02087046 toy terrier
+n02087394 Rhodesian ridgeback
+n02088094 Afghan hound, Afghan
+n02088238 basset, basset hound
+n02088364 beagle
+n02088466 bloodhound, sleuthhound
+n02088632 bluetick
+n02089078 black-and-tan coonhound
+n02089867 Walker hound, Walker foxhound
+n02089973 English foxhound
+n02090379 redbone
+n02090622 borzoi, Russian wolfhound
+n02090721 Irish wolfhound
+n02091032 Italian greyhound
+n02091134 whippet
+n02091244 Ibizan hound, Ibizan Podenco
+n02091467 Norwegian elkhound, elkhound
+n02091635 otterhound, otter hound
+n02091831 Saluki, gazelle hound
+n02092002 Scottish deerhound, deerhound
+n02092339 Weimaraner
+n02093256 Staffordshire bullterrier, Staffordshire bull terrier
+n02093428 American Staffordshire terrier, Staffordshire terrier, American pit bull terrier, pit bull terrier
+n02093647 Bedlington terrier
+n02093754 Border terrier
+n02093859 Kerry blue terrier
+n02093991 Irish terrier
+n02094114 Norfolk terrier
+n02094258 Norwich terrier
+n02094433 Yorkshire terrier
+n02095314 wire-haired fox terrier
+n02095570 Lakeland terrier
+n02095889 Sealyham terrier, Sealyham
+n02096051 Airedale, Airedale terrier
+n02096177 cairn, cairn terrier
+n02096294 Australian terrier
+n02096437 Dandie Dinmont, Dandie Dinmont terrier
+n02096585 Boston bull, Boston terrier
+n02097047 miniature schnauzer
+n02097130 giant schnauzer
+n02097209 standard schnauzer
+n02097298 Scotch terrier, Scottish terrier, Scottie
+n02097474 Tibetan terrier, chrysanthemum dog
+n02097658 silky terrier, Sydney silky
+n02098105 soft-coated wheaten terrier
+n02098286 West Highland white terrier
+n02098413 Lhasa, Lhasa apso
+n02099267 flat-coated retriever
+n02099429 curly-coated retriever
+n02099601 golden retriever
+n02099712 Labrador retriever
+n02099849 Chesapeake Bay retriever
+n02100236 German short-haired pointer
+n02100583 vizsla, Hungarian pointer
+n02100735 English setter
+n02100877 Irish setter, red setter
+n02101006 Gordon setter
+n02101388 Brittany spaniel
+n02101556 clumber, clumber spaniel
+n02102040 English springer, English springer spaniel
+n02102177 Welsh springer spaniel
+n02102318 cocker spaniel, English cocker spaniel, cocker
+n02102480 Sussex spaniel
+n02102973 Irish water spaniel
+n02104029 kuvasz
+n02104365 schipperke
+n02105056 groenendael
+n02105162 malinois
+n02105251 briard
+n02105412 kelpie
+n02105505 komondor
+n02105641 Old English sheepdog, bobtail
+n02105855 Shetland sheepdog, Shetland sheep dog, Shetland
+n02106030 collie
+n02106166 Border collie
+n02106382 Bouvier des Flandres, Bouviers des Flandres
+n02106550 Rottweiler
+n02106662 German shepherd, German shepherd dog, German police dog, alsatian
+n02107142 Doberman, Doberman pinscher
+n02107312 miniature pinscher
+n02107574 Greater Swiss Mountain dog
+n02107683 Bernese mountain dog
+n02107908 Appenzeller
+n02108000 EntleBucher``^
+n02108089 boxer`
+n02108422 bull mastif
+n02108551 Tibetan mastiff
+n02108915 French bulldog
+n02109047 Great Dane
+n02109525 Saint Bernard, St Bernard
+n02109961 Eskimo dog, husky
+n02110063 malamute, malemute, Alaskan malamute
+n02110185 Siberian husky
+n02110341 dalmatian, coach dog, carriage dog
+n02110627 affenpinscher, monkey pinscher, monkey dog
+n02110806 basenji
+n02110958 pug, pug-dog
+n02111129 Leonberg
+n02111277 Newfoundland, Newfoundland dog
+n02111500 Great Pyrenees
+n02111889 Samoyed, Samoyede
+n02112018 Pomeranian
+n02112137 chow, chow chow
+n02112350 keeshond
+n02112706 Brabancon griffon
+n02113023 Pembroke, Pembroke Welsh corgi
+n02113186 Cardigan, Cardigan Welsh corgi
+n02113624 toy poodle
+n02113712 miniature poodle
+n02113799 standard poodle
+n02113978 Mexican hairless
+n02114367 timber wolf, grey wolf, gray wolf, Canis lupus
+n02114548 white wolf, Arctic wolf, Canis lupus tundrarum
+n02114712 red wolf, maned wolf, Canis rufus, Canis niger
+n02114855 coyote, prairie wolf, brush wolf, Canis latrans
+n02115641 dingo, warrigal, warragal, Canis dingo
+n02115913 dhole, Cuon alpinus
+n02116738 African hunting dog, hyena dog, Cape hunting dog, Lycaon pictus
+n02117135 hyena, hyaena
+n02119022 red fox, Vulpes vulpes
+n02119789 kit fox, Vulpes macrotis
+n02120079 Arctic fox, white fox, Alopex lagopus
+n02120505 grey fox, gray fox, Urocyon cinereoargenteus
+n02123045 tabby, tabby cat
+n02123159 tiger cat
+n02123394 Persian cat
+n02123597 Siamese cat, Siamese
+n02124075 Egyptian cat
+n02125311 cougar, puma, catamount, mountain lion, painter, panther, Felis concolor
+n02127052 lynx, catamount
+n02128385 leopard, Panthera pardus
+n02128757 snow leopard, ounce, Panthera uncia
+n02128925 jaguar, panther, Panthera onca, Felis onca
+n02129165 lion, king of beasts, Panthera leo
+n02129604 tiger, Panthera tigris
+n02130308 cheetah, chetah, Acinonyx jubatus
+n02132136 brown bear, bruin, Ursus arctos
+n02133161 American black bear, black bear, Ursus americanus, Euarctos americanus
+n02134084 ice bear, polar bear, Ursus Maritimus, Thalarctos maritimus
+n02134418 sloth bear, Melursus ursinus, Ursus ursinus
+n02137549 mongoose
+n02138441 meerkat, mierkat
+n02165105 tiger beetle
+n02165456 ladybug, ladybeetle, lady beetle, ladybird, ladybird beetle
+n02167151 ground beetle, carabid beetle
+n02168699 long-horned beetle, longicorn, longicorn beetle
+n02169497 leaf beetle, chrysomelid
+n02172182 dung beetle
+n02174001 rhinoceros beetle
+n02177972 weevil
+n02190166 fly
+n02206856 bee
+n02219486 ant, emmet, pismire
+n02226429 grasshopper, hopper
+n02229544 cricket
+n02231487 walking stick, walkingstick, stick insect
+n02233338 cockroach, roach
+n02236044 mantis, mantid
+n02256656 cicada, cicala
+n02259212 leafhopper
+n02264363 lacewing, lacewing fly
+n02268443 dragonfly, darning needle, devil's darning needle, sewing needle, snake feeder, snake doctor, mosquito hawk, skeeter hawk
+n02268853 damselfly
+n02276258 admiral
+n02277742 ringlet, ringlet butterfly
+n02279972 monarch, monarch butterfly, milkweed butterfly, Danaus plexippus
+n02280649 cabbage butterfly
+n02281406 sulphur butterfly, sulfur butterfly
+n02281787 lycaenid, lycaenid butterfly
+n02317335 starfish, sea star
+n02319095 sea urchin
+n02321529 sea cucumber, holothurian
+n02325366 wood rabbit, cottontail, cottontail rabbit
+n02326432 hare
+n02328150 Angora, Angora rabbit
+n02342885 hamster
+n02346627 porcupine, hedgehog
+n02356798 fox squirrel, eastern fox squirrel, Sciurus niger
+n02361337 marmot
+n02363005 beaver
+n02364673 guinea pig, Cavia cobaya
+n02389026 sorrel
+n02391049 zebra
+n02395406 hog, pig, grunter, squealer, Sus scrofa
+n02396427 wild boar, boar, Sus scrofa
+n02397096 warthog
+n02398521 hippopotamus, hippo, river horse, Hippopotamus amphibius
+n02403003 ox
+n02408429 water buffalo, water ox, Asiatic buffalo, Bubalus bubalis
+n02410509 bison
+n02412080 ram, tup
+n02415577 bighorn, bighorn sheep, cimarron, Rocky Mountain bighorn, Rocky Mountain sheep, Ovis canadensis
+n02417914 ibex, Capra ibex
+n02422106 hartebeest
+n02422699 impala, Aepyceros melampus
+n02423022 gazelle
+n02437312 Arabian camel, dromedary, Camelus dromedarius
+n02437616 llama
+n02441942 weasel
+n02442845 mink
+n02443114 polecat, fitch, foulmart, foumart, Mustela putorius
+n02443484 black-footed ferret, ferret, Mustela nigripes
+n02444819 otter
+n02445715 skunk, polecat, wood pussy
+n02447366 badger
+n02454379 armadillo
+n02457408 three-toed sloth, ai, Bradypus tridactylus
+n02480495 orangutan, orang, orangutang, Pongo pygmaeus
+n02480855 gorilla, Gorilla gorilla
+n02481823 chimpanzee, chimp, Pan troglodytes
+n02483362 gibbon, Hylobates lar
+n02483708 siamang, Hylobates syndactylus, Symphalangus syndactylus
+n02484975 guenon, guenon monkey
+n02486261 patas, hussar monkey, Erythrocebus patas
+n02486410 baboon
+n02487347 macaque
+n02488291 langur
+n02488702 colobus, colobus monkey
+n02489166 proboscis monkey, Nasalis larvatus
+n02490219 marmoset
+n02492035 capuchin, ringtail, Cebus capucinus
+n02492660 howler monkey, howler
+n02493509 titi, titi monkey
+n02493793 spider monkey, Ateles geoffroyi
+n02494079 squirrel monkey, Saimiri sciureus
+n02497673 Madagascar cat, ring-tailed lemur, Lemur catta
+n02500267 indri, indris, Indri indri, Indri brevicaudatus
+n02504013 Indian elephant, Elephas maximus
+n02504458 African elephant, Loxodonta africana
+n02509815 lesser panda, red panda, panda, bear cat, cat bear, Ailurus fulgens
+n02510455 giant panda, panda, panda bear, coon bear, Ailuropoda melanoleuca
+n02514041 barracouta, snoek
+n02526121 eel
+n02536864 coho, cohoe, coho salmon, blue jack, silver salmon, Oncorhynchus kisutch
+n02606052 rock beauty, Holocanthus tricolor
+n02607072 anemone fish
+n02640242 sturgeon
+n02641379 gar, garfish, garpike, billfish, Lepisosteus osseus
+n02643566 lionfish
+n02655020 puffer, pufferfish, blowfish, globefish
+n02666196 abacus
+n02667093 abaya
+n02669723 academic gown, academic robe, judge's robe
+n02672831 accordion, piano accordion, squeeze box
+n02676566 acoustic guitar
+n02687172 aircraft carrier, carrier, flattop, attack aircraft carrier
+n02690373 airliner
+n02692877 airship, dirigible
+n02699494 altar
+n02701002 ambulance
+n02704792 amphibian, amphibious vehicle
+n02708093 analog clock
+n02727426 apiary, bee house
+n02730930 apron
+n02747177 ashcan, trash can, garbage can, wastebin, ash bin, ash-bin, ashbin, dustbin, trash barrel, trash bin
+n02749479 assault rifle, assault gun
+n02769748 backpack, back pack, knapsack, packsack, rucksack, haversack
+n02776631 bakery, bakeshop, bakehouse
+n02777292 balance beam, beam
+n02782093 balloon
+n02783161 ballpoint, ballpoint pen, ballpen, Biro
+n02786058 Band Aid
+n02787622 banjo
+n02788148 bannister, banister, balustrade, balusters, handrail
+n02790996 barbell
+n02791124 barber chair
+n02791270 barbershop
+n02793495 barn
+n02794156 barometer
+n02795169 barrel, cask
+n02797295 barrow, garden cart, lawn cart, wheelbarrow
+n02799071 baseball
+n02802426 basketball
+n02804414 bassinet
+n02804610 bassoon
+n02807133 bathing cap, swimming cap
+n02808304 bath towel
+n02808440 bathtub, bathing tub, bath, tub
+n02814533 beach wagon, station wagon, wagon, estate car, beach waggon, station waggon, waggon
+n02814860 beacon, lighthouse, beacon light, pharos
+n02815834 beaker
+n02817516 bearskin, busby, shako
+n02823428 beer bottle
+n02823750 beer glass
+n02825657 bell cote, bell cot
+n02834397 bib
+n02835271 bicycle-built-for-two, tandem bicycle, tandem
+n02837789 bikini, two-piece
+n02840245 binder, ring-binder
+n02841315 binoculars, field glasses, opera glasses
+n02843684 birdhouse
+n02859443 boathouse
+n02860847 bobsled, bobsleigh, bob
+n02865351 bolo tie, bolo, bola tie, bola
+n02869837 bonnet, poke bonnet
+n02870880 bookcase
+n02871525 bookshop, bookstore, bookstall
+n02877765 bottlecap
+n02879718 bow
+n02883205 bow tie, bow-tie, bowtie
+n02892201 brass, memorial tablet, plaque
+n02892767 brassiere, bra, bandeau
+n02894605 breakwater, groin, groyne, mole, bulwark, seawall, jetty
+n02895154 breastplate, aegis, egis
+n02906734 broom
+n02909870 bucket, pail
+n02910353 buckle
+n02916936 bulletproof vest
+n02917067 bullet train, bullet
+n02927161 butcher shop, meat market
+n02930766 cab, hack, taxi, taxicab
+n02939185 caldron, cauldron
+n02948072 candle, taper, wax light
+n02950826 cannon
+n02951358 canoe
+n02951585 can opener, tin opener
+n02963159 cardigan
+n02965783 car mirror
+n02966193 carousel, carrousel, merry-go-round, roundabout, whirligig
+n02966687 carpenter's kit, tool kit
+n02971356 carton
+n02974003 car wheel
+n02977058 cash machine, cash dispenser, automated teller machine, automatic teller machine, automated teller, automatic teller, ATM
+n02978881 cassette
+n02979186 cassette player
+n02980441 castle
+n02981792 catamaran
+n02988304 CD player
+n02992211 cello, violoncello
+n02992529 cellular telephone, cellular phone, cellphone, cell, mobile phone
+n02999410 chain
+n03000134 chainlink fence
+n03000247 chain mail, ring mail, mail, chain armor, chain armour, ring armor, ring armour
+n03000684 chain saw, chainsaw
+n03014705 chest
+n03016953 chiffonier, commode
+n03017168 chime, bell, gong
+n03018349 china cabinet, china closet
+n03026506 Christmas stocking
+n03028079 church, church building
+n03032252 cinema, movie theater, movie theatre, movie house, picture palace
+n03041632 cleaver, meat cleaver, chopper
+n03042490 cliff dwelling
+n03045698 cloak
+n03047690 clog, geta, patten, sabot
+n03062245 cocktail shaker
+n03063599 coffee mug
+n03063689 coffeepot
+n03065424 coil, spiral, volute, whorl, helix
+n03075370 combination lock
+n03085013 computer keyboard, keypad
+n03089624 confectionery, confectionary, candy store
+n03095699 container ship, containership, container vessel
+n03100240 convertible
+n03109150 corkscrew, bottle screw
+n03110669 cornet, horn, trumpet, trump
+n03124043 cowboy boot
+n03124170 cowboy hat, ten-gallon hat
+n03125729 cradle
+n03126707 crane
+n03127747 crash helmet
+n03127925 crate
+n03131574 crib, cot
+n03133878 Crock Pot
+n03134739 croquet ball
+n03141823 crutch
+n03146219 cuirass
+n03160309 dam, dike, dyke
+n03179701 desk
+n03180011 desktop computer
+n03187595 dial telephone, dial phone
+n03188531 diaper, nappy, napkin
+n03196217 digital clock
+n03197337 digital watch
+n03201208 dining table, board
+n03207743 dishrag, dishcloth
+n03207941 dishwasher, dish washer, dishwashing machine
+n03208938 disk brake, disc brake
+n03216828 dock, dockage, docking facility
+n03218198 dogsled, dog sled, dog sleigh
+n03220513 dome
+n03223299 doormat, welcome mat
+n03240683 drilling platform, offshore rig
+n03249569 drum, membranophone, tympan
+n03250847 drumstick
+n03255030 dumbbell
+n03259280 Dutch oven
+n03271574 electric fan, blower
+n03272010 electric guitar
+n03272562 electric locomotive
+n03290653 entertainment center
+n03291819 envelope
+n03297495 espresso maker
+n03314780 face powder
+n03325584 feather boa, boa
+n03337140 file, file cabinet, filing cabinet
+n03344393 fireboat
+n03345487 fire engine, fire truck
+n03347037 fire screen, fireguard
+n03355925 flagpole, flagstaff
+n03372029 flute, transverse flute
+n03376595 folding chair
+n03379051 football helmet
+n03384352 forklift
+n03388043 fountain
+n03388183 fountain pen
+n03388549 four-poster
+n03393912 freight car
+n03394916 French horn, horn
+n03400231 frying pan, frypan, skillet
+n03404251 fur coat
+n03417042 garbage truck, dustcart
+n03424325 gasmask, respirator, gas helmet
+n03425413 gas pump, gasoline pump, petrol pump, island dispenser
+n03443371 goblet
+n03444034 go-kart
+n03445777 golf ball
+n03445924 golfcart, golf cart
+n03447447 gondola
+n03447721 gong, tam-tam
+n03450230 gown
+n03452741 grand piano, grand
+n03457902 greenhouse, nursery, glasshouse
+n03459775 grille, radiator grille
+n03461385 grocery store, grocery, food market, market
+n03467068 guillotine
+n03476684 hair slide
+n03476991 hair spray
+n03478589 half track
+n03481172 hammer
+n03482405 hamper
+n03483316 hand blower, blow dryer, blow drier, hair dryer, hair drier
+n03485407 hand-held computer, hand-held microcomputer
+n03485794 handkerchief, hankie, hanky, hankey
+n03492542 hard disc, hard disk, fixed disk
+n03494278 harmonica, mouth organ, harp, mouth harp
+n03495258 harp
+n03496892 harvester, reaper
+n03498962 hatchet
+n03527444 holster
+n03529860 home theater, home theatre
+n03530642 honeycomb
+n03532672 hook, claw
+n03534580 hoopskirt, crinoline
+n03535780 horizontal bar, high bar
+n03538406 horse cart, horse-cart
+n03544143 hourglass
+n03584254 iPod
+n03584829 iron, smoothing iron
+n03590841 jack-o'-lantern
+n03594734 jean, blue jean, denim
+n03594945 jeep, landrover
+n03595614 jersey, T-shirt, tee shirt
+n03598930 jigsaw puzzle
+n03599486 jinrikisha, ricksha, rickshaw
+n03602883 joystick
+n03617480 kimono
+n03623198 knee pad
+n03627232 knot
+n03630383 lab coat, laboratory coat
+n03633091 ladle
+n03637318 lampshade, lamp shade
+n03642806 laptop, laptop computer
+n03649909 lawn mower, mower
+n03657121 lens cap, lens cover
+n03658185 letter opener, paper knife, paperknife
+n03661043 library
+n03662601 lifeboat
+n03666591 lighter, light, igniter, ignitor
+n03670208 limousine, limo
+n03673027 liner, ocean liner
+n03676483 lipstick, lip rouge
+n03680355 Loafer
+n03690938 lotion
+n03691459 loudspeaker, speaker, speaker unit, loudspeaker system, speaker system
+n03692522 loupe, jeweler's loupe
+n03697007 lumbermill, sawmill
+n03706229 magnetic compass
+n03709823 mailbag, postbag
+n03710193 mailbox, letter box
+n03710637 maillot
+n03710721 maillot, tank suit
+n03717622 manhole cover
+n03720891 maraca
+n03721384 marimba, xylophone
+n03724870 mask
+n03729826 matchstick
+n03733131 maypole
+n03733281 maze, labyrinth
+n03733805 measuring cup
+n03742115 medicine chest, medicine cabinet
+n03743016 megalith, megalithic structure
+n03759954 microphone, mike
+n03761084 microwave, microwave oven
+n03763968 military uniform
+n03764736 milk can
+n03769881 minibus
+n03770439 miniskirt, mini
+n03770679 minivan
+n03773504 missile
+n03775071 mitten
+n03775546 mixing bowl
+n03776460 mobile home, manufactured home
+n03777568 Model T
+n03777754 modem
+n03781244 monastery
+n03782006 monitor
+n03785016 moped
+n03786901 mortar
+n03787032 mortarboard
+n03788195 mosque
+n03788365 mosquito net
+n03791053 motor scooter, scooter
+n03792782 mountain bike, all-terrain bike, off-roader
+n03792972 mountain tent
+n03793489 mouse, computer mouse
+n03794056 mousetrap
+n03796401 moving van
+n03803284 muzzle
+n03804744 nail
+n03814639 neck brace
+n03814906 necklace
+n03825788 nipple
+n03832673 notebook, notebook computer
+n03837869 obelisk
+n03838899 oboe, hautboy, hautbois
+n03840681 ocarina, sweet potato
+n03841143 odometer, hodometer, mileometer, milometer
+n03843555 oil filter
+n03854065 organ, pipe organ
+n03857828 oscilloscope, scope, cathode-ray oscilloscope, CRO
+n03866082 overskirt
+n03868242 oxcart
+n03868863 oxygen mask
+n03871628 packet
+n03873416 paddle, boat paddle
+n03874293 paddlewheel, paddle wheel
+n03874599 padlock
+n03876231 paintbrush
+n03877472 pajama, pyjama, pj's, jammies
+n03877845 palace
+n03884397 panpipe, pandean pipe, syrinx
+n03887697 paper towel
+n03888257 parachute, chute
+n03888605 parallel bars, bars
+n03891251 park bench
+n03891332 parking meter
+n03895866 passenger car, coach, carriage
+n03899768 patio, terrace
+n03902125 pay-phone, pay-station
+n03903868 pedestal, plinth, footstall
+n03908618 pencil box, pencil case
+n03908714 pencil sharpener
+n03916031 perfume, essence
+n03920288 Petri dish
+n03924679 photocopier
+n03929660 pick, plectrum, plectron
+n03929855 pickelhaube
+n03930313 picket fence, paling
+n03930630 pickup, pickup truck
+n03933933 pier
+n03935335 piggy bank, penny bank
+n03937543 pill bottle
+n03938244 pillow
+n03942813 ping-pong ball
+n03944341 pinwheel
+n03947888 pirate, pirate ship
+n03950228 pitcher, ewer
+n03954731 plane, carpenter's plane, woodworking plane
+n03956157 planetarium
+n03958227 plastic bag
+n03961711 plate rack
+n03967562 plow, plough
+n03970156 plunger, plumber's helper
+n03976467 Polaroid camera, Polaroid Land camera
+n03976657 pole
+n03977966 police van, police wagon, paddy wagon, patrol wagon, wagon, black Maria
+n03980874 poncho
+n03982430 pool table, billiard table, snooker table
+n03983396 pop bottle, soda bottle
+n03991062 pot, flowerpot
+n03992509 potter's wheel
+n03995372 power drill
+n03998194 prayer rug, prayer mat
+n04004767 printer
+n04005630 prison, prison house
+n04008634 projectile, missile
+n04009552 projector
+n04019541 puck, hockey puck
+n04023962 punching bag, punch bag, punching ball, punchball
+n04026417 purse
+n04033901 quill, quill pen
+n04033995 quilt, comforter, comfort, puff
+n04037443 racer, race car, racing car
+n04039381 racket, racquet
+n04040759 radiator
+n04041544 radio, wireless
+n04044716 radio telescope, radio reflector
+n04049303 rain barrel
+n04065272 recreational vehicle, RV, R.V.
+n04067472 reel
+n04069434 reflex camera
+n04070727 refrigerator, icebox
+n04074963 remote control, remote
+n04081281 restaurant, eating house, eating place, eatery
+n04086273 revolver, six-gun, six-shooter
+n04090263 rifle
+n04099969 rocking chair, rocker
+n04111531 rotisserie
+n04116512 rubber eraser, rubber, pencil eraser
+n04118538 rugby ball
+n04118776 rule, ruler
+n04120489 running shoe
+n04125021 safe
+n04127249 safety pin
+n04131690 saltshaker, salt shaker
+n04133789 sandal
+n04136333 sarong
+n04141076 sax, saxophone
+n04141327 scabbard
+n04141975 scale, weighing machine
+n04146614 school bus
+n04147183 schooner
+n04149813 scoreboard
+n04152593 screen, CRT screen
+n04153751 screw
+n04154565 screwdriver
+n04162706 seat belt, seatbelt
+n04179913 sewing machine
+n04192698 shield, buckler
+n04200800 shoe shop, shoe-shop, shoe store
+n04201297 shoji
+n04204238 shopping basket
+n04204347 shopping cart
+n04208210 shovel
+n04209133 shower cap
+n04209239 shower curtain
+n04228054 ski
+n04229816 ski mask
+n04235860 sleeping bag
+n04238763 slide rule, slipstick
+n04239074 sliding door
+n04243546 slot, one-armed bandit
+n04251144 snorkel
+n04252077 snowmobile
+n04252225 snowplow, snowplough
+n04254120 soap dispenser
+n04254680 soccer ball
+n04254777 sock
+n04258138 solar dish, solar collector, solar furnace
+n04259630 sombrero
+n04263257 soup bowl
+n04264628 space bar
+n04265275 space heater
+n04266014 space shuttle
+n04270147 spatula
+n04273569 speedboat
+n04275548 spider web, spider's web
+n04277352 spindle
+n04285008 sports car, sport car
+n04286575 spotlight, spot
+n04296562 stage
+n04310018 steam locomotive
+n04311004 steel arch bridge
+n04311174 steel drum
+n04317175 stethoscope
+n04325704 stole
+n04326547 stone wall
+n04328186 stopwatch, stop watch
+n04330267 stove
+n04332243 strainer
+n04335435 streetcar, tram, tramcar, trolley, trolley car
+n04336792 stretcher
+n04344873 studio couch, day bed
+n04346328 stupa, tope
+n04347754 submarine, pigboat, sub, U-boat
+n04350905 suit, suit of clothes
+n04355338 sundial
+n04355933 sunglass
+n04356056 sunglasses, dark glasses, shades
+n04357314 sunscreen, sunblock, sun blocker
+n04366367 suspension bridge
+n04367480 swab, swob, mop
+n04370456 sweatshirt
+n04371430 swimming trunks, bathing trunks
+n04371774 swing
+n04372370 switch, electric switch, electrical switch
+n04376876 syringe
+n04380533 table lamp
+n04389033 tank, army tank, armored combat vehicle, armoured combat vehicle
+n04392985 tape player
+n04398044 teapot
+n04399382 teddy, teddy bear
+n04404412 television, television system
+n04409515 tennis ball
+n04417672 thatch, thatched roof
+n04418357 theater curtain, theatre curtain
+n04423845 thimble
+n04428191 thresher, thrasher, threshing machine
+n04429376 throne
+n04435653 tile roof
+n04442312 toaster
+n04443257 tobacco shop, tobacconist shop, tobacconist
+n04447861 toilet seat
+n04456115 torch
+n04458633 totem pole
+n04461696 tow truck, tow car, wrecker
+n04462240 toyshop
+n04465501 tractor
+n04467665 trailer truck, tractor trailer, trucking rig, rig, articulated lorry, semi
+n04476259 tray
+n04479046 trench coat
+n04482393 tricycle, trike, velocipede
+n04483307 trimaran
+n04485082 tripod
+n04486054 triumphal arch
+n04487081 trolleybus, trolley coach, trackless trolley
+n04487394 trombone
+n04493381 tub, vat
+n04501370 turnstile
+n04505470 typewriter keyboard
+n04507155 umbrella
+n04509417 unicycle, monocycle
+n04515003 upright, upright piano
+n04517823 vacuum, vacuum cleaner
+n04522168 vase
+n04523525 vault
+n04525038 velvet
+n04525305 vending machine
+n04532106 vestment
+n04532670 viaduct
+n04536866 violin, fiddle
+n04540053 volleyball
+n04542943 waffle iron
+n04548280 wall clock
+n04548362 wallet, billfold, notecase, pocketbook
+n04550184 wardrobe, closet, press
+n04552348 warplane, military plane
+n04553703 washbasin, handbasin, washbowl, lavabo, wash-hand basin
+n04554684 washer, automatic washer, washing machine
+n04557648 water bottle
+n04560804 water jug
+n04562935 water tower
+n04579145 whiskey jug
+n04579432 whistle
+n04584207 wig
+n04589890 window screen
+n04590129 window shade
+n04591157 Windsor tie
+n04591713 wine bottle
+n04592741 wing
+n04596742 wok
+n04597913 wooden spoon
+n04599235 wool, woolen, woollen
+n04604644 worm fence, snake fence, snake-rail fence, Virginia fence
+n04606251 wreck
+n04612504 yawl
+n04613696 yurt
+n06359193 web site, website, internet site, site
+n06596364 comic book
+n06785654 crossword puzzle, crossword
+n06794110 street sign
+n06874185 traffic light, traffic signal, stoplight
+n07248320 book jacket, dust cover, dust jacket, dust wrapper
+n07565083 menu
+n07579787 plate
+n07583066 guacamole
+n07584110 consomme
+n07590611 hot pot, hotpot
+n07613480 trifle
+n07614500 ice cream, icecream
+n07615774 ice lolly, lolly, lollipop, popsicle
+n07684084 French loaf
+n07693725 bagel, beigel
+n07695742 pretzel
+n07697313 cheeseburger
+n07697537 hotdog, hot dog, red hot
+n07711569 mashed potato
+n07714571 head cabbage
+n07714990 broccoli
+n07715103 cauliflower
+n07716358 zucchini, courgette
+n07716906 spaghetti squash
+n07717410 acorn squash
+n07717556 butternut squash
+n07718472 cucumber, cuke
+n07718747 artichoke, globe artichoke
+n07720875 bell pepper
+n07730033 cardoon
+n07734744 mushroom
+n07742313 Granny Smith
+n07745940 strawberry
+n07747607 orange
+n07749582 lemon
+n07753113 fig
+n07753275 pineapple, ananas
+n07753592 banana
+n07754684 jackfruit, jak, jack
+n07760859 custard apple
+n07768694 pomegranate
+n07802026 hay
+n07831146 carbonara
+n07836838 chocolate sauce, chocolate syrup
+n07860988 dough
+n07871810 meat loaf, meatloaf
+n07873807 pizza, pizza pie
+n07875152 potpie
+n07880968 burrito
+n07892512 red wine
+n07920052 espresso
+n07930864 cup
+n07932039 eggnog
+n09193705 alp
+n09229709 bubble
+n09246464 cliff, drop, drop-off
+n09256479 coral reef
+n09288635 geyser
+n09332890 lakeside, lakeshore
+n09399592 promontory, headland, head, foreland
+n09421951 sandbar, sand bar
+n09428293 seashore, coast, seacoast, sea-coast
+n09468604 valley, vale
+n09472597 volcano
+n09835506 ballplayer, baseball player
+n10148035 groom, bridegroom
+n10565667 scuba diver
+n11879895 rapeseed
+n11939491 daisy
+n12057211 yellow lady's slipper, yellow lady-slipper, Cypripedium calceolus, Cypripedium parviflorum
+n12144580 corn
+n12267677 acorn
+n12620546 hip, rose hip, rosehip
+n12768682 buckeye, horse chestnut, conker
+n12985857 coral fungus
+n12998815 agaric
+n13037406 gyromitra
+n13040303 stinkhorn, carrion fungus
+n13044778 earthstar
+n13052670 hen-of-the-woods, hen of the woods, Polyporus frondosus, Grifola frondosa
+n13054560 bolete
+n13133613 ear, spike, capitulum
+n15075141 toilet tissue, toilet paper, bathroom tissue

docs/Makefile

@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line, and also
+# from the environment for the first two.
+SPHINXOPTS    ?=
+SPHINXBUILD   ?= sphinx-build
+SOURCEDIR     = .
+BUILDDIR      = _build
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

docs/conf.py

@@ -0,0 +1,71 @@
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+# sys.path.insert(0, os.path.abspath('.'))
+sys.path.insert(0, os.path.abspath('../'))
+# sys.path.append('/home/jinwei/Laboratory/api')
+sys.path.append('../..')
+
+
+# -- Project information -----------------------------------------------------
+
+project = 'DeepRobust'
+copyright = ''
+author = 'Yaxin Li, Wei Jin, Han Xu, Jiliang Tang'
+
+# The full version, including alpha/beta/rc tags
+release = '0.1.1'
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = ['sphinx.ext.todo', 'sphinx.ext.viewcode', 'sphinx.ext.autodoc', 'sphinx.ext.napoleon',
+              'sphinx.ext.autosummary', 'sphinx.ext.mathjax', 'sphinx.ext.viewcode', 'sphinx.ext.githubpages' ]
+
+# extensions = ['sphinx.ext.napoleon']
+autodoc_mock_imports = ['torch', 'torchvision', 'texttable', 'tensorboardX',
+                'torch_geometric', 'gensim', 'node2vec']
+
+# remove undoc members
+#autodoc_default_flags = ['members']
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+# html_theme = 'alabaster'
+html_theme = 'sphinx_rtd_theme'
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']
+
+add_module_names = False
+
+master_doc = 'index'
+

docs/index.rst

@@ -0,0 +1,65 @@
+.. Deep documentation master file, created by
+   sphinx-quickstart on Fri Jul  3 12:19:59 2020.
+   You can adapt this file completely to your liking, but it should at least
+   contain the root `toctree` directive.
+
+Start building your robust models with DeepRobust!
+================================
+.. comments original size: 626*238
+
+.. image:: ./DeepRobust.png
+   :width: 313px
+   :height: 119px
+
+DeepRobust is a pytorch adversarial learning library, which contains most popular attack and defense algorithms in image domain and graph domain. 
+
+.. toctree::
+   :glob:
+   :maxdepth: 1
+   :caption: Installation 
+
+   notes/installation
+   
+.. toctree::
+   :glob:
+   :maxdepth: 1
+   :caption: Graph Package
+
+   graph/data
+   graph/attack
+   graph/defense
+   graph/pyg
+   graph/node_embedding
+
+.. toctree::
+   :glob:
+   :maxdepth: 1
+   :caption: Image Package
+
+   image/example
+
+Package API
+===========
+.. toctree::
+   :maxdepth: 1
+   :caption: Image Package
+   
+   source/deeprobust.image.attack
+   source/deeprobust.image.defense
+   source/deeprobust.image.netmodels
+
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Graph Package
+   
+   source/deeprobust.graph.global_attack
+   source/deeprobust.graph.targeted_attack
+   source/deeprobust.graph.defense
+   source/deeprobust.graph.data
+
+Indices and tables
+==================
+
+* :ref:`modindex`
+* :ref:`search`

examples/graph/cgscore_datasets.py

@@ -0,0 +1,255 @@
+# compute cgscore for gcn
+# author: Yaning
+import torch
+import numpy as np
+import torch.nn.functional as Fd
+from deeprobust.graph.defense import GCNJaccard, GCN
+from deeprobust.graph.defense import GCNScore
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset, PrePtbDataset
+from scipy.sparse import csr_matrix
+import argparse
+import pickle
+from deeprobust.graph import utils
+from collections import defaultdict
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='polblogs', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.10,  help='pertubation rate')
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# make sure you use the same data splits as you generated attacks
+np.random.seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+
+# Here the random seed is to split the train/val/test data,
+# we need to set the random seed to be the same as that when you generate the perturbed graph
+# data = Dataset(root='/tmp/', name=args.dataset, setting='nettack', seed=15)
+# Or we can just use setting='prognn' to get the splits
+data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+
+
+perturbed_data = PrePtbDataset(root='/tmp/',
+        name=args.dataset,
+        attack_method='meta',
+        ptb_rate=args.ptb_rate)
+
+perturbed_adj = perturbed_data.adj
+# perturbed_adj = adj
+
+def save_cg_scores(cg_scores, filename="cg_scores.npy"):
+    np.save(filename, cg_scores)
+    print(f"CG-scores saved to {filename}")
+
+def load_cg_scores_numpy(filename="cg_scores.npy"):
+    cg_scores = np.load(filename, allow_pickle=True)
+    print(f"CG-scores loaded from {filename}")
+    return cg_scores
+
+def calc_cg_score_gnn_with_sampling(
+    A, X, labels, device, rep_num=1, unbalance_ratio=1, sub_term=False
+):
+    """
+    Calculate CG-score for each edge in a graph with node labels and random sampling.
+
+    Args:
+        A: torch.Tensor
+            Adjacency matrix of the graph (size: N x N).
+        X: torch.Tensor
+            Node features matrix (size: N x F).
+        labels: torch.Tensor
+            Node labels (size: N).
+        device: torch.device
+            Device to perform calculations.
+        rep_num: int
+            Number of repetitions for Monte Carlo sampling.
+        unbalance_ratio: float
+            Ratio of unbalanced data (1:unbalance_ratio).
+        sub_term: bool
+            If True, calculate and return sub-terms.
+
+    Returns:
+        cg_scores: dict
+            Dictionary containing CG-scores for edges and optionally sub-terms.
+    """
+    N = A.shape[0]
+    cg_scores = {
+        "vi": np.zeros((N, N)),
+        "ab": np.zeros((N, N)),
+        "a2": np.zeros((N, N)),
+        "b2": np.zeros((N, N)),
+        "times": np.zeros((N, N)),
+    }
+
+    with torch.no_grad():
+        for _ in range(rep_num):
+            # Compute AX (node representations)
+            AX = torch.matmul(A, X).to(device)
+            norm_AX = AX / torch.norm(AX, dim=1, keepdim=True)
+
+            # Group nodes by their labels
+            dataset = defaultdict(list)
+            data_idx = defaultdict(list)
+            for i, label in enumerate(labels):
+                dataset[label.item()].append(norm_AX[i].unsqueeze(0))  # Store normalized data
+                data_idx[label.item()].append(i)  # Store indices
+
+            # Convert to tensors
+            for label, data_list in dataset.items():
+                dataset[label] = torch.cat(data_list, dim=0)
+                data_idx[label] = torch.tensor(data_idx[label], dtype=torch.long, device=device)
+
+            # Calculate CG-scores for each label group
+            for curr_label, curr_samples in dataset.items():
+                curr_indices = data_idx[curr_label]
+                curr_num = len(curr_samples)
+
+                # Randomly sample a subset of current label examples
+                chosen_curr_idx = np.random.choice(range(curr_num), curr_num, replace=False)
+                chosen_curr_samples = curr_samples[chosen_curr_idx]
+                chosen_curr_indices = curr_indices[chosen_curr_idx]
+
+                # Sample negative examples from other classes
+                neg_samples = torch.cat(
+                    [dataset[l] for l in dataset if l != curr_label], dim=0
+                )
+                neg_indices = torch.cat(
+                    [data_idx[l] for l in data_idx if l != curr_label], dim=0
+                )
+                neg_num = min(int(curr_num * unbalance_ratio), len(neg_samples))
+                chosen_neg_samples = neg_samples[
+                    torch.randperm(len(neg_samples))[:neg_num]
+                ]
+
+                # Combine positive and negative samples
+                combined_samples = torch.cat([chosen_curr_samples, chosen_neg_samples], dim=0)
+                y = torch.cat(
+                    [torch.ones(len(chosen_curr_samples)), -torch.ones(neg_num)], dim=0
+                ).to(device)
+
+                # Compute the Gram matrix H^\infty
+                H_inner = torch.matmul(combined_samples, combined_samples.T)
+                del combined_samples
+                ###
+                H_inner = torch.clamp(H_inner, min=-1.0, max=1.0)
+                ###
+                H = H_inner * (np.pi - torch.acos(H_inner)) / (2 * np.pi)
+                del H_inner
+
+                H.fill_diagonal_(0.5)
+                ##
+                epsilon = 1e-6
+                H = H + epsilon * torch.eye(H.size(0), device=H.device)
+                ##
+                invH = torch.inverse(H)
+                del H
+                original_error = y @ (invH @ y)
+
+                # Compute CG-scores for each edge
+                for i in chosen_curr_indices:
+                    print("the node index:", i)
+                    for j in range(i + 1, N):  # Upper triangular traversal
+                        # print(j)
+                        if A[i, j] == 0:  # Skip if no edge exists
+                            continue
+
+                        # Remove edge (i, j) to create A1
+                        A1 = A.clone()
+                        A1[i, j] = A1[j, i] = 0
+
+                        # Recompute AX with A1
+                        AX1 = torch.matmul(A1, X).to(device)
+                        norm_AX1 = AX1 / torch.norm(AX1, dim=1, keepdim=True)
+
+                        # Repeat error calculation with A1
+                        curr_samples_A1 = norm_AX1[chosen_curr_indices]
+                        neg_samples_A1 = norm_AX1[neg_indices]
+                        chosen_neg_samples_A1 = neg_samples_A1[
+                            torch.randperm(len(neg_samples_A1))[:neg_num]
+                        ]
+                        combined_samples_A1 = torch.cat(
+                            [curr_samples_A1, chosen_neg_samples_A1], dim=0
+                        )
+                        H_inner_A1 = torch.matmul(combined_samples_A1, combined_samples_A1.T)
+
+                        del combined_samples_A1
+                        
+                        ### trick1
+                        H_inner_A1 = torch.clamp(H_inner_A1, min=-1.0, max=1.0)
+                        ###
+
+                        H_A1 = H_inner_A1 * (np.pi - torch.acos(H_inner_A1)) / (2 * np.pi)
+                        del H_inner_A1
+                        H_A1.fill_diagonal_(0.5)
+
+                        ### trick2
+                        epsilon = 1e-6
+                        H_A1= H_A1 + epsilon * torch.eye(H_A1.size(0), device=H_A1.device)
+                        ###
+                        invH_A1 = torch.inverse(H_A1)
+                        del H_A1
+
+                        error_A1 = y @ (invH_A1 @ y)
+                         
+                        print("i:", i)
+                        print("j:", j)
+                        print("current score:", (original_error - error_A1).item())
+                        # Compute the difference in error (CG-score)
+                        cg_scores["vi"][i, j] += (original_error - error_A1).item()
+                        cg_scores["vi"][j, i] = cg_scores["vi"][i, j]  # Symmetric
+                        cg_scores["times"][i, j] += 1
+                        cg_scores["times"][j, i] += 1
+
+    # Normalize CG-scores by repetition count
+    for key, values in cg_scores.items():
+        if key == "times":
+            continue
+        cg_scores[key] = values / np.where(cg_scores["times"] > 0, cg_scores["times"], 1)
+
+    return cg_scores if sub_term else cg_scores["vi"] 
+
+def is_symmetric_sparse(adj): 
+    """
+    Check if a sparse matrix is symmetric.
+    """
+    # Check symmetry
+    return (adj != adj.transpose()).nnz == 0  # .nnz is the number of non-zero elements
+
+def make_symmetric_sparse(adj):
+    """
+    Ensure the sparse adjacency matrix is symmetrical.
+    """
+    # Make the matrix symmetric
+    sym_adj = (adj + adj.transpose()) / 2
+    return sym_adj
+
+perturbed_adj = make_symmetric_sparse(perturbed_adj)
+
+if type(perturbed_adj) is not torch.Tensor:
+    features, perturbed_adj, labels = utils.to_tensor(features, perturbed_adj, labels)
+else:
+    features = features.to(device)
+    perturbed_adj = perturbed_adj.to(device)
+    labels = labels.to(device)
+
+if utils.is_sparse_tensor(perturbed_adj):
+    
+    adj_norm = utils.normalize_adj_tensor(perturbed_adj, sparse=True)
+else:
+    adj_norm = utils.normalize_adj_tensor(perturbed_adj)
+
+features = features.to_dense()
+perturbed_adj = adj_norm.to_dense()
+
+
+calc_cg_score =  calc_cg_score_gnn_with_sampling(perturbed_adj, features, labels, device, rep_num=1, unbalance_ratio=1, sub_term=False)
+save_cg_scores(calc_cg_score, filename="cg_scores_polblogs_0.10.npy")
+# print("completed"）

examples/graph/cgscore_datasets_multigpus.py

@@ -0,0 +1,299 @@
+# compute cgscore for gcn
+# author: Yaning
+import torch
+import numpy as np
+import torch.nn.functional as Fd
+from deeprobust.graph.defense import GCNJaccard, GCN
+from deeprobust.graph.defense import GCNScore
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset, PrePtbDataset
+from scipy.sparse import csr_matrix
+import argparse
+import pickle
+from deeprobust.graph import utils
+import torch.multiprocessing as mp
+from collections import defaultdict
+from tqdm import tqdm
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='pubmed', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.05,  help='pertubation rate')
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:1" if torch.cuda.is_available() else "cpu")
+
+# make sure you use the same data splits as you generated attacks
+np.random.seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+
+# Here the random seed is to split the train/val/test data,
+# we need to set the random seed to be the same as that when you generate the perturbed graph
+# data = Dataset(root='/tmp/', name=args.dataset, setting='nettack', seed=15)
+# Or we can just use setting='prognn' to get the splits
+data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+
+
+perturbed_data = PrePtbDataset(root='/tmp/',
+        name=args.dataset,
+        attack_method='meta',
+        ptb_rate=args.ptb_rate)
+
+perturbed_adj = perturbed_data.adj
+# perturbed_adj = adj
+
+def save_cg_scores(cg_scores, filename="cg_scores.npy"):
+    np.save(filename, cg_scores)
+    print(f"CG-scores saved to {filename}")
+
+def load_cg_scores_numpy(filename="cg_scores.npy"):
+    cg_scores = np.load(filename, allow_pickle=True)
+    print(f"CG-scores loaded from {filename}")
+    return cg_scores
+
+def calc_cg_score_gnn_with_sampling(
+    A, X, labels, device, rep_num=1, unbalance_ratio=1, sub_term=False, batch_size=64, label_filter=None
+):
+    N = A.shape[0]
+    cg_scores = {
+        "vi": np.zeros((N, N)),
+        "ab": np.zeros((N, N)),
+        "a2": np.zeros((N, N)),
+        "b2": np.zeros((N, N)),
+        "times": np.zeros((N, N)),
+    }
+
+    A = A.to(device)
+    X = X.to(device)
+    labels = labels.to(device)
+
+    @torch.no_grad()
+    def normalize(tensor):
+        return tensor / (torch.norm(tensor, dim=1, keepdim=True) + 1e-8)
+
+    for _ in range(rep_num):
+        AX = torch.matmul(A, X)
+        norm_AX = normalize(AX)
+
+        unique_labels = torch.unique(labels)
+        if label_filter is not None:
+            unique_labels = [label for label in unique_labels if label.item() in label_filter]
+
+        label_to_indices = {
+            label.item(): (labels == label).nonzero(as_tuple=True)[0] for label in unique_labels
+        }
+        dataset = {label: norm_AX[indices] for label, indices in label_to_indices.items()}
+
+        neg_samples_dict = {}
+        neg_indices_dict = {}
+        for label in unique_labels:
+            print("label:", label)
+            label = label.item()
+            mask = labels != label
+            neg_samples = norm_AX[mask]
+            neg_indices = mask.nonzero(as_tuple=True)[0]
+            neg_samples_dict[label] = neg_samples
+            neg_indices_dict[label] = neg_indices
+
+        for curr_label in tqdm(unique_labels, desc="Label groups", position=device.index):
+            print("curr_label:", curr_label)
+            label_id = int(curr_label)
+            curr_samples = dataset[label_id]
+            curr_indices = label_to_indices[label_id]
+            curr_num = len(curr_samples)
+
+            chosen_curr_idx = torch.randperm(curr_num, device=device)
+            chosen_curr_samples = curr_samples[chosen_curr_idx]
+            chosen_curr_indices = curr_indices[chosen_curr_idx]
+
+            neg_samples = neg_samples_dict[label_id]
+            neg_indices = neg_indices_dict[label_id]
+            neg_num = min(int(curr_num * unbalance_ratio), len(neg_samples))
+            rand_idx = torch.randperm(len(neg_samples), device=device)[:neg_num]
+            chosen_neg_samples = neg_samples[rand_idx]
+            chosen_neg_indices = neg_indices[rand_idx]
+
+            combined_samples = torch.cat([chosen_curr_samples, chosen_neg_samples], dim=0)
+            y = torch.cat([torch.ones(len(chosen_curr_samples)), -torch.ones(neg_num)], dim=0).to(device)
+
+            H_inner = torch.matmul(combined_samples, combined_samples.T)
+            H_inner = torch.clamp(H_inner, min=-1.0, max=1.0)
+            H = H_inner * (np.pi - torch.acos(H_inner)) / (2 * np.pi)
+            H.fill_diagonal_(0.5)
+            H += 1e-6 * torch.eye(H.size(0), device=device)
+            invH = torch.inverse(H)
+            original_error = y @ (invH @ y)
+
+            edge_batch = []
+            for idx_i in chosen_curr_indices.tolist():
+                for j in range(idx_i + 1, N):
+                    if A[idx_i, j] != 0:
+                        edge_batch.append((idx_i, j))
+
+            for k in tqdm(range(0, len(edge_batch), batch_size), desc="Edge batches", leave=False, position=device.index):
+                batch = edge_batch[k: k + batch_size]
+                B = len(batch)
+
+                norm_AX1_batch = norm_AX.repeat(B, 1, 1).clone()
+                for b, (i, j) in enumerate(batch):
+                    AX1_i = AX[i] - A[i, j] * X[j]
+                    AX1_j = AX[j] - A[j, i] * X[i]
+                    norm_AX1_batch[b, i] = AX1_i / (torch.norm(AX1_i) + 1e-8)
+                    norm_AX1_batch[b, j] = AX1_j / (torch.norm(AX1_j) + 1e-8)
+
+                sample_idx = chosen_curr_indices.tolist() + chosen_neg_indices.tolist()
+                sample_batch = norm_AX1_batch[:, sample_idx, :]
+
+                H_inner = torch.matmul(sample_batch, sample_batch.transpose(1, 2))
+                H_inner = torch.clamp(H_inner, min=-1.0, max=1.0)
+                H = H_inner * (np.pi - torch.acos(H_inner)) / (2 * np.pi)
+                eye = torch.eye(H.size(-1), device=device).unsqueeze(0).expand_as(H)
+                H = H + 1e-6 * eye
+                H.diagonal(dim1=-2, dim2=-1).copy_(0.5)
+
+                invH = torch.inverse(H)
+                y_expanded = y.unsqueeze(0).expand(B, -1)
+                error_A1 = torch.einsum("bi,bij,bj->b", y_expanded, invH, y_expanded)
+
+                for b, (i, j) in enumerate(batch):
+                    score = (original_error - error_A1[b]).item()
+                    cg_scores["vi"][i, j] += score
+                    cg_scores["vi"][j, i] = score
+                    cg_scores["times"][i, j] += 1
+                    cg_scores["times"][j, i] += 1
+
+    for key in cg_scores:
+        if key != "times":
+            cg_scores[key] = cg_scores[key] / np.where(cg_scores["times"] > 0, cg_scores["times"], 1)
+
+    # return cg_scores if sub_term else cg_scores["vi"]
+    return cg_scores
+
+
+def run_worker(gpu_id, world_size, A, X, labels, rep_num, unbalance_ratio, sub_term, batch_size, return_dict):
+    device = torch.device(f"cuda:{gpu_id}")
+    unique_labels = torch.unique(labels).tolist()
+    label_chunks = np.array_split(unique_labels, world_size)
+    rank = torch.cuda.current_device()
+    label_filter = [int(l) for l in label_chunks[gpu_id % world_size]]
+
+    result = calc_cg_score_gnn_with_sampling(
+        A, X, labels, device,
+        rep_num=rep_num,
+        unbalance_ratio=unbalance_ratio,
+        sub_term=sub_term,
+        batch_size=batch_size,
+        label_filter=label_filter
+    )
+    return_dict[gpu_id] = result
+
+
+
+def multi_gpu_wrapper(A, X, labels, rep_num=1, unbalance_ratio=1, sub_term=False, batch_size=64, gpu_ids=None):
+    if gpu_ids is None:
+        gpu_ids = list(range(torch.cuda.device_count()))
+    world_size = len(gpu_ids)
+
+    manager = mp.Manager()
+    return_dict = manager.dict()
+    processes = []
+
+    for local_rank, gpu_id in enumerate(gpu_ids):
+        p = mp.Process(
+            target=run_worker,
+            args=(gpu_id, world_size, A, X, labels, rep_num, unbalance_ratio, sub_term, batch_size, return_dict)
+        )
+        p.start()
+        processes.append(p)
+
+    for p in processes:
+        p.join()
+
+    # 初始化 final_score
+    final_score = None
+
+    for gpu_id, rank_result in return_dict.items():
+        if not isinstance(rank_result, dict):
+            print(f"[FATAL] GPU {gpu_id} result is not a dict: {type(rank_result)}")
+            continue
+
+        if final_score is None:
+            # 深拷贝防止指针复用
+            final_score = {k: np.copy(v) for k, v in rank_result.items()}
+        else:
+            for key in rank_result:
+                if key not in final_score:
+                    print(f"[WARN] key '{key}' not in final_score. Skipping.")
+                    continue
+                try:
+                    if isinstance(final_score[key], np.ndarray) and isinstance(rank_result[key], np.ndarray):
+                        final_score[key] += rank_result[key]
+                    else:
+                        print(f"[WARN] Skipped merging key '{key}' due to type mismatch.")
+                except Exception as e:
+                    print(f"[ERROR] Failed merging key '{key}': {e}")
+
+    return final_score
+
+
+
+def is_symmetric_sparse(adj): 
+    """
+    Check if a sparse matrix is symmetric.
+    """
+    # Check symmetry
+    return (adj != adj.transpose()).nnz == 0  # .nnz is the number of non-zero elements
+
+def make_symmetric_sparse(adj):
+    """
+    Ensure the sparse adjacency matrix is symmetrical.
+    """
+    # Make the matrix symmetric
+    sym_adj = (adj + adj.transpose()) / 2
+    return sym_adj
+
+if __name__ == "__main__":
+    mp.set_start_method("spawn", force=True)
+
+    print("cuda:", torch.cuda.is_available())
+
+    # 选择使用的 GPU（根据你的实际情况）
+    selected_gpus = [0, 1, 2, 3]
+
+    # 稀疏矩阵对称处理
+    perturbed_adj = make_symmetric_sparse(perturbed_adj)
+
+    # 转 tensor
+    if type(perturbed_adj) is not torch.Tensor:
+        features, perturbed_adj, labels = utils.to_tensor(features, perturbed_adj, labels)
+    else:
+        features = features.to(device)
+        perturbed_adj = perturbed_adj.to(device)
+        labels = labels.to(device)
+
+    # 标准化邻接
+    if utils.is_sparse_tensor(perturbed_adj):
+        adj_norm = utils.normalize_adj_tensor(perturbed_adj, sparse=True)
+    else:
+        adj_norm = utils.normalize_adj_tensor(perturbed_adj)
+
+    features = features.to_dense()
+    perturbed_adj = adj_norm.to_dense()
+
+    #  多GPU并行计算 CG-score
+    calc_cg_score = multi_gpu_wrapper(
+        perturbed_adj, features, labels,
+        rep_num=1,
+        unbalance_ratio=1,
+        sub_term=False,
+        batch_size=1024,
+        gpu_ids=selected_gpus
+    )
+    save_cg_scores(calc_cg_score["vi"], filename=f"{args.dataset}_{args.ptb_rate}.npy")
+
+    print(" CG-score computation completed.")

examples/graph/cgscore_datasets_multigpus2.py

@@ -0,0 +1,208 @@
+
+# compute cgscore for gcn - Final Optimized Complete Version
+## 精度有损失，但不多
+import torch
+import numpy as np
+import torch.multiprocessing as mp
+import argparse
+from tqdm import tqdm
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset, PrePtbDataset
+from torch.cuda.amp import autocast
+from deeprobust.graph import utils
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15)
+parser.add_argument('--dataset', type=str, default='pubmed', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'])
+parser.add_argument('--ptb_rate', type=float, default=0.05)
+args = parser.parse_args()
+
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if args.cuda else "cpu")
+
+np.random.seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+
+data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+adj, features, labels = data.adj, data.features, data.labels
+
+perturbed_data = PrePtbDataset(root='/tmp/', name=args.dataset, attack_method='meta', ptb_rate=args.ptb_rate)
+perturbed_adj = (perturbed_data.adj + perturbed_data.adj.T) / 2
+
+def save_cg_scores(cg_scores, filename="cg_scores.npy"):
+    np.save(filename, cg_scores)
+    print(f"CG-scores saved to {filename}")
+
+def calc_cg_score_gnn_with_sampling(A, X, labels, device, rep_num=1, unbalance_ratio=1, batch_size=1024, node_filter=None):
+    N = A.shape[0]
+    cg_scores = {"vi": np.zeros((N, N)), "times": np.zeros((N, N))}
+    A, X, labels = A.to(device), X.to(device), labels.to(device)
+
+    @torch.no_grad()
+    def normalize(tensor):
+        return tensor / (torch.norm(tensor, dim=1, keepdim=True) + 1e-8)
+
+    for _ in range(rep_num):
+        AX = torch.matmul(A, X)
+        norm_AX = normalize(AX)
+
+        unique_labels = torch.unique(labels)
+        label_to_indices = {label.item(): (labels == label).nonzero(as_tuple=True)[0] for label in unique_labels}
+        dataset = {label: norm_AX[idx] for label, idx in label_to_indices.items()}
+
+        neg_samples_dict = {}
+        neg_indices_dict = {}
+        for label in unique_labels:
+            label = label.item()
+            mask = labels != label
+            neg_samples_dict[label] = norm_AX[mask]
+            neg_indices_dict[label] = mask.nonzero(as_tuple=True)[0]
+
+        if node_filter is not None:
+            node_filter = set(node_filter.tolist())
+        else:
+            node_filter = set(range(labels.size(0)))
+
+        for curr_label in tqdm(unique_labels, desc="Label groups", position=device.index):
+            label_id = int(curr_label)
+            curr_samples = dataset[label_id]
+            curr_indices = label_to_indices[label_id]
+            curr_num = len(curr_samples)
+
+            chosen_curr_idx = torch.randperm(curr_num, device=device)
+            pos_samples = curr_samples[chosen_curr_idx]
+            pos_indices = curr_indices[chosen_curr_idx]
+
+            neg_samples = neg_samples_dict[label_id]
+            neg_indices = neg_indices_dict[label_id]
+            neg_num = min(int(curr_num * unbalance_ratio), len(neg_samples))
+            rand_idx = torch.randperm(len(neg_samples), device=device)[:neg_num]
+            neg_samples = neg_samples[rand_idx]
+            neg_indices = neg_indices[rand_idx]
+
+            sample_idx = pos_indices.tolist() + neg_indices.tolist()
+            sample_tensor = norm_AX[sample_idx]  # [M, F]
+            y = torch.cat([
+                torch.ones(len(pos_samples)),
+                -torch.ones(len(neg_samples))
+            ], dim=0).to(device)
+
+            with autocast():
+                H_inner = torch.matmul(sample_tensor, sample_tensor.T).clamp(-1.0, 1.0)
+                H_base = H_inner * (np.pi - torch.acos(H_inner)) / (2 * np.pi)
+                H_base.fill_diagonal_(0.5)
+                H_base += 1e-6 * torch.eye(H_base.size(0), device=device)
+                ref_error = torch.dot(y, torch.linalg.solve(H_base, y))
+
+            edge_batch = [(i.item(), j)
+                          for i in pos_indices if i.item() in node_filter
+                          for j in range(i.item() + 1, N) if A[i, j] != 0]
+
+            for k in tqdm(range(0, len(edge_batch), batch_size), desc="Edge batches", leave=False, position=device.index):
+                batch = edge_batch[k:k + batch_size]
+                if not batch: continue
+                i_idx, j_idx = zip(*batch)
+                i_idx = torch.tensor(i_idx, device=device)
+                j_idx = torch.tensor(j_idx, device=device)
+
+                AX1_i = AX[i_idx] - A[i_idx, j_idx].unsqueeze(1) * X[j_idx]
+                AX1_j = AX[j_idx] - A[j_idx, i_idx].unsqueeze(1) * X[i_idx]
+                norm_AX1_i = normalize(AX1_i)
+                norm_AX1_j = normalize(AX1_j)
+
+                for b, (i, j) in enumerate(batch):
+                    i_int, j_int = i, j
+                    sample_tensor_copy = sample_tensor.clone()
+                    try:
+                        i_pos = sample_idx.index(i_int)
+                        sample_tensor_copy[i_pos] = norm_AX1_i[b]
+                    except ValueError:
+                        pass
+                    try:
+                        j_pos = sample_idx.index(j_int)
+                        sample_tensor_copy[j_pos] = norm_AX1_j[b]
+                    except ValueError:
+                        pass
+
+                    with autocast():
+                        H_inner = torch.matmul(sample_tensor_copy, sample_tensor_copy.T).clamp(-1.0, 1.0)
+                        H = H_inner * (np.pi - torch.acos(H_inner)) / (2 * np.pi)
+                        H.fill_diagonal_(0.5)
+                        H += 1e-6 * torch.eye(H.size(0), device=device)
+                        sol = torch.linalg.solve(H, y)
+                        err_new = torch.dot(y, sol)
+
+                    score = (ref_error - err_new).item()
+                    cg_scores["vi"][i, j] += score
+                    cg_scores["vi"][j, i] = score
+                    cg_scores["times"][i, j] += 1
+                    cg_scores["times"][j, i] += 1
+
+    for key in ["vi"]:
+        cg_scores[key] = cg_scores[key] / np.where(cg_scores["times"] > 0, cg_scores["times"], 1)
+
+    return cg_scores
+
+def run_worker(gpu_id, world_size, A, X, labels, rep_num, unbalance_ratio, batch_size, return_dict):
+    device = torch.device(f"cuda:{gpu_id}")
+
+    # 用 node ids 划分代替 label 分片
+    node_ids = torch.arange(labels.size(0))
+    node_chunks = np.array_split(node_ids.numpy(), world_size)
+    node_filter = torch.tensor(node_chunks[gpu_id], device=device)
+
+    result = calc_cg_score_gnn_with_sampling(
+        A, X, labels, device,
+        rep_num=rep_num,
+        unbalance_ratio=unbalance_ratio,
+        batch_size=batch_size,
+        node_filter=node_filter  # 👈 改名字
+    )
+    return_dict[gpu_id] = result
+
+def multi_gpu_wrapper(A, X, labels, rep_num=1, unbalance_ratio=1, batch_size=1024, gpu_ids=None):
+    if gpu_ids is None:
+        gpu_ids = list(range(torch.cuda.device_count()))
+    world_size = len(gpu_ids)
+
+    mp.set_start_method("spawn", force=True)
+    manager = mp.Manager()
+    return_dict = manager.dict()
+    processes = []
+
+    for i, gpu_id in enumerate(gpu_ids):
+        p = mp.Process(target=run_worker, args=(gpu_id, world_size, A, X, labels, rep_num, unbalance_ratio, batch_size, return_dict))
+        p.start()
+        processes.append(p)
+
+    for p in processes:
+        p.join()
+
+    final_score = None
+    for res in return_dict.values():
+        if final_score is None:
+            final_score = {k: np.copy(v) for k, v in res.items()}
+        else:
+            for k in res:
+                final_score[k] += res[k]
+    return final_score
+
+if __name__ == "__main__":
+    features, perturbed_adj, labels = utils.to_tensor(features, perturbed_adj, labels)
+    features = features.to_dense()
+    if utils.is_sparse_tensor(perturbed_adj):
+        perturbed_adj = utils.normalize_adj_tensor(perturbed_adj, sparse=True)
+    perturbed_adj = perturbed_adj.to_dense()
+
+    selected_gpus = [0,1,2,3]
+    cg_scores = multi_gpu_wrapper(perturbed_adj, features, labels,
+                                  rep_num=1,
+                                  unbalance_ratio=3,
+                                  batch_size=40280,
+                                  gpu_ids=selected_gpus)
+
+    save_cg_scores(cg_scores["vi"], filename=f"{args.dataset}_{args.ptb_rate}.npy")
+    print("🎉 CG-score computation completed.")

examples/graph/cgscore_env.yaml

@@ -0,0 +1,193 @@
+name: cgscore
+channels:
+  - defaults
+dependencies:
+  - _libgcc_mutex=0.1=main
+  - _openmp_mutex=5.1=1_gnu
+  - ca-certificates=2024.11.26=h06a4308_0
+  - ld_impl_linux-64=2.40=h12ee557_0
+  - libffi=3.4.4=h6a678d5_1
+  - libgcc-ng=11.2.0=h1234567_1
+  - libgomp=11.2.0=h1234567_1
+  - libstdcxx-ng=11.2.0=h1234567_1
+  - ncurses=6.4=h6a678d5_0
+  - openssl=3.0.15=h5eee18b_0
+  - python=3.9.21=he870216_1
+  - readline=8.2=h5eee18b_0
+  - sqlite=3.45.3=h5eee18b_0
+  - tk=8.6.14=h39e8969_0
+  - wheel=0.44.0=py39h06a4308_0
+  - xz=5.4.6=h5eee18b_1
+  - zlib=1.2.13=h5eee18b_1
+  - pip:
+      - aiohappyeyeballs==2.4.4
+      - aiohttp==3.11.11
+      - aiosignal==1.3.2
+      - alabaster==0.7.16
+      - alembic==1.15.1
+      - asttokens==3.0.0
+      - async-timeout==5.0.1
+      - attrs==24.3.0
+      - autopage==0.5.2
+      - babel==2.17.0
+      - certifi==2025.1.31
+      - cfgv==3.4.0
+      - charset-normalizer==3.4.1
+      - cliff==4.9.1
+      - cmaes==0.11.1
+      - cmake==3.31.2
+      - cmd2==2.5.11
+      - cogdl==0.6
+      - colorlog==6.9.0
+      - commonmark==0.9.1
+      - contourpy==1.3.0
+      - cycler==0.12.1
+      - decorator==5.1.1
+      - distlib==0.3.9
+      - docutils==0.21.2
+      - exceptiongroup==1.2.2
+      - executing==2.1.0
+      - filelock==3.18.0
+      - flake8==7.1.2
+      - fonttools==4.56.0
+      - frozenlist==1.5.0
+      - fsspec==2025.3.0
+      - fst-pso==1.8.1
+      - fuzzytm==2.0.9
+      - gensim==4.3.0
+      - grave==0.0.3
+      - grb==0.1.0
+      - greenlet==3.1.1
+      - huggingface-hub==0.29.3
+      - identify==2.6.9
+      - idna==3.10
+      - imageio==2.36.1
+      - imagesize==1.4.1
+      - importlib-metadata==4.13.0
+      - importlib-resources==6.5.2
+      - ipdb==0.13.13
+      - ipython==8.18.1
+      - jedi==0.19.2
+      - jinja2==3.1.6
+      - joblib==1.4.2
+      - kiwisolver==1.4.7
+      - lazy-loader==0.4
+      - lit==18.1.8
+      - littleutils==0.2.4
+      - llvmlite==0.40.1
+      - mako==1.3.9
+      - markupsafe==3.0.2
+      - matplotlib==3.6.0
+      - matplotlib-inline==0.1.7
+      - mccabe==0.7.0
+      - miniful==0.0.6
+      - mpmath==1.3.0
+      - multidict==6.1.0
+      - networkx==3.0
+      - ninja==1.11.1.4
+      - nodeenv==1.9.1
+      - numba==0.57.1
+      - numpy==1.23.5
+      - nvidia-cublas-cu11==11.10.3.66
+      - nvidia-cublas-cu12==12.1.3.1
+      - nvidia-cuda-cupti-cu11==11.7.101
+      - nvidia-cuda-cupti-cu12==12.1.105
+      - nvidia-cuda-nvrtc-cu11==11.7.99
+      - nvidia-cuda-nvrtc-cu12==12.1.105
+      - nvidia-cuda-runtime-cu11==11.7.99
+      - nvidia-cuda-runtime-cu12==12.1.105
+      - nvidia-cudnn-cu11==8.5.0.96
+      - nvidia-cudnn-cu12==8.9.2.26
+      - nvidia-cufft-cu11==10.9.0.58
+      - nvidia-cufft-cu12==11.0.2.54
+      - nvidia-curand-cu11==10.2.10.91
+      - nvidia-curand-cu12==10.3.2.106
+      - nvidia-cusolver-cu11==11.4.0.1
+      - nvidia-cusolver-cu12==11.4.5.107
+      - nvidia-cusparse-cu11==11.7.4.91
+      - nvidia-cusparse-cu12==12.1.0.106
+      - nvidia-cusparselt-cu12==0.6.2
+      - nvidia-nccl-cu11==2.14.3
+      - nvidia-nccl-cu12==2.20.5
+      - nvidia-nvjitlink-cu12==12.4.127
+      - nvidia-nvtx-cu11==11.7.91
+      - nvidia-nvtx-cu12==12.1.105
+      - ogb==1.3.6
+      - optuna==2.4.0
+      - outdated==0.2.2
+      - packaging==24.2
+      - pandas==2.2.3
+      - parso==0.8.4
+      - pbr==6.1.1
+      - pexpect==4.9.0
+      - pillow==9.4.0
+      - pip==25.0.1
+      - platformdirs==4.3.7
+      - pre-commit==4.2.0
+      - prettytable==3.16.0
+      - prompt-toolkit==3.0.48
+      - propcache==0.2.1
+      - protobuf==3.20.3
+      - psutil==6.1.1
+      - ptyprocess==0.7.0
+      - pure-eval==0.2.3
+      - pycodestyle==2.12.1
+      - pyflakes==3.2.0
+      - pyfume==0.3.1
+      - pygments==2.19.1
+      - pyparsing==3.2.3
+      - pyperclip==1.9.0
+      - python-dateutil==2.9.0.post0
+      - pytz==2025.2
+      - pyyaml==6.0.2
+      - recommonmark==0.7.1
+      - regex==2024.11.6
+      - requests==2.32.3
+      - safetensors==0.5.3
+      - scikit-image==0.24.0
+      - scikit-learn==1.2.0
+      - scipy==1.11.3
+      - sentencepiece==0.2.0
+      - setuptools==78.1.0
+      - simpful==2.12.0
+      - six==1.17.0
+      - smart-open==7.1.0
+      - snowballstemmer==2.2.0
+      - sphinx==7.3.7
+      - sphinxcontrib-applehelp==2.0.0
+      - sphinxcontrib-devhelp==2.0.0
+      - sphinxcontrib-htmlhelp==2.1.0
+      - sphinxcontrib-jsmath==1.0.1
+      - sphinxcontrib-qthelp==2.0.0
+      - sphinxcontrib-serializinghtml==2.0.0
+      - sqlalchemy==2.0.40
+      - stack-data==0.6.3
+      - stevedore==5.4.1
+      - sympy==1.13.1
+      - tabulate==0.9.0
+      - tensorboardx==2.6
+      - texttable==1.6.7
+      - threadpoolctl==3.6.0
+      - tifffile==2024.8.30
+      - tokenizers==0.21.1
+      - tomli==2.2.1
+      - torch==2.3.0+cu121
+      - torch-cluster==1.6.3+pt23cu121
+      - torch-geometric==2.6.1
+      - torch-scatter==2.1.2+pt23cu121
+      - torch-sparse==0.6.18+pt23cu121
+      - torch-spline-conv==1.2.2+pt23cu121
+      - torchvision==0.18.0+cu121
+      - tqdm==4.64.1
+      - traitlets==5.14.3
+      - transformers==4.50.2
+      - triton==2.3.0
+      - typing-extensions==4.13.0
+      - tzdata==2025.2
+      - urllib3==2.3.0
+      - virtualenv==20.29.3
+      - wcwidth==0.2.13
+      - wrapt==1.17.2
+      - yarl==1.18.3
+      - zipp==3.21.0
+prefix: /home/yiren/new_ssd2/chunhui/miniconda/envs/cgscore

examples/graph/cgscore_experiments/attack_method/attack_minmax.py

@@ -0,0 +1,106 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+import torch.optim as optim
+from deeprobust.graph.defense import GCN
+from deeprobust.graph.global_attack import MinMax
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset
+import argparse
+import os
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--epochs', type=int, default=200,
+                    help='Number of epochs to train.')
+parser.add_argument('--lr', type=float, default=0.01,
+                    help='Initial learning rate.')
+parser.add_argument('--weight_decay', type=float, default=5e-4,
+                    help='Weight decay (L2 loss on parameters).')
+parser.add_argument('--hidden', type=int, default=16,
+                    help='Number of hidden units.')
+parser.add_argument('--dropout', type=float, default=0.5,
+                    help='Dropout rate (1 - keep probability).')
+
+parser.add_argument('--dataset', type=str, default='cora', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed', 'Flickr'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.25,  help='pertubation rate')
+parser.add_argument('--ptb_type', type=str, default='minmax', choices=['clean', 'meta', 'dice', 'minmax', 'pgd', 'random'], help='attack type')
+parser.add_argument('--model', type=str, default='min-max', choices=['PGD', 'min-max'], help='model variant')
+
+args = parser.parse_args()
+
+device = torch.device("cuda:3" if torch.cuda.is_available() else "cpu")
+
+np.random.seed(args.seed)
+torch.manual_seed(args.seed)
+if device != 'cpu':
+    torch.cuda.manual_seed(args.seed)
+
+# data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+data = Dataset(root='/tmp/', name=args.dataset)
+adj, features, labels = data.adj, data.features, data.labels
+# features = normalize_feature(features)
+
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+idx_unlabeled = np.union1d(idx_val, idx_test)
+
+perturbations = int(args.ptb_rate * (adj.sum()//2))
+
+adj, features, labels = preprocess(adj, features, labels, preprocess_adj=False)
+
+# Setup Victim Model
+victim_model = GCN(nfeat=features.shape[1], nclass=labels.max().item()+1, nhid=16,
+        dropout=0.5, weight_decay=5e-4, device=device)
+
+victim_model = victim_model.to(device)
+victim_model.fit(features, adj, labels, idx_train)
+
+# Setup Attack Model
+
+model = MinMax(model=victim_model, nnodes=adj.shape[0], loss_type='CE', device=device)
+
+model = model.to(device)
+
+def test(adj):
+    ''' test on GCN '''
+
+    # adj = normalize_adj_tensor(adj)
+    gcn = GCN(nfeat=features.shape[1],
+              nhid=args.hidden,
+              nclass=labels.max().item() + 1,
+              dropout=args.dropout, device=device)
+    gcn = gcn.to(device)
+    gcn.fit(features, adj, labels, idx_train) # train without model picking
+    # gcn.fit(features, adj, labels, idx_train, idx_val) # train with validation model picking
+    output = gcn.output.cpu()
+    loss_test = F.nll_loss(output[idx_test], labels[idx_test])
+    acc_test = accuracy(output[idx_test], labels[idx_test])
+    print("Test set results:",
+          "loss= {:.4f}".format(loss_test.item()),
+          "accuracy= {:.4f}".format(acc_test.item()))
+
+    return acc_test.item()
+
+
+def main():
+    model.attack(features, adj, labels, idx_train, perturbations)
+    print('=== testing GCN on original(clean) graph ===')
+    test(adj)
+    modified_adj = model.modified_adj
+    # modified_features = model.modified_features
+    
+    save_dir = f"../attacked_adj/{args.dataset}"
+    os.makedirs(save_dir, exist_ok=True)  
+
+    save_path = os.path.join(save_dir, f"{args.ptb_type}_{args.dataset}_{args.ptb_rate}.pt")
+    torch.save(modified_adj, save_path)
+    
+    test(modified_adj)
+
+    # # if you want to save the modified adj/features, uncomment the code below
+    # model.save_adj(root='./', name=f'mod_adj')
+    # model.save_features(root='./', name='mod_features')
+
+if __name__ == '__main__':
+    main()
+

examples/graph/cgscore_experiments/attack_method/attack_nettack.py

@@ -0,0 +1,212 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+import torch.optim as optim
+from deeprobust.graph.defense import GCN
+from deeprobust.graph.targeted_attack import Nettack
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset
+import argparse
+from tqdm import tqdm
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='citeseer', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+np.random.seed(args.seed)
+torch.manual_seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+
+data = Dataset(root='/tmp/', name=args.dataset)
+adj, features, labels = data.adj, data.features, data.labels
+
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+
+idx_unlabeled = np.union1d(idx_val, idx_test)
+
+# Setup Surrogate model
+surrogate = GCN(nfeat=features.shape[1], nclass=labels.max().item()+1,
+                nhid=16, dropout=0, with_relu=False, with_bias=False, device=device)
+
+surrogate = surrogate.to(device)
+surrogate.fit(features, adj, labels, idx_train, idx_val, patience=30)
+
+# Setup Attack Model
+target_node = 0
+assert target_node in idx_unlabeled
+
+model = Nettack(surrogate, nnodes=adj.shape[0], attack_structure=True, attack_features=True, device=device)
+model = model.to(device)
+
+def main():
+    degrees = adj.sum(0).A1
+    # How many perturbations to perform. Default: Degree of the node
+    n_perturbations = int(degrees[target_node])
+
+    # direct attack
+    model.attack(features, adj, labels, target_node, n_perturbations)
+    # # indirect attack/ influencer attack
+    # model.attack(features, adj, labels, target_node, n_perturbations, direct=False, n_influencers=5)
+    modified_adj = model.modified_adj
+    modified_features = model.modified_features
+    print(model.structure_perturbations)
+    print('=== testing GCN on original(clean) graph ===')
+    test(adj, features, target_node)
+    print('=== testing GCN on perturbed graph ===')
+    test(modified_adj, modified_features, target_node)
+
+def test(adj, features, target_node):
+    ''' test on GCN '''
+    gcn = GCN(nfeat=features.shape[1],
+              nhid=16,
+              nclass=labels.max().item() + 1,
+              dropout=0.5, device=device)
+
+    gcn = gcn.to(device)
+
+    gcn.fit(features, adj, labels, idx_train, idx_val, patience=30)
+
+    gcn.eval()
+    output = gcn.predict()
+    probs = torch.exp(output[[target_node]])[0]
+    print('Target node probs: {}'.format(probs.detach().cpu().numpy()))
+    acc_test = accuracy(output[idx_test], labels[idx_test])
+
+    print("Overall test set results:",
+          "accuracy= {:.4f}".format(acc_test.item()))
+
+    return acc_test.item()
+
+def select_nodes(target_gcn=None):
+    '''
+    selecting nodes as reported in nettack paper:
+    (i) the 10 nodes with highest margin of classification, i.e. they are clearly correctly classified,
+    (ii) the 10 nodes with lowest margin (but still correctly classified) and
+    (iii) 20 more nodes randomly
+    '''
+
+    if target_gcn is None:
+        target_gcn = GCN(nfeat=features.shape[1],
+                  nhid=16,
+                  nclass=labels.max().item() + 1,
+                  dropout=0.5, device=device)
+        target_gcn = target_gcn.to(device)
+        target_gcn.fit(features, adj, labels, idx_train, idx_val, patience=30)
+    target_gcn.eval()
+    output = target_gcn.predict()
+
+    margin_dict = {}
+    for idx in idx_test:
+        margin = classification_margin(output[idx], labels[idx])
+        if margin < 0: # only keep the nodes correctly classified
+            continue
+        margin_dict[idx] = margin
+    sorted_margins = sorted(margin_dict.items(), key=lambda x:x[1], reverse=True)
+    high = [x for x, y in sorted_margins[: 10]]
+    low = [x for x, y in sorted_margins[-10: ]]
+    other = [x for x, y in sorted_margins[10: -10]]
+    other = np.random.choice(other, 20, replace=False).tolist()
+
+    return high + low + other
+
+def multi_test_poison_accumulative():
+    degrees = adj.sum(0).A1
+    node_list = select_nodes()
+    print("=== [Poisoning Accumulative] Attacking {} nodes sequentially ===".format(len(node_list)))
+    
+    # 初始化结构
+    adj_attacked = adj.copy()
+    
+    for target_node in tqdm(node_list):
+        n_perturbations = int(degrees[target_node])
+        model = Nettack(surrogate, nnodes=adj.shape[0],
+                        attack_structure=True, attack_features=False, device=device)
+        model = model.to(device)
+        model.attack(features, adj_attacked, labels, target_node, n_perturbations, verbose=False)
+        adj_attacked = model.modified_adj
+
+    gcn = GCN(nfeat=features.shape[1],
+              nhid=16,
+              nclass=labels.max().item() + 1,
+              dropout=0.5, device=device)
+    gcn = gcn.to(device)
+    gcn.fit(features, adj_attacked, labels, idx_train, idx_val, patience=30)
+    gcn.eval()
+    output = gcn.predict()
+
+    # 在 node_list 上评估被误分类的节点数
+    preds = output.argmax(1)
+    node_preds = preds[node_list]
+    node_labels = labels[node_list]
+
+    # 转为 tensor，确保正确
+    correct_mask = torch.tensor(node_preds == node_labels, dtype=torch.bool)
+    correct = correct_mask.sum().item()
+    print("Accuracy on attacked nodes: {:.2f}%".format(100 * correct / len(node_list)))
+
+def single_test(adj, features, target_node, gcn=None):
+    if gcn is None:
+        # test on GCN (poisoning attack)
+        gcn = GCN(nfeat=features.shape[1],
+                  nhid=16,
+                  nclass=labels.max().item() + 1,
+                  dropout=0.5, device=device)
+
+        gcn = gcn.to(device)
+
+        gcn.fit(features, adj, labels, idx_train, idx_val, patience=30)
+        gcn.eval()
+        output = gcn.predict()
+    else:
+        # test on GCN (evasion attack)
+        output = gcn.predict(features, adj)
+    probs = torch.exp(output[[target_node]])
+
+    # acc_test = accuracy(output[[target_node]], labels[target_node])
+    acc_test = (output.argmax(1)[target_node] == labels[target_node])
+    return acc_test.item()
+
+def multi_test_evasion():
+    # test on 40 nodes on evasion attack
+    target_gcn = GCN(nfeat=features.shape[1],
+              nhid=16,
+              nclass=labels.max().item() + 1,
+              dropout=0.5, device=device)
+
+    target_gcn = target_gcn.to(device)
+
+    target_gcn.fit(features, adj, labels, idx_train, idx_val, patience=30)
+
+    cnt = 0
+    degrees = adj.sum(0).A1
+    node_list = select_nodes(target_gcn)
+    num = len(node_list)
+
+    print('=== [Evasion] Attacking %s nodes respectively ===' % num)
+    for target_node in tqdm(node_list):
+        n_perturbations = int(degrees[target_node])
+        model = Nettack(surrogate, nnodes=adj.shape[0], attack_structure=True, attack_features=True, device=device)
+        model = model.to(device)
+        model.attack(features, adj, labels, target_node, n_perturbations, verbose=False)
+        modified_adj = model.modified_adj
+        modified_features = model.modified_features
+
+        acc = single_test(modified_adj, modified_features, target_node, gcn=target_gcn)
+        if acc == 0:
+            cnt += 1
+    print('misclassification rate : %s' % (cnt/num))
+
+if __name__ == '__main__':
+    # main()
+    # multi_test_poison()
+    # multi_test_poison()
+    multi_test_poison_accumulative()
+
+

examples/graph/cgscore_experiments/defense_method/GAT.py

@@ -0,0 +1,61 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+import scipy.sparse as sp
+from deeprobust.graph.defense import GCNJaccard, GCN, GAT
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset, PrePtbDataset, Dpr2Pyg
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='cora', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.0,  help='pertubation rate')
+parser.add_argument('--ptb_type', type=str, default='clean', choices=['clean', 'meta', 'dice', 'minmax', 'pgd', 'random'], help='attack type')
+parser.add_argument('--hidden', type=int, default=16, help='Number of hidden units.')
+parser.add_argument('--dropout', type=float, default=0.5, help='Dropout rate (1 - keep probability).')
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# make sure you use the same data splits as you generated attacks
+np.random.seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+
+# Here the random seed is to split the train/val/test data,
+# we need to set the random seed to be the same as that when you generate the perturbed graph
+# data = Dataset(root='/tmp/', name=args.dataset, setting='nettack', seed=15)
+# Or we can just use setting='prognn' to get the splits
+
+# data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+data = Dataset(root='/tmp/', name=args.dataset)
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+idx_unlabeled = np.union1d(idx_val, idx_test)
+# print(type((adj)))
+# adj, features, labels = preprocess(adj, features, labels, preprocess_adj=False)
+
+
+## load from attacked_adj
+ptb_path = f"../attacked_adj/{args.dataset}/{args.ptb_type}_{args.dataset}_{args.ptb_rate}.pt"
+perturbed_adj = torch.load(ptb_path)
+print("type(perturbed_adj)", type(perturbed_adj))
+perturbed_adj = sp.csr_matrix(perturbed_adj.cpu().numpy())
+
+gat = GAT(nfeat=features.shape[1],
+      nhid=8, heads=8,
+      nclass=labels.max().item() + 1,
+      dropout=0.5, device=device)
+gat = gat.to(device)
+
+# test on clean graph
+print('==================')
+print('=== train on clean graph ===')
+
+pyg_data = Dpr2Pyg(data)
+pyg_data.update_edge_index(perturbed_adj) # inplace operation
+gat.fit(pyg_data, train_iters=200, verbose=True) # train with earlystopping
+gat.test()

examples/graph/cgscore_experiments/defense_method/GCN.py

@@ -0,0 +1,73 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+from deeprobust.graph.defense import GCNJaccard, GCN
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset, PrePtbDataset
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='cora', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.0,  help='pertubation rate')
+parser.add_argument('--ptb_type', type=str, default='clean', choices=['clean', 'meta', 'dice', 'minmax', 'pgd', 'random'], help='attack type')
+parser.add_argument('--hidden', type=int, default=16, help='Number of hidden units.')
+parser.add_argument('--dropout', type=float, default=0.5, help='Dropout rate (1 - keep probability).')
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# make sure you use the same data splits as you generated attacks
+np.random.seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+
+# Here the random seed is to split the train/val/test data,
+# we need to set the random seed to be the same as that when you generate the perturbed graph
+# data = Dataset(root='/tmp/', name=args.dataset, setting='nettack', seed=15)
+# Or we can just use setting='prognn' to get the splits
+
+# data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+data = Dataset(root='/tmp/', name=args.dataset)
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+idx_unlabeled = np.union1d(idx_val, idx_test)
+adj, features, labels = preprocess(adj, features, labels, preprocess_adj=False)
+
+
+## load from attacked_adj
+ptb_path = f"../attacked_adj/{args.dataset}/{args.ptb_type}_{args.dataset}_{args.ptb_rate}.pt"
+perturbed_adj = torch.load(ptb_path)
+
+def test(adj):
+    ''' test on GCN '''
+
+    # adj = normalize_adj_tensor(adj)
+    gcn = GCN(nfeat=features.shape[1],
+              nhid=args.hidden,
+              nclass=labels.max().item() + 1,
+              dropout=args.dropout, device=device)
+    gcn = gcn.to(device)
+    gcn.fit(features, adj, labels, idx_train) # train without model picking
+    # gcn.fit(features, adj, labels, idx_train, idx_val) # train with validation model picking
+    output = gcn.output.cpu()
+    loss_test = F.nll_loss(output[idx_test], labels[idx_test])
+    acc_test = accuracy(output[idx_test], labels[idx_test])
+    print("Test set results:",
+          "loss= {:.4f}".format(loss_test.item()),
+          "accuracy= {:.4f}".format(acc_test.item()))
+
+    return acc_test.item()
+
+def main():
+    
+    test(perturbed_adj)
+
+    # # if you want to save the modified adj/features, uncomment the code below
+    # model.save_adj(root='./', name=f'mod_adj')
+    # model.save_features(root='./', name='mod_features')
+
+if __name__ == '__main__':
+    main()

examples/graph/cgscore_experiments/defense_method/GCNJaccard.py

@@ -0,0 +1,68 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+from deeprobust.graph.defense import GCNJaccard, GCN
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset, PrePtbDataset
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='cora', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.0,  help='pertubation rate')
+parser.add_argument('--ptb_type', type=str, default='clean', choices=['clean', 'meta', 'dice', 'minmax', 'pgd', 'random'], help='attack type')
+parser.add_argument('--hidden', type=int, default=16, help='Number of hidden units.')
+parser.add_argument('--dropout', type=float, default=0.5, help='Dropout rate (1 - keep probability).')
+parser.add_argument('--threshold', type=float, default=0.1, help='jaccard coeficient')
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# make sure you use the same data splits as you generated attacks
+np.random.seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+
+# Here the random seed is to split the train/val/test data,
+# we need to set the random seed to be the same as that when you generate the perturbed graph
+# data = Dataset(root='/tmp/', name=args.dataset, setting='nettack', seed=15)
+# Or we can just use setting='prognn' to get the splits
+
+# data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+data = Dataset(root='/tmp/', name=args.dataset)
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+idx_unlabeled = np.union1d(idx_val, idx_test)
+# adj, features, labels = preprocess(adj, features, labels, preprocess_adj=False)
+
+
+## load from attacked_adj
+ptb_path = f"../attacked_adj/{args.dataset}/{args.ptb_type}_{args.dataset}_{args.ptb_rate}.pt"
+perturbed_adj = torch.load(ptb_path)
+perturbed_adj = perturbed_adj
+
+def test_jaccard(adj):
+    ''' test on GCN '''
+
+    # adj = normalize_adj_tensor(adj)
+    gcn = GCNJaccard(nfeat=features.shape[1],
+              nhid=args.hidden,
+              nclass=labels.max().item() + 1,
+              dropout=args.dropout, device=device)
+    gcn = gcn.to(device)
+    gcn.fit(features, adj, labels, idx_train, idx_val, threshold=args.threshold)
+    gcn.eval()
+    gcn.test(idx_test)
+
+
+def main():
+    
+    test_jaccard(perturbed_adj)
+    # # if you want to save the modified adj/features, uncomment the code below
+    # model.save_adj(root='./', name=f'mod_adj')
+    # model.save_features(root='./', name='mod_features')
+
+if __name__ == '__main__':
+    main()

examples/graph/cgscore_experiments/defense_method/GCNSVD.py

@@ -0,0 +1,63 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+from deeprobust.graph.defense import GCNJaccard, GCN, GCNSVD
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset, PrePtbDataset
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='cora', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.0,  help='pertubation rate')
+parser.add_argument('--ptb_type', type=str, default='clean', choices=['clean', 'meta', 'dice', 'minmax', 'pgd', 'random'], help='attack type')
+parser.add_argument('--hidden', type=int, default=16, help='Number of hidden units.')
+parser.add_argument('--dropout', type=float, default=0.5, help='Dropout rate (1 - keep probability).')
+parser.add_argument('--k', type=int, default=50, help='Truncated Components.')
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# make sure you use the same data splits as you generated attacks
+np.random.seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+
+# Here the random seed is to split the train/val/test data,
+# we need to set the random seed to be the same as that when you generate the perturbed graph
+# data = Dataset(root='/tmp/', name=args.dataset, setting='nettack', seed=15)
+# Or we can just use setting='prognn' to get the splits
+
+# data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+data = Dataset(root='/tmp/', name=args.dataset)
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+# adj, features, labels = preprocess(adj, features, labels, preprocess_adj=False)
+
+
+## load from attacked_adj
+ptb_path = f"../attacked_adj/{args.dataset}/{args.ptb_type}_{args.dataset}_{args.ptb_rate}.pt"
+perturbed_adj = torch.load(ptb_path)
+
+def test_svd(adj):
+    
+    ''' test on GCNSVD '''
+
+    gcn = GCNSVD(nfeat=features.shape[1], nclass=labels.max()+1,nhid=args.hidden, device=device)
+    gcn = gcn.to(device)
+    gcn.fit(features, perturbed_adj, labels, idx_train, idx_val, k=args.k, verbose=True)
+    gcn.eval()
+    gcn.test(idx_test)
+
+
+def main():
+    
+    test_svd(perturbed_adj)
+    # # if you want to save the modified adj/features, uncomment the code below
+    # model.save_adj(root='./', name=f'mod_adj')
+    # model.save_features(root='./', name='mod_features')
+
+if __name__ == '__main__':
+    main()

examples/graph/cgscore_experiments/defense_method/GNNGuard.py

@@ -0,0 +1,64 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+from deeprobust.graph.defense.gcn_guard import GCNGuard
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset
+from deeprobust.graph.data import PtbDataset, PrePtbDataset
+
+import argparse
+from scipy import sparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed')
+parser.add_argument('--GNNGuard', type=bool, default=True,  choices=[True, False])
+parser.add_argument('--dataset', type=str, default='cora', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed', 'flickr'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.0,  help='pertubation rate')
+parser.add_argument('--ptb_type', type=str, default='clean', choices=['clean', 'meta', 'dice', 'minmax', 'pgd', 'random'], help='attack type')
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+np.random.seed(args.seed)
+torch.manual_seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+    
+# data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+data = Dataset(root='/tmp/', name=args.dataset)
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+
+ptb_path = f"../attacked_adj/{args.dataset}/{args.ptb_type}_{args.dataset}_{args.ptb_rate}.pt"
+perturbed_adj = torch.load(ptb_path)
+perturbed_adj = sp.csr_matrix(perturbed_adj.to('cpu').numpy())
+
+
+def test(adj):
+    # """defense models"""
+    ''' testing model '''
+    gcn =  GCNGuard(nfeat=features.shape[1], nclass=labels.max().item() + 1, nhid=16,
+               dropout=0.5, with_relu=False, with_bias=True, weight_decay=5e-4, device=device)
+    gcn = gcn.to(device)
+
+    gcn.fit(features, adj, labels, idx_train, train_iters=200, idx_val=idx_val, idx_test=idx_test, verbose=True, attention=args.GNNGuard)
+    gcn.eval()
+
+    # classifier.fit(features, adj, labels, idx_train, idx_val) # train with validation model picking
+    acc_test, _ = gcn.test(idx_test)
+    # acc_test = classifier.test(idx_test)
+    return acc_test
+
+def main():
+
+    # print('=== testing GCN on original(clean) graph ===')
+    # test(adj)
+    #
+    print('=== testing GCN on Mettacked graph ===')
+    test(perturbed_adj)
+
+if __name__ == '__main__':
+    main()
+

examples/graph/cgscore_experiments/defense_method/ProGNN.py

@@ -0,0 +1,80 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+from deeprobust.graph.defense import GCNJaccard, GCN, ProGNN
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset, PrePtbDataset
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='cora', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+parser.add_argument('--ptb_type', type=str, default='clean', choices=['clean', 'meta', 'dice', 'minmax', 'pgd', 'random'], help='attack type')
+parser.add_argument('--ptb_rate', type=float, default=0.0,  help='pertubation rate')
+parser.add_argument('--epochs', type=int,  default=200, help='Number of epochs to train.')
+
+parser.add_argument('--hidden', type=int, default=16, help='Number of hidden units.')
+parser.add_argument('--dropout', type=float, default=0.5, help='Dropout rate (1 - keep probability).')
+parser.add_argument('--debug', action='store_true',default=False, help='debug mode')
+parser.add_argument('--only_gcn', action='store_true',default=False, help='test the performance of gcn without other components')
+# parser.add_argument('--no-cuda', action='store_true', default=False, help='Disables CUDA training.')
+parser.add_argument('--lr', type=float, default=0.01, help='Initial learning rate.')
+parser.add_argument('--weight_decay', type=float, default=5e-4, help='Weight decay (L2 loss on parameters).')
+parser.add_argument('--alpha', type=float, default=5e-4, help='weight of l1 norm')
+parser.add_argument('--beta', type=float, default=1.5, help='weight of nuclear norm')
+parser.add_argument('--gamma', type=float, default=1, help='weight of l2 norm')
+parser.add_argument('--lambda_', type=float, default=0, help='weight of feature smoothing')
+parser.add_argument('--phi', type=float, default=0, help='weight of symmetric loss')
+parser.add_argument('--inner_steps', type=int, default=2, help='steps for inner optimization')
+parser.add_argument('--outer_steps', type=int, default=1, help='steps for outer optimization')
+parser.add_argument('--lr_adj', type=float, default=0.01, help='lr for training adj')
+parser.add_argument('--symmetric', action='store_true', default=False, help='whether use symmetric matrix')
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+device = torch.device("cuda:5" if args.cuda else "cpu")
+print('Using device:', device)
+
+# make sure you use the same data splits as you generated attacks
+np.random.seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+
+# Here the random seed is to split the train/val/test data,
+# we need to set the random seed to be the same as that when you generate the perturbed graph
+# data = Dataset(root='/tmp/', name=args.dataset, setting='nettack', seed=15)
+# Or we can just use setting='prognn' to get the splits
+
+# data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+data = Dataset(root='/tmp/', name=args.dataset)
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+idx_unlabeled = np.union1d(idx_val, idx_test)
+print(type(adj))
+# adj, features, labels = preprocess(adj, features, labels, preprocess_adj=False)
+
+
+## load from attacked_adj
+ptb_path = f"../attacked_adj/{args.dataset}/{args.ptb_type}_{args.dataset}_{args.ptb_rate}.pt"
+perturbed_adj = torch.load(ptb_path)
+perturbed_adj = sp.csr_matrix(perturbed_adj.to('cpu').numpy())
+
+def test_prognn(features, adj, labels):
+    
+
+    adj, features, labels = preprocess(adj, features, labels, preprocess_adj=False, device=device)
+    
+    model = GCN(nfeat=features.shape[1],
+                nhid=args.hidden,
+                nclass=labels.max().item() + 1,
+                dropout=args.dropout, device=device).to(device)
+    prognn = ProGNN(model, args, device)
+    prognn.fit(features, adj, labels, idx_train, idx_val)
+    prognn.test(features, labels, idx_test)
+
+def main():
+
+    test_prognn(features, perturbed_adj, labels)
+
+if __name__ == '__main__':
+    main()

examples/graph/cgscore_experiments/defense_method/RGCN.py

@@ -0,0 +1,66 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+from deeprobust.graph.defense import RGCN
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset, PrePtbDataset
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='cora', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.0,  help='pertubation rate')
+parser.add_argument('--ptb_type', type=str, default='clean', choices=['clean', 'meta', 'dice', 'minmax', 'pgd', 'random'], help='attack type')
+parser.add_argument('--hidden', type=int, default=16, help='Number of hidden units.')
+parser.add_argument('--dropout', type=float, default=0.5, help='Dropout rate (1 - keep probability).')
+
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# make sure you use the same data splits as you generated attacks
+np.random.seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+
+# Here the random seed is to split the train/val/test data,
+# we need to set the random seed to be the same as that when you generate the perturbed graph
+# data = Dataset(root='/tmp/', name=args.dataset, setting='nettack', seed=15)
+# Or we can just use setting='prognn' to get the splits
+
+# data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+data = Dataset(root='/tmp/', name=args.dataset)
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+
+# adj, features, labels = preprocess(adj, features, labels, preprocess_adj=False)
+
+
+## load from attacked_adj
+ptb_path = f"../attacked_adj/{args.dataset}/{args.ptb_type}_{args.dataset}_{args.ptb_rate}.pt"
+perturbed_adj = torch.load(ptb_path)
+perturbed_adj = perturbed_adj
+
+def test_rgcn(adj):
+    ''' test on GCN '''
+
+    # adj = normalize_adj_tensor(adj)
+    gcn = RGCN(nnodes=adj.shape[0], nfeat=features.shape[1], nclass=labels.max()+1,
+               nhid=args.hidden, device=device)
+    gcn = gcn.to(device)
+    gcn.fit(features, adj, labels, idx_train, idx_val, train_iters=200, verbose=True)
+    gcn.eval()
+    gcn.test(idx_test)
+
+
+def main():
+    
+    test_rgcn(perturbed_adj)
+    # # if you want to save the modified adj/features, uncomment the code below
+    # model.save_adj(root='./', name=f'mod_adj')
+    # model.save_features(root='./', name='mod_features')
+
+if __name__ == '__main__':
+    main()

examples/graph/cgscore_experiments/grb/grb_data.py

@@ -0,0 +1,32 @@
+import torch  # pytorch backend
+from grb.dataset import Dataset
+from grb.model.torch import GCN
+from grb.utils.trainer import Trainer
+
+# Load data
+# name: ["grb-cora", "grb-citeseer", "grb-aminer", "grb-reddit", "grb-flickr"].
+# mode: [["easy", "medium", "hard", "full"]
+# mode: 
+
+dataset = Dataset(name='grb-citeseer', mode='easy',feat_norm='None')
+
+features = dataset.features      # 注意：不是 tensor，而是 scipy.sparse
+adj = dataset.adj            # 是 numpy.ndarray 或 scipy.sparse
+labels = dataset.labels 
+index = dataset.idx_train
+ 
+print(type(features))
+
+print(type(adj))
+print(type(labels))
+print(type(index))
+# model = GCN(in_features=dataset.num_features,
+#             out_features=dataset.num_classes,
+#             hidden_features=[64, 64])
+# # Training
+# adam = torch.optim.Adam(model.parameters(), lr=0.01)
+# trainer = Trainer(dataset=dataset, optimizer=adam,
+#                   loss=torch.nn.functional.nll_loss)
+# trainer.train(model=model, n_epoch=200, dropout=0.1,
+#               train_mode='inductive')
+

examples/graph/cgscore_save.py

@@ -0,0 +1,402 @@
+def calc_cg_score_gnn_with_sampling(   # stable training and defense effect
+    A, X, labels, device, rep_num=1, unbalance_ratio=1, sub_term=False
+):
+    """
+    Optimized CG-score calculation with edge sampling.
+    """
+
+    N = A.shape[0]
+    cg_scores = {
+        "vi": np.zeros((N, N)),
+        "ab": np.zeros((N, N)),
+        "a2": np.zeros((N, N)),
+        "b2": np.zeros((N, N)),
+        "times": np.zeros((N, N)),
+    }
+
+    A = A.to(device)
+    X = X.to(device)
+    labels = labels.to(device)
+
+    @torch.no_grad()
+    def normalize(tensor):
+        return tensor / (torch.norm(tensor, dim=1, keepdim=True) + 1e-8)
+
+    for _ in range(rep_num):
+        AX = torch.matmul(A, X)
+        norm_AX = normalize(AX)
+
+        # Organize data by labels
+        dataset = defaultdict(list)
+        data_idx = defaultdict(list)
+        for i, label in enumerate(labels):
+            dataset[label.item()].append(norm_AX[i].unsqueeze(0))
+            data_idx[label.item()].append(i)
+
+        for label in dataset:
+            dataset[label] = torch.cat(dataset[label], dim=0)
+            data_idx[label] = torch.tensor(data_idx[label], dtype=torch.long, device=device)
+
+        # Cache negative samples
+        neg_samples_dict = {}
+        neg_indices_dict = {}
+        for label in dataset:
+            neg_samples = torch.cat([dataset[l] for l in dataset if l != label])
+            neg_indices = torch.cat([data_idx[l] for l in data_idx if l != label])
+            neg_samples_dict[label] = neg_samples
+            neg_indices_dict[label] = neg_indices
+
+        # for curr_label, curr_samples in dataset.items():
+        for curr_label, curr_samples in tqdm(dataset.items(), desc="Label groups"):
+            curr_indices = data_idx[curr_label]
+            curr_num = len(curr_samples)
+
+            chosen_curr_idx = np.random.choice(range(curr_num), curr_num, replace=False)
+            chosen_curr_samples = curr_samples[chosen_curr_idx]
+            chosen_curr_indices = curr_indices[chosen_curr_idx]
+
+            # Get negative samples
+            neg_samples = neg_samples_dict[curr_label]
+            neg_indices = neg_indices_dict[curr_label]
+            neg_num = min(int(curr_num * unbalance_ratio), len(neg_samples))
+            rand_idx = torch.randperm(len(neg_samples))[:neg_num]
+            chosen_neg_samples = neg_samples[rand_idx]
+            chosen_neg_indices = neg_indices[rand_idx]
+
+            combined_samples = torch.cat([chosen_curr_samples, chosen_neg_samples], dim=0)
+            y = torch.cat([torch.ones(len(chosen_curr_samples)), -torch.ones(neg_num)], dim=0).to(device)
+
+            # Gram matrix H
+            H_inner = torch.matmul(combined_samples, combined_samples.T)
+            H_inner = torch.clamp(H_inner, min=-1.0, max=1.0)
+            H = H_inner * (np.pi - torch.acos(H_inner)) / (2 * np.pi)
+            H.fill_diagonal_(0.5)
+            H += 1e-6 * torch.eye(H.size(0), device=device)
+            invH = torch.inverse(H)
+            original_error = y @ (invH @ y)
+
+            # for idx_i in chosen_curr_indices:
+            for idx_i in tqdm(chosen_curr_indices.tolist(), desc=f"Nodes in label {curr_label}"):
+                for j in range(idx_i + 1, N):
+                    if A[idx_i, j] == 0:
+                        continue
+
+                    # Sparse AX1 update
+                    AX1_i = AX[idx_i] - A[idx_i, j] * X[j]
+                    AX1_j = AX[j] - A[j, idx_i] * X[idx_i]
+
+                    norm_AX1 = norm_AX.clone()
+                    norm_AX1[idx_i] = AX1_i / (torch.norm(AX1_i) + 1e-8)
+                    norm_AX1[j] = AX1_j / (torch.norm(AX1_j) + 1e-8)
+
+                    # Updated samples
+                    curr_samples_A1 = norm_AX1[chosen_curr_indices]
+                    neg_samples_A1 = norm_AX1[chosen_neg_indices]
+                    combined_samples_A1 = torch.cat([curr_samples_A1, neg_samples_A1], dim=0)
+
+                    # Recompute H_A1
+                    H_inner_A1 = torch.matmul(combined_samples_A1, combined_samples_A1.T)
+                    H_inner_A1 = torch.clamp(H_inner_A1, min=-1.0, max=1.0)
+                    H_A1 = H_inner_A1 * (np.pi - torch.acos(H_inner_A1)) / (2 * np.pi)
+                    H_A1.fill_diagonal_(0.5)
+                    H_A1 += 1e-6 * torch.eye(H_A1.size(0), device=device)
+                    invH_A1 = torch.inverse(H_A1)
+                    error_A1 = y @ (invH_A1 @ y)
+
+                    score = (original_error - error_A1).item()
+                    cg_scores["vi"][idx_i, j] += score
+                    cg_scores["vi"][j, idx_i] = cg_scores["vi"][idx_i, j]
+                    cg_scores["times"][idx_i, j] += 1
+                    cg_scores["times"][j, idx_i] += 1
+
+    # Normalize
+    for key in cg_scores:
+        if key != "times":
+            cg_scores[key] = cg_scores[key] / np.where(cg_scores["times"] > 0, cg_scores["times"], 1)
+
+    return cg_scores if sub_term else cg_scores["vi"]
+
+
+def calc_cg_score_gnn_with_sampling(
+    A, X, labels, device, rep_num=1, unbalance_ratio=1, sub_term=False, batch_size=64
+):
+    """
+    Optimized CG-score calculation with edge batching and GPU acceleration.
+    """
+    # if hasattr(torch, "compile"):
+    #     calc_cg_score_gnn_with_sampling = torch.compile(calc_cg_score_gnn_with_sampling)
+
+    N = A.shape[0]
+    cg_scores = {
+        "vi": np.zeros((N, N)),
+        "ab": np.zeros((N, N)),
+        "a2": np.zeros((N, N)),
+        "b2": np.zeros((N, N)),
+        "times": np.zeros((N, N)),
+    }
+
+    A = A.to(device)
+    X = X.to(device)
+    labels = labels.to(device)
+
+    @torch.no_grad()
+    def normalize(tensor):
+        return tensor / (torch.norm(tensor, dim=1, keepdim=True) + 1e-8)
+
+    for _ in range(rep_num):
+        AX = torch.matmul(A, X)
+        norm_AX = normalize(AX)
+
+        # Group nodes by label
+        dataset = defaultdict(list)
+        data_idx = defaultdict(list)
+        for i, label in enumerate(labels):
+            dataset[label.item()].append(norm_AX[i].unsqueeze(0))
+            data_idx[label.item()].append(i)
+
+        for label in dataset:
+            dataset[label] = torch.cat(dataset[label], dim=0)
+            data_idx[label] = torch.tensor(data_idx[label], dtype=torch.long, device=device)
+
+        # Prepare negative samples
+        neg_samples_dict = {}
+        neg_indices_dict = {}
+        for label in dataset:
+            neg_samples = torch.cat([dataset[l] for l in dataset if l != label])
+            neg_indices = torch.cat([data_idx[l] for l in data_idx if l != label])
+            neg_samples_dict[label] = neg_samples
+            neg_indices_dict[label] = neg_indices
+
+        for curr_label, curr_samples in tqdm(dataset.items(), desc="Label groups"):
+            curr_indices = data_idx[curr_label]
+            curr_num = len(curr_samples)
+
+            chosen_curr_idx = np.random.choice(range(curr_num), curr_num, replace=False)
+            chosen_curr_samples = curr_samples[chosen_curr_idx]
+            chosen_curr_indices = curr_indices[chosen_curr_idx]
+
+            neg_samples = neg_samples_dict[curr_label]
+            neg_indices = neg_indices_dict[curr_label]
+            neg_num = min(int(curr_num * unbalance_ratio), len(neg_samples))
+            rand_idx = torch.randperm(len(neg_samples))[:neg_num]
+            chosen_neg_samples = neg_samples[rand_idx]
+            chosen_neg_indices = neg_indices[rand_idx]
+
+            combined_samples = torch.cat([chosen_curr_samples, chosen_neg_samples], dim=0)
+            y = torch.cat([torch.ones(len(chosen_curr_samples)), -torch.ones(neg_num)], dim=0).to(device)
+
+            # Compute reference error
+            H_inner = torch.matmul(combined_samples, combined_samples.T)
+            H_inner = torch.clamp(H_inner, min=-1.0, max=1.0)
+            H = H_inner * (np.pi - torch.acos(H_inner)) / (2 * np.pi)
+            H.fill_diagonal_(0.5)
+            H += 1e-6 * torch.eye(H.size(0), device=device)
+            invH = torch.inverse(H)
+            original_error = y @ (invH @ y)
+
+            # Gather candidate edges
+            edge_batch = []
+            for idx_i in chosen_curr_indices.tolist():
+                for j in range(idx_i + 1, N):
+                    if A[idx_i, j] != 0:
+                        edge_batch.append((idx_i, j))
+
+            # Process in batches
+            for k in tqdm(range(0, len(edge_batch), batch_size), desc="Edge batches", leave=False):
+                batch = edge_batch[k : k + batch_size]
+                B = len(batch)
+
+                norm_AX1_batch = norm_AX.repeat(B, 1, 1)
+                updates = []
+                for b, (i, j) in enumerate(batch):
+                    AX1_i = AX[i] - A[i, j] * X[j]
+                    AX1_j = AX[j] - A[j, i] * X[i]
+                    norm_AX1_batch[b, i] = AX1_i / (torch.norm(AX1_i) + 1e-8)
+                    norm_AX1_batch[b, j] = AX1_j / (torch.norm(AX1_j) + 1e-8)
+
+                sample_idx = chosen_curr_indices.tolist() + chosen_neg_indices.tolist()
+                sample_batch = norm_AX1_batch[:, sample_idx, :]  # [B, M, D]
+
+                H_inner = torch.matmul(sample_batch, sample_batch.transpose(1, 2))
+                H_inner = torch.clamp(H_inner, min=-1.0, max=1.0)
+                H = H_inner * (np.pi - torch.acos(H_inner)) / (2 * np.pi)
+                eye = torch.eye(H.size(-1), device=device).unsqueeze(0).expand_as(H)
+                H = H + 1e-6 * eye
+                H.diagonal(dim1=-2, dim2=-1).copy_(0.5)
+
+                invH = torch.inverse(H)
+                y_expanded = y.unsqueeze(0).expand(B, -1)
+                error_A1 = torch.einsum('bi,bij,bj->b', y_expanded, invH, y_expanded)
+
+                for b, (i, j) in enumerate(batch):
+                    score = (original_error - error_A1[b]).item()
+                    cg_scores["vi"][i, j] += score
+                    cg_scores["vi"][j, i] = cg_scores["vi"][i, j]
+                    cg_scores["times"][i, j] += 1
+                    cg_scores["times"][j, i] += 1
+
+    for key in cg_scores:
+        if key != "times":
+            cg_scores[key] = cg_scores[key] / np.where(cg_scores["times"] > 0, cg_scores["times"], 1)
+
+    return cg_scores if sub_term else cg_scores["vi"]
+
+def calc_cg_score_gnn_with_sampling(      # based on the front code, remove more data to GPU, effect is approxiamate
+    A, X, labels, device, rep_num=1, unbalance_ratio=1, sub_term=False
+):
+    """
+    Calculate CG-score for each edge in a graph with node labels and random sampling.
+
+    Args:
+        A: torch.Tensor
+            Adjacency matrix of the graph (size: N x N).
+        X: torch.Tensor
+            Node features matrix (size: N x F).
+        labels: torch.Tensor
+            Node labels (size: N).
+        device: torch.device
+            Device to perform calculations.
+        rep_num: int
+            Number of repetitions for Monte Carlo sampling.
+        unbalance_ratio: float
+            Ratio of unbalanced data (1:unbalance_ratio).
+        sub_term: bool
+            If True, calculate and return sub-terms.
+
+    Returns:
+        cg_scores: dict
+            Dictionary containing CG-scores for edges and optionally sub-terms.
+    """
+    N = A.shape[0]
+    cg_scores = {
+        "vi": np.zeros((N, N)),
+        "ab": np.zeros((N, N)),
+        "a2": np.zeros((N, N)),
+        "b2": np.zeros((N, N)),
+        "times": np.zeros((N, N)),
+    }
+
+    with torch.no_grad():
+        for _ in range(rep_num):
+            # Compute AX (node representations)
+            AX = torch.matmul(A, X).to(device)
+            norm_AX = AX / torch.norm(AX, dim=1, keepdim=True)
+
+            # Group nodes by their labels
+            dataset = defaultdict(list)
+            data_idx = defaultdict(list)
+            for i, label in enumerate(labels):
+                dataset[label.item()].append(norm_AX[i].unsqueeze(0))  # Store normalized data
+                data_idx[label.item()].append(i)  # Store indices
+
+            # Convert to tensors
+            for label, data_list in dataset.items():
+                dataset[label] = torch.cat(data_list, dim=0)
+                data_idx[label] = torch.tensor(data_idx[label], dtype=torch.long, device=device)
+
+            # Calculate CG-scores for each label group
+            for curr_label, curr_samples in dataset.items():
+                curr_indices = data_idx[curr_label]
+                curr_num = len(curr_samples)
+
+                # Randomly sample a subset of current label examples
+                chosen_curr_idx = np.random.choice(range(curr_num), curr_num, replace=False)
+                chosen_curr_samples = curr_samples[chosen_curr_idx]
+                chosen_curr_indices = curr_indices[chosen_curr_idx]
+
+                # Sample negative examples from other classes
+                neg_samples = torch.cat(
+                    [dataset[l] for l in dataset if l != curr_label], dim=0
+                )
+                neg_indices = torch.cat(
+                    [data_idx[l] for l in data_idx if l != curr_label], dim=0
+                )
+                neg_num = min(int(curr_num * unbalance_ratio), len(neg_samples))
+                chosen_neg_samples = neg_samples[
+                    torch.randperm(len(neg_samples))[:neg_num]
+                ]
+
+                # Combine positive and negative samples
+                combined_samples = torch.cat([chosen_curr_samples, chosen_neg_samples], dim=0)
+                y = torch.cat(
+                    [torch.ones(len(chosen_curr_samples)), -torch.ones(neg_num)], dim=0
+                ).to(device)
+
+                # Compute the Gram matrix H^\infty
+                H_inner = torch.matmul(combined_samples, combined_samples.T)
+                del combined_samples
+                ###
+                H_inner = torch.clamp(H_inner, min=-1.0, max=1.0)
+                ###
+                H = H_inner * (np.pi - torch.acos(H_inner)) / (2 * np.pi)
+                del H_inner
+
+                H.fill_diagonal_(0.5)
+                ##
+                epsilon = 1e-6
+                H = H + epsilon * torch.eye(H.size(0), device=H.device)
+                ##
+                invH = torch.inverse(H)
+                del H
+                original_error = y @ (invH @ y)
+
+                # Compute CG-scores for each edge
+                for i in chosen_curr_indices:
+                    print("the node index:", i)
+                    for j in range(i + 1, N):  # Upper triangular traversal
+                        # print(j)
+                        if A[i, j] == 0:  # Skip if no edge exists
+                            continue
+
+                        # Remove edge (i, j) to create A1
+                        A1 = A.clone()
+                        A1[i, j] = A1[j, i] = 0
+
+                        # Recompute AX with A1
+                        AX1 = torch.matmul(A1, X).to(device)
+                        norm_AX1 = AX1 / torch.norm(AX1, dim=1, keepdim=True)
+
+                        # Repeat error calculation with A1
+                        curr_samples_A1 = norm_AX1[chosen_curr_indices]
+                        neg_samples_A1 = norm_AX1[neg_indices]
+                        chosen_neg_samples_A1 = neg_samples_A1[
+                            torch.randperm(len(neg_samples_A1))[:neg_num]
+                        ]
+                        combined_samples_A1 = torch.cat(
+                            [curr_samples_A1, chosen_neg_samples_A1], dim=0
+                        )
+                        H_inner_A1 = torch.matmul(combined_samples_A1, combined_samples_A1.T)
+
+                        del combined_samples_A1
+                        
+                        ### trick1
+                        H_inner_A1 = torch.clamp(H_inner_A1, min=-1.0, max=1.0)
+                        ###
+
+                        H_A1 = H_inner_A1 * (np.pi - torch.acos(H_inner_A1)) / (2 * np.pi)
+                        del H_inner_A1
+                        H_A1.fill_diagonal_(0.5)
+
+                        ### trick2
+                        epsilon = 1e-6
+                        H_A1= H_A1 + epsilon * torch.eye(H_A1.size(0), device=H_A1.device)
+                        ###
+                        invH_A1 = torch.inverse(H_A1)
+                        del H_A1
+
+                        error_A1 = y @ (invH_A1 @ y)
+                         
+                        print("i:", i)
+                        print("j:", j)
+                        print("current score:", (original_error - error_A1).item())
+                        # Compute the difference in error (CG-score)
+                        cg_scores["vi"][i, j] += (original_error - error_A1).item()
+                        cg_scores["vi"][j, i] = cg_scores["vi"][i, j]  # Symmetric
+                        cg_scores["times"][i, j] += 1
+                        cg_scores["times"][j, i] += 1
+
+    # Normalize CG-scores by repetition count
+    for key, values in cg_scores.items():
+        if key == "times":
+            continue
+        cg_scores[key] = values / np.where(cg_scores["times"] > 0, cg_scores["times"], 1)

examples/graph/test_adv_train_evasion.py

@@ -0,0 +1,112 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+import torch.optim as optim
+from deeprobust.graph.defense import GCN
+from deeprobust.graph.global_attack import Random
+from deeprobust.graph.targeted_attack import Nettack
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset
+from deeprobust.graph.data import PtbDataset
+from tqdm import tqdm
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='citeseer', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.05,  help='pertubation rate')
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# make sure you use the same data splits as you generated attacks
+np.random.seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+
+# load original dataset (to get clean features and labels)
+data = Dataset(root='/tmp/', name=args.dataset)
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+
+# Setup Target Model
+model = GCN(nfeat=features.shape[1], nclass=labels.max()+1,
+                nhid=16, dropout=0, with_relu=False, with_bias=True, device=device)
+
+model = model.to(device)
+
+# test on original adj
+print('=== test on original adj ===')
+model.fit(features, adj, labels, idx_train)
+output = model.output
+acc_test = accuracy(output[idx_test], labels[idx_test])
+print("Test set results:",
+      "accuracy= {:.4f}".format(acc_test.item()))
+
+print('=== Adversarial Training for Evasion Attack===')
+adversary = Random()
+adv_train_model = GCN(nfeat=features.shape[1], nclass=labels.max()+1,
+                nhid=16, dropout=0, with_relu=False, with_bias=True, device=device)
+
+adv_train_model = adv_train_model.to(device)
+
+adv_train_model.initialize()
+n_perturbations = int(0.01 * (adj.sum()//2))
+for i in tqdm(range(100)):
+    # modified_adj = adversary.attack(features, adj)
+    adversary.attack(adj, n_perturbations=n_perturbations, type='add')
+    modified_adj = adversary.modified_adj
+    adv_train_model.fit(features, modified_adj, labels, idx_train, train_iters=50, initialize=False)
+
+adv_train_model.eval()
+# test directly or fine tune
+print('=== test on perturbed adj ===')
+output = adv_train_model.predict()
+acc_test = accuracy(output[idx_test], labels[idx_test])
+print("Test set results:",
+      "accuracy= {:.4f}".format(acc_test.item()))
+
+
+# set up Surrogate & Nettack to attack the graph
+import random
+target_nodes = random.sample(idx_test.tolist(), 20)
+# Setup Surrogate model
+surrogate = GCN(nfeat=features.shape[1], nclass=labels.max().item()+1,
+                nhid=16, dropout=0, with_relu=False, with_bias=False, device=device)
+surrogate = surrogate.to(device)
+surrogate.fit(features, adj, labels, idx_train)
+
+all_margins = []
+all_adv_margins = []
+
+for target_node in target_nodes:
+    # set up Nettack
+    adversary = Nettack(surrogate, nnodes=adj.shape[0], attack_structure=True, attack_features=True, device=device)
+    adversary = adversary.to(device)
+    degrees = adj.sum(0).A1
+    n_perturbations = int(degrees[target_node]) + 2
+    adversary.attack(features, adj, labels, target_node, n_perturbations)
+    perturbed_adj = adversary.modified_adj
+
+    model = GCN(nfeat=features.shape[1], nclass=labels.max()+1,
+            nhid=16, dropout=0, with_relu=False, with_bias=True, device=device)
+    model = model.to(device)
+
+    print('=== testing GCN on perturbed graph ===')
+    model.fit(features, perturbed_adj, labels, idx_train)
+    output = model.output
+    margin = classification_margin(output[target_node], labels[target_node])
+    all_margins.append(margin)
+
+    print('=== testing adv-GCN on perturbed graph ===')
+    output = adv_train_model.predict(features, perturbed_adj)
+    adv_margin = classification_margin(output[target_node], labels[target_node])
+    all_adv_margins.append(adv_margin)
+
+
+print("No adversarial training: classfication margin for {0} nodes: {1}".format(len(target_nodes), np.mean(all_margins)))
+
+print("Adversarial training: classfication margin for {0} nodes: {1}".format(len(target_nodes), np.mean(all_adv_margins)))
+

examples/graph/test_adv_train_poisoning.py

@@ -0,0 +1,78 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+import torch.optim as optim
+from deeprobust.graph.defense import GCN
+from deeprobust.graph.global_attack import Random
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset
+from deeprobust.graph.data import PtbDataset
+
+import argparse
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='citeseer', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.05,  help='pertubation rate')
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# make sure you use the same data splits as you generated attacks
+np.random.seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+
+# load original dataset (to get clean features and labels)
+data = Dataset(root='/tmp/', name=args.dataset)
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+
+# load pre-attacked graph
+perturbed_data = PtbDataset(root='/tmp/', name=args.dataset)
+perturbed_adj = perturbed_data.adj
+
+# Setup Target Model
+model = GCN(nfeat=features.shape[1], nclass=labels.max()+1,
+                nhid=16, dropout=0, with_relu=False, with_bias=True, device=device)
+
+model = model.to(device)
+
+adversary = Random()
+# test on original adj
+print('=== test on original adj ===')
+model.fit(features, adj, labels, idx_train)
+output = model.output
+acc_test = accuracy(output[idx_test], labels[idx_test])
+print("Test set results:",
+      "accuracy= {:.4f}".format(acc_test.item()))
+
+print('=== testing GCN on perturbed graph ===')
+model.fit(features, perturbed_adj, labels, idx_train)
+output = model.output
+acc_test = accuracy(output[idx_test], labels[idx_test])
+print("Test set results:",
+      "accuracy= {:.4f}".format(acc_test.item()))
+
+
+# For poisoning attack, the adjacency matrix you have
+# is alreay perturbed
+print('=== Adversarial Training for Poisoning Attack===')
+model.initialize()
+n_perturbations = int(0.01 * (adj.sum()//2))
+for i in range(100):
+    # modified_adj = adversary.attack(features, adj)
+    adversary.attack(perturbed_adj, n_perturbations=n_perturbations, type='remove')
+    modified_adj = adversary.modified_adj
+    model.fit(features, modified_adj, labels, idx_train, train_iters=50, initialize=False)
+
+model.eval()
+
+# test directly or fine tune
+print('=== test on perturbed adj ===')
+output = model.predict(features, perturbed_adj)
+acc_test = accuracy(output[idx_test], labels[idx_test])
+print("Test set results:",
+      "accuracy= {:.4f}".format(acc_test.item()))
+

examples/graph/test_all.py

@@ -0,0 +1,13 @@
+import os
+import os.path as osp
+
+for file in os.listdir('./'):
+    if "py" not in file:
+        continue
+    if 'rl' in file or 'nipa' in file or 'meta' in file or 'all' in file:
+        continue
+    if osp.isfile(file):
+        print(file)
+        os.system('CUDA_VISIBLE_DEVICES=0 python %s' % file)
+
+

examples/graph/test_chebnet.py

@@ -0,0 +1,48 @@
+import torch
+import argparse
+from deeprobust.graph.data import Dataset, Dpr2Pyg
+from deeprobust.graph.defense import ChebNet
+from deeprobust.graph.data import Dataset
+from deeprobust.graph.data import PrePtbDataset
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='cora', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.05,  help='perturbation rate')
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# use data splist provided by prognn
+data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+
+cheby = ChebNet(nfeat=features.shape[1],
+      nhid=16, num_hops=3,
+      nclass=labels.max().item() + 1,
+      dropout=0.5, device=device)
+cheby = cheby.to(device)
+
+# test on clean graph
+print('==================')
+print('=== train on clean graph ===')
+
+pyg_data = Dpr2Pyg(data)
+cheby.fit(pyg_data, verbose=True) # train with earlystopping
+cheby.test()
+
+# load pre-attacked graph by Zugner: https://github.com/danielzuegner/gnn-meta-attack
+print('==================')
+print('=== load graph perturbed by Zugner metattack (under prognn splits) ===')
+perturbed_data = PrePtbDataset(root='/tmp/',
+        name=args.dataset,
+        attack_method='meta',
+        ptb_rate=args.ptb_rate)
+perturbed_adj = perturbed_data.adj
+pyg_data.update_edge_index(perturbed_adj) # inplace operation
+cheby.fit(pyg_data, verbose=True) # train with earlystopping
+cheby.test()
+

examples/graph/test_deepwalk.py

@@ -0,0 +1,39 @@
+from deeprobust.graph.data import Dataset
+from deeprobust.graph.defense import DeepWalk, Node2Vec
+from deeprobust.graph.global_attack import NodeEmbeddingAttack
+import numpy as np
+
+dataset_str = 'cora_ml'
+data = Dataset(root='/tmp/', name=dataset_str, seed=15)
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+
+attacker = NodeEmbeddingAttack()
+attacker.attack(adj, attack_type="remove", n_perturbations=1000)
+modified_adj = attacker.modified_adj
+
+# train defense model
+print("Test DeepWalk on clean graph")
+model = DeepWalk()
+model.fit(adj)
+model.evaluate_node_classification(labels, idx_train, idx_test)
+# model.evaluate_node_classification(labels, idx_train, idx_test, lr_params={"max_iter": 1000})
+
+print("Test DeepWalk on attacked graph")
+model.fit(modified_adj)
+model.evaluate_node_classification(labels, idx_train, idx_test)
+
+print("Test DeepWalk on link prediciton...")
+model.evaluate_link_prediction(modified_adj, np.array(adj.nonzero()).T)
+
+print("Test DeepWalk SVD on attacked graph")
+model = DeepWalk(type="svd")
+model.fit(modified_adj)
+model.evaluate_node_classification(labels, idx_train, idx_test)
+
+print("Test Node2vec on attacked graph")
+model = Node2Vec()
+model.fit(modified_adj)
+model.evaluate_node_classification(labels, idx_train, idx_test)
+
+

examples/graph/test_gat.py

@@ -0,0 +1,55 @@
+import torch
+import argparse
+from deeprobust.graph.data import Dataset, Dpr2Pyg
+from deeprobust.graph.defense import GAT
+from deeprobust.graph.data import Dataset
+from deeprobust.graph.data import PrePtbDataset
+import scipy.sparse as sp
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='cora', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.10,  help='perturbation rate')
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# use data splist provided by prognn
+data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+
+gat = GAT(nfeat=features.shape[1],
+      nhid=8, heads=8,
+      nclass=labels.max().item() + 1,
+      dropout=0.5, device=device)
+gat = gat.to(device)
+
+
+# test on clean graph
+print('==================')
+print('=== train on clean graph ===')
+
+print(type(features))
+print(type(adj))
+pyg_data = Dpr2Pyg(data)
+gat.fit(pyg_data, verbose=True) # train with earlystopping
+gat.test()
+
+# load pre-attacked graph by Zugner: https://github.com/danielzuegner/gnn-meta-attack
+print('==================')
+print('=== load graph perturbed by Zugner metattack (under prognn splits) ===')
+perturbed_data = PrePtbDataset(root='/tmp/',
+        name=args.dataset,
+        attack_method='meta',
+        ptb_rate=args.ptb_rate)
+perturbed_adj = perturbed_data.adj
+pyg_data.update_edge_index(perturbed_adj) # inplace operation
+gat.fit(pyg_data, verbose=True) # train with earlystopping
+gat.test()
+
+
+
+

examples/graph/test_gcn.py

@@ -0,0 +1,69 @@
+import torch
+import numpy as np
+import torch.nn.functional as F
+from deeprobust.graph.defense import GCN
+from deeprobust.graph.utils import *
+from deeprobust.graph.data import Dataset
+from deeprobust.graph.data import PtbDataset, PrePtbDataset
+import argparse
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--seed', type=int, default=15, help='Random seed.')
+parser.add_argument('--dataset', type=str, default='citeseer', choices=['cora', 'cora_ml', 'citeseer', 'polblogs', 'pubmed'], help='dataset')
+parser.add_argument('--ptb_rate', type=float, default=0.05,  help='pertubation rate')
+
+args = parser.parse_args()
+args.cuda = torch.cuda.is_available()
+print('cuda: %s' % args.cuda)
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+# Here the random seed is to split the train/val/test data,
+# we need to set the random seed to be the same as that when you generate the perturbed graph
+# data = Dataset(root='/tmp/', name=args.dataset, setting='nettack', seed=15)
+# Or we can just use setting='prognn' to get the splits
+data = Dataset(root='/tmp/', name=args.dataset, setting='prognn')
+adj, features, labels = data.adj, data.features, data.labels
+idx_train, idx_val, idx_test = data.idx_train, data.idx_val, data.idx_test
+
+
+# load pre-attacked graph by Zugner: https://github.com/danielzuegner/gnn-meta-attack
+print('==================')
+print('=== load graph perturbed by Zugner metattack (under prognn splits) ===')
+perturbed_data = PrePtbDataset(root='/tmp/',
+        name=args.dataset,
+        attack_method='meta',
+        ptb_rate=args.ptb_rate)
+# perturbed_adj = perturbed_data.adj
+perturbed_adj = adj
+
+np.random.seed(args.seed)
+torch.manual_seed(args.seed)
+if args.cuda:
+    torch.cuda.manual_seed(args.seed)
+
+# Setup GCN Model
+model = GCN(nfeat=features.shape[1], nhid=16, nclass=labels.max()+1, device=device)
+model = model.to(device)
+
+# model.fit(features, perturbed_adj, labels, idx_train, train_iters=200, verbose=True)
+# # using validation to pick model
+model.fit(features, perturbed_adj, labels, idx_train, idx_val, train_iters=200, verbose=True)
+model.eval()
+# You can use the inner function of model to test
+model.test(idx_test)
+
+# print('==================')
+# print('=== load graph perturbed by DeepRobust 5% metattack (under prognn splits) ===')
+# perturbed_data = PtbDataset(root='/tmp/',
+#                     name=args.dataset,
+#                     attack_method='meta')
+# perturbed_adj = perturbed_data.adj
+
+# print("dataset:", args.dataset)
+# # model.fit(features, perturbed_adj, labels, idx_train, train_iters=200, verbose=True)
+# # # using validation to pick model
+# model.fit(features, perturbed_adj, labels, idx_train, idx_val, train_iters=200, verbose=True)
+# model.eval()
+# # You can use the inner function of model to test
+# model.test(idx_test)
+