New interpretation/Visualization API (#176)

* Switch to InlineTest for new test cases

* Add abstract types and interface

* Add text backend

* Document `showblocks`

* Change `plotimage` defaults

* Add `ShowMakie` backend

* Add missing method for `showblocks!(::ShowText, ...)`

* Add detection for default `ShowBackend`

* Add `showblockintepretable`

* fix `setup` docstring being overwritten

* Fix column detection for Tabular data

* Fix `ShowText` `io` argument

* Clean up `Label*` blocks

* add learning method show helpers

* fix makie nested block alingment and keypoints

* add WrapperBlock default visualization

* add error message to showinterpretable

* Add `Bounded` wrapper block

* Add makie bacend tests

* Fill in training interface for `Wrapped`

* remove old plotting code

* Add showoutputs for learner

* move wrapper showblock! implementation

* make Makie dep optional

* Add text-based visualization for LR finder

* Fix method registry search

* update docs

* update Changelog

Author: lorenzoh

CHANGELOG.md

@@ -5,6 +5,22 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+
+### Added
+
+- A new API for visualizing data. See [this issue](https://github.com/FluxML/FastAI.jl/issues/154) for motivation. This includes:
+
+    - High-level functions for visualizing data related to a learning method: `showsample`,  `showsamples`, `showencodedsample`, `showencodedsamples`, `showbatch`, `showprediction`, `showpredictions`, `showoutput`, `showoutputs`, `showoutputbatch`
+    - Support for multiple backends, including a new text-based show backend that you can use to visualize data in a non-graphical environment. This is also the default unless `Makie` is imported.
+    - Functions for showing blocks directly: `showblock`, `showblocks`
+    - Interfaces for extension: `ShowBackend`, `showblock!`, `showblocks!`
+
+### Removed
+
+- The old visualization API incl. all its `plot*` methods: `plotbatch`, `plotsample`, `plotsamples`, `plotpredictions`
+
+
 ## 0.2.0
 
 ### Added

Project.toml

@@ -19,22 +19,25 @@ FixedPointNumbers = "53c48c17-4a7d-5ca2-90c5-79b7896eea93"
 Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"
 FluxTraining = "7bf95e4d-ca32-48da-9824-f0dc5310474f"
 Glob = "c27321d9-0574-5035-807b-f59d2c89b15c"
+ImageInTerminal = "d8c32880-2388-543b-8c61-d9f865259254"
 IndirectArrays = "9b13fd28-a010-5f03-acff-a1bbcff69959"
+InlineTest = "bd334432-b1e7-49c7-a2dc-dd9149e4ebd6"
 JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819"
 LearnBase = "7f8f8fb0-2700-5f03-b4bd-41f8cfc144b6"
 MLDataPattern = "9920b226-0b2a-5f5f-9153-9aa70a013f8b"
-Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a"
 Markdown = "d6f4376e-aef5-505a-96c1-9c027394607a"
 MosaicViews = "e94cdb99-869f-56ef-bcf0-1ae2bcbe0389"
 Parameters = "d96e819e-fc66-5662-9728-84c9c7592b0a"
 PrettyTables = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
+Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 Setfield = "efcf1570-3423-57d1-acb7-fd33fddbac46"
 ShowCases = "605ecd9f-84a6-4c9e-81e2-4798472b76a3"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
 Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 
 [compat]
@@ -57,10 +60,9 @@ IndirectArrays = "0.5, 1"
 JLD2 = "0.4"
 LearnBase = "0.3, 0.4"
 MLDataPattern = "0.5"
-Makie = "0.15"
 MosaicViews = "0.2, 0.3"
 Parameters = "0.12"
-PrettyTables = "1"
+PrettyTables = "1.2"
 Reexport = "1.0"
 Setfield = "0.7, 0.8"
 ShowCases = "0.1"

README.md

@@ -22,7 +22,7 @@ data, blocks = loaddataset("imagenette2-160", (Image, Label))
 method = ImageClassificationSingle(blocks)
 learner = methodlearner(method, data, callbacks=[ToGPU()])
 fitonecycle!(learner, 10)
-plotpredictions(method, learner)
+showoutputs(method, learner)
 ```
 
 Please read [the documentation](https://fluxml.github.io/FastAI.jl/dev) for more information and see the [setup instructions](docs/setup.md).

docs/howto/augmentvision.md

@@ -4,27 +4,22 @@ Data augmentation is important to train models with good generalization ability,
 
 By default, the only augmentation that will be used in computer vision tasks is a random crop, meaning that after images, keypoints and masks are resized to a similar size a random portion will be cropped during training. We can demonstrate this on the image classification task.
 
-{cell=main result=false output=false}
+{cell=main output=false}
 ```julia
 using FastAI
 import CairoMakie; CairoMakie.activate!(type="png")
 
-path = datasetpath("imagenette2-160")
-data = Datasets.loadfolderdata(
-    path,
-    filterfn=isimagefile,
-    loadfn=(loadfile, parentname))
-classes = unique(eachobs(data[2]))
+data, blocks = loaddataset("imagenette2-160", (Image, Label))
 method = BlockMethod(
-    (Image{2}(), Label(classes)),
+    blocks,
     (
         ProjectiveTransforms((128, 128)),
         ImagePreprocessing(),
         OneHot()
     )
 )
-xs, ys = FastAI.makebatch(method, data, fill(4, 9))
-FastAI.plotbatch(method, xs, ys)
+xs, ys = FastAI.makebatch(method, data, fill(4, 3))
+showbatch(method, (xs, ys))     
 ```
 
 
@@ -33,15 +28,15 @@ Most learning methods let you pass additional augmentations as keyword arguments
 {cell=main}
 ```julia
 method2 = BlockMethod(
-    (Image{2}(), Label(classes)),
+    blocks,
     (
         ProjectiveTransforms((128, 128), augmentations=augs_projection()),
         ImagePreprocessing(),
         OneHot()
     )
 )
-xs2, ys2 = FastAI.makebatch(method2, data, fill(4, 9))
-f = FastAI.plotbatch(method2, xs2, ys2)
+xs2, ys2 = FastAI.makebatch(method2, data, fill(4, 3))
+showbatch(method2, (xs2, ys2))
 ```
 
 
@@ -50,13 +45,13 @@ Likewise, there is an [`augs_lighting`](#) helper that adds contrast and brightn
 {cell=main}
 ```julia
 method3 = BlockMethod(
-    (Image{2}(), Label(classes)),
+    blocks,
     (
         ProjectiveTransforms((128, 128), augmentations=augs_projection()),
         ImagePreprocessing(augmentations=augs_lighting()),
         OneHot()
     )
 )
-xs3, ys3 = FastAI.makebatch(method3, data, fill(4, 9))
-FastAI.plotbatch(method3, xs3, ys3)
+xs3, ys3 = FastAI.makebatch(method3, data, fill(4, 3))
+showbatch(method3, (xs3, ys3))
 ```

docs/introduction.md

@@ -15,7 +15,7 @@ data, blocks = loaddataset("imagenette2-160", (Image, Label))
 method = ImageClassificationSingle(blocks)
 learner = methodlearner(method, data, callbacks=[ToGPU()])
 fitonecycle!(learner, 10)
-plotpredictions(method, learner)
+showoutputs(method, learner)
 ```
 
 Each of the five lines encapsulates one part of the deep learning pipeline to give a high-level API while still allowing customization. Let's have a closer look. 
@@ -111,7 +111,7 @@ Training now is quite simple. You have several options for high-level training s
 ## Visualization
 
 ```julia
-plotpredictions(method, learner)
+showoutputs(method, learner)
 ```
 
 Finally, the last line visualizes the predictions of the trained model. It takes some samples from the training data loader, runs them through the model and decodes the outputs. How each piece of data is visualized is also inferred through the blocks in the learning method.

docs/make.jl

@@ -1,4 +1,4 @@
-using CairoMakie
+import CairoMakie
 using Pollen
 using FastAI
 using FluxTraining

docs/serve.jl

@@ -1,4 +1,4 @@
-using CairoMakie
+import CairoMakie
 using Pollen
 using FastAI
 using FluxTraining

docs/setup.md

@@ -7,20 +7,19 @@ using Pkg
 Pkg.add("FastAI")
 ```
 
-**Plotting** FastAI.jl also defines [Makie.jl](https://github.com/JuliaPlots/Makie.jl) plotting recipes to visualize data. If you want to use them, you'll have to install and one of the Makie.jl backends [CairoMakie.jl](https://github.com/JuliaPlots/CairoMakie.jl), [GLMakie.jl](https://github.com/JuliaPlots/GLMakie.jl) or [WGLMakie.jl](https://github.com/JuliaPlots/WGLMakie.jl). For example:
+**Visualization** Aside from text-based visualizations, FastAI.jl also defines [Makie.jl](https://github.com/JuliaPlots/Makie.jl) plotting recipes to visualize data. If you want to use them, you'll have to install and one of the Makie.jl backends [CairoMakie.jl](https://github.com/JuliaPlots/CairoMakie.jl), [GLMakie.jl](https://github.com/JuliaPlots/GLMakie.jl) or [WGLMakie.jl](https://github.com/JuliaPlots/WGLMakie.jl) and load the package.
 
 ```julia
+# Install backend package once
 using Pkg
 Pkg.add("CairoMakie")
+
+# Then load it therafter
+import CairoMakie
+using FastAI
 ```
 
 **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
-using Pkg
-Pkg.add(Pkg.PackageSpec(url="https://github.com/darsnack/Metalhead.jl", rev="darsnack/vision-refactor")
-```
 
 **Threaded data loading** To make use of multi-threaded data loading, you need to start Julia with multiple threads, either with the `-t auto` commandline flag or by setting the environment variable `JULIA_NUM_THREADS`. See the [IJulia.jl documentation](https://julialang.github.io/IJulia.jl/dev/manual/installation/#Installing-additional-Julia-kernels) for instructions on setting these for Jupyter notebook kernels.