Merge pull request #31 from CarloLucibello/cl/dev

small doc fixes

Author: CarloLucibello

README.md

@@ -15,10 +15,15 @@ Its most relevant features are:
 
 ## Installation
 
+GraphNeuralNetworks.jl is a registered julia package. 
+You can easily install it through the package manager:
+
 ```julia
-]add GraphNeuralNetworks
+julia> ]
+
+pkg> add GraphNeuralNetworks
 ```
 
 ## Usage
 
-Usage examples can be found in the [examples](https://github.com/CarloLucibello/GraphNeuralNetworks.jl/tree/master/examples) folder. 
+Usage examples can be found in the [examples](https://github.com/CarloLucibello/GraphNeuralNetworks.jl/tree/master/examples) folder. Also, make sure to read the [documentation](https://CarloLucibello.github.io/GraphNeuralNetworks.jl/dev) for a comprehensive introduction to the library.

docs/src/index.md

@@ -23,7 +23,7 @@ Usage examples on real datasets can be found in the [examples](https://github.co
 First, we create our dataset consisting in multiple random graphs and associated data features. 
 that we batch together into a unique graph.
 
-```juliarepl
+```julia
 julia> using GraphNeuralNetworks, LightGraphs, Flux, CUDA, Statistics
 
 julia> all_graphs = GNNGraph[];
@@ -51,9 +51,9 @@ GNNGraph:
 ### Model building 
 
 We concisely define our model using as a [`GNNChain`](@ref) containing 2 graph convolutaional 
-layers. If CUDA is available, our model will leave on the gpu.
+layers. If CUDA is available, our model will live on the gpu.
 
-```juliarepl
+```julia
 julia> device = CUDA.functional() ? Flux.gpu : Flux.cpu;
 
 julia> model = GNNChain(GCNConv(16 => 64),
@@ -70,15 +70,17 @@ julia> opt = ADAM(1f-4);
 
 ### Training 
 
-```juliarepl
+Finally, we use a standard Flux training pipeling to fit our dataset.
+Flux's DataLoader iterates over mini-batches of graphs 
+(batched together into a `GNNGraph` object). 
+
+```julia
 gtrain, _ = getgraph(gbatch, 1:800)
 gtest, _ = getgraph(gbatch, 801:gbatch.num_graphs)
 train_loader = Flux.Data.DataLoader(gtrain, batchsize=32, shuffle=true)
 test_loader = Flux.Data.DataLoader(gtest, batchsize=32, shuffle=false)
 
-function loss(g::GNNGraph)
-    mean((vec(model(g, g.ndata.x)) - g.gdata.y).^2)
-end
+loss(g::GNNGraph) = mean((vec(model(g, g.ndata.x)) - g.gdata.y).^2)
 
 loss(loader) = mean(loss(g |> device) for g in loader)
 

docs/src/messagepassing.md

@@ -22,12 +22,11 @@ respectively.
 
 Let's (re-)implement the [`GCNConv`](@ref) layer use the message passing framework.
 The convolution reads 
-```math
 
 ```math
-\mathbf{x}'_i = \sum_{j \in {i} \cup N(i)} \frac{1}{c_{ij}} W \mathbf{x}_j
+\mathbf{x}'_i = \sum_{j \in N(i)} \frac{1}{c_{ij}} W \mathbf{x}_j
 ```
-where ``c_{ij} = \sqrt{(1+|N(i)|)(1+|N(j)|)}``. We will also add a bias and an activation function.
+where ``c_{ij} = \sqrt{(|N(i)|)(|N(j)|)}``. We will also add a bias and an activation function.
 
 ```julia
 using Flux, LightGraphs, GraphNeuralNetworks
@@ -52,7 +51,6 @@ compute_message(l::GCN, xi, xj, eij) = l.weight * xj
 update_node(l::GCN, m, x) = m
 
 function (l::GCN)(g::GNNGraph, x::AbstractMatrix{T}) where T
-    g = add_self_loops(g)
     c = 1 ./ sqrt.(degree(g, T, dir=:in))
     x = x .* c'
     x, _ = propagate(l, g, +, x)
@@ -61,4 +59,6 @@ function (l::GCN)(g::GNNGraph, x::AbstractMatrix{T}) where T
 end
 ```
 
+See the [`GATConv`](@ref) implementation [here](https://github.com/CarloLucibello/GraphNeuralNetworks.jl/blob/master/src/layers/conv.jl) for a more complex example.
+