remove update_global

Author: CarloLucibello

docs/make.jl

@@ -1,10 +1,11 @@
-using Flux, NNlib, GraphNeuralNetworks
+using Flux, NNlib, GraphNeuralNetworks, LightGraphs, SparseArrays
 using Documenter
 
 DocMeta.setdocmeta!(GraphNeuralNetworks, :DocTestSetup, :(using GraphNeuralNetworks); recursive=true)
 
 makedocs(;
-    modules=[GraphNeuralNetworks],
+    modules=[GraphNeuralNetworks, NNlib, Flux, LightGraphs, SparseArrays],
+    doctest=false, clean=true,     
     sitename = "GraphNeuralNetworks.jl",
     pages = ["Home" => "index.md",
              "GNNGraph" => "gnngraph.md",

docs/src/api/basic.md

@@ -2,11 +2,11 @@
 
 ```@index
 Order = [:type, :function]
-Pages   = ["api/basics.md"]
+Modules = [GraphNeuralNetworks, LightGraphs, Flux, NNlib]
+Pages = ["api/basics.md"]
 ```
 
-```@autodocs
-Modules = [GraphNeuralNetworks]
-Pages   = ["layers/basic.jl"]
-Private = false
-```
+```@docs
+GNNLayer
+GNNChain
+```

docs/src/api/gnngraph.md

@@ -10,3 +10,8 @@ Modules = [GraphNeuralNetworks]
 Pages   = ["gnngraph.jl"]
 Private = false
 ```
+```@docs
+Flux.batch
+SparseArrays.blockdiag
+LightGraphs.adjacency_matrix
+```

docs/src/gnngraph.md

@@ -67,7 +67,7 @@ using Flux
 
 gall = Flux.batch([GNNGraph(erdos_renyi(10, 30), ndata=rand(3,10)) for _ in 1:100])
 
-subgraph(gall, 2:3)
+getgraph(gall, 2:3)
 
 
 # DataLoader compatibility

docs/src/messagepassing.md

@@ -2,6 +2,3 @@
 
 TODO
 
-```@docs
-propagate
-```

examples/graph_classification_tudataset.jl

@@ -21,7 +21,7 @@ function eval_loss_accuracy(model, data_loader, device)
         y = g.gdata.y
         ŷ = model(g, g.ndata.X) |> vec
         loss += logitbinarycrossentropy(ŷ, y) * n 
-        acc += mean((2 .* ŷ .- 1) .* (2 .* y .- 1) .> 0) * n
+        acc += mean((ŷ .> 0) .== y) * n
         ntot += n
     end 
     return (loss = round(loss/ntot, digits=4), acc = round(acc*100/ntot, digits=2))

src/GraphNeuralNetworks.jl

@@ -20,18 +20,18 @@ export
     # gnngraph
     GNNGraph,
     edge_index,
-    node_features, edge_features, global_features,
+    node_features, edge_features, graph_features,
     adjacency_list, normalized_laplacian, scaled_laplacian,
     add_self_loops, remove_self_loops,
-    subgraph,
+    getgraph,
 
     # from LightGraphs
     adjacency_matrix, 
     # from SparseArrays
     sprand, sparse, 
 
     # msgpass
-    # update, update_edge, update_global, message, propagate,
+    # update, update_edge, message, propagate,
 
     # layers/basic
     GNNLayer,

src/gnngraph.jl

@@ -10,7 +10,7 @@ const ADJLIST_T = AbstractVector{T} where T <: AbstractVector
 const ADJMAT_T = AbstractMatrix
 const SPARSE_T = AbstractSparseMatrix # subset of ADJMAT_T
 
-"""
+""" 
     GNNGraph(data; [graph_type, ndata, edata, gdata, num_nodes, graph_indicator, dir])
     GNNGraph(g::GNNGraph; [ndata, edata, gdata])
 
@@ -416,9 +416,6 @@ end
 """
     blockdiag(xs::GNNGraph...)
 
-Batch togheter multiple `GNNGraph`s into a single one 
-containing the total number of nodes and edges of the original graphs.
-
 Equivalent to [`Flux.batch`](@ref).
 """
 function SparseArrays.blockdiag(g1::GNNGraph, gothers::GNNGraph...)
@@ -432,7 +429,7 @@ end
 """
     batch(xs::Vector{<:GNNGraph})
 
-Batch togheter multiple `GNNGraph`s into a single one 
+Batch together multiple `GNNGraph`s into a single one 
 containing the total number of nodes and edges of the original graphs.
 
 Equivalent to [`SparseArrays.blockdiag`](@ref).
@@ -441,28 +438,28 @@ Flux.batch(xs::Vector{<:GNNGraph}) = blockdiag(xs...)
 
 ### LearnBase compatibility
 LearnBase.nobs(g::GNNGraph) = g.num_graphs 
-LearnBase.getobs(g::GNNGraph, i) = subgraph(g, i)[1]
+LearnBase.getobs(g::GNNGraph, i) = getgraph(g, i)[1]
 
 # Flux's Dataloader compatibility. Related PR https://github.com/FluxML/Flux.jl/pull/1683
 Flux.Data._nobs(g::GNNGraph) = g.num_graphs
-Flux.Data._getobs(g::GNNGraph, i) = subgraph(g, i)[1]
+Flux.Data._getobs(g::GNNGraph, i) = getgraph(g, i)[1]
 
 #########################
 Base.:(==)(g1::GNNGraph, g2::GNNGraph) = all(k -> getfield(g1,k)==getfield(g2,k), fieldnames(typeof(g1)))
 
 """
-    subgraph(g::GNNGraph, i)
+    getgraph(g::GNNGraph, i)
 
-Return the subgraph of `g` induced by those nodes `v`
+Return the getgraph of `g` induced by those nodes `v`
 for which `g.graph_indicator[v] ∈ i`. In other words, it
 extract the component graphs from a batched graph. 
 
 It also returns a vector `nodes` mapping the new nodes to the old ones. 
-The node `i` in the subgraph corresponds to the node `nodes[i]` in `g`.
+The node `i` in the getgraph corresponds to the node `nodes[i]` in `g`.
 """
-subgraph(g::GNNGraph, i::Int) = subgraph(g::GNNGraph{<:COO_T}, [i])
+getgraph(g::GNNGraph, i::Int) = getgraph(g::GNNGraph{<:COO_T}, [i])
 
-function subgraph(g::GNNGraph{<:COO_T}, i::AbstractVector{Int})
+function getgraph(g::GNNGraph{<:COO_T}, i::AbstractVector{Int})
     if g.graph_indicator === nothing
         @assert i == [1]
         return g
@@ -517,7 +514,7 @@ function edge_features(g::GNNGraph)
     end
 end
 
-function global_features(g::GNNGraph)
+function graph_features(g::GNNGraph)
     if isempty(g.gdata)
         return nothing
     elseif length(g.gdata) > 1

src/msgpass.jl

@@ -2,7 +2,7 @@
 # "Relational inductive biases, deep learning, and graph networks"
 
 """
-    propagate(l, g, aggr, [X, E, U]) -> X′, E′, U′
+    propagate(l, g, aggr, [X, E]) -> X′, E′
     propagate(l, g, aggr) -> g′
 
 Perform the sequence of operations implementing the message-passing scheme
@@ -12,11 +12,10 @@ Updates the node, edge, and global features `X`, `E`, and `U` respectively.
 The computation involved is the following:
 
 ```julia
-M = compute_batch_message(l, g, X, E, U) 
+M = compute_batch_message(l, g, X, E) 
 M̄ = aggregate_neighbors(l, aggr, g, M)
-X′ = update(l, X, M̄, U)
-E′ = update_edge(l, E, M, U)
-U′ = update_global(l, U, X′, E′)
+X′ = update(l, X, M̄)
+E′ = update_edge(l, E, M)
 ```
 
 Custom layers typically define their own [`update`](@ref)
@@ -26,7 +25,7 @@ this method in the forward pass:
 ```julia
 function (l::MyLayer)(g, X)
     ... some prepocessing if needed ...
-    propagate(l, g, +, X, E, U)
+    propagate(l, g, +, X, E)
 end
 ```
 
@@ -35,24 +34,21 @@ See also [`message`](@ref) and [`update`](@ref).
 function propagate end 
 
 function propagate(l, g::GNNGraph, aggr)
-    X, E, U = propagate(l, g, aggr, 
-                node_features(g), edge_features(g), global_features(g))
+    X, E = propagate(l, g, aggr, node_features(g), edge_features(g))
 
-    return GNNGraph(g, ndata=X, edata=E, gdata=U)
+    return GNNGraph(g, ndata=X, edata=E)
 end
 
-function propagate(l, g::GNNGraph, aggr, X, E=nothing, U=nothing)
-    # TODO consider g.graph_indicator in propagating U
-    M = compute_batch_message(l, g, X, E, U) 
+function propagate(l, g::GNNGraph, aggr, X, E=nothing)
+    M = compute_batch_message(l, g, X, E) 
     M̄ = aggregate_neighbors(l, g, aggr, M)
-    X′ = update(l, X, M̄, U)
-    E′ = update_edge(l, E, M, U)
-    U′ = update_global(l, U, X′, E′)
+    X′ = update(l, X, M̄)
+    E′ = update_edge(l, E, M)
     return X′, E′, U′
 end
 
 """
-    message(l, x_i, x_j, [e_ij, u])
+    message(l, x_i, x_j, [e_ij])
 
 Message function for the message-passing scheme,
 returning the message from node `j` to node `i` .
@@ -68,15 +64,14 @@ Custom layer should specialize this method with the desired behavior.
 - `l`: A gnn layer.
 - `x_i`: Features of the central node `i`.
 - `x_j`: Features of the neighbor `j` of node `i`.
-- `e_ij`: Features of edge (`i`, `j`).
-- `u`: Global features.
+- `e_ij`: Features of edge `(i,j)`.
 
 See also [`update`](@ref) and [`propagate`](@ref).
 """
 function message end 
 
 """
-    update(l, x, m̄, [u])
+    update(l, x, m̄)
 
 Update function for the message-passing scheme,
 returning a new set of node features `x′` based on old 
@@ -102,15 +97,14 @@ _gather(x::Nothing, i) = nothing
 
 ## Step 1.
 
-function compute_batch_message(l, g, X, E, U)
+function compute_batch_message(l, g, X, E)
     s, t = edge_index(g)
     Xi = _gather(X, t)
     Xj = _gather(X, s)
-    M = message(l, Xi, Xj, E, U)
+    M = message(l, Xi, Xj, E)
     return M
 end
 
-@inline message(l, x_i, x_j, e_ij, u) = message(l, x_i, x_j, e_ij)
 @inline message(l, x_i, x_j, e_ij) = message(l, x_i, x_j)
 @inline message(l, x_i, x_j) = x_j
 
@@ -125,17 +119,10 @@ aggregate_neighbors(l, g, aggr::Nothing, E) = nothing
 
 ## Step 3
 
-@inline update(l, x, m̄, u) = update(l, x, m̄)
 @inline update(l, x, m̄) = m̄
 
 ## Step 4
 
-@inline update_edge(l, E, M, U) = update_edge(l, E, M)
 @inline update_edge(l, E, M) = E
 
-## Step 5
-
-@inline update_global(l, U, X, E) = update_global(l, U, X)
-@inline update_global(l, U, X) = U
-
 ### end steps ###

test/gnngraph.jl

@@ -120,13 +120,13 @@
         @test node_features(g123)[:,11:14] ≈ node_features(g2) 
     end
 
-    @testset "subgraph"  begin
+    @testset "getgraph"  begin
         #TODO add graph_type=GRAPH_T
         g1 = GNNGraph(random_regular_graph(10,2), ndata=rand(16,10))
         g2 = GNNGraph(random_regular_graph(4,2), ndata=rand(16,4))
         g3 = GNNGraph(random_regular_graph(7,2), ndata=rand(16,7))
         g = Flux.batch([g1, g2, g3])
-        g2b, nodemap = subgraph(g, 2)
+        g2b, nodemap = getgraph(g, 2)
 
         s, t = edge_index(g2b)
         @test s == edge_index(g2)[1]
@@ -171,11 +171,11 @@
         g = Flux.batch([GNNGraph(erdos_renyi(10, 30), ndata=rand(10, n), edata=rand(10, m), gdata=rand(10, 1)) 
                         for _ in 1:num_graphs])
 
-        @test LearnBase.getobs(g, 3) == subgraph(g, 3)[1]
-        @test LearnBase.getobs(g, 3:5) == subgraph(g, 3:5)[1]
+        @test LearnBase.getobs(g, 3) == getgraph(g, 3)[1]
+        @test LearnBase.getobs(g, 3:5) == getgraph(g, 3:5)[1]
         @test LearnBase.nobs(g) == g.num_graphs
 
         d = Flux.Data.DataLoader(g, batchsize = 2, shuffle=false)
-        @test first(d) == subgraph(g, 1:2)[1]
+        @test first(d) == getgraph(g, 1:2)[1]
     end
 end