def __init__(self, n_features, n_classes, num_layers, hidden_gcn, hidden_fc, edge_index, n_genes=15135, mode='cat'): super().__init__() self.edge_index = edge_index self.conv1 = GCNConv(n_features, hidden_gcn) self.convs = torch.nn.ModuleList() self.mode = mode for i in range(num_layers - 1): self.convs.append(GCNConv(hidden_gcn, hidden_gcn)) if mode == 'cat': self.topkpooling = TopKPooling(num_layers * hidden_gcn) self.fc = torch.nn.Linear( num_layers * hidden_gcn, 1) # FC layer to reduce dim of gene features to 1 else: self.topkpooling = TopKPooling(hidden_gcn) self.fc = torch.nn.Linear( hidden_gcn, 1) # FC layer to reduce dim of pathway features to 1 n_nodes_after_topk = int(np.ceil(0.5 * n_genes)) self.lin1 = Linear(n_nodes_after_topk, hidden_fc) self.lin2 = Linear(hidden_fc, n_classes)
def __init__(self, indim, ratio, nclass, k=8, R=200): ''' :param indim: (int) node feature dimension :param ratio: (float) pooling ratio in (0,1) :param nclass: (int) number of classes :param k: (int) number of communities :param R: (int) number of ROIs ''' super(Network, self).__init__() self.indim = indim self.dim1 = 32 self.dim2 = 32 self.dim3 = 512 self.dim4 = 256 self.dim5 = 8 self.k = k self.R = R self.n1 = nn.Sequential(nn.Linear(self.R, self.k, bias=False), nn.ReLU(), nn.Linear(self.k, self.dim1 * self.indim)) self.conv1 = MyNNConv(self.indim, self.dim1, self.n1, normalize=False) self.pool1 = TopKPooling(self.dim1, ratio=ratio, multiplier=1, nonlinearity=torch.sigmoid) self.n2 = nn.Sequential(nn.Linear(self.R, self.k, bias=False), nn.ReLU(), nn.Linear(self.k, self.dim2 * self.dim1)) self.conv2 = MyNNConv(self.dim1, self.dim2, self.n2, normalize=False) self.pool2 = TopKPooling(self.dim2, ratio=ratio, multiplier=1, nonlinearity=torch.sigmoid) #self.fc1 = torch.nn.Linear((self.dim2) * 2, self.dim2) self.fc1 = torch.nn.Linear((self.dim1+self.dim2)*2, self.dim2) self.bn1 = torch.nn.BatchNorm1d(self.dim2) self.fc2 = torch.nn.Linear(self.dim2, self.dim3) self.bn2 = torch.nn.BatchNorm1d(self.dim3) self.fc3 = torch.nn.Linear(self.dim3, nclass)
def __init__(self): # super(Net, self).__init__() # self.pool1 = TopKPooling(5, ratio=0.01) # self.nn1 = torch.nn.Linear(5, 64) # THESE ARE THE LAYERS OF THE MODEL self.pool2 = TopKPooling(64, ratio=0.1) # self.pool3 = TopKPooling(64, ratio=0.1) # self.nn2 = torch.nn.Linear(64, 8) #
def __init__(self, dataset, embedding_layer, hidden_dim=cmd_args.hidden_dim): super().__init__() self.embedding_layer = embedding_layer self.nn2 = nn.Sequential(nn.Linear(hidden_dim, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, hidden_dim**2)) self.nn4 = nn.Sequential(nn.Linear(hidden_dim, hidden_dim), nn.ReLU(), nn.Linear(hidden_dim, hidden_dim**2)) self.conv1 = GraphConvE(hidden_dim, hidden_dim) self.pool1 = TopKPooling(hidden_dim, ratio=1.0) self.conv2 = NNConv(hidden_dim, hidden_dim, self.nn2) self.pool2 = TopKPooling(hidden_dim, ratio=1.0) self.conv3 = GraphConvE(hidden_dim, hidden_dim) self.pool3 = TopKPooling(hidden_dim, ratio=1.0) self.conv4 = NNConv(hidden_dim, hidden_dim, self.nn4) self.pool4 = TopKPooling(hidden_dim, ratio=1.0) self.lin1 = torch.nn.Linear(hidden_dim, hidden_dim) self.lin2 = torch.nn.Linear(hidden_dim, hidden_dim) self.lin3 = torch.nn.Linear(hidden_dim, hidden_dim) self.l1 = torch.nn.Linear(hidden_dim, hidden_dim) self.l2 = torch.nn.Linear(hidden_dim, hidden_dim) self.l3 = torch.nn.Linear(hidden_dim, hidden_dim) self.l4 = torch.nn.Linear(hidden_dim, hidden_dim)
def __init__(self, num_classes): super(PoolNetv2, self).__init__() self.att_w = nn.Sequential(nn.Linear(512, 256), nn.ELU(), nn.Linear(256, 128), nn.ELU(), nn.Linear(128, 1)) self.att_net = nn.Sequential( nn.Linear(512, 512), #nn.Tanh() nn.ELU()) self.conv1 = GATConv(3, 32, heads=2) self.norm1 = InstanceNorm(64, affine=True) self.pool1 = TopKPooling(64, ratio=0.3, nonlinearity=torch.sigmoid) self.conv2 = GATConv(64, 128, heads=2) self.norm2 = InstanceNorm(256, affine=True) self.pool2 = TopKPooling(256, ratio=0.3, nonlinearity=torch.sigmoid) self.conv3 = GATConv(256, 512, heads=2, concat=False) self.norm3 = InstanceNorm(512, affine=True) self.att = GlobalAttention(gate_nn=self.att_w, nn=self.att_net) self.lin1 = Linear(512, 512) self.lin2 = Linear(512, 256) self.lin3 = Linear(256, num_classes)
def __init__(self): super(Net, self).__init__() self.conv1 = GCNConv(128, 128) # self.conv1 = GraphConv(128, 128) self.pool1 = TopKPooling(128, ratio=0.8) self.conv2 = GCNConv(128, 128) # self.conv2 = GraphConv(128, 128) self.pool2 = TopKPooling(128, ratio=0.8) self.conv3 = GCNConv(128, 128) # self.conv3 = GraphConv(128, 128) self.pool3 = TopKPooling(128, ratio=0.8) self.conv4 = GCNConv(128, 128) self.pool4 = TopKPooling(128, ratio=0.8) self.conv5 = GCNConv(128, 128) self.pool5 = TopKPooling(128, ratio=0.8) # self.conv6 = GCNConv(128, 128) # self.pool6 = TopKPooling(128, ratio=0.8) # self.conv7 = GCNConv(128, 128) # self.pool7 = TopKPooling(128, ratio=0.8) self.lin1 = torch.nn.Linear(256, 128) self.lin2 = torch.nn.Linear(128, 64) self.lin3 = torch.nn.Linear(64, 2) self.readout = Seq(Linear(128, 64), ReLU(), Linear(64, 2))
def __init__(self, args): super(Topkpool, self).__init__() self.args = args missing_keys = list(set(["features_num", "num_class", "num_graph_features", "ratio", "dropout", "act"]) - set(self.args.keys())) if len(missing_keys) > 0: raise Exception("Missing keys: %s." % ','.join(missing_keys)) self.num_features = self.args["features_num"] self.num_classes = self.args["num_class"] self.ratio = self.args["ratio"] self.dropout = self.args["dropout"] self.num_graph_features = self.args["num_graph_features"] self.conv1 = GraphConv(self.num_features, 128) self.pool1 = TopKPooling(128, ratio=self.ratio) self.conv2 = GraphConv(128, 128) self.pool2 = TopKPooling(128, ratio=self.ratio) self.conv3 = GraphConv(128, 128) self.pool3 = TopKPooling(128, ratio=self.ratio) self.lin1 = torch.nn.Linear(256 + self.num_graph_features, 128) self.lin2 = torch.nn.Linear(128, 64) self.lin3 = torch.nn.Linear(64, self.num_classes)
def __init__(self, num_features, output_channels, nb_neurons=128, **kwargs): """ Parameters ---------- num_features: int number of node features output_channels: int number of classes """ super(GCNConv3TPK, self).__init__() self.conv1 = GCNConv(num_features, nb_neurons) self.pool1 = TopKPooling(nb_neurons, ratio=0.8) self.conv2 = GCNConv(nb_neurons, nb_neurons) self.pool2 = TopKPooling(nb_neurons, ratio=0.8) self.conv3 = GCNConv(nb_neurons, nb_neurons) self.pool3 = TopKPooling(nb_neurons, ratio=0.8) self.lin1 = torch.nn.Linear(nb_neurons, 64) self.lin2 = torch.nn.Linear(64, output_channels)
def __init__(self): super(Net, self).__init__() out = 5 size = 3 self.depth = 3 rate = [0.8, 0.8, 0.8] shape = [64, 48, 32] self.direction = 1 self.down_list = torch.nn.ModuleList() self.up_list = torch.nn.ModuleList() self.pool_list = torch.nn.ModuleList() # encoder conv = SGConv(size, out, shape[0]) self.down_list.append(conv) for i in range(self.depth - 1): pool = TopKPooling(shape[i], rate[i]) self.pool_list.append(pool) conv = SGConv(size, shape[i], shape[i + 1]) self.down_list.append(conv) pool = TopKPooling(shape[-1], rate[-1]) self.pool_list.append(pool) # decoder for i in range(self.depth - 1): conv = SGConv(size, shape[self.depth - i - 1], shape[self.depth - i - 2]) self.up_list.append(conv) conv = SGConv(1, shape[0], out) self.up_list.append(conv) self.x_num_nodes = 0 self.x = 0 self.r_graph = 0
def __init__(self): super(Net, self).__init__() self.conv1 = GCNConv(128, 128) self.pool1 = TopKPooling(128, ratio=0.8) self.conv2 = GCNConv(128, 128) self.pool2 = TopKPooling(128, ratio=0.8) self.conv3 = GCNConv(128, 128) self.pool3 = TopKPooling(128, ratio=0.8) self.convAtt1 = torch.nn.Conv1d(in_channels=256, out_channels=64, kernel_size=1, stride=2) self.poolAtt1 = torch.nn.MaxPool1d(kernel_size=1, stride=2) self.convAtt2 = torch.nn.Conv1d(64, 16, kernel_size=1, stride=2) self.poolAtt2 = torch.nn.MaxPool1d(kernel_size=1, stride=2) self.convAtt3 = torch.nn.Conv1d(16, 2, kernel_size=1, stride=2) self.poolAtt3 = torch.nn.MaxPool1d(kernel_size=1, stride=2) self.convAtt4 = torch.nn.Conv1d(2, 16, kernel_size=1, stride=2) self.poolAtt4 = torch.nn.MaxPool1d(kernel_size=1, stride=2) self.convAtt5 = torch.nn.Conv1d(16, 64, kernel_size=1, stride=2) self.poolAtt5 = torch.nn.MaxPool1d(kernel_size=1, stride=2) self.convAtt6 = torch.nn.Conv1d(64, 256, kernel_size=1, stride=2) self.poolAtt6 = torch.nn.MaxPool1d(kernel_size=1, stride=2) self.lin1 = torch.nn.Linear(256, 128) self.lin2 = torch.nn.Linear(128, 64) self.lin3 = torch.nn.Linear(64, 2)
def __init__(self, input_size, kernels, depth, rate, shapes, device): super(Net, self).__init__() size = kernels self.device = device self.depth = depth self.direction = 1 self.down_list = torch.nn.ModuleList() self.up_list = torch.nn.ModuleList() self.pool_list = torch.nn.ModuleList() # encoder conv = SGAT(size, input_size, shapes[0]) self.down_list.append(conv) for i in range(self.depth - 1): pool = TopKPooling(shapes[i], rate[i]) self.pool_list.append(pool) conv = SGAT(size, shapes[i], shapes[i + 1]) self.down_list.append(conv) pool = TopKPooling(shapes[-1], rate[-1]) self.pool_list.append(pool) # decoder for i in range(self.depth - 1): conv = SAGEConv(shapes[self.depth - i - 1], shapes[self.depth - i - 2]) self.up_list.append(conv) conv = SAGEConv(shapes[0], input_size) self.up_list.append(conv)
def __init__(self, num_features, num_classes): super(TopKNet, self).__init__() self.name = "topknet" self.version = "v1" self.num_features = num_features self.num_classes = num_classes self.bn1 = torch.nn.BatchNorm1d(num_features=num_features) self.conv1 = GATConv(num_features, 256) self.bn2 = torch.nn.BatchNorm1d(num_features=256) self.pool1 = TopKPooling(256, ratio=0.8) self.conv2 = GATConv(256, 256) self.bn3 = torch.nn.BatchNorm1d(num_features=256) self.pool2 = TopKPooling(256, ratio=0.8) self.conv3 = GATConv(256, 256) self.bn4 = torch.nn.BatchNorm1d(num_features=256) self.pool3 = TopKPooling(256, ratio=0.8) self.lin1 = torch.nn.Linear(512, 256) self.bn5 = torch.nn.BatchNorm1d(num_features=256) self.lin2 = torch.nn.Linear(256, 128) self.bn6 = torch.nn.BatchNorm1d(num_features=128) self.lin3 = torch.nn.Linear(128, num_classes)
def __init__(self): # super(Net, self).__init__() # self.conv1 = GCNConv(5, 20) # self.pool = TopKPooling(20, ratio=0.01) # LAG I MODELLEN self.conv2 = GCNConv(20, 15) # self.pool2 = TopKPooling(15, ratio=0.1) # self.conv3 = GCNConv(15, 12) # self.pool3 = TopKPooling(12, ratio=0.1) # self.conv4 = GCNConv(12, 10) # self.nn1 = torch.nn.Linear(10, 8) #
def __init__(self): # super(Net, self).__init__() # #self.graph_unet = GraphUNet(5,20,124,2, pool_ratios = 0.01) # self.pool1 = TopKPooling(5, ratio=0.01) self.nn1 = torch.nn.Linear(5, 64) # LAG I MODELLEN# self.pool2 = TopKPooling(64, ratio=0.1) # self.pool3 = TopKPooling(64, ratio=0.1) # #self.drop = Dropout(0.0001) # self.nn2 = torch.nn.Linear(64, 1) #
def __init__(self): super(FeatureExtractor, self).__init__() self.num_features = 14 self.nhid = 128 self.conv1 = GraphConv(self.num_features, self.nhid) self.pool1 = TopKPooling(self.nhid, ratio=0.8) self.conv2 = GraphConv(self.nhid, self.nhid) self.pool2 = TopKPooling(self.nhid, ratio=0.8)
def __init__(self): super(Net7, self).__init__() self.conv1 = GCNConv(dataset.num_node_features, 256) self.conv2 = GCNConv(126, 62) self.linear1 = torch.nn.Linear(256, 11) self.linear2 = torch.nn.Linear(126, 11) self.pool1 = TopKPooling(512, ratio=0.5) self.pool2 = TopKPooling(62, ratio=0.5) self.bn1 = torch.nn.BatchNorm1d(256) self.bn2 = torch.nn.BatchNorm1d(62)
def __init__(self): # super(Net, self).__init__() # # self.pool1 = TopKPooling(5, ratio=0.01) self.nn1 = torch.nn.Linear(5, 64) # LAG I MODELLEN# self.pool2 = TopKPooling(64, ratio=0.1) # self.pool3 = TopKPooling( 64, ratio=0.1 ) # # self.nn2 = torch.nn.Linear(64, 3) #
def __init__(self): super(Net4, self).__init__() self.conv1 = GCNConv( dataset.num_node_features, 126 ) # parameters - in_channel, out_channel, the other parameters are booleans self.conv2 = GCNConv(126, 62) self.linear1 = torch.nn.Linear(768, 11) self.linear2 = torch.nn.Linear(126, 11) self.pool1 = TopKPooling(126, ratio=0.5) self.pool2 = TopKPooling(62, ratio=0.5)
def build_model(self): self.conv1 = GraphConv(self.hparams.num_features, 128) self.pool1 = TopKPooling(128, ratio=0.8) self.conv2 = GraphConv(128, 128) self.pool2 = TopKPooling(128, ratio=0.8) self.conv3 = GraphConv(128, 128) self.pool3 = TopKPooling(128, ratio=0.8) self.lin1 = torch.nn.Linear(256, 128) self.lin2 = torch.nn.Linear(128, 64) self.lin3 = torch.nn.Linear(64, self.hparams.num_classes)
def __init__(self, dim): super().__init__() self.conv1 = GraphConv(dim, dim) self.pool1 = TopKPooling(dim, ratio=0.5) self.conv2 = GraphConv(dim, dim) self.pool2 = TopKPooling(dim, ratio=0.5) self.conv3 = GraphConv(dim, dim) self.pool3 = TopKPooling(dim, ratio=0.5) self.lin1 = nn.Linear(2 * dim, dim) self.lin2 = nn.Linear(dim, dim // 2)
def __init__(self): # # self.nn1 = torch.nn.RNN(5,64) # LAG I MODELLEN# super(Net, self).__init__() l1, l2, l3, l4 = 5, 64, 32, 8 # # self.relu = torch.nn.ReLU(inplace=True) # LAG I MODELLEN# self.pool1 = TopKPooling(l1, ratio=0.01) self.nn1 = torch.nn.RNNCell(l1, l2) # LAG I MODELLEN# self.pool2 = TopKPooling(l2, ratio=0.1) # self.nn2 = torch.nn.Linear(l2, l3) self.pool3 = TopKPooling(l3, ratio=0.1) # self.nn3 = torch.nn.Linear(l3, l4) #
def __init__(self, num_features, hidden, dropout, num_classes): super(Net, self).__init__() self.conv1 = GraphConv(num_features, hidden) self.pool1 = TopKPooling(hidden, ratio=0.8) self.conv2 = GraphConv(hidden, hidden) self.pool2 = TopKPooling(hidden, ratio=0.8) self.lin1 = nn.Linear(hidden * 2, hidden) self.lin2 = nn.Linear(hidden, num_classes) self.dropout = dropout
def __init__(self, num_node_features, num_of_classes=2): super(Net_1, self).__init__() self.conv1 = SAGEConv(num_node_features, 128) self.pool1 = TopKPooling(128, ratio=0.5) self.conv2 = SAGEConv(128, 128) self.pool2 = TopKPooling(128, ratio=0.5) self.conv3 = SAGEConv(128, 128) self.pool3 = TopKPooling(128, ratio=0.5) self.lin1 = torch.nn.Linear(256, 128) self.lin2 = torch.nn.Linear(128, 64) self.lin3 = torch.nn.Linear(64, num_of_classes)
def __init__(self, config): super(MRGIN, self).__init__() self.num_features = config.num_features self.num_relations = config.num_relations self.num_classes = config.nclass self.num_layers = config.num_layers #defines number of RGCN conv layers. self.hidden_dim = config.hidden_dim self.layer_spec = None if config.layer_spec == None else list(map(int, config.layer_spec.split(','))) self.lstm_dim1 = config.lstm_input_dim self.lstm_dim2 = config.lstm_output_dim self.rgcn_func = FastRGCNConv if config.conv_type == "FastRGCNConv" else RGCNConv self.activation = F.relu if config.activation == 'relu' else F.leaky_relu self.pooling_type = config.pooling_type self.readout_type = config.readout_type self.temporal_type = config.temporal_type self.dropout = config.dropout self.conv = [] self.pool = [] total_dim = 0 if self.layer_spec == None: for i in range(self.num_layers): if i == 0: self.conv.append(self.rgcn_func(self.num_features, self.hidden_dim, self.num_relations).to(config.device)) else: self.conv.append(self.rgcn_func(self.hidden_dim, self.hidden_dim, self.num_relations).to(config.device)) if self.pooling_type == "sagpool": self.pool.append(RGCNSAGPooling(self.hidden_dim, self.num_relations, ratio=config.pooling_ratio, rgcn_func=config.conv_type).to(config.device)) elif self.pooling_type == "topk": self.pool.append(TopKPooling(self.hidden_dim, ratio=config.pooling_ratio).to(config.device)) total_dim += self.hidden_dim else: print("using layer specification and ignoring hidden_dim parameter.") print("layer_spec: " + str(self.layer_spec)) for i in range(self.num_layers): if i == 0: self.conv.append(self.rgcn_func(self.num_features, self.layer_spec[0], self.num_relations).to(config.device)) else: self.conv.append(self.rgcn_func(self.layer_spec[i-1], self.layer_spec[i], self.num_relations).to(config.device)) if self.pooling_type == "sagpool": self.pool.append(RGCNSAGPooling(self.layer_spec[i], self.num_relations, ratio=config.pooling_ratio, rgcn_func=config.conv_type).to(config.device)) elif self.pooling_type == "topk": self.pool.append(TopKPooling(self.layer_spec[i], ratio=config.pooling_ratio).to(config.device)) total_dim += self.layer_spec[i] self.fc1 = Linear(total_dim, self.lstm_dim1) if "lstm" in self.temporal_type: self.lstm = LSTM(self.lstm_dim1, self.lstm_dim2, batch_first=True) self.attn = Attention(self.lstm_dim2) self.fc2 = Linear(self.lstm_dim2, self.num_classes)
def __init__(self): super(TopKPool, self).__init__() self.conv1 = GraphConv(dataset.num_features, 128) self.pool1 = TopKPooling(128, ratio=0.8) self.conv2 = GraphConv(128, 128) self.pool2 = TopKPooling(128, ratio=0.8) self.conv3 = GraphConv(128, 128) self.pool3 = TopKPooling(128, ratio=0.8) self.lin1 = torch.nn.Linear(256, 128) self.lin2 = torch.nn.Linear(128, 64) self.lin3 = torch.nn.Linear(64, dataset.num_classes)
def __init__(self, graph_w=64, lin_w1=32, lin_w2=8): super(Net, self).__init__() self.conv1 = GraphConv(2, graph_w) self.pool1 = TopKPooling(graph_w, ratio=0.5) self.conv2 = GraphConv(graph_w, graph_w) self.pool2 = TopKPooling(graph_w, ratio=0.8) self.conv3 = GraphConv(graph_w, graph_w) self.pool3 = TopKPooling(graph_w, ratio=0.8) self.lin1 = torch.nn.Linear(2*graph_w, lin_w1) self.lin2 = torch.nn.Linear(lin_w1, lin_w2) self.lin3 = torch.nn.Linear(lin_w2, 3)
def __init__(self, num_features, num_classes): super(Net, self).__init__() self.conv1 = GraphConv(num_features, 128) self.conv1.weight.data.normal_() self.pool1 = TopKPooling(128, ratio=0.8) self.conv2 = GraphConv(128, 128) self.pool2 = TopKPooling(128, ratio=0.8) self.conv3 = GraphConv(128, 128) self.pool3 = TopKPooling(128, ratio=0.8) self.lin1 = torch.nn.Linear(256, 128) self.lin2 = torch.nn.Linear(128, 64) self.lin3 = torch.nn.Linear(64, num_classes)
def __init__(self, datasetroot, width): super(topk_pool_Net, self).__init__() self.conv1 = GraphConv(datasetroot.num_features, 128) self.pool1 = TopKPooling(128, ratio=0.8) self.conv2 = GraphConv(128, 128) self.pool2 = TopKPooling(128, ratio=0.8) self.conv3 = GraphConv(128, 128) self.pool3 = TopKPooling(128, ratio=0.8) self.lin1 = torch.nn.Linear(256, width[1]) self.lin2 = torch.nn.Linear(width[1], width[2]) self.lin3 = torch.nn.Linear(width[2], datasetroot.num_classes)
def __init__(self): super(Net, self).__init__() self.conv1 = GCNConv(1, 30) self.pool1 = TopKPooling(30, ratio=0.4) self.conv2 = GCNConv(30, 20) self.pool2 = TopKPooling(20, ratio=0.2) self.conv3 = GCNConv(20, 10) self.pool3 = TopKPooling(10, ratio=0.1) self.lin1 = torch.nn.Linear(1380, 80) self.lin2 = torch.nn.Linear(80, 64) self.lin3 = torch.nn.Linear(64, 1) #2)
def __init__(self): super().__init__() self.conv1 = GraphConv(dataset.num_features, 32) self.pool1 = TopKPooling(32, ratio=0.3) self.conv2 = GraphConv(32, 32) self.pool2 = TopKPooling(32, ratio=0.3) self.conv3 = GraphConv(32, 32) self.pool3 = TopKPooling(32, ratio=0.3) self.lin1 = torch.nn.Linear(64, 32) # self.lin2 = torch.nn.Linear(128, 64) self.lin3 = torch.nn.Linear(32, dataset.num_classes)