def __init__(self,
in_channels,
out_channels,
hiddens=[16],
activations=['relu'],
dropout=0.5,
weight_decay=5e-4,
lr=0.01,
use_bias=True):
super().__init__()
self.layers = ModuleList()
inc = in_channels
for hidden, activation in zip(hiddens, activations):
layer = GraphConv(inc,
hidden,
activation=get_activation(activation),
bias=use_bias)
self.layers.append(layer)
inc = hidden
# output layer
self.layers.append(GraphConv(inc, out_channels))
self.dropout = Dropout(p=dropout)
self.compile(loss=torch.nn.CrossEntropyLoss(),
optimizer=optim.Adam(self.parameters(),
lr=lr,
weight_decay=weight_decay),
metrics=[Accuracy()])
def __init__(self,
in_channels,
out_channels,
hids=[64],
acts=['relu'],
dropout=0.5,
weight_decay=5e-3,
lr=0.01,
use_bias=False,
K=10):
super().__init__()
layers = nn.ModuleList()
acts_fn = []
# use ModuleList to create layers with different size
inc = in_channels
for hid, act in zip(hids, acts):
layer = nn.Linear(inc, hid, bias=use_bias)
layers.append(layer)
acts_fn.append(get_activation(act))
inc = hid
layer = nn.Linear(inc, out_channels, bias=use_bias)
acts_fn.append(get_activation(act))
layers.append(layer)
conv = PropConvolution(out_channels,
K=K,
use_bias=use_bias,
activation="sigmoid")
self.layers = layers
self.conv = conv
paras = [
dict(params=layers.parameters(), weight_decay=weight_decay),
dict(params=conv.parameters(), weight_decay=weight_decay),
]
# do not use weight_decay in the final layer
self.compile(loss=torch.nn.CrossEntropyLoss(),
optimizer=optim.Adam(paras, lr=lr),
metrics=[Accuracy()])
self.dropout = nn.Dropout(dropout)
def __init__(self,
in_channels,
out_channels,
hids=[8],
num_heads=[8],
acts=['elu'],
dropout=0.6,
weight_decay=5e-4,
lr=0.01,
use_bias=True):
super().__init__()
layers = ModuleList()
act_fns = []
paras = []
inc = in_channels
pre_head = 1
for hid, num_head, act in zip(hids, num_heads, acts):
layer = GATConv(inc * pre_head,
hid,
heads=num_head,
bias=use_bias,
dropout=dropout)
layers.append(layer)
act_fns.append(get_activation(act))
paras.append(
dict(params=layer.parameters(), weight_decay=weight_decay))
inc = hid
pre_head = num_head
layer = GATConv(inc * pre_head,
out_channels,
heads=1,
bias=use_bias,
concat=False,
dropout=dropout)
layers.append(layer)
# do not use weight_decay in the final layer
paras.append(dict(params=layer.parameters(), weight_decay=0.))
self.act_fns = act_fns
self.layers = layers
self.dropout = Dropout(dropout)
self.compile(loss=torch.nn.CrossEntropyLoss(),
optimizer=optim.Adam(paras, lr=lr),
metrics=[Accuracy()])
def __init__(self,
in_channels,
out_channels,
hiddens=[16],
activations=['relu'],
dropout=0.5,
weight_decay=5e-4,
lr=0.01,
use_bias=True):
super().__init__()
paras = []
acts = []
layers = ModuleList()
# use ModuleList to create layers with different size
inc = in_channels
for hidden, activation in zip(hiddens, activations):
layer = GCNConv(inc,
hidden,
cached=True,
bias=use_bias,
normalize=False)
layers.append(layer)
paras.append(
dict(params=layer.parameters(), weight_decay=weight_decay))
acts.append(get_activation(activation))
inc = hidden
layer = GCNConv(inc,
out_channels,
cached=True,
bias=use_bias,
normalize=False)
layers.append(layer)
# do not use weight_decay in the final layer
paras.append(dict(params=layer.parameters(), weight_decay=0.))
self.acts = acts
self.layers = layers
self.dropout = Dropout(dropout)
self.compile(loss=torch.nn.CrossEntropyLoss(),
optimizer=optim.Adam(paras, lr=lr),
metrics=[Accuracy()])
def __init__(self,
in_channels,
out_channels,
hiddens=[8],
n_heads=[8],
activations=['elu'],
dropout=0.6,
weight_decay=5e-4,
lr=0.01):
super().__init__()
layers = ModuleList()
paras = []
inc = in_channels
pre_head = 1
for hidden, n_head, activation in zip(hiddens, n_heads, activations):
layer = GATConv(inc * pre_head,
hidden,
activation=get_activation(activation),
num_heads=n_head,
feat_drop=dropout,
attn_drop=dropout)
layers.append(layer)
paras.append(
dict(params=layer.parameters(), weight_decay=weight_decay))
inc = hidden
pre_head = n_head
layer = GATConv(inc * pre_head,
out_channels,
num_heads=1,
feat_drop=dropout,
attn_drop=dropout)
layers.append(layer)
# do not use weight_decay in the final layer
paras.append(dict(params=layer.parameters(), weight_decay=0.))
self.layers = layers
self.dropout = Dropout(dropout)
self.compile(loss=torch.nn.CrossEntropyLoss(),
optimizer=optim.Adam(paras, lr=lr),
metrics=[Accuracy()])
def __init__(self,
in_channels,
out_channels,
hiddens=[],
activations=[],
dropout=0.5,
weight_decay=5e-5,
lr=0.2,
use_bias=False):
super().__init__()
if len(hiddens) != len(activations):
raise RuntimeError(
f"Arguments 'hiddens' and 'activations' should have the same length."
" Or you can set both of them to `[]`.")
layers = ModuleList()
acts = []
paras = []
inc = in_channels
for hidden, activation in zip(hiddens, activations):
layer = Linear(inc, hidden, bias=use_bias)
paras.append(
dict(params=layer.parameters(), weight_decay=weight_decay))
layers.append(layer)
inc = hidden
acts.append(get_activation(activation))
layer = Linear(inc, out_channels, bias=use_bias)
layers.append(layer)
paras.append(dict(params=layer.parameters(),
weight_decay=weight_decay))
self.layers = layers
self.acts = acts
self.dropout = Dropout(dropout)
self.compile(loss=torch.nn.CrossEntropyLoss(),
optimizer=optim.Adam(paras, lr=lr),
metrics=[Accuracy()])
def __init__(self,
in_channels,
out_channels,
hids=[16],
acts=['relu'],
dropout=0.5,
weight_decay=5e-4,
lr=0.01,
use_bias=False):
super().__init__()
layers = nn.ModuleList()
paras = []
acts_fn = []
# use ModuleList to create layers with different size
inc = in_channels
for hid, act in zip(hids, acts):
layer = nn.Linear(inc, hid, bias=use_bias)
layers.append(layer)
acts_fn.append(get_activation(act))
paras.append(
dict(params=layer.parameters(), weight_decay=weight_decay))
inc = hid
conv = GraphConvolution(inc, out_channels, use_bias=use_bias)
# do not use weight_decay in the final layer
paras.append(dict(params=conv.parameters(), weight_decay=0.))
self.compile(loss=torch.nn.CrossEntropyLoss(),
optimizer=optim.Adam(paras, lr=lr),
metrics=[Accuracy()])
self.dropout = nn.Dropout(dropout)
self.acts_fn = acts_fn
self.layers = layers
self.conv = conv
