Remove all reference to LearningTask. (#131)

lorenzoh · web-flow · commit 54cf3b2b4f6a · 2021-07-01T13:24:24.000+02:00
diff --git a/.gitignore b/.gitignore
@@ -1,4 +1,4 @@
-**/.ipynb_checkpoints
+**/.ipynb_checkpoints/**
 test/Manifest.toml
 docs/Manifest.toml
 development/**
diff --git a/Project.toml b/Project.toml
@@ -36,7 +36,7 @@ Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 Animations = "0.4"
 BSON = "0.3"
 Colors = "0.12"
-DLPipelines = "0.2.1"
+DLPipelines = "0.3"
 DataAugmentation = "0.2.2"
 DataDeps = "0.7"
 DataLoaders = "0.1"
diff --git a/README.md b/README.md
@@ -9,7 +9,7 @@ As an example, training an image classification model from scratch is as simple
 ```julia
 using FastAI
 path = datasetpath("imagenette2-160")
-data = loadtaskdata(path, ImageClassificationTask)
+data = loadtaskdata(path, ImageClassification)
 method = ImageClassification(Datasets.getclassesclassification("imagenette2-160"), (160, 160))
 learner = methodlearner(method, data, Models.xresnet18(), ToGPU(), Metrics(accuracy))
 fitonecycle!(learner, 5)
diff --git a/docs/api.md b/docs/api.md
@@ -30,7 +30,6 @@ Quickly get started training and finetuning models using already implemented lea
 
 {.tight}
 - [`LearningMethod`](#)
-- [`LearningTask`](#)
 - [`encode`](#)
 - [`encodeinput`](#)
 - `decodey`
diff --git a/docs/background/datapipelines.md b/docs/background/datapipelines.md
@@ -26,7 +26,7 @@ using DataLoaders: batchviewcollated
 using FastAI
 using FastAI.Datasets
 
-data = loadtaskdata(datasetpath("imagenette2-320"), ImageClassificationTask)
+data = loadtaskdata(datasetpath("imagenette2-320"), ImageClasssification)
 method = ImageClassification(Datasets.getclassesclassification("imagenette2-320"), (224, 224))
 
 # maps data processing over `data`
@@ -68,7 +68,7 @@ using FastAI
 using FastAI.Datasets
 using FluxTraining: fitbatchphase!
 
-data = loadtaskdata(datasetpath("imagenette2-320"), ImageClassificationTask)
+data = loadtaskdata(datasetpath("imagenette2-320"), ImageClasssification)
 method = ImageClassification(Datasets.getclassesclassification("imagenette2-320"), (224, 224))
 
 learner = methodlearner(method, data, xresnet18())
@@ -100,7 +100,7 @@ using FastAI.Datasets
 
 # Since loading times can vary per observation, we'll average the measurements over multiple observations
 N = 10
-data = datasubset(shuffleobs(loadtaskdata(datasetpath("imagenette2"), ImageClassificationTask), 1:N))
+data = datasubset(shuffleobs(loadtaskdata(datasetpath("imagenette2"), ImageClasssification), 1:N))
 method = ImageClassification(Datasets.getclassesclassification("imagenette2-320"), (224, 224))
 
 # Time it takes to load an `(image, class)` observation
@@ -132,13 +132,13 @@ If the data loading is still slowing down training, you'll probably have to spee
 For many computer vision tasks, you will resize and crop images to a specific size during training for GPU performance reasons. If the images themselves are large, loading them from disk itself can take some time. If your dataset consists of 1920x1080 resolution images but you're resizing them to 256x256 during training, you're wasting a lot of time loading the large images. *Presizing* means saving resized versions of each image to disk once, and then loading these smaller versions during training. We can see the performance difference using ImageNette since it comes in 3 sizes: original, 360px and 180px.
 
 ```julia
-data_orig = loadtaskdata(datasetpath("imagenette2"), ImageClassificationTask)
+data_orig = loadtaskdata(datasetpath("imagenette2"), ImageClasssification)
 @time eachobsparallel(data_orig, buffered = false)
 
-data_320px = loadtaskdata(datasetpath("imagenette2-320"), ImageClassificationTask)
+data_320px = loadtaskdata(datasetpath("imagenette2-320"), ImageClasssification)
 @time eachobsparallel(data_320px, buffered = false)
 
-data_160px = loadtaskdata(datasetpath("imagenette2-160"), ImageClassificationTask)
+data_160px = loadtaskdata(datasetpath("imagenette2-160"), ImageClasssification)
 @time eachobsparallel(data_160px, buffered = false)
 ```
 
diff --git a/docs/data_containers.md b/docs/data_containers.md
@@ -18,7 +18,7 @@ using FastAI.Datasets: datasetpath, loadtaskdata
 
 NAME = "imagenette2-160"
 dir = datasetpath(NAME)
-data = loadtaskdata(dir, ImageClassificationTask)
+data = loadtaskdata(dir, ImageClasssification)
 ```
 
 A data container is any type that holds observations of data and allows us to load them with `getobs` and query the number of observations with `nobs`:
diff --git a/docs/glossary.md b/docs/glossary.md
@@ -15,7 +15,6 @@ In many docstrings, generic types are abbreviated with the following symbols. Ma
 
 Some examples of these in use:
 
-- `LearningTask` represents the task of learning to predict `T` from `I`.
 - `LearningMethod` is a concrete approach to learning to predict `T` from `I` by using the encoded representations `X` and `Y`.
 - `encodeinput : (method, context, I) -> X` encodes an input so that a prediction can be made by a model.
 - A task dataset is a `DC{(I, T)}`, i.e. a data container where each observation is a 2-tuple of an input and a target.
@@ -32,10 +31,6 @@ An instance of `DLPipelines.LearningMethod`. A concrete approach to solving a le
 
 See the DLPipelines.jl documentation for more information. 
 
-### Learning task
-
-An abstract subtype of `DLPipelines.LearningTask` that represents the problem of learning a mapping from some input type `I` to a target type `T`. For example, `ImageClassificationTask` represents the task of learning to map an image to a class. See [learning method](#learning-method)
-
 ### Task data container / dataset
 
 `DC{(I, T)}`. A data container containing pairs of inputs and targets. Used in [`methoddataset`](#), [`methoddataloaders`](#) and `evaluate`.
diff --git a/docs/howto/augmentvision.md b/docs/howto/augmentvision.md
@@ -10,7 +10,7 @@ using FastAI
 using CairoMakie; CairoMakie.activate!(type="png")
 
 dir = joinpath(datasetpath("dogscats"), "train")
-data = loadtaskdata(dir, ImageClassificationTask)
+data = loadtaskdata(dir, ImageClasssification)
 classes = Datasets.getclassesclassification(dir)
 method = ImageClassification(classes, (100, 128))
 xs, ys = FastAI.makebatch(method, data, fill(4, 9))
diff --git a/docs/howto/logtensorboard.md b/docs/howto/logtensorboard.md
@@ -33,7 +33,7 @@ callbacks = [
     Metrics(accuracy)
 ]
 
-data = Datasets.loadtaskdata(Datasets.datasetpath("imagenette2-160"), ImageClassificationTask)
+data = Datasets.loadtaskdata(Datasets.datasetpath("imagenette2-160"), ImageClasssification)
 method = ImageClassification(Datasets.getclassesclassification("imagenette2-160"), (160, 160))
 learner = methodlearner(method, data, Models.xresnet18(), callbacks...)
 fitonecycle!(learner, 5)
diff --git a/docs/interfaces.md b/docs/interfaces.md
@@ -6,7 +6,7 @@ FastAI.jl provides many interfaces that allow extending its functionality.
 
 Learning methods form the core of FastAI.jl's high-level API. See [this tutorial](learning_methods.md) for a motivation and introduction.
 
-Functions for the learning method interfaces always dispatch on a [`LearningMethod`](#)`{T}` where `T` is an abstract subtype of [`LearningTask`](#). `LearningTask` only constrains what input and target data look like, while `LearningMethod` defines everything that needs to happen to turn an input into a target and much more. `LearningMethod` should be a `struct` containing configuration.
+Functions for the learning method interfaces always dispatch on a [`LearningMethod`](#). A `LearningMethod` defines everything that needs to happen to turn an input into a target and much more. `LearningMethod` should be a `struct` containing configuration.
 
 ### Core interface
 
diff --git a/docs/introduction.md b/docs/introduction.md
@@ -13,7 +13,7 @@ On the [quickstart page](quickstart.ipynb), we showed how to train models on com
 using FastAI
 
 path = datasetpath("imagenette2-160")
-dataset = loadtaskdata(path, ImageClassificationTask)
+dataset = loadtaskdata(path, ImageClasssification)
 method = ImageClassification(Datasets.getclassesclassification("imagenette2-160"), (160, 160))
 dls = methoddataloaders(dataset, method, 16)
 model = methodmodel(method, Models.xresnet18())
@@ -28,7 +28,7 @@ Let's unpack each line.
 {cell=main}
 ```julia
 path = datasetpath("imagenette2-160")
-dataset = loadtaskdata(path, ImageClassificationTask)
+dataset = loadtaskdata(path, ImageClasssification)
 ```
 
 These two lines download and load the [ImageNette](https://github.com/fastai/imagenette) image classification dataset, a small subset of ImageNet with 10 different classes. `dataset` is a [data container](data_containers.md) that can be used to load individual observations, here of images and the corresponding labels. We can use `getobs(dataset, i)` to load the `i`-th observation and `nobs` to find out how many observations there are.
diff --git a/docs/learning_methods.md b/docs/learning_methods.md
@@ -27,7 +27,7 @@ Before we get started, let's load up a [data container](data_containers.md) that
 using FastAI
 using FastAI.Datasets
 DATASET = "imagenette2-160"
-data = Datasets.loadtaskdata(Datasets.datasetpath(DATASET), ImageClassificationTask)
+data = Datasets.loadtaskdata(Datasets.datasetpath(DATASET), ImageClasssification)
 image, class = getobs(data, 1)
 image
 ```
@@ -45,21 +45,13 @@ classes = unique([getobs(data.target, i) for i in 1:nobs(data.target)])
 
 ### Learning method struct
 
-Now let's get to it! The first thing we need to do is to create a [`DLPipelines.LearningTask`](#) and a [`DLPipelines.LearningMethod`](#) struct. The **task** represents learning a mapping from an image to a class, while the **method** is a concrete way to solve the task. The distinction is made since in practice there can be multiple methods to solve a task. After this part, we'll only deal with `LearningMethod`.
+Now let's get to it! The first thing we need to do is to create a [`DLPipelines.LearningMethod`](#) struct. The `LearningMethod` `struct` should contain all the configuration needed for encoding and decoding the data. We'll keep it simple here and include a list of the classes and the image dimensions input to the model. The reference implementation [`ImageClassification`](#) of course has many more parameters that can be configured.
 
 {cell=main}
 ```julia
 using FastAI: DLPipelines
 
-abstract type MyImageClassificationTask <: DLPipelines.LearningTask end
-```
-
-
-The `LearningMethod` `struct` should contain all the configuration needed for encoding and decoding the data. We'll keep it simple here and include a list of the classes and the image dimensions input to the model. The reference implementation [`FastAI.ImageClassification`](#) of course has many more parameters that can be configured.
-
-{cell=main}
-```julia
-struct MyImageClassification <: DLPipelines.LearningMethod{MyImageClassificationTask}
+struct MyImageClassification <: DLPipelines.LearningMethod
     classes
     size
 end
@@ -74,7 +66,7 @@ method = MyImageClassification(classes, (128, 128))
 
 ### Encoding and decoding
 
-There are only 3 methods we need to define before we can use our learning method to train models and make predictions:
+There are 3 methods we need to define before we can use our learning method to train models and make predictions:
 
 - `DLPipelines.encodeinput` will encode an image so it can be input to a model;
 - `DLPipelines.encodetarget` encodes a class so we can compare it with a model output; and
@@ -91,7 +83,7 @@ Each of the methods also takes a `context::`[`DLPipelines.Context`](#) argument
 
 #### Inputs
 
-We implement [`encodeinput`](#) using [DataAugmenation.jl](https://github.com/lorenzoh/DataAugmentation.jl). Feel free to look at [its documentation](https://lorenzoh.github.io/DataAugmentation.jl/dev/docs/literate/intro.html), we won't focus on it here.
+We implement [`encodeinput`](#) using [DataAugmentation.jl](https://github.com/lorenzoh/DataAugmentation.jl). Feel free to look at [its documentation](https://lorenzoh.github.io/DataAugmentation.jl/dev/docs/literate/intro.html), we won't focus on it here.
 
 {cell=main}
 ```julia
@@ -118,7 +110,7 @@ function DLPipelines.encodeinput(
 end
 ```
 
-If we test this out on our image, it should give us a 3D array of size `(128, 128, 3)`, and indeed it does:
+If we test this out on an image, it should give us a 3D array of size `(128, 128, 3)`, and indeed it does:
 
 {cell=main}
 ```julia
@@ -148,7 +140,7 @@ end
 y = encodetarget(method, Training(), class)
 ```
 
-The decoding step as well:
+The same goes for the decoding step:
 
 {cell=main}
 ```julia
diff --git a/docs/methods/imageclassification.md b/docs/methods/imageclassification.md
@@ -19,7 +19,7 @@ end
 using CairoMakie
 using FastAI
 dir = joinpath(datasetpath("dogscats"), "train")
-data = loadtaskdata(dir, ImageClassificationTask)
+data = loadtaskdata(dir, ImageClasssification)
 samples = [getobs(data, i) for i in rand(1:nobs(data), 9)]
 classes = Datasets.getclassesclassification(dir)
 method = ImageClassification(classes, (128, 128))
diff --git a/docs/methods/imagesegmentation.md b/docs/methods/imagesegmentation.md
diff --git a/docs/notebooks/finetune.ipynb b/docs/notebooks/finetune.ipynb
@@ -68,7 +68,7 @@
     }
    ],
    "source": [
-    "taskdata = Datasets.loadtaskdata(Datasets.datasetpath(DATASETNAME), ImageClassificationTask)\n",
+    "taskdata = Datasets.loadtaskdata(Datasets.datasetpath(DATASETNAME), ImageClasssification)\n",
     "classes = Datasets.getclassesclassification(DATASETNAME);\n",
     "method = ImageClassification(classes, (128, 128))"
    ]
diff --git a/docs/notebooks/fitonecycle.ipynb b/docs/notebooks/fitonecycle.ipynb
@@ -47,7 +47,7 @@
     }
    ],
    "source": [
-    "data = Datasets.loadtaskdata(Datasets.datasetpath(\"imagenette2-160\"), ImageClassificationTask)\n",
+    "data = Datasets.loadtaskdata(Datasets.datasetpath(\"imagenette2-160\"), ImageClasssification)\n",
     "method = ImageClassification(Datasets.getclassesclassification(\"imagenette2-160\"), (160, 160))\n",
     "learner = methodlearner(method, data, Models.xresnet18(), ToGPU(), Metrics(accuracy))"
    ]
diff --git a/docs/notebooks/how_to_visualize.ipynb b/docs/notebooks/how_to_visualize.ipynb
@@ -73,7 +73,7 @@
     "using FastAI\n",
     "\n",
     "method, model = loadmethodmodel(\"catsdogs.jld2\")\n",
-    "data = loadtaskdata(joinpath(datasetpath(\"dogscats\"), \"train\"), ImageClassificationTask)"
+    "data = loadtaskdata(joinpath(datasetpath(\"dogscats\"), \"train\"), ImageClasssification)"
    ]
   },
   {
diff --git a/docs/notebooks/imagesegmentation.ipynb b/docs/notebooks/imagesegmentation.ipynb
@@ -70,16 +70,16 @@
     }
    ],
    "source": [
-    "taskdata = Datasets.loadtaskdata(Datasets.datasetpath(\"camvid_tiny\"), FastAI.ImageSegmentationTask);\n",
+    "taskdata = Datasets.loadtaskdata(Datasets.datasetpath(\"camvid_tiny\"), ImageSegmentation);\n",
     "image = getobs(taskdata, 1).input"
    ]
   },
   {
-   "cell_type": "markdown",
-   "metadata": {},
    "source": [
     "Every pixel in this image is assigned one of the following classes:"
-   ]
+   ],
+   "cell_type": "markdown",
+   "metadata": {}
   },
   {
    "cell_type": "code",
@@ -551,4 +551,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 4
-}
+}
diff --git a/docs/notebooks/keypointregression.ipynb b/docs/notebooks/keypointregression.ipynb
@@ -278,7 +278,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "struct MyKeypointRegression <: LearningMethod{LearningTask}\n",
+    "struct MyKeypointRegression <: LearningMethod\n",
     "    projections::ProjectiveTransforms\n",
     "    preprocessing::ImagePreprocessing\n",
     "end"
diff --git a/docs/notebooks/lrfind.ipynb b/docs/notebooks/lrfind.ipynb
@@ -35,7 +35,7 @@
    "outputs": [],
    "source": [
     "using FastAI\n",
-    "data = Datasets.loadtaskdata(Datasets.datasetpath(\"imagenette2-160\"), ImageClassificationTask)\n",
+    "data = Datasets.loadtaskdata(Datasets.datasetpath(\"imagenette2-160\"), ImageClasssification)\n",
     "method = ImageClassification(Datasets.getclassesclassification(\"imagenette2-160\"), (160, 160))\n",
     "learner = methodlearner(method, data, Models.xresnet18(), ToGPU(), Metrics(accuracy))"
    ]
diff --git a/docs/notebooks/serialization.ipynb b/docs/notebooks/serialization.ipynb
@@ -184,7 +184,7 @@
     "using Metalhead\n",
     "\n",
     "dir = joinpath(datasetpath(\"dogscats\"), \"train\")\n",
-    "data = loadtaskdata(dir, ImageClassificationTask)\n",
+    "data = loadtaskdata(dir, ImageClasssification)\n",
     "classes = Datasets.getclassesclassification(dir)\n",
     "method = ImageClassification(classes, (128, 128))\n",
     "backbone = Metalhead.resnet50(pretrain = true)[1:end-3]\n",
diff --git a/docs/quickstart.md b/docs/quickstart.md
@@ -12,7 +12,7 @@ using FastAI.Datasets
 Train an image classifier from scratch:
 
 ```julia
-data = Datasets.loadtaskdata(Datasets.datasetpath("imagenette2-160"), ImageClassificationTask)
+data = Datasets.loadtaskdata(Datasets.datasetpath("imagenette2-160"), ImageClasssification)
 method = ImageClassification(Datasets.getclassesclassification("imagenette2-160"), (160, 160))
 learner = methodlearner(method, data, Models.xresnet18(), ToGPU(), Metrics(accuracy))
 fitonecycle!(learner, 5)
diff --git a/docs/tutorials/presizing.ipynb b/docs/tutorials/presizing.ipynb
@@ -374,7 +374,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "data = loadtaskdata(DSTDIR, ImageClassificationTask);"
+    "data = loadtaskdata(DSTDIR, ImageClassification);"
    ]
   },
   {
@@ -410,4 +410,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
diff --git a/src/FastAI.jl b/src/FastAI.jl
@@ -97,10 +97,6 @@ export
     # pipeline steps
     ProjectiveTransforms, ImagePreprocessing, augs_projection, augs_lighting,
 
-    # tasks
-    ImageClassificationTask,
-    ImageSegmentationTask,
-
     # methods
     ImageClassification,
     ImageSegmentation,
diff --git a/src/datasets/load.jl b/src/datasets/load.jl
diff --git a/src/methods/imageclassification.jl b/src/methods/imageclassification.jl
diff --git a/src/methods/imagesegmentation.jl b/src/methods/imagesegmentation.jl
diff --git a/src/methods/singlekeypointregression.jl b/src/methods/singlekeypointregression.jl
diff --git a/src/plotting.jl b/src/plotting.jl
diff --git a/src/tasks.jl b/src/tasks.jl
diff --git a/test/datasets/datasets.jl b/test/datasets/datasets.jl

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-**/.ipynb_checkpoints`
	`1`	`+/.ipynb_checkpoints/`
`2`	`2`	`test/Manifest.toml`
`3`	`3`	`docs/Manifest.toml`
`4`	`4`	`development/**`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ callbacks = [`
`33`	`33`	`Metrics(accuracy)`
`34`	`34`	`]`
`35`	`35`
`36`		`-data = Datasets.loadtaskdata(Datasets.datasetpath("imagenette2-160"), ImageClassificationTask)`
	`36`	`+data = Datasets.loadtaskdata(Datasets.datasetpath("imagenette2-160"), ImageClasssification)`
`37`	`37`	`method = ImageClassification(Datasets.getclassesclassification("imagenette2-160"), (160, 160))`
`38`	`38`	`learner = methodlearner(method, data, Models.xresnet18(), callbacks...)`
`39`	`39`	`fitonecycle!(learner, 5)`