Merge pull request #253 from codeboy5/ts-models

Added Model for Time Series Classification

Author: ToucheSir

FastTimeSeries/Project.toml

@@ -4,18 +4,24 @@ authors = ["FluxML Community"]
 version = "0.1.0"
 
 [deps]
+DataDeps = "124859b0-ceae-595e-8997-d05f6a7a8dfe"
 FastAI = "5d0beca9-ade8-49ae-ad0b-a3cf890e669f"
 FilePathsBase = "48062228-2e41-5def-b9a4-89aafe57970f"
+Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"
 InlineTest = "bd334432-b1e7-49c7-a2dc-dd9149e4ebd6"
 MLUtils = "f1d291b0-491e-4a28-83b9-f70985020b54"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 UnicodePlots = "b8865327-cd53-5732-bb35-84acbb429228"
+Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 
 [compat]
+DataDeps = "0.7"
 FastAI = "0.5"
 FilePathsBase = "0.9"
+Flux = "0.12, 0.13"
 InlineTest = "0.2"
 MLUtils = "0.2"
 UnicodePlots = "2, 3"
 julia = "1.6"
+Zygote = "0.6"

FastTimeSeries/src/FastTimeSeries.jl

@@ -34,11 +34,16 @@ include("blocks/timeseriesrow.jl")
 # Encodings
 include("encodings/tspreprocessing.jl")
 
+# Models
+include("models/Models.jl")
+include("models.jl")
+
 include("container.jl")
 include("recipes.jl")
 
 const _tasks = Dict{String, Any}()
 include("tasks/classification.jl")
+include("tasks/regression.jl")
 
 function __init__()
     _registerrecipes()
@@ -50,5 +55,5 @@ function __init__()
 end
 
 export
-    TimeSeriesRow, TSClassificationSingle, TSPreprocessing
+    TimeSeriesRow, TSClassificationSingle, TSPreprocessing, TSRegression
 end

FastTimeSeries/src/container.jl

@@ -54,6 +54,7 @@ function _ts2df(
 
     timestamps = false
     class_labels = false
+    target_labels = true
 
     open(full_file_path_and_name, "r") do file
         for ln in eachline(file)
@@ -109,6 +110,21 @@ function _ts2df(
 
                     series_length = parse(Int, tokens[2])
 
+                elseif startswith(ln, "@dimension")
+                    # Check that the associated value is valid
+                    tokens = split(ln, " ")
+                    
+                    num_dimensions = parse(Int, tokens[2])
+                
+                elseif startswith(ln, "@targetlabel")
+                    tokens = split(ln, " ")
+
+                    if tokens[2] == "true"
+                        target_labels = true
+                    else
+                        target_labels = false
+                    end
+
                 elseif startswith(ln, "@classlabel")
                     # Check that the associated value is valid
                     tokens = split(ln, " ")
@@ -150,7 +166,106 @@ function _ts2df(
                     # Check if we dealing with data that has timestamps
 
                     if timestamps
-                        #! Need To Add Code.
+                        
+                        has_another_value = false
+                        has_another_dimension = false
+
+                        timestamps_for_dimension = []
+                        values_for_dimension = []
+
+                        line_len = length(ln)
+                        char_num = 1
+                        num_this_dimension = 1
+                        arr = Array{Float32, 2}(undef, num_dimensions, series_length)
+
+                        while char_num <= line_len
+
+                            # Move through any spaces.
+                            while char_num <= line_len && isspace(ln[char_num])
+                                char_num += 1
+                            end
+
+                            if char_num <= line_len
+
+                                # Check if we have reached a class label
+                                if ln[char_num] != '(' && target_labels
+
+                                    class_val = strip(ln[char_num:end], ' ')
+
+                                    push!(class_val_list, parse(Float32, class_val))
+                                    push!(instance_list, arr)
+
+                                    char_num = line_len
+
+                                    has_another_value = false
+                                    has_another_dimension = false
+
+                                    timestamps_for_dimension = []
+                                    values_for_dimension = []
+
+                                    char_num += 1
+                                    num_this_dimension = 1
+                                    arr = Array{Float32, 2}(undef, num_dimensions, series_length)
+                                
+                                else
+
+                                    char_num += 1
+                                    tuple_data = ""
+
+                                    while (char_num <= line_len && ln[char_num] != ')')
+                                        tuple_data *= ln[char_num]
+                                        char_num += 1
+                                    end
+
+                                    char_num += 1
+
+                                    while char_num <= line_len && isspace(ln[char_num])
+                                        char_num += 1
+                                    end
+
+                                    # Check if there is another value or dimension to process after this tuple.
+                                    if char_num > line_len
+                                        has_another_value = false
+                                        has_another_dimension = false
+                                    elseif ln[char_num] == ','
+                                        has_another_value = true
+                                        has_another_dimension = false
+                                    elseif ln[char_num] == ':'
+                                        has_another_value = false
+                                        has_another_dimension = true
+                                    end
+
+                                    char_num += 1
+
+                                    last_comma_index = findlast(",", tuple_data)
+
+                                    if !isnothing(last_comma_index)
+                                        last_comma_index = last_comma_index[1]
+                                    end
+
+                                    value = tuple_data[last_comma_index+1:end]
+                                    value = parse(Float32, value)
+
+                                    timestamp = tuple_data[1:last_comma_index-1]
+
+                                    push!(values_for_dimension, value)
+
+                                    if !has_another_value
+
+                                        arr[num_this_dimension, 1:end] = values_for_dimension
+
+                                        values_for_dimension = []
+
+                                        num_this_dimension += 1
+                                    end
+                                    
+                                end
+
+                            end
+
+                        end
+
+
                     else
                         dimensions = split(ln, ':')
 
@@ -196,13 +311,9 @@ function _ts2df(
                                 data_series = split(dimension, ',')
                                 data_series = [parse(Float32, i) for i in data_series]
                                 arr[dim, 1:end] = data_series
-                                # println(data_series)
-                                # data_series = [parse(Float32, i) for i in data_series]
-                                # push!(instance_list[dim], data_series)
                             else
                                 tmp = Array{Float32, 1}(undef, 100)
                                 arr[dim, 1:end] = tmp
-                                # push!(instance_list[dim], [])
                             end
                         end
 
@@ -229,7 +340,7 @@ function _ts2df(
         end
 
         # Check if we should return any associated class labels separately
-        if class_labels
+        if class_labels || target_labels
             return data, class_val_list
         else
             return data

FastTimeSeries/src/models.jl

@@ -0,0 +1,27 @@
+
+"""
+blockmodel(inblock::TimeSeriesRow, outblock::OneHotTensor{0}, backbone)
+
+Construct a model for time-series classification.
+"""
+function blockmodel(inblock::TimeSeriesRow,
+                outblock::OneHotTensor{0}, 
+                backbone)
+    data   = rand(Float32, inblock.nfeatures, 32, inblock.obslength)
+    # data   = [rand(Float32, inblock.nfeatures, 32) for _ ∈ 1:inblock.obslength]
+    output = backbone(data)
+    return Models.RNNModel(backbone, outsize = length(outblock.classes), recout = size(output, 1))
+end
+
+"""
+    blockbackbone(inblock::TimeSeriesRow)
+
+Construct a recurrent backbone
+"""
+function blockbackbone(inblock::TimeSeriesRow)
+    Models.StackedLSTM(inblock.nfeatures, 16, 10, 2);
+end
+
+# ## Tests
+
+@testset "blockbackbone" begin @test_nowarn FastAI.blockbackbone(TimeSeriesRow(1,140)) end

FastTimeSeries/src/models/Models.jl

@@ -0,0 +1,15 @@
+module Models
+
+using ..FastAI
+
+using Flux
+using Zygote
+using DataDeps
+using InlineTest
+
+include("StackedLSTM.jl")
+include("RNN.jl")
+
+export StackedLSTM, RNNModel
+
+end

FastTimeSeries/src/models/RNN.jl

@@ -0,0 +1,39 @@
+function tabular2rnn(X::AbstractArray{Float32, 3})
+    X = permutedims(X, (1, 3, 2))
+    return X
+end
+
+struct RNNModel{A, B}
+    recbackbone::A
+    finalclassifier::B
+end
+
+"""
+    RNNModel(recbackbonem, outsize, recout[; kwargs...])
+
+Creates a RNN model from the recurrent 'recbackbone' architecture. The output from this backbone
+is passed through a dropout layer before a 'finalclassifier' block.
+
+## Keyword arguments.
+
+- `outsize`: The output size of the final classifier block. For single classification tasks,
+    this would be the number of classes.
+- `recout`: The output size of the `recbackbone` architecture.
+- `dropout_rate`: Dropout probability for the dropout layer.
+"""
+
+function RNNModel(recbackbone;
+                outsize,
+                recout,
+                kwargs...)
+    return RNNModel(recbackbone, Dense(recout, outsize))
+end
+
+function (m::RNNModel)(X)
+    X = tabular2rnn(X)
+    Flux.reset!(m.recbackbone)
+    X = m.recbackbone(X)[:, :, end]
+    return m.finalclassifier(X)
+end
+
+Flux.@functor RNNModel 

FastTimeSeries/src/models/StackedLSTM.jl

@@ -0,0 +1,26 @@
+"""
+	StackedLSTM(in, out, hiddensize, layers)
+
+Stacked LSTM network. Feeds the data through a chain of LSTM layers, where the hidden state
+of the previous layer gets fed to the next one. The first layer corresponds to
+`LSTM(in, hiddensize)`, the hidden layers to `LSTM(hiddensize, hiddensize)`, and the final
+layer to `LSTM(hiddensize, out)`. Takes the keyword argument `init` for the initialization
+of the layers.
+
+"""
+function StackedLSTM(in::Int, out::Integer, hiddensize::Integer, layers::Integer;
+			init=Flux.glorot_uniform)
+	if layers == 1
+		chain = Chain(LSTM(in, out; init=init))
+	elseif layers == 2
+		chain = Chain(LSTM(in, hiddensize; init=init),
+					  LSTM(hiddensize, out; init=init))
+	else
+		chain_vec = [LSTM(in, hiddensize; init=init)]
+		for i = 1:layers - 2
+			push!(chain_vec, LSTM(hiddensize, hiddensize; init=init))
+		end
+		chain = Chain(chain_vec..., LSTM(hiddensize, out; init=init))
+	end
+	return chain
+end

FastTimeSeries/src/models/layers.jl

@@ -0,0 +1,9 @@
+"""
+    GAP1d(output_size)
+
+Create a Global Adaptive Pooling + Flatten layer.
+"""
+function GAP1d(output_size::Int)
+    gap = AdaptiveMeanPool((output_size,))
+    Chain(gap, Flux.flatten)    
+end