def __init__(self, nfeat, nhid, nclass, dropout,nlayer=2): super(ChebGCN2, self).__init__() chebgcn_para1 = 2 self.conv1 = ChebConv(nfeat, nhid,chebgcn_para1) self.conv2 = ChebConv(nhid, nclass,chebgcn_para1) self.dropout_p = dropout
def __init__(self, n_features, n_labels, classification=False, width=128, conv_depth=3, point_depth=3, lin_depth=5): super(ChebConvNet, self).__init__() self.classification = classification self.n_features = n_features self.n_labels = n_labels self.lin_depth = lin_depth self.conv_depth = conv_depth self.width = width n_intermediate = self.width n_intermediate2 = 2 * self.conv_depth * n_intermediate self.conv1 = ChebConv(self.n_features, n_intermediate, 2) self.convfkt = torch.nn.ModuleList([ ChebConv(n_intermediate, n_intermediate, 2) for i in range(self.conv_depth - 1) ]) self.batchnorm1 = BatchNorm1d(n_intermediate2) self.linearfkt = torch.nn.ModuleList([ torch.nn.Linear(n_intermediate2, n_intermediate2) for i in range(self.lin_depth) ]) self.drop = torch.nn.ModuleList( [torch.nn.Dropout(.3) for i in range(self.lin_depth)]) self.out = torch.nn.Linear(n_intermediate2, self.n_labels)
def __init__(self, nfeat, nhid, nclass, num_hops=3, dropout=0.5, lr=0.01, weight_decay=5e-4, with_bias=True, device=None): super(ChebNet, self).__init__() assert device is not None, "Please specify 'device'!" self.device = device self.conv1 = ChebConv(nfeat, nhid, K=num_hops, bias=with_bias) self.conv2 = ChebConv(nhid, nclass, K=num_hops, bias=with_bias) self.dropout = dropout self.weight_decay = weight_decay self.lr = lr self.output = None self.best_model = None self.best_output = None
def __init__(self, num_features, num_classes): super(ChebNet, self).__init__() self.conv1 = ChebConv(num_features, 16, K=2) self.conv2 = ChebConv(16, num_classes, K=2) self.reg_params = self.conv1.parameters() self.non_reg_params = self.conv2.parameters()
def __init__(self, num_nodes, learn_edge_weight, edge_weight, num_features, num_hiddens, num_classes, K, dropout=0.5): super(EEGNet, self).__init__() self.num_nodes = num_nodes self.num_features = num_features self.num_hiddens = num_hiddens self.xs, self.ys = torch.tril_indices(self.num_nodes, self.num_nodes, offset=0) edge_weight = edge_weight.reshape( self.num_nodes, self.num_nodes)[self.xs, self.ys] # strict lower triangular values # edge_weight_gconv = torch.zeros(self.num_hiddens,1) # self.edge_weight_gconv = nn.Parameter(edge_weight_gconv, requires_grad=True) # nn.init.xavier_uniform_(self.edge_weight_gconv) self.edge_weight = nn.Parameter(edge_weight, requires_grad=learn_edge_weight) self.dropout = dropout self.chebconv_single = ChebConv(num_features, 1, K, node_dim=0) self.chebconv0 = ChebConv(num_features, num_hiddens[0], K, node_dim=0) self.chebconv1 = ChebConv(num_hiddens[0], 1, K, node_dim=0) # self.fc1 = nn.Linear(num_nodes, num_hiddens) self.fc2 = nn.Linear(num_nodes, num_classes)
def __init__(self, chev_conv_state_dim, action_dim): super(A3C_Model, self).__init__() self.substrate_state = 0 self.substrate_edge_index = 0 self.v_cpu_demand_t = 0 self.v_bw_demand_t = 0 self.num_pending_v_nodes_t = 0 self.actor_conv = ChebConv(in_channels=chev_conv_state_dim, out_channels=3, K=3) self.critic_conv = ChebConv(in_channels=chev_conv_state_dim, out_channels=3, K=3) self.actor_vnr_1_fc = nn.Linear(1, 3) self.actor_vnr_2_fc = nn.Linear(1, 3) self.actor_vnr_3_fc = nn.Linear(1, 3) self.critic_vnr_1_fc = nn.Linear(1, 3) self.critic_vnr_2_fc = nn.Linear(1, 3) self.critic_vnr_3_fc = nn.Linear(1, 3) self.actor_fc = nn.Linear((config.SUBSTRATE_NODES + 3) * 3, action_dim) self.critic_fc = nn.Linear((config.SUBSTRATE_NODES + 3) * 3, 1) set_init([ self.actor_conv, self.critic_conv, self.actor_vnr_1_fc, self.actor_vnr_2_fc, self.actor_vnr_2_fc, self.critic_vnr_1_fc, self.critic_vnr_2_fc, self.critic_vnr_3_fc, self.actor_fc, self.critic_fc ]) self.distribution = torch.distributions.Categorical
def __init__(self, name='GCNConv'): super(Net, self).__init__() self.name = name if (name == 'GCNConv'): self.conv1 = GCNConv(dataset.num_features, 128) self.conv2 = GCNConv(128, 64) elif (name == 'ChebConv'): self.conv1 = ChebConv(dataset.num_features, 128, K=2) self.conv2 = ChebConv(128, 64, K=2) elif (name == 'GATConv'): self.conv1 = GATConv(dataset.num_features, 128) self.conv2 = GATConv(128, 64) elif (name == 'GINConv'): nn1 = Sequential(Linear(dataset.num_features, 128), ReLU(), Linear(128, 64)) self.conv1 = GINConv(nn1) self.bn1 = torch.nn.BatchNorm1d(64) nn2 = Sequential(Linear(64, 64), ReLU(), Linear(64, 64)) self.conv2 = GINConv(nn2) self.bn2 = torch.nn.BatchNorm1d(64) self.attr = GCNConv(64, dataset.num_classes, cached=True, normalize=not args.use_gdc) self.attack = GCNConv(64, dataset.num_classes, cached=True, normalize=not args.use_gdc) self.reverse = GradientReversalLayer()
def __init__(self, num_features, num_classes, nh=38, K=6, K_mix=2, inout_skipconn=True, depth=3, p=0.5, bn=False): super(Graph_resnet, self).__init__() self.inout_skipconn = inout_skipconn self.depth = depth self.Kipfblock_list = nn.ModuleList() self.skipproject_list = nn.ModuleList() if isinstance(nh, list): # if you give every layer a differnt number of channels # you need one number of channels for every layer! assert len(nh) == depth else: channels = nh nh = [] for i in range(depth): nh.append(channels) for i in range(depth): if i == 0: self.Kipfblock_list.append(Kipfblock(n_input=num_features, n_hidden=nh[0], K=K, p=p, bn=bn)) self.skipproject_list.append(ChebConv(num_features, nh[0], K=1)) else: self.Kipfblock_list.append(Kipfblock(n_input=nh[i-1], n_hidden=nh[i], K=K, p=p, bn=bn)) self.skipproject_list.append(ChebConv(nh[i-1], nh[i], K=1)) if inout_skipconn: self.conv_mix = ChebConv(nh[-1]+num_features, num_classes, K=K_mix) else: self.conv_mix = ChebConv(nh[-1], num_classes, K=K_mix)
def __init__(self, d1=90, d2=80, d3=50, num_features=1, num_classes=1, num_layers=4, dK=10, **kwargs): super(Net8, self).__init__() self.conv1 = ChebConv(num_features, d1, K=dK, bias=False) self.convs = torch.nn.ModuleList() for i in range(num_layers - 1): self.convs.append(ChebConv(d1, d1, K=dK)) self.bn1 = nn.BatchNorm1d(d1) self.fc1 = nn.Linear(d1, d2) self.bn2 = nn.BatchNorm1d(d2) self.fc2 = nn.Linear(d2, d3) self.bn3 = nn.BatchNorm1d(d3) self.fc3 = nn.Linear(d3, 2) # one output for regression self.bn4 = nn.BatchNorm1d(2) self.fc4 = nn.Linear(2, 1) self.num_layers = num_layers self.d1 = d1 self.d2 = d2 self.d3 = d3 self.dK = dK
def __init__(self, nfeat, nhid, nclass, dropout,nlayer=3): super(ChebGCNX, self).__init__() chebgcn_para1 = 2 self.conv1 = ChebConv(nfeat, nhid,chebgcn_para1) self.conv2 = ChebConv(nhid, nclass,chebgcn_para1) self.convx = nn.ModuleList([ChebConv(nhid, nhid,chebgcn_para1) for _ in range(nlayer-2)]) self.dropout_p = dropout
def __init__(self): super(Net, self).__init__() self.conv1 = ChebConv(80, 16, K=2) self.conv2 = ChebConv(16, 32, K=2) self.conv3 = ChebConv(32, 64, K=2) self.fc1 = nn.Linear(64, 100) self.fc2 = nn.Linear(100, 20) self.fc3 = nn.Linear(20, 5)
def __init__( self, in_channels, ): super(MultiChev_B, self).__init__() self.scale_1 = ChebConv(in_channels, 100, K=1) self.scale_2 = ChebConv(in_channels, 100, K=2) self.scale_3 = ChebConv(in_channels, 100, K=3)
def __init__(self, numFeatures, numClasses): super().__init__() self.conv1 = ChebConv(numFeatures, 8, 3) self.conv2 = ChebConv(8, 8, 3) self.fc1 = torch.nn.Linear(192, 64) self.fc2 = torch.nn.Linear(64, numClasses * 1)
def __init__(self): super(Net, self).__init__() self.conv1 = ChebConv(8, 16, K=4) self.conv2 = ChebConv(16, 32, K=4) self.conv3 = ChebConv(32, 64, K=4) self.fc1 = nn.Linear(512, 256) self.fc2 = nn.Linear(256, 128) self.fc3 = nn.Linear(128, 5)
def _create_candidate_state_parameters_and_layers(self): self.conv_x_h = ChebConv(in_channels=self.in_channels, out_channels=self.out_channels, K=self.K) self.conv_h_h = ChebConv(in_channels=self.out_channels, out_channels=self.out_channels, K=self.K)
def _create_reset_gate_parameters_and_layers(self): self.conv_x_r = ChebConv(in_channels=self.in_channels, out_channels=self.out_channels, K=self.K) self.conv_h_r = ChebConv(in_channels=self.out_channels, out_channels=self.out_channels, K=self.K)
def __init__(self, numFeatures, numClasses): super().__init__() self.conv1 = ChebConv(numFeatures, 8, 3) self.conv2 = ChebConv(8, 16, 3) self.conv3 = ChebConv(16, 32, 5) self.fc1 = torch.nn.Linear(768, 128) self.fc2 = torch.nn.Linear(128, numClasses * 1)
def __init__(self, inChannels, hiddenChannels, numNodes, numClasses): super(VanillaGCN, self).__init__() self.hiddenChannels = hiddenChannels self.numNodes = numNodes # self.conv1 = GCNConv(inChannels, 2*hiddenChannels) # self.conv2 = GCNConv(2*hiddenChannels, hiddenChannels) self.conv1 = ChebConv(inChannels, 2 * hiddenChannels, K=4) self.conv2 = ChebConv(2 * hiddenChannels, hiddenChannels, K=4) self.fc = nn.Linear(hiddenChannels * numNodes, numClasses)
def __init__(self): super(Net, self).__init__() # self.conv1 = GCNConv(dataset.num_features, 16, cached=True) # self.conv2 = GCNConv(16, dataset.num_classes, cached=True) self.conv1 = ChebConv(data.num_features, 16, K=2) self.conv2 = ChebConv(16, data.num_features, K=2) self.reg_params = self.conv1.parameters() self.non_reg_params = self.conv2.parameters()
def __init__(self, datasetroot, width): super(ChebConvNet, self).__init__() self.NumLayers = len(width) self.layers = nn.ModuleList() self.layers.append(ChebConv(datasetroot.num_features, width[0], K=1)) for i in range(self.NumLayers - 1): layer = ChebConv(width[i], width[i + 1], K=1) nn.init.xavier_uniform_(layer.weight) self.layers.append(layer) self.layers.append(ChebConv(width[-1], datasetroot.num_classes, K=1))
def __init__(self, num_features, num_classes, nh1=64, K=8, K_mix=2, cached=True, inout_skipconn=False): super(KipfNet, self).__init__() self.inout_skipconn = inout_skipconn self.Kipfblock1 = Kipfblock(n_input=num_features, n_hidden=nh1, K=K) if inout_skipconn: self.conv_mix = ChebConv(nh1+num_features, num_classes, K=K_mix) else: self.conv_mix = ChebConv(nh1, num_classes, K=K_mix)
def __init__(self, num_features, num_classes, training_method='dfa'): super(DFAChebNet, self).__init__() self.conv1 = ChebConv(num_features, 16, K=2) self.dfa_1 = DFALayer() self.conv2 = ChebConv(16, num_classes, K=2) self.dfa = DFA(dfa_layers=[self.dfa_1], no_training=training_method != 'dfa') self.reg_params = self.conv1.parameters() self.non_reg_params = self.conv2.parameters()
def _create_cell_state_parameters_and_layers(self): self.conv_x_c = ChebConv(in_channels=self.in_channels, out_channels=self.out_channels, K=self.K) self.conv_h_c = ChebConv(in_channels=self.out_channels, out_channels=self.out_channels, K=self.K) self.b_c = Parameter(torch.Tensor(1, self.out_channels))
def __init__(self, feature, out_channel): super(ChebyNet, self).__init__() self.GConv1 = ChebConv(feature,1024,K=1) self.bn1 = BatchNorm(1024) self.GConv2 = ChebConv(1024,1024,K=1) self.bn2 = BatchNorm(1024) self.fc = nn.Sequential(nn.Linear(1024, 512), nn.ReLU(inplace=True)) self.dropout = nn.Dropout(0.2) self.fc1 = nn.Sequential(nn.Linear(512, out_channel))
def _create_output_gate_parameters_and_layers(self): self.conv_x_o = ChebConv(in_channels=self.in_channels, out_channels=self.out_channels, K=self.K) self.conv_h_o = ChebConv(in_channels=self.out_channels, out_channels=self.out_channels, K=self.K) self.w_c_o = Parameter(torch.Tensor(1, self.out_channels)) self.b_o = Parameter(torch.Tensor(1, self.out_channels))
def __init__(self, in_channels, out_channels): super(Net, self).__init__() dim = 512 self.gcn1 = ChebConv(in_channels, dim, K=1) self.lin1 = nn.Linear(in_channels, dim) self.gcn2 = ChebConv(dim, dim, K=1) self.lin2 = nn.Linear(dim, dim) self.gcn3 = ChebConv(dim, dim, K=1) self.lin3 = nn.Linear(dim, dim) self.gcn4 = ChebConv(dim, dim, K=1) self.lin4 = nn.Linear(dim, dim) self.gcn5 = ChebConv(dim, out_channels, K=1) self.lin5 = nn.Linear(dim, out_channels)
def __init__(self, embedding_dim, conv_layers, polynomial_degree, hidden_dim, hidden_layers, nonlinearity, output_type): super(ChebNet, self).__init__(embedding_dim, hidden_dim, hidden_layers, nonlinearity, output_type) self.num_conv_layers = conv_layers self.polynomial_degree = polynomial_degree self.conv_layers = ModuleList( [ChebConv(1, self.embedding_dim, self.polynomial_degree)] + [ ChebConv(self.embedding_dim, self.embedding_dim, self.polynomial_degree) for _ in range(self.num_conv_layers - 1) ])
def _create_candidate_state_parameters_and_layers(self): self.conv_x_h = ChebConv(in_channels=self.in_channels, out_channels=self.out_channels, K=self.K, normalization=self.normalization, bias=self.bias) self.conv_h_h = ChebConv(in_channels=self.out_channels, out_channels=self.out_channels, K=self.K, normalization=self.normalization, bias=self.bias)
def __init__(self): super(Net, self).__init__() if args.model == 'GCN': #cached = True is for transductive learning self.conv1 = GCNConv(data.x.shape[1], 16, cached=True) self.conv2 = GCNConv(16, 32, cached=True) self.conv3 = GCNConv(32, 64, cached=True) self.conv4 = GCNConv(64, 6, cached=True) elif args.model == 'ChebConv': self.conv1 = ChebConv(data.x.shape[1], 16, K=3) self.conv2 = ChebConv(16, 32, K=3) self.conv3 = ChebConv(32, 64, K=3) self.conv4 = ChebConv(64, 6, K=3)
def __init__(self, in_channels=8, out_channels=2): super(MultiScaleChebConv, self).__init__() out_channels *= 144 in_channels *= 144 self.out_channels = out_channels self.in_channels = in_channels self.chebconv_k3 = ChebConv(in_channels, out_channels, K=4).cuda() self.chebconv_k5 = ChebConv(in_channels, out_channels, K=5).cuda() self.chebconv_k7 = ChebConv(in_channels, out_channels, K=6).cuda() self.chebconv_k9 = ChebConv(in_channels, out_channels, K=7).cuda()