Added Time Series Container and Block. It is capable of loading all datasets from timeseriesclassification. The .ts files are loaded using Julia translation of this method .

I have also added a basic test case for the recipe. This allows us to do the following

using FastAI

data, blocks = load(datarecipes()["ecg5000"])
nobs(data)
sample = series, class = getobs(data, 10)

Just wanted to get some initial thoughts on the work, there might be more changes as I continue to work on the other parts.

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers. Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue. I'll open a PR within a few hours, please be patient!

Registered the NLP ( Text ) dataset to be added in the upcoming months. Added functions for the blocks of the Text dataset. All the nlp dataset ( which are registered ) along with their forthcoming models will be added . Exploring Julia Text, MLutils and other package along with FastAI concepts so that these datasets can work well with Flux. As almost all the text datasets are in csv format it will be easily lo load them and create the corresponding container, working on further concepts to implement these text datasets.

Currently I have added the entire basic structure of the Text Data comprising of the blocks and the containers. Have researched a lot since a week ( understanding FastAI docs and codebase ). Currently working on adding textrow block along with the recipes.jl. Also currently working on two datasets "imdb" and "amazon_review_full" as both have different folder structure so different blocks would be required. Also going through the 2 papers which have built state of the art model for these two datasets and working on its implementation. Any reviews thus far will be appreciated.

Reopened PR#100 , needed to delete that repo due to merging issue.

This PR will contain the implementation of InceptionTime Model and it's use for classification and regression task.

Some of the commits from the PR #253 are also in this PR, but will take care of them when that PR is merged.

I have added the code for a basic RNN Model for the task of time series classification.

> data, blocks = load(datarecipes()["ecg5000"]);
> task = TSClassificationSingle(blocks, data);
> model = FastAI.taskmodel(task);
> traindl, validdl = taskdataloaders(data, task, 32);
> callbacks = [ToGPU(), Metrics(accuracy)];
> learner = Learner(model, tasklossfn(task); data=(traindl, validdl), optimizer=ADAM(), callbacks = callbacks);
> fitonecycle!(learner, 10, 0.033)

As I discussed with @darsnack, the idea is to add an encoding to do the reshaping to (features, batch, time) instead of doing it inside on the RNN Model. Working on that right now.

Have remove the type from StackedLSTM as it was redundant.

When I try to train a simple resnet on CIFAR10 dataset, FastAi seems very slow compared to Flux (≈ 9-19 times slower). It seems, it could be a garbage collector problem, because with Flux I can have a batch-size of 512, and with FastAI I can't exceed 128 without having a out of memory error.

FastAI code:

using FastAI
using ResNet9 # Pkg.add(url = "https://github.com/a-r-n-o-l-d/ResNet9.jl", rev="v0.1.1")

data, blocks = loaddataset("cifar10", (Image, Label))
method = ImageClassificationSingle(blocks)
model = resnet9(inchannels=3, nclasses=10, dropout=0.0)
method = ImageClassificationSingle(blocks)
learner = methodlearner(method, data; 
    lossfn=Flux.crossentropy,
    callbacks=[ToGPU()],
    batchsize=16,
    model=model,
    optimizer=Descent())

@time fitonecycle!(learner, 5, 1f-3, pct_start=0.5, divfinal=100, div=100)

Flux code:

using Flux
using Flux: DataLoader, onehotbatch
using Augmentor
using MLDatasets
using ParameterSchedulers
using ParameterSchedulers: Scheduler
using ResNet9 # Pkg.add(url = "https://github.com/a-r-n-o-l-d/ResNet9.jl", rev="v0.1.1")

normpip = SplitChannels() |> PermuteDims(3, 2, 1) |> ConvertEltype(Float32)

labels = CIFAR10.classnames() .|> Symbol

function datasets(batchsize)
    train = let
        x = CIFAR10.traintensor() |> CIFAR10.convert2image
        y = map(i -> labels[i + 1], CIFAR10.trainlabels())
        DataLoader((x, y), batchsize = batchsize, shuffle = true, partial = false)
    end

    test = let
        x = CIFAR10.testtensor() |> CIFAR10.convert2image
        y = map(i -> labels[i + 1], CIFAR10.testlabels())
        DataLoader((x, y), batchsize = batchsize)
    end
    
    train, test
end

function minibatch(x, y)
    h, w, n = size(x)
    xb = Array{Float32}(undef, w, h, 3, n)
    augmentbatch!(CPUThreads(), xb, x, normpip)
    yb = onehotbatch(y, labels)
    xb, yb
end

function train!(model, optimiser, nepochs)
    loss_hist = []
    loss(x, y) = Flux.crossentropy(model(x), y)
    ps = params(model)
    for e in 1:nepochs
        # Training phase
        tloss = 0
        trainmode!(model)
        for (x, y) ∈ train
            x, y = minibatch(x, y) |> gpu
            gs = gradient(ps) do
                l = loss(x, y)
                tloss += l
                l
            end
            Flux.Optimise.update!(optimiser, ps, gs)
        end
        tloss /= length(train)
        # Validation phase
        testmode!(model)
        vloss = 0
        for (x, y) ∈ test
            x, y = minibatch(x, y) |> gpu
            vloss += loss(x, y)
        end
        vloss /= length(test)
        push!(loss_hist, (tloss, vloss))
    end
    
    loss_hist
end

train, test = datasets(16)
nepochs = 5
s = Triangle(λ0 = 1f-5, λ1 = 1f-3, period = nepochs * length(train))
opt = Scheduler(s, Descent())
model = resnet9(inchannels = 3, nclasses = 10, dropout = 0.0) |> gpu
@time train!(model, opt, nepochs)

Results on a RTX 2080 Ti: FastAI: 1841.008685 seconds (3.92 G allocations: 212.561 GiB, 59.59% gc time, 0.00% compilation time) Flux: 98.444806 seconds (106.49 M allocations: 16.643 GiB, 3.58% gc time, 2.58% compilation time)

Results on a Quadro P5000: FastAI: 1574.714976 seconds (3.92 G allocations: 212.473 GiB, 11.08% gc time) Flux: 177.416636 seconds (105.55 M allocations: 16.639 GiB, 2.05% gc time, 1.42% compilation time)

Discriminative learning rates means using different learning rates for differents part of a model, so-called layer groups. This is used in fastai when finetuning models.

Some miscellaneous changes with the tokenizer being the main focus. Implements the LearnBase getobs and nobs methods. Uses the WordTokenizers module.

Closes #24

Tried starting at creating a simple textual recipe based on ImageFolders dataset recipe. This specifically works for imdb and similar datasets. Any feedback is highly appreciated.

Added Time Series Container and Block. Currently can only load univariate time series. This is work in progress for issue #155 . I was planning to add loaddataset function for such datasets. Currently all datasets have the same root URL :- "https://s3.amazonaws.com/fast-ai-" . For time series datasets the root url is different so i think we can proceed by add root_url field in the FastAIDataset structure. How does this sound ?

I suspect that the following code line from the Image segmentation example

backbone = Metalhead.ResNet50(pretrain=true).layers[1:end-3]

is not doing what is intended since ResNet50 from Metalhead (https://github.com/darsnack/Metalhead.jl/tree/darsnack/vision-refactor) returns a 2 item Chain (backbone and head), and the 1:end-3 indexing returns an empty Chain.

Funny enough, with the model return by methodmodel (basically a Conv((1,1), 3=>32)) the example still works and is able to produce some image segmentation (does it works like just a pixel color indexer?).

I'd say the expected code should be something Metalhead.ResNet50(pretrain=true).layers[1].layers and I would open a PR, but I'm not sure since, with that, the example fails later in the training loop.

This pull request changes the compat entry for the MLUtils package from 0.2.6, 0.3 to 0.2.6, 0.3, 0.4. This keeps the compat entries for earlier versions.

Note: I have not tested your package with this new compat entry. It is your responsibility to make sure that your package tests pass before you merge this pull request.

Package Version

0.5.0

Julia Version

1.8.3

OS / Environment

Windows10

Describe the bug

The downloads do not work under proxy, although Base.download and Downloads.download works just fine. The HTTP_PROXY and HTTPS_PROXY are set properly, ENV["HTTP_PROXY"] = "http://127.0.0.1:3128".

using FastAI

imagenette2_url = "https://s3.amazonaws.com/fast-ai-imageclas/imagenette2-160.tgz"
FastAI.load(datasets()["imagenette2-160"])

Do you want to download the dataset from https://s3.amazonaws.com/fast-ai-imageclas/imagenette2-160.tgz to "D:\z_installed_programs\julia-depot\datadeps\fastai-imagenette2-160"?
[y/n]
y
ERROR: HTTP.Exceptions.RequestError(HTTP.Messages.Request:
"""
GET /fast-ai-imageclas/imagenette2-160.tgz HTTP/1.1
Host: s3.amazonaws.com
Accept: */*
User-Agent: HTTP.jl/1.8.3
Content-Length: 0

[Message Body was streamed]""", Base.IOError("X509 - Certificate verification failed, e.g. CRL, CA or signature check failed", -9984))

Using Downloads.download or Base.download works just fine under the same proxy conditions.

import Downloads
imagenette2_url = "https://s3.amazonaws.com/fast-ai-imageclas/imagenette2-160.tgz"
Downloads.download(imagenette2_url, "imagenette2-160.tgz")

Steps to Reproduce

see above

Expected Results

see above

Observed Results

see above

Relevant log output

see above

Package Version

0.5.0

Julia Version

1.8.3

OS / Environment

Windows10

Describe the bug

I just run the following code to download the coco_sample dataset: FastAI.load(datasets()["coco_sample"]). The download is succesful. After the download 7zip is being called to unpack the archive. After the unzipping the following error occurs. It looks like the script tries to delete the folder it just created, fastai-coco_cample. This happens with all the datasets.

ERROR: LoadError: IOError: rm("D:\\z_installed_programs\\julia-depot\\datadeps\\fastai-coco_sample"): resource busy or locked (EBUSY)

Note that I have the julia's DEPOT_PATH environment variable set to D:\\z_installed_programs\\julia-depot, instead of the default home directory of the user.

Steps to Reproduce

using FastAI
FastAI.load(datasets()["coco_sample"])

Expected Results

get the coco sample dataset on the PC

Observed Results

the archive of the coco sample is downloaded, the archive is unzipped, then the error occurs and then the fastai-coco_cample folder containing the archive and the unzipped data is deleted.

Relevant log output

ERROR: LoadError: IOError: rm("D:\\z_installed_programs\\julia-depot\\datadeps\\fastai-coco_sample"): resource busy or locked (EBUSY)
Stacktrace:
  [1] uv_error
    @ .\libuv.jl:97 [inlined]
  [2] rm(path::String; force::Bool, recursive::Bool)
    @ Base.Filesystem .\file.jl:306
  [3] checkfor_mv_cp_cptree(src::String, dst::String, txt::String; force::Bool)
    @ Base.Filesystem .\file.jl:330
  [4] #mv#15
    @ .\file.jl:425 [inlined]
  [5] (::FastAI.Datasets.var"#10#11")(f::String)
    @ FastAI.Datasets D:\z_installed_programs\julia-depot\packages\FastAI\as9UG\src\datasets\fastaidatasets.jl:261
  [6] #16
    @ D:\z_installed_programs\julia-depot\packages\DataDeps\ae6dT\src\resolution_automatic.jl:122 [inlined]
  [7] cd(f::DataDeps.var"#16#17"{FastAI.Datasets.var"#10#11", String}, dir::String)
    @ Base.Filesystem .\file.jl:101
  [8] run_post_fetch(post_fetch_method::FastAI.Datasets.var"#10#11", fetched_path::String)
    @ DataDeps D:\z_installed_programs\julia-depot\packages\DataDeps\ae6dT\src\resolution_automatic.jl:119
  [9] download(datadep::DataDeps.DataDep{String, String, typeof(DataDeps.fetch_default), FastAI.Datasets.var"#10#11"}, localdir::String; remotepath::String, i_accept_the_terms_of_use::Nothing, skip_checksum::Bool)
    @ DataDeps D:\z_installed_programs\julia-depot\packages\DataDeps\ae6dT\src\resolution_automatic.jl:84
 [10] download
    @ D:\z_installed_programs\julia-depot\packages\DataDeps\ae6dT\src\resolution_automatic.jl:63 [inlined]
 [11] handle_missing
    @ D:\z_installed_programs\julia-depot\packages\DataDeps\ae6dT\src\resolution_automatic.jl:10 [inlined]
 [12] _resolve
    @ D:\z_installed_programs\julia-depot\packages\DataDeps\ae6dT\src\resolution.jl:83 [inlined]
 [13] resolve(datadep::DataDeps.DataDep{String, String, typeof(DataDeps.fetch_default), FastAI.Datasets.var"#10#11"}, inner_filepath::String, calling_filepath::String)
    @ DataDeps D:\z_installed_programs\julia-depot\packages\DataDeps\ae6dT\src\resolution.jl:29
 [14] resolve(datadep_name::String, inner_filepath::String, calling_filepath::String)
    @ DataDeps D:\z_installed_programs\julia-depot\packages\DataDeps\ae6dT\src\resolution.jl:54
 [15] resolve
    @ D:\z_installed_programs\julia-depot\packages\DataDeps\ae6dT\src\resolution.jl:73 [inlined]
 [16] makeavailable
    @ D:\z_installed_programs\julia-depot\packages\FastAI\as9UG\src\datasets\loaders.jl:46 [inlined]
 [17] loaddata(loader::FastAI.Datasets.DataDepLoader)
    @ FastAI.Datasets D:\z_installed_programs\julia-depot\packages\FastAI\as9UG\src\datasets\loaders.jl:50
 [18] (::FastAI.Registries.var"#8#13")(row::NamedTuple{(:id, :description, :size, :tags, :package, :downloaded, :loader), Tuple{String, Union{Missing, String}, Union{Missing, String}, Vector{String}, Module, Bool, FastAI.Datasets.DatasetLoader}})
    @ FastAI.Registries D:\z_installed_programs\julia-depot\packages\FastAI\as9UG\src\Registries\datasets.jl:38
 [19] load(entry::FeatureRegistries.RegistryEntry; kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
    @ FeatureRegistries D:\z_installed_programs\julia-depot\packages\FeatureRegistries\FBMLI\src\registry.jl:135
 [20] load
    @ D:\z_installed_programs\julia-depot\packages\FeatureRegistries\FBMLI\src\registry.jl:135 [inlined]

This populates the model registry from #267 with models from Metalhead.jl.

Depends on #267 as well as unreleased [email protected] . Possibly supersedes https://github.com/FluxML/Metalhead.jl/pull/153.

See #267 for usage.

PR Checklist

• [ ] Tests are added
• [ ] Documentation, if applicable

Implements #246.

PR Checklist

• [x] Tests are added
• [x] Documentation (this is an internal change for now, docs will be added in follow-up when functionality is made available and used in domain package)

Usage examples

From #269:

using FastAI: models
# loading this adds the models to registry
using FastVision


# Load original model, 1000 output classes, no weights (`ResNet(18)`):
load(models()["metalhead/resnet18"]);

# Load original model, 1000 output classes, with weights (`ResNet(18), pretrain=true`):
load(models()["metalhead/resnet18"], pretrained = true);

# Load only backbone, without weights:
load(models()["metalhead/resnet18"], variant = "backbone");

# Load only backbone, with weights:
load(models()["metalhead/resnet18"], pretrained = true, variant = "backbone");

# Load model for task, adapting layers as necessary:
task = ImageClassificationSingle((256, 256), 1:5, C = Gray{N0f8}) # input with 1 color channel, 5 classes
load(models()["metalhead/resnet18"], input = task.blocks.x, output = task.blocks.y)
# Also works with pretrained weights
load(models()["metalhead/resnet18"], pretrained = true, input = task.blocks.x, output = task.blocks.y)

# Correct variants are selected automatically given the blocks:
load(models()["metalhead/resnet18"], output = FastAI.ConvFeatures)  # uses backbone variant


# Support for multiple checkpoints, selectable by name:
load(models()["metalhead/resnet18"], checkpoint = "imagenet1k")

Docs

The proposed interface is well-described by the registry description, pasted below:

A FeatureRegistry for models. Allows you to find and load models for various learning tasks using a unified interface. Call models() to see a table view of available models:

using FastAI
models()

Which models are available depends on the loaded packages. For example, FastVision.jl adds vision models from Metalhead to the registry. Index the registry with a model ID to get more information about that model:

using FastAI: models
using FastVision  # loading the package extends the list of available models

models()["metalhead/resnet18"]

If you've selected a model, call load to then instantiate a model:

model = load("metalhead/resnet18")

By default, load loads a default version of the model without any pretrained weights.

load(model) also accepts keyword arguments that allow you to specify variants of the model and weight checkpoints that should be loaded.

Loading a checkpoint of pretrained weights:

• load(entry; pretrained = true): Use any pretrained weights, if they are available.
• load(entry; checkpoint = "checkpoint-name"): Use the weights with given name. See entry.checkpoints for available checkpoints (if any).
• load(entry; pretrained = false): Don't use pretrained weights

Loading a model variant for a specific task:

• load(entry; input = ImageTensor, output = OneHotLabel): Load a model variant matching an input and output block.
• load(entry; variant = "backbone"): Load a model variant by name. Seeentry.variants` for available variants.