fix GraphNeuralNetworks.jl

Author: CarloLucibello

GraphNeuralNetworks/docs/make.jl

@@ -12,6 +12,7 @@ using GraphNeuralNetworks
 using Flux, GNNGraphs, GNNlib, Graphs
 using DocumenterInterLinks
 
+DocMeta.setdocmeta!(GNNGraphs, :DocTestSetup, :(using GNNGraphs, MLUtils); recursive = true)
 DocMeta.setdocmeta!(GraphNeuralNetworks, :DocTestSetup, :(using GraphNeuralNetworks); recursive = true)
 
 mathengine = MathJax3(Dict(:loader => Dict("load" => ["[tex]/require", "[tex]/mathtools"]),

GraphNeuralNetworks/src/layers/basic.jl

@@ -74,30 +74,22 @@ julia> using Flux, GraphNeuralNetworks
 julia> m = GNNChain(GCNConv(2=>5), 
                     BatchNorm(5), 
                     x -> relu.(x), 
-                    Dense(5, 4))
-GNNChain(GCNConv(2 => 5), BatchNorm(5), #7, Dense(5 => 4))
+                    Dense(5, 4));
 
 julia> x = randn(Float32, 2, 3);
 
 julia> g = rand_graph(3, 6)
 GNNGraph:
-    num_nodes = 3
-    num_edges = 6
+  num_nodes: 3
+  num_edges: 6
 
-julia> m(g, x)
-4×3 Matrix{Float32}:
-    -0.795592  -0.795592  -0.795592
-    -0.736409  -0.736409  -0.736409
-    0.994925   0.994925   0.994925
-    0.857549   0.857549   0.857549
+julia> m(g, x) |> size
+(4, 3)
 
-julia> m2 = GNNChain(enc = m, 
-                     dec = DotDecoder())
-GNNChain(enc = GNNChain(GCNConv(2 => 5), BatchNorm(5), #7, Dense(5 => 4)), dec = DotDecoder())
+julia> m2 = GNNChain(enc = m, dec = DotDecoder());
 
-julia> m2(g, x)
-1×6 Matrix{Float32}:
- 2.90053  2.90053  2.90053  2.90053  2.90053  2.90053
+julia> m2(g, x) |> size
+(1, 6)
 
 julia> m2[:enc](g, x) == m(g, x)
 true
@@ -196,15 +188,14 @@ returns the dot product `x_i ⋅ xj` on each edge.
 ```jldoctest
 julia> g = rand_graph(5, 6)
 GNNGraph:
-    num_nodes = 5
-    num_edges = 6
+  num_nodes: 5
+  num_edges: 6
 
 julia> dotdec = DotDecoder()
 DotDecoder()
 
-julia> dotdec(g, rand(2, 5))
-1×6 Matrix{Float64}:
- 0.345098  0.458305  0.106353  0.345098  0.458305  0.106353
+julia> dotdec(g, rand(2, 5)) |> size
+(1, 6)
 ```
 """
 struct DotDecoder <: GNNLayer end

GraphNeuralNetworks/src/layers/heteroconv.jl

@@ -21,10 +21,12 @@ have to be aggregated using the `aggr` function. The default is to sum the outpu
 # Examples 
 
 ```jldoctest
-julia> g = rand_bipartite_heterograph((10, 15), 20)
+julia> using GraphNeuralNetworks, Flux
+
+julia> g = rand_bipartite_heterograph((10, 15), 80)
 GNNHeteroGraph:
   num_nodes: Dict(:A => 10, :B => 15)
-  num_edges: Dict((:A, :to, :B) => 20, (:B, :to, :A) => 20)
+  num_edges: Dict((:A, :to, :B) => 80, (:B, :to, :A) => 80)
 
 julia> x = (A = rand(Float32, 64, 10), B = rand(Float32, 64, 15));
 

GraphNeuralNetworks/src/layers/temporalconv.jl

@@ -59,16 +59,13 @@ Returns the updated node features:
 The following example considers a static graph and a time-varying node features.
 
 ```jldoctest
-julia> num_nodes, num_edges = 5, 10;
+julia> num_nodes, num_edges = 5, 16;
 
 julia> d_in, d_out = 2, 3;
 
 julia> timesteps = 5;
 
 julia> g = rand_graph(num_nodes, num_edges);
-GNNGraph:
-  num_nodes: 5
-  num_edges: 10
 
 julia> x = rand(Float32, d_in, timesteps, num_nodes);
 
@@ -93,11 +90,15 @@ julia> timesteps = 5;
 
 julia> num_nodes = [10, 10, 10, 10, 10];
 
-julia> num_edges = [10, 12, 14, 16, 18];
+julia> num_edges = [20, 22, 24, 26, 28];
 
 julia> snapshots = [rand_graph(n, m) for (n, m) in zip(num_nodes, num_edges)];
 
 julia> tg = TemporalSnapshotsGNNGraph(snapshots)
+TemporalSnapshotsGNNGraph:
+  num_nodes: [10, 10, 10, 10, 10]
+  num_edges: [20, 22, 24, 26, 28]
+  num_snapshots: 5
 
 julia> x = [rand(Float32, d_in, n) for n in num_nodes];
 
@@ -269,7 +270,7 @@ See [`GNNRecurrence`](@ref) for more details.
 # Examples
 
 ```jldoctest
-julia> num_nodes, num_edges = 5, 10;
+julia> num_nodes, num_edges = 5, 16;
 
 julia> d_in, d_out = 2, 3;
 
@@ -280,7 +281,7 @@ julia> g = rand_graph(num_nodes, num_edges);
 julia> x = rand(Float32, d_in, timesteps, num_nodes);
 
 julia> layer = GConvGRU(d_in => d_out, 2)
-GConvGRU(
+GNNRecurrence(
   GConvGRUCell(2 => 3, 2),              # 108 parameters
 )                   # Total: 12 arrays, 108 parameters, 1.148 KiB.
 
@@ -326,9 +327,9 @@ where `output` is the updated hidden state `h` of the LSTM cell and `state` is t
 # Examples
 
 ```jldoctest
-julia> using GraphNeuralNetworks, Flux
+julia> using Flux
 
-julia> num_nodes, num_edges = 5, 10;
+julia> num_nodes, num_edges = 5, 16;
 
 julia> d_in, d_out = 2, 3;
 
@@ -453,7 +454,7 @@ See [`GNNRecurrence`](@ref) for more details.
 # Examples
 
 ```jldoctest
-julia> num_nodes, num_edges = 5, 10;
+julia> num_nodes, num_edges = 5, 16;
 
 julia> d_in, d_out = 2, 3;
 
@@ -727,23 +728,27 @@ julia> timesteps = 5;
 
 julia> num_nodes = [10, 10, 10, 10, 10];
 
-julia> num_edges = [10, 12, 14, 16, 18];
+julia> num_edges = [60, 62, 64, 66, 68];
 
 julia> snapshots = [rand_graph(n, m) for (n, m) in zip(num_nodes, num_edges)];
 
 julia> tg = TemporalSnapshotsGNNGraph(snapshots)
+TemporalSnapshotsGNNGraph:
+  num_nodes: [10, 10, 10, 10, 10]
+  num_edges: [60, 62, 64, 66, 68]
+  num_snapshots: 5
 
 julia> x = [rand(Float32, d_in, n) for n in num_nodes];
 
-julia> cell = EvolveGCNO(d_in => d_out)
+julia> layer = EvolveGCNO(d_in => d_out)
 GNNRecurrence(
   EvolveGCNOCell(2 => 3),               # 321 parameters
 )                   # Total: 5 arrays, 321 parameters, 1.535 KiB.
 
 julia> y = layer(tg, x);
 
 julia> length(y)    # timesteps
-5 
+5
 
 julia> size(y[end]) # (d_out, num_nodes[end])
 (3, 10)
@@ -874,6 +879,9 @@ julia> g = rand_graph(num_nodes, num_edges);
 julia> x = rand(Float32, d_in, timesteps, num_nodes);
 
 julia> layer = TGCN(d_in => d_out)
+GNNRecurrence(
+  TGCNCell(2 => 3),                     # 126 parameters
+)                   # Total: 18 arrays, 126 parameters, 1.469 KiB.
 
 julia> y = layer(g, x);