Merge pull request #57 from CarloLucibello/cl/graph

CarloLucibello · web-flow · commit a8b5ba9484ff · 2021-10-23T09:51:30.000+02:00
drop LightGraphs for Graphs
diff --git a/Project.toml b/Project.toml
@@ -1,17 +1,17 @@
 name = "GraphNeuralNetworks"
 uuid = "cffab07f-9bc2-4db1-8861-388f63bf7694"
 authors = ["Carlo Lucibello and contributors"]
-version = "0.2.3"
+version = "0.3.0"
 
 [deps]
 Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
 CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
 ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"
+Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 KrylovKit = "0b1a1467-8014-51b9-945f-bf0ae24f4b77"
 LearnBase = "7f8f8fb0-2700-5f03-b4bd-41f8cfc144b6"
-LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
 NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd"
@@ -26,9 +26,9 @@ CUDA = "3.3"
 ChainRulesCore = "1"
 DataStructures = "0.18"
 Flux = "0.12.7"
+Graphs = "1.4"
 KrylovKit = "0.5"
 LearnBase = "0.4, 0.5"
-LightGraphs = "1.3"
 MacroTools = "0.5"
 NNlib = "0.7"
 NNlibCUDA = "0.1"
diff --git a/docs/Project.toml b/docs/Project.toml
@@ -2,6 +2,6 @@
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
 Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"
 GraphNeuralNetworks = "cffab07f-9bc2-4db1-8861-388f63bf7694"
-LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
+Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
diff --git a/docs/make.jl b/docs/make.jl
@@ -1,10 +1,10 @@
-using Flux, NNlib, GraphNeuralNetworks, LightGraphs, SparseArrays
+using Flux, NNlib, GraphNeuralNetworks, Graphs, SparseArrays
 using Documenter
 
 DocMeta.setdocmeta!(GraphNeuralNetworks, :DocTestSetup, :(using GraphNeuralNetworks); recursive=true)
 
 makedocs(;
-    modules=[GraphNeuralNetworks, NNlib, Flux, LightGraphs, SparseArrays],
+    modules=[GraphNeuralNetworks, NNlib, Flux, Graphs, SparseArrays],
     doctest=false, clean=true,     
     sitename = "GraphNeuralNetworks.jl",
     pages = ["Home" => "index.md",
diff --git a/docs/src/api/gnngraph.md b/docs/src/api/gnngraph.md
@@ -24,5 +24,5 @@ Private = false
 ```@docs
 Flux.batch
 SparseArrays.blockdiag
-LightGraphs.adjacency_matrix
+Graphs.adjacency_matrix
 ```
diff --git a/docs/src/gnngraph.md b/docs/src/gnngraph.md
@@ -9,10 +9,10 @@ operators, gpu movement, and storage of node/edge/graph related feature arrays.
 A GNNGraph can be created from several different data sources encoding the graph topology:
 
 ```julia
-using GraphNeuralNetworks, LightGraphs, SparseArrays
+using GraphNeuralNetworks, Graphs, SparseArrays
 
 
-# Construct GNNGraph from From LightGraphs's graph
+# Construct GNNGraph from From Graphs's graph
 lg = erdos_renyi(10, 30)
 g = GNNGraph(lg)
 
@@ -70,7 +70,7 @@ g.ndata.y, g.ndata.x
 
 # Attach an array with edge features.
 # Since `GNNGraph`s are directed, the number of edges
-# will be double that of the original LightGraphs' undirected graph.
+# will be double that of the original Graphs' undirected graph.
 g = GNNGraph(erdos_renyi(10,  30), edata = rand(Float32, 60))
 @assert g.num_edges == 60
 
@@ -134,10 +134,10 @@ g′ = remove_self_loops(g)
 
 ## JuliaGraphs ecosystem integration
 
-Since `GNNGraph <: LightGraphs.AbstractGraph`, we can use any functionality from LightGraphs. 
+Since `GNNGraph <: Graphs.AbstractGraph`, we can use any functionality from Graphs. 
 
 ```julia
-@assert LightGraphs.isdirected(g)
+@assert Graphs.isdirected(g)
 ```
 
 ## GPU movement
diff --git a/docs/src/index.md b/docs/src/index.md
@@ -27,7 +27,7 @@ First, we create our dataset consisting in multiple random graphs and associated
 Then we batch the graphs together into a unique graph.
 
 ```julia
-julia> using GraphNeuralNetworks, LightGraphs, Flux, CUDA, Statistics
+julia> using GraphNeuralNetworks, Graphs, Flux, CUDA, Statistics
 
 julia> all_graphs = GNNGraph[];
 
diff --git a/docs/src/messagepassing.md b/docs/src/messagepassing.md
@@ -49,7 +49,7 @@ The convolution reads
 We will also add a bias and an activation function.
 
 ```julia
-using Flux, LightGraphs, GraphNeuralNetworks
+using Flux, Graphs, GraphNeuralNetworks
 
 struct GCN{A<:AbstractMatrix, B, F} <: GNNLayer
     weight::A
diff --git a/docs/src/models.md b/docs/src/models.md
@@ -20,7 +20,7 @@ In the explicit modeling style, the model is created according to the following
 
 Here is an example of this construction:
 ```julia
-using Flux, LightGraphs, GraphNeuralNetworks
+using Flux, Graphs, GraphNeuralNetworks
 
 struct GNN                                # step 1
     conv1
@@ -71,7 +71,7 @@ to layers subtyping the [`GNNLayer`](@ref) abstract type.
 Using `GNNChain`, the previous example becomes
 
 ```julia
-using Flux, LightGraphs, GraphNeuralNetworks
+using Flux, Graphs, GraphNeuralNetworks
 
 din, d, dout = 3, 4, 2 
 g = GNNGraph(random_regular_graph(10, 4))
diff --git a/examples/Project.toml b/examples/Project.toml
@@ -4,7 +4,7 @@ DiffEqFlux = "aae7a2af-3d4f-5e19-a356-7da93b79d9d0"
 DifferentialEquations = "0c46a032-eb83-5123-abaf-570d42b7fbaa"
 Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"
 GraphNeuralNetworks = "cffab07f-9bc2-4db1-8861-388f63bf7694"
-LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
+Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 MLDatasets = "eb30cadb-4394-5ae3-aed4-317e484a6458"
 NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd"
 NNlibCUDA = "a00861dc-f156-4864-bf3c-e6376f28a68d"
diff --git a/examples/node_classification_cora.jl b/examples/node_classification_cora.jl
@@ -12,7 +12,7 @@ CUDA.allowscalar(false)
 function eval_loss_accuracy(X, y, ids, model, g)
     ŷ = model(g, X)
     l = logitcrossentropy(ŷ[:,ids], y[:,ids])
-    acc = mean(onecold(ŷ[:,ids] |> cpu) .== onecold(y[:,ids] |> cpu))
+    acc = mean(onecold(ŷ[:,ids]) .== onecold(y[:,ids]))
     return (loss = round(l, digits=4), acc = round(acc*100, digits=2))
 end
 
diff --git a/perf/Project.toml b/perf/Project.toml
@@ -3,4 +3,4 @@ BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"
 DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
 GraphNeuralNetworks = "cffab07f-9bc2-4db1-8861-388f63bf7694"
 JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819"
-LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
+Graphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
diff --git a/perf/perf.jl b/perf/perf.jl
@@ -1,4 +1,4 @@
-using Flux, GraphNeuralNetworks, LightGraphs, BenchmarkTools, CUDA
+using Flux, GraphNeuralNetworks, Graphs, BenchmarkTools, CUDA
 using DataFrames, Statistics, JLD2, SparseArrays
 CUDA.device!(2)
 CUDA.allowscalar(false)
diff --git a/src/GraphNeuralNetworks.jl b/src/GraphNeuralNetworks.jl
@@ -14,8 +14,8 @@ using LearnBase: getobs
 using NNlib, NNlibCUDA
 using NNlib: scatter, gather
 using ChainRulesCore
-import LightGraphs
-using LightGraphs: AbstractGraph, outneighbors, inneighbors, adjacency_matrix, degree
+import Graphs
+using Graphs: AbstractGraph, outneighbors, inneighbors, adjacency_matrix, degree
 
 export
     # gnngraph
@@ -26,7 +26,7 @@ export
     add_self_loops, remove_self_loops,
     getgraph,
 
-    # from LightGraphs
+    # from Graphs
     adjacency_matrix, 
     # from SparseArrays
     sprand, sparse, blockdiag,
diff --git a/src/gnngraph.jl b/src/gnngraph.jl
@@ -1,8 +1,8 @@
 #===================================
-Define GNNGraph type as a subtype of LightGraphs' AbstractGraph.
+Define GNNGraph type as a subtype of Graphs' AbstractGraph.
 For the core methods to be implemented by any AbstractGraph, see
-https://juliagraphs.org/LightGraphs.jl/latest/types/#AbstractGraph-Type
-https://juliagraphs.org/LightGraphs.jl/latest/developing/#Developing-Alternate-Graph-Types
+https://juliagraphs.org/Graphs.jl/latest/types/#AbstractGraph-Type
+https://juliagraphs.org/Graphs.jl/latest/developing/#Developing-Alternate-Graph-Types
 =============================================#
 
 const COO_T = Tuple{T, T, V} where {T <: AbstractVector, V}
@@ -31,16 +31,16 @@ A `GNNGraph` can also represent multiple graphs batched togheter
 The field `g.graph_indicator` contains the graph membership
 of each node.
 
-A `GNNGraph` is a LightGraphs' `AbstractGraph`, therefore any functionality
-from the LightGraphs' graph library can be used on it.
+A `GNNGraph` is a Graphs' `AbstractGraph`, therefore any functionality
+from the Graphs' graph library can be used on it.
 
 # Arguments 
 
 - `data`: Some data representing the graph topology. Possible type are 
     - An adjacency matrix
     - An adjacency list.
     - A tuple containing the source and target vectors (COO representation)
-    - A LightGraphs' graph.
+    - A Graphs' graph.
 - `graph_type`: A keyword argument that specifies 
                 the underlying representation used by the GNNGraph. 
                 Currently supported values are 
@@ -77,7 +77,7 @@ s = [1,1,2,2,2,3,4,4,5,5]
 t = [2,3,1,4,5,3,2,5,2,4]
 g = GNNGraph(s, t)
 
-# From a LightGraphs' graph
+# From a Graphs' graph
 g = GNNGraph(erdos_renyi(100, 20))
 
 # Add 2 node feature arrays
@@ -150,13 +150,13 @@ GNNGraph((s, t)::NTuple{2}; kws...) = GNNGraph((s, t, nothing); kws...)
 # GNNGraph(g::AbstractGraph; kws...) = GNNGraph(adjacency_matrix(g, dir=:out); kws...)
 
 function GNNGraph(g::AbstractGraph; kws...)
-    s = LightGraphs.src.(LightGraphs.edges(g))
-    t = LightGraphs.dst.(LightGraphs.edges(g))
-    if !LightGraphs.is_directed(g) 
+    s = Graphs.src.(Graphs.edges(g))
+    t = Graphs.dst.(Graphs.edges(g))
+    if !Graphs.is_directed(g) 
         # add reverse edges since GNNGraph are directed
         s, t = [s; t], [t; s]    
     end
-    GNNGraph((s, t); num_nodes=LightGraphs.nv(g), kws...)
+    GNNGraph((s, t); num_nodes=Graphs.nv(g), kws...)
 end
 
 
@@ -222,44 +222,44 @@ edge_weight(g::GNNGraph{<:COO_T}) = g.graph[3]
 
 edge_weight(g::GNNGraph{<:ADJMAT_T}) = to_coo(g.graph, num_nodes=g.num_nodes)[1][3]
 
-LightGraphs.edges(g::GNNGraph) = zip(edge_index(g)...)
+Graphs.edges(g::GNNGraph) = zip(edge_index(g)...)
 
-LightGraphs.edgetype(g::GNNGraph) = Tuple{Int, Int}
+Graphs.edgetype(g::GNNGraph) = Tuple{Int, Int}
 
-function LightGraphs.has_edge(g::GNNGraph{<:COO_T}, i::Integer, j::Integer)
+function Graphs.has_edge(g::GNNGraph{<:COO_T}, i::Integer, j::Integer)
     s, t = edge_index(g)
     return any((s .== i) .& (t .== j))
 end
 
-LightGraphs.has_edge(g::GNNGraph{<:ADJMAT_T}, i::Integer, j::Integer) = g.graph[i,j] != 0
+Graphs.has_edge(g::GNNGraph{<:ADJMAT_T}, i::Integer, j::Integer) = g.graph[i,j] != 0
 
-LightGraphs.nv(g::GNNGraph) = g.num_nodes
-LightGraphs.ne(g::GNNGraph) = g.num_edges
-LightGraphs.has_vertex(g::GNNGraph, i::Int) = 1 <= i <= g.num_nodes
-LightGraphs.vertices(g::GNNGraph) = 1:g.num_nodes
+Graphs.nv(g::GNNGraph) = g.num_nodes
+Graphs.ne(g::GNNGraph) = g.num_edges
+Graphs.has_vertex(g::GNNGraph, i::Int) = 1 <= i <= g.num_nodes
+Graphs.vertices(g::GNNGraph) = 1:g.num_nodes
 
-function LightGraphs.outneighbors(g::GNNGraph{<:COO_T}, i::Integer)
+function Graphs.outneighbors(g::GNNGraph{<:COO_T}, i::Integer)
     s, t = edge_index(g)
     return t[s .== i]
 end
 
-function LightGraphs.outneighbors(g::GNNGraph{<:ADJMAT_T}, i::Integer)
+function Graphs.outneighbors(g::GNNGraph{<:ADJMAT_T}, i::Integer)
     A = g.graph
     return findall(!=(0), A[i,:])
 end
 
-function LightGraphs.inneighbors(g::GNNGraph{<:COO_T}, i::Integer)
+function Graphs.inneighbors(g::GNNGraph{<:COO_T}, i::Integer)
     s, t = edge_index(g)
     return s[t .== i]
 end
 
-function LightGraphs.inneighbors(g::GNNGraph{<:ADJMAT_T}, i::Integer)
+function Graphs.inneighbors(g::GNNGraph{<:ADJMAT_T}, i::Integer)
     A = g.graph
     return findall(!=(0), A[:,i])
 end
 
-LightGraphs.is_directed(::GNNGraph) = true
-LightGraphs.is_directed(::Type{GNNGraph}) = true
+Graphs.is_directed(::GNNGraph) = true
+Graphs.is_directed(::Type{<:GNNGraph}) = true
 
 """
     adjacency_list(g; dir=:out)
@@ -278,7 +278,7 @@ function adjacency_list(g::GNNGraph; dir=:out)
     return [fneighs(g, i) for i in 1:g.num_nodes]
 end
 
-function LightGraphs.adjacency_matrix(g::GNNGraph{<:COO_T}, T::DataType=Int; dir=:out)
+function Graphs.adjacency_matrix(g::GNNGraph{<:COO_T}, T::DataType=Int; dir=:out)
     if g.graph[1] isa CuVector
         # TODO revisi after https://github.com/JuliaGPU/CUDA.jl/pull/1152
         A, n, m = to_dense(g.graph, T, num_nodes=g.num_nodes)
@@ -289,14 +289,14 @@ function LightGraphs.adjacency_matrix(g::GNNGraph{<:COO_T}, T::DataType=Int; dir
     return dir == :out ? A : A'
 end
 
-function LightGraphs.adjacency_matrix(g::GNNGraph{<:ADJMAT_T}, T::DataType=eltype(g.graph); dir=:out)
+function Graphs.adjacency_matrix(g::GNNGraph{<:ADJMAT_T}, T::DataType=eltype(g.graph); dir=:out)
     @assert dir ∈ [:in, :out]
     A = g.graph
     A = T != eltype(A) ? T.(A) : A
     return dir == :out ? A : A'
 end
 
-function LightGraphs.degree(g::GNNGraph{<:COO_T}, T=nothing; dir=:out)
+function Graphs.degree(g::GNNGraph{<:COO_T}, T=nothing; dir=:out)
     s, t = edge_index(g)
     T = isnothing(T) ? eltype(s) : T
     degs = fill!(similar(s, T, g.num_nodes), 0)
@@ -310,13 +310,13 @@ function LightGraphs.degree(g::GNNGraph{<:COO_T}, T=nothing; dir=:out)
     return degs 
 end
 
-function LightGraphs.degree(g::GNNGraph{<:ADJMAT_T}, T=Int; dir=:out)
+function Graphs.degree(g::GNNGraph{<:ADJMAT_T}, T=Int; dir=:out)
     @assert dir ∈ (:in, :out)
     A = adjacency_matrix(g, T)
     return dir == :out ? vec(sum(A, dims=2)) : vec(sum(A, dims=1))
 end
 
-function LightGraphs.laplacian_matrix(g::GNNGraph, T::DataType=Int; dir::Symbol=:out)
+function Graphs.laplacian_matrix(g::GNNGraph, T::DataType=Int; dir::Symbol=:out)
     A = adjacency_matrix(g, T; dir=dir)
     D = Diagonal(vec(sum(A; dims=2)))
     return D - A
diff --git a/src/layers/pool.jl b/src/layers/pool.jl
@@ -18,7 +18,7 @@ See also [`reduce_nodes`](@ref).
 
 # Examples
 ```julia
-using Flux, GraphNeuralNetworks, LightGraphs
+using Flux, GraphNeuralNetworks, Graphs
 
 pool = GlobalPool(mean)
 
diff --git a/test/examples/node_classification_cora.jl b/test/examples/node_classification_cora.jl
@@ -10,7 +10,7 @@ CUDA.allowscalar(false)
 function eval_loss_accuracy(X, y, ids, model, g)
     ŷ = model(g, X)
     l = logitcrossentropy(ŷ[:,ids], y[:,ids])
-    acc = mean(onecold(ŷ[:,ids] |> cpu) .== onecold(y[:,ids] |> cpu))
+    acc = mean(onecold(ŷ[:,ids]) .== onecold(y[:,ids]))
     return (loss = round(l, digits=4), acc = round(acc*100, digits=2))
 end
 
diff --git a/test/gnngraph.jl b/test/gnngraph.jl
diff --git a/test/layers/pool.jl b/test/layers/pool.jl
diff --git a/test/runtests.jl b/test/runtests.jl
diff --git a/test/test_utils.jl b/test/test_utils.jl
