custom execution

Author: SelimChraibi

Project.toml

@@ -8,11 +8,12 @@ Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"
 DistributedObjects = "00fc1a24-2ccf-42b7-af30-c6381044c15f"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 ProgressMeter = "92933f4c-e287-5a05-a399-4b506db050ca"
+UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
 
 [compat]
-julia = "1"
-ProgressMeter = "1.7.2"
 DistributedObjects = "0.1.5"
+ProgressMeter = "1.7.2"
+julia = "1"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"

README.md

@@ -56,7 +56,7 @@ Now to the implementation.
     mutable struct SGD<:AbstractAlgorithm{Vector{Float64},Vector{Float64}}
         stepsize::Float64
         previous_q::Vector{Float64} # previous query
-        SGD(stepsize::Float64) = new(stepsize, Vector{Float64}())
+        SGD(stepsize::Float64) = new(stepsize, Float64[])
     end
 
     # initialisation step 

docs/make.jl

@@ -1,5 +1,6 @@
 using Documenter
 using AsynchronousIterativeAlgorithms
+const AIA = AsynchronousIterativeAlgorithms
 
 makedocs(
     sitename = "AsynchronousIterativeAlgorithms.jl",

docs/src/documentation.md

@@ -1,15 +1,11 @@
 # Documentation
 
-## `start` and `start!`
+## `start`
 
 ```@docs
 start
 ```
 
-```@docs
-start!
-```
-
 ## `AbstractAlgorithm`
 
 The algorithm you pass to [`start`](@ref) should subtype `AbstractAlgorithm{Q,A}`.
@@ -18,7 +14,33 @@ The algorithm you pass to [`start`](@ref) should subtype `AbstractAlgorithm{Q,A}
 AbstractAlgorithm
 ```
 
-## Algorithm templates
+## Customization of `start`'s execution
+
+```@docs
+stopnow
+```
+
+```@docs
+savenow
+```
+
+```@docs
+savevalues
+```
+
+```@docs
+report
+```
+
+```@docs
+progress
+```
+
+```@docs
+showvalues
+```
+
+## Algorithm wrappers
 
 The two following algorithms already subtype [`AbstractAlgorithm{Q,A}`](@ref) and are ready to use in [`start`](@ref).
 
@@ -28,5 +50,4 @@ AggregationAlgorithm
 
 ```@docs
 AveragingAlgorithm
-
 ```

docs/src/index.md

@@ -21,13 +21,13 @@ julia> ] add AsynchronousIterativeAlgorithms
 Say you want to implement a distributed version of *Stochastic Gradient Descent* (SGD). You'll need to define:
 
 - an **algorithm structure** subtyping [`AbstractAlgorithm{Q,A}`](@ref)
-- the **initialisation step** where you compute the first iteration 
+- the **initialization step** where you compute the first iteration 
 - the **worker step** performed by the workers when they receive a query `q::Q` from the central node
 - the asynchronous **central step** performed by the central node when it receives an answer `a::A` from a `worker`
 
 ![Sequence Diagram](assets/sequence_diagram.png)
 
-Let's first of all set up our distributed environement.
+Let's first of all set up our distributed environment.
 
 ```julia
 # Launch multiple processes (or remote machines)
@@ -49,7 +49,7 @@ Now to the implementation.
     mutable struct SGD<:AbstractAlgorithm{Vector{Float64},Vector{Float64}}
         stepsize::Float64
         previous_q::Vector{Float64} # previous query
-        SGD(stepsize::Float64) = new(stepsize, Vector{Float64}())
+        SGD(stepsize::Float64) = new(stepsize, Float64[])
     end
 
     # initialisation step 
@@ -96,7 +96,7 @@ We're almost ready to start the algorithm...
 
 ```julia
 # Provide the stopping criteria 
-stopat = (1000,0,0.) # (iterations, epochs, time)
+stopat = (iteration=1000, time=42.)
 
 # Instanciate your algorithm 
 sgd = SGD(0.01)