Merge branch 'manikyabard/tableblock' into manikyabard/tabularmethods

Author: manikyabard

src/FastAI.jl

@@ -1,6 +1,8 @@
 module FastAI
 
 
+using Base: NamedTuple
+using Colors: colormaps_sequential
 using Reexport
 @reexport using DLPipelines
 @reexport using FluxTraining
@@ -47,6 +49,7 @@ include("datablock/checks.jl")
 include("datablock/wrappers.jl")
 
 # Encodings
+include("encodings/tabularpreprocessing.jl")
 include("encodings/onehot.jl")
 include("encodings/imagepreprocessing.jl")
 include("encodings/projective.jl")
@@ -120,6 +123,8 @@ export
     Label,
     LabelMulti,
     Keypoints,
+    TableRow,
+    Continuous,
 
     # encodings
     encode,
@@ -131,6 +136,7 @@ export
     Only,
     Named,
     augs_projection, augs_lighting,
+    TabularTransform,
 
     BlockMethod,
     describemethod,

src/datablock/block.jl

@@ -155,3 +155,30 @@ function checkblock(
 end
 
 mockblock(block::Keypoints{N}) where N = rand(SVector{N, Float32}, block.sz)
+
+
+# TableRow
+
+struct TableRow{M, N} <: Block
+    catcols
+    contcols
+    categorydict
+end
+
+function TableRow(catcols, contcols, categorydict)
+    TableRow{length(catcols), length(contcols)}(catcols, contcols, categorydict)
+end
+
+function checkblock(block::TableRow, x)
+    (all(col -> x[col] ∈ block.categorydict[col], block.catcols) &&
+    all(col -> x[col] isa Number, block.contcols) &&
+    all(col -> haskey(block.categorydict, col), block.catcols))
+end
+
+struct Continuous <: Block
+    n
+end
+
+function checkblock(block::Continuous, x)
+    block.n == length(x)
+end

src/datablock/loss.jl

@@ -42,3 +42,8 @@ function blocklossfn(outblock::KeypointTensor{N}, yblock::KeypointTensor{N}) whe
     outblock.sz == yblock.sz || error("Sizes of $outblock and $yblock differ!")
     return Flux.Losses.mse
 end
+
+function blocklossfn(outblock::Continuous, yblock::Continuous)
+    outblock.n == yblock.n || error("Sizes of $outblock and $yblock differ!")
+    return Flux.Losses.mse
+end

src/datablock/method.jl

@@ -10,7 +10,7 @@ struct BlockMethod{B, E, O} <: LearningMethod
     outputblock::O
 end
 
-function BlockMethod(blocks, encodings; outputblock = encodedblock(encodings, blocks[2]))
+function BlockMethod(blocks, encodings; outputblock = isnothing(encodedblock(encodings, blocks[2])) ? blocks[2] : encodedblock(encodings, blocks[2]))
     return BlockMethod(blocks, encodings, outputblock)
 end
 
@@ -47,12 +47,12 @@ end
 
 function methodmodel(method::BlockMethod, backbone)
     xblock = encodedblock(method.encodings, method.blocks[1])
-    return blockmodel(xblock, method.outputblock, backbone)
+    return blockmodel(isnothing(xblock) ? method.blocks[1] : xblock, method.outputblock, backbone)
 end
 
 function methodlossfn(method::BlockMethod)
     yblock = encodedblock(method.encodings, method.blocks[2])
-    return blocklossfn(method.outputblock, yblock)
+    return blocklossfn(method.outputblock, isnothing(yblock) ? method.blocks[2] : yblock)
 end
 
 # Testing interface

src/datablock/models.jl

@@ -59,3 +59,27 @@ function blockmodel(inblock::ImageTensor{N}, outblock::KeypointTensor{N}, backbo
     head = Models.visionhead(outch, prod(outblock.sz)*N, p = 0.)
     return Chain(backbone, head)
 end
+
+"""
+    blockmodel(inblock::TableRow{M, N}, outblock::Union{Continuous, OneHotTensor{0}}, backbone=nothing) where {M, N}
+
+Contruct a model for tabular classification or regression. `backbone` should 
+either be `nothing` or a tuple of categoricalbackbone, continuousbackbone, 
+and a classifierbackbone, with the first two taking in batches of corresponding 
+row value matrices.
+"""
+
+# function blockmodel(
+#         inblock::EncodedTableRow{M, N}, 
+#         outblock::Union{Continuous, OneHotTensor{0}}, 
+#         backbone=nothing;) where {M, N}
+#     outsz = outblock isa Continuous ? outblock.n : length(outblock.classes)
+#     if isnothing(backbone)
+#         TabularModel(inblock.catcols, N, outsz; catdict = inblock.categorydict)
+#     else
+#         TabularModel(backbone[1], backbone[2], backbone[3])
+#     end
+# end
+
+
+

src/encodings/onehot.jl

@@ -24,6 +24,7 @@ function checkblock(block::OneHotTensorMulti{N}, a::AbstractArray{T, M}) where {
     return N + 1 == M && last(size(a)) == length(block.classes)
 end
 
+
 """
     OneHot()
     OneHot(T, threshold)

src/encodings/tabularpreprocessing.jl

@@ -0,0 +1,36 @@
+struct EncodedTableRow{M, N} <: Block
+    catcols
+    contcols
+    categorydict
+end
+
+function EncodedTableRow(catcols, contcols, categorydict)
+    EncodedTableRow{length(catcols), length(contcols)}(catcols, contcols, categorydict)
+end
+
+function checkblock(::EncodedTableRow{M, N}, x) where {M, N}
+    length(x[1]) == M && length(x[2]) == N
+end
+
+struct TabularTransform <: Encoding
+	tfms
+end
+
+function encodedblock(::TabularTransform, block::TableRow)
+    EncodedTableRow(block.catcols, block.contcols, block.categorydict)
+end
+
+function encode(tt::TabularTransform, _, block::TableRow, row)
+    columns = Tables.columnnames(row)
+    usedrow = NamedTuple(filter(
+            x -> x[1] ∈ block.catcols || x[1] ∈ block.contcols, 
+            collect(zip(columns, row))
+        ))
+    tfmrow = DataAugmentation.apply(
+        tt.tfms, 
+        DataAugmentation.TabularItem(usedrow, keys(usedrow))
+    ).data
+    catvals = map(col -> tfmrow[col], block.catcols)
+    contvals = map(col -> tfmrow[col], block.contcols)
+    (catvals, contvals)
+end