def __init__(self, in_features, out_features, *, hids=[64], acts=['relu'], dropout=0.5, gamma=1., bias=False): super().__init__() assert len(hids) > 0 and len(acts) > 0 # The first layer that conver node features to distribution self.conv1 = GaussionConvF(in_features, hids[0], gamma=gamma, bias=bias) self.act1 = activations.get(acts[0]) in_features = hids[0] conv2 = nn.ModuleList() act2 = nn.ModuleList() for hid, act in zip(hids[1:], acts[1:]): conv2.append( GaussionConvD(in_features, hid, gamma=gamma, bias=bias)) act2.append(activations.get(act)) in_features = hid conv2.append(GaussionConvD(in_features, out_features, bias=bias)) self.conv2 = conv2 self.act2 = act2 self.dropout = nn.Dropout(dropout)
def __init__(self, in_features, out_features, hids=[64], acts=[None], lambda_=5.0, gamma=0.1, dropout=0.5, weight_decay=5e-4, lr=0.01, bias=False): super().__init__() self.lambda_ = lambda_ self.gamma = gamma assert hids, "hids should not empty" layers = nn.ModuleList() act_layers = nn.ModuleList() inc = in_features for hid, act in zip(hids, acts): layers.append(GCNConv(in_features, hid, bias=bias)) act_layers.append(activations.get(act)) inc = hid layers.append(GCNConv(inc, out_features, bias=bias)) act_layers.append(activations.get(None)) self.layers = layers self.act_layers = act_layers self.scores = nn.ParameterList() self.bias = nn.ParameterList() self.D_k = nn.ParameterList() self.D_bias = nn.ParameterList() for hid in [in_features] + hids: self.scores.append(nn.Parameter(torch.FloatTensor(hid, 1))) self.bias.append(nn.Parameter(torch.FloatTensor(1))) self.D_k.append(nn.Parameter(torch.FloatTensor(hid, 1))) self.D_bias.append(nn.Parameter(torch.FloatTensor(1))) # discriminator for ssl self.linear = nn.Linear(hids[-1], 1) self.compile(loss=nn.CrossEntropyLoss(), optimizer=optim.Adam(self.parameters(), lr=lr, weight_decay=weight_decay), metrics=[Accuracy()]) self.dropout = nn.Dropout(dropout) self.reset_parameters()
def __init__(self, in_features: int, out_features: int, hids: list = [16], acts: list = ['relu'], dropout: float = 0.5, bias: bool = True, gamma: float = 1.0): r""" Parameters ---------- in_features : int, the input dimmensions of model out_features : int, the output dimensions of model hids : list, optional the number of hidden units of each hidden layer, by default [16] acts : list, optional the activaction function of each hidden layer, by default ['relu'] dropout : float, optional the dropout ratio of model, by default 0.5 bias : bool, optional whether to use bias in the layers, by default True gamma : float, optional the attention weight, by default 1.0 """ super().__init__() assert len(hids) == len(acts) and len(hids) > 0 self.conv1 = RobustConv(in_features, hids[0], bias=bias, activation=activations.get(acts[0])) conv2 = nn.ModuleList() in_features = hids[0] for hid, act in zip(hids[1:], acts[1:]): conv2.append( RobustConv(in_features, hid, bias=bias, gamma=gamma, activation=activations.get(act))) in_features = hid conv2.append( RobustConv(in_features, out_features, gamma=gamma, bias=bias)) self.conv2 = conv2 self.dropout = nn.Dropout(dropout)
def __init__(self, in_features, out_features, hids=[16], acts=['relu'], dropout=0.5, S=1, K=4, temp=0.5, lam=1., bias=False, bn=False): super().__init__() mlp = [] for hid, act in zip(hids, acts): if bn: mlp.append(nn.BatchNorm1d(in_features)) mlp.append(nn.Linear(in_features, hid, bias=bias)) mlp.append(activations.get(act)) mlp.append(nn.Dropout(dropout)) in_features = hid if bn: mlp.append(nn.BatchNorm1d(in_features)) mlp.append(nn.Linear(in_features, out_features, bias=bias)) self.mlp = mlp = nn.Sequential(*mlp) self.K = K self.temp = temp self.lam = lam self.dropout = dropout self.S = S
def __init__(self, in_features, out_features, *, alpha=0.1, K=10, ppr_dropout=0., hids=[64], acts=['relu'], dropout=0.5, bias=True, approximated=True): super().__init__() lin = [] lin.append(nn.Dropout(dropout)) for hid, act in zip(hids, acts): lin.append(nn.Linear(in_features, hid, bias=bias)) lin.append(activations.get(act)) lin.append(nn.Dropout(dropout)) in_features = hid lin.append(nn.Linear(in_features, out_features, bias=bias)) lin = nn.Sequential(*lin) self.lin = lin if approximated: self.propagation = APPNProp(alpha=alpha, K=K, dropout=ppr_dropout) else: self.propagation = PPNProp(dropout=ppr_dropout) self.reg_paras = lin[1].parameters() self.non_reg_paras = lin[2:].parameters()
def __init__(self, in_features, out_features, hids=[16], acts=['relu'], bn=False, dropout=0.5, bias=False): super().__init__() lin = [] lin.append(nn.Dropout(dropout)) for hid, act in zip(hids, acts): if bn: lin.append(nn.BatchNorm1d(in_features)) lin.append(nn.Linear(in_features, hid, bias=bias)) lin.append(activations.get(act)) lin.append(nn.Dropout(dropout)) in_features = hid if bn: lin.append(nn.BatchNorm1d(in_features)) lin.append(nn.Linear(in_features, out_features, bias=bias)) lin = nn.Sequential(*lin) self.lin = lin
def __init__(self, in_features, out_features, hids=[16], acts=['relu'], dropout=0.5, weight_decay=5e-4, lr=0.01, bias=False): super().__init__() lin = [] lin.append(nn.Dropout(dropout)) for hid, act in zip(hids, acts): lin.append(nn.Linear(in_features, hid, bias=bias)) lin.append(activations.get(act)) lin.append(nn.Dropout(dropout)) in_features = hid lin.append(nn.Linear(in_features, out_features, bias=bias)) lin = nn.Sequential(*lin) self.lin = lin self.compile( loss=nn.CrossEntropyLoss(), optimizer=optim.Adam([ dict(params=lin[1].parameters(), weight_decay=weight_decay), dict(params=lin[2:].parameters(), weight_decay=0.), ], lr=lr), metrics=[Accuracy()])
def __init__(self, in_features, out_features, edge_features, *, hids=[32], pdn_hids=32, acts=['relu'], dropout=0.5, weight_decay=5e-4, lr=0.01, bias=True): super().__init__() conv = [] for hid, act in zip(hids, acts): conv.append(GCNConv(in_features, hid, bias=bias)) conv.append(activations.get(act)) conv.append(nn.Dropout(dropout)) in_features = hid conv.append(GCNConv(in_features, out_features, bias=bias)) conv = Sequential(*conv) self.fc = nn.Sequential(nn.Linear(edge_features, pdn_hids), nn.ReLU(), nn.Linear(pdn_hids, 1), nn.Sigmoid()) self.conv = conv self.compile(loss=nn.CrossEntropyLoss(), optimizer=optim.Adam(self.parameters(), lr=lr, weight_decay=weight_decay), metrics=[Accuracy()])
def __init__(self, in_features, out_features, num_nodes, *, hids=[16], acts=['relu'], dropout=0.5, bias=False): super().__init__() conv = [] conv.append(nn.Dropout(dropout)) for hid, act in zip(hids, acts): conv.append( WaveletConv(in_features, hid, num_nodes=num_nodes, bias=bias)) conv.append(activations.get(act)) conv.append(nn.Dropout(dropout)) in_features = hid conv.append( WaveletConv(in_features, out_features, num_nodes=num_nodes, bias=bias)) conv = Sequential(*conv) self.conv = conv
def __init__(self, in_features, out_features, hids=[16], acts=['relu'], dropout=0.5, bias=True): super().__init__() conv = [] conv.append(nn.Dropout(dropout)) for hid, act in zip(hids, acts): conv.append( GCNConv(in_features, hid, cached=True, bias=bias, normalize=False)) conv.append(activations.get(act)) conv.append(nn.Dropout(dropout)) in_features = hid conv.append( GCNConv(in_features, out_features, cached=True, bias=bias, normalize=False)) conv = Sequential(*conv) self.conv = conv self.reg_paras = conv[1].parameters() self.non_reg_paras = conv[2:].parameters()
def __init__(self, in_features, out_features, p=0.3, hids=[16], acts=['relu'], dropout=0.5, weight_decay=5e-4, lr=0.01, bias=True): super().__init__() conv = [] conv.append(nn.Dropout(dropout)) for hid, act in zip(hids, acts): conv.append( GCNConv(in_features, hid, cached=True, bias=bias, normalize=False)) conv.append(activations.get(act)) conv.append(nn.Dropout(dropout)) in_features = hid conv.append( GCNConv(in_features, out_features, cached=True, bias=bias, normalize=False)) conv = Sequential(*conv) self.p = p self.conv = conv
def __init__(self, in_features, out_features, num_nodes, *, eta=0.1, hids=[16], acts=['relu'], dropout=0.2, bias=False): super().__init__() assert hids, "LATGCN requires hidden layers" conv = [] conv.append(nn.Dropout(dropout)) for hid, act in zip(hids, acts): conv.append(GCNConv(in_features, hid, bias=bias)) conv.append(activations.get(act)) conv.append(nn.Dropout(dropout)) in_features = hid conv.append(GCNConv(in_features, out_features, bias=bias)) conv = Sequential(*conv) self.zeta = nn.Parameter(torch.randn(num_nodes, hids[0])) self.conv1 = conv[:3] # includes dropout, ReLU and the first GCN layer self.conv2 = conv[3:] # the remaining self.eta = eta self.reg_paras = self.conv1.parameters() self.non_reg_paras = self.conv2.parameters()
def __init__(self, in_features, out_features, hids=[16], acts=['relu'], dropout=0.5, bias=True): super().__init__() conv = [] for hid, act in zip(hids, acts): conv.append(MedianConv(in_features, hid, add_self_loops=False, bias=bias)) conv.append(activations.get(act)) conv.append(nn.Dropout(dropout)) in_features = hid conv.append(MedianConv(in_features, out_features, add_self_loops=False, bias=bias)) conv = Sequential(*conv) self.conv = conv self.reg_paras = conv[0].parameters() self.non_reg_paras = conv[1:].parameters()
def __init__(self, in_features, out_features, hids=[16], acts=['relu'], alpha=0.45, dropout=0.5, bias=False): super().__init__() conv = [] conv.append(nn.Dropout(dropout)) for hid, act in zip(hids, acts): conv.append(TrimmedConv(in_features, hid, bias=bias, alpha=alpha)) conv.append(activations.get(act)) conv.append(nn.Dropout(dropout)) in_features = hid conv.append(TrimmedConv(in_features, out_features, bias=bias, alpha=alpha)) conv = Sequential(*conv) self.conv = conv self.reg_paras = conv[1].parameters() self.non_reg_paras = conv[2:].parameters()
def __init__(self, in_features, out_features, *, hids=[16], num_attn=2, acts=['relu'], dropout=0.5, bias=False): super().__init__() conv = [] for hid, act in zip(hids, acts): conv.append(nn.Linear(in_features, hid, bias=bias)) conv.append(activations.get(act)) conv.append(nn.Dropout(dropout)) in_features = hid # for Cora dataset, the first propagation layer is non-trainable # and beta is fixed at 0 conv.append(AGNNConv(trainable=False)) for _ in range(1, num_attn): conv.append(AGNNConv()) conv.append(nn.Linear(in_features, out_features, bias=bias)) conv.append(nn.Dropout(dropout)) conv = Sequential(*conv) self.conv = conv
def __init__(self, in_features, out_features, *, alpha=0.1, K=10, ppr_dropout=0., hids=[64], acts=['relu'], dropout=0.5, bias=True): super().__init__() lin = [] lin.append(nn.Dropout(dropout)) for hid, act in zip(hids, acts): lin.append(nn.Linear(in_features, hid, bias=bias)) lin.append(activations.get(act)) lin.append(nn.Dropout(dropout)) in_features = hid lin.append(nn.Linear(in_features, out_features, bias=bias)) lin = nn.Sequential(*lin) self.lin = lin self.propagation = APPNPConv(K, alpha, ppr_dropout)
def __init__(self, in_features, out_features, *, hids=[16], acts=['relu'], dropout=0.5, weight_decay=5e-4, lr=0.01, bias=False): super().__init__() conv = [] for hid, act in zip(hids, acts): conv.append(nn.Linear(in_features, hid, bias=bias)) conv.append(activations.get(act)) conv.append(nn.Dropout(dropout)) in_features = hid conv.append(GraphConvolution(in_features, out_features, bias=bias)) conv = Sequential(*conv) self.conv = conv self.compile( loss=nn.CrossEntropyLoss(), optimizer=optim.Adam([ dict(params=conv[0].parameters(), weight_decay=weight_decay), dict(params=conv[1:].parameters(), weight_decay=0.) ], lr=lr), metrics=[Accuracy()])
def __init__(self, in_features, out_features, K=10, alpha=0.1, hids=[], acts=[], dropout=0.5, bias=False): super().__init__() lin = [] lin.append(nn.Dropout(dropout)) for hid, act in zip(hids, acts): lin.append(nn.Linear(in_features, hid, bias=bias)) lin.append(activations.get(act)) lin.append(nn.Dropout(dropout)) in_features = hid lin = nn.Sequential(*lin) conv = SpectralEigenConv(in_features, out_features, bias=bias, K=K, alpha=alpha) self.lin = lin self.conv = conv
def __init__(self, in_features, *, out_features=16, hids=[32], acts=['relu'], dropout=0.5, bias=False): super().__init__() encoder = [] for hid, act in zip(hids, acts): encoder.append( GCNConv(in_features, hid, cached=True, bias=bias, normalize=True)) encoder.append(activations.get(act)) encoder.append(nn.Dropout(dropout)) in_features = hid encoder.append( GCNConv(in_features, out_features, cached=True, bias=bias, normalize=True)) self.encoder = Sequential(*encoder) self.decoder = InnerProductDecoder()
def __init__(self, in_features, out_features, *, alpha=1.0, epsilon=0.9, hids=[16], acts=['relu'], dropout=0., weight_decay=5e-4, lr=0.01, bias=False): super().__init__() conv = [] conv.append(nn.Dropout(dropout)) for hid, act in zip(hids, acts): conv.append(GCNConv(in_features, hid, bias=bias)) conv.append(activations.get(act)) conv.append(nn.Dropout(dropout)) in_features = hid conv.append(GCNConv(in_features, out_features, bias=bias)) conv = Sequential(*conv) self.conv = conv self.compile( loss=nn.CrossEntropyLoss(), optimizer=optim.Adam([ dict(params=conv[1].parameters(), weight_decay=weight_decay), dict(params=conv[2:].parameters(), weight_decay=0.) ], lr=lr), metrics=[Accuracy()]) self.alpha = alpha self.epsilon = epsilon
def __init__(self, in_features, out_features, mapsize_a, mapsize_b, conv_channel=64, hids=[200], acts=['relu6'], attnum=10, dropout=0.6, bias=True): super().__init__() self.conv = nn.Sequential( nn.Conv2d(in_channels=in_features, out_channels=conv_channel, kernel_size=(2, 1), stride=1, padding=0), nn.Softmax(dim=1), ) lin = [] in_features = (mapsize_a - 1) * mapsize_b * conv_channel for hid, act in zip(hids, acts): lin.append(nn.Linear(in_features, hid, bias=bias)) lin.append(activations.get(act)) lin.append(nn.Dropout(dropout)) in_features = hid lin.append(nn.Linear(in_features, out_features, bias=bias)) self.lin = nn.Sequential(*lin) self.attention = nn.Parameter( torch.ones(attnum, mapsize_a - 1, mapsize_b))
def __init__(self, in_features, out_features, in_edge_features, *, hids=[32], pdn_hids=32, acts=['relu'], dropout=0.5, bias=True): super().__init__() conv = [] for hid, act in zip(hids, acts): conv.append(GCNConv(in_features, hid, bias=bias)) conv.append(activations.get(act)) conv.append(nn.Dropout(dropout)) in_features = hid conv.append(GCNConv(in_features, out_features, bias=bias)) conv = Sequential(*conv) self.fc = nn.Sequential(nn.Linear(in_edge_features, pdn_hids), nn.ReLU(), nn.Linear(pdn_hids, 1), nn.Sigmoid()) self.conv = conv
def __init__(self, in_features, out_features, hids=[64], acts=[None], gamma=0.1, dropout=0.5, bias=False): super().__init__() self.gamma = gamma assert hids, "hids should not empty" layers = nn.ModuleList() act_layers = nn.ModuleList() inc = in_features for hid, act in zip(hids, acts): layers.append(GCNConv(in_features, hid, bias=bias)) act_layers.append(activations.get(act)) inc = hid layers.append(GCNConv(inc, out_features, bias=bias)) act_layers.append(activations.get(None)) self.layers = layers self.act_layers = act_layers self.scores = nn.ParameterList() self.bias = nn.ParameterList() self.D_k = nn.ParameterList() self.D_bias = nn.ParameterList() for hid in [in_features] + hids: self.scores.append(nn.Parameter(torch.FloatTensor(hid, 1))) self.bias.append(nn.Parameter(torch.FloatTensor(1))) self.D_k.append(nn.Parameter(torch.FloatTensor(hid, 1))) self.D_bias.append(nn.Parameter(torch.FloatTensor(1))) # discriminator for ssl self.linear = nn.Linear(hids[-1], 1) self.dropout = nn.Dropout(dropout) self._adj_knn = None self.reset_parameters()
def __init__(self, in_features, out_features, *, hids=[64], acts=['relu'], dropout=0.5, bias=False, K=10): super().__init__() lin = [] for hid, act in zip(hids, acts): lin.append(nn.Dropout(dropout)) lin.append(nn.Linear(in_features, hid, bias=bias)) lin.append(activations.get(act)) in_features = hid lin.append(nn.Linear(in_features, out_features, bias=bias)) lin.append(activations.get(act)) lin.append(nn.Dropout(dropout)) lin = nn.Sequential(*lin) self.lin = lin self.conv = DAGNNConv(out_features, K=K, bias=bias)
def __init__(self, in_features, out_features, act='gelu', dropout=0.6, bias=True): super().__init__() self.fc1 = nn.Linear(in_features, out_features, bias=bias) self.fc2 = nn.Linear(out_features, out_features, bias=bias) self.act = activations.get(act) self.dropout = nn.Dropout(dropout) self.layernorm = nn.LayerNorm(out_features, eps=1e-6) self.reset_parameters()
def __init__(self, in_features, out_features, hids=[8], num_heads=[8], acts=['elu'], dropout=0.6, weight_decay=5e-4, lr=0.01, bias=True): super().__init__() head = 1 conv = [] conv.append(nn.Dropout(dropout)) for hid, num_head, act in zip(hids, num_heads, acts): conv.append( GATConv(in_features * head, hid, heads=num_head, bias=bias, dropout=dropout)) conv.append(activations.get(act)) conv.append(nn.Dropout(dropout)) in_features = hid head = num_head conv.append( GATConv(in_features * head, out_features, heads=1, bias=bias, concat=False, dropout=dropout)) conv = Sequential(*conv) self.conv = conv self.compile( loss=nn.CrossEntropyLoss(), optimizer=optim.Adam([ dict(params=conv[1].parameters(), weight_decay=weight_decay), dict(params=conv[2:].parameters(), weight_decay=0.) ], lr=lr), metrics=[Accuracy()])
def __init__(self, in_features, out_features, p=0.3, hids=[16], acts=['relu'], dropout=0.5, weight_decay=5e-4, kl=0.005, lr=0.01, bias=True): super().__init__() conv = [] conv.append(nn.Dropout(dropout)) for hid, act in zip(hids, acts): conv.append( GCNConv(in_features, hid, cached=True, bias=bias, normalize=False)) conv.append(activations.get(act)) conv.append(nn.Dropout(dropout)) in_features = hid conv.append( GCNConv(in_features, out_features, cached=True, bias=bias, normalize=False)) conv = Sequential(*conv) self.p = p self.kl = kl self.conv = conv self.compile( loss=nn.CrossEntropyLoss(), optimizer=optim.Adam([ dict(params=conv[1].parameters(), weight_decay=weight_decay), dict(params=conv[2:].parameters(), weight_decay=0.) ], lr=lr), metrics=[Accuracy()])
def __init__(self, in_features, out_features, K=10, alpha=0.1, eps_U=0.3, eps_V=1.2, lamb_U=0.8, lamb_V=0.8, hids=[], acts=[], dropout=0.5, weight_decay=5e-4, lr=0.01, bias=False): super().__init__() lin = [] lin.append(nn.Dropout(dropout)) for hid, act in zip(hids, acts): lin.append(nn.Linear(in_features, hid, bias=bias)) lin.append(activations.get(act)) lin.append(nn.Dropout(dropout)) in_features = hid lin = nn.Sequential(*lin) conv = SpectralEigenConv(in_features, out_features, bias=bias, K=K, alpha=alpha) self.lin = lin self.conv = conv self.compile(loss=nn.CrossEntropyLoss(), optimizer=optim.Adam(self.parameters(), weight_decay=weight_decay, lr=lr), metrics=[Accuracy()]) self.eps_U = eps_U self.eps_V = eps_V self.lamb_U = lamb_U self.lamb_V = lamb_V
def __init__(self, in_features, out_features, hids=[8], num_heads=[8], acts=['elu'], dropout=0.6, weight_decay=5e-4, lr=0.01): super().__init__() head = 1 conv = [] for hid, num_head, act in zip(hids, num_heads, acts): conv.append( GATConv(in_features * head, hid, num_heads=num_head, feat_drop=dropout, attn_drop=dropout)) conv.append(activations.get(act)) conv.append(nn.Flatten(start_dim=1)) conv.append(nn.Dropout(dropout)) in_features = hid head = num_head conv.append( GATConv(in_features * head, out_features, num_heads=1, feat_drop=dropout, attn_drop=dropout)) conv = Sequential(*conv, inverse=True) # `inverse=True` is important self.conv = conv self.compile( loss=nn.CrossEntropyLoss(), optimizer=optim.Adam([ dict(params=conv[0].parameters(), weight_decay=weight_decay), dict(params=conv[1:].parameters(), weight_decay=0.) ], lr=lr), metrics=[Accuracy()])
def __init__(self, in_features, out_features, hids=[32], acts=['relu'], dropout=0.5, weight_decay=5e-4, lr=0.01, bias=False, aggregator='mean', output_normalize=False, sizes=[15, 5], concat=True): super().__init__() Agg = _AGG.get(aggregator, None) if not Agg: raise ValueError( f"Invalid value of 'aggregator', allowed values {tuple(_AGG.keys())}, but got '{aggregator}'." ) self.output_normalize = output_normalize self.sizes = sizes assert len(sizes) == len(hids) + 1 aggregators, act_layers = nn.ModuleList(), nn.ModuleList() for hid, act in zip(hids, acts): aggregators.append(Agg(in_features, hid, concat=concat, bias=bias)) act_layers.append(activations.get(act)) in_features = hid * 2 if concat else hid aggregators.append(Agg(in_features, out_features, bias=bias)) self.aggregators = aggregators self.dropout = nn.Dropout(dropout) self.acts = act_layers self.compile(loss=nn.CrossEntropyLoss(), optimizer=optim.Adam(self.parameters(), lr=lr, weight_decay=weight_decay), metrics=[Accuracy()])