Adding TIMIT phonetic alignments.

src/SpeechDatasets.jl

@@ -10,6 +10,7 @@ export
     # ManifestItem
     Recording,
     Supervision,
+    Alignment,
     load,
 
     # Manifest interface

src/corpora/timit.jl

@@ -250,6 +250,14 @@ function timit_prepare(timitdir, dir; audio_fmt="SPHERE")
         open(manifestpath, "w") do f
             writemanifest(f, supervisions)
         end
+
+        # Alignments
+        manifestpath = joinpath(dir, "alignments-$(subset).jsonl")
+        @debug "Preparing $manifestpath"
+        alignments = timit_alignments(sdir)
+        open(manifestpath, "w") do f
+            writemanifest(f, alignments)
+        end
     end
 end
 
@@ -310,7 +318,7 @@ function timit_supervisions(dir)
                      "text" => join(words, " "),
                      "dialect" => dialect,
                      "speaker" => spk,
-                     "sex" => string(first(spk))
+                     "sex" => string(first(spk)),
                 )
             )
         end
@@ -319,11 +327,60 @@ function timit_supervisions(dir)
 end
 
 
+function timit_alignments(dir)
+    
+	! isdir(dir) && throw(ArgumentError("expected directory $dir"))
+    splitline(line) = rsplit(line, limit=3)
+	
+    alignments = Dict()
+		
+    for (root, subdirs, files) in walkdir(dir)
+		for file in files
+			            
+			name, ext = splitext(file)
+            ext != ".phn" && continue
+			
+            _, dialect, spk = rsplit(root, "/", limit=3)
+            path = joinpath(root, file)
+			id = "timit_$(spk)_$(name)"
+
+            slines = map(splitline, eachline(path))
+            starts, ends, phones = zip(slines...)
+            
+			start_sample = parse(Int, first(starts))
+			end_sample = parse(Int, last(ends))
+            dur = end_sample - start_sample
+            
+            palign = [(parse(Int, s), parse(Int, e), TIMIT_PHONE_MAP48[p]) for (s, e, p) in zip(starts, ends, phones)]
+            
+            @show palign
+
+			alignments[id] = Alignment(
+                id, 
+				id, 
+				start_sample, 
+				dur,
+				Dict(
+                     "phones" => palign,
+                     "dialect" => dialect,
+                     "speaker" => spk,
+                     "sex" => string(first(spk))
+                )
+            )
+        end
+    end
+    alignments
+end
+
+
 function TIMIT(timitdir, dir, subset)
     if ! (isfile(joinpath(dir, "recordings.jsonl")) &&
           isfile(joinpath(dir, "supervisions-train.jsonl")) &&
           isfile(joinpath(dir, "supervisions-dev.jsonl")) &&
-          isfile(joinpath(dir, "supervisions-test.jsonl")))
+          isfile(joinpath(dir, "supervisions-test.jsonl")) &&
+          isfile(joinpath(dir, "alignments-train.jsonl")) &&
+          isfile(joinpath(dir, "alignments-dev.jsonl")) &&
+          isfile(joinpath(dir, "alignments-test.jsonl")))
         timit_prepare(timitdir, dir)
     end
     dataset(dir, subset)

src/dataset.jl

@@ -3,6 +3,7 @@
 struct SpeechDataset <: MLUtils.AbstractDataContainer
     idxs::Vector{AbstractString}
     supervisions::Dict{AbstractString, Supervision}
+    alignments::Dict{AbstractString, Alignment}
     recordings::Dict{AbstractString, Recording}
     partition::Symbol
 end
@@ -34,15 +35,17 @@ julia> ds[1]
 """
 function dataset(manifestroot, partition)
     sup_path = joinpath(manifestroot, "supervisions-$(partition).jsonl")
+    alg_path = joinpath(manifestroot, "alignments-$(partition).jsonl")
     rec_path = joinpath(manifestroot, "recordings.jsonl")
     supervisions = load(Supervision, sup_path)
+    alignments = load(Alignment, alg_path)
     recordings = load(Recording, rec_path)
-    dataset(supervisions, recordings, partition)
+    dataset(supervisions, alignments, recordings, partition)
 end
 
-function dataset(supervisions, recordings, partition)
+function dataset(supervisions, alignments, recordings, partition)
     idxs = collect(keys(supervisions))
-    SpeechDataset(idxs, supervisions, recordings, Symbol(partition))
+    SpeechDataset(idxs, supervisions, alignments, recordings, Symbol(partition))
 end
 
 function Base.getindex(d::SpeechDataset, key::AbstractString)

src/manifest_io.jl

@@ -105,6 +105,14 @@ Supervision(d::Dict) = Supervision(
     d["data"]
 )
 
+Alignment(d::Dict) = Alignment(
+    d["id"],
+    d["recording_id"],
+    d["start"],
+    d["duration"],
+    d["data"]
+)
+
 #=====================================================================#
 # Writing / reading manifest from file.
 
@@ -127,12 +135,14 @@ end
 # Some utilities
 manifestname(::Type{<:Recording}, name) = "recordings.jsonl"
 manifestname(::Type{<:Supervision}, name) = "supervisions-$name.jsonl"
+manifestname(::Type{<:Alignment}, name) = "alignments-$name.jsonl"
 
 """
     load(Supervision, path)
+    load(Alignments, path)
     load(Recording, path)
 
-Load Recording/Supervision manifest from `path`.
+Load Recording/Supervisions/Alignments manifest from `path`.
 """
-load(T::Type{<:Union{Recording,Supervision}}, path) = open(f -> readmanifest(f, T), path, "r")
+load(T::Type{<:Union{Recording, Supervision, Alignment}}, path) = open(f -> readmanifest(f, T), path, "r")
 

src/manifest_item.jl

@@ -81,6 +81,40 @@ end
 Supervision(id, recid; channels = missing, start = -1, duration = -1, data = missing) =
     Supervision(id, recid, start, duration, channels, data)
 
+"""
+    struct Alignments <: ManifestItem
+        id::AbstractString
+        recording_id::AbstractString
+        start::Float64
+        duration::Float64
+        data::Dict
+    end
+
+An "alignment" defines a segment of a recording on a single channel.
+The `data` field is an arbitrary dictionary holdin the nature of the
+alignments. `start` and `duration` (in seconds) defines,
+where the segment is locatated within the recoding `recording_id`.
+
+# Constructor
+
+    Alignment(id, recording_id, start, duration, data)
+    Alignment(id, recording_id[;start = -1, duration = -1, data = missing)
+
+If `start` and/or `duration` are negative, the segment is considered to
+be the whole sequence length of the recording.
+"""
+struct Alignment <: ManifestItem
+    id::AbstractString
+    recording_id::AbstractString
+    start::Float64
+    duration::Float64
+    data::Dict
+end
+
+Alignment(id, recid; start = -1, duration = -1, data = missing) =
+    Alignment(id, recid, start, duration, data)
+
+
 """
     load(recording[; start = -1, duration = -1, channels = recording.channels])
     load(recording, supervision)