Fixed a few typos in notebooks, docs and docstrings (#205)

Author: pitmonticone

docs/src/gnngraph.md

@@ -117,7 +117,7 @@ g.edata.e
 ## Edge weights
 
 It is common to denote scalar edge features as edge weights. The `GNNGraph` has specific support
-for edge weights: they can be stored as part of internal representions of the graph (COO or adjacency matrix). Some graph convolutional layers, most notably the [`GCNConv`](@ref), can use the edge weights to perform weighted sums over the nodes' neighborhoods.
+for edge weights: they can be stored as part of internal representations of the graph (COO or adjacency matrix). Some graph convolutional layers, most notably the [`GCNConv`](@ref), can use the edge weights to perform weighted sums over the nodes' neighborhoods.
 
 ```julia
 julia> source = [1, 1, 2, 2, 3, 3];
@@ -143,7 +143,7 @@ julia> get_edge_weight(g)
 
 ## Batches and Subgraphs
 
-Multiple `GNNGraph`s can be batched togheter into a single graph
+Multiple `GNNGraph`s can be batched together into a single graph
 that contains the total number of the original nodes 
 and where the original graphs are disjoint subgraphs.
 

docs/src/messagepassing.md

@@ -25,7 +25,7 @@ manipulating arrays of size ``D_{node} \times num\_nodes`` and
 
 [`propagate`](@ref) is composed of two steps, also available as two independent methods:
 
-1. [`apply_edges`](@ref) materializes node features on edges and applyes the message function. 
+1. [`apply_edges`](@ref) materializes node features on edges and applies the message function. 
 2. [`aggregate_neighbors`](@ref) applies a reduction operator on the messages coming from the neighborhood of each node.
 
 The whole propagation mechanism internally relies on the [`NNlib.gather`](@ref) 

docs/src/tutorials/gnn_intro_pluto.jl

@@ -40,7 +40,7 @@ end;
 md"""
 # Introduction: Hands-on Graph Neural Networks
 
-*This Pluto noteboook is a julia adaptation of the Pytorch Geometric tutorials that can be found [here](https://pytorch-geometric.readthedocs.io/en/latest/notes/colabs.html).*
+*This Pluto notebook is a julia adaptation of the Pytorch Geometric tutorials that can be found [here](https://pytorch-geometric.readthedocs.io/en/latest/notes/colabs.html).*
 
 Recently, deep learning on graphs has emerged to one of the hottest research fields in the deep learning community.
 Here, **Graph Neural Networks (GNNs)** aim to generalize classical deep learning concepts to irregular structured data (in contrast to images or texts) and to enable neural networks to reason about objects and their relations.
@@ -135,7 +135,7 @@ The  `g` object holds 3 attributes:
 These attributes are `NamedTuples` that can store multiple feature arrays: we can access a specific set of features e.g. `x`, with `g.ndata.x`.
 
 
-In our task, `g.ndata.train_mask` describes for which nodes we already know their community assigments. In total, we are only aware of the ground-truth labels of 4 nodes (one for each community), and the task is to infer the community assignment for the remaining nodes.
+In our task, `g.ndata.train_mask` describes for which nodes we already know their community assignments. In total, we are only aware of the ground-truth labels of 4 nodes (one for each community), and the task is to infer the community assignment for the remaining nodes.
 
 The `g` object also provides some **utility functions** to infer some basic properties of the underlying graph.
 For example, we can easily infer whether there exists isolated nodes in the graph (*i.e.* there exists no edge to any node), whether the graph contains self-loops (*i.e.*, ``(v, v) \in \mathcal{E}``), or whether the graph is bidirected (*i.e.*, for each edge ``(v, w) \in \mathcal{E}`` there also exists the edge ``(w, v) \in \mathcal{E}``).
@@ -262,13 +262,13 @@ This leads to the conclusion that GNNs introduce a strong inductive bias, leadin
 
 But can we do better? Let's look at an example on how to train our network parameters based on the knowledge of the community assignments of 4 nodes in the graph (one for each community):
 
-Since everything in our model is differentiable and parameterized, we can add some labels, train the model and observse how the embeddings react.
+Since everything in our model is differentiable and parameterized, we can add some labels, train the model and observe how the embeddings react.
 Here, we make use of a semi-supervised or transductive learning procedure: We simply train against one node per class, but are allowed to make use of the complete input graph data.
 
 Training our model is very similar to any other Flux model.
 In addition to defining our network architecture, we define a loss criterion (here, `logitcrossentropy` and initialize a stochastic gradient optimizer (here, `Adam`).
 After that, we perform multiple rounds of optimization, where each round consists of a forward and backward pass to compute the gradients of our model parameters w.r.t. to the loss derived from the forward pass.
-If you are not new to Flux, this scheme should appear familar to you. 
+If you are not new to Flux, this scheme should appear familiar to you. 
 
 Note that our semi-supervised learning scenario is achieved by the following line:
 ```
@@ -277,7 +277,7 @@ loss = logitcrossentropy(ŷ[:,train_mask], y[:,train_mask])
 While we compute node embeddings for all of our nodes, we **only make use of the training nodes for computing the loss**.
 Here, this is implemented by filtering the output of the classifier `out` and ground-truth labels `data.y` to only contain the nodes in the `train_mask`.
 
-Let us now start training and see how our node embeddings evolve over time (best experienced by explicitely running the code):
+Let us now start training and see how our node embeddings evolve over time (best experienced by explicitly running the code):
 """
 
 

docs/src/tutorials/graph_classification_pluto.jl

@@ -40,10 +40,10 @@ end;
 md"""
 # Graph Classification with Graph Neural Networks
 
-*This Pluto noteboook is a julia adaptation of the Pytorch Geometric tutorials that can be found [here](https://pytorch-geometric.readthedocs.io/en/latest/notes/colabs.html).*
+*This Pluto notebook is a julia adaptation of the Pytorch Geometric tutorials that can be found [here](https://pytorch-geometric.readthedocs.io/en/latest/notes/colabs.html).*
 
 In this tutorial session we will have a closer look at how to apply **Graph Neural Networks (GNNs) to the task of graph classification**.
-Graph classification refers to the problem of classifiying entire graphs (in contrast to nodes), given a **dataset of graphs**, based on some structural graph properties.
+Graph classification refers to the problem of classifying entire graphs (in contrast to nodes), given a **dataset of graphs**, based on some structural graph properties.
 Here, we want to embed entire graphs, and we want to embed those graphs in such a way so that they are linearly separable given a task at hand.
 
 
@@ -242,7 +242,7 @@ end
 # ╔═╡ 3454b311-9545-411d-b47a-b43724b84c36
 md"""
 As one can see, our model reaches around **74% test accuracy**.
-Reasons for the fluctations in accuracy can be explained by the rather small dataset (only 38 test graphs), and usually disappear once one applies GNNs to larger datasets.
+Reasons for the fluctuations in accuracy can be explained by the rather small dataset (only 38 test graphs), and usually disappear once one applies GNNs to larger datasets.
 
 ## (Optional) Exercise
 

src/mldatasets.jl

@@ -1,4 +1,4 @@
-# We load a Graph Dataset from MLDatasets without explicitely depending on it
+# We load a Graph Dataset from MLDatasets without explicitly depending on it
 
 """
     mldataset2gnngraph(dataset)

src/msgpass.jl

@@ -174,7 +174,7 @@ end
 """
     w_mul_xj(xi, xj, w) = reshape(w, (...)) .* xj
 
-Similar to [`e_mul_xj`](@ref) but specialized on scalar edge feautures (weights).
+Similar to [`e_mul_xj`](@ref) but specialized on scalar edge features (weights).
 """
 w_mul_xj(xi, xj::AbstractArray, w::Nothing) = xj # same as copy_xj if no weights