Add log_audio, TBAudio, tests, examples

Project.toml

@@ -21,6 +21,7 @@ Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c"
 ImageMagick = "6218d12a-5da1-5696-b52f-db25d2ecc6d1"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 TestImages = "5e47fb64-e119-507b-a336-dd2b206d9990"
+WAV = "8149f6b0-98f6-5db9-b78f-408fbbb8ef88"
 
 [targets]
-test = ["Test", "Flux", "TestImages", "ImageMagick"]
+test = ["Test", "Flux", "TestImages", "ImageMagick", "WAV"]

examples/Audios.jl

@@ -0,0 +1,27 @@
+using TensorBoardLogger #import the TensorBoardLogger package
+using Logging #import Logging package
+
+logger = TBLogger("audiologs", tb_append) #create tensorboard logger
+
+################log audio example: cos wave ################
+samplerate = 44100
+x = collect(1:samplerate*2)
+x = cos.(440*pi*x/samplerate)
+#using logger interface
+with_logger(logger) do
+    @info "cos/loggerinterface" x = TBAudio(x, samplerate)
+end
+#using explicit function interface
+log_audio(logger, "cos/explicitinterface", x, samplerate, step = 0)
+
+
+################log scalar example: sin+cos wave################
+y = collect(1:samplerate*2)
+y = sin.(440*pi*y/samplerate)
+z = x+y
+#using logger interface
+with_logger(logger) do
+    @info "sin+cos/loggerinterface" z = TBAudio(z, samplerate)
+end
+#using explicit function interface
+log_audio(logger, "sin+cos/explicitinterface", z, samplerate, step = 0)

examples/Texts.jl

@@ -0,0 +1,29 @@
+using TensorBoardLogger #import the TensorBoardLogger package
+using Logging #import Logging package
+
+logger = TBLogger("textlogs", tb_append) #create tensorboard logger
+
+################log scalars example: String################
+#using logger interface
+with_logger(logger) do
+    @info "string/loggerinterface" str = "A computer once beat me at chess, but it was no match for me at kick boxing. *— Emo Philips*"
+end
+#using explicit function interface
+str =
+"
+All parts should go together without forcing.
+You must remember that the parts you are reassembling were disassembled by you.
+Therefore, if you can’t get them together again, there must be a reason.
+By all means, do not use a hammer.”
+*— IBM Manual, 1925*
+"
+log_text(logger, "string/explicitinterface", str, step = 0)
+
+
+################log scalar example: y = matrix################
+squares =
+[["Number" "Square"];
+[1 1]; [2 4]; [3 9]; [4 16]; [5 25]; [6 36]; [7 49]; [8 64]; [9 81]; [10 100]]
+
+#using explicit function interface
+log_text(logger, "table", squares, step = 0)

src/Loggers/LogAudio.jl

@@ -0,0 +1,35 @@
+"""
+    log_audios(logger::TBLogger, name::AbstractString, samples::AbstractArray, samplerate::Real, step)
+
+Logs multiple audio clips at step `step`
+- samples:
+    Array of audio clips which are Arrays of samples N*C where N = number of samples and C = number of channel
+- samplerate: Sampling rate or Sampling frequency: a Real value same for all clips
+"""
+function log_audios(logger::TBLogger, name::AbstractString, samplesArray::AbstractArray, samplerate::Real; step=nothing)
+    for (n, sample) in enumerate(samplesArray)
+        log_audio(logger, name*"/$n", sample, samplerate, step = step)
+    end
+end
+"""
+    log_audio(logger::TBLogger, name::AbstractString, samples::AbstractArray, samplerate::Real, step)
+
+Logs an audio clip with name `name` at step `step`
+- samples: Array of samples N*C where N = number of samples and C = number of channels
+- samplerate: Sampling rate or Sampling frequency: a Real value
+"""
+function log_audio(logger::TBLogger, name::AbstractString, samples::AbstractArray, samplerate::Real; step=nothing)
+    summ = SummaryCollection(audio_summary(name, samples, samplerate))
+    write_event(logger.file, make_event(logger, summ, step=step))
+end
+
+function audio_summary(name::AbstractString, samples::AbstractArray, samplerate::Real)
+    @assert ndims(samples) <= 2
+    samples = samples./max(maximum(samples), 1)
+    samples = Int16.(floor.(samples.*32767))
+    io = IOBuffer()
+    save(Stream(format"WAV", io), samples)
+    eas = io.data
+    audio = Summary_Audio(sample_rate = samplerate, num_channels = ndims(samples), length_frames = size(samples, 1), encoded_audio_string = eas, content_type = "audio/wav")
+    Summary_Value(tag=name, audio=audio)
+end

src/Loggers/LogImage.jl

@@ -78,8 +78,7 @@ function log_image(logger::TBLogger, name::AbstractString, imgArray::AbstractArr
     @assert dims == expected_ndims(format)
     obsdim = obs_dim(format)
     if iszero(obsdim)
-        summ = SummaryCollection()
-        push!(summ.value, image_summary(name, imgArray, format))
+        summ = SummaryCollection(image_summary(name, imgArray, format))
         write_event(logger.file, make_event(logger, summ, step=step))
     else
         format = strip_obs[format]

src/Loggers/LogText.jl

@@ -25,6 +25,9 @@ function text_summary(name::String, text::Any)
     #content of the tensor
     textstringval = Vector{Array{UInt8, 1}}()
     if isa(text, AbstractArray)
+        if ndims(text) == 2
+            text = permutedims(text, (2, 1))
+        end
         for string in text
             string = markdown_repr(string)
             push!(textstringval, Array{UInt8, 1}(string))

src/TensorBoardLogger.jl

@@ -11,13 +11,13 @@ import Base.CoreLogging:
     AbstractLogger, handle_message, shouldlog, min_enabled_level,
 	catch_exceptions
 
-export log_histogram, log_value, log_vector, log_text, log_image, log_images
+export log_histogram, log_value, log_vector, log_text, log_image, log_images, log_audio, log_audios
 export scalar_summary, histogram_summary, text_summary, make_event
 export TBLogger
 export reset!, set_step!, increment_step!
 export ImageFormat, L, CL, LC, LN, NL, NCL, NLC, CLN, LCN, HW, WH, HWC, WHC, CHW, CWH,HWN, WHN, NHW, NWH, HWCN, WHCN, CHWN, CWHN, NHWC, NWHC, NCHW, NCWH
 # Wrapper types
-export TBText, TBVector, TBHistogram, TBImage, TBImages
+export TBText, TBVector, TBHistogram, TBImage, TBImages, TBAudio, TBAudios
 
 # Protobuffer definitions for tensorboard
 include("protojl/tensorflow.jl")
@@ -42,6 +42,7 @@ include("Loggers/LogValue.jl")
 include("Loggers/LogText.jl")
 include("Loggers/LogHistograms.jl")
 include("Loggers/LogImage.jl")
+include("Loggers/LogAudio.jl")
 
 include("logger_dispatch.jl")
 include("logger_dispatch_overrides.jl")

src/logger_dispatch_overrides.jl

@@ -24,11 +24,41 @@ preprocess(name, val::WrapperLogType, data) = push!(data, name=>val)
 Base.show(io::IO, mime::AbstractString, x::WrapperLogType) =
     Base.show(io, mime, content(x))
 
+########## For things going to LogAudio ##############################
+"""
+    TBAudios(data, samplerate)
+
+Forces elements of Array `data` to be serialized as Audio to TensorBoard.
+"""
+struct TBAudios <:WrapperLogType
+    data::AbstractArray
+    samplerate::Real
+end
+content(x::TBAudios) = x.data
+function preprocess(name, val::TBAudios, data)
+    for (n, audio) in enumerate(val.data)
+        preprocess(name*"/$n", TBAudio(audio, val.samplerate), data)
+    end
+end
+
+"""
+    TBAudio(data, samplerate)
+
+Forces `data` to be serialized as Audio to TensorBoard.
+"""
+struct TBAudio <: WrapperLogType
+    data::AbstractArray
+    samplerate::Real
+end
+content(x::TBAudio) = x.data
+preprocess(name, val::TBAudio, data) = push!(data, name=>val)
+summary_impl(name, val::TBAudio) = audio_summary(name, val.data, val.samplerate)
+
 ########## For things going to LogImage ########################
 """
-    TBImage(data, format)
+    TBImages(data, format)
 
-Forces `data` to be serialized as an Image to TensorBoard.
+Forces elements of Array `data` to be serialized as an Image to TensorBoard.
 """
 struct TBImages <:WrapperLogType
     data::AbstractArray
@@ -41,6 +71,11 @@ function preprocess(name, val::TBImages, data)
     end
 end
 
+"""
+    TBImage(data, format)
+
+Forces `data` to be serialized as an Image to TensorBoard.
+"""
 struct TBImage <: WrapperLogType
     data::AbstractArray
     format::ImageFormat
@@ -54,7 +89,7 @@ function preprocess(name, val::TBImage, data)
     @assert dims == expected_ndims(format)
     obsdim = obs_dim(format)
     if iszero(obsdim)
-        push!(data, name=>TBImage(imgArray, format))
+        push!(data, name=>val)
     else
         format = strip_obs[format]
         index = collect("[:"* ",:"^(dims-1) *"]")

test/runtests.jl

@@ -5,6 +5,7 @@ using Flux.Data.MNIST
 using TestImages
 using ImageCore
 using ColorTypes
+using FileIO
 
 
 @testset "TBLogger" begin
@@ -201,6 +202,21 @@ end
     @test TensorBoardLogger.step(logger) == 200
 end
 
+@testset "Audio Logger" begin
+    logger = TBLogger("test_logs/t", tb_overwrite)
+    step = 1
+
+    ss = TensorBoardLogger.audio_summary("test", rand(800), 800)
+    @test isa(ss, TensorBoardLogger.Summary_Value)
+    @test ss.tag == "test"
+
+    clip = (cos.(440*pi*collect(1:100)/44100), 44100)
+    fs = clip[2]
+    sample = clip[1]
+    samples = [sample, sample, sample]
+    log_audios(logger, "audiosample", samples, fs, step = step)
+end
+
 @testset "Logger dispatch overrides" begin
     include("test_logger_dispatch_overrides.jl")
 end

test/test_logger_dispatch_overrides.jl

@@ -45,8 +45,19 @@ end
     (rand(5, 4, 3, 2), WHCN), (rand(4, 5, 3, 2), HWCN), (rand(2, 3, 4, 5), NCHW), (rand(2, 3, 5, 4), NCWH),
     (rand(3, 5, 4, 2), CWHN), (rand(3, 4, 5, 2), CHWN), (rand(2, 4, 5, 3), NHWC), (rand(2, 5, 4, 3), NWHC),
     ]
+    preprocess("randTBImages", TBImages([rand(3, 3), rand(3,3)], HW), data)
     for testtuple in testdata
         preprocess("randTBImage/$(last(testtuple))", TBImage(first(testtuple), last(testtuple)), data)
     end
-    @test size(data, 1) == 45
+    @test size(data, 1) == 47
+end
+
+@testset "TBAudio" begin
+    data = Vector{Pair{String,Any}}()
+    sample_rate = 44100
+    x = collect(1:sample_rate*2)
+    y = cos.(440*pi*x/sample_rate)
+    preprocess("test", TBAudios([y, y], sample_rate), data)
+    @test first(data) == ("test/1"=>TBAudio(y, sample_rate))
+    @test last(data) == ("test/2"=>TBAudio(y, sample_rate))
 end