Get ready for release of 0.1.0 (#145)

* Correct `encode` method for `NamedTuple`

* Implement `blocklossfn(block)` fallback method

* minor cleanup of plot code

* implement `Block` interface for `WrapperBlock`

* remove `collectobs` stub

* make `ProjectiveTransforms` work with `WrapperBlock`s

* fix `wd` option in `fitonecycle!`

* remove outdated docstring

* update doc serve sript

* fix `plotprediction!` for segmentation

* amend

* add Colab instructions to "Setup" page

* Update `fitonecycle` notebook

Author: lorenzoh

docs/serve.jl

@@ -7,9 +7,9 @@ import DataAugmentation
 using FilePathsBase
 using Colors
 
-function serve(lazy=true)
+function serve(lazy=true; kwargs...)
     refmodules = [FastAI, FluxTraining, DLPipelines, DataAugmentation, DataLoaders, FastAI.Datasets]
-    project = Pollen.documentationproject(FastAI; refmodules, watchpackage=true)
+    project = Pollen.documentationproject(FastAI; refmodules, watchpackage=true, kwargs...)
     Pollen.serve(project, lazy=lazy)
 end
 serve()

docs/setup.md

@@ -1,8 +1,6 @@
 # Setup
 
-FastAI.jl is a **Julia** package. You can download Julia from the [official website](http://localhost:8000/docs/setup.md.html).
-
-**FastAI.jl** is not registered yet, but you can try it out by installing it manually. You should be able to install FastAI.jl using the REPL as follows (The package mode in the REPL can be entered by typing `]`).
+FastAI.jl is a **Julia** package. You can download Julia from the [official website](http://localhost:8000/docs/setup.md.html). You can install FastAI.jl like any other Julia package using the REPL as follows (The package mode in the REPL can be entered by typing `]`).
 
 ```julia
 pkg> add https://github.com/FluxML/FastAI.jl
@@ -14,6 +12,8 @@ pkg> add https://github.com/FluxML/FastAI.jl
 pkg> add CairoMakie
 ```
 
+**Colab** If you don't have access to a GPU or want to try out FastAI.jl without installing Julia, try out [this FastAI.jl Colab notebook](https://colab.research.google.com/gist/lorenzoh/2fdc91f9e42a15e633861c640c68e5e8). We're working on adding a "Launch Colab" button to every documentation page based off a notebook file, but for now you can copy the code over manually.
+
 **Pretrained models** To use pretrained vision models, you currently have to install a WIP branch of Metalhead.jl:
 
 ```julia

notebooks/Project.toml

@@ -8,6 +8,7 @@ FastAI = "5d0beca9-ade8-49ae-ad0b-a3cf890e669f"
 FilePathsBase = "48062228-2e41-5def-b9a4-89aafe57970f"
 FluxTraining = "7bf95e4d-ca32-48da-9824-f0dc5310474f"
 Images = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
+Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a"
 Metalhead = "dbeba491-748d-5e0e-a39e-b530a07fa0cc"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"

notebooks/fitonecycle.ipynb

@@ -81,11 +81,11 @@ function encode(encoding::Encoding, context, blocks::Tuple, datas::Tuple)
 end
 
 # Named tuples of data are handled like tuples, but the keys are preserved
-function encode(encoding::Encoding, context, blocks::Union{Tuple, NamedTuple}, datas::NamedTuple)
+function encode(encoding::Encoding, context, blocks::NamedTuple, datas::NamedTuple)
     @assert length(blocks) == length(datas)
     return NamedTuple(zip(
         keys(datas),
-        encode(encoding, context, blocks, values(datas))
+        encode(encoding, context, values(blocks), values(datas))
     ))
 end
 
@@ -114,11 +114,11 @@ function decode(encoding::Encoding, context, blocks::Tuple, datas::Tuple)
 end
 
 # Named tuples of data are handled like tuples, but the keys are preserved
-function decode(encoding::Encoding, context, blocks::Union{Tuple, NamedTuple}, datas::NamedTuple)
+function decode(encoding::Encoding, context, blocks::NamedTuple, datas::NamedTuple)
     @assert length(blocks) == length(datas)
     return NamedTuple(zip(
         keys(datas),
-        decode(encoding, context, blocks, values(datas))
+        decode(encoding, context, values(blocks), values(datas))
     ))
 end
 

src/datablock/encoding.jl

@@ -11,7 +11,7 @@ For example for `block = OneHotTensor{1}(classes)` (i.e. an encoded
 function blocklossfn end
 
 
-blocklossfn(predblock) = blocklossfn(predblock, targetblock)
+blocklossfn(predblock) = blocklossfn(predblock, predblock)
 
 function blocklossfn(outblock::OneHotTensor{0}, yblock::OneHotTensor{0})
     outblock.classes == yblock.classes || error("Classes of $outblock and $yblock differ!")

src/datablock/loss.jl

@@ -68,11 +68,15 @@ function plotsample!(f, ctxs::Tuple{NDContext{2}, NDOverlayContext{2}}, blocks,
     plotblock!(ax, blocks[1], datas[1], alpha = 0.6)  # plots an N-D image
 end
 
-function plotsample!(f, ctxs::Tuple{NDContext{2}, NDContext{2}}, blocks, datas)
-    f[1, 1] = ax1 = imageaxis(f)
-    plotblock!(ax1, blocks[1], datas[1])  # plots an image
-    f[1, 2] = ax2 = imageaxis(f)
-    plotblock!(ax, blocks[2], datas[2])  # plots an image
+function plotsample!(
+        f,
+        ctxs::NTuple{N, NDContext{2}},
+        blocks::NTuple{N},
+        datas::NTuple{N}) where N
+    for i in 1:N
+        f[1, i] = ax = imageaxis(f)
+        plotblock!(ax, blocks[i], datas[i])  # plots an image
+    end
 end
 
 function plotsample!(
@@ -102,13 +106,14 @@ function plotprediction!(f, method::BlockMethod, x, ŷ, y)
     ŷblock = method.outputblock
     blocks = (xblock, ŷblock, yblock)
     input, target_pred, target = decode(method.encodings, Validation(), blocks, (x, ŷ, y))
-    inblocks = decodedblock(method.encodings, blocks)
+    inblocks = decodedblock(method.encodings, blocks, true)
     contexts = plotcontext(inblocks)
     plotprediction!(f, contexts, inblocks, (input, target_pred, target))
 end
 
 function plotprediction!(
-        f, ::Tuple{NDContext{2}, TextContext, TextContext},
+        f,
+        ::Tuple{NDContext{2}, TextContext, TextContext},
         blocks,
         datas)
 

src/datablock/plot.jl

@@ -1,5 +1,8 @@
 abstract type WrapperBlock <: Block end
 
+wrapped(w::WrapperBlock) = w.block
+mockblock(w::WrapperBlock) = mockblock(wrapped(w))
+checkblock(w::WrapperBlock, data) = checkblock(wrapped(w), data)
 
 # If not overwritten, encodings are applied to the wrapped block
 function encode(enc::Encoding, ctx, wrapper::WrapperBlock, data; kwargs...)
@@ -21,17 +24,15 @@ struct Named{Name, B<:Block} <: WrapperBlock
 end
 Named(name::Symbol, block::B) where {B<:Block} = Named{name, B}(block)
 
-mockblock(named::Named) = mockblock(named.block)
-checkblock(named::Named, data) = checkblock(named.block, data)
 
 # the name is preserved through encodings and decodings
 function encodedblock(enc::Encoding, named::Named{Name}) where Name
-    outblock = encodedblock(enc, named.block)
+    outblock = encodedblock(enc, wrapped(named))
     return isnothing(outblock) ? nothing : Named(Name, outblock)
 end
 
 function decodedblock(enc::Encoding, named::Named{Name}) where Name
-    outblock = decodedblock(enc, named.block)
+    outblock = decodedblock(enc, wrapped(named))
     return isnothing(outblock) ? nothing : Named(Name, outblock)
 end
 

src/datablock/wrappers.jl

@@ -157,8 +157,3 @@ getobs(jdata, 15) == 15
 ```
 """
 joinobs(datas...) = JoinedData(datas)
-
-
-function collectobs(data, parallel=false)
-    collect()
-end

src/datasets/transformations.jl

@@ -135,6 +135,7 @@ function blockitemtype(block::Mask{N}, n::Int) where N
     end
 end
 blockitemtype(block::Keypoints{N}, n::Int) where N = N == n ? DataAugmentation.Keypoints : nothing
+blockitemtype(block::WrapperBlock, n::Int) = blockitemtype(wrapped(block), n)
 
 
 """
@@ -152,6 +153,7 @@ end
 
 grabbounds(block::Image{N}, a, n) where N = N == n ? DataAugmentation.Bounds(size(a)) : nothing
 grabbounds(block::Mask{N}, a, n) where N = N == n ? DataAugmentation.Bounds(size(a)) : nothing
+grabbounds(block::WrapperBlock, a, n) = grabbounds(wrapped(block), a, n)
 
 
 function getsamplebounds(blocks, datas, N)