10,27 most function finished

GCN-PyTorch-master/layer.py

@@ -24,34 +24,36 @@ class GraphConvolution(nn.Module):
         self.featureless = featureless                  # 如果啥都没有，那就没有
         self.num_features_nonzero = num_features_nonzero    # 返回的是如果有值的时候他值的个数
 
-        self.weight = nn.Parameter(torch.randn(input_dim, output_dim))      # 学习参数，上边的bias那个地方写的公式
-        self.bias = None                                # 他这个地方强制置成零了
+        self.weight = nn.Parameter(torch.randn(input_dim, output_dim))      # 学习参数，上边的bias那个地方写的公式，给踢个random
+        self.bias = None                                                    # 他这个地方强制置成零了
         if bias:
-            self.bias = nn.Parameter(torch.zeros(output_dim))       # 他这个给bias了一个可学的参数
+            self.bias = nn.Parameter(torch.zeros(output_dim))               # 他这个给bias了一个可学的参数
 
 
     def forward(self, inputs):
-        # print('inputs:', inputs)
-        x, support = inputs
+        # print('inputs:', inputs)，
+        # 这个地方的input就是那个连接矩阵，用它做的前馈函数
+        x, support = inputs     # 这个接进来，support做的Adcexcay
 
+        # 确定在train的状态下，稀疏矩阵和非稀疏矩阵是两种不同的dropout方法
         if self.training and self.is_sparse_inputs:
             x = sparse_dropout(x, self.dropout, self.num_features_nonzero)
         elif self.training:
             x = F.dropout(x, self.dropout)
 
-        # convolve
+        # convolve，看一下有没有特征
         if not self.featureless: # if it has features x
             if self.is_sparse_inputs:
-                xw = torch.sparse.mm(x, self.weight)
+                xw = torch.sparse.mm(x, self.weight)        # 把x和weight相乘
             else:
                 xw = torch.mm(x, self.weight)
         else:
             xw = self.weight
 
-        out = torch.sparse.mm(support, xw)
+        out = torch.sparse.mm(support, xw)                  # 把support和weight乘起来
 
         if self.bias is not None:
-            out += self.bias
+            out += self.bias                                # 加了bias
 
-        return self.activation(out), support
+        return self.activation(out), support                # 这个前向函数写的有问题吧我感觉？！
 

GCN-PyTorch-master/model.py

@@ -6,7 +6,7 @@ from    layer import GraphConvolution
 from    config import args
 
 class GCN(nn.Module):
-
+    # https://www.educba.com/torch-dot-nn-module/
 
     def __init__(self, input_dim, output_dim, num_features_nonzero):
         super(GCN, self).__init__()
@@ -21,31 +21,38 @@ class GCN(nn.Module):
         print('output dim:', output_dim)
         print('num_features_nonzero:', num_features_nonzero)
 
-
+        # 这个地方实际上定义的是两层，就是说，输入输出之间增加了一个隐含层，然后他配合了一下维度把他连接起来了，
+        # 定义的是两层自己层内的特性，层之间的链接还没有
+        # https://blog.csdn.net/dss_dssssd/article/details/82980222，Sequential 相当于将各个层加入一个容器里边，
+        # 而且我这个地方调用的时候调用的是类，相当于连接的部分nn.Sequential直接就把forward函数调用进来了，
+        # 这个地方还没有调用forward函数？
         self.layers = nn.Sequential(GraphConvolution(self.input_dim, args.hidden, num_features_nonzero,
                                                      activation=F.relu,
                                                      dropout=args.dropout,
-                                                     is_sparse_inputs=True),
+                                                     is_sparse_inputs=True),   # 这个地方是输入->隐层
 
                                     GraphConvolution(args.hidden, output_dim, num_features_nonzero,
                                                      activation=F.relu,
                                                      dropout=args.dropout,
-                                                     is_sparse_inputs=False),
-
+                                                     is_sparse_inputs=False),  # 这个地方是隐层->输出
                                     )
 
-    def forward(self, inputs):
+
+    def forward(self, inputs) :
+        # 这个地方调用了forword函数，稍等一下再看那个forward函数，感觉他有点问题哈
         x, support = inputs
 
-        x = self.layers((x, support))
+        x = self.layers((x, support))          # 这个地方调用了layer里边的forword函数，这个layer这个里边只有一个函数，所以直接用就行了，
+        # 他这个相当于直接调用了一个元组扔进去了，x为feature信息，support为联通矩阵的信息
 
         return x
 
     def l2_loss(self):
-
+        # L2型的损失函数，利用l2范数计算损失情况：（误差的平方）的和，可以有稳定的单一解
+        # https://zhuanlan.zhihu.com/p/52203156，这个下边的layer是抽取了nn.Model里边的一层
         layer = self.layers.children()
         layer = next(iter(layer))
-
+        # todo: 明天看一下Python迭代器的东西
         loss = None
 
         for p in layer.parameters():

GCN-PyTorch-master/train.py

@@ -69,7 +69,8 @@ feature = torch.sparse.FloatTensor(i.t(), v, features[2]).to(device)
 supports = preprocess_adj(adj)          # 把A搞成这个东西的返回值就是那个系数D^-0.5AD^0.5
 i = torch.from_numpy(supports[0]).long().to(device)
 v = torch.from_numpy(supports[1]).to(device)
-support = torch.sparse.FloatTensor(i.t(), v, supports[2]).float().to(device)
+support = torch.sparse.FloatTensor(i.t(), v, supports[2]).float().to(device)        # support是内个连接矩阵的常见版本
+
 
 print('x :', feature)
 print('sp:', support)
@@ -82,11 +83,13 @@ feat_dim = feature.shape[1]     # 返回的是那个非稀疏矩阵的维度
 
 
 # 开始train net了
-net = GCN(feat_dim, num_classes, num_features_nonzero)
-net.to(device)
-optimizer = optim.Adam(net.parameters(), lr=args.learning_rate)
+net = GCN(feat_dim, num_classes, num_features_nonzero)                  # 投进去的只有数据和特征
+# torch.nn.Parameter(data,requires_grad)
+net.to(device)          # CUDA
+optimizer = optim.Adam(net.parameters(), lr=args.learning_rate)         # 底层加速计算用的
 
-net.train()
+net.train()         # 一般在开始训练代码的地方加入，涉及Dropout和batch normalizatuon的时候用这个是必须的
+# https://blog.csdn.net/qq_46284579/article/details/120439049，如果没有DP和BN，这两个函数的影响好坏不定， 不用细致操作，不是类函数
 for epoch in range(args.epochs):
 
     out = net((feature, support))
@@ -104,7 +107,7 @@ for epoch in range(args.epochs):
 
         print(epoch, loss.item(), acc.item())
 
-net.eval()
+net.eval()          # 一般在测试的地方加入，涉及Dropout和batch normalizatuon的时候用这个是必须的
 
 out = net((feature, support))
 out = out[0]