def __init__(self, in_feats, h_feats, num_classes, pooling):
super(GCN_GraphConv, self).__init__()
assert isinstance(h_feats, list), "h_feats must be a list"
assert len(
h_feats) != 0, "h_feats is empty. unable to add hidden layers"
self.list_of_layers = []
dim = [in_feats] + h_feats
# Convolution (Hidden) Layers
for i in range(1, len(dim)):
self.list_of_layers.append(GraphConv(dim[i - 1], dim[i]))
# Final Layer
# Followed example at: https://docs.dgl.ai/tutorials/blitz/5_graph_classification.html#sphx-glr-tutorials-blitz-5-graph-classification-py
self.final = GraphConv(dim[-1], num_classes)
# Pooling layer
if pooling == "AvgPooling":
self.pooling_layer = dgl.nn.AvgPooling()
elif pooling == "MaxPooling":
self.pooling_layer = dgl.nn.MaxPooling()
elif pooling == "SumPooling":
self.pooling_layer = dgl.nn.SumPooling()
else:
raise NotImplementedError
def __init__(self, in_feats, hidden_size, num_classes):
# inherit from backend NN model
super(GCN, self).__init__()
# add 2 conv layers
self.conv1 = GraphConv(in_feats, hidden_size)
self.conv2 = GraphConv(hidden_size, num_classes)
def __init__(self,
in_dim,
hid_dim,
out_dim,
num_layers=1,
mode='cat',
dropout=0.):
super(JKNet, self).__init__()
self.mode = mode
self.dropout = nn.Dropout(dropout)
self.layers = nn.ModuleList()
self.layers.append(GraphConv(in_dim, hid_dim, activation=F.relu))
for _ in range(num_layers):
self.layers.append(GraphConv(hid_dim, hid_dim, activation=F.relu))
if self.mode == 'lstm':
self.jump = JumpingKnowledge(mode, hid_dim, num_layers)
else:
self.jump = JumpingKnowledge(mode)
if self.mode == 'cat':
hid_dim = hid_dim * (num_layers + 1)
self.output = nn.Linear(hid_dim, out_dim)
self.reset_params()
def __init__(self, num_feats):
super(EEGGraphConvNet, self).__init__()
self.conv1 = GraphConv(num_feats, 16)
self.conv2 = GraphConv(16, 32)
self.conv3 = GraphConv(32, 64)
self.conv4 = GraphConv(64, 50)
self.conv4_bn = BatchNorm1d(50,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.fc_block1 = nn.Linear(50, 30)
self.fc_block2 = nn.Linear(30, 10)
self.fc_block3 = nn.Linear(10, 2)
# Xavier initializations
self.fc_block1.apply(
lambda x: nn.init.xavier_normal_(x.weight, gain=1))
self.fc_block2.apply(
lambda x: nn.init.xavier_normal_(x.weight, gain=1))
self.fc_block3.apply(
lambda x: nn.init.xavier_normal_(x.weight, gain=1))
self.sumpool = SumPooling()
def __init__(
self,
in_features: int,
hidden_features: List[int],
out_features: int,
activation: Callable[[], nn.Module] = nn.ReLU,
):
super().__init__()
layers = [
GraphConv(in_feats=in_features, out_feats=hidden_features[0])
]
dropouts = [nn.Dropout(0.5) for _ in range(len(hidden_features))]
batch_norms = [
nn.BatchNorm1d(hidden_feature)
for hidden_feature in hidden_features
]
activations = [activation() for _ in range(len(hidden_features))]
for i in range(1, len(hidden_features)):
layers.append(GraphConv(hidden_features[i - 1],
hidden_features[i]))
layers.append(GraphConv(hidden_features[-1], out_features))
self.layers = nn.ModuleList(layers)
self.dropouts = nn.ModuleList(dropouts)
self.batch_norms = nn.ModuleList(batch_norms)
self.activations = nn.ModuleList(activations)
def __init__(self, input_dim, hidden_dim, output_dim, num_layers, gnn_type):
super(GNN, self).__init__()
self.hidden_dim = hidden_dim
self.num_layers = num_layers
self.gnn_type = gnn_type
self.convs = nn.ModuleList()
if gnn_type == "gcn":
self.convs.append(GraphConv(input_dim, hidden_dim))
elif gnn_type == "sage":
self.convs.append(SAGEConv(input_dim, hidden_dim, "gcn"))
elif gnn_type == "gat":
self.convs.append(GATConv(input_dim, hidden_dim, num_heads=3))
else:
raise ValueError("Invalid gnn_type")
for i in range(num_layers - 2):
if gnn_type == "gcn":
self.convs.append(GraphConv(hidden_dim, hidden_dim))
elif gnn_type == "sage":
self.convs.append(SAGEConv(hidden_dim, hidden_dim, "gcn"))
elif gnn_type == "gat":
self.convs.append(GATConv(hidden_dim, hidden_dim, num_heads=3))
if gnn_type == "gcn":
self.convs.append(GraphConv(hidden_dim, output_dim))
elif gnn_type == "sage":
self.convs.append(SAGEConv(hidden_dim, output_dim, "gcn"))
elif gnn_type == "gat":
self.convs.append(GATConv(hidden_dim, output_dim, num_heads=3))
def __init__(self,
in_feats,
hidden_dim,
num_classes):
super(GCN, self).__init__()
self.conv1 = GraphConv(in_feats, hidden_dim)
self.conv2 = GraphConv(hidden_dim, hidden_dim)
self.classify = nn.Linear(hidden_dim, num_classes)
def __init__(self, G, hid_dims, num_layers, multihot=True):
super().__init__(G, hid_dims, num_layers, multihot)
self.input_layer = GraphConv(self.in_dims, hid_dims)
self.hidden_layers = [
GraphConv(hid_dims, hid_dims) for _ in range(num_layers)
]
self.output_layer = GraphConv(hid_dims, self.out_dims)
def __init__(self, in_feats, hid_feats, out_feats, rel_names):
super().__init__()
self.conv1 = HeteroGraphConv({
rel: GraphConv(in_feats, hid_feats) for rel in rel_names
}, aggregate='sum')
self.conv2 = HeteroGraphConv({
rel: GraphConv(hid_feats, out_feats) for rel in rel_names
}, aggregate='sum')
def __init__(self,
graph_x_size,
graph_emb_size,
output_size=1,
model_predictor="agent"):
super(MapGraphModel, self).__init__()
self.graph_emb_size = graph_emb_size
self.agent_layer = nn.Sequential(
nn.Linear((64 + graph_emb_size) * 2, 32), nn.ReLU(True),
nn.Linear(32, 1)
) # layer to process agent representations and predict novelty
self.model_predictor = model_predictor
# GCN layers for graph
self.GCN1 = GraphConv(graph_x_size,
graph_x_size,
norm='both',
weight=True,
bias=False)
self.GCN2 = GraphConv(graph_x_size,
graph_x_size,
norm='both',
weight=True,
bias=False)
self.GCN3 = GraphConv(graph_x_size,
self.graph_emb_size,
norm='both',
weight=True,
bias=False)
#CNN layers for Map
self.Conv = torch.nn.Sequential(*[
nn.Conv2d(graph_emb_size, 256, kernel_size=3, stride=1, padding=1),
nn.ReLU(True),
nn.Dropout(),
nn.Conv2d(256, 128, kernel_size=3, stride=1, padding=1),
nn.ReLU(True),
nn.Dropout(),
nn.Conv2d(128, 64, kernel_size=3, stride=1, padding=1),
nn.Tanh(),
])
#Last activation function
self.last_activation = torch.nn.functional.sigmoid if output_size == 1 else torch.nn.functional.softmax
#CNN to process the maps of two adjacent timesteps and predict novelty.
self.DiffConv = torch.nn.Sequential(*[
nn.Conv2d(64 * 2, 32, kernel_size=3, stride=1, padding=0),
nn.ReLU(True),
nn.Dropout(),
nn.Conv2d(32, 16, kernel_size=4, stride=2, padding=1),
nn.ReLU(True),
nn.Dropout(),
nn.Conv2d(16, 8, kernel_size=4, stride=2, padding=1),
nn.ReLU(True),
nn.Conv2d(8, output_size, kernel_size=4, stride=2, padding=1)
])
self.device = "cuda"
def __init__(self,
in_dim,
hidden_dim,
layer_num,
sample_size,
device,
GNN_name="GIN"):
super(GNNStructEncoder, self).__init__()
self.n_distribution = 7 # How many gaussian distribution should exist
self.out_dim = hidden_dim
if GNN_name == "GIN":
self.linear1 = MLP(layer_num, hidden_dim, hidden_dim, hidden_dim)
self.graphconv1 = GINConv(apply_func=self.linear1,
aggregator_type='sum')
self.linear2 = MLP(layer_num, hidden_dim, hidden_dim, hidden_dim)
self.graphconv2 = GINConv(apply_func=self.linear2,
aggregator_type='sum')
elif GNN_name == "GCN":
self.graphconv1 = GraphConv(hidden_dim, hidden_dim)
self.graphconv2 = GraphConv(hidden_dim, hidden_dim)
else:
self.graphconv = GATConv(hidden_dim, hidden_dim, num_heads=10)
# self.neighbor_num_list = neighbor_num_list
self.linear_classifier = MLP(1, hidden_dim, hidden_dim,
self.n_distribution)
self.neighbor_generator = MLP_generator(hidden_dim, hidden_dim,
sample_size).to(device)
# Gaussian Means, and std
self.gaussian_mean = nn.Parameter(
torch.FloatTensor(sample_size, self.n_distribution,
hidden_dim).uniform_(-0.5 / hidden_dim, 0.5 /
hidden_dim)).to(device)
self.gaussian_log_sigma = nn.Parameter(
torch.FloatTensor(sample_size, self.n_distribution,
hidden_dim).uniform_(-0.5 / hidden_dim, 0.5 /
hidden_dim)).to(device)
self.m = torch.distributions.Normal(
torch.zeros(sample_size, self.n_distribution, hidden_dim),
torch.ones(sample_size, self.n_distribution, hidden_dim))
# Before MLP Gaussian Means, and std
self.mlp_gaussian_mean = nn.Parameter(
torch.FloatTensor(hidden_dim).uniform_(-0.5 / hidden_dim, 0.5 /
hidden_dim)).to(device)
self.mlp_gaussian_log_sigma = nn.Parameter(
torch.FloatTensor(hidden_dim).uniform_(-0.5 / hidden_dim, 0.5 /
hidden_dim)).to(device)
self.mlp_m = torch.distributions.Normal(torch.zeros(hidden_dim),
torch.ones(hidden_dim))
# Decoders
self.degree_decoder = FNN(hidden_dim, hidden_dim, 1, 4)
# self.degree_loss_func = FocalLoss(int(max_degree_num) + 1)
self.degree_loss_func = nn.MSELoss()
self.pool = mp.Pool(1)
self.in_dim = in_dim
self.sample_size = sample_size
def __init__(self):
super(Net, self).__init__()
self.conv1 = GraphConv(num_features,
128,
norm='both',
weight=True,
bias=True)
self.conv2 = GraphConv(128,
num_classes,
norm='both',
weight=True,
bias=True)
def __init__(self, in_dim, out_dim, act_fn, num_layers=2):
super(GCN, self).__init__()
assert num_layers >= 2
self.num_layers = num_layers
self.convs = nn.ModuleList()
self.convs.append(GraphConv(in_dim, out_dim * 2))
for _ in range(self.num_layers - 2):
self.convs.append(GraphConv(out_dim * 2, out_dim * 2))
self.convs.append(GraphConv(out_dim * 2, out_dim))
self.act_fn = act_fn
def __init__(self, in_feats, h_feats1, h_feats2, num_outputs, dropout=0):
super(GCN, self).__init__()
# self.conv1 = GraphConv(in_feats, h_feats1, weight=True, bias=True) # GCNLayer
# self.conv2 = GraphConv(h_feats1, h_feats2, weight=True, bias=True) # GCNLayer
# self.conv3 = GraphConv(h_feats2, num_outputs, weight=True, bias=True) # GCNLayer
self.msg_net = Sequential(MessageLayer(), MessageLayer(),
MessageLayer())
self.conv1 = GraphConv(in_feats, h_feats1, weight=True,
bias=True) # GCNLayer
self.conv3 = GraphConv(h_feats1, num_outputs, weight=True,
bias=True) # GCNLayer
if (dropout):
self.dropout = nn.Dropout(p=dropout)
def __init__(self,
in_dim,
out_dim,
ntypes,
etypes,
activation=None,
dropout=0.0):
"""R-GCN层（用于异构图）
:param in_dim: 输入特征维数
:param out_dim: 输出特征维数
:param ntypes: List[str] 顶点类型列表
:param etypes: List[str] 边类型列表
:param activation: callable, optional 激活函数，默认为None
:param dropout: float, optional Dropout概率，默认为0
"""
super().__init__()
self.activation = activation
self.dropout = nn.Dropout(dropout)
self.conv = HeteroGraphConv(
{
etype: GraphConv(in_dim, out_dim, norm='right', bias=False)
for etype in etypes
}, 'sum')
self.loop_weight = nn.ModuleDict({
ntype: nn.Linear(in_dim, out_dim, bias=False)
for ntype in ntypes
})
def __init__(self, n_hid_in, n_hid_out, dropout=0.3):
super().__init__()
"""
Define a branch of the graph convolution with
1. GraphConv from n_hid_in to n_hid_in
2. ReLU
3. Dropout
4. GraphConv from n_hid_in to n_hid_out
Note: your should call dgl.nn.GraphConv with allow_zero_in_degree=True
"""
### Your code here ###
self.gc1 = GraphConv(n_hid_in, n_hid_in, allow_zero_in_degree=True)
self.act = nn.ReLU()
self.drop = nn.Dropout(p=dropout)
self.gc2 = GraphConv(n_hid_in, n_hid_out, allow_zero_in_degree=True)
def __init__(self, in_feat, hid_feat, out_feat, n_hidden_layers):
super().__init__()
self.h_embedding = nn.Embedding(in_feat, hid_feat)
self.mlp = MLPPredictor(hid_feat, out_feat)
self.layers = nn.ModuleList([
GraphConv(hid_feat, hid_feat, allow_zero_in_degree=True)
for _ in range(n_hidden_layers)
])
def __init__(self, num_feats):
super(EEGGraphConvNet, self).__init__()
self.conv1 = GraphConv(num_feats, 32)
self.conv2 = GraphConv(32, 20)
self.conv2_bn = nn.BatchNorm1d(20,
eps=1e-05,
momentum=0.1,
affine=True,
track_running_stats=True)
self.fc_block1 = nn.Linear(20, 10)
self.fc_block2 = nn.Linear(10, 2)
# Xavier initializations
self.fc_block1.apply(
lambda x: nn.init.xavier_normal_(x.weight, gain=1))
self.fc_block2.apply(
lambda x: nn.init.xavier_normal_(x.weight, gain=1))
def __init__(self, num_nodes, num_rels):
super(testModel, self).__init__()
self.e_emb = nn.Embedding(num_nodes, emb_size)
self.e_gc = GraphConv(emb_size,
gc_size,
norm='both',
weight=True,
bias=True)
self.r_emb = nn.Embedding(num_rels, emb_size)
def __init__(self,
in_dim,
out_dim,
rel_names,
num_bases=None,
weight=True,
self_loop=True,
activation=None,
dropout=0.0):
"""R-GCN层（用于异构图）
:param in_dim: 输入特征维数
:param out_dim: 输出特征维数
:param rel_names: List[str] 关系名称
:param num_bases: int, optional 基的个数，默认使用关系个数
:param weight: bool, optional 是否进行线性变换，默认为True
:param self_loop: 是否包括自环消息，默认为True
:param activation: callable, optional 激活函数，默认为None
:param dropout: float, optional Dropout概率，默认为0
"""
super().__init__()
self.rel_names = rel_names
self.self_loop = self_loop
self.activation = activation
self.dropout = nn.Dropout(dropout)
self.conv = HeteroGraphConv({
rel: GraphConv(in_dim,
out_dim,
norm='right',
weight=False,
bias=False)
for rel in rel_names
})
self.use_weight = weight
if not num_bases:
num_bases = len(rel_names)
self.use_basis = weight and 0 < num_bases < len(rel_names)
if self.use_weight:
if self.use_basis:
self.basis = WeightBasis((in_dim, out_dim), num_bases,
len(rel_names))
else:
self.weight = nn.Parameter(
torch.Tensor(len(rel_names), in_dim, out_dim))
nn.init.xavier_uniform_(self.weight,
nn.init.calculate_gain('relu'))
if self.self_loop:
self.loop_weight = nn.Parameter(torch.Tensor(in_dim, out_dim))
nn.init.xavier_uniform_(self.loop_weight,
nn.init.calculate_gain('relu'))
def __init__(self, num_metapaths, hidden_dim, attn_drop):
"""元路径视图编码器
:param num_metapaths: int 元路径数量M
:param hidden_dim: int 隐含特征维数
:param attn_drop: float 注意力dropout
"""
super().__init__()
self.gcns = nn.ModuleList([
GraphConv(hidden_dim, hidden_dim, norm='right', activation=nn.PReLU())
for _ in range(num_metapaths)
])
self.attn = Attention(hidden_dim, attn_drop)
def __init__(self, in_feats, h_feats, num_classes, pooling):
super(GCN_GraphConv, self).__init__()
assert isinstance(h_feats, list), "h_feats must be a list"
assert len(
h_feats) != 0, "h_feats is empty. unable to add hidden layers"
self.list_of_layers = []
dim = [in_feats] + h_feats
# Convolution (Hidden) Layers
for i in range(1, len(dim)):
self.list_of_layers.append(GraphConv(dim[i - 1], dim[i]))
# Final Layer
self.final = GraphConv(dim[-1], num_classes)
# Pooling layer
if pooling == "AvgPooling":
self.pooling_layer = dgl.nn.AvgPooling()
elif pooling == "MaxPooling":
self.pooling_layer = dgl.nn.MaxPooling()
elif pooling == "SumPooling":
self.pooling_layer = dgl.nn.SumPooling()
else:
raise NotImplementedError
def __init__(self,dataset,args):
super(myModel, self).__init__()
self._act =args.model_activation
self.user_embed = nn.Embedding(dataset.num_user, args.embed_units)
self.item_embed = nn.Embedding(dataset.num_item, args.embed_units)
self.num_user=dataset.num_user
self.num_item=dataset.num_item
data_dict={}
for rating in rating_vals:
data_dict[(str(rating)+'ed').replace('.','_')]=GraphConv(dataset.gender_len, dataset.gender_len)
self.genre_conv=dgl.nn.HeteroGraphConv(
data_dict#,allow_zero_in_degree=True
)
self.encoder = MyLayer(
args.embed_units+dataset.gender_len,args.embed_units+dataset.gender_len,args.gcn_agg_units,args.gcn_out_units,
rating_vals,args.gcn_dropout,args.gcn_agg_accum,self._act,self._act)
self.pred= MLPPredictor(args.gcn_out_units,args.gcn_dropout)
def __init__(self, in_feat, h_feat, out_feat):
super().__init__()
self.gcl1 = GraphConv(in_feat, h_feat)
self.relu = nn.ReLU()
self.gcl2 = GraphConv(h_feat, out_feat)
def __init__(self):
super(Net, self).__init__()
self.layer1 = GraphConv(602, 128)
self.layer2 = GraphConv(128, 128)
self.layer3 = GraphConv(128, 128)
self.fc = nn.Linear(128, 41)
def __init__(self):
super(Net, self).__init__()
self.layer1 = GraphConv(8710, 256)
self.layer2 = GraphConv(256, 256)
self.layer3 = GraphConv(256, 256)
self.fc = nn.Linear(256, 70)
def __init__(self, in_dim, hidden_dim, n_classes):
super(Classifier, self).__init__()
self.conv1 = GraphConv(in_dim, hidden_dim)
self.conv2 = GraphConv(hidden_dim, hidden_dim)
self.classify = nn.Linear(hidden_dim, n_classes)
def __init__(self, in_feats, h_feats, num_classes):
super(GCN, self).__init__()
self.conv1 = GraphConv(in_feats, h_feats)
self.conv2 = GraphConv(h_feats, num_classes)
def __init__(self, in_feats, hidden_size, num_classes):
super().__init__()
self.conv1 = GraphConv(in_feats, hidden_size)
self.conv2 = GraphConv(hidden_size, num_classes)
def __init__(self, in_feats, h_feats, num_classes):
super(GCN, self).__init__()
self.conv1 = GraphConv(
in_feats, h_feats) # Layer 1: input features, hidden features;
self.conv2 = GraphConv(
h_feats, num_classes) # Layer 2: hidden features, number of class;