ripped ML out into the SkraakML repo, compiles quicker now

[?]

AEj8dahVWy718uSSFPe9VSRJ5qX5G8pC2zvFzJJ8yzBd

Nov 10, 2024, 1:42 AM

QA2TJZRA7RYN5UMRDLXWASQBU7YXV63R2A33EVJME6FV4S67WY3AC

Dependencies

[2] X54TLSYE catch up commit, train now working with julia 1.10.5 but not 1.11
[3] YODTMMPT added a whole bunch of functions to Labels.jl for working with raven and avians labels
[4] PHGT4YMB extended Skraak.dddict, and work on all the functions that call it or make it
[5] 2UBDFCJH new files tracked
[6] WOSKMRI4 added module Base and module ML
[7] ZGLDIQ4G rolled back reduced and bifurcated training set used to test models before going away
[8] AQWXGGE3 mod to clips.jl
[9] 3FAESP6N catch up with changes, mainly construct primary dataset
[10] G4IN2F2T
[11] NMQCXLNG catch up commit, about to do some work on prediction loop
[12] U46LDPL7 added model, CUDA works again now on ubuntu
[13] PQ6OQCBQ work on construct primary dataset
[14] L7G33K4C fixed a comment problem in Clips, and upgraded, now it compiles on Mac again
[15] JYCKLP2E changes to clips and predict
[16] EDYR5C55 fixed ConstructPrimaryDataSet, licence date, Readme, re-arranged Predict.jl
[17] OFTU77S5 first commit
[18] SMODB47P mods to clips to truncate freq to max 16000
[19] MMG2PLXK new functiion to make clips of downloaded bisd calls
[20] E5JDMNIA added kiwi 1-4 model
[21] NV7FXZ5Q first commit
[22] 4BTZNCRM catch up commit before starting work
[23] 27HKDBYT changet train api to take a list of images instead of glob pattern
[24] ETOIK7VE recording changes, but this does not work anymore
[25] RBXUHIO2 made somn small changes and reverted them mostly
[26] QPBH7QWC added MLBaste for confusion matrix, f1, roc, must still remove freq tables
[27] RQ56K2G4 minor work on train and predict
[28] 2O6SHIVY added avianz_of_raven function to Labels.jl
[29] E3Y55MPR added perceptual colour maps and changed get_image_from_sample
[30] BOPNWZL4 refactored Skraak.jl into sub files, tidy now
[31] FY7CEMM2 mac work on train.jl
[32] ROFI4OLA catch up, working on colour images
[33] YXAKJSDT added check_change_avianz_species! function to Labels.jl
[34] VLYXSYAD added .ignore

Change contents

file deletion: LICENSE (---r------)

[5.1]→[5.387877:387908](∅→∅),[5.387908]→[5.386771:386771](∅→∅)

MIT License

Copyright (c) 2023 David Cary <cdecary@gmail.com> and contributors

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
file deletion: Train.jl (----------)

[5.6598]→[5.345424:345456](∅→∅),[5.345456]→[5.335620:335620](∅→∅)

# Train.jl

export train #beware Flux.train! is not Skraak.train

import Base: length, getindex
import MLBase
using CUDA, Dates, Images, Flux, Glob, JLD2, Noise
using Random: shuffle!, seed!
using Metalhead: ResNet

#=
function train(
model_name::String,
train_epochs::Int64,
images::Vector{String},
pretrain::Model=true,
train_test_split::Float64 = 0.8,
batch_size::Int64 = 64,
)

Note:
Dont forget temp env, julia -t 4
Assumes 224x224 pixel RGB images as png's
Saves jld2's in current directory

Use like:
using Skraak, Glob
images = glob("kiwi_set*/*/[N,K]/*.png") #11699814-element Vector{String}
model = "/media/david/SSD2/PrimaryDataset/model_K1-9_original_set_CPU_epoch-7-0.9924-2024-03-05.jld2"
train("K1-10_total_set_no_augumentation", 2, images, model, 0.97, 64)

images = glob("*/[D,F,M,N]/*.png") #from SSD2/Clips
model = "/media/david/SSD2/PrimaryDataset/model_K1-5_CPU_epoch-6-0.9795-2023-12-16.jld2"
train("DFMN1-5", 20, images, model)
=#
const LABELTOINDEX::Dict{String,Int32} = Dict()

Model = Union{Bool,String}

function train(
model_name::String,
train_epochs::Int64,
images::Vector{String}, #glob_pattern::String = "*/*.png"
pretrain::Model = true,
train_test_split::Float64 = 0.8,
batch_size::Int64 = 64,
)
epochs = 1:train_epochs
#images = glob(glob_pattern) #|> shuffle! |> x -> x[1:640]
@assert !isempty(images) "No png images found"
@info "$(length(images)) images in dataset"

label_to_index = labels_to_dict(images)
register_label_to_index!(label_to_index)
@info "Text labels translate to: " label_to_index
classes = length(label_to_index)
@assert classes >= 2 "At least 2 label classes are required, for example: kiwi, not_kiwi"
@info "$classes classes in dataset"
@info "Device: $device"

ceiling = seil(length(images), batch_size)
train_test_index = train_test_idx(ceiling, batch_size, train_test_split)

train, train_sample, test = process_data(images, train_test_index, ceiling, batch_size)
@info "Made data loaders"

model = load_model(pretrain, classes)
@info "Loaded model"
opt = Flux.setup(Flux.Optimisers.Adam(1e-5), model)
@info "Setup optimiser"

@info "Training for $epochs epochs: " now()
training_loop!(
model,
opt,
train,
train_sample,
test,
epochs,
model_name,
classes,
label_to_index,
)
@info "Finished $(last(epochs)) epochs: " now()
end

struct ImageContainer{T<:Vector}
img::T
end

struct ValidationImageContainer{T<:Vector}
img::T
end

Container = Union{ImageContainer,ValidationImageContainer}

function seil(n::Int, batch_size::Int)
return n ÷ batch_size * batch_size
end

function train_test_idx(ceiling::Int, batch_size::Int, train_test_split::Float64)::Int
t =
#! format: off
ceiling ÷ batch_size * train_test_split |>
round |>
x -> x * batch_size |>
x -> convert(Int, x)
#! format: on
end

function labels_to_dict(list::Vector{String})::Dict{String,Int32}
l =
#! format: off
map(x -> split(x, "/")[end-1], list) |>
unique |>
sort |>
x -> zip(x, 1:length(x)) |>
Dict
#! format: on
return l
end

"""
register_label_to_index!(label_to_index::Dict{String,Int32})

This will replace the content of the global variable LABELTOINDEX
with the content intended by the caller.

Thanks algunion
https://discourse.julialang.org/t/dataloader-scope-troubles/105207/4
"""
function register_label_to_index!(label_to_index::Dict{String,Int32})
empty!(LABELTOINDEX)
merge!(LABELTOINDEX, label_to_index)
end

device = CUDA.functional() ? gpu : cpu

function process_data(array_of_file_names, train_test_index, ceiling, batch_size)
seed!(1234)
images = shuffle!(array_of_file_names)
train =
ImageContainer(images[1:train_test_index]) |> x -> make_dataloader(x, batch_size)
train_sample =
ValidationImageContainer(images[1:(ceiling-train_test_index)]) |>
x -> make_dataloader(x, batch_size)
test =
ValidationImageContainer(images[train_test_index+1:ceiling]) |>
x -> make_dataloader(x, batch_size)
return train, train_sample, test
end

length(data::ImageContainer) = length(data.img)
length(data::ValidationImageContainer) = length(data.img)

function getindex(data::ImageContainer{Vector{String}}, index::Int)
path = data.img[index]
img =
#! format: off
Images.load(path) |>
#x -> Images.imresize(x, 224, 224) |>
#x -> Images.RGB.(x) |>
x -> Noise.add_gauss(x, (rand() * 0.2)) |>
x -> apply_mask!(x, 3, 3, 12) |>
x -> collect(channelview(float32.(x))) |>
x -> permutedims(x, (3, 2, 1))
#! format: on
y = LABELTOINDEX[(split(path, "/")[end-1])]
return img, y
end

function getindex(data::ValidationImageContainer{Vector{String}}, index::Int)
path = data.img[index]
img =
#! format: off
Images.load(path) |>
#x -> Images.imresize(x, 224, 224) |>
#x -> Images.RGB.(x) |>
x -> collect(channelview(float32.(x))) |>
x -> permutedims(x, (3, 2, 1))
#! format: on
y = LABELTOINDEX[(split(path, "/")[end-1])]
return img, y
end

# assumes 224px square images
function apply_mask!(
img::Array{RGB{N0f8},2},
max_number::Int = 3,
min_size::Int = 3,
max_size::Int = 22,
)
# horizontal
for range in get_random_ranges(max_number, min_size, max_size)
img[range, :] .= RGB{N0f8}(0.7, 0.7, 0.7)
end
# vertical
for range in get_random_ranges(max_number, min_size, max_size)
img[:, range] .= RGB{N0f8}(0.7, 0.7, 0.7)
end
return img
end

# assumes 224px square images
function get_random_ranges(max_number::Int, min_size::Int, max_size::Int)
number = rand(0:max_number)
ranges = []
while length(ranges) < number
start = rand(1:224)
size = rand(min_size:max_size)
if start + size > 224
continue
end
push!(ranges, start:start+size)
end
return ranges
end

function make_dataloader(container::Container, batch_size::Int)
data =
Flux.DataLoader(container; batchsize = batch_size, collate = true, parallel = true)
device == gpu ? data = CuIterator(data) : nothing
return data
end

# see load_model() from predict, and below
function load_model(pretrain::Bool, classes::Int64)
fst = Metalhead.ResNet(18, pretrain = pretrain).layers
lst = Flux.Chain(AdaptiveMeanPool((1, 1)), Flux.flatten, Dense(512 => classes))
model = Flux.Chain(fst[1], lst) |> device
return model
end

#If model classes == desired classes I don't empty the last layer
#That means that I can just train from where I left off for new data, DFMN model
#Could be a gotcha if I want to train a different 4 class model, no need for a switch just yet
function load_model(model_path::String, classes::Int64)
model_state = JLD2.load(model_path, "model_state")
model_classes = length(model_state[1][2][1][3][2])
f = Metalhead.ResNet(18, pretrain = false).layers
l = Flux.Chain(AdaptiveMeanPool((1, 1)), Flux.flatten, Dense(512 => model_classes))
m = Flux.Chain(f[1], l)
Flux.loadmodel!(m, model_state)
if classes == model_classes
model = m |> device
else
fst = m.layers
lst = Flux.Chain(AdaptiveMeanPool((1, 1)), Flux.flatten, Dense(512 => classes))
model = Flux.Chain(fst[1], lst) |> device
end
return model
end

function evaluate(m, d, c)
good = 0
count = 0
pred = Int64[]
actual = Int64[]
for (x, y) in d
p = Flux.onecold(m(x))
good += sum(p .== y)
count += length(y)
append!(pred, p)
append!(actual, y)
end
accuracy = round(good / count, digits = 4)
confusion_matrix = MLBase.confusmat(c, actual, pred)
#freqtable(DataFrame(targets = actual, predicts = pred), :targets, :predicts)
#roc=MLBase.roc(actual, pred, 100)
#f1=MLBase.f1score(roc)
return accuracy, confusion_matrix #, roc, f1
end

function train_epoch!(model; opt, train, classes)
Flux.train!(model, train, opt) do m, x, y
Flux.Losses.logitcrossentropy(m(x), Flux.onehotbatch(y, 1:classes))
end
end

function dict_to_text_file(dict, model_name)
text = ""
for (key, value) in dict
text = text * "$(key) => $(value)\n"
end
open("labels_$(model_name)-$(today()).txt", "w") do file
write(file, text)
end
@info "Saved labels to file for future reference"
end

function training_loop!(
model,
opt,
train,
train_sample,
test,
epochs::UnitRange{Int64},
model_name::String,
classes,
label_to_index,
)
@time eval, vcm = evaluate(model, test, classes)
@info "warm up accuracy" accuracy = eval
@info "warm up confusion matrix" vcm

a = 0
for epoch in epochs
println("")
@info "Starting Epoch: $epoch"
epoch == 1 && dict_to_text_file(label_to_index, model_name)
@time train_epoch!(model; opt, train, classes)
@time train_accuracy, train_confusion_matrix =
evaluate(model, train_sample, classes)
@info "Epoch: $epoch"
@info "train" accuracy = train_accuracy
@info "train" train_confusion_matrix

@time test_accuracy, test_confusion_matrix = evaluate(model, test, classes)
@info "test" accuracy = test_accuracy
@info "test" test_confusion_matrix

# number kiwi guessed right, assumes kiwi=1, not=2 (alphabetical)
#test_confusion_matrix[1,1] > a && begin
#a = test_confusion_matrix[1,1]
let _model = cpu(model)
jldsave(
"/media/david/SSD2/model_$(model_name)_CPU_epoch-$epoch-$test_accuracy-$(today()).jld2";
model_state = Flux.state(_model),
)
@info "Saved a best_model"
end
#end
end
end
file deletion: Predict.jl (----------)

[5.6598]→[5.375088:375122](∅→∅),[5.375122]→[5.366496:366496](∅→∅)

# Predict.jl

using WAV,
DSP, Images, ThreadsX, Dates, DataFrames, CSV, Flux, CUDA, Metalhead, JLD2, FLAC, Glob
import Base: length, getindex

"""
predict(glob_pattern::String, model::String)

This function takes a glob pattern for folders (or a vector of folders) to run over, and a model path. It saves results in a csv in each folder, similar to opensoundscape

Args:

• glob pattern (folder/) or a vector of folders
• model path

Returns: Nothing - This function saves csv files.

I use this function to find kiwi from new data gathered on a trip. And to predict D/F/M/N for images clipped from primary detections.

It works on both audio (wav or flac) and png images.

Note:
From Pomona-3/Pomona-3/

Use like:
using Skraak
glob_pattern = "*/*/"
model = "/media/david/SSD2/PrimaryDataset/model_K1-9_original_set_CPU_epoch-7-0.9924-2024-03-05.jld2"
glob_pattern = "Clips_2024-10-21/"
model = "/media/david/SSD1/Clips/model_DFMN1-5_CPU_epoch-18-0.9132-2024-01-29.jld2"
predict(glob_pattern, model)
"""

function predict(glob_pattern::String, model::String)
model = load_model_pred(model) |> device
folders = glob(glob_pattern)
@info "Folders: $folders"
for folder in folders
@info "Working on: $folder"
predict_folder(folder, model)
end
end

function predict(folders::Vector{String}, model::String)
model = load_model_pred(model) |> device
@info "Folders: $folders"
for folder in folders
@info "Working on: $folder"
predict_folder(folder, model)
end
end

#~~~~~ The guts ~~~~~#
struct PredictImageContainer{T<:Vector}
img::T
end

length(data::PredictImageContainer) = length(data.img)

function getindex(data::PredictImageContainer{Vector{String}}, idx::Int)
path = data.img[idx]
img =
#! format: off
Images.load(path) |>
x -> Images.imresize(x, 224, 224)|>
x -> Images.RGB.(x) |>
x -> collect(channelview(float32.(x))) |>
x -> permutedims(x, (3, 2, 1))
#! format: on
return img, path
end

function predict_image_folder(png_files::Vector{String}, model, folder::String)
l = length(png_files)
@assert (l > 0) "No png files present in $folder"
@info "$(l) png_files in $folder"
save_path = "$folder/preds-$(today()).csv"
loader = png_loader(png_files)
@time preds, files = predict_pngs(model, loader)
f = split.(files, "/") |> x -> last.(x)
df = DataFrame(file = f, label = preds)
CSV.write("$save_path", df)
end

function png_loader(png_files::Vector{String})
loader = Flux.DataLoader(
PredictImageContainer(png_files);
batchsize = 64,
collate = true,
parallel = true,
)
device == gpu ? loader = CuIterator(loader) : nothing
return loader
end

function predict_pngs(m, d)
@info "Predicting..."
pred = []
path = []
for (x, pth) in d
p = Flux.onecold(m(x))
append!(pred, p)
append!(path, pth)
end
return pred, path
end

# Predict from audio files
function predict_audio_folder(audio_files::Vector{String}, model, folder::String)
l = length(audio_files)
@assert (l > 0) "No wav or flac audio files present in $folder"
@info "$(l) audio_files in $folder"
df = DataFrame(
file = String[],
start_time = Float64[],
end_time = Float64[],
label = Int[],
)
save_path = "$folder/preds-$(today()).csv"
CSV.write("$save_path", df)
for file in audio_files
df = predict_audio_file(file, model)
CSV.write("$save_path", df, append = true)
end
end

function predict_audio_file(file::String, model)
#check form of opensoundscape preds.csv and needed by my make_clips
@info "File: $file"
@time data = audio_loader(file)
pred = []
time = []
@time for (x, t) in data
p = Flux.onecold(model(x))
append!(pred, p)
append!(time, t)
end
f = (repeat(["$file"], length(time)))
df = DataFrame(
:file => f,
:start_time => first.(time),
:end_time => last.(time),
:label => pred,
)
sort!(df)
return df
end

function audio_loader(file::String, increment::Int = 5, divisor::Int = 2)
raw_images, n_samples = get_images_from_audio(file::String, increment, divisor)
images = reshape_images(raw_images, n_samples)

start_time = 0:(increment/divisor):(n_samples-1)*(increment/divisor)
end_time = increment:(increment/divisor):(n_samples+1)*(increment/divisor)
time = collect(zip(start_time, end_time))

loader = Flux.DataLoader((images, time), batchsize = n_samples, shuffle = false)
device == gpu ? loader = CuIterator(loader) : nothing #check this works with gpu
return loader
end

function reshape_images(raw_images, n_samples)
images =
#! format: off
hcat(raw_images...) |>
x -> reshape(x, (224, 224, 3, n_samples))
#! format: on
return images
end

# need to change divisor to a overlap fraction, chech interaction with audioloader()
# if divisor is 0, then no overlap atm
function get_images_from_audio(file::String, increment::Int = 5, divisor::Int = 2) #5s sample, 2.5s hop
signal, freq = load_audio_file(file)
if freq > 16000
signal, freq = resample_to_16000hz(signal, freq)
end
f = convert(Int, freq)
inc = increment * f
#hop = f * increment ÷ divisor #need guarunteed Int, maybe not anymore, refactor
hop = 0 #f * increment / divisor |> x -> x == Inf ? 0 : trunc(Int, x)
split_signal = DSP.arraysplit(signal[:, 1], inc, hop)
raw_images = ThreadsX.map(x -> get_image_from_sample(x, f), split_signal)
n_samples = length(raw_images)
return raw_images, n_samples
end

function load_audio_file(file::String)
ext = split(file, ".")[end]
@assert ext in ["WAV", "wav", "flac"] "Unsupported audio file type, requires wav or flac."
if ext in ["WAV", "wav"]
signal, freq = WAV.wavread(file)
else
signal, freq = load(file)
end
@assert !isempty(signal[:, 1]) "$file seems to be empty, could it be corrupted?\nYou could delete it, or replace it with a known\ngood version from SD card or backup."
return signal, freq
end

function resample_to_16000hz(signal, freq)
signal = DSP.resample(signal, 16000.0f0 / freq; dims = 1)
freq = 16000
return signal, freq
end

############### PYTHON Opensoundscape ################
#=
# Dont forget conda activate opensoundscape
# Dont forget to modify file names and glob pattern
# Run script in Pomona-2, hard code trip date in the glob
# python /media/david/USB/Skraak/src/predict.py

from opensoundscape.torch.models.cnn import load_model
import opensoundscape

import torch
from pathlib import Path
import numpy as np
import pandas as pd

from glob import glob
import os
from datetime import datetime

model = load_model('/home/david/best.model0')

# folders = glob('./*/2023-?????/')
# folders = glob('./*/*/2024-05-0?')
folders = glob('./*/2024-10-18/')
for folder in folders:
os.chdir(folder)
print(folder, ' start: ', datetime.now())
# Beware, secretary island files are .wav
field_recordings = glob('./*.[W,w][A,a][V,v]')
scores, preds, unsafe = model.predict(
field_recordings,
binary_preds = 'single_target',
overlap_fraction = 0.5,
batch_size = 128,
num_workers = 12)
scores.to_csv("scores-2024-10-21.csv")
preds.to_csv("preds-2024-10-21.csv")
os.chdir('../..') # Be careful this matches the glob on line 284
print(folder, ' done: ', datetime.now())
print()
print()
=#
#=Kahurangi
folders = glob('./*/')
for folder in folders:
os.chdir(folder)
print(folder, ' start: ', datetime.now())
# Beware, secretary island files are .wav
field_recordings = glob('./*.[W,w][A,a][V,v]')
scores, preds, unsafe = model.predict(
field_recordings,
binary_preds = 'single_target',
overlap_fraction = 0.5,
batch_size = 128,
num_workers = 12)
scores.to_csv("scores-2024-10-21.csv")
preds.to_csv("preds-2024-10-21.csv")
os.chdir('./..') # Be careful this matches the glob on line 284
print(folder, ' done: ', datetime.now())
print()
print()
=#
# Python 3.8.12, opensoundscape 0.7.1
function resample_to_8000hz(signal, freq)
signal = DSP.resample(signal, 8000.0f0 / freq; dims = 1)
freq = 8000
return signal, freq
end

function get_image_for_inference(sample, f)
image =
#! format: off
get_image_from_sample(sample, f) |>
# x -> collect(channelview(float32.(x))) |>
x -> permutedims(x, (3, 2, 1))
#! format: on
return image
end

=#
#= not needed
# Start time and end time for each 5s audio clip, in seconds relative to the start of the file.
# see load_model() from train, different input types
function load_model_pred(model_path::String)
model_state = JLD2.load(model_path, "model_state")
model_classes = length(model_state[1][2][1][3][2])
f = Metalhead.ResNet(18, pretrain = false).layers
l = Flux.Chain(AdaptiveMeanPool((1, 1)), Flux.flatten, Dense(512 => model_classes))
model = Flux.Chain(f[1], l)
Flux.loadmodel!(model, model_state)
return model
end

#=
function load_bson(model_path::String)
BSON.@load model_path model
end
=#

function predict_folder(folder::String, model)
wav = glob("$folder/*.[W,w][A,a][V,v]")
flac = glob("$folder/*.flac")
audio_files = vcat(wav, flac) #if wav and flac both present will predict on all
png_files = glob("$folder/*.png")
#it will predict on images when both images and audio present
if isempty(png_files)
length(audio_files) > 0 ? predict_audio_folder(audio_files, model, folder) :
@info "No png, flac, wav, WAV files present in $folder"
else
predict_image_folder(png_files, model, folder)
end
end

device = CUDA.functional() ? gpu : cpu

# Predict from png images
@info "Model classes: $model_classes"
julia -t 4
Dont forget temp environment: ] activate --temp

export predict
export get_images_from_audio
replacement in src/Utility.jl at line 5

[5.315223]→[4.340746:340834](∅→∅)

using CSV, DataFrames, Dates, Glob, HTTP, Images, JSON3, TimeZones, WAV, DataFramesMeta

[5.315223]

[5.187]

using CSV,
DataFrames,
Dates,
Glob,
HTTP,
ImageTransformations,
JSON3,
TimeZones,
WAV,
DataFramesMeta
replacement in src/Utility.jl at line 37

[5.316598]→[5.316598:316632](∅→∅)

p = glob("$folder/*.png")

[5.316598]

[5.316632]

p = Glob.glob("$folder/*.png")
replacement in src/Utility.jl at line 42

[5.316762]→[5.316762:316808](∅→∅)

w = glob("$folder/*.[W,w][A,a][V,v]")

[5.316762]

[5.316808]

w = Glob.glob("$folder/*.[W,w][A,a][V,v]")
replacement in src/Utility.jl at line 72

[5.325332]→[5.325332:325350](∅→∅)

a=glob("*/*.png")

[5.325332]

[5.325350]

a=Glob.glob("*/*.png")
replacement in src/Utility.jl at line 80

[5.325480]→[5.325480:325527](∅→∅)

small_image = imresize(load(name), (x, y))

[5.325480]

[5.325527]

small_image = ImageTransformations.imresize(load(name), (x, y))
replacement in src/Utility.jl at line 95

[5.325864]→[5.325864:325906](∅→∅)

df = DataFrame(Date=[], Dawn=[], Dusk=[])

[5.325864]

[5.325906]

df = DataFrames.DataFrame(Date=[], Dawn=[], Dusk=[])
edit in src/Utility.jl at line 105

[5.131]

[5.326185]

#####deprecated now have a big sunset_sunrise_utc.csv to work from
edit in src/Utility.jl at line 108

[5.326189]→[4.340946:341009](∅→∅)

#deprecated now have a big sunset_sunrise_utc.csv to work from
replacement in src/Utility.jl at line 128

[5.327097]→[4.341010:341103](∅→∅)

function dawn_dusk_lt_of_sunrise_sunset_utc(file::String)
df = DataFrame(CSV.File(file))

[5.327097]

[4.341103]

#dawn_dusk is local time, sunrise_sunret is utc
function dawn_dusk_of_sunrise_sunset(file::String)
df = DataFrames.DataFrame(CSV.File(file))
replacement in src/Utility.jl at line 168

[5.327613]→[5.327613:327663](∅→∅)

df = DataFrame([name => [] for name in cols])

[5.327613]

[5.327663]

df = DataFrames.DataFrame([name => [] for name in cols])
replacement in src/Utility.jl at line 252

[5.328354]→[5.328354:328380](∅→∅)

a = glob("*/2022-12-17/")

[5.328354]

[5.328380]

a = Glob.glob("*/2022-12-17/")
replacement in src/Utility.jl at line 256

[5.328423]→[5.328423:328445](∅→∅)

files = glob("*.WAV")

[5.328423]

[5.328445]

files = Glob.glob("*.WAV")
edit in src/Utility.jl at line 298

[5.329751]

function resample_to_16000hz(signal, freq)
signal = DSP.resample(signal, 16000.0f0 / freq; dims = 1)
freq = 16000
return signal, freq
end

function resample_to_8000hz(signal, freq)
signal = DSP.resample(signal, 8000.0f0 / freq; dims = 1)
freq = 8000
return signal, freq
end
replacement in src/Skraak.jl at line 12

[5.356020]→[5.475:497](∅→∅),[5.497]→[5.35:55](∅→∅),[5.35]→[5.35:55](∅→∅),[5.81]→[5.81:82](∅→∅),[5.82]→[5.360059:360071](∅→∅),[5.360059]→[5.360059:360071](∅→∅)

include("Predict.jl")
include("Train.jl")

end # module

[5.356020]

end # Skraak module
replacement in src/Labels.jl at line 13

[5.309]→[5.309:358](∅→∅)

a=glob("[M,F,D,N]/*.png")
df = DataFrame(file=a)

[5.309]

[5.358]

a=Glob.glob("[M,F,D,N]/*.png")
df = DataFrames.DataFrame(file=a)
replacement in src/Labels.jl at line 21

[5.469]→[5.469:511](∅→∅)

df=DataFrame(CSV.File("actual_mfdn.csv"))

[5.469]

[5.511]

df=DataFrames.DataFrame(CSV.File("actual_mfdn.csv"))
replacement in src/Labels.jl at line 39

[5.931]→[5.931:980](∅→∅)

paths = append!(paths, glob("$l/*.png"))

[5.931]

[5.980]

paths = append!(paths, Glob.glob("$l/*.png"))
replacement in src/Labels.jl at line 41

[5.988]→[5.988:1021](∅→∅)

df = DataFrame(file = paths)

[5.988]

[5.1021]

df = DataFrames.DataFrame(file = paths)
edit in src/Labels.jl at line 46

[5.1072]→[5.1072:1136](∅→∅)

"""
aggregate_labels(actual="actual.csv", outfile="labels.csv")
edit in src/Labels.jl at line 47

[5.1137]→[5.1137:1483](∅→∅),[5.1483]→[5.1483:1526](∅→∅)

file
[D, F, M, N]/C05-2023-04-15-20230219_223000-380-470.png

This function takes the csv output from my hand classification and ouputs a df, and csv for insertion into AudioData.duckdb using the duckdb cli or using DFto.audiodata_db()

assumes run from Clips_xxxx-xx-xx folder and that "actual.csv" present if not specified.
returns a dataframe

using CSV, DataFrames, DataFramesMeta
"""
edit in src/Labels.jl at line 73

[5.2214]

[5.2214]

"""
aggregate_labels(actual="actual.csv", outfile="labels.csv")

file
[D, F, M, N]/C05-2023-04-15-20230219_223000-380-470.png

This function takes the csv output from my hand classification and ouputs a df, and csv for insertion into AudioData.duckdb using the duckdb cli or using DFto.audiodata_db()

assumes run from Clips_xxxx-xx-xx folder and that "actual.csv" present if not specified.
returns a dataframe

using CSV, DataFrames, DataFramesMeta
"""
replacement in src/Labels.jl at line 91

[5.2369]→[5.2369:2406](∅→∅)

df = DataFrame(CSV.File(actual))

[5.2369]

[5.2406]

df = DataFrames.DataFrame(CSV.File(actual))
replacement in src/Labels.jl at line 172

[5.158]→[5.158:199](∅→∅)

# a=glob("*/*/*.Table.1.selections.txt")

[5.158]

[3.307]

# a=Glob.glob("*/*/*.Table.1.selections.txt")
replacement in src/Labels.jl at line 176

[3.378]→[5.74:106](∅→∅),[5.272]→[5.74:106](∅→∅)

df = DataFrame(CSV.File(f))

[3.378]

[5.106]

df = DataFrames.DataFrame(CSV.File(f))
replacement in src/Labels.jl at line 202

[3.722]→[3.722:742](∅→∅)

df = DataFrame(

[3.722]

[3.742]

df = DataFrames.DataFrame(
replacement in src/Labels.jl at line 231

[3.1463]→[3.1463:1483](∅→∅)

df = DataFrame(

[3.1463]

[3.1483]

df = DataFrames.DataFrame(
replacement in src/Labels.jl at line 260

[5.574]→[5.574:597](∅→∅)

# a=glob("*.WAV.data")

[5.574]

[5.597]

# a=Glob.glob("*.WAV.data")
replacement in src/Labels.jl at line 294

[3.2442]→[3.2442:2533](∅→∅)

files = glob("$folder/*.['W','w']['A','a']['V','v'].data")
df = DataFrame(

[3.2442]

[3.2533]

files = Glob.glob("$folder/*.['W','w']['A','a']['V','v'].data")
df = DataFrames.DataFrame(
replacement in src/Labels.jl at line 313

[3.3210]→[3.3210:3291](∅→∅)

files = glob("$folder/*.Table.1.selections.txt")
df = DataFrame(

[3.3210]

[3.3291]

files = Glob.glob("$folder/*.Table.1.selections.txt")
df = DataFrames.DataFrame(
replacement in src/Labels.jl at line 323

[3.3521]→[3.3521:3565](∅→∅)

df1 = DataFrame(CSV.File(file))

[3.3521]

[3.3565]

df1 = DataFrames.DataFrame(CSV.File(file))
replacement in src/FileMetaData.jl at line 9

[5.4707]→[2.1610:1649](∅→∅)

# needs SSD1 present for dawn_dusk.csv

[5.4707]

[5.4707]

# needs SSD1 present for dawn_dusk.csv (not anymore, gets from dddict)
replacement in src/FileMetaData.jl at line 12

[5.4742]→[2.1650:1680](∅→∅)

folders=glob("*/2024-10-18/")

[5.4742]

[2.1680]

folders=Glob.glob("*/2024-10-18/")
replacement in src/FileMetaData.jl at line 55

[5.5977]→[5.5977:5997](∅→∅)

df = DataFrame(

[5.5977]

[5.5997]

df = DataFrames.DataFrame(
replacement in src/FileMetaData.jl at line 77

[5.6579]→[5.6579:6616](∅→∅)

wav_list = glob("*.WAV") |> sort

[5.6579]

[5.6616]

wav_list = Glob.glob("*.WAV") |> sort
replacement in src/FileMetaData.jl at line 92

[5.6946]→[5.6946:6975](∅→∅)

waypoint = glob("*.gpx")

[5.6946]

[5.6975]

waypoint = Glob.glob("*.gpx")
replacement in src/FileMetaData.jl at line 100

[5.7245]→[5.7245:7303](∅→∅)

_, _, _, binary_metadata_start = wavread(wav_list[1])

[5.7245]

[5.7303]

_, _, _, binary_metadata_start = WAV.wavread(wav_list[1])
replacement in src/FileMetaData.jl at line 128

[5.8356]→[5.8356:8414](∅→∅)

_, _, _, binary_metadata_end = wavread(wav_list[end])

[5.8356]

[5.8414]

_, _, _, binary_metadata_end = WAV.wavread(wav_list[end])
replacement in src/FileMetaData.jl at line 165

[5.9609]→[5.9609:9681](∅→∅)

audio_data, sample_rate, _, binary_metadata = wavread(file)

[5.9609]

[5.9681]

audio_data, sample_rate, _, binary_metadata = WAV.wavread(file)
replacement in src/ConstructPrimaryDataset.jl at line 26

[5.5180]→[5.5180:5221](∅→∅)

df = DataFrame(CSV.File(input_file))

[5.5180]

[5.5221]

df = DataFrames.DataFrame(CSV.File(input_file))
replacement in src/ConstructPrimaryDataset.jl at line 45

[5.6003]→[5.6003:6035](∅→∅)

b = glob("$l/*/$f")

[5.6003]

[5.6035]

b = Glob.glob("$l/*/$f")
replacement in src/ConstructPrimaryDataset.jl at line 62

[5.511]→[5.6366:6394](∅→∅),[5.6366]→[5.6366:6394](∅→∅)

gdf = groupby(df, :key)

[5.511]

[5.663]

gdf = DataFrames.groupby(df, :key)
replacement in src/ConstructPrimaryDataset.jl at line 67

[5.378849]→[5.6596:6665](∅→∅)

#signal, freq = wavread("kiwi_set_2023-11-13/$folder/$file")

[5.377051]

[5.624]

#signal, freq = WAV.wavread("kiwi_set_2023-11-13/$folder/$file")
replacement in src/ConstructPrimaryDataset.jl at line 75

[5.865]→[5.6924:6983](∅→∅),[5.6924]→[5.6924:6983](∅→∅)

ldf = DataFrame(second = 1:duration, kiwi = false)

[5.865]

[5.866]

ldf = DataFrames.DataFrame(second = 1:duration, kiwi = false)
replacement in src/ConstructPrimaryDataset.jl at line 92

[5.7405]→[5.7405:7460](∅→∅)

plot = get_image_from_sample(sample, freq)

[5.7405]

[5.7460]

plot = Skraak.get_image_from_sample(sample, freq)
replacement in src/ConstructPrimaryDataset.jl at line 114

[5.8398]→[5.8398:8453](∅→∅)

plot = get_image_from_sample(sample, freq)

[5.8398]

[5.8453]

plot = Skraak.get_image_from_sample(sample, freq)
replacement in src/Clips.jl at line 11

[5.853]→[5.540:552](∅→∅)

Images,

[5.853]

[5.863]

ImageTransformations,
edit in src/Clips.jl at line 21

[5.718]→[5.12570:13038](∅→∅),[5.12570]→[5.12570:13038](∅→∅),[5.13038]→[5.859:929](∅→∅),[5.929]→[5.13089:13189](∅→∅),[5.13089]→[5.13089:13189](∅→∅)

make_clips(preds_path::String, dawn_dusk_dict::Dict{Dates.Date, Tuple{Dates.DateTime, Dates.DateTime}} = construct_dawn_dusk_dict("/media/david/SSD1/dawn_dusk.csv"))

This function takes a preds.csv files and generates
file names, wav's, spectrograms etc to be reviewed.
it calls night() and may call construct_dawn_dusk_dict() unless the dict is globally defined and passed in

It should be run from Pomona-1/, Pomona-2/ or Pomona-3/, assumes it is, it uses the path
It saves wav and png files to current working directory, ie Pomona-3
need to use a try/catch because the 2 assert functions thow an error to short circuit the function
replacement in src/Clips.jl at line 22

[5.13208]→[2.2080:2122](∅→∅)

predictions = glob("*/2024-10-18/preds*")

[5.13208]

[2.2122]

predictions = Glob.glob("*/2024-10-18/preds*")
edit in src/Clips.jl at line 38

[5.13665]→[5.719:722](∅→∅)

=#
edit in src/Clips.jl at line 42

[5.13877]

[5.13877]

=#
"""
make_clips(preds_path::String, dawn_dusk_dict::Dict{Dates.Date, Tuple{Dates.DateTime, Dates.DateTime}} = construct_dawn_dusk_dict("/media/david/SSD1/dawn_dusk.csv"))

This function takes a preds.csv files and generates
file names, wav's, spectrograms etc to be reviewed.
it calls night() and may call construct_dawn_dusk_dict() unless the dict is globally defined and passed in

It should be run from Pomona-1/, Pomona-2/ or Pomona-3/, assumes it is, it uses the path
It saves wav and png files to current working directory, ie Pomona-3
need to use a try/catch because the 2 assert functions thow an error to short circuit the function
"""
replacement in src/Clips.jl at line 67

[5.14176]→[5.14176:14469](∅→∅)

DataFrame(CSV.File(preds_path)) |>
x -> assert_not_empty(x, preds_path) |>
x -> rename_column!(x, "1.0", "label") |> #can remove now, needs to be label
x -> assert_detections_present(x, label, location, trip_date) |>
x -> filter_positives!(x, label) |>

[5.14176]

[5.14469]

DataFrames.DataFrame(CSV.File(preds_path)) |>
x -> Skraak.assert_not_empty(x, preds_path) |>
x -> Skraak.rename_column!(x, "1.0", "label") |> #can remove now, needs to be label
x -> Skraak.assert_detections_present(x, label, location, trip_date) |>
x -> Skraak.filter_positives!(x, label) |>
replacement in src/Clips.jl at line 73

[5.14504]→[5.14504:14583](∅→∅)

x -> night_or_day!(x, dawn_dusk_dict, night) |> #true=night, false=day

[5.14504]

[5.14583]

x -> Skraak.night_or_day!(x, dawn_dusk_dict, night) |> #true=night, false=day
replacement in src/Clips.jl at line 79

[5.14746]→[5.75:137](∅→∅)

file_name, extension = path_to_file_string(v.file[1])

[5.14746]

[5.14797]

file_name, extension = Skraak.path_to_file_string(v.file[1])
replacement in src/Clips.jl at line 82

[5.14846]→[5.14846:14899](∅→∅)

detections = cluster_detections(start_times)

[5.14846]

[5.14899]

detections = Skraak.cluster_detections(start_times)
replacement in src/Clips.jl at line 85

[5.14940]→[5.138:219](∅→∅),[5.219]→[5.1009:1095](∅→∅)

signal, freq = wavread("$location/$trip_date/$(file_name).$(extension)")
##signal, freq = wavread("$location/$h/$trip_date/$(file_name).$(extension)")

[5.14940]

[5.219]

signal, freq = WAV.wavread("$location/$trip_date/$(file_name).$(extension)")
##signal, freq = WAV.wavread("$location/$h/$trip_date/$(file_name).$(extension)")
replacement in src/Clips.jl at line 94

[5.15086]→[5.15086:15164](∅→∅)

st, en = calculate_clip_start_end(detection, freq, length_signal)

[5.15086]

[5.15164]

st, en = Skraak.calculate_clip_start_end(detection, freq, length_signal)
replacement in src/Clips.jl at line 102

[5.15398]→[5.15398:15459](∅→∅)

wavwrite(sample, "$outfile.wav", Fs = Int(freq))

[5.15398]

[5.15459]

WAV.wavwrite(sample, "$outfile.wav", Fs = Int(freq))
replacement in src/Clips.jl at line 106

[5.15554]→[5.15554:15610](∅→∅)

image = get_image_from_sample(sample, freq)

[5.15554]

[5.15610]

image = Skraak.get_image_from_sample(sample, freq)
replacement in src/Clips.jl at line 154

[5.17063]→[5.506:559](∅→∅)

file_string = path_to_file_string(file) |> first

[5.17063]

[5.17107]

file_string = Skraak.path_to_file_string(file) |> first
replacement in src/Clips.jl at line 165

[5.17425]→[5.17425:17502](∅→∅)

@transform!(df, @byrow :DateTime = filename_to_datetime!(String(:file)))

[5.17425]

[5.17502]

@transform!(df, @byrow :DateTime = Skraak.filename_to_datetime!(String(:file)))
replacement in src/Clips.jl at line 175

[5.17740]→[5.17740:17813](∅→∅)

night_time ? @subset!(df, @byrow night(:DateTime, dawn_dusk_dict)) :

[5.17740]

[5.17813]

night_time ? @subset!(df, @byrow Skraak.night(:DateTime, dawn_dusk_dict)) :
replacement in src/Clips.jl at line 181

[5.17930]→[5.17930:17959](∅→∅)

gdf = groupby(df, :file)

[5.17930]

[5.17959]

gdf = DataFrames.groupby(df, :file)
replacement in src/Clips.jl at line 227

[5.19231]→[5.2008:2054](∅→∅)

x -> applycolourmap(x, cmap("L4")) |>

[5.19231]

[5.837]

x -> PerceptualColourMaps.applycolourmap(x, cmap("L4")) |>
replacement in src/Clips.jl at line 229

[5.863]→[5.863:901](∅→∅)

x -> imresize(x, 224, 224) |>

[5.863]

[5.901]

x -> ImageTransformations.imresize(x, 224, 224) |>
edit in src/Clips.jl at line 234

[5.19334]

[5.19334]

#=
dict = construct_dawn_dusk_dict("/Volumes/SSD1/dawn_dusk.csv")
edit in src/Clips.jl at line 238

[5.19335]

[5.19335]

df=DataFrames.DataFrame(dict)
df=CSV.File("dawn_dusk.csv") |> DataFrame
open("dict.jl", "w") do file
write(file, "const dddict = Dict(")
for row in eachrow(df)
line="\tDates.Date(\"$(row.Date)\") =>
(Dates.DateTime(\"$(row.Dawn)\"), Dates.DateTime(\"$(row.Dusk)\")),\n"
write(file, line)
end
write(file, ")")
end

using CSV, DataFrames
=#
replacement in src/Clips.jl at line 254

[5.19415]→[5.19415:19447](∅→∅)

sun = DataFrame(CSV.File(file))

[5.19415]

[5.19447]

sun = DataFrames.DataFrame(CSV.File(file))
replacement in src/Clips.jl at line 256

[5.19448]→[4.342040:342107](∅→∅)

Takes dawn_dusk.csv and returns a dict to be consumeed by night().

[5.19448]

[5.19515]

Takes dawn_dusk.csv and returns a dict to be consumed by night().
replacement in src/Clips.jl at line 260

[5.19639]→[5.19639:19787](∅→∅),[5.19862]→[5.19862:19885](∅→∅)

I use this to decide if a file with a local time encoded name was recorded at night

dict = construct_dawn_dusk_dict("/Volumes/SSD1/dawn_dusk.csv")

using CSV, DataFrames

[5.19639]

[5.19885]

I use this to decide if a file with a local time encoded name was recorded at nigh
replacement in src/Clips.jl at line 263

[5.19974]→[5.19974:20010](∅→∅)

sun = DataFrame(CSV.File(file))

[5.19974]

[5.20010]

sun = DataFrames.DataFrame(CSV.File(file))
replacement in src/Clips.jl at line 301

[5.21108]→[5.21108:21164](∅→∅)

p = glob("*.png")
w = glob("*.[W,w][A,a][V,v]")

[5.21108]

[5.21164]

p = Glob.glob("*.png")
w = Glob.glob("*.[W,w][A,a][V,v]")
replacement in src/Clips.jl at line 330

[5.430]→[5.430:451](∅→∅)

wavs = glob("*.wav")

[5.430]

[5.451]

wavs = Glob.glob("*.wav")
replacement in src/Clips.jl at line 336

[5.559]→[5.559:595](∅→∅)

signal, freq = wavread("$file")

[5.559]

[5.595]

signal, freq = WAV.wavread("$file")
replacement in src/Clips.jl at line 343

[5.850]→[5.850:904](∅→∅)

image = get_image_from_sample(part, freq)

[5.850]

[5.904]

image = Skraak.get_image_from_sample(part, freq)
replacement in src/Clips.jl at line 377

[2.2173]→[2.2173:2239](∅→∅)

a=glob("*/*/*.csv")
b=glob("*/*/*/*.csv")
c=glob("*/*/*/*/*.csv")

[2.2173]

[2.2239]

a=Glob.glob("*/*/*.csv")
b=Glob.glob("*/*/*/*.csv")
c=Glob.glob("*/*/*/*/*.csv")
replacement in src/Clips.jl at line 405

[2.3027]→[2.3027:3070](∅→∅)

DataFrame(CSV.File(preds_path)) |>

[2.3027]

[2.3070]

DataFrames.DataFrame(CSV.File(preds_path)) |>
replacement in src/Clips.jl at line 421

[2.3722]→[2.3722:3793](∅→∅)

signal, freq = Skraak.wavread("$pth$(file_name).$(extension)")

[2.3722]

[2.3793]

signal, freq = WAV.wavread("$pth$(file_name).$(extension)")
replacement in src/Clips.jl at line 439

[2.4624]→[2.4624:4692](∅→∅)

Skraak.wavwrite(sample, "$outfile.wav", Fs = Int(freq))

[2.4624]

[2.4692]

Skraak.WAV.wavwrite(sample, "$outfile.wav", Fs = Int(freq))
replacement in src/Clips.jl at line 451

[2.4918]→[2.4918:5029](∅→∅)

a=glob("*/*/preds-2024-08-29.csv")
b=glob("*/*/*/preds-2024-08-29.csv")
c=glob("*/*/*/*/preds-2024-08-29.csv")

[2.4918]

[2.5029]

a=Glob.glob("*/*/preds-2024-08-29.csv")
b=Glob.glob("*/*/*/preds-2024-08-29.csv")
c=Glob.glob("*/*/*/*/preds-2024-08-29.csv")
replacement in src/Clips.jl at line 456

[2.5061]→[2.5061:5108](∅→∅)

predictions = glob("*/*/preds-2024-10-21.csv")

[2.5061]

[2.5108]

predictions = Glob.glob("*/*/preds-2024-10-21.csv")
edit in Project.toml at line 8

[5.385442]→[5.385442:385488](∅→∅)

CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
edit in Project.toml at line 16

[5.385883]→[5.385883:385929](∅→∅)

Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"
replacement in Project.toml at line 18

[5.386073]→[5.386073:386167](∅→∅)

Images = "916415d5-f1e6-5110-898d-aaa5f9f070e0"
JLD2 = "033835bb-8acc-5ee8-8aae-3f567f8a3819"

[5.386073]

[5.725]

ImageTransformations = "02fcd773-0e25-5acc-982a-7f6622650795"
edit in Project.toml at line 20

[5.772]→[5.1147:1195](∅→∅),[5.386213]→[5.1147:1195](∅→∅),[5.1195]→[5.386213:386311](∅→∅),[5.386213]→[5.386213:386311](∅→∅)

MLBase = "f0e99cf1-93fa-52ec-9ecc-5026115318e0"
Metalhead = "dbeba491-748d-5e0e-a39e-b530a07fa0cc"
Noise = "81d43f40-5267-43b7-ae1c-8b967f377efa"
edit in Project.toml at line 24

[5.386454]→[5.386454:386504](∅→∅)

ThreadsX = "ac1d9e8a-700a-412c-b207-f0111f4b6c0d"
edit in Project.toml at line 27

[5.386649]→[5.73:120](∅→∅)

cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd"
replacement in Manifest.toml at line 5

[5.10259938]→[5.800:858](∅→∅)

project_hash = "05f43fbbf5550775beb65cc441429ae846ed9652"

[5.10259938]

[5.1017]

project_hash = "8a2989b77560f8052503af51052115b4c49ef719"
edit in Manifest.toml at line 17

[5.1348]→[5.2180:2200](∅→∅),[5.2200]→[5.859:1029](∅→∅),[5.1029]→[5.2375:2421](∅→∅),[5.1443]→[5.2375:2421](∅→∅),[5.2375]→[5.2375:2421](∅→∅),[5.2421]→[5.1030:1049](∅→∅),[5.1049]→[5.1348:1349](∅→∅),[5.1463]→[5.1348:1349](∅→∅),[5.2440]→[5.1348:1349](∅→∅),[5.1348]→[5.1348:1349](∅→∅),[5.1349]→[5.2441:2511](∅→∅),[5.2511]→[5.1050:1082](∅→∅),[5.1082]→[5.2511:2649](∅→∅),[5.2511]→[5.2511:2649](∅→∅),[5.2649]→[5.1083:1113](∅→∅),[5.1113]→[5.1464:1500](∅→∅),[5.2649]→[5.1464:1500](∅→∅),[5.1500]→[5.2649:2734](∅→∅),[5.2649]→[5.2649:2734](∅→∅),[5.2734]→[5.1114:1165](∅→∅),[5.1165]→[5.2734:2962](∅→∅),[5.2734]→[5.2734:2962](∅→∅),[5.2962]→[5.1166:1216](∅→∅),[5.1216]→[5.1501:1554](∅→∅),[5.2962]→[5.1501:1554](∅→∅),[5.1554]→[5.2962:2963](∅→∅),[5.2962]→[5.2962:2963](∅→∅),[5.2963]→[5.1349:1401](∅→∅),[5.1349]→[5.1349:1401](∅→∅),[5.1401]→[5.1217:1276](∅→∅),[5.1075]→[5.1460:1506](∅→∅),[5.1276]→[5.1460:1506](∅→∅),[5.3023]→[5.1460:1506](∅→∅),[5.1460]→[5.1460:1506](∅→∅),[5.1506]→[5.1277:1295](∅→∅),[5.1094]→[5.1524:1765](∅→∅),[5.1295]→[5.1524:1765](∅→∅),[5.3042]→[5.1524:1765](∅→∅),[5.1524]→[5.1524:1765](∅→∅)

[[deps.Accessors]]
deps = ["CompositionsBase", "ConstructionBase", "InverseFunctions", "LinearAlgebra", "MacroTools", "Markdown"]
git-tree-sha1 = "b392ede862e506d451fc1616e79aa6f4c673dab8"
uuid = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697"
version = "0.1.38"

[deps.Accessors.extensions]
AccessorsAxisKeysExt = "AxisKeys"
AccessorsDatesExt = "Dates"
AccessorsIntervalSetsExt = "IntervalSets"
AccessorsStaticArraysExt = "StaticArrays"
AccessorsStructArraysExt = "StructArrays"
AccessorsTestExt = "Test"
AccessorsUnitfulExt = "Unitful"

[deps.Accessors.weakdeps]
AxisKeys = "94b1ba4f-4ee9-5380-92f1-94cde586c3c5"
Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953"
Requires = "ae029012-a4dd-5104-9daa-d747884805df"
StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"
Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"

[[deps.Adapt]]
deps = ["LinearAlgebra", "Requires"]
git-tree-sha1 = "50c3c56a52972d78e8be9fd135bfb91c9574c140"
uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
version = "4.1.1"
weakdeps = ["StaticArrays"]

[deps.Adapt.extensions]
AdaptStaticArraysExt = "StaticArrays"

[[deps.ArgCheck]]
git-tree-sha1 = "a3a402a35a2f7e0b87828ccabbd5ebfbebe356b4"
uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197"
version = "2.3.0"
edit in Manifest.toml at line 30

[5.10260145]→[5.2922:3087](∅→∅)

[[deps.Atomix]]
deps = ["UnsafeAtomics"]
git-tree-sha1 = "c06a868224ecba914baa6942988e2f2aade419be"
uuid = "a9b6321e-bd34-4604-b9c9-b65b8de01458"
version = "0.1.0"
edit in Manifest.toml at line 42

[5.3511]→[5.3511:3584](∅→∅),[5.3584]→[5.1375:1434](∅→∅),[5.1434]→[5.3643:3689](∅→∅),[5.3643]→[5.3643:3689](∅→∅),[5.3689]→[5.1435:1453](∅→∅),[5.1453]→[5.3707:3722](∅→∅),[5.3707]→[5.3707:3722](∅→∅),[5.3722]→[5.3122:3181](∅→∅),[5.3181]→[5.3781:3827](∅→∅),[5.3781]→[5.3781:3827](∅→∅),[5.3827]→[5.3182:3200](∅→∅),[5.3200]→[5.3845:3864](∅→∅),[5.3845]→[5.3845:3864](∅→∅),[5.3864]→[5.1454:1600](∅→∅),[5.1600]→[5.4029:4075](∅→∅),[5.3260]→[5.4029:4075](∅→∅),[5.4029]→[5.4029:4075](∅→∅),[5.4075]→[5.1601:1619](∅→∅),[5.1619]→[5.4094:4306](∅→∅),[5.3280]→[5.4094:4306](∅→∅),[5.4094]→[5.4094:4306](∅→∅),[5.4306]→[5.1620:1653](∅→∅),[5.1653]→[5.4306:4611](∅→∅),[5.4306]→[5.4306:4611](∅→∅),[5.4611]→[5.1654:1706](∅→∅),[5.1706]→[5.4611:4668](∅→∅),[5.4611]→[5.4611:4668](∅→∅)

[[deps.BFloat16s]]
deps = ["LinearAlgebra", "Printf", "Random", "Test"]
git-tree-sha1 = "2c7cc21e8678eff479978a0a2ef5ce2f51b63dff"
uuid = "ab4f0b2a-ad5b-11e8-123f-65d77653426b"
version = "0.5.0"

[[deps.BSON]]
git-tree-sha1 = "4c3e506685c527ac6a54ccc0c8c76fd6f91b42fb"
uuid = "fbb218c0-5317-5bc6-957e-2ee96dd4b1f0"
version = "0.3.9"

[[deps.BangBang]]
deps = ["Accessors", "ConstructionBase", "InitialValues", "LinearAlgebra", "Requires"]
git-tree-sha1 = "e2144b631226d9eeab2d746ca8880b7ccff504ae"
uuid = "198e06fe-97b7-11e9-32a5-e1d131e6ad66"
version = "0.4.3"

[deps.BangBang.extensions]
BangBangChainRulesCoreExt = "ChainRulesCore"
BangBangDataFramesExt = "DataFrames"
BangBangStaticArraysExt = "StaticArrays"
BangBangStructArraysExt = "StructArrays"
BangBangTablesExt = "Tables"
BangBangTypedTablesExt = "TypedTables"

[deps.BangBang.weakdeps]
ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"
Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
TypedTables = "9d95f2ec-7b3d-5a63-8d20-e2491e220bb9"
edit in Manifest.toml at line 45

[5.10260208]→[5.4670:4811](∅→∅)

[[deps.Baselet]]
git-tree-sha1 = "aebf55e6d7795e02ca500a689d326ac979aaf89e"
uuid = "9718e550-a3fa-408a-8086-8db961cd8217"
version = "0.1.1"
edit in Manifest.toml at line 67

[5.1635]→[5.5494:5509](∅→∅),[5.2029]→[5.5494:5509](∅→∅),[5.5494]→[5.5494:5509](∅→∅),[5.5509]→[5.2030:2550](∅→∅),[5.2550]→[5.6018:6064](∅→∅),[5.3864]→[5.6018:6064](∅→∅),[5.6018]→[5.6018:6064](∅→∅),[5.6064]→[5.2551:2569](∅→∅),[5.2569]→[5.6132:6201](∅→∅),[5.6132]→[5.6132:6201](∅→∅),[5.6201]→[5.2570:2603](∅→∅),[5.2603]→[5.6201:6246](∅→∅),[5.6201]→[5.6201:6246](∅→∅),[5.6246]→[5.2604:2808](∅→∅),[5.2808]→[5.6246:6272](∅→∅),[5.6246]→[5.6246:6272](∅→∅),[5.6272]→[5.2809:2920](∅→∅),[5.2920]→[5.6400:6446](∅→∅),[5.6400]→[5.6400:6446](∅→∅),[5.6446]→[5.2921:2942](∅→∅),[5.2942]→[5.6466:6516](∅→∅),[5.6466]→[5.6466:6516](∅→∅),[5.6516]→[5.2943:3002](∅→∅),[5.3002]→[5.6575:6621](∅→∅),[5.3943]→[5.6575:6621](∅→∅),[5.6575]→[5.6575:6621](∅→∅),[5.6621]→[5.3003:3021](∅→∅),[5.3021]→[5.6639:6755](∅→∅),[5.3962]→[5.6639:6755](∅→∅),[5.6639]→[5.6639:6755](∅→∅),[5.6755]→[5.3022:3081](∅→∅),[5.3081]→[5.6814:6860](∅→∅),[5.4022]→[5.6814:6860](∅→∅),[5.6814]→[5.6814:6860](∅→∅),[5.6860]→[5.3082:3103](∅→∅),[5.3103]→[5.6881:6991](∅→∅),[5.4044]→[5.6881:6991](∅→∅),[5.6881]→[5.6881:6991](∅→∅),[5.6991]→[5.3104:3163](∅→∅),[5.3163]→[5.7050:7096](∅→∅),[5.7050]→[5.7050:7096](∅→∅),[5.7096]→[5.3164:3184](∅→∅)

[[deps.CUDA]]
deps = ["AbstractFFTs", "Adapt", "BFloat16s", "CEnum", "CUDA_Driver_jll", "CUDA_Runtime_Discovery", "CUDA_Runtime_jll", "Crayons", "DataFrames", "ExprTools", "GPUArrays", "GPUCompiler", "KernelAbstractions", "LLVM", "LLVMLoopInfo", "LazyArtifacts", "Libdl", "LinearAlgebra", "Logging", "NVTX", "Preferences", "PrettyTables", "Printf", "Random", "Random123", "RandomNumbers", "Reexport", "Requires", "SparseArrays", "StaticArrays", "Statistics", "demumble_jll"]
git-tree-sha1 = "e0725a467822697171af4dae15cec10b4fc19053"
uuid = "052768ef-5323-5732-b1bb-66c8b64840ba"
version = "5.5.2"

[deps.CUDA.extensions]
ChainRulesCoreExt = "ChainRulesCore"
EnzymeCoreExt = "EnzymeCore"
SpecialFunctionsExt = "SpecialFunctions"

[deps.CUDA.weakdeps]
ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"
SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"

[[deps.CUDA_Driver_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "ccd1e54610c222fadfd4737dac66bff786f63656"
uuid = "4ee394cb-3365-5eb0-8335-949819d2adfc"
version = "0.10.3+0"

[[deps.CUDA_Runtime_Discovery]]
deps = ["Libdl"]
git-tree-sha1 = "33576c7c1b2500f8e7e6baa082e04563203b3a45"
uuid = "1af6417a-86b4-443c-805f-a4643ffb695f"
version = "0.3.5"

[[deps.CUDA_Runtime_jll]]
deps = ["Artifacts", "CUDA_Driver_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "TOML"]
git-tree-sha1 = "e43727b237b2879a34391eeb81887699a26f8f2f"
uuid = "76a88914-d11a-5bdc-97e0-2f5a05c973a2"
version = "0.15.3+0"

[[deps.CUDNN_jll]]
deps = ["Artifacts", "CUDA_Runtime_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "TOML"]
git-tree-sha1 = "9851af16a2f357a793daa0f13634c82bc7e40419"
uuid = "62b44479-cb7b-5706-934f-f13b2eb2e645"
version = "9.4.0+0"
edit in Manifest.toml at line 78

[5.3263]→[5.8049:8292](∅→∅),[5.10260971]→[5.8049:8292](∅→∅),[5.8292]→[5.3264:3323](∅→∅),[5.3323]→[5.8351:8397](∅→∅),[5.4104]→[5.8351:8397](∅→∅),[5.8351]→[5.8351:8397](∅→∅),[5.8397]→[5.3324:3343](∅→∅)

[[deps.ChainRules]]
deps = ["Adapt", "ChainRulesCore", "Compat", "Distributed", "GPUArraysCore", "IrrationalConstants", "LinearAlgebra", "Random", "RealDot", "SparseArrays", "SparseInverseSubset", "Statistics", "StructArrays", "SuiteSparse"]
git-tree-sha1 = "be227d253d132a6d57f9ccf5f67c0fb6488afd87"
uuid = "082447d4-558c-5d27-93f4-14fc19e9eca2"
version = "1.71.0"
edit in Manifest.toml at line 125

[5.10261157]→[5.10326:10356](∅→∅),[5.10356]→[5.3744:3825](∅→∅),[5.3825]→[5.10445:10491](∅→∅),[5.10445]→[5.10445:10491](∅→∅),[5.10491]→[5.3826:3844](∅→∅),[5.3844]→[5.10509:10510](∅→∅),[5.10509]→[5.10509:10510](∅→∅)

[[deps.CommonSubexpressions]]
deps = ["MacroTools"]
git-tree-sha1 = "cda2cfaebb4be89c9084adaca7dd7333369715c5"
uuid = "bbf7d656-a473-5ed7-a52c-81e309532950"
version = "0.3.1"
edit in Manifest.toml at line 139

[5.1369]→[5.10616:10766](∅→∅),[5.3945]→[5.10616:10766](∅→∅),[5.10261562]→[5.10616:10766](∅→∅),[5.10766]→[5.4632:4664](∅→∅)

[[deps.CompositionsBase]]
git-tree-sha1 = "802bb88cd69dfd1509f6670416bd4434015693ad"
uuid = "a33af91c-f02d-484b-be07-31d278c5ca2b"
version = "0.1.2"
weakdeps = ["InverseFunctions"]
edit in Manifest.toml at line 140

[5.10767]→[5.10767:10868](∅→∅)

[deps.CompositionsBase.extensions]
CompositionsBaseInverseFunctionsExt = "InverseFunctions"
edit in Manifest.toml at line 168

[5.10262073]→[5.11169:11358](∅→∅)

[[deps.ContextVariablesX]]
deps = ["Compat", "Logging", "UUIDs"]
git-tree-sha1 = "25cc3803f1030ab855e383129dcd3dc294e322cc"
uuid = "6add18c4-b38d-439d-96f6-d6bc489c04c5"
version = "0.1.3"
edit in Manifest.toml at line 227

[5.12215]→[5.12215:12364](∅→∅),[5.12364]→[5.10263999:10264163](∅→∅),[5.10263999]→[5.10263999:10264163](∅→∅),[5.10264163]→[5.12365:12774](∅→∅)

[[deps.DefineSingletons]]
git-tree-sha1 = "0fba8b706d0178b4dc7fd44a96a92382c9065c2c"
uuid = "244e2a9f-e319-4986-a169-4d1fe445cd52"
version = "0.1.2"

[[deps.DelimitedFiles]]
deps = ["Mmap"]
git-tree-sha1 = "9e2f36d3c96a820c678f2f1f1782582fcf685bae"
uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab"
version = "1.9.1"

[[deps.DiffResults]]
deps = ["StaticArraysCore"]
git-tree-sha1 = "782dd5f4561f5d267313f23853baaaa4c52ea621"
uuid = "163ba53b-c6d8-5494-b064-1a9d43ac40c5"
version = "1.1.0"

[[deps.DiffRules]]
deps = ["IrrationalConstants", "LogExpFunctions", "NaNMath", "Random", "SpecialFunctions"]
git-tree-sha1 = "23163d55f885173722d1e4cf0f6110cdbaf7e272"
uuid = "b552c78f-8df3-52c6-915a-8e097449b14b"
version = "1.15.1"
edit in Manifest.toml at line 312

[5.14786]→[5.14786:14936](∅→∅),[5.14936]→[5.5360:5419](∅→∅),[5.5419]→[5.14995:15041](∅→∅),[5.14995]→[5.14995:15041](∅→∅),[5.15041]→[5.5420:5438](∅→∅),[5.5438]→[5.15059:15232](∅→∅),[5.15059]→[5.15059:15232](∅→∅),[5.15232]→[5.10265521:10265522](∅→∅),[5.10265521]→[5.10265521:10265522](∅→∅)

[[deps.FLoops]]
deps = ["BangBang", "Compat", "FLoopsBase", "InitialValues", "JuliaVariables", "MLStyle", "Serialization", "Setfield", "Transducers"]
git-tree-sha1 = "0a2e5873e9a5f54abb06418d57a8df689336a660"
uuid = "cc61a311-1640-44b5-9fba-1b764f453329"
version = "0.2.2"

[[deps.FLoopsBase]]
deps = ["ContextVariablesX"]
git-tree-sha1 = "656f7a6859be8673bf1f35da5670246b923964f7"
uuid = "b9860ae5-e623-471e-878b-f6a53c775ea6"
version = "0.1.1"
edit in Manifest.toml at line 331

[5.10266183]→[5.15313:15334](∅→∅),[5.15334]→[5.5759:5843](∅→∅),[5.5843]→[5.15428:15474](∅→∅),[5.15428]→[5.15428:15474](∅→∅),[5.15474]→[5.5844:5863](∅→∅),[5.5863]→[5.10266183:10266184](∅→∅),[5.15492]→[5.10266183:10266184](∅→∅),[5.10266183]→[5.10266183:10266184](∅→∅),[5.10266184]→[5.15493:15849](∅→∅)

[[deps.FillArrays]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "6a70198746448456524cb442b8af316927ff3e1a"
uuid = "1a297f60-69ca-5386-bcde-b61e274b549b"
version = "1.13.0"

[deps.FillArrays.extensions]
FillArraysPDMatsExt = "PDMats"
FillArraysSparseArraysExt = "SparseArrays"
FillArraysStatisticsExt = "Statistics"

[deps.FillArrays.weakdeps]
PDMats = "90014a1f-27ba-587c-ab20-58faa44d9150"
SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
edit in Manifest.toml at line 343

[5.6055]→[5.10266712:10266713](∅→∅),[5.16102]→[5.10266712:10266713](∅→∅),[5.10266712]→[5.10266712:10266713](∅→∅),[5.10266713]→[5.16103:16117](∅→∅),[5.16117]→[5.6056:6398](∅→∅),[5.2256]→[5.16430:16476](∅→∅),[5.5318]→[5.16430:16476](∅→∅),[5.6398]→[5.16430:16476](∅→∅),[5.16430]→[5.16430:16476](∅→∅),[5.16476]→[5.6399:6419](∅→∅)

[[deps.Flux]]
deps = ["Adapt", "ChainRulesCore", "Compat", "Functors", "LinearAlgebra", "MLDataDevices", "MLUtils", "MacroTools", "NNlib", "OneHotArrays", "Optimisers", "Preferences", "ProgressLogging", "Random", "Reexport", "Setfield", "SparseArrays", "SpecialFunctions", "Statistics", "Zygote"]
git-tree-sha1 = "df520a0727f843576801a0294f5be1a94be28e23"
uuid = "587475ba-b771-5e3f-ad9e-33799f191a9c"
version = "0.14.25"
edit in Manifest.toml at line 344

[5.16496]→[5.16496:16618](∅→∅),[5.16618]→[5.6420:6517](∅→∅),[5.6517]→[5.16645:16773](∅→∅),[5.16645]→[5.16645:16773](∅→∅),[5.16773]→[5.6518:6669](∅→∅),[5.6669]→[5.16824:17059](∅→∅),[5.16824]→[5.16824:17059](∅→∅),[5.17059]→[5.6670:6729](∅→∅),[5.6729]→[5.17118:17164](∅→∅),[5.17118]→[5.17118:17164](∅→∅),[5.17164]→[5.6730:6750](∅→∅),[5.6750]→[5.17184:17296](∅→∅),[5.17184]→[5.17184:17296](∅→∅),[5.17506]→[5.17506:17549](∅→∅),[5.17549]→[5.6751:6810](∅→∅),[5.5399]→[5.17608:17654](∅→∅),[5.6810]→[5.17608:17654](∅→∅),[5.17608]→[5.17608:17654](∅→∅),[5.17654]→[5.6811:6830](∅→∅),[5.5418]→[5.10266886:10266887](∅→∅),[5.6830]→[5.10266886:10266887](∅→∅),[5.17672]→[5.10266886:10266887](∅→∅),[5.10266886]→[5.10266886:10266887](∅→∅)

[deps.Flux.extensions]
FluxAMDGPUExt = "AMDGPU"
FluxCUDAExt = "CUDA"
FluxCUDAcuDNNExt = ["CUDA", "cuDNN"]
FluxEnzymeExt = "Enzyme"
FluxMPIExt = "MPI"
FluxMPINCCLExt = ["CUDA", "MPI", "NCCL"]

[deps.Flux.weakdeps]
AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e"
CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9"
MPI = "da04e1cc-30fd-572f-bb4f-1f8673147195"
NCCL = "3fe64909-d7a1-4096-9b7d-7a0f12cf0f6b"
cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd"

[[deps.ForwardDiff]]
deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"]
git-tree-sha1 = "a2df1b776752e3f344e5116c06d75a10436ab853"
uuid = "f6369f11-7733-5829-9624-2563aa707210"
version = "0.10.38"
weakdeps = ["StaticArrays"]

[deps.ForwardDiff.extensions]
ForwardDiffStaticArraysExt = "StaticArrays"

[[deps.Functors]]
deps = ["LinearAlgebra"]
git-tree-sha1 = "64d8e93700c7a3f28f717d265382d52fac9fa1c1"
uuid = "d9f16b24-f501-4c13-a1f2-28368ffc5196"
version = "0.4.12"
edit in Manifest.toml at line 347

[5.10266967]→[5.10266967:10266968](∅→∅),[5.10266968]→[5.17673:17814](∅→∅),[5.17814]→[5.6831:6890](∅→∅),[5.5478]→[5.17873:17919](∅→∅),[5.6890]→[5.17873:17919](∅→∅),[5.17873]→[5.17873:17919](∅→∅),[5.17919]→[5.6891:6910](∅→∅),[5.5498]→[5.17937:17978](∅→∅),[5.6910]→[5.17937:17978](∅→∅),[5.17937]→[5.17937:17978](∅→∅),[5.17978]→[5.5499:5558](∅→∅),[5.5558]→[5.18037:18083](∅→∅),[5.18037]→[5.18037:18083](∅→∅),[5.18083]→[5.5559:5577](∅→∅)

[[deps.GPUArrays]]
deps = ["Adapt", "GPUArraysCore", "LLVM", "LinearAlgebra", "Printf", "Random", "Reexport", "Serialization", "Statistics"]
git-tree-sha1 = "62ee71528cca49be797076a76bdc654a170a523e"
uuid = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7"
version = "10.3.1"

[[deps.GPUArraysCore]]
deps = ["Adapt"]
git-tree-sha1 = "ec632f177c0d990e64d955ccc1b8c04c485a0950"
uuid = "46192b85-c4d5-4398-a991-12ede77f4527"
version = "0.1.6"
edit in Manifest.toml at line 348

[5.18102]→[5.18102:18123](∅→∅),[5.18123]→[5.6911:7134](∅→∅),[5.7134]→[5.18287:18333](∅→∅),[5.18287]→[5.18287:18333](∅→∅),[5.18333]→[5.7135:7154](∅→∅),[5.7154]→[5.18352:18353](∅→∅),[5.18352]→[5.18352:18353](∅→∅)

[[deps.GPUCompiler]]
deps = ["ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "PrecompileTools", "Preferences", "Scratch", "Serialization", "TOML", "TimerOutputs", "UUIDs"]
git-tree-sha1 = "1d6f290a5eb1201cd63574fbc4440c788d5cb38f"
uuid = "61eb1bfa-7361-4325-ad38-22787b887f55"
version = "0.27.8"
edit in Manifest.toml at line 377

[5.19499]→[5.19499:19516](∅→∅),[5.19516]→[5.7395:7496](∅→∅),[5.5637]→[5.19625:19671](∅→∅),[5.7496]→[5.19625:19671](∅→∅),[5.19625]→[5.19625:19671](∅→∅),[5.19671]→[5.7497:7516](∅→∅),[5.5657]→[5.19830:19831](∅→∅),[5.7516]→[5.19830:19831](∅→∅),[5.19830]→[5.19830:19831](∅→∅)

[[deps.IRTools]]
deps = ["InteractiveUtils", "MacroTools"]
git-tree-sha1 = "950c3717af761bc3ff906c2e8e52bd83390b6ec2"
uuid = "7869d1d1-7146-5819-86e3-90919afe41df"
version = "0.4.14"
edit in Manifest.toml at line 489

[5.25371]→[5.25371:25517](∅→∅),[5.25517]→[5.10267717:10267718](∅→∅),[5.10267717]→[5.10267717:10267718](∅→∅)

[[deps.InitialValues]]
git-tree-sha1 = "4da0f88e9a39111c2fa3add390ab15f3a44f3ca3"
uuid = "22cec73e-a1b8-11e9-2c92-598750a2cf9c"
version = "0.3.1"
edit in Manifest.toml at line 535

[5.26708]→[5.7435:7461](∅→∅),[5.7461]→[5.8302:8361](∅→∅),[5.8361]→[5.7536:7582](∅→∅),[5.7536]→[5.7536:7582](∅→∅),[5.7582]→[5.8362:8526](∅→∅),[5.8526]→[5.7601:7602](∅→∅),[5.7601]→[5.7601:7602](∅→∅)

[[deps.InverseFunctions]]
git-tree-sha1 = "a779299d77cd080bf77b97535acecd73e1c5e5cb"
uuid = "3587e190-3f89-42d0-90ee-14403ec27112"
version = "0.1.17"
weakdeps = ["Dates", "Test"]

[deps.InverseFunctions.extensions]
InverseFunctionsDatesExt = "Dates"
InverseFunctionsTestExt = "Test"
edit in Manifest.toml at line 596

[5.3297]→[5.10269054:10269055](∅→∅),[5.9249]→[5.10269054:10269055](∅→∅),[5.27548]→[5.10269054:10269055](∅→∅),[5.10269054]→[5.10269054:10269055](∅→∅),[5.10269055]→[5.27549:27943](∅→∅),[5.27943]→[5.10269273:10269274](∅→∅),[5.10269273]→[5.10269273:10269274](∅→∅),[5.10269274]→[5.27944:27972](∅→∅),[5.27972]→[5.9250:9464](∅→∅),[5.1496]→[5.28219:28265](∅→∅),[5.3357]→[5.28219:28265](∅→∅),[5.7742]→[5.28219:28265](∅→∅),[5.9464]→[5.28219:28265](∅→∅),[5.28219]→[5.28219:28265](∅→∅),[5.28265]→[5.9465:9484](∅→∅)

[[deps.JuliaNVTXCallbacks_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "af433a10f3942e882d3c671aacb203e006a5808f"
uuid = "9c1d0b0a-7046-5b2e-a33f-ea22f176ac7e"
version = "0.2.1+0"

[[deps.JuliaVariables]]
deps = ["MLStyle", "NameResolution"]
git-tree-sha1 = "49fb3cb53362ddadb4415e9b73926d6b40709e70"
uuid = "b14d175d-62b4-44ba-8fb7-3064adc8c3ec"
version = "0.2.4"

[[deps.KernelAbstractions]]
deps = ["Adapt", "Atomix", "InteractiveUtils", "MacroTools", "PrecompileTools", "Requires", "StaticArrays", "UUIDs", "UnsafeAtomics", "UnsafeAtomicsLLVM"]
git-tree-sha1 = "e73a077abc7fe798fe940deabe30ef6c66bdde52"
uuid = "63c18a36-062a-441e-b654-da1e3ab1ce7c"
version = "0.9.29"
edit in Manifest.toml at line 597

[5.28285]→[5.28285:28355](∅→∅),[5.28355]→[5.9485:9561](∅→∅),[5.9561]→[5.28355:28451](∅→∅),[5.28355]→[5.28355:28451](∅→∅),[5.28451]→[5.9562:9679](∅→∅),[5.9679]→[5.28451:28452](∅→∅),[5.28451]→[5.28451:28452](∅→∅)

[deps.KernelAbstractions.extensions]
EnzymeExt = "EnzymeCore"
LinearAlgebraExt = "LinearAlgebra"
SparseArraysExt = "SparseArrays"

[deps.KernelAbstractions.weakdeps]
EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"
LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
edit in Manifest.toml at line 602

[5.9805]→[5.28647:28662](∅→∅),[5.28647]→[5.28647:28662](∅→∅),[5.28662]→[5.9806:9944](∅→∅),[5.3437]→[5.28812:28858](∅→∅),[5.7822]→[5.28812:28858](∅→∅),[5.9944]→[5.28812:28858](∅→∅),[5.28812]→[5.28812:28858](∅→∅),[5.28858]→[5.9945:9963](∅→∅),[5.3456]→[5.28876:28960](∅→∅),[5.7841]→[5.28876:28960](∅→∅),[5.9963]→[5.28876:28960](∅→∅),[5.28876]→[5.28876:28960](∅→∅),[5.28960]→[5.10269463:10269464](∅→∅),[5.10269463]→[5.10269463:10269464](∅→∅),[5.10269464]→[5.28961:29054](∅→∅),[5.29054]→[5.9964:10023](∅→∅),[5.3516]→[5.29113:29159](∅→∅),[5.7901]→[5.29113:29159](∅→∅),[5.10023]→[5.29113:29159](∅→∅),[5.29113]→[5.29113:29159](∅→∅),[5.29159]→[5.10024:10045](∅→∅),[5.3538]→[5.29180:29326](∅→∅),[5.7923]→[5.29180:29326](∅→∅),[5.10045]→[5.29180:29326](∅→∅),[5.29180]→[5.29180:29326](∅→∅)

[[deps.LLVM]]
deps = ["CEnum", "LLVMExtra_jll", "Libdl", "Preferences", "Printf", "Unicode"]
git-tree-sha1 = "d422dfd9707bec6617335dc2ea3c5172a87d5908"
uuid = "929cbde3-209d-540e-8aea-75f648917ca0"
version = "9.1.3"
weakdeps = ["BFloat16s"]

[deps.LLVM.extensions]
BFloat16sExt = "BFloat16s"

[[deps.LLVMExtra_jll]]
deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl", "TOML"]
git-tree-sha1 = "05a8bd5a42309a9ec82f700876903abce1017dd3"
uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab"
version = "0.0.34+0"

[[deps.LLVMLoopInfo]]
git-tree-sha1 = "2e5c102cfc41f48ae4740c7eca7743cc7e7b75ea"
uuid = "8b046642-f1f6-4319-8d3c-209ddc03c586"
version = "1.0.0"
edit in Manifest.toml at line 696

[5.10707]→[5.31081:31082](∅→∅),[5.31081]→[5.31081:31082](∅→∅),[5.31082]→[5.4036:4232](∅→∅),[5.4232]→[5.10708:11643](∅→∅)

[[deps.MLBase]]
deps = ["IterTools", "Random", "Reexport", "StatsBase"]
git-tree-sha1 = "ac79beff4257e6e80004d5aee25ffeee79d91263"
uuid = "f0e99cf1-93fa-52ec-9ecc-5026115318e0"
version = "0.9.2"

[[deps.MLDataDevices]]
deps = ["Adapt", "Compat", "Functors", "Preferences", "Random"]
git-tree-sha1 = "d0666f5a9294484110e2bfc12e07cff5a434488d"
uuid = "7e8f7934-dd98-4c1a-8fe8-92b47a384d40"
version = "1.5.0"

[deps.MLDataDevices.extensions]
MLDataDevicesAMDGPUExt = "AMDGPU"
MLDataDevicesCUDAExt = "CUDA"
MLDataDevicesChainRulesCoreExt = "ChainRulesCore"
MLDataDevicesFillArraysExt = "FillArrays"
MLDataDevicesGPUArraysExt = "GPUArrays"
MLDataDevicesMLUtilsExt = "MLUtils"
MLDataDevicesMetalExt = ["GPUArrays", "Metal"]
MLDataDevicesReactantExt = "Reactant"
MLDataDevicesRecursiveArrayToolsExt = "RecursiveArrayTools"
MLDataDevicesReverseDiffExt = "ReverseDiff"
MLDataDevicesSparseArraysExt = "SparseArrays"
MLDataDevicesTrackerExt = "Tracker"
MLDataDevicesZygoteExt = "Zygote"
MLDataDevicescuDNNExt = ["CUDA", "cuDNN"]
MLDataDevicesoneAPIExt = ["GPUArrays", "oneAPI"]
edit in Manifest.toml at line 697

[5.11644]→[5.11644:12498](∅→∅),[5.4232]→[5.31082:31539](∅→∅),[5.12498]→[5.31082:31539](∅→∅),[5.31082]→[5.31082:31539](∅→∅),[5.31539]→[5.10272056:10272057](∅→∅),[5.10272056]→[5.10272056:10272057](∅→∅)

[deps.MLDataDevices.weakdeps]
AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e"
CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4"
FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
GPUArrays = "0c68f7d7-f131-5f86-a1c3-88cf8149b2d7"
MLUtils = "f1d291b0-491e-4a28-83b9-f70985020b54"
Metal = "dde4c033-4e86-420c-a63e-0dd931031962"
Reactant = "3c362404-f566-11ee-1572-e11a4b42c853"
RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd"
ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267"
SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c"
Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd"
oneAPI = "8f75cd03-7ff8-4ecb-9b8f-daf728133b1b"

[[deps.MLStyle]]
git-tree-sha1 = "bc38dff0548128765760c79eb7388a4b37fae2c8"
uuid = "d8e11817-5142-5d16-987a-aa16d5891078"
version = "0.4.17"

[[deps.MLUtils]]
deps = ["ChainRulesCore", "Compat", "DataAPI", "DelimitedFiles", "FLoops", "NNlib", "Random", "ShowCases", "SimpleTraits", "Statistics", "StatsBase", "Tables", "Transducers"]
git-tree-sha1 = "b45738c2e3d0d402dffa32b2c1654759a2ac35a4"
uuid = "f1d291b0-491e-4a28-83b9-f70985020b54"
version = "0.4.4"
edit in Manifest.toml at line 728

[5.32264]→[5.32264:32440](∅→∅),[5.32440]→[5.12499:12558](∅→∅),[5.8063]→[5.32499:32545](∅→∅),[5.12558]→[5.32499:32545](∅→∅),[5.32499]→[5.32499:32545](∅→∅),[5.32545]→[5.12559:12577](∅→∅),[5.8082]→[5.32563:32673](∅→∅),[5.12577]→[5.32563:32673](∅→∅),[5.32563]→[5.32563:32673](∅→∅),[5.32673]→[5.12578:12687](∅→∅),[5.12687]→[5.32781:32827](∅→∅),[5.32781]→[5.32781:32827](∅→∅),[5.32827]→[5.12688:12706](∅→∅)

[[deps.Metalhead]]
deps = ["Artifacts", "BSON", "ChainRulesCore", "Flux", "Functors", "JLD2", "LazyArtifacts", "MLUtils", "NNlib", "PartialFunctions", "Random", "Statistics"]
git-tree-sha1 = "aef476e4958303f5ea9e1deb81a1ba2f510d4e11"
uuid = "dbeba491-748d-5e0e-a39e-b530a07fa0cc"
version = "0.9.4"
weakdeps = ["CUDA"]

[deps.Metalhead.extensions]
MetalheadCUDAExt = "CUDA"

[[deps.MicroCollections]]
deps = ["Accessors", "BangBang", "InitialValues"]
git-tree-sha1 = "44d32db644e84c75dab479f1bc15ee76a1a3618f"
uuid = "128add7d-3638-4c79-886c-908ea0c25c34"
version = "0.2.0"
edit in Manifest.toml at line 753

[5.10273140]→[5.33061:33077](∅→∅),[5.33077]→[5.12865:13049](∅→∅),[5.4292]→[5.33280:33326](∅→∅),[5.8142]→[5.33280:33326](∅→∅),[5.13049]→[5.33280:33326](∅→∅),[5.33280]→[5.33280:33326](∅→∅),[5.33326]→[5.13050:13069](∅→∅),[5.4312]→[5.33345:33510](∅→∅),[5.8162]→[5.33345:33510](∅→∅),[5.13069]→[5.33345:33510](∅→∅),[5.33345]→[5.33345:33510](∅→∅),[5.33510]→[5.13070:13136](∅→∅),[5.13136]→[5.33510:33695](∅→∅),[5.33510]→[5.33510:33695](∅→∅),[5.33695]→[5.13137:13244](∅→∅),[5.13244]→[5.33695:34145](∅→∅),[5.33695]→[5.33695:34145](∅→∅)

[[deps.NNlib]]
deps = ["Adapt", "Atomix", "ChainRulesCore", "GPUArraysCore", "KernelAbstractions", "LinearAlgebra", "Random", "Statistics"]
git-tree-sha1 = "da09a1e112fd75f9af2a5229323f01b56ec96a4c"
uuid = "872c559c-99b0-510c-b3b7-b6c96a88d5cd"
version = "0.9.24"

[deps.NNlib.extensions]
NNlibAMDGPUExt = "AMDGPU"
NNlibCUDACUDNNExt = ["CUDA", "cuDNN"]
NNlibCUDAExt = "CUDA"
NNlibEnzymeCoreExt = "EnzymeCore"
NNlibFFTWExt = "FFTW"
NNlibForwardDiffExt = "ForwardDiff"

[deps.NNlib.weakdeps]
AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e"
CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba"
EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869"
FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
cuDNN = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd"

[[deps.NVTX]]
deps = ["Colors", "JuliaNVTXCallbacks_jll", "Libdl", "NVTX_jll"]
git-tree-sha1 = "53046f0483375e3ed78e49190f1154fa0a4083a1"
uuid = "5da4648a-3479-48b8-97b9-01cb529c0a1f"
version = "0.3.4"

[[deps.NVTX_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"]
git-tree-sha1 = "ce3269ed42816bf18d500c9f63418d4b0d9f5a3b"
uuid = "e98f9f5b-d649-5603-91fd-7774390e6439"
version = "3.1.0+2"
edit in Manifest.toml at line 759

[5.34310]→[5.34310:34481](∅→∅)

[[deps.NameResolution]]
deps = ["PrettyPrint"]
git-tree-sha1 = "1a0fa0e9613f46c9b8c11eee38ebb4f590013c5e"
uuid = "71a1bf82-56d0-4bbc-8a3c-48b961074391"
version = "0.1.5"
edit in Manifest.toml at line 776

[5.10273230]→[5.35153:35340](∅→∅)

[[deps.Noise]]
deps = ["ImageCore", "PoissonRandom", "Random"]
git-tree-sha1 = "d34a07459e1ebdc6b551ecb28e3c19993f544d91"
uuid = "81d43f40-5267-43b7-ae1c-8b967f377efa"
version = "0.3.3"
edit in Manifest.toml at line 780

[5.13404]→[5.35486:35507](∅→∅),[5.35486]→[5.35486:35507](∅→∅)

weakdeps = ["Adapt"]
edit in Manifest.toml at line 783

[5.35578]

[5.10273384]

[deps.OffsetArrays.weakdeps]
Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
edit in Manifest.toml at line 793

[5.35774]→[5.35774:35884](∅→∅),[5.35884]→[5.8163:8222](∅→∅),[5.8222]→[5.35943:35989](∅→∅),[5.35943]→[5.35943:35989](∅→∅),[5.35989]→[5.8223:8241](∅→∅),[5.8241]→[5.10273527:10273528](∅→∅),[5.36007]→[5.10273527:10273528](∅→∅),[5.10273527]→[5.10273527:10273528](∅→∅)

[[deps.OneHotArrays]]
deps = ["Adapt", "ChainRulesCore", "Compat", "GPUArraysCore", "LinearAlgebra", "NNlib"]
git-tree-sha1 = "963a3f28a2e65bb87a68033ea4a616002406037d"
uuid = "0b1bfda6-eb8a-41d2-88d8-f5af5cad476f"
version = "0.2.5"
edit in Manifest.toml at line 839

[5.36411]→[5.36411:36510](∅→∅),[5.36510]→[5.13807:13866](∅→∅),[5.8383]→[5.36569:36615](∅→∅),[5.13866]→[5.36569:36615](∅→∅),[5.36569]→[5.36569:36615](∅→∅),[5.36615]→[5.13867:13885](∅→∅),[5.8402]→[5.10274444:10274445](∅→∅),[5.13885]→[5.10274444:10274445](∅→∅),[5.36633]→[5.10274444:10274445](∅→∅),[5.10274444]→[5.10274444:10274445](∅→∅)

[[deps.Optimisers]]
deps = ["ChainRulesCore", "Functors", "LinearAlgebra", "Random", "Statistics"]
git-tree-sha1 = "c9ff5c686240c31eb8570b662dd1f66f4b183116"
uuid = "3bd65402-5787-11e9-1adc-39752487f4e2"
version = "0.3.4"
edit in Manifest.toml at line 868

[5.37377]→[5.37377:37548](∅→∅),[5.37548]→[5.10274782:10274783](∅→∅),[5.10274782]→[5.10274782:10274783](∅→∅)

[[deps.PartialFunctions]]
deps = ["MacroTools"]
git-tree-sha1 = "47b49a4dbc23b76682205c646252c0f9e1eb75af"
uuid = "570af359-4316-4cb7-8c74-252c00c2016b"
version = "1.2.0"
edit in Manifest.toml at line 884

[5.37708]→[5.37708:37873](∅→∅)

[[deps.PoissonRandom]]
deps = ["Random"]
git-tree-sha1 = "a0f1159c33f846aa77c3f30ebbc69795e5327152"
uuid = "e409e4f3-bfea-5376-8464-e040bb5c01ab"
version = "0.4.4"
edit in Manifest.toml at line 920

[5.1674]→[5.10276256:10276257](∅→∅),[5.4631]→[5.10276256:10276257](∅→∅),[5.10276256]→[5.10276256:10276257](∅→∅),[5.10276257]→[5.38243:38387](∅→∅)

[[deps.PrettyPrint]]
git-tree-sha1 = "632eb4abab3449ab30c5e1afaa874f0b98b586e4"
uuid = "8162dcfd-2161-5ef2-ae6c-7681170c5f98"
version = "0.2.0"
edit in Manifest.toml at line 931

[5.10276586]→[5.38588:38772](∅→∅)

[[deps.ProgressLogging]]
deps = ["Logging", "SHA", "UUIDs"]
git-tree-sha1 = "80d919dee55b9c50e8d9e2da5eeafff3fe58b539"
uuid = "33c8b6b6-d38a-422a-b730-caa89a2f386c"
version = "0.1.4"
edit in Manifest.toml at line 968

[5.10276978]→[5.39333:39388](∅→∅),[5.39388]→[5.4632:4691](∅→∅),[5.4691]→[5.39447:39493](∅→∅),[5.39447]→[5.39447:39493](∅→∅),[5.39493]→[5.4692:4710](∅→∅)

[[deps.Random123]]
deps = ["Random", "RandomNumbers"]
git-tree-sha1 = "4743b43e5a9c4a2ede372de7061eed81795b12e7"
uuid = "74087812-796a-5b5d-8853-05524746bad3"
version = "1.7.0"
edit in Manifest.toml at line 969

[5.39512]→[5.39512:39535](∅→∅),[5.39535]→[5.14443:14520](∅→∅),[5.14520]→[5.39624:39670](∅→∅),[5.39624]→[5.39624:39670](∅→∅),[5.39670]→[5.14521:14539](∅→∅),[5.14539]→[5.39688:39689](∅→∅),[5.39688]→[5.39688:39689](∅→∅)

[[deps.RandomNumbers]]
deps = ["Random"]
git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902"
uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143"
version = "1.6.0"
edit in Manifest.toml at line 1000

[5.10277292]→[5.40276:40441](∅→∅)

[[deps.Referenceables]]
deps = ["Adapt"]
git-tree-sha1 = "02d31ad62838181c1a3a5fd23a1ce5914a643601"
uuid = "42d2dcc6-99eb-4e98-b66c-637b7d73030e"
version = "0.1.3"
edit in Manifest.toml at line 1057

[5.41320]→[5.41320:41463](∅→∅)

[[deps.ShowCases]]
git-tree-sha1 = "7f534ad62ab2bd48591bdeac81994ea8c445e4a5"
uuid = "605ecd9f-84a6-4c9e-81e2-4798472b76a3"
version = "0.1.0"
edit in Manifest.toml at line 1094

[5.10278707]→[5.42186:42395](∅→∅)

[[deps.SparseInverseSubset]]
deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"]
git-tree-sha1 = "52962839426b75b3021296f7df242e40ecfc0852"
uuid = "dc90abb0-5640-4711-901d-7e5b23a2fada"
version = "0.1.2"
edit in Manifest.toml at line 1104

[5.10279039]→[5.10279039:10279040](∅→∅),[5.10279040]→[5.42427:42604](∅→∅)

[[deps.SplittablesBase]]
deps = ["Setfield", "Test"]
git-tree-sha1 = "e08a62abc517eb79667d0a29dc08a3b589516bb5"
uuid = "171d559e-b47b-412a-8079-5efa626c420e"
version = "0.1.15"
edit in Manifest.toml at line 1150

[5.10279594]→[5.44302:44324](∅→∅),[5.44324]→[5.4790:4898](∅→∅),[5.4898]→[5.44478:44524](∅→∅),[5.9759]→[5.44478:44524](∅→∅),[5.44478]→[5.44478:44524](∅→∅),[5.44524]→[5.4899:5208](∅→∅),[5.5208]→[5.15339:15340](∅→∅)

[[deps.StructArrays]]
deps = ["ConstructionBase", "DataAPI", "Tables"]
git-tree-sha1 = "f4dc295e983502292c4c3f951dbb4e985e35b3be"
uuid = "09ab397b-f2b6-538f-b94a-2f83cf4a842a"
version = "0.6.18"
weakdeps = ["Adapt", "GPUArraysCore", "SparseArrays", "StaticArrays"]

[deps.StructArrays.extensions]
StructArraysAdaptExt = "Adapt"
StructArraysGPUArraysCoreExt = "GPUArraysCore"
StructArraysSparseArraysExt = "SparseArrays"
StructArraysStaticArraysExt = "StaticArrays"
edit in Manifest.toml at line 1156

[5.44544]→[5.44544:44678](∅→∅),[5.44678]→[5.10279765:10279766](∅→∅),[5.10279765]→[5.10279765:10279766](∅→∅)

[[deps.SuiteSparse]]
deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"]
uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9"
edit in Manifest.toml at line 1205

[5.10281309]→[5.45082:45100](∅→∅),[5.45100]→[5.9865:10078](∅→∅),[5.10078]→[5.45312:45358](∅→∅),[5.45312]→[5.45312:45358](∅→∅),[5.45358]→[5.10079:10098](∅→∅),[5.10098]→[5.45377:45378](∅→∅),[5.45377]→[5.45377:45378](∅→∅)

[[deps.ThreadsX]]
deps = ["Accessors", "ArgCheck", "BangBang", "ConstructionBase", "InitialValues", "MicroCollections", "Referenceables", "SplittablesBase", "Transducers"]
git-tree-sha1 = "70bd8244f4834d46c3d68bd09e7792d8f571ef04"
uuid = "ac1d9e8a-700a-412c-b207-f0111f4b6c0d"
version = "0.1.12"
edit in Manifest.toml at line 1226

[5.10281946]→[5.45905:45959](∅→∅),[5.45959]→[5.16256:16315](∅→∅),[5.16315]→[5.46018:46064](∅→∅),[5.46018]→[5.46018:46064](∅→∅),[5.46064]→[5.16316:16335](∅→∅)

[[deps.TimerOutputs]]
deps = ["ExprTools", "Printf"]
git-tree-sha1 = "3a6f063d690135f5c1ba351412c82bae4d1402bf"
uuid = "a759f4b9-e2f1-59dc-863e-4aeb61b1ea8f"
version = "0.5.25"
edit in Manifest.toml at line 1231

[5.16415]→[5.10282129:10282130](∅→∅),[5.10282129]→[5.10282129:10282130](∅→∅),[5.46085]→[5.46085:46106](∅→∅),[5.46106]→[5.16416:16707](∅→∅),[5.16707]→[5.46405:46451](∅→∅),[5.46405]→[5.46405:46451](∅→∅),[5.46451]→[5.16708:16727](∅→∅)

[[deps.Transducers]]
deps = ["Accessors", "ArgCheck", "BangBang", "Baselet", "CompositionsBase", "ConstructionBase", "DefineSingletons", "Distributed", "InitialValues", "Logging", "Markdown", "MicroCollections", "Requires", "SplittablesBase", "Tables"]
git-tree-sha1 = "7deeab4ff96b85c5f72c824cae53a1398da3d1cb"
uuid = "28d57a85-8fef-5791-bfe6-a80928e7c999"
version = "0.4.84"
edit in Manifest.toml at line 1232

[5.10282205]→[5.46471:46505](∅→∅),[5.46505]→[5.16728:16762](∅→∅),[5.16762]→[5.46505:46778](∅→∅),[5.46505]→[5.46505:46778](∅→∅),[5.46778]→[5.16763:16814](∅→∅),[5.16814]→[5.46778:47068](∅→∅),[5.46778]→[5.46778:47068](∅→∅),[5.47068]→[5.10282366:10282367](∅→∅),[5.10282366]→[5.10282366:10282367](∅→∅)

[deps.Transducers.extensions]
TransducersAdaptExt = "Adapt"
TransducersBlockArraysExt = "BlockArrays"
TransducersDataFramesExt = "DataFrames"
TransducersLazyArraysExt = "LazyArrays"
TransducersOnlineStatsBaseExt = "OnlineStatsBase"
TransducersReferenceablesExt = "Referenceables"

[deps.Transducers.weakdeps]
Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e"
BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02"
OnlineStatsBase = "925886fa-5bf2-5e8e-b522-a9147a512338"
Referenceables = "42d2dcc6-99eb-4e98-b66c-637b7d73030e"
edit in Manifest.toml at line 1254

[5.16894]→[5.2230:2282](∅→∅),[5.2230]→[5.2230:2282](∅→∅)

weakdeps = ["ConstructionBase", "InverseFunctions"]
replacement in Manifest.toml at line 1259

[5.2418]→[5.47210:47356](∅→∅),[5.10282656]→[5.47210:47356](∅→∅)

[[deps.UnsafeAtomics]]
git-tree-sha1 = "6331ac3440856ea1988316b46045303bef658278"
uuid = "013be700-e6cd-48c3-b4a1-df204f14c38f"
version = "0.2.1"

[5.2418]

[5.10283046]

[deps.Unitful.weakdeps]
ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9"
InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112"
edit in Manifest.toml at line 1263

[5.10283047]→[5.47357:47417](∅→∅),[5.47417]→[5.16895:16954](∅→∅),[5.16954]→[5.47476:47522](∅→∅),[5.47476]→[5.47476:47522](∅→∅),[5.47522]→[5.16955:16973](∅→∅),[5.16973]→[5.47540:47541](∅→∅),[5.47540]→[5.47540:47541](∅→∅)

[[deps.UnsafeAtomicsLLVM]]
deps = ["LLVM", "UnsafeAtomics"]
git-tree-sha1 = "2d17fabcd17e67d7625ce9c531fb9f40b7c42ce4"
uuid = "d80eeb9a-aca5-4d75-85e5-170c8b632249"
version = "0.2.1"
edit in Manifest.toml at line 1319

[5.17217]→[5.48832:49190](∅→∅),[5.48832]→[5.48832:49190](∅→∅),[5.49190]→[5.17218:17277](∅→∅),[5.10568]→[5.49249:49295](∅→∅),[5.17277]→[5.49249:49295](∅→∅),[5.49249]→[5.49249:49295](∅→∅),[5.49295]→[5.17278:17297](∅→∅),[5.10588]→[5.49314:49633](∅→∅),[5.17297]→[5.49314:49633](∅→∅),[5.49314]→[5.49314:49633](∅→∅),[5.49633]→[5.10284202:10284203](∅→∅),[5.10284202]→[5.10284202:10284203](∅→∅),[5.10284203]→[5.49634:49695](∅→∅),[5.49695]→[5.10589:10648](∅→∅),[5.10648]→[5.49754:49800](∅→∅),[5.49754]→[5.49754:49800](∅→∅),[5.49800]→[5.10649:10667](∅→∅)

[[deps.Zygote]]
deps = ["AbstractFFTs", "ChainRules", "ChainRulesCore", "DiffRules", "Distributed", "FillArrays", "ForwardDiff", "GPUArrays", "GPUArraysCore", "IRTools", "InteractiveUtils", "LinearAlgebra", "LogExpFunctions", "MacroTools", "NaNMath", "PrecompileTools", "Random", "Requires", "SparseArrays", "SpecialFunctions", "Statistics", "ZygoteRules"]
git-tree-sha1 = "f816633be6dc5c0ed9ffedda157ecfda0b3b6a69"
uuid = "e88e6eb3-aa80-5325-afca-941959d7151f"
version = "0.6.72"

[deps.Zygote.extensions]
ZygoteColorsExt = "Colors"
ZygoteDistancesExt = "Distances"
ZygoteTrackerExt = "Tracker"

[deps.Zygote.weakdeps]
Colors = "5ae59095-9a9b-59fe-a467-6f913c188581"
Distances = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7"
Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c"

[[deps.ZygoteRules]]
deps = ["ChainRulesCore", "MacroTools"]
git-tree-sha1 = "27798139afc0a2afa7b1824c206d5e87ea587a00"
uuid = "700de1a5-db45-46bc-99cf-38207098b444"
version = "0.2.5"
edit in Manifest.toml at line 1320

[5.49819]→[5.49819:49898](∅→∅),[5.49898]→[5.17298:17357](∅→∅),[5.10727]→[5.49957:50003](∅→∅),[5.17357]→[5.49957:50003](∅→∅),[5.49957]→[5.49957:50003](∅→∅),[5.50003]→[5.17358:17569](∅→∅),[5.10746]→[5.50021:50022](∅→∅),[5.17569]→[5.50021:50022](∅→∅),[5.50021]→[5.50021:50022](∅→∅)

[[deps.cuDNN]]
deps = ["CEnum", "CUDA", "CUDA_Runtime_Discovery", "CUDNN_jll"]
git-tree-sha1 = "4b3ac62501ca73263eaa0d034c772f13c647fba6"
uuid = "02a925ec-e4fe-4b08-9a7e-0d78e3d38ccd"
version = "1.4.0"

[[deps.demumble_jll]]
deps = ["Artifacts", "JLLWrappers", "Libdl"]
git-tree-sha1 = "6498e3581023f8e530f34760d18f75a69e3a4ea8"
uuid = "1e29f10c-031c-5a83-9565-69cddfc27673"
version = "1.3.0+0"