From 86d68d4f4d3bcea16c2e45fd7913e04d226f6df5 Mon Sep 17 00:00:00 2001 From: andrew Date: Tue, 19 Jan 2021 17:31:54 -0600 Subject: [PATCH 1/6] add time_series tutorial --- tutorials/time_series/.gitignore | 4 + tutorials/time_series/Project.toml | 12 + tutorials/time_series/time_series.jl | 435 +++++++++++++++++++++++++++ 3 files changed, 451 insertions(+) create mode 100644 tutorials/time_series/.gitignore create mode 100644 tutorials/time_series/Project.toml create mode 100644 tutorials/time_series/time_series.jl diff --git a/tutorials/time_series/.gitignore b/tutorials/time_series/.gitignore new file mode 100644 index 000000000..9d7ddda60 --- /dev/null +++ b/tutorials/time_series/.gitignore @@ -0,0 +1,4 @@ +Manifest.toml +jena_climate* +.vscode +.ipynb_* \ No newline at end of file diff --git a/tutorials/time_series/Project.toml b/tutorials/time_series/Project.toml new file mode 100644 index 000000000..73187fbe3 --- /dev/null +++ b/tutorials/time_series/Project.toml @@ -0,0 +1,12 @@ +[deps] +CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" +CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" +DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" +Debugger = "31a5f54b-26ea-5ae9-a837-f05ce5417438" +FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c" +Literate = "98b081ad-f1c9-55d3-8b20-4c87d4299306" +MLDataPattern = "9920b226-0b2a-5f5f-9153-9aa70a013f8b" +Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +StatsPlots = "f3b207a7-027a-5e70-b257-86293d7955fd" +ZipFile = "a5390f91-8eb1-5f08-bee0-b1d1ffed6cea" diff --git a/tutorials/time_series/time_series.jl b/tutorials/time_series/time_series.jl new file mode 100644 index 000000000..e30f3ecd0 --- /dev/null +++ b/tutorials/time_series/time_series.jl @@ -0,0 +1,435 @@ +#= TODO +* Add any Flux specific explanation +* Handle target value better for dataset y's; Is there a way to ensure that time series always have a batched axis using MLDataPattern, esp lazily? +* Decide what level we want this tutorial at - Flux or some higher level? +* Clean up and make more idiomatic - particularly on how timeseries are batched +* Make any tests or integrations +* Put things in functions as needed +* Eachbatch - size or maxsize? what's more popular +* Flux on master for Dense behavior. Needs to be latest when this is published +* In train_model! is it critical to return and assign the model (`linear = train_model!(linear, single_step_1h, opt; bs=16, epochs=20)`)? I found that without doing it, Flux.update! would work during training, but then calling the model outside wouldn't be mutated? could this deal with calling params at the beginning? +* Early Stopping could use some work. Not sure it does exactly what I want it to +* Need to convert data to Float32? Without it, I get this when running conv_model. Related to Params being Float32? + ┌ Warning: Slow fallback implementation invoked for conv! You probably don't want this; check your datatypes. + │ yT = Float64 + │ T1 = Float64 + │ T2 = Float32 + └ @ NNlib ~/.julia/packages/NNlib/fxLrD/src/conv.jl:206 + +------------------------------------------------------------------------ +=# + +# # Time series forecasting +# This tutorial serves as a `Julia` implementation of the Tensorflow time series forecasting tutorial here: +# +# [Tensorflow Time Series Forecasting Tutorial](https://www.tensorflow.org/tutorials/structured_data/time_series) + +# ## Setup + +using ZipFile +using CSV +using DataFrames +using StatsPlots #re-exports Plots.jl functions +using Dates +using FFTW +using CUDA +using Flux +using MLDataPattern + +using Random: seed! +using Statistics: mean, std +using Flux: unsqueeze +import StatsPlots: plot + +seed!(4231) +ENV["LINES"] = 20 + +CUDA.allowscalar(false) + +# ## The weather dataset + +function download_data(; fname="jena_climate_2009_2016.zip") + DATA_PATH = "https://storage.googleapis.com/tensorflow/tf-keras-datasets/jena_climate_2009_2016.csv.zip" + isfile(fname) || download(DATA_PATH, fname) + + zip = ZipFile.Reader(fname) #https://juliadata.github.io/CSV.jl/stable/index.html#Example:-reading-from-a-zip-file-1 + csv = zip.files[1] + df = CSV.File(csv) |> DataFrame + close(zip) + return df +end + +df = download_data(); + +df = df[6:6:end, :] + +df[!,"Date Time"] = Dates.DateTime.(df[:,"Date Time"], "dd.mm.yyyy HH:MM:SS"); #https://en.wikibooks.org/wiki/Introducing_Julia/Working_with_dates_and_times + +col = ["Date Time", "T (degC)", "p (mbar)", "rho (g/m**3)"] + +df[:,col] + +@df df plot(cols(1), cols(2:4); layout=(3, 1)) # from https://github.com/JuliaPlots/StatsPlots.jl + +@df df[1:480,:] plot(cols(1), cols(2:4); layout=(3, 1)) + +# ## Inspect and cleanup +@show describe(df) + +df."p (mbar)"; #cool that this works + +replace!(df[!,"wv (m/s)"], -9999.0 => 0); # https://juliadata.github.io/DataFrames.jl/stable/man/getting_started/#Replacing-Data +replace!(df[!,"max. wv (m/s)"], -9999.0 => 0); + +@show describe(df) + +# ## Feature engineering + +histogram2d(df[!,"wd (deg)"], df[!,"wv (m/s)"], bins=(75,75), xlabel="wd (deg)", ylabel="wv (m/s)") + +wd_rad = df[!,"wd (deg)"] * π / 180 +df.Wx = df[!,"wv (m/s)"] .* cos.(wd_rad) +df.Wy = df[!,"wv (m/s)"] .* sin.(wd_rad) +df."max Wx" = df[!,"max. wv (m/s)"] .* cos.(wd_rad) +df."max Wy" = df[!,"max. wv (m/s)"] .* sin.(wd_rad); + +histogram2d(df.Wx, df.Wy, bins=(75,75), xlabel="Wind X [m/s]", ylabel="Wind Y [m/s]") + +timestamp_s = Dates.datetime2unix.(df."Date Time"); + +day = 24*60*60 #seconds in a day +year = 365.2425 * day #seconds in a year + +df[!,"Day sin"] = sin.(timestamp_s * (2 * π / day)) +df[!,"Day cos"] = cos.(timestamp_s * (2 * π / day)) +df[!,"Year sin"] = sin.(timestamp_s * (2 * π / year)) +df[!,"Year cos"] = cos.(timestamp_s * (2 * π / year)); + +plot(df[1:25,"Day sin"], legend=false) +plot!(df[1:25,"Day cos"]) +xlabel!("Time [h]") +title!("Time of Day Signal") + +fftrans = FFTW.rfft(df[!,"T (degC)"]) +f_per_dataset = 1:size(fftrans)[1] + +n_samples_h = size(df[!,"T (degC)"])[1] +hours_per_year = 24 * 365.2524 +years_per_dataset = n_samples_h / hours_per_year +f_per_year = f_per_dataset / years_per_dataset; + +plot(f_per_year, abs.(fftrans), xscale=:log10, ylim=(0, 400000), xlim=(0.3,Inf), leg=false) +xticks!([1, 365.2524], ["1/Year", "1/Day"]) +xlabel!("Frequency (log scale)") + +# ## Split the data +# drop columns you don't want to use further +select!(df, Not([:("wv (m/s)"),:("max. wv (m/s)"), :("wd (deg)"), :("Date Time")])); + +column_indices = pairs(names(df)) +indices_columns = Dict(value => key for (key, value) in column_indices) +df = convert.(Float32, df) # Don't need high precision; reduces errors later on when using Params - gradients are Float32 + + +n = size(df)[1] +train_df = df[1:round(Int,n*0.7, RoundDown),:] +valid_df = df[round(Int,n*0.7, RoundUp):round(Int,n*0.9, RoundDown),:] +test_df = df[round(Int,n*0.9, RoundUp):end,:]; # matching TF tutorial exactly, can also use partition + +num_features = size(df)[2] + +# ## Normalize the data +train_mean = mean.(eachcol(train_df)) +train_std = std.(eachcol(train_df)) + +train_df = (train_df .- train_mean') ./ train_std' +valid_df = (valid_df .- train_mean') ./ train_std' +test_df = (test_df .- train_mean') ./ train_std' + +df_std = (df .- train_mean') ./ train_std' +df_std = stack(df_std) + +violin(df_std.variable, df_std.value, xrotation=30.0, legend=false, xticks=:all) # use plotattr() to learn about keywords + +boxplot!(df_std.variable, df_std.value, fillalpha=0.75, outliers=false) + + +# ## Data Windowing +# We are going to make use of MLDataPattern's `slidingwindow` to generate the windows +# https://mldatapatternjl.readthedocs.io/en/latest/documentation/dataview.html?highlight=slidingwindow#labeled-windows +h = 6 # historical window length +f = 1 # future window length + +train_loader = slidingwindow(i -> i+h:i+h+f-1, Array(train_df)', h, stride=1) + +# We will define our own WindowGenerator, some constructors, and plotting functions. The data from the WindowGenerator will be used in training. +""" +Calculates the windows used for modeling, the target index, and features useful for plotting. +""" +mutable struct WindowGenerator + train # training windows + valid # validation windows + h # historical steps in window + f # target steps in window + label_indices # indices for plotting predictions in a window + target_idx::Array{Int, 1} # indices to be predicted +end + +""" +Specify `h` historical points, `f` target points. By default, the target points are assumed to follow after all the historical points (`offset = h`). +By setting `offset = 1`, the targets for each historical point will be the next point in time. +""" +function WindowGenerator(h, f, train_df, valid_df, label_columns::Vector{String}; offset=h) + train = slidingwindow(i -> i+offset:i+offset+f-1, Array(train_df)', h, stride=1) + valid = slidingwindow(i -> i+offset:i+offset+f-1, Array(valid_df)', h, stride=1) + + label_indices = (offset + 1):(offset + f) + + target_idx = findall(x->x in label_columns, names(train_df)) + + return WindowGenerator(train, valid, h, f, label_indices, target_idx) +end + +WindowGenerator(h, f, train_df, valid_df, label_columns::String; offset=h) = + WindowGenerator(h, f, train_df, valid_df, label_columns=[label_columns]; offset=offset) + +WindowGenerator(h, f, train_df, valid_df; label_columns, offset=h) = + WindowGenerator(h, f, train_df, valid_df, label_columns; offset=offset) + +""" +Plots the historical data and the target(s) for prediction. +""" +function plot(wg::WindowGenerator) + idx = wg.target_idx[1] # Currently, will only plot the first target index but could be redone to plot all label columns. + sw = wg.valid + plots = [] + for it in 1:3 + i = rand(1:size(sw,1)) + p = plot(sw[i][1][idx, :], leg=false) + scatter!(wg.label_indices,sw[i][2][idx,:]') + it == 3 && xlabel!("Given $(wg.h)h as input, predict $(wg.f)h into the future.") + push!(plots, p) + end + plot(plots..., layout=(3,1)) +end + +# Some usage examples of WindowGenerator +WindowGenerator(6, 1, train_df, valid_df, label_columns=["T (degC)"]) +WindowGenerator(6, 1, train_df, valid_df, label_columns=["T (degC)", "Wx"]) +wg = WindowGenerator(6, 1, train_df, valid_df, label_columns="T (degC)") + +plot(wg) + +# Make a utility function for batching lazily-evaluated timeseries from slidingwindow +""" +Takes in t, which is an array of tuples of (`sequence`, `target`) where `sequence` is an array of timestamp x features, +and target is either an array or a single value. Outputs a tuple of batched + +julia> z = [([1 2 3; 2 3 4], 5), ([6 7 8; 7 8 9], 0)] +2-element Array{Tuple{Array{Int64,2},Int64},1}: + ([1 2 3; 2 3 4], 5) + ([6 7 8; 7 8 9], 0) + +julia> batch_ts(z) +([1 2 3; 2 3 4] + +[6 7 8; 7 8 9], [5] + +[0]) + +julia> size(batch_ts(z)[1]) +(2, 3, 2) + +julia> size(batch_ts(z)[2]) +(1, 1, 2) +""" +batch_ts(t) = reduce((x, y) -> (cat(x[1], y[1], dims=3), cat(x[2], y[2], dims=3)), t) +batch_ts(t::Tuple) = (unsqueeze(t[1],3), unsqueeze(t[2],3)) # handle batch size of 1 + +# To understand better what the above code does, let's look at an imitation training loop and look at everything's dimensions +practice_df = train_df[1:10,:] +a = slidingwindow(i -> i+h:i+h+f-1, Array(practice_df)', h, stride=1) + +for i in eachbatch(shuffleobs(a), size=2) + (x,y) = batch_ts(i) + @show x + @show y + println() +end + +# # Single Step Models +loss(x,y) = Flux.Losses.mse(x, y) + +# ### Baseline - 1h +struct Baseline + label_index::Int +end + +(m::Baseline)(x) = x[m.label_index,:,:] + +target = "T (degC)" + +# Since this model repeats the last point, we make slidingwindows with 1 historical and 1 target point. +single_step_1h = WindowGenerator(1, 1, train_df, valid_df, label_columns=target); + +baseline_model = Baseline(wg.target_idx[1]) + +function run_single_step_baseline(wg, model) + preds = Float32[] + reals = Float32[] + for (x,y) in wg.train + val = model(x)[1] + push!(preds, val) + push!(reals, y[model.label_index]) #figure out how to do validation + end + + l = loss(preds, reals) + return l +end + +run_single_step_baseline(single_step_1h, baseline_model) + +# ### Baseline - 24h +# Let's try to predict the next hour's value for 24 hours +single_step_24h = WindowGenerator(24, 24, train_df, valid_df, label_columns=target; offset=1); + +""" +Plots the historical window, the target(s) for prediction, and the model's predictions. +""" +function plot(wg::WindowGenerator, model; set=:valid) + data = getfield(wg,set) + i = rand(1:size(data,1)) + plot(1:wg.h, data[i][1][2,:], lab="Inputs", shape=:circ, m=2, leg=:outerright) + scatter!(wg.label_indices, data[i][2][2,:], lab="Labels", c=:green) + z = model(unsqueeze(data[i][1],3))[:] + scatter!(wg.label_indices, z, lab="Predictions", shape=:star5, m=6, c=:orange) +end + +plot(single_step_24h, baseline_model) + +# ### Linear Models +# ##### 1 hour +linear = Dense(size(single_step_1h.train[1][1],1), 1; initW=Flux.glorot_uniform, initb=Flux.zeros) +opt = Flux.Optimise.ADAM(0.01) + +function train_model!(model, wg::WindowGenerator, opt; epochs=20, bs=16, dev=Flux.gpu, conv=false) + model = model |> dev + ps = params(model) + t = shuffleobs(wg.train) + v = batch_ts(getobs(wg.valid)) + v = conv ? ((unsqueeze(v[1],3), v[2]) |> dev) : (v |> dev) # handle validation dimensions if conv network + + local l + vl_prev = Inf + for e in 1:epochs + for d in eachbatch(t, size=bs) + x, y = batch_ts(d) + y = y[wg.target_idx,:,:] + conv && (x = unsqueeze(x,3)) + x, y = x |> dev, y |> dev + gs = gradient(ps) do + l = loss(model(x),y) + end + Flux.update!(opt, ps, gs) + end + l = round(l;digits=4) + vl = round(loss(model(v[1]),v[2][wg.target_idx,:,:]); digits=4) + println("Epoch $e/$epochs - train loss: $l, valid loss: $vl") + # crude early-stopping + # vl_prev < (vl - 0.001) && break + # vl_prev = vl + end + model = model |> cpu +end + +@time linear = train_model!(linear, single_step_1h, opt; bs=32, epochs=20) + +# ##### 24 hr +plot(single_step_24h, linear) + +bar(names(train_df), linear.W[:], xrotation=30.0, legend=false, xticks=:all, tickfontsize=6) + +# ### Dense +dense = Chain( + Dense(19, 64, relu), + Dense(64, 64, relu), + Dense(64, 1) +) + +@time dense = train_model!(dense, single_step_1h, opt; bs=32, epochs=20) + +plot(single_step_24h, dense) + + +# ### Multi-step Dense +# Now we are going to use 3 historical hours to predict 1 hour in the future. +single_step_3h = WindowGenerator(3, 1, train_df, valid_df, label_columns=target); + +plot(single_step_3h) + +multi_step_dense = Chain( + i -> reshape(i, :, 1, size(i)[end]), # flatten first two dimensions, but preserve batch dimension + Dense(19*3, 32, relu), + Dense(32, 32, relu), + Dense(32, 1) +) + +@time multi_step_dense = train_model!(multi_step_dense, single_step_3h, opt; bs=32, epochs=20) + +plot(single_step_3h, multi_step_dense) + +# ### Convolutional Neural Network +conv_model = Chain( + Conv((19,3), 1=>32, relu), # need to explain why this conv pattern + x -> Flux.flatten(x), + Dense(32, 32, relu), + Dense(32, 1) +) + +single_step_3h = WindowGenerator(3, 1, train_df[1:60,:], valid_df, label_columns=target); + +@time conv_model = train_model!(conv_model, single_step_3h, opt; bs=20, epochs=2, conv=true) + + +#not learning :( but dimensions are right? +# maybe convolutions arent? + +# https://github.com/FluxML/Flux.jl/issues/1465 + + +# ### Recurrent Neural Network + +# ### Performance + +# ### Multi-output Models + +# #### Baseline + +# #### Dense + +# #### RNN + +# #### Advanced: Residual Connections + +# #### Performance + +# # Multi-Step Models + +# ### Baselines + +# ## Single-shot Models + +# ### Linear + +# ### Dense + +# ### CNN + +# ### RNN + +# ## Advanced Autoregressive model +# ### RNN + +# ## Performance + +# Next Steps From 4b256654336b9bbb800488995df4d5eee47df862 Mon Sep 17 00:00:00 2001 From: adinhobl Date: Sun, 21 Mar 2021 20:17:08 -0500 Subject: [PATCH 2/6] split up files, finish 1D conv --- tutorials/time_series/TODO | 16 +++ tutorials/time_series/batch_ts.jl | 24 ++++ tutorials/time_series/runtests.jl | 41 ++++++ tutorials/time_series/time_series.jl | 156 ++++------------------ tutorials/time_series/window_generator.jl | 64 +++++++++ 5 files changed, 173 insertions(+), 128 deletions(-) create mode 100644 tutorials/time_series/TODO create mode 100644 tutorials/time_series/batch_ts.jl create mode 100644 tutorials/time_series/runtests.jl create mode 100644 tutorials/time_series/window_generator.jl diff --git a/tutorials/time_series/TODO b/tutorials/time_series/TODO new file mode 100644 index 000000000..f88d96601 --- /dev/null +++ b/tutorials/time_series/TODO @@ -0,0 +1,16 @@ +* Handle target value better for dataset y's; Is there a way to ensure that time series always have a batched axis using MLDataPattern, esp lazily? +* Decide what level to put this tutorial at - base Flux or incorporate higher level packages? +* Make timeseries batching more idiomatic and faster. +* Add benchmarking integrations so we tell how other PRs affect this functionality. +* Put things in functions as needed +* Eachbatch - size or maxsize? what's more popular. Probably incorporate with DataLoaders.jl +* Flux on master for Dense behavior. Needs to be latest when this is published +* In train_model! is it critical to return and assign the model (`linear = train_model!(linear, single_step_1h, opt; bs=16, epochs=20)`)? I found that without doing it, Flux.update! would work during training, but then calling the model outside wouldn't be mutated? could this deal with calling params at the beginning? +* Early Stopping could use some work. Not sure it does exactly what I want it to. Could use earlystopping.jl +* Need to convert data to Float32? Without it, I get this when running conv_model. Related to Params being Float32? + ┌ Warning: Slow fallback implementation invoked for conv! You probably don't want this; check your datatypes. + │ yT = Float64 + │ T1 = Float64 + │ T2 = Float32 + └ @ NNlib ~/.julia/packages/NNlib/fxLrD/src/conv.jl:206 +* Make sure conv examples are implemented correctly. \ No newline at end of file diff --git a/tutorials/time_series/batch_ts.jl b/tutorials/time_series/batch_ts.jl new file mode 100644 index 000000000..8104b654c --- /dev/null +++ b/tutorials/time_series/batch_ts.jl @@ -0,0 +1,24 @@ +""" +Takes in t, which is an array of tuples of (`sequence`, `target`) where `sequence` is an array of timestamp x features, +and target is either an array or a single value. Outputs a tuple of batched + +julia> z = [([1 2 3; 2 3 4], 5), ([6 7 8; 7 8 9], 0)] +2-element Array{Tuple{Array{Int64,2},Int64},1}: + ([1 2 3; 2 3 4], 5) + ([6 7 8; 7 8 9], 0) + +julia> batch_ts(z) +([1 2 3; 2 3 4] + +[6 7 8; 7 8 9], [5] + +[0]) + +julia> size(batch_ts(z)[1]) +(2, 3, 2) + +julia> size(batch_ts(z)[2]) +(1, 1, 2) +""" +batch_ts(t) = reduce((x, y) -> (cat(x[1], y[1], dims=3), cat(x[2], y[2], dims=3)), t) +batch_ts(t::Tuple) = (unsqueeze(t[1],3), unsqueeze(t[2],3)) # handle batch size of 1 \ No newline at end of file diff --git a/tutorials/time_series/runtests.jl b/tutorials/time_series/runtests.jl new file mode 100644 index 000000000..b134a1ae3 --- /dev/null +++ b/tutorials/time_series/runtests.jl @@ -0,0 +1,41 @@ +using Test +using DataFrames +using Random +using Dates + +include("window_generator.jl") +include("batch_ts.jl") + +rng = MersenneTwister(123) + +df = DataFrame("timestamp"=>Date(2014,11,15):Day(1):Date(2014, 12, 31), + "A"=>randn(rng, Float16, 47), + "B"=>sin.(rand(rng, 47))) +num_train = 35 +train_df = df[1:num_train,:] +test_df = df[num_train+1:end,:] + +# WindowGenerator +@testset "historical window of length 1" begin + +end + + +@testset "multiple label columns" begin + +end + + +@testset "" begin + +end + + +# batch_ts +@testset "" begin + +end + + +WindowGenerator(6, 1, train_df, valid_df, label_columns=["T (degC)"]) +WindowGenerator(6, 1, train_df, valid_df, label_columns=["T (degC)", "Wx"]) \ No newline at end of file diff --git a/tutorials/time_series/time_series.jl b/tutorials/time_series/time_series.jl index e30f3ecd0..c4e82f58e 100644 --- a/tutorials/time_series/time_series.jl +++ b/tutorials/time_series/time_series.jl @@ -1,31 +1,9 @@ -#= TODO -* Add any Flux specific explanation -* Handle target value better for dataset y's; Is there a way to ensure that time series always have a batched axis using MLDataPattern, esp lazily? -* Decide what level we want this tutorial at - Flux or some higher level? -* Clean up and make more idiomatic - particularly on how timeseries are batched -* Make any tests or integrations -* Put things in functions as needed -* Eachbatch - size or maxsize? what's more popular -* Flux on master for Dense behavior. Needs to be latest when this is published -* In train_model! is it critical to return and assign the model (`linear = train_model!(linear, single_step_1h, opt; bs=16, epochs=20)`)? I found that without doing it, Flux.update! would work during training, but then calling the model outside wouldn't be mutated? could this deal with calling params at the beginning? -* Early Stopping could use some work. Not sure it does exactly what I want it to -* Need to convert data to Float32? Without it, I get this when running conv_model. Related to Params being Float32? - ┌ Warning: Slow fallback implementation invoked for conv! You probably don't want this; check your datatypes. - │ yT = Float64 - │ T1 = Float64 - │ T2 = Float32 - └ @ NNlib ~/.julia/packages/NNlib/fxLrD/src/conv.jl:206 - ------------------------------------------------------------------------- -=# - # # Time series forecasting # This tutorial serves as a `Julia` implementation of the Tensorflow time series forecasting tutorial here: # # [Tensorflow Time Series Forecasting Tutorial](https://www.tensorflow.org/tutorials/structured_data/time_series) # ## Setup - using ZipFile using CSV using DataFrames @@ -39,7 +17,6 @@ using MLDataPattern using Random: seed! using Statistics: mean, std using Flux: unsqueeze -import StatsPlots: plot seed!(4231) ENV["LINES"] = 20 @@ -150,101 +127,28 @@ df_std = (df .- train_mean') ./ train_std' df_std = stack(df_std) violin(df_std.variable, df_std.value, xrotation=30.0, legend=false, xticks=:all) # use plotattr() to learn about keywords - boxplot!(df_std.variable, df_std.value, fillalpha=0.75, outliers=false) # ## Data Windowing -# We are going to make use of MLDataPattern's `slidingwindow` to generate the windows -# https://mldatapatternjl.readthedocs.io/en/latest/documentation/dataview.html?highlight=slidingwindow#labeled-windows -h = 6 # historical window length -f = 1 # future window length - -train_loader = slidingwindow(i -> i+h:i+h+f-1, Array(train_df)', h, stride=1) - # We will define our own WindowGenerator, some constructors, and plotting functions. The data from the WindowGenerator will be used in training. -""" -Calculates the windows used for modeling, the target index, and features useful for plotting. -""" -mutable struct WindowGenerator - train # training windows - valid # validation windows - h # historical steps in window - f # target steps in window - label_indices # indices for plotting predictions in a window - target_idx::Array{Int, 1} # indices to be predicted -end +include("window_generator.jl") -""" -Specify `h` historical points, `f` target points. By default, the target points are assumed to follow after all the historical points (`offset = h`). -By setting `offset = 1`, the targets for each historical point will be the next point in time. -""" -function WindowGenerator(h, f, train_df, valid_df, label_columns::Vector{String}; offset=h) - train = slidingwindow(i -> i+offset:i+offset+f-1, Array(train_df)', h, stride=1) - valid = slidingwindow(i -> i+offset:i+offset+f-1, Array(valid_df)', h, stride=1) - - label_indices = (offset + 1):(offset + f) - - target_idx = findall(x->x in label_columns, names(train_df)) - - return WindowGenerator(train, valid, h, f, label_indices, target_idx) -end +h = 6 # historical window length +f = 1 # future window length -WindowGenerator(h, f, train_df, valid_df, label_columns::String; offset=h) = - WindowGenerator(h, f, train_df, valid_df, label_columns=[label_columns]; offset=offset) - -WindowGenerator(h, f, train_df, valid_df; label_columns, offset=h) = - WindowGenerator(h, f, train_df, valid_df, label_columns; offset=offset) - -""" -Plots the historical data and the target(s) for prediction. -""" -function plot(wg::WindowGenerator) - idx = wg.target_idx[1] # Currently, will only plot the first target index but could be redone to plot all label columns. - sw = wg.valid - plots = [] - for it in 1:3 - i = rand(1:size(sw,1)) - p = plot(sw[i][1][idx, :], leg=false) - scatter!(wg.label_indices,sw[i][2][idx,:]') - it == 3 && xlabel!("Given $(wg.h)h as input, predict $(wg.f)h into the future.") - push!(plots, p) - end - plot(plots..., layout=(3,1)) -end +# WindowGenerator makes use of MLDataPattern's `slidingwindow` to generate the windows. It is good at flexibly generating +# https://mldatapatternjl.readthedocs.io/en/latest/documentation/dataview.html?highlight=slidingwindow#labeled-windows +slidingwindow(i -> i+h:i+h+f-1, Array(train_df)', h, stride=1) -# Some usage examples of WindowGenerator -WindowGenerator(6, 1, train_df, valid_df, label_columns=["T (degC)"]) -WindowGenerator(6, 1, train_df, valid_df, label_columns=["T (degC)", "Wx"]) +# How to use WindowGenerator wg = WindowGenerator(6, 1, train_df, valid_df, label_columns="T (degC)") - plot(wg) -# Make a utility function for batching lazily-evaluated timeseries from slidingwindow -""" -Takes in t, which is an array of tuples of (`sequence`, `target`) where `sequence` is an array of timestamp x features, -and target is either an array or a single value. Outputs a tuple of batched - -julia> z = [([1 2 3; 2 3 4], 5), ([6 7 8; 7 8 9], 0)] -2-element Array{Tuple{Array{Int64,2},Int64},1}: - ([1 2 3; 2 3 4], 5) - ([6 7 8; 7 8 9], 0) - -julia> batch_ts(z) -([1 2 3; 2 3 4] - -[6 7 8; 7 8 9], [5] -[0]) +# We will also make use of the utility function for batching lazily-evaluated timeseries from slidingwindow +include("batch_ts.jl") -julia> size(batch_ts(z)[1]) -(2, 3, 2) - -julia> size(batch_ts(z)[2]) -(1, 1, 2) -""" -batch_ts(t) = reduce((x, y) -> (cat(x[1], y[1], dims=3), cat(x[2], y[2], dims=3)), t) -batch_ts(t::Tuple) = (unsqueeze(t[1],3), unsqueeze(t[2],3)) # handle batch size of 1 # To understand better what the above code does, let's look at an imitation training loop and look at everything's dimensions practice_df = train_df[1:10,:] @@ -293,20 +197,9 @@ run_single_step_baseline(single_step_1h, baseline_model) # Let's try to predict the next hour's value for 24 hours single_step_24h = WindowGenerator(24, 24, train_df, valid_df, label_columns=target; offset=1); -""" -Plots the historical window, the target(s) for prediction, and the model's predictions. -""" -function plot(wg::WindowGenerator, model; set=:valid) - data = getfield(wg,set) - i = rand(1:size(data,1)) - plot(1:wg.h, data[i][1][2,:], lab="Inputs", shape=:circ, m=2, leg=:outerright) - scatter!(wg.label_indices, data[i][2][2,:], lab="Labels", c=:green) - z = model(unsqueeze(data[i][1],3))[:] - scatter!(wg.label_indices, z, lab="Predictions", shape=:star5, m=6, c=:orange) -end - plot(single_step_24h, baseline_model) + # ### Linear Models # ##### 1 hour linear = Dense(size(single_step_1h.train[1][1],1), 1; initW=Flux.glorot_uniform, initb=Flux.zeros) @@ -317,7 +210,7 @@ function train_model!(model, wg::WindowGenerator, opt; epochs=20, bs=16, dev=Flu ps = params(model) t = shuffleobs(wg.train) v = batch_ts(getobs(wg.valid)) - v = conv ? ((unsqueeze(v[1],3), v[2]) |> dev) : (v |> dev) # handle validation dimensions if conv network + # v = conv ? ((unsqueeze(v[1],3), v[2]) |> dev) : (v |> dev) # handle validation dimensions if conv network local l vl_prev = Inf @@ -325,7 +218,7 @@ function train_model!(model, wg::WindowGenerator, opt; epochs=20, bs=16, dev=Flu for d in eachbatch(t, size=bs) x, y = batch_ts(d) y = y[wg.target_idx,:,:] - conv && (x = unsqueeze(x,3)) + # conv && (x = unsqueeze(x,3)) x, y = x |> dev, y |> dev gs = gradient(ps) do l = loss(model(x),y) @@ -379,22 +272,29 @@ multi_step_dense = Chain( plot(single_step_3h, multi_step_dense) # ### Convolutional Neural Network + +# conv_model = Chain( +# Conv((19,), 3=>32, relu), # need to explain why this conv pattern +# x -> Flux.flatten(x), +# Dense(32, 32, relu), +# Dense(32, 1), +# x -> unsqueeze(x, 1) +# ) + conv_model = Chain( - Conv((19,3), 1=>32, relu), # need to explain why this conv pattern + x -> permutedims(x, [2,1,3]), # put data in NTime x NCovariates X NBatch https://github.com/FluxML/Flux.jl/issues/1465 + Conv((3,), 19=>32, relu), # convolve over 3 inputs - 19 variables -> 32 filters x -> Flux.flatten(x), Dense(32, 32, relu), - Dense(32, 1) + Dense(32, 1), + x -> unsqueeze(x, 1) ) -single_step_3h = WindowGenerator(3, 1, train_df[1:60,:], valid_df, label_columns=target); - -@time conv_model = train_model!(conv_model, single_step_3h, opt; bs=20, epochs=2, conv=true) - +single_step_3h = WindowGenerator(3, 1, train_df, valid_df, label_columns=target); -#not learning :( but dimensions are right? -# maybe convolutions arent? +@time conv_model = train_model!(conv_model, single_step_3h, opt; bs=32, epochs=20, conv=true) -# https://github.com/FluxML/Flux.jl/issues/1465 +plot(single_step_3h, conv_model) # ### Recurrent Neural Network diff --git a/tutorials/time_series/window_generator.jl b/tutorials/time_series/window_generator.jl new file mode 100644 index 000000000..0ac2531da --- /dev/null +++ b/tutorials/time_series/window_generator.jl @@ -0,0 +1,64 @@ +import StatsPlots: plot + +""" +Calculates the windows used for modeling, the target index, and features useful for plotting. +""" +mutable struct WindowGenerator + train # training windows + valid # validation windows + h # historical steps in window + f # target steps in window + label_indices # indices for plotting predictions in a window + target_idx::Array{Int, 1} # indices to be predicted +end + +""" +Specify `h` historical points, `f` target points. By default, the target points are assumed to follow after all the historical points (`offset = h`). +By setting `offset = 1`, the targets for each historical point will be the next point in time. +""" +function WindowGenerator(h, f, train_df, valid_df, label_columns::Vector{String}; offset=h) + train = slidingwindow(i -> i+offset:i+offset+f-1, Array(train_df)', h, stride=1) + valid = slidingwindow(i -> i+offset:i+offset+f-1, Array(valid_df)', h, stride=1) + + label_indices = (offset + 1):(offset + f) + + target_idx = findall(x->x in label_columns, names(train_df)) + + return WindowGenerator(train, valid, h, f, label_indices, target_idx) +end + +WindowGenerator(h, f, train_df, valid_df, label_columns::String; offset=h) = + WindowGenerator(h, f, train_df, valid_df, label_columns=[label_columns]; offset=offset) + +WindowGenerator(h, f, train_df, valid_df; label_columns, offset=h) = + WindowGenerator(h, f, train_df, valid_df, label_columns; offset=offset) + +""" +Plots the historical data and the target(s) for prediction. +""" +function plot(wg::WindowGenerator) + idx = wg.target_idx[1] # Currently, will only plot the first target index but could be redone to plot all label columns. + sw = wg.valid + plots = [] + for it in 1:3 + i = rand(1:size(sw,1)) + p = plot(sw[i][1][idx, :], leg=false) + scatter!(wg.label_indices,sw[i][2][idx,:]') + it == 3 && xlabel!("Given $(wg.h)h as input, predict $(wg.f)h into the future.") + push!(plots, p) + end + plot(plots..., layout=(3,1)) +end + + +""" +Plots the historical window, the target(s) for prediction, and the model's predictions. +""" +function plot(wg::WindowGenerator, model; set=:valid) + data = getfield(wg,set) + i = rand(1:size(data,1)) + plot(1:wg.h, data[i][1][2,:], lab="Inputs", shape=:circ, m=2, leg=:outerright) + scatter!(wg.label_indices, data[i][2][2,:], lab="Labels", c=:green) + z = model(unsqueeze(data[i][1],3))[:] + scatter!(wg.label_indices, z, lab="Predictions", shape=:star5, m=6, c=:orange) +end \ No newline at end of file From 7f225aa827e7e26a65c7c26e5b2e75ba0925272b Mon Sep 17 00:00:00 2001 From: adinhobl Date: Sun, 21 Mar 2021 23:00:55 -0500 Subject: [PATCH 3/6] update tests --- tutorials/time_series/runtests.jl | 42 ++++++++++++++--------- tutorials/time_series/window_generator.jl | 7 ++++ 2 files changed, 32 insertions(+), 17 deletions(-) diff --git a/tutorials/time_series/runtests.jl b/tutorials/time_series/runtests.jl index b134a1ae3..782ac131f 100644 --- a/tutorials/time_series/runtests.jl +++ b/tutorials/time_series/runtests.jl @@ -3,39 +3,47 @@ using DataFrames using Random using Dates -include("window_generator.jl") -include("batch_ts.jl") - rng = MersenneTwister(123) -df = DataFrame("timestamp"=>Date(2014,11,15):Day(1):Date(2014, 12, 31), - "A"=>randn(rng, Float16, 47), - "B"=>sin.(rand(rng, 47))) -num_train = 35 -train_df = df[1:num_train,:] -test_df = df[num_train+1:end,:] +times = 150 +df = DataFrame("timestamp"=>1:times, + "A"=>randn(rng, Float16, times), + "B"=>sin.(rand(rng, times)), + "C"=>1:times) +train_prop = 0.8 +train_end = Int(times*train_prop) +train_df = df[1:train_end,:] +valid_df = df[train_end+1:end,:] + # WindowGenerator +include("window_generator.jl") @testset "historical window of length 1" begin - + h = 1 + f = 1 + wg = WindowGenerator(h, f, train_df, valid_df, "C") + @test wg.target_idx == [4] + @test size(wg.train[1][1]) == (4,1) + @test size(wg.valid[1][1]) == (4,1) + @test length(wg.train) == 119 + @test length(wg.valid) == 29 + @test (wg.train[1][1][1]) == (wg.train[1][2][1] - 1) + @test (wg.train[end][1][1]) == (wg.train[end][2][1] - 1) end -@testset "multiple label columns" begin +@testset "historical window of length 10" begin end -@testset "" begin +@testset "multiple label columns" begin end # batch_ts +include("batch_ts.jl") @testset "" begin -end - - -WindowGenerator(6, 1, train_df, valid_df, label_columns=["T (degC)"]) -WindowGenerator(6, 1, train_df, valid_df, label_columns=["T (degC)", "Wx"]) \ No newline at end of file +end \ No newline at end of file diff --git a/tutorials/time_series/window_generator.jl b/tutorials/time_series/window_generator.jl index 0ac2531da..e3b6eb8b5 100644 --- a/tutorials/time_series/window_generator.jl +++ b/tutorials/time_series/window_generator.jl @@ -1,3 +1,4 @@ +using MLDataPattern: slidingwindow import StatsPlots: plot """ @@ -27,9 +28,15 @@ function WindowGenerator(h, f, train_df, valid_df, label_columns::Vector{String} return WindowGenerator(train, valid, h, f, label_indices, target_idx) end +""" +WindowGenerator with a single label_column. +""" WindowGenerator(h, f, train_df, valid_df, label_columns::String; offset=h) = WindowGenerator(h, f, train_df, valid_df, label_columns=[label_columns]; offset=offset) +""" +WindowGenerator with multiple label_columns. +""" WindowGenerator(h, f, train_df, valid_df; label_columns, offset=h) = WindowGenerator(h, f, train_df, valid_df, label_columns; offset=offset) From 900c3845358b73169963737361e894879a8cfd3e Mon Sep 17 00:00:00 2001 From: adinhobl Date: Sun, 21 Mar 2021 23:01:51 -0500 Subject: [PATCH 4/6] remove conv from training loop --- tutorials/time_series/time_series.jl | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/tutorials/time_series/time_series.jl b/tutorials/time_series/time_series.jl index c4e82f58e..9457e524a 100644 --- a/tutorials/time_series/time_series.jl +++ b/tutorials/time_series/time_series.jl @@ -205,12 +205,11 @@ plot(single_step_24h, baseline_model) linear = Dense(size(single_step_1h.train[1][1],1), 1; initW=Flux.glorot_uniform, initb=Flux.zeros) opt = Flux.Optimise.ADAM(0.01) -function train_model!(model, wg::WindowGenerator, opt; epochs=20, bs=16, dev=Flux.gpu, conv=false) +function train_model!(model, wg::WindowGenerator, opt; epochs=20, bs=16, dev=Flux.gpu) model = model |> dev ps = params(model) t = shuffleobs(wg.train) v = batch_ts(getobs(wg.valid)) - # v = conv ? ((unsqueeze(v[1],3), v[2]) |> dev) : (v |> dev) # handle validation dimensions if conv network local l vl_prev = Inf @@ -218,7 +217,6 @@ function train_model!(model, wg::WindowGenerator, opt; epochs=20, bs=16, dev=Flu for d in eachbatch(t, size=bs) x, y = batch_ts(d) y = y[wg.target_idx,:,:] - # conv && (x = unsqueeze(x,3)) x, y = x |> dev, y |> dev gs = gradient(ps) do l = loss(model(x),y) From 250f5936be3bbac8893ac772662bbf337b22e1b4 Mon Sep 17 00:00:00 2001 From: adinhobl Date: Mon, 22 Mar 2021 21:47:11 -0500 Subject: [PATCH 5/6] separate & add tests --- tutorials/time_series/batch_ts.jl | 9 ++- tutorials/time_series/runtests.jl | 49 ------------- tutorials/time_series/runtests_batch.jl | 45 ++++++++++++ tutorials/time_series/runtests_wg.jl | 91 +++++++++++++++++++++++++ tutorials/time_series/time_series.jl | 2 +- 5 files changed, 145 insertions(+), 51 deletions(-) delete mode 100644 tutorials/time_series/runtests.jl create mode 100644 tutorials/time_series/runtests_batch.jl create mode 100644 tutorials/time_series/runtests_wg.jl diff --git a/tutorials/time_series/batch_ts.jl b/tutorials/time_series/batch_ts.jl index 8104b654c..6c0afd9f9 100644 --- a/tutorials/time_series/batch_ts.jl +++ b/tutorials/time_series/batch_ts.jl @@ -1,3 +1,5 @@ +using Flux: unsqueeze + """ Takes in t, which is an array of tuples of (`sequence`, `target`) where `sequence` is an array of timestamp x features, and target is either an array or a single value. Outputs a tuple of batched @@ -21,4 +23,9 @@ julia> size(batch_ts(z)[2]) (1, 1, 2) """ batch_ts(t) = reduce((x, y) -> (cat(x[1], y[1], dims=3), cat(x[2], y[2], dims=3)), t) -batch_ts(t::Tuple) = (unsqueeze(t[1],3), unsqueeze(t[2],3)) # handle batch size of 1 \ No newline at end of file + + +""" +Handles batch of size 1, with a (`sequence`, `target`) tuple +""" +batch_ts(t::Tuple) = (unsqueeze(t[1],3), unsqueeze(t[2],3)) \ No newline at end of file diff --git a/tutorials/time_series/runtests.jl b/tutorials/time_series/runtests.jl deleted file mode 100644 index 782ac131f..000000000 --- a/tutorials/time_series/runtests.jl +++ /dev/null @@ -1,49 +0,0 @@ -using Test -using DataFrames -using Random -using Dates - -rng = MersenneTwister(123) - -times = 150 -df = DataFrame("timestamp"=>1:times, - "A"=>randn(rng, Float16, times), - "B"=>sin.(rand(rng, times)), - "C"=>1:times) -train_prop = 0.8 -train_end = Int(times*train_prop) -train_df = df[1:train_end,:] -valid_df = df[train_end+1:end,:] - - -# WindowGenerator -include("window_generator.jl") -@testset "historical window of length 1" begin - h = 1 - f = 1 - wg = WindowGenerator(h, f, train_df, valid_df, "C") - @test wg.target_idx == [4] - @test size(wg.train[1][1]) == (4,1) - @test size(wg.valid[1][1]) == (4,1) - @test length(wg.train) == 119 - @test length(wg.valid) == 29 - @test (wg.train[1][1][1]) == (wg.train[1][2][1] - 1) - @test (wg.train[end][1][1]) == (wg.train[end][2][1] - 1) -end - - -@testset "historical window of length 10" begin - -end - - -@testset "multiple label columns" begin - -end - - -# batch_ts -include("batch_ts.jl") -@testset "" begin - -end \ No newline at end of file diff --git a/tutorials/time_series/runtests_batch.jl b/tutorials/time_series/runtests_batch.jl new file mode 100644 index 000000000..470cf157f --- /dev/null +++ b/tutorials/time_series/runtests_batch.jl @@ -0,0 +1,45 @@ +using Test + +include("batch_ts.jl") + +@testset "multi batch - single element y" begin + for _ in 1:100 + dim1 = rand(1:20) + dim2 = rand(1:20) + num = rand(2:100) # single item batch not used with single element + + tups = [(rand(dim1, dim2), rand()) for i in 1:num] + b_tups = batch_ts(tups) + @test b_tups |> length == 2 + @test size(b_tups[1]) == (dim1, dim2, num) + @test size(b_tups[2]) == (1, 1, num) + end +end + +@testset "multi batch - multi element y" begin + for _ in 1:100 + dim1 = rand(1:20) + dim2 = rand(1:20) + dim3 = rand(1:20) + dim4 = rand(1:20) + num = rand(2:100) # single item batch + + tups = [(rand(dim1, dim2), rand(dim3, dim4)) for i in 1:num] + b_tups = batch_ts(tups) + @test b_tups |> length == 2 + @test size(b_tups[1]) == (dim1, dim2, num) + @test size(b_tups[2]) == (dim3, dim4, num) + end +end + +@testset "single item batch" begin + for _ in 1:100 + dim1 = rand(1:20) + dim2 = rand(1:20) + + tups = (rand(dim1, dim2), rand(dim1, 1)) + b_tups = batch_ts(tups) + @test ndims(b_tups[1]) == ndims(b_tups[2]) == 3 + end +end + diff --git a/tutorials/time_series/runtests_wg.jl b/tutorials/time_series/runtests_wg.jl new file mode 100644 index 000000000..0cd010649 --- /dev/null +++ b/tutorials/time_series/runtests_wg.jl @@ -0,0 +1,91 @@ +using Test +using DataFrames +using Random +using Dates + +rng = MersenneTwister(123) + +times = 150 +df = DataFrame("timestamp"=>1:times, + "A"=>randn(rng, Float16, times), + "B"=>sin.(rand(rng, times)), + "C"=>1:times) +train_prop = 0.8 +train_end = Int(times*train_prop) +train_df = df[1:train_end,:] +valid_df = df[train_end+1:end,:] + + +include("window_generator.jl") +@testset "historical window of length 1, future window 1" begin + h = 1 + f = 1 + wg = WindowGenerator(h, f, train_df, valid_df, "C") + @test wg.target_idx == [4] + @test size(wg.train[1][1]) == (length(names(df)),h) + @test size(wg.valid[1][1]) == (length(names(df)),h) + @test length(wg.train) == train_end - (h+f-1) # truncates necessary first and last sequence points + @test length(wg.valid) == times - train_end - (h+f-1) + @test (wg.train[1][1][1]) == (wg.train[1][2][1] - h) + @test (wg.train[end][1][1]) == (wg.train[end][2][1] - h) + @test wg.train[end][1][1,end] == (wg.train[end][2][1,begin] - 1) # 1st pred is immediately after last hist + +end + +@testset "historical window of length 7, future window 5" begin + h = 7 + f = 5 + wg = WindowGenerator(h, f, train_df, valid_df, "C") + @test wg.target_idx == [4] + @test size(wg.train[1][1]) == (length(names(df)),h) + @test size(wg.valid[1][1]) == (length(names(df)),h) + @test length(wg.train) == train_end - (h+f-1) + @test length(wg.valid) == times - train_end - (h+f-1) + @test (wg.train[1][1][1]) == (wg.train[1][2][1] - h) + @test (wg.train[end][1][1]) == (wg.train[end][2][1] - h) + @test wg.train[end][1][1,end] == (wg.train[end][2][1,begin] - 1) # 1st pred is immediately after last hist +end + +@testset "multiple label columns" begin + h = 16 + f = 3 + wg = WindowGenerator(h, f, train_df, valid_df, "C") + @test length(wg.target_idx) == 1 + wg = WindowGenerator(h, f, train_df, valid_df, ["A","C"]) + @test length(wg.target_idx) == 2 + wg = WindowGenerator(h, f, train_df, valid_df, ["A","C","B"]) + @test length(wg.target_idx) == 3 + wg = WindowGenerator(h, f, train_df, valid_df, ["timestamp","A","C","B"]) + @test length(wg.target_idx) == 4 +end + +@testset "ignores nonexistent/duplicate columns" begin + h = 5 + f = 3 + wg = WindowGenerator(h, f, train_df, valid_df, ["timestamp","A","C","B","D"]) + @test length(wg.target_idx) == 4 + + wg = WindowGenerator(h, f, train_df, valid_df, ["timestamp","timestamp"]) + @test length(wg.target_idx) == 1 +end + +@testset "labels_indices are correct" begin + valid_end = times - train_end # limited by size of validation set + for h in 1:(valid_end - 1) + for f in 1:(valid_end - h) + wg = WindowGenerator(h, f, train_df, valid_df, ["timestamp","A","C","B"]) + @test f == length(wg.label_indices) + @test first(wg.label_indices) == h + 1 + @test last(wg.label_indices) == h + f + end + end +end + + + + +# batch_ts +include("batch_ts.jl") +@testset "" begin + +end \ No newline at end of file diff --git a/tutorials/time_series/time_series.jl b/tutorials/time_series/time_series.jl index 9457e524a..448385663 100644 --- a/tutorials/time_series/time_series.jl +++ b/tutorials/time_series/time_series.jl @@ -290,7 +290,7 @@ conv_model = Chain( single_step_3h = WindowGenerator(3, 1, train_df, valid_df, label_columns=target); -@time conv_model = train_model!(conv_model, single_step_3h, opt; bs=32, epochs=20, conv=true) +@time conv_model = train_model!(conv_model, single_step_3h, opt; bs=32, epochs=20) plot(single_step_3h, conv_model) From dfeb917cda264d11f03f454f0e0e6921e2c6cdf9 Mon Sep 17 00:00:00 2001 From: adinhobl Date: Tue, 23 Mar 2021 23:13:54 -0500 Subject: [PATCH 6/6] add notebook, update script --- tutorials/time_series/time_series.ipynb | 19314 ++++++++++++++++++++ tutorials/time_series/time_series.jl | 107 +- tutorials/time_series/window_generator.jl | 10 +- 3 files changed, 19399 insertions(+), 32 deletions(-) create mode 100644 tutorials/time_series/time_series.ipynb diff --git a/tutorials/time_series/time_series.ipynb b/tutorials/time_series/time_series.ipynb new file mode 100644 index 000000000..f060b60a0 --- /dev/null +++ b/tutorials/time_series/time_series.ipynb @@ -0,0 +1,19314 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Time series forecasting\n", + "This tutorial is inspired by a [Tensorflow Time Series Forecasting Tutorial](https://www.tensorflow.org/tutorials/structured_data/time_series).\n", + "It implements the data analysis, plotting, and model training from scratch using Julia tools such as Plots.jl, Flux, and DataFrames.jl." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Setup\n", + "Importing the usual suspects. Two interesting notes:\n", + "* StatsPlots re-exports Plots.jl functions, so we don't need that separately\n", + "* MLDataPattern is useful for preprocessing data for ML in a lazy (read: non-memory intensive) way. We will be seeing more of it" + ], + "metadata": {} + }, + { + "outputs": [], + "cell_type": "code", + "source": [ + "using ZipFile\n", + "using CSV\n", + "using DataFrames\n", + "using StatsPlots\n", + "using Dates\n", + "using FFTW\n", + "using CUDA\n", + "using Flux\n", + "using MLDataPattern\n", + "\n", + "using Random: seed!\n", + "using Statistics: mean, std\n", + "using Flux: unsqueeze" + ], + "metadata": {}, + "execution_count": 1 + }, + { + "cell_type": "markdown", + "source": [ + "Set a seed to make this reproducible." + ], + "metadata": {} + }, + { + "outputs": [], + "cell_type": "code", + "source": [ + "seed!(4231)\n", + "\n", + "ENV[\"LINES\"] = 20;" + ], + "metadata": {}, + "execution_count": 2 + }, + { + "cell_type": "markdown", + "source": [ + "Disallow scalar indexing for CUDA - prevents slow accesses to GPU memory" + ], + "metadata": {} + }, + { + "outputs": [], + "cell_type": "code", + "source": [ + "CUDA.allowscalar(false)" + ], + "metadata": {}, + "execution_count": 3 + }, + { + "cell_type": "markdown", + "source": [ + "## The weather dataset\n", + "We are going to be using weather data for 7 years from the Max Planck Institute: https://www.bgc-jena.mpg.de/wetter/" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "download_data (generic function with 1 method)" + }, + "metadata": {}, + "execution_count": 4 + } + ], + "cell_type": "code", + "source": [ + "function download_data(; fname=\"jena_climate_2009_2016.zip\")\n", + " DATA_PATH = \"https://storage.googleapis.com/tensorflow/tf-keras-datasets/jena_climate_2009_2016.csv.zip\"\n", + " isfile(fname) || download(DATA_PATH, fname)\n", + "\n", + " zip = ZipFile.Reader(fname)\n", + " csv = zip.files[1]\n", + " df = CSV.File(csv) |> DataFrame\n", + " close(zip)\n", + " return df\n", + "end" + ], + "metadata": {}, + "execution_count": 4 + }, + { + "cell_type": "markdown", + "source": [ + "More discussion on reading zipped CSVs here: https://juliadata.github.io/CSV.jl/stable/index.html#Example:-reading-from-a-zip-file-1" + ], + "metadata": {} + }, + { + "outputs": [], + "cell_type": "code", + "source": [ + "df = download_data();\n", + "\n", + "df = df[6:6:end, :]\n", + "\n", + "df[!,\"Date Time\"] = Dates.DateTime.(df[:,\"Date Time\"], \"dd.mm.yyyy HH:MM:SS\");" + ], + "metadata": {}, + "execution_count": 5 + }, + { + "cell_type": "markdown", + "source": [ + "More info on working with dates and times: https://en.wikibooks.org/wiki/Introducing_Julia/Working_with_dates_and_times" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "\u001b[1m70091×4 DataFrame\u001b[0m\n\u001b[1m Row \u001b[0m│\u001b[1m Date Time \u001b[0m\u001b[1m T (degC) \u001b[0m\u001b[1m p (mbar) \u001b[0m\u001b[1m rho (g/m**3) \u001b[0m\n\u001b[1m \u001b[0m│\u001b[90m DateTime \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n───────┼───────────────────────────────────────────────────────\n 1 │ 2009-01-01T01:00:00 -8.05 996.5 1307.86\n 2 │ 2009-01-01T02:00:00 -8.88 996.62 1312.25\n 3 │ 2009-01-01T03:00:00 -8.81 996.84 1312.18\n 4 │ 2009-01-01T04:00:00 -9.05 996.99 1313.61\n 5 │ 2009-01-01T05:00:00 -9.63 997.46 1317.19\n 6 │ 2009-01-01T06:00:00 -9.67 997.71 1317.71\n ⋮ │ ⋮ ⋮ ⋮ ⋮\n 70087 │ 2016-12-31T19:10:00 -0.98 1002.18 1280.7\n 70088 │ 2016-12-31T20:10:00 -1.4 1001.4 1281.87\n 70089 │ 2016-12-31T21:10:00 -2.75 1001.19 1288.02\n 70090 │ 2016-12-31T22:10:00 -2.89 1000.65 1288.03\n 70091 │ 2016-12-31T23:10:00 -3.93 1000.11 1292.41\n\u001b[36m 70080 rows omitted\u001b[0m", + "text/html": [ + "

70,091 rows × 4 columns

Date TimeT (degC)p (mbar)rho (g/m**3)
DateTimeFloat64Float64Float64
12009-01-01T01:00:00-8.05996.51307.86
22009-01-01T02:00:00-8.88996.621312.25
32009-01-01T03:00:00-8.81996.841312.18
42009-01-01T04:00:00-9.05996.991313.61
52009-01-01T05:00:00-9.63997.461317.19
62009-01-01T06:00:00-9.67997.711317.71
72009-01-01T07:00:00-9.17998.331315.98
82009-01-01T08:00:00-8.1999.171311.65
92009-01-01T09:00:00-7.66999.691310.14
102009-01-01T10:00:00-7.041000.271307.76
112009-01-01T11:00:00-7.411000.871310.43
122009-01-01T12:00:00-6.871000.31306.98
132009-01-01T13:00:00-5.891000.031301.73
142009-01-01T14:00:00-5.94999.811301.67
152009-01-01T15:00:00-5.69999.881300.51
162009-01-01T16:00:00-5.4999.941299.17
172009-01-01T17:00:00-5.371000.171299.27
182009-01-01T18:00:00-5.251000.161298.68
192009-01-01T19:00:00-5.111000.221298.07
202009-01-01T20:00:00-4.91000.221297.05
⋮⋮⋮⋮⋮
" + ] + }, + "metadata": {}, + "execution_count": 6 + } + ], + "cell_type": "code", + "source": [ + "col = [\"Date Time\", \"T (degC)\", \"p (mbar)\", \"rho (g/m**3)\"]\n", + "\n", + "df[:,col]" + ], + "metadata": {}, + "execution_count": 6 + }, + { + "cell_type": "markdown", + "source": [ + "One easy way to plot data from a datafrom is with the StatsPlots `@df` macro" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Plot{Plots.GRBackend() n=3}", + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ], + "cell_type": "code", + "source": [ + "@df df plot(cols(1), cols(2:4); layout=(3, 1))\n", + "\n", + "@df df[1:480,:] plot(cols(1), cols(2:4); layout=(3, 1))" + ], + "metadata": {}, + "execution_count": 7 + }, + { + "cell_type": "markdown", + "source": [ + "## Inspect and cleanup" + ], + "metadata": {} + }, + { + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "describe(df) = 15×7 DataFrame\n", + " Row │ variable mean min median max nmissing eltype\n", + " │ Symbol Union… Any Union… Any Int64 DataType\n", + "─────┼────────────────────────────────────────────────────────────────────────────────────────────────\n", + " 1 │ Date Time 2009-01-01T01:00:00 2016-12-31T23:10:00 0 DateTime\n", + " 2 │ p (mbar) 989.213 913.6 989.57 1015.29 0 Float64\n", + " 3 │ T (degC) 9.45048 -22.76 9.41 37.28 0 Float64\n", + " 4 │ Tpot (K) 283.493 250.85 283.46 311.21 0 Float64\n", + " 5 │ Tdew (degC) 4.95647 -24.8 5.21 23.06 0 Float64\n", + " 6 │ rh (%) 76.0098 13.88 79.3 100.0 0 Float64\n", + " 7 │ VPmax (mbar) 13.5766 0.97 11.82 63.77 0 Float64\n", + " 8 │ VPact (mbar) 9.53397 0.81 8.86 28.25 0 Float64\n", + " 9 │ VPdef (mbar) 4.04254 0.0 2.19 46.01 0 Float64\n", + " 10 │ sh (g/kg) 6.02256 0.51 5.59 18.07 0 Float64\n", + " 11 │ H2OC (mmol/mol) 9.64044 0.81 8.96 28.74 0 Float64\n", + " 12 │ rho (g/m**3) 1216.06 1059.45 1213.8 1393.54 0 Float64\n", + " 13 │ wv (m/s) 1.70257 -9999.0 1.76 14.01 0 Float64\n", + " 14 │ max. wv (m/s) 2.96304 -9999.0 2.98 23.5 0 Float64\n", + " 15 │ wd (deg) 174.789 0.0 198.1 360.0 0 Float64\n" + ] + } + ], + "cell_type": "code", + "source": [ + "@show describe(df)\n", + "\n", + "df.\"p (mbar)\"; #cool that this works" + ], + "metadata": {}, + "execution_count": 8 + }, + { + "cell_type": "markdown", + "source": [ + "Need to replace bad database values" + ], + "metadata": {} + }, + { + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "describe(df) = 15×7 DataFrame\n", + " Row │ variable mean min median max nmissing eltype\n", + " │ Symbol Union… Any Union… Any Int64 DataType\n", + "─────┼────────────────────────────────────────────────────────────────────────────────────────────────\n", + " 1 │ Date Time 2009-01-01T01:00:00 2016-12-31T23:10:00 0 DateTime\n", + " 2 │ p (mbar) 989.213 913.6 989.57 1015.29 0 Float64\n", + " 3 │ T (degC) 9.45048 -22.76 9.41 37.28 0 Float64\n", + " 4 │ Tpot (K) 283.493 250.85 283.46 311.21 0 Float64\n", + " 5 │ Tdew (degC) 4.95647 -24.8 5.21 23.06 0 Float64\n", + " 6 │ rh (%) 76.0098 13.88 79.3 100.0 0 Float64\n", + " 7 │ VPmax (mbar) 13.5766 0.97 11.82 63.77 0 Float64\n", + " 8 │ VPact (mbar) 9.53397 0.81 8.86 28.25 0 Float64\n", + " 9 │ VPdef (mbar) 4.04254 0.0 2.19 46.01 0 Float64\n", + " 10 │ sh (g/kg) 6.02256 0.51 5.59 18.07 0 Float64\n", + " 11 │ H2OC (mmol/mol) 9.64044 0.81 8.96 28.74 0 Float64\n", + " 12 │ rho (g/m**3) 1216.06 1059.45 1213.8 1393.54 0 Float64\n", + " 13 │ wv (m/s) 2.13054 0.0 1.76 14.01 0 Float64\n", + " 14 │ max. wv (m/s) 3.53367 0.0 2.98 23.5 0 Float64\n", + " 15 │ wd (deg) 174.789 0.0 198.1 360.0 0 Float64\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": "\u001b[1m15×7 DataFrame\u001b[0m\n\u001b[1m Row \u001b[0m│\u001b[1m variable \u001b[0m\u001b[1m mean \u001b[0m\u001b[1m min \u001b[0m\u001b[1m median \u001b[0m\u001b[1m max \u001b[0m ⋯\n\u001b[1m \u001b[0m│\u001b[90m Symbol \u001b[0m\u001b[90m Union… \u001b[0m\u001b[90m Any \u001b[0m\u001b[90m Union… \u001b[0m\u001b[90m Any \u001b[0m ⋯\n─────┼──────────────────────────────────────────────────────────────────────────\n 1 │ Date Time \u001b[90m \u001b[0m 2009-01-01T01:00:00 \u001b[90m \u001b[0m 2016-12-31T23:10 ⋯\n 2 │ p (mbar) 989.213 913.6 989.57 1015.29\n 3 │ T (degC) 9.45048 -22.76 9.41 37.28\n 4 │ Tpot (K) 283.493 250.85 283.46 311.21\n 5 │ Tdew (degC) 4.95647 -24.8 5.21 23.06 ⋯\n 6 │ rh (%) 76.0098 13.88 79.3 100.0\n ⋮ │ ⋮ ⋮ ⋮ ⋮ ⋮ ⋱\n 11 │ H2OC (mmol/mol) 9.64044 0.81 8.96 28.74\n 12 │ rho (g/m**3) 1216.06 1059.45 1213.8 1393.54\n 13 │ wv (m/s) 2.13054 0.0 1.76 14.01 ⋯\n 14 │ max. wv (m/s) 3.53367 0.0 2.98 23.5\n 15 │ wd (deg) 174.789 0.0 198.1 360.0\n\u001b[36m 3 columns and 4 rows omitted\u001b[0m", + "text/html": [ + "

15 rows × 7 columns (omitted printing of 1 columns)

variablemeanminmedianmaxnmissing
SymbolUnion…AnyUnion…AnyInt64
1Date Time2009-01-01T01:00:002016-12-31T23:10:000
2p (mbar)989.213913.6989.571015.290
3T (degC)9.45048-22.769.4137.280
4Tpot (K)283.493250.85283.46311.210
5Tdew (degC)4.95647-24.85.2123.060
6rh (%)76.009813.8879.3100.00
7VPmax (mbar)13.57660.9711.8263.770
8VPact (mbar)9.533970.818.8628.250
9VPdef (mbar)4.042540.02.1946.010
10sh (g/kg)6.022560.515.5918.070
11H2OC (mmol/mol)9.640440.818.9628.740
12rho (g/m**3)1216.061059.451213.81393.540
13wv (m/s)2.130540.01.7614.010
14max. wv (m/s)3.533670.02.9823.50
15wd (deg)174.7890.0198.1360.00
" + ] + }, + "metadata": {}, + "execution_count": 9 + } + ], + "cell_type": "code", + "source": [ + "replace!(df[!,\"wv (m/s)\"], -9999.0 => 0);\n", + "replace!(df[!,\"max. wv (m/s)\"], -9999.0 => 0);\n", + "\n", + "@show describe(df)" + ], + "metadata": {}, + "execution_count": 9 + }, + { + "cell_type": "markdown", + "source": [ + "## Feature engineering\n", + "Bucket wind direction and speed" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Plot{Plots.GRBackend() n=1}", + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ], + "cell_type": "code", + "source": [ + "histogram2d(df[!,\"wd (deg)\"], df[!,\"wv (m/s)\"], bins=(75,75), xlabel=\"wd (deg)\", ylabel=\"wv (m/s)\")" + ], + "metadata": {}, + "execution_count": 10 + }, + { + "cell_type": "markdown", + "source": [ + "It would be better to decompose this into X and Y velocities" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Plot{Plots.GRBackend() n=1}", + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ], + "cell_type": "code", + "source": [ + "wd_rad = df[!,\"wd (deg)\"] * π / 180\n", + "df.Wx = df[!,\"wv (m/s)\"] .* cos.(wd_rad)\n", + "df.Wy = df[!,\"wv (m/s)\"] .* sin.(wd_rad)\n", + "df.\"max Wx\" = df[!,\"max. wv (m/s)\"] .* cos.(wd_rad)\n", + "df.\"max Wy\" = df[!,\"max. wv (m/s)\"] .* sin.(wd_rad);\n", + "\n", + "histogram2d(df.Wx, df.Wy, bins=(75,75), xlabel=\"Wind X [m/s]\", ylabel=\"Wind Y [m/s]\")" + ], + "metadata": {}, + "execution_count": 11 + }, + { + "cell_type": "markdown", + "source": [ + "Modify timestamp into a continuous \"time of day\" signal to deal with periodicity." + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Plot{Plots.GRBackend() n=2}", + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 12 + } + ], + "cell_type": "code", + "source": [ + "timestamp_s = Dates.datetime2unix.(df.\"Date Time\");\n", + "\n", + "day = 24*60*60 #seconds in a day\n", + "year = 365.2425 * day #seconds in a year\n", + "\n", + "df[!,\"Day sin\"] = sin.(timestamp_s * (2 * π / day))\n", + "df[!,\"Day cos\"] = cos.(timestamp_s * (2 * π / day))\n", + "df[!,\"Year sin\"] = sin.(timestamp_s * (2 * π / year))\n", + "df[!,\"Year cos\"] = cos.(timestamp_s * (2 * π / year));\n", + "\n", + "plot(df[1:25,\"Day sin\"], legend=false)\n", + "plot!(df[1:25,\"Day cos\"])\n", + "xlabel!(\"Time [h]\")\n", + "title!(\"Time of Day Signal\")" + ], + "metadata": {}, + "execution_count": 12 + }, + { + "cell_type": "markdown", + "source": [ + "If you don't know the frequency to choose for your periodicity, you can take the FFT.\n", + "Here you can see that the yearly and daily periodicities are the most prominent." + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Plot{Plots.GRBackend() n=1}", + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 13 + } + ], + "cell_type": "code", + "source": [ + "fftrans = FFTW.rfft(df[!,\"T (degC)\"])\n", + "f_per_dataset = 1:size(fftrans)[1]\n", + "\n", + "n_samples_h = size(df[!,\"T (degC)\"])[1]\n", + "hours_per_year = 24 * 365.2524\n", + "years_per_dataset = n_samples_h / hours_per_year\n", + "f_per_year = f_per_dataset / years_per_dataset;\n", + "\n", + "plot(f_per_year, abs.(fftrans), xscale=:log10, ylim=(0, 400000), xlim=(0.3,Inf), leg=false)\n", + "xticks!([1, 365.2524], [\"1/Year\", \"1/Day\"])\n", + "xlabel!(\"Frequency (log scale)\")" + ], + "metadata": {}, + "execution_count": 13 + }, + { + "cell_type": "markdown", + "source": [ + "## Split the data\n", + "Drop columns that won't be used further." + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "\u001b[1m70091×19 DataFrame\u001b[0m\n\u001b[1m Row \u001b[0m│\u001b[1m p (mbar) \u001b[0m\u001b[1m T (degC) \u001b[0m\u001b[1m Tpot (K) \u001b[0m\u001b[1m Tdew (degC) \u001b[0m\u001b[1m rh (%) \u001b[0m\u001b[1m VPmax (mbar) \u001b[0m\u001b[1m VPa\u001b[0m ⋯\n\u001b[1m \u001b[0m│\u001b[90m Float32 \u001b[0m\u001b[90m Float32 \u001b[0m\u001b[90m Float32 \u001b[0m\u001b[90m Float32 \u001b[0m\u001b[90m Float32 \u001b[0m\u001b[90m Float32 \u001b[0m\u001b[90m Flo\u001b[0m ⋯\n───────┼────────────────────────────────────────────────────────────────────────\n 1 │ 996.5 -8.05 265.38 -8.78 94.4 3.33 ⋯\n 2 │ 996.62 -8.88 264.54 -9.77 93.2 3.12\n 3 │ 996.84 -8.81 264.59 -9.66 93.5 3.13\n 4 │ 996.99 -9.05 264.34 -10.02 92.6 3.07\n 5 │ 997.46 -9.63 263.72 -10.65 92.2 2.94 ⋯\n 6 │ 997.71 -9.67 263.66 -10.62 92.7 2.93\n ⋮ │ ⋮ ⋮ ⋮ ⋮ ⋮ ⋮ ⋱\n 70087 │ 1002.18 -0.98 272.01 -5.36 72.0 5.69\n 70088 │ 1001.4 -1.4 271.66 -6.84 66.29 5.51\n 70089 │ 1001.19 -2.75 270.32 -6.9 72.9 4.99 ⋯\n 70090 │ 1000.65 -2.89 270.22 -7.15 72.3 4.93\n 70091 │ 1000.11 -3.93 269.23 -8.09 72.6 4.56\n\u001b[36m 13 columns and 70080 rows omitted\u001b[0m", + "text/html": [ + "

70,091 rows × 19 columns (omitted printing of 12 columns)

p (mbar)T (degC)Tpot (K)Tdew (degC)rh (%)VPmax (mbar)VPact (mbar)
Float32Float32Float32Float32Float32Float32Float32
1996.5-8.05265.38-8.7894.43.333.14
2996.62-8.88264.54-9.7793.23.122.9
3996.84-8.81264.59-9.6693.53.132.93
4996.99-9.05264.34-10.0292.63.072.85
5997.46-9.63263.72-10.6592.22.942.71
6997.71-9.67263.66-10.6292.72.932.71
7998.33-9.17264.12-10.192.93.042.83
8999.17-8.1265.12-9.0592.83.313.07
9999.69-7.66265.52-8.8491.23.433.13
101000.27-7.04266.1-8.1791.63.63.3
111000.87-7.41265.68-8.6690.73.53.17
121000.3-6.87266.27-8.2889.63.643.27
131000.03-5.89267.27-7.4688.63.933.48
14999.81-5.94267.24-7.4389.13.923.49
15999.88-5.69267.48-7.090.43.993.61
16999.94-5.4267.76-6.8689.44.083.65
171000.17-5.37267.78-6.8289.44.093.66
181000.16-5.25267.9-6.7589.14.133.68
191000.22-5.11268.03-6.5789.44.173.73
201000.22-4.9268.24-6.3889.34.243.79
⋮⋮⋮⋮⋮⋮⋮⋮
" + ] + }, + "metadata": {}, + "execution_count": 14 + } + ], + "cell_type": "code", + "source": [ + "select!(df, Not([:(\"wv (m/s)\"),:(\"max. wv (m/s)\"), :(\"wd (deg)\"), :(\"Date Time\")]));\n", + "\n", + "column_indices = pairs(names(df))\n", + "indices_columns = Dict(value => key for (key, value) in column_indices)\n", + "df = convert.(Float32, df) # Don't need high precision; reduces errors later on when using Params - gradients are Float32" + ], + "metadata": {}, + "execution_count": 14 + }, + { + "cell_type": "markdown", + "source": [ + "Split the data into a training and validation set" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "19" + }, + "metadata": {}, + "execution_count": 15 + } + ], + "cell_type": "code", + "source": [ + "n = size(df)[1]\n", + "train_df = df[1:round(Int,n*0.7, RoundDown),:]\n", + "valid_df = df[round(Int,n*0.7, RoundUp):round(Int,n*0.9, RoundDown),:]\n", + "test_df = df[round(Int,n*0.9, RoundUp):end,:]; # matching TF tutorial exactly, can also use partition\n", + "\n", + "num_features = size(df,2)" + ], + "metadata": {}, + "execution_count": 15 + }, + { + "cell_type": "markdown", + "source": [ + "## Normalize the data" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Plot{Plots.GRBackend() n=2}", + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 16 + } + ], + "cell_type": "code", + "source": [ + "train_mean = mean.(eachcol(train_df))\n", + "train_std = std.(eachcol(train_df))\n", + "\n", + "train_df = (train_df .- train_mean') ./ train_std'\n", + "valid_df = (valid_df .- train_mean') ./ train_std'\n", + "test_df = (test_df .- train_mean') ./ train_std'\n", + "\n", + "df_std = (df .- train_mean') ./ train_std'\n", + "df_std = stack(df_std)\n", + "\n", + "violin(df_std.variable, df_std.value, xrotation=30.0, legend=false, xticks=:all) # use plotattr() to learn about keywords\n", + "boxplot!(df_std.variable, df_std.value, fillalpha=0.75, outliers=false)" + ], + "metadata": {}, + "execution_count": 16 + }, + { + "cell_type": "markdown", + "source": [ + "## Data Windowing\n", + "We will define our own WindowGenerator, some constructors, and plotting functions. The data from the WindowGenerator will be used in training." + ], + "metadata": {} + }, + { + "outputs": [], + "cell_type": "code", + "source": [ + "include(\"window_generator.jl\")\n", + "\n", + "h = 6; # historical window length\n", + "f = 1; # future window length" + ], + "metadata": {}, + "execution_count": 17 + }, + { + "cell_type": "markdown", + "source": [ + "WindowGenerator makes use of MLDataPattern's `slidingwindow` to generate the windows. It is good at flexibly generating sequences data, though requires a bit of mind-bending to fully understand how it generates sequences.\n", + "[slidingwindow docs](https://mldatapatternjl.readthedocs.io/en/latest/documentation/dataview.html?highlight=slidingwindow#labeled-windows)" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "49057-element slidingwindow(::Main.##722.var\"#18#19\", adjoint(::Matrix{Float32}), 6, stride = 1) with eltype Tuple:\n ([0.9453041 0.95976573 … 1.0610048 1.0911344; -1.9824733 -2.078372 … -2.1650276 -2.1696491; … ; -0.061052326 -0.060029317 … -0.056960337 -0.055937365; 1.428434 1.4284236 … 1.4283878 1.4283743], [1.1658554; -2.1118789; … ; -0.0549144; 1.4283602])\n ([0.95976573 0.9862837 … 1.0911344 1.1658554; -2.078372 -2.0702844 … -2.1696491 -2.1118789; … ; -0.060029317 -0.059006315 … -0.055937365 -0.0549144; 1.4284236 1.4284124 … 1.4283743 1.4283602], [1.2670871; -1.9882501; … ; -0.053891443; 1.4283456])\n ([0.9862837 1.0043571 … 1.1658554 1.2670871; -2.0702844 -2.098014 … -2.1118789 -1.9882501; … ; -0.059006315 -0.05798332 … -0.0549144 -0.053891443; 1.4284124 1.4284005 … 1.4283602 1.4283456], [1.3297591; -1.9374124; … ; -0.0528685; 1.42833])\n ([1.0043571 1.0610048 … 1.2670871 1.3297591; -2.098014 -2.1650276 … -1.9882501 -1.9374124; … ; -0.05798332 -0.056960337 … -0.053891443 -0.0528685; 1.4284005 1.4283878 … 1.4283456 1.42833], [1.399662; -1.865777; … ; -0.05184557; 1.4283137])\n ([1.0610048 1.0911344 … 1.3297591 1.399662; -2.1650276 -2.1696491 … -1.9374124 -1.865777; … ; -0.056960337 -0.055937365 … -0.0528685 -0.05184557; 1.4283878 1.4283743 … 1.42833 1.4283137], [1.4719703; -1.9085271; … ; -0.050822653; 1.4282966])\n ([1.0911344 1.1658554 … 1.399662 1.4719703; -2.1696491 -2.1118789 … -1.865777 -1.9085271; … ; -0.055937365 -0.0549144 … -0.05184557 -0.050822653; 1.4283743 1.4283602 … 1.4283137 1.4282966], [1.4032738; -1.846135; … ; -0.049799744; 1.428279])\n ([1.1658554 1.2670871 … 1.4719703 1.4032738; -2.1118789 -1.9882501 … -1.9085271 -1.846135; … ; -0.0549144 -0.053891443 … -0.050822653 -0.049799744; 1.4283602 1.4283456 … 1.4282966 1.428279], [1.3707387; -1.732905; … ; -0.04877685; 1.4282606])\n ([1.2670871 1.3297591 … 1.4032738 1.3707387; -1.9882501 -1.9374124 … -1.846135 -1.732905; … ; -0.053891443 -0.0528685 … -0.049799744 -0.04877685; 1.4283456 1.42833 … 1.428279 1.4282606], [1.3442208; -1.738682; … ; -0.04775397; 1.4282415])\n ⋮\n ([0.032976408 0.0076648267 … -0.033307422 0.06551882; 1.0135001 1.3786092 … 1.6616842 1.0550948; … ; -0.84815776 -0.84901774 … -0.8515952 -0.8524536; -1.158996 -1.1584501 … -1.156809 -1.1562608], [0.05105716; 0.97999334; … ; -0.8533115; -1.1557119])\n ([0.0076648267 -0.04295098 … 0.06551882 0.05105716; 1.3786092 1.5819609 … 1.0550948 0.97999334; … ; -0.84901774 -0.8498773 … -0.8524536 -0.8533115; -1.1584501 -1.1579037 … -1.1562608 -1.1557119], [0.08359221; 0.9372431; … ; -0.85416913; -1.1551625])\n ([-0.04295098 -0.033307422 … 0.05105716 0.08359221; 1.5819609 1.6940356 … 0.97999334 0.9372431; … ; -0.8498773 -0.85073644 … -0.8533115 -0.85416913; -1.1579037 -1.1573567 … -1.1557119 -1.1551625], [0.16916317; 0.90489185; … ; -0.85502625; -1.1546124])\n ([-0.033307422 -0.033307422 … 0.08359221 0.16916317; 1.6940356 1.6616842 … 0.9372431 0.90489185; … ; -0.85073644 -0.8515952 … -0.85416913 -0.85502625; -1.1573567 -1.156809 … -1.1551625 -1.1546124], [0.26678303; 0.87947273; … ; -0.855883; -1.1540618])\n ([-0.033307422 0.06551882 … 0.16916317 0.26678303; 1.6616842 1.0550948 … 0.90489185 0.87947273; … ; -0.8515952 -0.8524536 … -0.85502625 -0.855883; -1.156809 -1.1562608 … -1.1546124 -1.1540618], [0.2173736; 0.74082386; … ; -0.85673934; -1.1535105])\n ([0.06551882 0.05105716 … 0.26678303 0.2173736; 1.0550948 0.97999334 … 0.87947273 0.74082386; … ; -0.8524536 -0.8533115 … -0.855883 -0.85673934; -1.1562608 -1.1557119 … -1.1540618 -1.1535105], [0.2137545; 0.71078324; … ; -0.85759526; -1.1529586])\n ([0.05105716 0.08359221 … 0.2173736 0.2137545; 0.97999334 0.9372431 … 0.74082386 0.71078324; … ; -0.8533115 -0.85416913 … -0.85673934 -0.85759526; -1.1557119 -1.1551625 … -1.1535105 -1.1529586], [0.16675043; 0.6530128; … ; -0.8584509; -1.1524062])" + }, + "metadata": {}, + "execution_count": 18 + } + ], + "cell_type": "code", + "source": [ + "slidingwindow(i -> i+h:i+h+f-1, Array(train_df)', h, stride=1)" + ], + "metadata": {}, + "execution_count": 18 + }, + { + "cell_type": "markdown", + "source": [ + "WindowGenerator is implemented to make sequence-generating simpler. It uses `slidingwindow` behind the scenes to create sequences." + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": " Calculates the windows used for modeling, the target index, and features\n useful for plotting.\n\n Specify \u001b[36mh\u001b[39m historical points, \u001b[36mf\u001b[39m target points. By default, the target points\n are assumed to follow after all the historical points (\u001b[36moffset = h\u001b[39m). By\n setting \u001b[36moffset = 1\u001b[39m, the targets for each historical point will be the next\n point in time.\n\n WindowGenerator with a single label_column.\n\n WindowGenerator with multiple label_columns.", + "text/markdown": "Calculates the windows used for modeling, the target index, and features useful for plotting.\n\nSpecify `h` historical points, `f` target points. By default, the target points are assumed to follow after all the historical points (`offset = h`). By setting `offset = 1`, the targets for each historical point will be the next point in time.\n\nWindowGenerator with a single label_column. \n\nWindowGenerator with multiple label_columns.\n" + }, + "metadata": {}, + "execution_count": 19 + } + ], + "cell_type": "code", + "source": [ + "@doc WindowGenerator" + ], + "metadata": {}, + "execution_count": 19 + }, + { + "cell_type": "markdown", + "source": [ + "Create a WindowGenerator" + ], + "metadata": {} + }, + { + "outputs": [], + "cell_type": "code", + "source": [ + "wg = WindowGenerator(6, 1, train_df, valid_df, label_columns=\"T (degC)\");" + ], + "metadata": {}, + "execution_count": 20 + }, + { + "cell_type": "markdown", + "source": [ + "Plotting methods are implemented for raw data and with predictions." + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Plot{Plots.GRBackend() n=6}", + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 21 + } + ], + "cell_type": "code", + "source": [ + "plot(wg)" + ], + "metadata": {}, + "execution_count": 21 + }, + { + "cell_type": "markdown", + "source": [ + "We will also make use of the utility function for batching lazily-evaluated timeseries from slidingwindow" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Main.##722.batch_ts" + }, + "metadata": {}, + "execution_count": 22 + } + ], + "cell_type": "code", + "source": [ + "include(\"batch_ts.jl\")" + ], + "metadata": {}, + "execution_count": 22 + }, + { + "cell_type": "markdown", + "source": [ + "To understand better what all the above code does, let's look at an imitation training loop and look at everything's dimensions" + ], + "metadata": {} + }, + { + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x = Float32[0.9862837 1.0043571 1.0610048 1.0911344 1.1658554 1.2670871; -2.0702844 -2.098014 -2.1650276 -2.1696491 -2.1118789 -1.9882501; -2.1324346 -2.1610887 -2.2321506 -2.2390273 -2.1863046 -2.071688; -2.045187 -2.09682 -2.187178 -2.1828752 -2.108294 -1.9576976; 1.0627385 1.0083753 0.9842138 1.0144156 1.0264965 1.0204563; -1.328843 -1.3366406 -1.3535352 -1.3548348 -1.3405393 -1.3054504; -1.5272249 -1.5462353 -1.5795032 -1.5795032 -1.5509878 -1.4939572; -0.78834784 -0.7821209 -0.7821209 -0.78627217 -0.7841965 -0.7800452; -1.5287029 -1.5474207 -1.5811126 -1.5811126 -1.5549077 -1.4950107; -1.5319922 -1.5531187 -1.5859822 -1.5836347 -1.5578135 -1.4991288; 2.323999 2.3589115 2.4463177 2.4590142 2.416776 2.311058; 0.20798267 0.27034295 0.11226401 0.27458957 1.3088222 -0.0017026255; 0.276266 0.19526656 0.35081816 0.26863295 -0.008001719 -0.006444905; 0.11121804 0.24690734 0.048640482 0.17511468 1.2110392 -0.024096228; 0.32407838 0.14517556 0.40205324 0.37752837 0.057261467 0.0046644583; 1.0000997 1.2248497 1.3661335 1.4143227 1.3661335 1.2248497; 1.0000591 0.70717865 0.366112 0.00010241506 -0.36590716 -0.7069738; -0.059006315 -0.05798332 -0.056960337 -0.055937365 -0.0549144 -0.053891443; 1.4284124 1.4284005 1.4283878 1.4283743 1.4283602 1.4283456]\n", + "\n", + "Float32[0.9453041 0.95976573 0.9862837 1.0043571 1.0610048 1.0911344; -1.9824733 -2.078372 -2.0702844 -2.098014 -2.1650276 -2.1696491; -2.0418866 -2.138164 -2.1324346 -2.1610887 -2.2321506 -2.2390273; -1.9189727 -2.0609639 -2.045187 -2.09682 -2.187178 -2.1828752; 1.1171018 1.0446173 1.0627385 1.0083753 0.9842138 1.0144156; -1.3028512 -1.3301426 -1.328843 -1.3366406 -1.3535352 -1.3548348; -1.477323 -1.5343539 -1.5272249 -1.5462353 -1.5795032 -1.5795032; -0.7904235 -0.78627217 -0.78834784 -0.7821209 -0.7821209 -0.78627217; -1.4800365 -1.5361899 -1.5287029 -1.5474207 -1.5811126 -1.5811126; -1.4826971 -1.5390345 -1.5319922 -1.5531187 -1.5859822 -1.5836347; 2.2185228 2.3257067 2.323999 2.3589115 2.4463177 2.4590142; 0.19340923 0.17298676 0.20798267 0.27034295 0.11226401 0.27458957; 0.2211613 0.22210087 0.276266 0.19526656 0.35081816 0.26863295; 0.11114045 0.10945824 0.11121804 0.24690734 0.048640482 0.17511468; 0.21792784 0.22779849 0.32407838 0.14517556 0.40205324 0.37752837; 0.36611056 0.70719975 1.0000997 1.2248497 1.3661335 1.4143227; 1.3660687 1.2247943 1.0000591 0.70717865 0.366112 0.00010241506; -0.061052326 -0.060029317 -0.059006315 -0.05798332 -0.056960337 -0.055937365; 1.428434 1.4284236 1.4284124 1.4284005 1.4283878 1.4283743]\n", + "y = Float32[1.3297591; -1.9374124; -2.0258422; -1.9275783; 0.92381036; -1.2898552; -1.4796994; -0.76759124; -1.48378; -1.4873918; 2.2741907; 0.13879544; 0.168457; 0.12114528; 0.17993191; 1.0000997; -0.9998543; -0.0528685; 1.42833]\n", + "\n", + "Float32[1.1658554; -2.1118789; -2.1863046; -2.108294; 1.0264965; -1.3405393; -1.5509878; -0.7841965; -1.5549077; -1.5578135; 2.416776; 1.3088222; -0.008001719; 1.2110392; 0.057261467; 1.3661335; -0.36590716; -0.0549144; 1.4283602]\n", + "\n", + "x = Float32[0.95976573 0.9862837 1.0043571 1.0610048 1.0911344 1.1658554; -2.078372 -2.0702844 -2.098014 -2.1650276 -2.1696491 -2.1118789; -2.138164 -2.1324346 -2.1610887 -2.2321506 -2.2390273 -2.1863046; -2.0609639 -2.045187 -2.09682 -2.187178 -2.1828752 -2.108294; 1.0446173 1.0627385 1.0083753 0.9842138 1.0144156 1.0264965; -1.3301426 -1.328843 -1.3366406 -1.3535352 -1.3548348 -1.3405393; -1.5343539 -1.5272249 -1.5462353 -1.5795032 -1.5795032 -1.5509878; -0.78627217 -0.78834784 -0.7821209 -0.7821209 -0.78627217 -0.7841965; -1.5361899 -1.5287029 -1.5474207 -1.5811126 -1.5811126 -1.5549077; -1.5390345 -1.5319922 -1.5531187 -1.5859822 -1.5836347 -1.5578135; 2.3257067 2.323999 2.3589115 2.4463177 2.4590142 2.416776; 0.17298676 0.20798267 0.27034295 0.11226401 0.27458957 1.3088222; 0.22210087 0.276266 0.19526656 0.35081816 0.26863295 -0.008001719; 0.10945824 0.11121804 0.24690734 0.048640482 0.17511468 1.2110392; 0.22779849 0.32407838 0.14517556 0.40205324 0.37752837 0.057261467; 0.70719975 1.0000997 1.2248497 1.3661335 1.4143227 1.3661335; 1.2247943 1.0000591 0.70717865 0.366112 0.00010241506 -0.36590716; -0.060029317 -0.059006315 -0.05798332 -0.056960337 -0.055937365 -0.0549144; 1.4284236 1.4284124 1.4284005 1.4283878 1.4283743 1.4283602]\n", + "\n", + "Float32[1.0043571 1.0610048 1.0911344 1.1658554 1.2670871 1.3297591; -2.098014 -2.1650276 -2.1696491 -2.1118789 -1.9882501 -1.9374124; -2.1610887 -2.2321506 -2.2390273 -2.1863046 -2.071688 -2.0258422; -2.09682 -2.187178 -2.1828752 -2.108294 -1.9576976 -1.9275783; 1.0083753 0.9842138 1.0144156 1.0264965 1.0204563 0.92381036; -1.3366406 -1.3535352 -1.3548348 -1.3405393 -1.3054504 -1.2898552; -1.5462353 -1.5795032 -1.5795032 -1.5509878 -1.4939572 -1.4796994; -0.7821209 -0.7821209 -0.78627217 -0.7841965 -0.7800452 -0.76759124; -1.5474207 -1.5811126 -1.5811126 -1.5549077 -1.4950107 -1.48378; -1.5531187 -1.5859822 -1.5836347 -1.5578135 -1.4991288 -1.4873918; 2.3589115 2.4463177 2.4590142 2.416776 2.311058 2.2741907; 0.27034295 0.11226401 0.27458957 1.3088222 -0.0017026255 0.13879544; 0.19526656 0.35081816 0.26863295 -0.008001719 -0.006444905 0.168457; 0.24690734 0.048640482 0.17511468 1.2110392 -0.024096228 0.12114528; 0.14517556 0.40205324 0.37752837 0.057261467 0.0046644583 0.17993191; 1.2248497 1.3661335 1.4143227 1.3661335 1.2248497 1.0000997; 0.70717865 0.366112 0.00010241506 -0.36590716 -0.7069738 -0.9998543; -0.05798332 -0.056960337 -0.055937365 -0.0549144 -0.053891443 -0.0528685; 1.4284005 1.4283878 1.4283743 1.4283602 1.4283456 1.42833]\n", + "y = Float32[1.2670871; -1.9882501; -2.071688; -1.9576976; 1.0204563; -1.3054504; -1.4939572; -0.7800452; -1.4950107; -1.4991288; 2.311058; -0.0017026255; -0.006444905; -0.024096228; 0.0046644583; 1.2248497; -0.7069738; -0.053891443; 1.4283456]\n", + "\n", + "Float32[1.399662; -1.865777; -1.9593625; -1.8314834; 0.9479719; -1.2677623; -1.4393027; -0.76759124; -1.4463444; -1.4498336; 2.2160816; 0.5720067; -0.6065562; 0.67631173; -0.7864484; 0.70719975; -1.2245895; -0.05184557; 1.4283137]\n", + "\n" + ] + } + ], + "cell_type": "code", + "source": [ + "practice_df = train_df[1:10,:]\n", + "a = slidingwindow(i -> i+h:i+h+f-1, Array(practice_df)', h, stride=1)\n", + "\n", + "for i in eachbatch(shuffleobs(a), size=2)\n", + " (x,y) = batch_ts(i)\n", + " @show x\n", + " @show y\n", + " println()\n", + "end" + ], + "metadata": {}, + "execution_count": 23 + }, + { + "cell_type": "markdown", + "source": [ + "That took the data at 10 timestamps (`train_df[1:10,:]`) and threw it into 4 'observations' using all the data it could while requesting 6 historical and 1 target point. This works out to the following:\n", + "* (1,2,3,4,5,6), 7\n", + "* (2,3,4,5,6,7), 8\n", + "* (3,4,5,6,7,8), 9\n", + "* (4,5,6,7,8,9), 10\n", + "\n", + "It then shuffles these obserations, and lazily batches them into 2 batches each of size 2." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "# Single Step Models" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "loss (generic function with 1 method)" + }, + "metadata": {}, + "execution_count": 24 + } + ], + "cell_type": "code", + "source": [ + "loss(x,y) = Flux.Losses.mse(x, y)" + ], + "metadata": {}, + "execution_count": 24 + }, + { + "cell_type": "markdown", + "source": [ + "### Baseline - 1h" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "\"T (degC)\"" + }, + "metadata": {}, + "execution_count": 25 + } + ], + "cell_type": "code", + "source": [ + "struct Baseline\n", + " label_index::Int\n", + "end\n", + "\n", + "(m::Baseline)(x) = x[m.label_index,:,:]\n", + "\n", + "target = \"T (degC)\"" + ], + "metadata": {}, + "execution_count": 25 + }, + { + "cell_type": "markdown", + "source": [ + "Since this model repeats the last point, we make slidingwindows with 1 historical and 1 target point." + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Main.##722.Baseline(2)" + }, + "metadata": {}, + "execution_count": 26 + } + ], + "cell_type": "code", + "source": [ + "single_step_1h = WindowGenerator(1, 1, train_df, valid_df, label_columns=target);\n", + "\n", + "baseline_model = Baseline(wg.target_idx[1])" + ], + "metadata": {}, + "execution_count": 26 + }, + { + "cell_type": "markdown", + "source": [ + "Demonstrate the 'training error' for this model, although there is no actual training." + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "0.013971615f0" + }, + "metadata": {}, + "execution_count": 27 + } + ], + "cell_type": "code", + "source": [ + "function run_single_step_baseline(wg, model)\n", + " preds = Float32[]\n", + " reals = Float32[]\n", + " for (x,y) in wg.train\n", + " val = model(x)[1]\n", + " push!(preds, val)\n", + " push!(reals, y[model.label_index])\n", + " end\n", + "\n", + " l = loss(preds, reals)\n", + " return l\n", + "end\n", + "\n", + "run_single_step_baseline(single_step_1h, baseline_model)" + ], + "metadata": {}, + "execution_count": 27 + }, + { + "cell_type": "markdown", + "source": [ + "### Baseline - 24h\n", + "Let's try to predict the next hour's value for 24 hours" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Plot{Plots.GRBackend() n=3}", + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 28 + } + ], + "cell_type": "code", + "source": [ + "single_step_24h = WindowGenerator(24, 24, train_df, valid_df, label_columns=target; offset=1);\n", + "\n", + "plot(single_step_24h, baseline_model)" + ], + "metadata": {}, + "execution_count": 28 + }, + { + "cell_type": "markdown", + "source": [ + "### Linear Models\n", + "##### 1 hour\n", + "Set up a fairly generic training loop for the rest of the models. It takes in a model, and a WindowGenerator object, and uses the ADAM optimizer to train the model." + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "train_model! (generic function with 1 method)" + }, + "metadata": {}, + "execution_count": 29 + } + ], + "cell_type": "code", + "source": [ + "opt = Flux.Optimise.ADAM(0.01)\n", + "\n", + "function train_model!(model, wg::WindowGenerator, opt; epochs=20, bs=16, dev=Flux.gpu)\n", + " model = model |> dev\n", + " ps = params(model)\n", + " t = shuffleobs(wg.train)\n", + " v = batch_ts(getobs(wg.valid))\n", + "\n", + " local l\n", + " vl_prev = Inf\n", + " for e in 1:epochs\n", + " for d in eachbatch(t, size=bs)\n", + " x, y = batch_ts(d)\n", + " y = y[wg.target_idx,:,:]\n", + " x, y = x |> dev, y |> dev\n", + " gs = gradient(ps) do\n", + " l = loss(model(x),y)\n", + " end\n", + " Flux.update!(opt, ps, gs)\n", + " end\n", + " l = round(l;digits=4)\n", + " vl = round(loss(model(v[1]),v[2][wg.target_idx,:,:]); digits=4)\n", + " println(\"Epoch $e/$epochs - train loss: $l, valid loss: $vl\")\n", + " #=\n", + " crude early-stopping\n", + " vl_prev < (vl - 0.001) && break\n", + " vl_prev = vl\n", + " =#\n", + " end\n", + " model = model |> cpu\n", + "end" + ], + "metadata": {}, + "execution_count": 29 + }, + { + "cell_type": "markdown", + "source": [ + "Now, train the linear model" + ], + "metadata": {} + }, + { + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "┌ Warning: The specified values for size and/or count will result in 6 unused data points\n", + "└ @ MLDataPattern /home/andrew/.julia/packages/MLDataPattern/KlSmO/src/dataview.jl:205\n", + "Epoch 1/20 - train loss: 0.0126, valid loss: 0.0094\n", + "Epoch 2/20 - train loss: 0.0112, valid loss: 0.009\n", + "Epoch 3/20 - train loss: 0.0112, valid loss: 0.009\n", + "Epoch 4/20 - train loss: 0.0112, valid loss: 0.009\n", + "Epoch 5/20 - train loss: 0.0112, valid loss: 0.009\n", + "Epoch 6/20 - train loss: 0.0112, valid loss: 0.009\n", + "Epoch 7/20 - train loss: 0.0111, valid loss: 0.009\n", + "Epoch 8/20 - train loss: 0.0111, valid loss: 0.009\n", + "Epoch 9/20 - train loss: 0.0111, valid loss: 0.009\n", + "Epoch 10/20 - train loss: 0.0111, valid loss: 0.009\n", + "Epoch 11/20 - train loss: 0.0111, valid loss: 0.009\n", + "Epoch 12/20 - train loss: 0.011, valid loss: 0.009\n", + "Epoch 13/20 - train loss: 0.011, valid loss: 0.009\n", + "Epoch 14/20 - train loss: 0.011, valid loss: 0.009\n", + "Epoch 15/20 - train loss: 0.011, valid loss: 0.009\n", + "Epoch 16/20 - train loss: 0.011, valid loss: 0.009\n", + "Epoch 17/20 - train loss: 0.011, valid loss: 0.009\n", + "Epoch 18/20 - train loss: 0.0109, valid loss: 0.009\n", + "Epoch 19/20 - train loss: 0.0109, valid loss: 0.009\n", + "Epoch 20/20 - train loss: 0.0109, valid loss: 0.009\n", + " 8.227544 seconds (55.81 M allocations: 5.889 GiB, 8.83% gc time, 8.01% compilation time)\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": "Dense(19, 1)" + }, + "metadata": {}, + "execution_count": 30 + } + ], + "cell_type": "code", + "source": [ + "linear = Dense(size(single_step_1h.train[1][1],1), 1; initW=Flux.glorot_uniform, initb=Flux.zeros)\n", + "\n", + "@time linear = train_model!(linear, single_step_1h, opt; bs=32, epochs=20)" + ], + "metadata": {}, + "execution_count": 30 + }, + { + "cell_type": "markdown", + "source": [ + "##### 24 hours\n", + "Show the model's predictions for each point in the window." + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Plot{Plots.GRBackend() n=3}", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlgAAAGQCAIAAAD9V4nPAAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nOzdd1hTVxsA8DeTvTcCyhQFWSIibqGCuKri3lal7j2rn6OOqlXrtm5xIQ5AQJQloiAiskRUBJwIMsIMZN/vj1hKEREhkBDe3+PzNDn33Jv3liRvzr1nkAiCAIQQQqi9Ios7AIQQQkicMBEihBBq1zARIoQQatcwESKEEGrXMBEihBBq1zARIoQQatcwESKEEGrXMBEihBBq1zARIoQQatcwESKEEGrXJDcRvnr1isViiTuKFsTn88UdQuvBk5VWAoFA3CG0HoIgcE5KqSS5iXD06NHZ2dnijqIFVVVViTuE1oMnK61YLFb7yYVcLpfL5Yo7CiR6kpsIEUIIoVaAiRAhhFC7hokQIYRQu4aJECGEULuGiRAhhFC7RhV3AAghVL/4+PjXr1+bm5s7OzuLOxYkzTARIoQkTnV1dT+Pfm94b8rVypVLlI2pxjF3YuTk5MQdF5JOeGkUISRxlq9f/kzzWfHgYm4PbvHg4meaz5avXy7uoJDUwkSIEJI4YZFhbCt2zVO2FTv8XrgY40HSDS+NIoRaCZfLffPmja6urrKycr0VBASkFBORn4i8aoC6c5mRWj5A1E5hixAh1BoOHD1g2MWw3/R+Zs5mQ72GMpnMmk15VXDtjcD7Id/wCm9sJD+rnOg3wF0mQ6amAvmZzGcjN5/XApzoE7UEbBEihFpcRGTE1pNbGRMZwq+ciNSIKb/OmrT1ysN8IvYz8YFJ9Nclu3Ugrbcjd1QkAUB1970DhyZl382uUKtQKlEylTXdfHrv+hTBkQzB3p6UPrrYOkSihIkQIdTiTlw4wejBqPm+4dhyAk/H8DL5rh0ocyzJ1mp1E5ucnFx8VHxiYmJmZqaFhYWjoyMADO4EPq8FE+/x++qSdvb4kjIRaj5MhAihFldYXAgm/ynRViBuDCTo9Ibuzjg6OgpToBCZBDMsyGNNyH+mCbr78+ZYktfZUZRpLRQyakfwHiFCqMW59v2Jki377/NSUFNQo9PpTTiUAhU2OZDTxlAZbDD34x5IF/AEAAAVFRVnz53dvH3z3bt3cdVA9EOwRYgQalmVXIjrukTu/BWC+4bZgUkuI2umafpc9mnOMfXlSX/3oSyxJq98zD/+UuCt8mrPgsHF5sVsRbZqmKrVn1bRodFUKn6/oUbBNwpCqAXlMonhYfweWrKFycm+vhejH0WbOJrMOTxHT0+v+Qfvqkq67U6NyCWGu09mDf4EWgAApV1Lk+OTDx49uHwxjsFHjYKJECHUUhKLiJ/D+au6kZdYkwFgxrQZM6bNEPmr9NfmqfDyWVr/llSZV4VEhmAiRI2EiRAh1CL83wp+jeWf6ksZbtSyfRGoVCqpznB7Digr1T9mH6GvYWcZhJDoHUgXLH4kuO1ObeksCAAkEsmhmwMlk/LlOQH0RNUpXtNa+nWR1MAWIUJIlPgELHnEj8knYodTjFprqN/FExc9Rnu8ffWWp8wj51Lke0wP1RgxGqdlQ42DiRAhJDKVXJgQxeMK4OFwqkhG+LHZbBkZme9WU1NTe3zvcXZ29qdPn6ytrelKap53eN4P+X/3oWAuRN+Fl0YRQqKRyyT6BfM6KJBC3EWTBQFg48aNja9samrat29fNTU1BSoEuVPTGMSyeL5o4kBSDRMhQqgpCIK4duPanCVzlq5Z+uzZs1QG0TuIP96E/HcfClVE3yvv3r3bu/fPd+/eNWFfZRrc9aDGfSaWYy5E34OJECHUFO4/u885POey4PKhvEO9xw3st+HUgV7kNbai/ErxvXS2twXZ99KZpu2uQoewIdQH+cSqx5gLUUMwESKEflhoaGgCI6FsQBkYAZhDxZhiSuhvnvoizjc3rp6/OJ/v73exyUdQpUPYEGpUHrElSSDCwJCUwc4yCKEfFhUbVWZY9u9zGlA7wMuXL7t169bkYzKZzIiICA6HAwAsFuvz58/6ipVGGqCrWPHnn3/q6OjIysoCAJ1Od3NzU1BQaORh1WQg1J066DaPSobf7PCnP6oHJkKE0A8z0DWgPKfw4d8mILmarKWl1cAu36WgoFBaUjx/nrdXT3IPE0KZzP19BADA78MLH71cVZZBi8ghXX8sOHrs78ZnQSFtOYjwpA4M4dHIsNoGcyGqC98TCKEf9vPwn9Wea0DVl6ekNyR9WX1dXd1mHnb6jFlPk5+9KOkgSyfPHQTdDAEAuhnC3EGgKg/phdqPHj+dPmNWE46sKwfRQ6nnMgW7UvEaKaoLEyFC6Id17Nix65yzStcMtIO0ta9p93zfM/hasEiObGlpGRWbFl4wYFeofE3h7lD5W7kD7z9+YWNj0+Qj68hB2BDKyVeCQ88xF6L/wEujCKEfdv61oNhkcMHrDx/fZKmrq6urq4vw4IqKis69ByhlRgIAmwsyNFCX5zjb9FdUVPzuvnfv3nV3d//WVgMF0r2hlAHBfAoJZhqz4+LiKioqnJyc9PX1RRg/anNIzV/BkiCI+/fvf/jwwcXFxdTUtPamoqKiR48eMZnM7t27m5ubA0BmZub79+9rKgwaNIhMrr9VamVl5efnZ2Vl1czwJFZFRYWSkpK4o2gleLLS5COTcAzghQ2h2qiTqqqqZGVlv/UpbjLX3t0uTEr3fSK39zZ1hSdvQo/qqZetI2OfNbzXq1evxnv9nPLsRcPV3lcSLoeeME+NBmMml8aVfyu/bPaydSvWfTcqYUeepq0njCSZCN6+06ZNW7Bgwf37952dnf39/WvK4+LizMzM/v777+Dg4B49euzduxcAjh8/Pnfu3F3/4PF4zQ8AIdRqBARMjeavsqHYqDdl8rKSkpLG1Hn79u30M+pFWr9kvskr0p4z/azmu3fvvrvvlQunPrzLzsjIaLiaoQKAz7jSEbmlfUuZzszC8YV7z+9NTk7+gdNAUoZonqSkJDU1NQaDQRDEtWvXOnfuLBAIhJsKCwuF5QRBREZG0ul0Fou1bNmyjRs3NubIXbt2TU9Pb2Z4kqy8vFzcIbQePFmpsSuVPyCYy//yKSeYTCafz2/87r/8MrOysrLhOhcvXjQx0n748EFNycOHD0yMtC9dutTwjvZdDU7PJW1cu7Thaq9fv9bpqQOboeYfyYu0ZceW7wbPZrPZbPZ3q6E2p7ktwqCgIFdXVzU1NQAYPnz427dvX716JdykqakpLAcAfX19Pp8vbP/l5eXdvXu3phpCqK1IZRB7n/HP96eQmzSVNZPJ9L18KehWQMPVVFRUUtKzevfuU1PSu3eflPQsFRWVBvZKSkqy1GFN6EXcCrhGNHjHhyCIf5elqAAAABIIBNiDpv1qbmeZ3NxcAwMD4WMZGRlNTc3c3FxLS8s61bZt2zZ+/HgFBQUymZyWlvbp06eEhAQXF5fr16/TaPXPzsvhcK5cuVLTIbtHjx6Ojo7NjFai8Pl8Pr+9zPyEJysF2HyYek/wZw9SBzlBzfkJT7bhxFPD/+aNkY7ky+eOjB03oYFqQ4YMER65dqG8vLyHh0ftwnfv3k2ZPDHrVbqxvjKfzwOAHT8Xy9NhcJfKHl21SSQSmwsfC6umTv9l9+7dVOq/33XGxsa0EhpUAFQA9SXwBoL6a/UhK4Z8968mrNBwNTKZTCLhihdtTHMTIZ/Pr32fnEqlfn3bb8eOHcnJyTExMQDwxx9/CN+RZWVlTk5Ox48fX7RoUb1HFggEr169KiwsFD7t0KEDl8ttZrQShcvlStkZNQBPVgqsTSSZKJLGGvFrnxyXy6VQKI3sLHPl/OH9I1lTz7wuKCiouVzUZPr6+iG37yxfNIv/6d7xaWXy/3Rh2e1VBgCZeTDltMb69esXLl5OEESdv4jPcZ9JcydxoFhQyKUWa84aNcvW1va7fzVhhYbzHI1Go1AoDVRAEqi5iVBPT69mbniBQFBYWFinI/L+/fvPnTsXHR2toaEBADW/y1RUVIYNG9bADWpZWdnNmzdLca9RLpcrnDKqPcCTbeti8omAD/zk0VTZ/y4OKBAIvtVrlMvlnj59uoyRX1VZzmZVAQAj/42FHoxxYC6eP8vUuCOZTFZR1wYyfeKkKUZGRk2ISlZW9uxF/7+PHRy0Z+vF2cVmOl/KfeNpf0bpnvEN/ta4w4EDBr5KfNXT1riLJWfq6hOjRo1qzMsJTxN7jUqf5ibC/v37z5w5k8vl0mi02NhYZWVlS0tLNpvN4XCUlJROnjx54MCB6OjoeofppKSk9O7du5kBIIRaWhkHpkXz/+5D0fj+Ern/otFobm5u40a5d5T/sMCVCwCzZgIA/Dqg2iH7DgCkvIMdJ+jHjp9sWhas4T1vcU7W66dvjpjpfLlCey1Z9e/z/g2Pvk9JSelrCaNsKsMibjUyESJp1dxE6OrqamhoOGbMGDc3twMHDqxevZpGox09evTkyZMHDx709vZ2d3ffuXOnsPLmzZunT5/es2dPVVXViIiIly9fXr58udmngBBqWfNi+SM7koYY/vCtLzMzs0eJGauXzj0WE3hmRpmKPACAshy4WYNPnKzvM70Hj4JEctXnwb3Q9fOJpLdw4ZHC5pHM4daMyLDg7t27166TkpJyyed0OeMTAAAQj+IT949h9LOEpRsCykoKaXQZAJCVV+rh4jZlypTmh4TaEBEMqGcymadPn/748WP//v2HDh0KAM+fP3/x4kX37t3Dw8Nr1xw7dmx8fHxCQkJ1dbWJicnEiRMbGHeMA+qlCZ5s23XjjWDjU8HTn6ly9f1sbuSA+lMnjgWeWR+0uFT49MJD0rU3/a/evC0nJ9f8CHNzc6eNsHe1rLqT1XHSjPknDm5bO7jgSLzF/cd1R9afO3Ny/Zqlu8dWWRuCshx00gIyCfJKoYQJxZWw7LJsNyf3Iycvy8vL1/tCOKBeWolgijUFBYXFixfXLrGyshImsLlz59apPGTIEGGXMISQ5MtlEgvi+EGD68+CjaemoWVnxAeAt4XQURPsOxHBn0giyYIAEHzLPz6DMWDo8qjzO6hU6oiRo2ZP83qcklBYWFhnQYwZs+Y4u/SdNt7Tu1fuL/04wkI9VSivhpXXNabOX7Nk2SqRhITaFpxrFCFUPwJg9gP+EmtKD63mjgcIun7O26piW7CCb6KqkVr1qWmMzJfPORyOSFpXma+z7z+Irxlepa+vHxIee/TIoXv37o0bN65OZeGk3q59u1vrZ/Y0+1LosVfx1t17zVlMEbVpmAgRQvX7K11QzhXBAn58Pj8iKib7uZrH6LmpF7Y/eBAzbME0bnVhdHT04MGDmx/nrt17ag8TBAASibRg4eJvzeCoqKjIZTPtOkJ5NXxkQNcO4NxZrvk3iVDbhcswIYTqkVFK7Ejhn+tHoTR7dPijR4+UVTX+Ohv+2+Y/KBTKgAED78WlO/QaHBR4QxSRQp0s+N3yjIwME01OfDZ5wB7tmZdM99yRH9q1OMj/qkiCQW0RJkKEUF1cAUyP5u9yopiriGCSFCUlpacpGbX7cKqoqPj43po8dWbzD94EQQF+L9+V7XzYPSgy6eGTF+UdvPeFK93y9xVLMEgSYCJECAEAlJWVzVk4x6iLkWEXw+7jZ2gTpbMsRPP9YGtrW2+/GGdnZ5Ec/0eFh0d6L/s9NPJxhw4daDTa7zv3HfUJLWUK8vLyxBIPEju8R4gQAoFA4DbCLUUrhTeeByTITb9E7E7lj0iUvtnCBALB0b9PW1hY1C50du71NPlZY5aIQlIJW4QIIUhJSXnLe8vrxhMuy0BY8/KoH548efLdHQsKClo8OJEik8l1sqCQoqKioaFh68eDJAEmQoQQZGVlMVWZtUsqVCqysrK+u+PxY0dwSVvU1uGlUYQQdO7cWaFYoRqqa0qUGEqdO3f+7o7Xfc/y2WXdu59oyegQalnYIkQIga2tbSclK9JjWagCqATZJNnO8p2/uwJoQkKCQ0ci/E4wrmqL2jRMhAghYPGB/UvQULOl+td09K5pL7ZZHH4r/LsLzF7xOT7DuaR7R3ZcXFzrxIlQS8BLowghWBDLt9KRv3Jw57CMKC6Xu+v3XfVW8/HxyUhLKC3OE07DEnP/3u6tBJ3KWL5wpr2dDQDQ6TIKqjrjJkx1cHBozfhbR05ODoVCMTc3F3cgSMQwESLU3l3NETz4TDz9mcpgMEoL31LIRH5+vq6u7tc1x4wZExF642VS+L4J1XJ02NQDaBQYZAU+6llMdtarPFh1VW7L9j1SmQUB4Oqls1Qa7bf/bRN3IEjE8NIoQu1aVjmxKI7vN4iiRAM/30tj7MvH2pddu3qx3soKCgo+VwIXrv1r6VV1WRroqwEAkElgqQ/vGbS/YoxuRzyaPXdBq55AKwoK8A28cUncUSDRwxYhQu1XQFDI4kOX7JWqd/gxACAx+dmDtSwqGXpt3/EgMggAVNXUSVT5oSPHjxgxomavaTPn2tg7DR/aL2dPhbAkIRt2RnaKeJiorKwslhNpBampqSbqVRwePH/+XIrXSW2fMBEi1H6FqbnrmCRlBv5xbnaVoQZQ3KCDGgBA9JoSHj8mtwSmn5DzXrhi+PDhdXakUChO5jIAFa/yQF8NbI2Ax6mS4iwIAFd8/p7YvZjLB98LJ3//4y9xh4NECS+NItROXX8jCPsEEQc3+t26t8Lf8GU+taPml01GGvCumLzQV+eET+Ca337/uvvorZu+w6wY+8Lkp5w37r9b60kOyUST8+JF3RXh27S7d+8a6GubGKg6dtXraa0bc+fyEFtimD0REXSup7WuY1c9EwNVww464eHh4o4UNRe2CBFqj3IqiAVx/NvuVBU69OjhdCc6ydG2c+L/GJpKAAClVTD9lHJiapq2tna9uwcFXOVVKQ4eMS085veysrI508fkv38WFODXpcumVj2NluTu7h4UcveXqaNWueWNd+LUlD/6rQygzP8pbWe43gmfQDs7OzEGiUQCW4QItTtcAUy+x99gR+mu+aWpJyMjo6NK0VSCN4WQ/RlU5cFAk/at5ePz8/OLy7kHzoTs2HOITqcbGhrevfdk5sJN4eGRrXgSrcHe3v5ebKpfdp8lV1Q4/6zyy+HBwktKV7L7RTx8hllQOmCLEKF2Z1UCX1MWFlr9+zv47p077lbVZx/KHHmgQyKR5vbKH2JdFXo7ZOKkyV/vzuFwklLSlZSUakpIJNKyleuHDBstEAjIZKn6ea2ionL9VkRXM70d/DI6FQCAzYN7mYrPX0eIOzQkMlL1lkUIfVfIByLgLXGuP7X2fb+gG+euxfMS2KPux2fEPH6RRhp/JY4IunGu3iMYGRnVzoI1LC0tpSwLCr1588ZMh1CQgZP3Zc48kFGSBSN1/rt378QdFxIZKXzXIoS+5QOTmB3DuzyQoiHzbyGfz096lrXv+LVjp68oKCjIyckdOn7+rxM30l6843K54gtWUgQFXncyZIw8pJbMH/2YPWrUEQ1no5LgWzfFHRcSGbw0ilB7wRPAxCj+ShuKi85/eoFWVlbeux+rqalZu3Cwu0fMw/jKyko1NbXWDVPi3LpxKeeNwrFTPoNcBwNARPjd+XOndy68uGDRMnGHhkQDW4QItRfrE/nKdFjere6nXkVFpU4WFFJXV8csWFpaqmPYJTEt22PIMGGJ59DhiamZ6rpmFRUV4o0NiQq2CBFqF0I/EL7ZRNIo6ndWlED/JS8vf/mKb51CTU3NK75XORxOvbugNgcTIUJSKzU19fi544xSRu++Q3fSx/u50TVlxR1TW/OtMSQNb0JtCyZChKTTuQvnVv6xstihGOTghk+oIe9kn8kx4g4KIUmE9wgRkkJ8Pn/N5jXFo4rBDKAD8AdWMKhpgYGB4o4LIUmEiRAhKfT69WvQAaD9W1JuWB4VGyW+iBCSXJgIEZJCWlpaJOZ/usWQmWQjfSNxxYOQJMNEiJAU0tDQMNY0JmX9kwuZoPFcY8zPY8QaFEISChMhQtLpkk8gLaOvmq+2TqCOUbDRhSMXjI2NxR1UW8Xlcvf8tcfZ1bmXW699B/fxeLzv74PaDuw1ipB0OvlJY/L+qEPdWZWVlTo6OuIOp20b5jUslh3L7MUEgFchryLvR4bcCBF3UEhksEWIkBR6U0GceiXY5khWUFDALNhMqampSflJzF5MUABQAKYL88n7J8+fPxd3XEhkMBEiJIXWJAiWWlP05XEaGRFIT08v1yyvXVKhVZGeni6ueJDIYSJESNo8KiDiC4hl1vjpFo1OnTopVirWLlGoUOjUqZOYwkGihx8VhKSKgIAlj/i7ncjy2AFARJycnHSYOjVdcMmvybps3e7du4s3KiRCmAgRkio+rwUUEow3xY+2yNBotKjgqOHc4bqXdXUv644QjIgKjqJS8YeG9MC/JULSo4oHm5IE11wpeG9QtHR1dQN9A4XLTeBc29IHfzYiJD3+SOX31yU5aWEeROgHNDcRstnsrVu3urq6Tp06NTMzs87WCxcuuLu7jxw5Mjw8vKb+li1bhPVfv37dzFdHCNX4yCSOZgi2OeKvW4R+THM/M+vWrQsPD9+6daupqemgQYNYLFbNpoCAgNWrVy9btmzChAleXl6pqakAsGbNmsjIyK1bt5qYmAwaNIjNZjczAISQ0JoEwUIrspEiNgcR+kFEM1RWViorK6ekpAif2tnZXbx4sWbrwIEDDx48KHy8aNEib2/vyspKJSWl1NRUYaGNjc2lS5e+dfCuXbump6c3JzwJV15eLu4QWg+ebEuL/ywwuMyt5Lb26zKZTD6f39qvKiZsNpvNZos7CiR6zWoRZmVl8Xg8W1tb4dNevXolJyfXbE1KSurVq1fNpqSkpNevXwsEAhsbm3rrI4SahgBY8Zi/swdZAXu/IfTjmvW5KSgoUFNTq3mqrq7+9u1b4WMWi1VWVlazVUNDIz8//+v6Hz58+NbBKysrvby85OTkhE9nzpw5c+bM5kQraZhMJonUXq5i4cm2qKtvyUwudYQOq7KyNV8WAKCqqorH45HJ7eLGZGN6jcrIyNBotAYqIAnUrESoqKhYXV1d85TJZKqoqAgfy8jI0On0mq3CTQ3U/5qcnNyWLVtMTEyET/X19RUVFb9VuS0iCELKzqgBeLItp5oHv6fzLg6gKCuJoVs/mUyWlZXFRIjatGa9fY2MjEpLSxkMhvBpTk6OoaGh8DGJRDI0NMzJyanZZGRkZGRkVFJSUm/9r1EoFCsrK8d/6OvrNydUhKTVnmeCXjqkPrrfbIMWFha2ZjwItTnNSoQdOnTo06fPyZMnASA7OzsqKmrcuHFsNnvv3r0MBmPixIknTpwgCKK6utrHx2fChAkGBgYuLi6nTp0CgKysrOjo6HHjxonmPBBqlz5VEYee83d+e8hERkbG/n1/tmZICLU5zb2gceDAgaNHj9rZ2Tk5OW3cuNHExKS6unrlypWfP39esWJFSUmJhYWFmZmZpaXlhAkTAODgwYNHjhyxs7Pr2bPnpk2bcKVQhH5UQkJCzeP1TwTeluROSt9sDl65cNL34mmCIFolNITapOZ2MrOzs8vOzs7KytLR0RF2hFFVVeVwOMLbxbGxsTk5ObKysjUXNu3t7YX1dXV1VVVVm/nqCLU3ubm5ixf+Gp+QBADJxURYruDl2Ia6ZoQEXnM0Fjx+/NjZ2bm1YkSojRHBLW4qlWppaVm7O2jtTlMmJiZ1bu8J62MWRKgJ/K5cePYsLSsrCwCWPuJvd6QofzsPJiQkWOmxZvUquXL+WOuFiFBbg8OOEGpLrl05vc2L8L142mLa9nIuTDf/z2/ZxMTE636XgFfNqmZWV1elpWdsGMhws4Zl/wvynjGGQqEoq6gDiWLWxf6XX35pPwNaEGoYJkKE2ozs7Gx1etnsgYL++y5XdP39VF8K+b+5zNHRMSnx0W9rV+2dyLYyBzAHWyOgUuDWopLy6ptsLizwoZt167N+007MggjVaBejfxBqoz5+/DhiuKeTrbGjtYGjtYH7AMcpPYqUZMFUJZ+71nDFT4ZO3YwcbcxWrlwpHOIGAHN/XRQeHf/Xg46vC+jdjYFKAQAw1wUtZVhzU33C7HV+ARHKysriPCuEJAy2CBGSXAYGBqfPnJ82YZitSsb20ZWUf364XlvAAcgvqoDpZ9TNHAfv3Lmz9o15Ozu7e7Gp7gN7Gqm9crH4Uui2R+nCtZCePbHLDEJ1YYsQIYmmpaV1OyJerfuynpvJeaX/lidkQ+/tcgs3nTtw5NTXc3qpqKjwudV2naCKA6/zAQB6mMnQ6TKtGDhCbQYmQoQkHYlEWrl2U06F7K1ac9Qvvw5ULeMhnsPr3SUnJ0dXifX8I/TbpTnhTMe/wuWGWRUH+fu2UsQItSmYCBFqAygUijzBHWEPH4ph923g8GBKD1CS/eakl7cCrn3IK1kZbHU1OD7u6as89Vl/RSgHBfi1ZswItRWYCBFqA4oYJSqK9LB06LELNn2ALpvATBso7G8uNnEnNHTsjJVRsammpqYyMjK79h7e83dgcTk3Nze3NcNGqE3AzjIISTomDzx233qXzzqVbE1TKlXN51FVlFcFVL9++47BYKirq9epTxDE7r0Haxb+FOrXr39KWkZxcXErBo5Q24CJECGJll8Nw+7yWK/jz1/wHTPGq6acw+Fs2fRbWFiYcBbf2kgkUp0sKKSsrIwDJxD6GiZChCRXRikx9C5/ujlp5fk9ddY4pNPp23fuqWz9pXgRkjqYCBGSUPfyiAlRvL09KVPMyAD1r/TbfpY7RqjlYCJESBJdeyNY8oh/dRB1gB7OhYZQy8JEiJDEOZAuOPhcEOlJ7aKKWRChFoeJECEJwhPAokf8p0VE3Aiqjpy4o0GofcBEiJCkqOTC+Cgen4BIT6pSQ6vtIoRECQfUIyQ2V/yumNqa6ljomNiY/HX6XL9gnr48KXgwZkGEWhW2CBESj1shtxZsX1AypATkANiw4q9lo6fST46aJO64EGp3sEWIkHj8/ufvJW4lILwRKAMCz9KXN3eKOSaE2iVMhAiJR0FBASjVei4PpSr08jMAACAASURBVGWl36yNEGoxmAgREg9zM3PIr/W8CAw6GIgtGoTaMUyECInHwZ0HtSK04B0AB+ADaN7VPLrnqLiDQqg9wkSIkHh07do1NjTW5LOXTlCXUaxRMYEx9vb24g4KofYIe40iJDbm5uaac6/4OFN66+AMMgiJDbYIERIbPgEZpYSNOmZBhMQJEyFCYvOilOggT8Lh8wiJFyZChMQmuZiw18TmIEJihokQIbFJLiLsNTARIiRmmAgREpukYkyECIkfJkKExIMASMVEiJAEwESIkHjklBNKNJKmrLjjQKjdw0SIkHgkFxMO2FMGIQmAiRAh8UjG66IISQZMhAiJR1IRYa8h7iAQQpgIERKXFLw0ipBkwESIkBh8qiK4AjBQwESIkPhhIkRIDJKLoTs2BxGSDJgIERKD5CKcXA0hSYGJECExwC6jCEkO0STCioqKN2/e8Pn8rzcxGIzc3FyCIETyQghJB5xcDSHJIYJEePjwYSMjIw8PDzMzs7S0tJry58+fW1tbm5qauri4GBkZhYWFAcDy5ctJtbBYrOYHgFDbUsKGYhZhpoyJECGJ0NxE+PHjx7Vr1z58+PDVq1dz585dtGhRzSYZGZlDhw6VlJS8e/du3bp1kydPFggEALBx40biH7KyOMEUaneSiwlbDRIZ8yBCkqG5ifDq1at9+vSxsrICgF9//TUuLu7Dhw/CTWZmZgMHDhQ+Hjp0aFFRUXl5ufBpZWVlM18XobYruZhwwOuiCEmM5ibCt2/fmpubCx+rqalpaGi8e/fu62oXLlxwcXFRVVUFgD179ujp6Wlpae3Zs6eBIwsEglevXqX+4/Pnz80MFSEJgT1lEJIo1EbW27ZtW0FBQZ3CAQMGVFZWampq1pTIy8vXNPtq3L1798CBA/fv3weABQsW7NixQ1ZWNiEhwcPDw9TUdPTo0fW+YlVV1Zo1a2qunc6ePfuXX35pZLRtApPJJJHay7chnmxtiQX0BWbcykpp6EFWVVXF4/HI5HbR/5zD4QAAnU5voI6MjAyNRmutiJBoNDYRmpiYqKur1ynU1tbW1tZmMBg1JSUlJTo6OrXrREdHT506NSAgoGvXrgBgamoqLHdycpo8efLdu3e/lQgVFRX9/PyEF12lEkEQioqK4o6ileDJ1qjiwccqrqO+Ak0qcgeZTJaVlcVEiNq0xibCSZMm1Vv+/v37P/74Q/j41atXHA6n5kopAMTFxY0fP/7q1au9e/f+el8Gg6Grq/uDASPUtqUyCEtVknRkQYSkQ2MT4beMHj161apV27dv9/DwWLdu3fTp05WVlX19fa9fv75161YPD49JkyYVFRVdu3YNANzd3ffs2dOnTx8VFZXIyMibN2/GxcWJ4iwQajOSi3CubfQfOTk5DXeYQM1hZ2fn7e3dcJ3mJkJZWdnIyMgtW7aEhIT079//f//7HwBoaWl16dKloqLCw8ODwWAIsyAA9OrVi0wm7927t7Ky0tzc/MGDB/b29s0MAKG2BdfjRXXk5+eHhYWtXLlS3IFIodTU1NDQ0BZPhABgaWl55cqV2iWurq6urq4A4OfnV6fyli1bmv+KCLVdycXEL53xwij6Dx0dnXnz5ok7CikUEBBw7ty571Zrqx9IHo+3ZO3/pv66pKysTNyxINRYXAG8LCW6qWOLECEJ0lYTYVRU1LmneZcLtS5cvvL92ghJhoxSwkiRpCCCCzEIIZFpq4nQxsZGvTCdlhoYJecskIbhWKhdSMKeMghJnraaCHV1dXOS4wqfx5dpW895wMdciNoEnFMGIQnUVhMhAJBIJCUZStBg6rtKYko0n4+5EEk87DKKkARqw4lQSJ4KtwZTC1nElGg+TyDuaBD6NgEBqcWELfaUQUjCtPlECMJc+BO1GHMhkmxZ5YSmLEldRtxxIGlUUVGRmJj46NGj/Px8ccfS9khDIgQAOSoEDaYyecRkzIVIUiUV4Q1CJHopKSnDhg1TV1fv0aOHi4uLnp6eo6NjQECAuONqS6QkEQKADAWuu1KreTDpHuZCJImwpwwSuatXrzo7O4eEhPB4vJrCp0+fjho1qslT1QgEgtu3b1dXV4soxjZAehIhCHOhG4UtgIn3+FzMhUjCYE8ZJFrPnz+fNm0am80GEhl6ToRZZ2DuRfhpCcgqAcDevXsbM6nK19hs9tChQ/Py8poTm5KS0vv375tzhNYkVYkQAOhkuOZK4WIuRJInBVuESKS2bNnC4XCARIZ5fjD7PPSaAj3Gwbg98NsjUNQEgA0bNggETf8ezM3Nraqqev/+fUxMTGlpKQBUVVXl5uay2ewHDx5kZWUJq5WWlhYVFQkf83i8t2/f5uXlCQSC9+/f5+TkMJlMAMjKyoqMjExJSandcpUcUjjFBZ0Mfq6U8ZH8UeG8G25UGYq4A0II4AOTIJNAT17ccSBpweVyQ0JCAADshoH9iP9s07UAj5VwfW1ubm5iYqKTk1PTXmL06NFGRkafPn1SVFRMTU2Nj49/8eLFsmXLNDQ0DA0N4+Pjx44du2fPniNHjnz69OnIkSMA8OnTJxsbm1WrVnE4nD/++ENeXn7VqlW+vr6hoaFOTk55eXndu3ffsWNHc09e1KQwEQIAnQxXXSkTovhjIjAXIomAqy+hH3IpS/CB2VCFsvxPVVVVAADmferZbPGlcP+9bFsZx4Zfa63tNy8NKikpxcbGAsCsWbPOnj3r7OycmZn59OlTe3t7BoNhbm5e71K1Gzdu3L1799GjR42MjABg0KBBmZmZenp6ANCcFmrLkbZLozXoZLg6iCJDIY2K4LH4AABsNlvcQaH2Kwmvi6IfUcGFUg7RwL8yNv+fuvW9r0hfvtuZXH7DxynlNDQXyYgRX9qaNjY2wnt+ZmZmwuXz1NXVXV1dHz58+N1z6d2794gRI/bv35+ZmUkmS2LSkc4WoRCNDH6ulGnRfPezz5kXZ2ZlZtLoNBdnlzNHzmhoaIg7OtS+JBfDVDNMhKixfu3ynYTB4Rick5Orrq6GnHiAJXU3Zz8S/nedq2mvHk2/JiYrKyt8QKFQ+Hw+AMjI/DsSlk6ns1gsEolEEF+yab23AG/dunXr1q2goKCtW7euWLFiw4YNTY6nhUhichYhCgkO2Vcmbnd/2vUJTbWs2qwoGII9vTxr/mwItY4GLo3Gx8e3cjBICtDpdHd3dwCApAB4Hv6fbcXvIHQPAOjo6DT5BuG3vH79+vPnzwDA5/Pj4+NtbGy0tLQ+fPgg3PrkyRPhAzk5uZqLcHQ63cvL6/z589evX/fx8RFtPCIhzS1CofC7dwSWxaAM8pVAygRmX8HbrLfv3r3r1KmTuEND7UUxG8q5hLFSPYmQx+NNmzop7VlGzU9vhBpp06ZNwcHBPB4PDv0MfWaAlTvQ6JCTAFFHgckAgM2bN1MoIu4ioaGhMW7cuDFjxoSFhRkaGg4ePDgvL2/VqlWrVq2Sl5ePjo4WVuvbt6+3t7eTk9OYMWOWLVs2dOhQNTW1q1evDhkyRLTxiISUtwgBIOttFkuRRcsA775grQuQDzwVXs3vF4RaQXIRYadBqrc9GBkZ+enj+9Dbt1s7JtT22dnZnThxgkqlAp8L90/CUS84MAKCtgmzoLe3t7e3dxMOS6fTL126pKOjs2PHDjs7O2HhkCFDFi5cCACGhoYnTpxgMpleXl537twhkUj6+voJCQlaWlqGhob+/v7nz58HAF9f33Xr1nXv3l1XV3fbtm2ysrJFRUWrVq3av3+/6P4HiIzUtgiTk5OLi4sBgMQnKTxXkGEyp64ES21IiILqz9zCwsKIiAgAMDY2NjU1FXewSMo9LSIcvtFT5vLZQ39O4l85f3jU6NGtHBWSAjNnzuzcufP69etjYmJq7vhYWFhs3LhxypQpTTsmhUIR9gV1dXWtKTQzMwOA0NBQAOjcufO6detq72JhYbF69Wrh41GjRgEAjUb76aefhCWGhoYDBgxoWjCtQ2oTIY1GWzRvFrAKxrnIrLaq1lQGQw3QVoY1uSR+5+oYn1kXopiOPZwv+t4Ud6RI+iUXE0ON6kmELBYrJSnh3CY4tS29vLxcWVm59WNDbZ2Li0t0dPTnz58zMjLYbLaZmZkwabUEFRUVS0vLFjq4GEltIrS2tn6SnDF35vg3RbHHpwrk6QAAMjTY+DNRWM4b/TdFftCcXacOaWniGEPU4pKLiY32ZACorKxctmxpTGSwkjwVAEggGN+jmkSCyc5Vg3pZCru8VzC5zv3cDx06jHkRNZ6Ojo6Ojk5Lv4qLi4uLi0tLv0rrk9pECACKioqXr4UcO7zfdc/Wh+tKKWQAgHdFMPyQ5v5jl3M7uv50h7/BjrTEWvpvlCIxquRCLpPorEICAEVFxcOHj6xeyv34LPDMjDKVfyaaWfYTc9lPTBYX1txQK5Hvc/ToMQUFBXEGjVB7Iv05YPK0X4BMp5BBQAAAaCiCrLyiq9tP08zJD4dTz70WjIngl3LEHSWSXinFhLU6ifrPR01GRubAsfOjvf8atFc7rdakxJl50H+3hsnAtT6+tzALoh/C4/GioqL279+/Z8+egICAiooKcUfUxkh/Irx75457V2ZmHvTZqT7hbzUODzTlmG/fvgWAziqk+BFUAwWw9+c9KsCRhahF1Lv60uSpM5au//PcI6WaEp9H8rMWb1uybHXrRofavPDw8E6mndzc3NbvWv+/v/7nNc5Lr4PewYMHm3xAgiCeP3/O5XIbrpaQkHDx4sXGHPDAgQNv3rxpcjytQPoT4a3rZ3KLOVN8Oh25EDF+yQnX/brywAgKvC7cKkOBA70o+53JP4fzNifxBZgNkah9axnC+JjQ4d0qSqtg2y1acSUMt6mKvx/S+uGhNi00NNRjiEeeTh6xgmDNY7Hmsvir+UwX5vJVyzdv3ty0Y7JYLGtr6++OMUtJSWnk8r+nT5+W8CWZpDwR8ni8O5GPFC2nxjx+YW9vP2q0V+i9ZJZyz6CAG7Wr/dyR/GQkNSKX+DmcX8wGAPj48eOtW7cePXoknFUIoSard2F6giAextzj8EgD92gRXda47tMrrqImPX0imVMSI8nEZrNnzp5JdCcEQwWg+E8pDaAX8Efwf9/2+4sXL0T7cm/fvi0vL69dSBDEmzdv6szkzGQyc3Nzvz5CeXl5Tk6OcEUniSLlifDNmze+fjf3Hz5dM22Hrq5u0N2HE6fNrfOXM1IkRQ+lOmiCgz9v7KKlDu4Ok49OHr52uKWD5bt378QRO5IGHAG8Lie6qddNhKmpqdnviw48cQq5l7Jx0+9hMSkn0lxyPhTjdGuo8SIjIws/FxID67uQZQ00XVojL102xvnz57t06TJlypQuXbpMnz5dOGaxsLCwd+/ekydP7tChg6+vLwBUVVVNnTrV2tp61KhRXbt2ffnyZc0RNm/ebGVlNXv2bCcnpwMHDogqMJGQ5l6jAGBubm5ubl6nkEQizZw58+vKVDJsdqDQX4RsjD0vGFsKJKiESkYuY8y0MYn3E1slXiRtnjEIU2WS7FeDdCIiInbt3jV/4TISiQQA2traAbfvnzpx5N69KKnsno5aQnp6Ol2XzpJj1buVrc9OSUsR1Wt5enpOnTqVTCZzOJx+/foFBQUBQFxcXHJysrW1dWJioqurq5ub24EDB/h8flZWFoVCOXv27Lx58+7duwcAXC53x44dBQUFqqqqAFBZWSmqwERCyhNhE2TcvyJwKK1Z2IToQHx8+LGqqkpeHtdURT/sW6vSz5s37+uuobPnLhAu541QY7DZ7Ia+wilQzaoW1WupqKj4+PgkJyezWKyqqqq0tDRtbW1nZ2dra2sAcHR0tLCwePToUUBAwMiRI2/evAkAZDI5Li5OuB4FlUrt2LHjvHnzJk2aNGjQIEVFxe+8XuuS8kujTcDj8b5kwX8unZbzIOgdv7qe1UUQ+o5v9ZT51gAJHDiBGs/Y2JhfyIdvdGOgMWjmpnWvhzXZ3Llzg4ODPTw8Zs+ebWVlJVwTuPacD8rKymVlZQwGo6SkJCcnJycnJz8/f+vWrcJuFiQSKTY21tbWdteuXXp6en5+fqIKTCSwRVjXaM/Rdw7eKTMoI0UD0R+gAtTkNS9+kPN+wu2rSxpuRB7RkawrV3evmJiYly9fGhsbu7q6SubKk0gskoqIcSb4fkAtwsPDA/gAaQD2X20rBH4Of9SBUaJ6rbCwsIiIiK5duwLAx48fjY2NASAtLY3H41GpVDabnZ6ebmlpaW1tbWZmtmzZsq+PoK2tvXbt2rVr1/r4+Ozdu3fcuHGiiq35MBHWNc5rnP9t/4hbEVUvi8iVMqocrTD/a126UEvYEPFJEPSOWPuEa6JEGmZEmmBCtlQlsdnsfh79srhZJRolKuUqumt14yLi1NTUxH0eSPz4BDwrIWy/6imDkEhoampuWL9h646tfHk+dK61oQDo1+j9XPt5eHg0+eD79+8X3s8DgPHjx9vb22/btm3y5Mm3b99+8+ZN3759AYDL5c6cOXPs2LEXL160sbFxdHTcvn37sGHDqqurbWxsPn78mJGRIRzRWFxcPHPmTA8PDyUlpWvXrvXs2bM5Jy5ymAjrceXMlePHjweeWFoi6HAvOV1OTg4A1GRgrDF5rDGw+ZQH+UTQe4FbKF+GDKp316erpHHsWQBQCqUVryvmLJ5z/cJ1cZ8EEr9XZYSuHEmFLu44kPTauHFjRWXF3j/30gxpnA4coAKtgMZ7zevn1u+G343v718fGo22Y8eO2iUUCuXChQsHDhwIDAwcNGjQ2LFjSSSSqqrq8ePHKRRKUFCQo6OjcJEmR0fH+Pj4ixcvBgYG6urqClexWLJkiY2NTUlJSWxsLJfL/fnnn6dOndr8cxchksSu1W5lZeXn52dlZSWWV58xcfivXYLX+Gv73Un71lS2AgISConhblZFw16AzD+lBBhcNfjw4vvrHVZUVCgpKX23mnRonyd7OVsQ8Jbwc5Xmid2rqqpkZWXbye0ADocDAHS6iH/axMXFrVy5Mi4urslHePbs2fnz5xOeJnC4nG5du3mN8Ro8eDCp/hUw25eAgIBz5859d+A/tggBAAQCgZ+fX1lpaSkjX1iS8jS+5zDwsi9dtsjb1s4OAGTlFOQUVNzc3ExMTIR1yCRw1ibpKlCK6oyBbh9fCui7kosIe038MkItrlu3bn/++ae4o2jDMBECAJDJZAcHh7E/D9aj5/7Sn0cmwYVfgESC6b05xi8Dqz8Hvi2ETbdoW7ZuEd4irs1rhNebB2+YPb/0eqek04s79N+VKlhiTf569BhqV5KKidU2+KsItZ7S0tKaG3uo8fBT+oWFhcXjpJede00KfKbqbgPdDAEAlOVgmD3IyVAuJencvhu1ZPm6r682/Lbqt35y/bRuaSk+UtQM1exebPfo/NGnRYSFH+/ESwFfQi88oxZHAKQUE3bfWJgeIZFLTEw8d/asuKNokzAR/ktWVvbAsfODJu0ceejfn1QhybDngVVUXIZL7z717kWlUm/fuB1zKebivIsRf0c8vvfYVk/Rz5VyzZVyKUtge5MX/B6TYXv0roKQo5J0vhppg1ALuexz4orPUXFH0SZhIqzLxMzSUp8EAAXlQBBgqQ/KSnLq6uoN72VpaTly5EhbW9uakp7apPvDqH85U9Y94f8UyksuxnTYviQVE/Ya4g4CtRsCgSAkKIBfXZSdnd3MQxEEUVJSUlJS0uSJ0AiCOHHiBIfDuXr1al5eXsOVnzx5Ehsb27QXEhVMhHXduuEz3Lrk5H2Zfru1RxxSV5CB/I85jZn4qrCw8OtCtw6k5FHUscbkYXf54yL5byoIAEhMTPQc69nTtef0X6fXO0c7kgLJxYQDXhdFrSUmJqZ7J/5Ml4orF88081AsFktdXd3Y2NjQ0FBDQ2PdunU/OrhAIBB4e3uzWKyDBw/Wu2jB5MmTaxJ2ZGRkSIiYFyATQWeZFy9eXL9+nU6nT5482cDAoKb87du3YWFhNU89PT2FW8PDw+/fv29oaDht2jThED2JEhIcnKGhYt59ePLzE7EPH3ounUXhFkZEhI8c+XPDO/7qPffa9Rtf9yOnkmGuJXmyGfnwc4FTIK8PI/L+0cklAxhgDi8/vAwbEJYYndihQ4cWOyEkHslFxGxL/KGJWgSXyxWuF8jhcIQ/008e2z+hO8PZDNz+8hkybDQAyMjICGdI1tLSasLgpaSkJBMTk5cvX/bq1cvR0XHMmDE1L02j0YSP+Xw+hfKfPoF8Pr/2d2Cdpp5wGhoAePjwYUVFhbBw7dq1dY5Q55hfF9aOQSSa+0FNTk52dnbmcDgfP350cHD49OlTzaaUlJTNmzc//YdwFaujR4/OmjVLWVk5ICBg8ODBkjaKMSMjg8kmlm/3PfT3BTk5Obeffop8mGZuO/CW/7WGd8zOzvYPCHjw4MG3KihQYY0t+YUXLfrY4pIRDNADqAbCjPjc8/Nv234T9Xkg8UsuhnpnGUWo+Wg02u3bt7t26TxhmNOuFZ67lv2kWHbPwwa0lWFi95I9y3/atXzI0un9TU1N/9i5ozk5w9LS0tHR8dmzZ//73//Wrl3bs2dPTU3NxMTEjIyMfv36mZiYGBoaCtdUIghiw4YNenp6xsbGe/fuFe7u5uaWkJBQVlY2a9YsPT29Tp06OTg4rF27Nj8/f9KkSY6Ojrdu3dq3b9/mzZsJgti8ebOenp6hoaGHh8fHjx8BYOLEiX/88YeVlZW2tvaAAQMYDMb79+9dXFxMTU0NDAz69+8vkv+ZIIy+OSZOnChsOBMEMX78+A0bNtRs8vf379evX+3KXC7XwMAgLCyMIAg2m21gYBAREfGtI3ft2jU9Pb2Z4f2o5OTk4uLir8sjIyMb3nHr/9bOGkD2njn2uy+hY6EDmwF+A4oZwGaAtdCtV7cmhtt2lJeXizuE1lNeXv65ilD34QjEHUkrYDKZfD5f3FG0EjabzWazRX7Y2NjYXr16NWHHp0+fWpl3ODGXTlyCOv8St0FXY5WTfx9twmGFE2pnZ2cTBPHhwwdNTc3Lly/PmzdPR0cnMzOTIIjKykpTU9Pr168TBFFQUGBhYRETE3Pz5k0zM7PCwkKBQDBv3jwAKCsrs7KyiomJmT59+pgxY6qrqwmCePXqlUAgMDIySk5OFr7c//73vyVLlly6dMnMzOzz588CgWDRokXCZlK/fv2cnZ1LS0t5PN6QIUO2b9++ePHiNWvWCHfMycn57rn4+/uPHDnyu9Wa2yKMiooaMmSI8LGHh0dkZGTtrUVFRYcPH/b19S0uLgaAzMzMwsLCgQMHAgCdTh80aFBUVFQzAxAtOzu7evvFDBo0qOEdA29e3jtZEPfwvnDuiQbIUGWAD+RXQOQAlAIwwLhT3bGJqK1LKibsNHBiD9SyHBwcHjx+FvTeefY5ZTb33/JDETKzL3e8Fhw3e+68Jh98wIABpqamnTt3HjVq1Pjx4wFg/PjxwuVd4+PjBQJBp06dnj59+v79+z59+ty5cycwMHDWrFmampokEmnVqlU1xxEIBFevXt25c6dwdXQLC4t6p7wJCAiYO3eutrY2iUTasGFDeHi4sKuOt7e3iooKhULx9PTMyMjQ0tKKiooKDAysrKz8elR3kzXrHiGPxyssLNTW1hY+1dXVrd1BSFZW1tzcPCcnJzg4eMGCBeHh4SUlJerq6sJrxML6tS+l1sFisbZt26ah8aXj3eDBgwcPHtycaEWourr6r/37qsryAaCspKiaxe6kWqkqD66W7Amj3TXUVFTVNQFIVDm1xUuW1ZmA+9eZv+68uVO2tGKyB5xIAf5H9ZVnVrJY9S+tKTVYLJZor+lLMhaLlZAvY6tKsFjSv3aX8K3brqZYEwgEDdSh0Whf3+JqOWpqagEh9zp2UK89ZNkvUfHC1WDhShFNduHCBWNjYz09vZpPbs1XfX5+PovFOnHihPAplUq1tLRMS0vT0tKqUxMAKisrWSyWnp5ewy9XO5VoamqSyeSioiIAqJkfQEZGhs1mr169WlFRcd++fZMmTZoxY8bhw4dFMpNcoxLhgwcPapp9tSUkJJDJ5Jq3RZ37mR4eHjVzn69YsWLdunXr1q2r/R7i8/k1SfFrZDLZ0NBQV1dX+FRDQ6M1314NU1RUHOM1duKYId31C5YM5gFAhwEAABuHlb0pjAaAK4/I154qXbx6S1NTs86+KxavYLPZl4/+vmmUwG8djTbvfIqqs7OknFlLoVAokvPna2kUCiW1hDSqI6k9nLHwL9tOEqHwPdzwO7n1Z/hMSUmxN6bK0yHyOSnzM/XXgdzhNhWR4XeES+Y2maGhoZGRUb2bzM3NBQLBwYMHZWRqJlmGhISEFy9eCB9nZGTUlCsrK2tqaqakpPTp8+9QbCqVKlynsIaJiUnNXi9evKBSqfV2IaTT6UuXLl26dGlubq6tre2sWbO6d+/e1FP8V6MSYe/evYXJuQ4ZGRltbe1Pnz516dIFAD59+qSvr1/vEQYMGODv76+vr89gMFgslrCN/OnTJ2FDu150On369OnimnT7u2xsbBLTshbPm3YgKuLYlFIFGQAAdUVQkYffg5XSKi0TUoJqZusuKCjYtnVT/vsvf+Y373JnD5JRla/uYa5Yfm/jnrDdQaokNVlKN8dBq1evFvmUvpKARqO1nxYhjUZLLSFt70Gh0aT/4qjwL9tOEiFBEAAgae/kW/5Xf7IoWXZFIbGgk6m5ZeBfUasHl+y4eWnJspUt9IpOTk4ODg6TJ09evnw5nU5/8uSJlZXV3LlzBwwY4OTkZGxsvHHjxtr1f/vttzlz5uzbt09PT+/Bgwfz58/v0qXLqVOncnJyHB0dhXUWLFjg5uZma2trbGy8atWq+fPn1/v/+ciRIwYGBhYWFi9fviQI4lsZ50c1KhGSyWRh6vra0KFD/f39XV1dAcDf39/T0xMA0tPTtbW11dTUas4kLCzM0tLS3Ny8U6dOwcHBXl5eyBq9DQAAIABJREFUFRUVERERS5YsEclpiIWcnNzJc9d27fx9me+eE9O/dAXeESxTrD7u7pWTtX8Yamtrz/GeP2HMkIkOBVN6cVXkQVEWAODK3JIqTklxBay+LlfAsvn111+lMgu2NxU8UkE1Ya4i/VkQSYKgAL+CzzLzFi6N/m0LhUIJ8L85f8Wv7z+lN3neUSqVOnfu3NqrzwNAnz59ah8tICDg6NGje/fu5XA4VlZWw4YNMzQ0vHnz5tGjRwUCwebNmzt16kSn08ePH6+vr9+3b18DA4Pz589XVFTY29uTyeQTJ06cOXMmMjJSX1+/R48eLBbLwcEhJCTk+PHjZWVl48ePnz9/PgAMHz68U6dOwlfs0qWLQCDQ09O7ceOGsNEVEhLy3SuujdWEPkW1ZWZmamlpTZkyZcSIEebm5sIul7a2tkePHp04caKnp6e3t3ffvn11dXVTU1MJgvDz89PU1Jw/f769vb2Xl1cDRxZLr9Em+HPXttPeVOISpP0BxCUIWwtL5k2rt2ZFRcVEL8+pg1SYZ//t3PX5GLg7qo+Zv9zSj10i+v5okqKd9Bp9+fKl2wg3LTMDOUvL8xfOizuc1oC9Rpuvyb1GCYL48OGDVReLp0+f1i7Mz88fNsT18uXLooiubWtkr9HmDqg3Nzd//vz53bt36XS6p6enoqIiAJw6dUpfX3/06NGPHz/Oz88fPnx4//79hZvGjh3brVu32NjYESNG/PTTTyLI5OIW7H/55DjerLOqzwo0OygwDk9irA6IqLemoqLi5Wshixd4H488vXzIl+vj8y6qzlxxZPyECQvj+BOieCHuVEp9DQmBQPD48eNevXq13ImgZvr48eOA4QPyB+SDA0A1LD64uJBRuGLxCnHHhaTck6cpdWYm0dHRCbodkZWVJa6Q2hwRzCwjbBHWLqm57DtixIiv61taWlpaWjb/dSVBcXHxi8yccX9rrtqw58yUGXfvhA5fNpvBYDx//vxbdzcLP2XP7slnc+FeBnjYglvnyoLPHwHgL2eKxx3euif83U713Ip/+PDhwX1/XA+43bLng5phz8E9n7t/BuENfjko8yjbd2QfJkLUompP5lWHmZlZa0bSprWLW9wt5/bt29bWNrcikidOmQEA7h5DIh6m9ezV91ZgYL31uVzui4w0AOi3S/1wcu9RRzScTXnBNy8BAJUMfq7UgHeEz+t6OmdfOX80JuaecHYeJJlSM1IJnVp92CnAo/KEY5MRQpIME2Gz2NrahkfH1/5RpqGh4RcQ5jl0aL31Y2Jiihllv14zO3v9wZUboXPWn53po/ck+UVZWRkAqMtA0GDKysf8mPz/zDzH4/HiHt5bOJgU4H+9RU8HNYdtV1vS51rXtflA5VGFkz0ihCQZJsJmsbGxqXfYUO31mGq7HRI0bab3/fgM4VhXz6HDIx6mDRw44O7du8IKnVVIFwZQJ93jf2D+mwvDwsIGWXKmOFf7+hxrgZNAorFq8SqdpzogXE2kGlTuqCxfsFzMMSGEGkEE9whR4y1avLSmN7CQpqbmjcA7b9++rSlxNyBNUsi0tpuky/ukqiTL53FZbM7ZmaUm2kCrynbsqkehUFgcQSWL+HXh8tpTGSHxMjAwiA6K7vPLAkHUKx01pbVL1k6bMk3cQSGEvg8TYauqkwW/Vb57RNeP3ID4zcOGWOZsGlld0+YMXFQCAK/yYNoZzYXrN83xXtii0aIf1cmsM3duaNpQtpGGorhjQQg1Fl4alVDnR3Uy2Jb4UG7Gz0fUSmqtCnzpEW3SGYOTVyIxC0qge3mEjTpJjS5Zi4shhBqGLUIJRSPDtcGyTtUHjQuyU9+HDejypfzPu0q37yeIbD4FJFKhHwRDDPHHJfphwiVdxR2FFBIufPRdmAgll44cBLiRPdek9ZkEiTkQkUFZ5ckfZseJi4sdM8ZL3NGhetz+QFx3w0SIfoyZmZmCgoKzs7O4A5FONWs/NAAToUQj3qc46TM33CCdekJUa/MvxZPWe1YGXT+HiVACZZYRTB5ho06qrBB3KKhN0dbWvn//vrijaNcwEUq0IH/fyJSKe85QMRuADOm5xOKrZD4nos6KV0gS3P5ADDMi40zbCLU5eBlHoqWkvZAxUa8Y8M8fqgMUeQg6dOwUHx8v3sDQ10I/CIYYYB5EqO3BRCjR/j55mkb+76JcXBjp5eXg4CCmiFD9mDx4VEC4dcAPFEJtD35uJZq2traprikp+592Bhs00zQneU2qM9k8ErvIXIGTFklJslZsRQg1Ct4jlHT+l/xHTxn9OuU1R5bEzCcf2f+XcHq2hvF4PBaLJVz6CrWC0I8EDpxAqI3CRCjptLW1H4Y9ZDAYxYwStyeGlgMb1eiIiorKz/s0bfqMFo4OfRH6gQj1wESIUJuEH922QV1d3dzMdLoF5Xx9izR9zff8EV+fIy0dFRJKLyHIJOiiij1lEGqTMBG2JTMtyBdeC9j871RjsVhPnzwqLXhXUFDQKnG1d7c/EJ6GmAURaqswEbYlxkqkbuqk4PffaRTevh3iacMZ1738xrUrrRNYO4czqyHUpuE9wjZmlgX5TKZgjPF/vnajo6MfP3oABJ9dzaxiVkRERJyeVKalBD/9tetd9gtZOQU5BSUgUaxtHIZ+Y8Vg1GTlXEgqIgbq/dsiFAgadfkaISQh8GdsGzPGmPy4gKi9bC8AuLi45L7P2f/nDrOSP91k/949PNvWCPTV4MTkPDfZv22q9h0/sONZ8uP+/fuLK2wpFvZR0FuXJF/rJ+WxY8f4/O9dv0YISQxMhG2MLAXGmZAvvP5PIqTT6QePnT1++tLucE0lWRhk9aW8twV01ITdYWpL1/x+0S8YR1O0hNAPhGet66IEQRw7vA+njkSoDcFE2PbM6kw+9Urw9ZJ3P48aey04buoZzdySLyVVHBi8V/nYxcgly9e0boztBQFw5yNRe2a1uLg4JUrFlfPYZRehNgMTYdvjqElSpkFMXj2rvxobG8vJkPVVoZIFjEqQp4OuuqyJiUnrB9lOJBcRynQwVf43EV4+d2T/JNaT+IdsNluMgSGE/t/efcc1cb8PAH8uCSRsCEOGgCDKcoEFBXGh4LZ1gq2javVr3W31q1Zr66+2tdXaOltRQaoMAakiKoJVhuKkKA4QBFSmiBAJJECSu98f6ReZCuVCSPK8X331lTs+d/ecyeXJfe4z2g8byyikhX0ZgdnkSLPmE1Bcu3bN00584wmxMtyIpBg7pr0c71xzMS5utp+fXOJUeueeSYaSj9PSagFALBbz+fyUpL/2boWxmbX79u0dMmSopqYmAKipqVlbW+vp6ck7XoRQKzARKqS5fRjf/C3i1TP11ZusPxt94mE+f8vr/tFxMRoaGks/nvW68E6OJAgToYzEFcOIF3+P/PgT197qA23YWuqSTROETAYsHV4VmLr9TCrrZRURllQ5a+b0Q4eD5B0sQqh1WDWqkAzZ4GPBiMhr3kw//lLSlHmbE5LTra2tTUxMTp9P+mjlTyk37onFYrnEqdwq6uBhJfXN8nlp6Rm1DJMBZtU7pvPmDKkDgL5msGNG1apRFfkvYeeP34WERWJLJYS6LUyEimqRPSMwu0ki5PP5J8Ki1m/6msF487Z+snTF5cSr5eXlXR6g8osrJEebMdhMsLe3v5KakfLa97OTbyo/Ux4T0w71/DUofs3nG+UYJELonTARKipfC6JEABkVb5rM6OjoDBgwoGXJ3r17m5qadmFoquJCATXhfyOraWlprfhsM0/45lkDRVFDhnjizJEIdX+YCBUVg4D5fYh2jsGNaEdSEF9Ejm/UceLsn6FT+1Wk5YPrN3q/Jmh69IHUa8kU1UrjXoRQt4KJUIEtat8Y3EgWbr2kTDUIK+03ifBC7OlbTzU+P+t8KCSh1HDRpL1GXI4gPT1djkEihNoDE6ECs9Eh+hm8ewxuJAvnC8jGM07k5+fff1ykNWD1X1fvOjg47Ni1b+sv0c8q1GJOR8oxSIRQe2AiVGyL7BlB2ZgI5eB8QZMp6XNycq7fuLnlmx9YrH8eE3p5Db/3KN/IxEJOASKE2gv7ESq2Gb0Ya69LCmooSy2cD6/rlAkhj095mLz5N/f19W1ZTEdHZ+XKlV0YF0Lo38A7QsWmwWplDG4ka+cKSB8LhhpePQgpBbyUFd7CvoyjrY3BjWTnQkGTgbYRQgoNE6HCczMmdNoYgxvJgpiES8XkuJ547SCkJPBiVgYf920+ygySnWsvqN46hJmmvONACNEEE6EymNeHEfOM5NXLOw7VcKGwSccJhJCiw0SoDNoagxvJQrOOEwghRYfXs5JoOQY3koXCGqpUQLkZ4x0hQsqDhkQYGhrav39/KyurtWvXikSihvWnT59+r6nnz5/v3r278Zr6eqzOo0fLMbiRLJwroMb1ZDAxDyKkRDrbof7BgweffvppTExMnz59ZsyYsWvXrk2bNkn/5OXldejQIenr06dPh4WFWVpaFhYWuri4LFu27J/Ds7BHPz0axuD+eUjzaesRjS4UULNtMQ0ipFQ6e0d49OjRWbNmjRw50tzcfMuWLQEBAQ1/MjIyGvw/qampCxcuJAgCAMzMzBrWN545D3USjsEta/UkJJZgxwmElE1nL+lHjx65uLhIX7u4uDx9+lQgEDQrk5+fn5ycPH/+fOliSEiIq6vrtGnTUlJSOnl01Jh0DO5zBfikUFaSSihnA8KQLe84EEK0alfNJEmSUVFRLde7ubm9evVKV1dXuqinpwcA5eXlVlZWjYsFBQX5+vpaWloCwMSJE6dOncrlchMSEnx9fZOTk93c3Fo9aFVVlbu7u/QmEgDWr1//xRdftPu8FEBNTU3D2dHlQ2tGwEOGr5GY3t12nixOtuvF5LHGmEB1de3biynHybaTQCAQi8UqUrUjbdOgrq7+ljJsNltNTa2rIkL0aG8iPH36dMv1xsbGBgYGfD5fulhVVQUAXC632bbBwcG7d++WLo4dO1b6YsCAAffu3QsNDW0rEero6Jw6dcrR0VG6yGaz3/75UzgURWlra9O7z48cYGO6qJJgd7cxuGVxsl0voVQcOpqprc15ezHlONl2YjAYHA4HEyFSaO1KhCwWKzQ0tNU/RUREZGZmSl9nZmaampo2+wqIj4+vqamZPHlyy211dXWFQmFbByUIQktLS0dHpz0RIikNFsyyZRzPob4c1L0SoRLI51Ov6ykXI/yHRUjZdPZ33IIFC8LDw588eVJXV7dz584FCxYAQFhY2LFjx6QFAgMDFyxYwGb/81wlNja2pqaGJMnExMQTJ05MnDixkwGgZhbhGNyyEfucmmjJwDSIkPLpbCIcOnTohg0bhgwZYmxsrK2tvWXLFgDIzMy8f/8+AFRXVz948GDRokUN5Q8cOGBsbKylpbV48eIffvhh6tSpnQwANeNmTGgIyrYdOhkWFlZYWNjOrSgKU+c7XCgkJ+DIaggpI4Kub0CSJNv/nKA9hZ2dnSMiIpydnTsdWjfF5/NlUfEbGR25aP1KYR8+i0nq5ul+/dnXK5auePdWkZGenp4WFrKaTl1GJ9tlhGIwDRE9m6Om347HQ4p+sh0iEAjwGSFSdLR9fDt0JajIZdP1Xr9+vWrjqmr/MomHsM697uWsl9t+2fbs2bN3bhh6bH/UyZAuiFBBXS6hXI2I9mRBhJDCwYSkVO7cuVNnXQcN39dMqOpddfXq1bdvxePxcrLuR4YdlXV4CurFixcxj1/jQNsIKSu8tpUKi8VikE3eUwbJeOc4dtGnIuZ71ukyK588eSLL6BTPlcQrNv1sBo4feHSZfehqr+LiYnlHhBCiHw71qVRcXV3VC9RBCKABAAAi0MnV8fLyalbs2bNnEomkqqpKIpEAwB9H9h3zF/TQqTu4b/dH8xcDAIfD0dDQ0NLS6tGjR1efQ7dRVFTkv9S/7P0y0AYAyMh/OXHGxLvX78o7LoQQzTARKhUdHZ2gA0ELVywUWgslBCXI4mzd/nPLJjC5ubkf+s800a7zcNAEgAl2tb2MgastST8TFvBVJAD8eb3K2tYhIqqVURRUx9lzZyscK+B/3WIpG6r0QWlBQYF0jCSEkNLARKhsxvuMf3zn8c2bN8Vi8WlicJauYcsy3t7eGQ+yFsyZYqbzaOvUamnnOF0N+NWfx6+FJcEG06ZN3/vbsYben6qpsKRQrNFksDpSi3z58iUmQoSUDD4jVEK6uro+Pj4TJkzYMdokIp98xGulh4yJiUlsfKrIeuHkPfoN3e+fv4JRPxlN/3TfocAwFc+CADDSc6R+of6bZTFAITg5OckvIoSQTGAiVGYGbFjXn7n5duvzUTCZzE1bv38lUGsYLkVTHbR0DWf7f9R1IXZjPj4+7kbuWpf1oBAgF7inuV9v+JrDecdAowghhYOJUMmt6ce4X0ldLm592IT4+Iu+TrUlPJi81+C/Ubo6HGCIKsrKyro4yG4r7s+40eN+G1Dh/x/uf+KPxbdnaAKEkMLBRKjk1Bnw7WDGupuSVocfjYkMqq+tmbTPdO234ZYjtozcaWKlyzsXe6bLw+ymCIJ4aj/ryO+hv//6++DBg+UdDkJIJjARKj//3gwNFoTnNa8glUgk5+KTizjjL1/PHOvju2rt+mNRSZk8q5joMLnE2Q2VCqFUSA3GGScQUmqYCJUfAbBrCHPzHbJW0mR9VlbW/oOHT0Sc09f/p0mIg4ND6p3MocPHiUQiOQTa/cQVkGPMGTjlBELKDROhSvAwIVwMib0Pm9wUOjs7+/n5NSuppqa2YcMGnGJbKqGI8rHANIiQksNEqCp2ujN+vi8pr5V3HIqDArhUTGIiREjpYSJUFb11CT9bxrfpkncXRQAAkF5OGbIJK21MhAgpOUyEKmSrCzMsl8x+jXPwtkt8ETWuJ2ZBhJQfJkIVYsSBL/ozN7XRvx41E19I+ljgBYKQ8sPrXLWs6cf4+xWVUoo3he9QI4Y75dQIU7wjREj5YSJULRwmbB/MWHdTgpnw7RJLKDdjQhsbzyKkAjARqpwP7RgkBREt+tejxhKKsF4UIVWBl7rKkfav33SbrOtEA9Lr16/TF1F3FF9I+WLHCYRUAyZCVTTSjOjPJfY/+vc3hZs3fpGZmUljSN1KYQ1VXksNMsREiJBKwESoon5yZ/x4T/Kq7t9sW1xcfOfO7bDjAXQH1V1cLKR8e+LIagipCkyEKspej5hly/juX/WvDw8J3jaTiPkzkqKUs81NPI6shpAqwUSour5xZR5/QuZ0vH99ZNjRjzxEzmZ1aWlpsghMvkgKruDIagipEpa8A0ByY8yBz/oxN98hI8Yw31KMJMnt27cHHz2gq8lSYzEoUuxoWmuiC/PdXy30n6CpyZaQwK+pt7C2P/ZHiJWVVZfFLyN3yilTTcJcExMhQqoCE6FK+7w/wyFSfLWU8mq75ziDwfjqq6/0tNkRQTtPfPLKxvif9eMGUOMGlFMU/BSnFf+0z/HQk+bm5l0Utyxhe1GEVA1Wjao0DhPW21ZMWzSvV79edoPstv+4vdWZCAmCWPP5hj1BF6Yfsoi+8+b2sZwPk/dyi3X94y7fUo4sCAAJRaRvT7wuEFIheMGrtNra2j1LvV7phT+b+Sx3Su4Pf/0wb8m8tgq/957b8Yi4A0kGDWuSMsF64KQ9B44ozfyFfBHcfUUN74F3hAipEEyEKu3cuXPFJsWUgwQIABYIhgku375cXl7eVvnUa8lT+vPrxfDjOfWsYvAdAH/futqVAcvalWJyqAmh0fSJQX19vZzCQQh1BUyEKu3uw7s13JrGa0gTMicnp63yZ6OCexvVjdppKLBZsyDE7o9UTX316ufPn8s+0i6SUET5tKgXDQoKys/Pl0s8CKEugIlQpQ1wHKBZodl4DeMlo0+fPq0WFggEial3v//LNiAscdv2n5JvPMjX+ij1YeXZM6e6JNiucLGolZYyoUH7wk8EyiUehFAXwESo0qZMmWL+wpyZwwQKQAJEikYf+xFGRkatFr58+fKKFSuTbmb269cPANhs9q49ATGxF+9l3O/aqGXlKZ/i11P9uU0SYWFhYW1V8Z9RJ+QVFUJI1jARqjQOh3Mt4dostVlWEVa2Z2wXua97MjX47qvWu9iPGTNmx08/q6urN145arT3nr0HuiRYmbtYRPn2bD6wWnjIsU+8qnvq1jx48EA+YSGEZAz7Eao6ExOTsKCwhsWofHJKvCR1KtNSq3kNoYaGRqt7aGu9wkkooqZZEzdu3CgsLJSOHlddXX0iOOCvtSJ9zfJtWze+P92fzWYDgLq6upOTU1t1yAghxYKJEDUx04aRx4cJcZJrU1h66u8u306JiYlTpkyhbXcyIKHgSjG531ONJ9Zf8rE/s654zjCWHrtu6zjSUBsmD6Iqq89V/hVfIWDtOS8aP358QKNfDwghhYZVo6i5/w5gjDYj/C6LxTTN3SsSiVZ8upTP59OzO9m49ZKy1iZMNcDBweH23awho6Y9LGHP8yKnuwEAaKjDUm+Y6iL6K0vz623fhkae1dbWlnfICCF6YCJErfjVg8lhEsuudWLq3kYuXbrE5708/We3blwaX0j59vynNpjD4RwKOjn6wx9G/ajXMMFGVjFM3t/j16D4NZ9vlFuUCCEZwESIWsEkIHQ0834F9cM9Gu4KQ4P2HfxYEh58sPO7kp34ItLHosnlMHHyNB0tdYKAejEAgJk+6Ghru7q6yic+hJDMYCJErdNkwWkf1qFM8sSTTuXC2traBxl3/D2gsuxpWVkZXeHRq0oEDyspr6Yjq8WePT3JmX87D4Z8x51+kFsvBm0mv7CwUF5BIoRkhJ5EWFhYWFxc3HJ9bW3t5cuXU1NTJZI3lWzl5eUXL17Exujdn5kmnB/P/OKm5EpJB+YsFAqFH3+8gKun5eLQY0h/cy8Xy/keAoKAJcOrJo50HtLfbLCTqaG+1swZ06qqqmQXfIdcKiI9exDsprNRnY0Kvvcc1p9zjjp/a8mXwb57zNXIytiYaDnFiBCSGapzgoODuVyumpra8OHDm/2pqKjI1tZ29OjRgwcP9vDwqKmpoSjq0qVLRkZGU6dOtbKyWr169Vv27OTk9ODBg06G151VVVXJO4R2uVJMmp6oz+KR7d+EJMkd278a48otPgBUSJP/Xh+BWcMNli70r6urk13MHbXsqviX+5LGawQCgb6u1nfbvhSLxdI15eXlM6Z4T/Bp/jlvSVHeWVrU1NRIJJJ3l1MKdXV13epzi+jS2UT45MmT3NzcgICAlolwzZo1c+fOpShKLBZ7enoeOHCAoqhBgwYdPnyYoqjS0lI9Pb23pDpMhN3H0ccS23DRC0HHtroYd2GgfY/krYyGLJj2HbjYG52KCpdNmP+ebbjoYWWTTJ+ZmZmWltay5MmTJ0Ui0dv3pkDvbOdhIkRKoLNVo71797a1tW31T9HR0XPnzgUAJpM5Z86c6OjovLy8+/fv+/v7A0CPHj3Gjh0bHY0VTQpgUV/GnN7E5HixQNyBrXzHjd/87b7T93Qa1sQ90Fi6Ztv0GX70h9gJT6qoOhKc9Js8IHRwcGi1Xczs2bNZLOx9i5BSkdUlTZJkSUmJlZWVdNHKyqqwsLCwsNDQ0LChA5a1tfVbmh6IRKK4uLiHDx9KF52cnJycnGQUrVyQJEmSNPXUk71trsQzPjU/URw+mtF8FLK2XY6L8u//upQHP17QXOsjmDpI+H9xkUv/s0yWkXbYxQLK1xxofC8U653tJFU72Yb/t4UgCILA+SwVTLsSYW5u7ooVK1qu/+WXXxwdHVvdRCQSSSSShvla1dXVa2tr6+rqGs/gKl3Z1kHFYvGFCxd0dXWli9OnT2/r1lNBNfvX6P72u8EHV5ifpwhtMo6k3Eox72G+bOGyt7wpFEVdS0nynshcE2n04cK10wMOrh5Zlp31sKqqqtmApfIVV8CaaSWpre1Ag6C3U7h3tjOklzCDoRLtz6UzU749Eaqrq2OdgcJp1xtmYmKybt26luvNzc3b2oTNZhsYGJSXl9vZ2QFAeXm5mZmZqalpRUUFSZLSy+bly5dmZmZt7UFDQ2PPnj3Ozs7tiVARSSQSTU3Nd5frTk6OqrN28yB75ddbC4gS4uSMk2EHw8aOGdtq4b///jv7afmfhT5XroeyWKzlK1Z+sXpJVn7k7du3fXx8ujjytohJuFomChylocmhbZ+K+M52BofDUZFEKM1w3epnHKJFuxKhjo7O2LGtf9m9hYeHR1JS0tChQwEgMTHR09Ozb9++WlpaN2/e9PDwoCgqKSlp165dHQ4Zyc/xwP1U79x691oAoIAq71m+dO3SvPt5rRZOSUk5FnzMf85cAODz+dra2ocCw6ZOn3Pr5s3ukwivl1F2uoQxfVkQIaRwOnsL/+TJk1OnTt26daugoODHH3+0t7cfPXq0kZHR/fv3v/jii+nTp3O53IqKiqioqDt37rDZ7FWrVi1ZsmTz5s0JCQnq6uqTJk2i5TRQ17iUcqmuV6PabC0QUILq6upWB95cvnx5yxrCSZOn+o6bINMgOyShiGwYWQ0hpJroqct2d3d3d3eXvuZwOFu3bjUyMnJwcDh9+nRISAiHw0lJSZHWkX711VdWVlYXL160tLRMSkrCynTFYmFmAc2GzhZBW9WAbT0n61bPz+KLqB1uzHeXQwgpL4KiaGsjQC9nZ+eIiAglfkbI5/N1dHTeXa47uXXr1sRFE19NfQVsAADWXbUPdN6P/CPynRt2z5OtrINe4aKyuWpsWlNh9zxZGREIBKrzjFDaWAafESoflfj4Irq4u7v/svkXsyizHmd76J8wVns16cDeY/IO6t+7VEyONGPQmwURQgoHEyHqmHlz5hVnF6edSSt9UDDz/6J25yhwO5P4QsrHAh8QIqTqMBGif8PCwoLNZu8cwgx8TGbxumnt+jtdKqawpQxCCBMh+vd6aMCXg5irrtMzf28Xy+JRFAX2epgIEVIIMG6qAAAUkElEQVR1mAhRp6xyZrwUQlQ+zYNsCYVCenfYUnwR3g4ihAAwEaJOYhKw35P5+Q2yWkTbPiUSyebNm2nbXRsSikhffECIEMJEiDrPy5QYYUZ8f5e2CtIrV64E/H6gpqaGrh22VE9CSinlbY6ff4QQJkJEh5+HMI/Q12omPPiARx+IOfMnLXtrVeoLylGf4LJldwSEkMLARIho0EMDNtHUaqa+vv7OrdS9c+vDgg90fm8t8Xi8uLi4gydjh2tXyGL/CCGFgyOcIXqscmIcyyZP5ZMzbDr266q0tDQlJaWmpkY6bEf240e+zrWOFvCyKPfggf0sNXUA0NLS0tTUnDx5cieHZ4s5F7N07VKhjbBaQunt1xj0/S8fzv6wMztECCkBTISIHiwGHPBkfpQoGW/J0OrIx8rU1LS0uGDjxv+u8ZX0MgYXNoweAwBw8MOX9+6vqhdDwgMiNV8nLPJsJ7Mgj8db+tnSFzNfAAcAoFLE/+yrz7xHeJuamnZmtwghRYdVo4g2XqaEVw/iu/QOV5CuWvN58tWbF3IsuTqsj4aBuQEAgEsvWDAcKuu0KtUH3bmbNWLEiE6Gd+vWrVrrWmgYCUcNqm2rr1271sndIoQUHSZCRKddQ5iHH5PZrzvcambw4MF/Xb0bcNc1NPXN0J+fBOvxTBddvHL7LRM4tx9FUdC0uwQF1NtnG0cIqQJMhIhOZpqwcSBzZeq/aTXD5XJ72/SyMJAAAL8WAMBcX/Le0BFMJj2jYru5uXGecqD+f8ti0M7X9vT0pGXnCCHFhYkQ0WyNM+OFEP582uE7LYqiUq8lu/SCFSF6zpv1AhLZU/pXn406RldgXC53z/d7tMNMWKkanJsck0iT7zZ+Z2FhQdf+EUIKChvLIJqxGLDfkzk3UeLbs2OtZtLT00FU5b3LcNln23ZGLvzvZ5+ePR97/9lViURC102h30y/ra+HzyWv9tWlRowYQUuNK0JI0eEdIaLfcFNiWA/ihw6ONRNzJlrb0Ppk7M1Plq7Q1NTcfyh45dcnRCTz+vXr79y2rq6uPYe4XkaBrsmWJbP9/PwwCyKEpDARIpnYPZQZkEU+7kirmcHvDUm+cb93794Na8aNn5DxMPud7VnKysr279/fnkMEZZML+zJwgFGEUGOYCJFMmGrAfwcyV3ek1cyUKVNaVoEaGhq+s+NEVETo8aP73rl/oRhO5ZNz7TAPIoSawESIZGWtM6NECKefybx/QsSJAC0G79GjR+8olk96mBA9tTARIoSawESIZEXaambNdfJllSAzM5PP58viKAUFBWyyfM2YqvDjh99eUlovKosYEEIKDVuNIhkaYUqwYz7rtemklhnAKxg/cnzQb0GdbAL69OnT9PR0sVgMAEKh8FL8+dkulZNdqG+/P2lp66Svry8t1qNHj8Z1qvl86lElNdkKEyFCqDlMhEiG9v2+r7TwD8GCKgEBABB9LdrqO6vtW7d3Zp+mpqYXzkaFhZ9cO1HNTE/sxRHPdANNdfjh/ZLim0uf1mtE3RDzJEaRf8Y13iowm5xrx2DT0wsDIaRU8AcykqHAE4F8j6qGgc1qhtaEnQrr5D45HE5AYMhvvx8+/1B3eF/xUm/Q0wQAmOwCC4ZDYSXLou+wm2mPBgwY0LCJhILgbArrRRFCrcKvBiRD/Go+NJ78lgnSuZY6b+78hcdPXZl3rGda/puVvrv1+/p8HR17paGCVOpSEdVDA/pzsZkMQqgVmAiRDHm4ezBz31RHEs8JR3tHunbu5ORkyNWXTlVRJwIA0NNSGzfx/ZYlA7PJRfZvPuokSYpEIrrCQAgpOkyESIb27NhjedeSc4sDT0EtTZ2RYO772RG6dl5ZWVlXXcZRgw8PG7huM0h+zJjavzLmz8hmxSrqIL6Q9Ld981FPSUmJi4sDhBACAEyESKa4XO6jO49+/eDX+erzd43beef6o1+KzE/l09Oz8Py5WE2C573LeNaq3y8mZ3yfMjglh302OqRZsRNPyImWDINGNbThf/wWHtyukWgQQqoAW40i2dLQ0PjPkv986P+hjo4OAJwfT/leEOuqEz4WnX1id/Z0hLrJ4At/REunmL/w1819v/7059ZtFRUVXC63oVhQNrnT/U31rEgkupZyhcWgampqtLS0OhkDQkgJ4B0h6lIDucRJb9bcRPGd8g5P3tsYRVEfzPzo7MVr0iwIAARBrP5sw42bd54/f95QLKOCqqwDb/M3STchIWGsU/2UAYLYs2c6EwBCSGngHSHqaqPMiCPDmVMuii9PYjnq/8v7QoIg/P39W653cnJqvHjkMTlOkn4q6ikAiESi6urqkycO/+DD0+HAJ7u/f11VraWlpa6uDgCWlpZDhw79d8EghBQaJkIkB1OsGDuHwLgLkpQpTGttWfVqqCchPJe84NXrqyWf3/37xheTGDrq9R85gpstEAQse++h8NZ/XorVfzlP2fTpFxZ1TkZhIIS6OawaRfIx146xYSDD54LkhVBWh/jzKTmASwzuZXwuPnnDl9vOP9CZ7AKLRgJBAADM84LpbpCQqf3BrHkJiTdxekKEVBYmQiQ3K5wY/rbEuAtiHj2d7JtrGGWbIIg1X3z51c8RY3/mllX981d+LYz8UX/l18F7DhxVU1OTSQQIIUWAiRDJ0/8NZo42J6YliGs7Npv9uxXWULdfUtN6vfmEjxg5Sk1NzUgHJCSIJKDDAXV1Ne8xPjQfGCGkaDARIjnbPZTZS4eY/ZdETOvEhceyKT9bhmajh+A3b958r5f46UsYs8tw1E+GmUUw2kGUmJhI51ERQgoIEyGSMwIgwItJUtTCZAnZqS4Vb1AAwTnNZx88Gx1ayeP5HbXcefj876FXFob1KSwTnD0VTM8hEUIKCxMhkj81BkSOYT2vplZflwCAWCx+8eJFZ3aYVEJxmOBm3KQ96tlzF8wHzUm6meXm5t6/f/+k6/d7DVl4Lu5Kp0JHCCk+TISoW9BgwdlxrNSS+vfmLDZ3MB84YaBZH7OAwIB/t7egpqNsAwCPx9v1y4H9h45rampK17DZ7J9++f3Y8fDS0tLORo8QUmTYjxB1F7pqMPjahsCXYeRcIRAAIti0d5ONtY1PB9uzVIkg5hm5071JQ1B9ff1x48a1LDxy5MhOBY0QUnw0JMJHjx7duHEjJyfn/fffbzw2R01NTXR0dEpKilAodHNzW7JkiYaGRmxs7NWrVxvKbN++ncXCZIz+ceF8NOkv/GciXzWo8KjYd2RfRxPhyVxytDnDREMWASKElBANVaPr1q2LjY0NCQlJT09vvP7GjRshISGurq4TJkwICQnx8/MDgMuXL9++fdvgfzp/dKQ0KIoSU2Jo/FxPG0pKSzq6n6BschFORo8Qajca7sbOnz8PAN7e3s3We3t7jxkzRvrazc3N3t6+qqoKAIYNG7Zhw4bOHxcpGYIgDPUMX7x+AXr/W5PHcn1veId28vg1lc+nxvfEyegRQu0lwx/OBPHmy6i4uFhbW1s6601ycvLKlSt37dpVXl4uu6MjRRS4L9D4rDGRRcALYP/N1r9ved5py/WyDnSqOPqY/Lgvg4U3hAihdmvvHWFVVVV1dXXzjVksExOTd25bU1OzcuXKrVu3MplMR0dHLpdrYGBw5cqVnTt3pqenm5ubt7XVkiVLtLW1pYt+fn7SylWlUVNT0/i3gnJr58k6Ozsnnkncf3h/fkG+x1CPZYeXJfM03o8XrbInP3MUv3NzMQnHc9TPjRZVV9PUIfFfUal3ViAQiMViBkMlfnrU19cDgHS6kraw2WwcsU/hEBTVrq+M77777tChQ81WWllZNbR88fb2njVr1qefftqsTG1t7ZQpUywsLIKCgpp9O4wbN87NzW379u2tHtHe3n7t2rXW1tbSRTs7Ozs7u/aEqij4fL50rlpV0JmTfV5N+V2hzDUhcDhD721fQRDznNp1n0qeJOcvZZV6ZwUCAYfDwUTYgCAI1fkZpDTae0e4efPmzZs3d3Tv9fX1M2bMMDIyOnr0aMsPh7Ozc3FxcZuRsVgjRoxwdnbu6EEVBYPBUJGvD+jcyfbSheTJ8N9bEo+zZNRYZj+DNr9ljuVIFvaV/7+qCr6zKnK+0tNUkZNVKTJ5R7Ozs8+dOycSiWbPns3hcI4fP85kMqV/aui8/OrVq5iYGDc3N1kEgJQMmwl7PJibXRijYsVB2a2PSfpCCEkl5Gxb/JJCCHUMDa1G16xZExsbW1JScv/+/V27dh08eDA3N/fw4cP19fVnzpyxtLS0t7eXlrx48eKoUaOMjY319PTu3bs3ceLEJUuWdD4ApCLm2THeMyJmXJLcKKP2eTLVm6a8P3LIab0YOvh0BiHUQe19RvgWZWVljdvR9OjRAwAEAoGmpmazESN79uxJkuSjR4+qq6vt7OzaaiYj5ezsHBERocRVoyr1JInGk+WLYHGyJI9PRY5h2ui8qSZ1jhL/7sUcbir/xzMq9c7iM0KkBGi4IzQxMWnZdlTaU8LW1rZleVdX184fFKksHTWIGMMMyCI9Y8SHhkpSg78JjQwVisU1enYmoUfAtK+8A0QIKRgc3gwppKUODCd9Yty8hfVwSjy7FhgAJSVjpnrfvXrXyMhI3tEhhBSJSlRoIKU0WK9W43m82Kv2n0+xGZT2LQ0JD5FzWAghRYOJECmqgoICFrfJB1hiKMnIzJBXPAghBYWJECkqGxsbsoyERp0p2C/YQ12Htr0FQgi1AhMhUlRqampL5i3RjdcFPoAYWJmsnoU9P5rzkbzjQggpGEyESIFt/3r7/lX7B98Z3Ce2z2LTxbcSbzVMQI8QQu2ErUaRAiMIYt6H8+Z9OE/egSCEFBjeESKEEFJpmAjlo7y8fNmyZfKOouvMnTu3rq5O3lF0kXXr1uXn58s7ii6ye/fulJQUeUfRRcLCwk6ePCnvKBD9sGpUPoRCYVJSkryj6DoJCQkSiUTeUXSR69evv379Wt5RdJG7d+8q2fxob5Gdnc1i4XemEsI7QoQQQioNEyFCCCGVRsPsEzIyZ86cpKSkhokMlQxJklVVVfr6+vIOpItUVlbq6+uryMzdVVVVWlpayvrRbaa6ulpdXV1FJmQQCoUEQXA4nLeU2blzp7+/f5eFhGjRfROhUCgsLy+XdxQIIdQBXC5XOvcOUiDdNxEihBBCXQCfESKEEFJpmAgRQgipNEyECCGEVBomQoQQQioNE2FXEwqFvRvZsWOHvCOiX1pa2scffzxw4MCJEyc2Xjlo0CANDY1Bgwalp6fLMTx68Xi81atXDxs2rHfv3mVlZdKVixcvbniLR44cKd8IaVRUVDRjxgxjY2MOhzNs2LDbt28DgEQiWb16tb6+PpfL3bRpkzK1v1u7dq2NjY2ampqdnV1wcDAA3L59u/H1GxMTI+8YEQ1wuKCuRpJkXl5eZmamtOuVUnYlFAqFgwYNsrS0PHPmjHQNSZL+/v6rV69esWLFgQMH/Pz8srKyGAxl+B0mEomMjIzWrFnj5+fXMIxcaWnpypUr33//fQBQpkG5qqurx4wZc/DgQQMDg++//37q1KmFhYWBgYFXrlzJzc0ViUReXl4uLi6zZ8+Wd6T0MDAwiIuLs7Oz++uvvz744IN+/frV1tYymcy4uDhpARMTE/lGiOhBoa5VXV0NALW1tfIOROZOnjzZv39/6evExEQTExOxWExRlFgsNjY2TkpKkmt0NOPxeABQXFwsXZw4ceLx48flG5KsvXr1CgAKCgo8PDwOHTokXblr167x48fLNzAZee+9944cOZKcnOzs7CzvWBDNlOEnuSJydHTs3bv34sWLGyrTlFtOTo6Tk5N0sBUmk+no6JidnS3voGRr48aNZmZmY8eOvXr1qrxjkYkLFy5YW1ubm5vn5OT069dPurJfv345OTnyDUwWnj9/npmZOWTIEADIy8vr2bOns7Pzli1bamtr5R0aogEmwq6mrq4eGxubmpoaGxv74sWLmTNnyjuirlBZWdl4uA1dXd2Kigo5xiNr69atS0lJSUtLGz9+/Pjx4/Py8uQdEc2ysrLWrl0bEBDAYDB4PJ62trZ0vY6OjvROUZkIBAJ/f//ly5f369fP1tY2Pj4+PT396NGjMTExGzdulHd0iAaYCLuamprapEmTTE1NHR0djx49mpKS8uLFC3kHJXOGhoZVVVUNizwez9jYWI7xyNro0aNtbGzMzc3XrVvn6up6/vx5eUdEp9zcXF9f359//tnX1xcAuFxuw7RTPB5PyR6b1dbWTps2rU+fPtJ2bRYWFl5eXsbGxkOHDv3xxx8jIyPlHSCiASZCeZIOQk0pUSu7ttjb2z98+FAsFgOAWCx+9OiRvb29vIPqIgShVAMZPn/+3NfX98svv5w/f750jYODQ0ZGhvR1RkaGMr2z9fX1s2fP1tXVPXr0aMu2XUr2zqoy5WnPpihu3bpVU1Pj7OzM4/HWr18/bNgwU1NTeQdFs+rq6sePH+fl5QmFwrS0NF1dXU9PTzMzsx07dqxdu/bXX381Nzf38PCQd5i0SU9Pl97vZmRkFBcX29vbnzp1ytvbW01NLTw8PC0tLTAwUN4x0qOkpGTUqFFjxoxxc3NLS0sDAAcHh08++eTbb7+dNGlSfX39wYMH9+/fL+8waTN79uznz58fOnTo3r17AGBubp6enm5iYmJjY5OXl7dx48YZM2bIO0ZEA/xF09UuX768cePGZ8+e6erqjhw5cvv27cqXCNPT05csWdKw6O7ufvDgwaysrOXLl2dkZAwYMOC3335TpvsGT0/P+vr6hsXLly/7+/tnZGSQJOns7Lx169bhw4fLMTwaXb9+fdWqVY3X/PHHH46Ojtu2bQsMDGQymcuXL1+/fr28wqMXRVFubm6N13z66acURe3du7eoqMjU1HT69OlffvmlhoaGvCJEdMFEiBBCSKXhM0KEEEIqDRMhQgghlYaJECGEkErDRIgQQkilYSJECCGk0jARIoQQUmmYCBFCCKk0TIQIIYRUGiZChBBCKg0TIUIIIZWGiRAhhJBKw0SIEEJIpf0/hxQ/xNU6aMAAAAAASUVORK5CYII=", + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 31 + } + ], + "cell_type": "code", + "source": [ + "plot(single_step_24h, linear)" + ], + "metadata": {}, + "execution_count": 31 + }, + { + "cell_type": "markdown", + "source": [ + "Visualize the weights of the linear regression. Naturally, since we are trying to predict future temperatures, we would expect that the current temperature is on of the most useful features.\n", + "This is shown by it having a high positive weight." + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Plot{Plots.GRBackend() n=1}", + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 32 + } + ], + "cell_type": "code", + "source": [ + "bar(names(train_df), linear.W[:], xrotation=30.0, legend=false, xticks=:all, tickfontsize=6)" + ], + "metadata": {}, + "execution_count": 32 + }, + { + "cell_type": "markdown", + "source": [ + "### Dense\n", + "A model with 2 Fully-connected layers and relu non-linearities." + ], + "metadata": {} + }, + { + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "┌ Warning: The specified values for size and/or count will result in 6 unused data points\n", + "└ @ MLDataPattern /home/andrew/.julia/packages/MLDataPattern/KlSmO/src/dataview.jl:205\n", + "Epoch 1/20 - train loss: 0.0095, valid loss: 0.009\n", + "Epoch 2/20 - train loss: 0.0081, valid loss: 0.0089\n", + "Epoch 3/20 - train loss: 0.0079, valid loss: 0.0083\n", + "Epoch 4/20 - train loss: 0.008, valid loss: 0.0076\n", + "Epoch 5/20 - train loss: 0.0069, valid loss: 0.0072\n", + "Epoch 6/20 - train loss: 0.0066, valid loss: 0.0076\n", + "Epoch 7/20 - train loss: 0.0078, valid loss: 0.0074\n", + "Epoch 8/20 - train loss: 0.0046, valid loss: 0.0072\n", + "Epoch 9/20 - train loss: 0.0044, valid loss: 0.0069\n", + "Epoch 10/20 - train loss: 0.0053, valid loss: 0.0071\n", + "Epoch 11/20 - train loss: 0.005, valid loss: 0.0073\n", + "Epoch 12/20 - train loss: 0.0071, valid loss: 0.0072\n", + "Epoch 13/20 - train loss: 0.0057, valid loss: 0.0067\n", + "Epoch 14/20 - train loss: 0.0057, valid loss: 0.0071\n", + "Epoch 15/20 - train loss: 0.0059, valid loss: 0.0069\n", + "Epoch 16/20 - train loss: 0.0077, valid loss: 0.007\n", + "Epoch 17/20 - train loss: 0.0073, valid loss: 0.0069\n", + "Epoch 18/20 - train loss: 0.0076, valid loss: 0.0072\n", + "Epoch 19/20 - train loss: 0.0058, valid loss: 0.007\n", + "Epoch 20/20 - train loss: 0.0059, valid loss: 0.0068\n", + " 11.781388 seconds (60.57 M allocations: 9.586 GiB, 6.87% gc time, 0.42% compilation time)\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": "Chain(Dense(19, 64, relu), Dense(64, 64, relu), Dense(64, 1))" + }, + "metadata": {}, + "execution_count": 33 + } + ], + "cell_type": "code", + "source": [ + "dense = Chain(\n", + " Dense(19, 64, relu),\n", + " Dense(64, 64, relu),\n", + " Dense(64, 1)\n", + ")\n", + "\n", + "@time dense = train_model!(dense, single_step_1h, opt; bs=32, epochs=20)" + ], + "metadata": {}, + "execution_count": 33 + }, + { + "cell_type": "markdown", + "source": [ + "Dense model's predicions" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Plot{Plots.GRBackend() n=3}", + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 34 + } + ], + "cell_type": "code", + "source": [ + "plot(single_step_24h, dense)" + ], + "metadata": {}, + "execution_count": 34 + }, + { + "cell_type": "markdown", + "source": [ + "### Multi-step Dense\n", + "Now we are going to use 3 historical hours to predict 1 hour in the future." + ], + "metadata": {} + }, + { + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "┌ Warning: The specified values for size and/or count will result in 4 unused data points\n", + "└ @ MLDataPattern /home/andrew/.julia/packages/MLDataPattern/KlSmO/src/dataview.jl:205\n", + "Epoch 1/20 - train loss: 0.0074, valid loss: 0.0088\n", + "Epoch 2/20 - train loss: 0.008, valid loss: 0.0092\n", + "Epoch 3/20 - train loss: 0.0065, valid loss: 0.0089\n", + "Epoch 4/20 - train loss: 0.0069, valid loss: 0.009\n", + "Epoch 5/20 - train loss: 0.0052, valid loss: 0.0088\n", + "Epoch 6/20 - train loss: 0.0057, valid loss: 0.0085\n", + "Epoch 7/20 - train loss: 0.006, valid loss: 0.009\n", + "Epoch 8/20 - train loss: 0.0072, valid loss: 0.0086\n", + "Epoch 9/20 - train loss: 0.0072, valid loss: 0.0087\n", + "Epoch 10/20 - train loss: 0.0073, valid loss: 0.008\n", + "Epoch 11/20 - train loss: 0.008, valid loss: 0.009\n", + "Epoch 12/20 - train loss: 0.0073, valid loss: 0.0088\n", + "Epoch 13/20 - train loss: 0.0076, valid loss: 0.0094\n", + "Epoch 14/20 - train loss: 0.0076, valid loss: 0.009\n", + "Epoch 15/20 - train loss: 0.0071, valid loss: 0.0089\n", + "Epoch 16/20 - train loss: 0.0074, valid loss: 0.0089\n", + "Epoch 17/20 - train loss: 0.0074, valid loss: 0.009\n", + "Epoch 18/20 - train loss: 0.0072, valid loss: 0.0085\n", + "Epoch 19/20 - train loss: 0.0074, valid loss: 0.0084\n", + "Epoch 20/20 - train loss: 0.007, valid loss: 0.0084\n", + " 12.272140 seconds (61.59 M allocations: 11.443 GiB, 6.89% gc time, 3.66% compilation time)\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": "Chain(#27, Dense(57, 32, relu), Dense(32, 32, relu), Dense(32, 1))" + }, + "metadata": {}, + "execution_count": 35 + } + ], + "cell_type": "code", + "source": [ + "single_step_3h = WindowGenerator(3, 1, train_df, valid_df, label_columns=target);\n", + "\n", + "plot(single_step_3h)\n", + "\n", + "multi_step_dense = Chain(\n", + " i -> reshape(i, :, 1, size(i)[end]), # flatten first two dimensions, but preserve batch dimension\n", + " Dense(19*3, 32, relu),\n", + " Dense(32, 32, relu),\n", + " Dense(32, 1)\n", + ")\n", + "\n", + "@time multi_step_dense = train_model!(multi_step_dense, single_step_3h, opt; bs=32, epochs=20)" + ], + "metadata": {}, + "execution_count": 35 + }, + { + "cell_type": "markdown", + "source": [ + "Show the model's 1 hour predicion using 3 hours of historical data." + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Plot{Plots.GRBackend() n=3}", + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 36 + } + ], + "cell_type": "code", + "source": [ + "plot(single_step_3h, multi_step_dense)" + ], + "metadata": {}, + "execution_count": 36 + }, + { + "cell_type": "markdown", + "source": [ + "### Convolutional Neural Network" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "conv_model = Chain(\n", + " Conv((19,), 3=>32, relu), # need to explain why this conv pattern\n", + " x -> Flux.flatten(x),\n", + " Dense(32, 32, relu),\n", + " Dense(32, 1),\n", + " x -> unsqueeze(x, 1)\n", + ")" + ], + "metadata": {} + }, + { + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "┌ Warning: The specified values for size and/or count will result in 4 unused data points\n", + "└ @ MLDataPattern /home/andrew/.julia/packages/MLDataPattern/KlSmO/src/dataview.jl:205\n", + "Epoch 1/20 - train loss: 0.0081, valid loss: 0.0084\n", + "Epoch 2/20 - train loss: 0.0064, valid loss: 0.0071\n", + "Epoch 3/20 - train loss: 0.0089, valid loss: 0.0082\n", + "Epoch 4/20 - train loss: 0.0081, valid loss: 0.008\n", + "Epoch 5/20 - train loss: 0.0084, valid loss: 0.0089\n", + "Epoch 6/20 - train loss: 0.0083, valid loss: 0.0083\n", + "Epoch 7/20 - train loss: 0.0084, valid loss: 0.0089\n", + "Epoch 8/20 - train loss: 0.0081, valid loss: 0.0084\n", + "Epoch 9/20 - train loss: 0.0093, valid loss: 0.0091\n", + "Epoch 10/20 - train loss: 0.0095, valid loss: 0.0094\n", + "Epoch 11/20 - train loss: 0.0099, valid loss: 0.0092\n", + "Epoch 12/20 - train loss: 0.0095, valid loss: 0.0096\n", + "Epoch 13/20 - train loss: 0.0101, valid loss: 0.0099\n", + "Epoch 14/20 - train loss: 0.0087, valid loss: 0.0091\n", + "Epoch 15/20 - train loss: 0.009, valid loss: 0.0096\n", + "Epoch 16/20 - train loss: 0.0082, valid loss: 0.009\n", + "Epoch 17/20 - train loss: 0.0081, valid loss: 0.0087\n", + "Epoch 18/20 - train loss: 0.0075, valid loss: 0.0092\n", + "Epoch 19/20 - train loss: 0.0081, valid loss: 0.0093\n", + "Epoch 20/20 - train loss: 0.0078, valid loss: 0.0089\n", + " 30.839493 seconds (75.26 M allocations: 13.133 GiB, 3.48% gc time, 3.65% compilation time)\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": "Chain(#29, Conv((3,), 19=>32, relu), #30, Dense(32, 32, relu), Dense(32, 1), #31)" + }, + "metadata": {}, + "execution_count": 37 + } + ], + "cell_type": "code", + "source": [ + "conv_model = Chain(\n", + " x -> permutedims(x, [2,1,3]), # put data in NTime x NCovariates X NBatch https://github.com/FluxML/Flux.jl/issues/1465\n", + " Conv((3,), 19=>32, relu), # convolve over 3 inputs - 19 variables -> 32 filters\n", + " x -> Flux.flatten(x),\n", + " Dense(32, 32, relu),\n", + " Dense(32, 1),\n", + " x -> unsqueeze(x, 1)\n", + ")\n", + "\n", + "single_step_3h = WindowGenerator(3, 1, train_df, valid_df, label_columns=target);\n", + "\n", + "@time conv_model = train_model!(conv_model, single_step_3h, opt; bs=32, epochs=20)" + ], + "metadata": {}, + "execution_count": 37 + }, + { + "cell_type": "markdown", + "source": [ + "Show the model's 1 hour predicion using 3 hours of historical data." + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Plot{Plots.GRBackend() n=3}", + "image/png": "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", + "text/html": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "image/svg+xml": [ + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ] + }, + "metadata": {}, + "execution_count": 38 + } + ], + "cell_type": "code", + "source": [ + "plot(single_step_3h, conv_model)" + ], + "metadata": {}, + "execution_count": 38 + }, + { + "cell_type": "markdown", + "source": [ + "### Recurrent Neural Network" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "Chain(Recur(LSTMCell(19, 32)), Dense(32, 1), #35)" + }, + "metadata": {}, + "execution_count": 39 + } + ], + "cell_type": "code", + "source": [ + "rnn_single_24h = Chain(\n", + " LSTM(19, 32), # input features * output dimensionality\n", + " Dense(32, 1),\n", + " x->reshape(x,:) # lstm output * single number\n", + ")" + ], + "metadata": {}, + "execution_count": 39 + }, + { + "cell_type": "markdown", + "source": [ + "Flux uses vectors of observations for RNNs, rather than the bulk tensor" + ], + "metadata": {} + }, + { + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "1-element Vector{Float32}:\n -0.7347592" + }, + "metadata": {}, + "execution_count": 40 + } + ], + "cell_type": "code", + "source": [ + "a = [rand(Float32, 19) for i in 1:24]\n", + "b = rnn_single_24h.(a)\n", + "a[1]\n", + "rnn_single_24h(a[1])" + ], + "metadata": {}, + "execution_count": 40 + }, + { + "cell_type": "markdown", + "source": [ + "### Performance" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Multi-output Models" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "#### Baseline" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "#### Dense" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "#### RNN" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "#### Advanced: Residual Connections" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "#### Performance" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "# Multi-Step Models" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Baselines" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Single-shot Models" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Linear" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Dense" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### CNN" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### RNN" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Advanced Autoregressive model\n", + "### RNN" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Performance" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Next Steps" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "---\n", + "\n", + "*This notebook was generated using [Literate.jl](https://github.com/fredrikekre/Literate.jl).*" + ], + "metadata": {} + } + ], + "nbformat_minor": 3, + "metadata": { + "language_info": { + "file_extension": ".jl", + "mimetype": "application/julia", + "name": "julia", + "version": "1.6.0-rc1" + }, + "kernelspec": { + "name": "julia-1.6", + "display_name": "Julia 1.6.0-rc1", + "language": "julia" + } + }, + "nbformat": 4 +} \ No newline at end of file diff --git a/tutorials/time_series/time_series.jl b/tutorials/time_series/time_series.jl index 448385663..ce8295583 100644 --- a/tutorials/time_series/time_series.jl +++ b/tutorials/time_series/time_series.jl @@ -1,13 +1,16 @@ # # Time series forecasting -# This tutorial serves as a `Julia` implementation of the Tensorflow time series forecasting tutorial here: -# -# [Tensorflow Time Series Forecasting Tutorial](https://www.tensorflow.org/tutorials/structured_data/time_series) +# This tutorial is inspired by a [Tensorflow](https://www.tensorflow.org/tutorials/structured_data/time_series) Time Series Forecasting Tutorial. +# It implements the data analysis, plotting, and model training from scratch using Julia tools such as Plots.jl, Flux, and DataFrames.jl. + # ## Setup +# Importing the usual suspects. Two interesting notes: +# * StatsPlots re-exports Plots.jl functions, so we don't need that separately +# * MLDataPattern is useful for preprocessing data for ML in a lazy (read: non-memory intensive) way. We will be seeing more of it using ZipFile using CSV using DataFrames -using StatsPlots #re-exports Plots.jl functions +using StatsPlots using Dates using FFTW using CUDA @@ -18,35 +21,43 @@ using Random: seed! using Statistics: mean, std using Flux: unsqueeze +# Set a seed to make this reproducible. seed!(4231) -ENV["LINES"] = 20 +ENV["LINES"] = 20; + +# Disallow scalar indexing for CUDA - prevents slow accesses to GPU memory CUDA.allowscalar(false) # ## The weather dataset +# We are going to be using weather data for 7 years from the Max Planck Institute: https://www.bgc-jena.mpg.de/wetter/ function download_data(; fname="jena_climate_2009_2016.zip") DATA_PATH = "https://storage.googleapis.com/tensorflow/tf-keras-datasets/jena_climate_2009_2016.csv.zip" isfile(fname) || download(DATA_PATH, fname) - zip = ZipFile.Reader(fname) #https://juliadata.github.io/CSV.jl/stable/index.html#Example:-reading-from-a-zip-file-1 + zip = ZipFile.Reader(fname) csv = zip.files[1] df = CSV.File(csv) |> DataFrame close(zip) return df end +# More discussion on reading zipped CSVs here: https://juliadata.github.io/CSV.jl/stable/index.html#Example:-reading-from-a-zip-file-1 + df = download_data(); df = df[6:6:end, :] -df[!,"Date Time"] = Dates.DateTime.(df[:,"Date Time"], "dd.mm.yyyy HH:MM:SS"); #https://en.wikibooks.org/wiki/Introducing_Julia/Working_with_dates_and_times +df[!,"Date Time"] = Dates.DateTime.(df[:,"Date Time"], "dd.mm.yyyy HH:MM:SS"); +# More info on working with dates and times: https://en.wikibooks.org/wiki/Introducing_Julia/Working_with_dates_and_times col = ["Date Time", "T (degC)", "p (mbar)", "rho (g/m**3)"] df[:,col] -@df df plot(cols(1), cols(2:4); layout=(3, 1)) # from https://github.com/JuliaPlots/StatsPlots.jl +# One easy way to plot data from a datafrom is with the StatsPlots `@df` macro +@df df plot(cols(1), cols(2:4); layout=(3, 1)) @df df[1:480,:] plot(cols(1), cols(2:4); layout=(3, 1)) @@ -55,15 +66,17 @@ df[:,col] df."p (mbar)"; #cool that this works -replace!(df[!,"wv (m/s)"], -9999.0 => 0); # https://juliadata.github.io/DataFrames.jl/stable/man/getting_started/#Replacing-Data +# Need to replace bad database values +replace!(df[!,"wv (m/s)"], -9999.0 => 0); replace!(df[!,"max. wv (m/s)"], -9999.0 => 0); @show describe(df) # ## Feature engineering - +# Bucket wind direction and speed histogram2d(df[!,"wd (deg)"], df[!,"wv (m/s)"], bins=(75,75), xlabel="wd (deg)", ylabel="wv (m/s)") +# It would be better to decompose this into X and Y velocities wd_rad = df[!,"wd (deg)"] * π / 180 df.Wx = df[!,"wv (m/s)"] .* cos.(wd_rad) df.Wy = df[!,"wv (m/s)"] .* sin.(wd_rad) @@ -72,6 +85,7 @@ df."max Wy" = df[!,"max. wv (m/s)"] .* sin.(wd_rad); histogram2d(df.Wx, df.Wy, bins=(75,75), xlabel="Wind X [m/s]", ylabel="Wind Y [m/s]") +# Modify timestamp into a continuous "time of day" signal to deal with periodicity. timestamp_s = Dates.datetime2unix.(df."Date Time"); day = 24*60*60 #seconds in a day @@ -87,6 +101,8 @@ plot!(df[1:25,"Day cos"]) xlabel!("Time [h]") title!("Time of Day Signal") +# If you don't know the frequency to choose for your periodicity, you can take the FFT. +# Here you can see that the yearly and daily periodicities are the most prominent. fftrans = FFTW.rfft(df[!,"T (degC)"]) f_per_dataset = 1:size(fftrans)[1] @@ -100,20 +116,20 @@ xticks!([1, 365.2524], ["1/Year", "1/Day"]) xlabel!("Frequency (log scale)") # ## Split the data -# drop columns you don't want to use further +# Drop columns that won't be used further. select!(df, Not([:("wv (m/s)"),:("max. wv (m/s)"), :("wd (deg)"), :("Date Time")])); column_indices = pairs(names(df)) indices_columns = Dict(value => key for (key, value) in column_indices) df = convert.(Float32, df) # Don't need high precision; reduces errors later on when using Params - gradients are Float32 - +# Split the data into a training and validation set n = size(df)[1] train_df = df[1:round(Int,n*0.7, RoundDown),:] valid_df = df[round(Int,n*0.7, RoundUp):round(Int,n*0.9, RoundDown),:] test_df = df[round(Int,n*0.9, RoundUp):end,:]; # matching TF tutorial exactly, can also use partition -num_features = size(df)[2] +num_features = size(df,2) # ## Normalize the data train_mean = mean.(eachcol(train_df)) @@ -134,15 +150,20 @@ boxplot!(df_std.variable, df_std.value, fillalpha=0.75, outliers=false) # We will define our own WindowGenerator, some constructors, and plotting functions. The data from the WindowGenerator will be used in training. include("window_generator.jl") -h = 6 # historical window length -f = 1 # future window length +h = 6; # historical window length +f = 1; # future window length -# WindowGenerator makes use of MLDataPattern's `slidingwindow` to generate the windows. It is good at flexibly generating -# https://mldatapatternjl.readthedocs.io/en/latest/documentation/dataview.html?highlight=slidingwindow#labeled-windows +# WindowGenerator makes use of MLDataPattern's `slidingwindow` to generate the windows. It is good at flexibly generating sequences data, though requires a bit of mind-bending to fully understand how it generates sequences. +# [slidingwindow docs](https://mldatapatternjl.readthedocs.io/en/latest/documentation/dataview.html?highlight=slidingwindow#labeled-windows) slidingwindow(i -> i+h:i+h+f-1, Array(train_df)', h, stride=1) -# How to use WindowGenerator -wg = WindowGenerator(6, 1, train_df, valid_df, label_columns="T (degC)") +# WindowGenerator is implemented to make sequence-generating simpler. It uses `slidingwindow` behind the scenes to create sequences. +@doc WindowGenerator + +# Create a WindowGenerator +wg = WindowGenerator(6, 1, train_df, valid_df, label_columns="T (degC)"); + +# Plotting methods are implemented for raw data and with predictions. plot(wg) @@ -150,7 +171,7 @@ plot(wg) include("batch_ts.jl") -# To understand better what the above code does, let's look at an imitation training loop and look at everything's dimensions +# To understand better what all the above code does, let's look at an imitation training loop and look at everything's dimensions practice_df = train_df[1:10,:] a = slidingwindow(i -> i+h:i+h+f-1, Array(practice_df)', h, stride=1) @@ -160,6 +181,15 @@ for i in eachbatch(shuffleobs(a), size=2) @show y println() end +#= +That took the data at 10 timestamps (`train_df[1:10,:]`) and threw it into 4 'observations' using all the data it could while requesting 6 historical and 1 target point. This works out to the following: +* (1,2,3,4,5,6), 7 +* (2,3,4,5,6,7), 8 +* (3,4,5,6,7,8), 9 +* (4,5,6,7,8,9), 10 + +It then shuffles these obserations, and lazily batches them into 2 batches each of size 2. +=# # # Single Step Models loss(x,y) = Flux.Losses.mse(x, y) @@ -178,13 +208,14 @@ single_step_1h = WindowGenerator(1, 1, train_df, valid_df, label_columns=target) baseline_model = Baseline(wg.target_idx[1]) +# Demonstrate the 'training error' for this model, although there is no actual training. function run_single_step_baseline(wg, model) preds = Float32[] reals = Float32[] for (x,y) in wg.train val = model(x)[1] push!(preds, val) - push!(reals, y[model.label_index]) #figure out how to do validation + push!(reals, y[model.label_index]) end l = loss(preds, reals) @@ -202,7 +233,7 @@ plot(single_step_24h, baseline_model) # ### Linear Models # ##### 1 hour -linear = Dense(size(single_step_1h.train[1][1],1), 1; initW=Flux.glorot_uniform, initb=Flux.zeros) +# Set up a fairly generic training loop for the rest of the models. It takes in a model, and a WindowGenerator object, and uses the ADAM optimizer to train the model. opt = Flux.Optimise.ADAM(0.01) function train_model!(model, wg::WindowGenerator, opt; epochs=20, bs=16, dev=Flux.gpu) @@ -226,21 +257,30 @@ function train_model!(model, wg::WindowGenerator, opt; epochs=20, bs=16, dev=Flu l = round(l;digits=4) vl = round(loss(model(v[1]),v[2][wg.target_idx,:,:]); digits=4) println("Epoch $e/$epochs - train loss: $l, valid loss: $vl") - # crude early-stopping - # vl_prev < (vl - 0.001) && break - # vl_prev = vl + #= + crude early-stopping + vl_prev < (vl - 0.001) && break + vl_prev = vl + =# end model = model |> cpu end +# Now, train the linear model +linear = Dense(size(single_step_1h.train[1][1],1), 1; initW=Flux.glorot_uniform, initb=Flux.zeros) + @time linear = train_model!(linear, single_step_1h, opt; bs=32, epochs=20) -# ##### 24 hr +# ##### 24 hours +# Show the model's predictions for each point in the window. plot(single_step_24h, linear) +# Visualize the weights of the linear regression. Naturally, since we are trying to predict future temperatures, we would expect that the current temperature is on of the most useful features. +# This is shown by it having a high positive weight. bar(names(train_df), linear.W[:], xrotation=30.0, legend=false, xticks=:all, tickfontsize=6) # ### Dense +# A model with 2 Fully-connected layers and relu non-linearities. dense = Chain( Dense(19, 64, relu), Dense(64, 64, relu), @@ -249,6 +289,7 @@ dense = Chain( @time dense = train_model!(dense, single_step_1h, opt; bs=32, epochs=20) +# Dense model's predicions plot(single_step_24h, dense) @@ -267,6 +308,7 @@ multi_step_dense = Chain( @time multi_step_dense = train_model!(multi_step_dense, single_step_3h, opt; bs=32, epochs=20) +# Show the model's 1 hour predicion using 3 hours of historical data. plot(single_step_3h, multi_step_dense) # ### Convolutional Neural Network @@ -292,11 +334,24 @@ single_step_3h = WindowGenerator(3, 1, train_df, valid_df, label_columns=target) @time conv_model = train_model!(conv_model, single_step_3h, opt; bs=32, epochs=20) +# Show the model's 1 hour predicion using 3 hours of historical data. plot(single_step_3h, conv_model) # ### Recurrent Neural Network +rnn_single_24h = Chain( + LSTM(19, 32), # input features * output dimensionality + Dense(32, 1), + x->reshape(x,:) # lstm output * single number +) + +# Flux uses vectors of observations for RNNs, rather than the bulk tensor +a = [rand(Float32, 19) for i in 1:24] +b = rnn_single_24h.(a) +a[1] +rnn_single_24h(a[1]) + # ### Performance # ### Multi-output Models diff --git a/tutorials/time_series/window_generator.jl b/tutorials/time_series/window_generator.jl index e3b6eb8b5..4f04537c0 100644 --- a/tutorials/time_series/window_generator.jl +++ b/tutorials/time_series/window_generator.jl @@ -28,15 +28,13 @@ function WindowGenerator(h, f, train_df, valid_df, label_columns::Vector{String} return WindowGenerator(train, valid, h, f, label_indices, target_idx) end -""" -WindowGenerator with a single label_column. -""" + +# WindowGenerator with a single label_column. WindowGenerator(h, f, train_df, valid_df, label_columns::String; offset=h) = WindowGenerator(h, f, train_df, valid_df, label_columns=[label_columns]; offset=offset) -""" -WindowGenerator with multiple label_columns. -""" + +# WindowGenerator with multiple label_columns. WindowGenerator(h, f, train_df, valid_df; label_columns, offset=h) = WindowGenerator(h, f, train_df, valid_df, label_columns; offset=offset)