general upgrades and more testing, wip

Author: dehann

Project.toml

@@ -8,6 +8,7 @@ version = "0.16.0"
 ApproxManifoldProducts = "9bbbb610-88a1-53cd-9763-118ce10c1f89"
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
 Combinatorics = "861a8166-3701-5b0c-9a16-15d98fcdc6aa"
+DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
 DelimitedFiles = "8bb1440f-4735-579b-a4ab-409b98df4dab"
 Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"
@@ -40,6 +41,7 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 [compat]
 ApproxManifoldProducts = "0.1, 0.2"
 Combinatorics = "1.0"
+DataStructures = "0.16, 0.17, 0.18"
 DistributedFactorGraphs = "0.10.6"
 Distributions = "0.20, 0.21, 0.22, 0.23, 0.24"
 DocStringExtensions = "0.8, 0.9, 0.10, 1"

src/ApproxConv.jl

@@ -11,8 +11,9 @@ Future work:
 - improve handling of n and particleidx, especially considering future multithreading support
 
 """
-function approxConvOnElements!( ccwl::CommonConvWrapper{T},
-                                elements::Union{Vector{Int}, UnitRange{Int}}, ::Type{MultiThreaded}  ) where {T <: AbstractRelative}
+function approxConvOnElements!( ccwl::Union{CommonConvWrapper{F},
+                                            CommonConvWrapper{Mixture{N_,F,S,T}}},
+                                elements::Union{Vector{Int}, UnitRange{Int}}, ::Type{MultiThreaded}  ) where {N_,F<:AbstractRelative,S,T}
   #
   Threads.@threads for n in elements
     # ccwl.thrid_ = Threads.threadid()
@@ -36,7 +37,8 @@ Future work:
 - improve handling of n and particleidx, especially considering future multithreading support
 
 """
-function approxConvOnElements!( ccwl::Union{CommonConvWrapper{F},CommonConvWrapper{Mixture{N_,F,S,T}}},
+function approxConvOnElements!( ccwl::Union{CommonConvWrapper{F},
+                                            CommonConvWrapper{Mixture{N_,F,S,T}}},
                                 elements::Union{Vector{Int}, UnitRange{Int}}, ::Type{SingleThreaded}) where {N_,F<:AbstractRelative,S,T}
   #
   for n in elements
@@ -60,7 +62,8 @@ Future work:
 - improve handling of n and particleidx, especially considering future multithreading support
 
 """
-function approxConvOnElements!( ccwl::Union{CommonConvWrapper{F},CommonConvWrapper{Mixture{N_,F,S,T}}}, #CommonConvWrapper{T},
+function approxConvOnElements!( ccwl::Union{CommonConvWrapper{F},
+                                            CommonConvWrapper{Mixture{N_,F,S,T}}},
                                 elements::Union{Vector{Int}, UnitRange{Int}} )  where {N_,F<:AbstractRelative,S,T}
   #
   approxConvOnElements!(ccwl, elements, ccwl.threadmodel)
@@ -114,7 +117,8 @@ function prepareCommonConvWrapper!( F_::Type{<:AbstractRelative},
 end
 
 
-function prepareCommonConvWrapper!( ccwl::Union{CommonConvWrapper{F},CommonConvWrapper{Mixture{N_,F,S,T}}},
+function prepareCommonConvWrapper!( ccwl::Union{CommonConvWrapper{F},
+                                                CommonConvWrapper{Mixture{N_,F,S,T}}},
                                     Xi::Vector{DFGVariable},
                                     solvefor::Symbol,
                                     N::Int;
@@ -204,7 +208,8 @@ end
 
 Common function to compute across a single user defined multi-hypothesis ambiguity per factor.  This function dispatches both `AbstractRelativeFactor` and `AbstractRelativeFactorMinimize` factors.
 """
-function computeAcrossHypothesis!(ccwl::Union{CommonConvWrapper{F},CommonConvWrapper{Mixture{N_,F,S,T}}},
+function computeAcrossHypothesis!(ccwl::Union{CommonConvWrapper{F},
+                                              CommonConvWrapper{Mixture{N_,F,S,T}}},
                                   allelements,
                                   activehypo,
                                   certainidx::Vector{Int},

src/Factors/Mixture.jl

@@ -22,27 +22,41 @@ end
 Mixture(f::Type{F},
         z::NamedTuple{S,T}, 
         c::Distributions.DiscreteNonParametric ) where {F<:FunctorInferenceType, S, T} = Mixture{length(z),F,S,T}(f(LinearAlgebra.I), z, c, size( rand(z[1],1), 1), zeros(Int, 0))
-#
 Mixture(f::F,
         z::NamedTuple{S,T}, 
         c::Distributions.DiscreteNonParametric ) where {F<:FunctorInferenceType, S, T} = Mixture{length(z),F,S,T}(f, z, c, size( rand(z[1],1), 1), zeros(Int, 0))
-#
-Mixture(f::Union{F,Type{F}},z::NamedTuple{S,T}, c::AbstractVector{<:Real}) where {F<:FunctorInferenceType,S,T} = Mixture(f, z, Categorical([c...]) )
-Mixture(f::Union{F,Type{F}},z::NamedTuple{S,T}, c::NTuple{N,<:Real}) where {N,F<:FunctorInferenceType,S,T} = Mixture(f, z, [c...] )
-Mixture(f::Union{F,Type{F}},z::AbstractVector{<:SamplableBelief}, c::Union{<:Distributions.DiscreteNonParametric, <:AbstractVector{<:Real}, <:NTuple{N,<:Real}} ) where {F <: FunctorInferenceType, N} = Mixture(f,NamedTuple{_defaultNamesMixtures(length(z))}((z...,)), c)
-Mixture(f::Union{F,Type{F}},z::Tuple, c::Union{<:Distributions.DiscreteNonParametric, <:AbstractVector{<:Real}, <:NTuple{N,<:Real}} ) where {F<:FunctorInferenceType, N} = Mixture(f,NamedTuple{_defaultNamesMixtures(length(z))}(z), c)
+Mixture(f::Union{F,Type{F}},z::NamedTuple{S,T}, 
+        c::AbstractVector{<:Real}) where {F<:FunctorInferenceType,S,T} = Mixture(f, z, Categorical([c...]) )
+Mixture(f::Union{F,Type{F}},
+        z::NamedTuple{S,T}, 
+        c::NTuple{N,<:Real}) where {N,F<:FunctorInferenceType,S,T} = Mixture(f, z, [c...] )
+Mixture(f::Union{F,Type{F}},
+        z::Tuple, 
+        c::Union{<:Distributions.DiscreteNonParametric, <:AbstractVector{<:Real}, <:NTuple{N,<:Real}} ) where {F<:FunctorInferenceType, N} = Mixture(f,NamedTuple{_defaultNamesMixtures(length(z))}(z), c )
+Mixture(f::Union{F,Type{F}},
+        z::AbstractVector{<:SamplableBelief}, 
+        c::Union{<:Distributions.DiscreteNonParametric, <:AbstractVector{<:Real}, <:NTuple{N,<:Real}} ) where {F <: FunctorInferenceType, N} = Mixture(f,(z...,), c )
 
 
 function Base.resize!(mp::Mixture, s::Int)
   resize!(mp.labels, s)
 end
 
 # TODO make in-place memory version
-function getSample(s::Mixture, N::Int=1)
+function getSample( s::Mixture{N_,F,S,T}, 
+                    N::Int=1,
+                    special...;
+                    kw...  ) where {N_,F<:FunctorInferenceType,S,T}
+  #
+  # TODO consolidate #927, case if mechanics has a special sampler
+  # TODO slight bit of waste in computation, but easiest way to ensure special tricks in s.mechanics::F are included
+  ## example case is old FluxModelsPose2Pose2 requiring velocity
+  smplLambda = hasfield(typeof(s.mechanics), :specialSampler) ? ()->s.specialSampler(s.mechanics, N, special...; kw...)[1] : ()->getSample(s.mechanics, N)[1]
+  smpls = smplLambda()
+    # smpls = Array{Float64,2}(undef,s.dims,N)
   #out memory should be right size first
   (length(s.labels) != N) && resize!(s, N)
   s.labels .= rand(s.diversity, N)
-  smpls = Array{Float64,2}(undef,s.dims,N)
   for i in 1:N
     mixComponent = s.components[s.labels[i]]
     smpls[:,i] = rand(mixComponent,1)

src/Factors/Sphere1D.jl

@@ -40,14 +40,18 @@ PriorSphere1( MvNormal([10; 10; pi/6.0], Matrix(Diagonal([0.1;0.1;0.05].^2))) )
 """
 mutable struct PriorSphere1{T<: SamplableBelief} <: AbstractPrior
     Z::T
-    PriorSphere1{T}() where T = new{T}()
-    PriorSphere1{T}(x::T) where {T <: IncrementalInference.SamplableBelief}  = new{T}(x)
+    # PriorSphere1{T}() where T = new{T}()
+    # PriorSphere1{T}(x::T) where {T <: IncrementalInference.SamplableBelief}  = new{T}(x)
 end
-PriorSphere1(x::T) where {T <: IncrementalInference.SamplableBelief} = PriorSphere1{T}(x)
+
+
+# PriorSphere1(x::T) where {T <: IncrementalInference.SamplableBelief} = PriorSphere1{T}(x)
+PriorSphere1(::UniformScaling) = PriorSphere1(Normal())
 function PriorSphere1(mu::Array{Float64}, cov::Array{Float64,2}, W::Vector{Float64})
   @warn "PriorSphere1(mu,cov,W) is deprecated in favor of PriorSphere1(T(...)) -- use for example PriorSphere1(MvNormal(mu, cov))"
   PriorSphere1(MvNormal(mu[:], cov))
 end
+
 function getSample(p2::PriorSphere1, N::Int=1)
   return (reshape(rand(p2.Z,N),:,N), )
 end

src/Flux/FluxModelsDistribution.jl

@@ -3,21 +3,21 @@
 @info "IncrementalInference is adding Flux related functionality."
 
 
-
 # the factor definitions
 export FluxModelsDistribution
-# some utilities
+export MixtureFluxModels
 
 
 # Required packages
 using .Flux
-
+using DataStructures: OrderedDict
 using Random, Statistics
-# using DistributedFactorGraphs
+
 
 # import Base: convert
 import Random: rand
 
+const _IIFListTypes = Union{<:AbstractVector, <:Tuple, <:NTuple, <:NamedTuple}
 
 
 function rand(nfb::FluxModelsDistribution,
@@ -55,6 +55,83 @@ FluxModelsDistribution( inDim::NTuple{ID,Int},
                         serializeHollow::Bool=false ) where {ID,OD,P,D<:AbstractArray} = FluxModelsDistribution{ID,OD,P,D}(inDim, outDim, models, data, Ref(shuffle), Ref(serializeHollow) )
 #
 
+# @deprecate 
+
+
+
+
+
+
+"""
+    $SIGNATURES
+
+Helper function to construct `MixtureFluxModels` containing a `NamedTuple`, resulting in a 
+`::Mixture` such that `(fluxnn=FluxNNModels, c1=>MvNormal, c2=>Uniform...)` and order sensitive 
+`diversity=[0.7;0.2;0.1]`.  The result is the mixture heavily favors `.fluxnn` and names 
+`c1` and `c2` for two other components were auto generated.
+
+Notes
+- The user can specify own component names if desired (see example).
+- `shuffle` is passed through to internal `FluxModelsDistribution` to command shuffling of NN models.
+  - `shuffle` does not influence selection of components in the mixture.
+
+Example:
+
+```julia
+# some made up data
+data = randn(10)
+# Flux models
+models = [Flux.Chain(softmax, Dense(10,5,σ), Dense(5,1, tanh)) for i in 1:20]
+# mixture with user defined names (optional) -- could also just pass Vector or Tuple of components
+mix = MixtureFluxModels(PriorSphere1, models, (10,), data, (1,), 
+                        (naiveNorm=Normal(),naiveUnif=Uniform()),
+                        [0.7; 0.2; 0.1],
+                        shuffle=false )
+#
+
+# test by add to simple graph
+fg = initfg()
+addVariable!(fg, :testmix, Sphere1)
+addFactor!(fg, [:testmix;], mix)
+
+# look at proposal distribution from the only factor on :testmix
+_,pts,__, = localProduct(fg, :testmix)
+```
+
+Related
+
+Mixture, FluxModelsDistribution
+"""
+function MixtureFluxModels( F_::FunctorInferenceType,
+                            nnModels::Vector{P}, 
+                            inDim::NTuple{ID,Int}, 
+                            data::D,
+                            outDim::NTuple{OD,Int},
+                            otherComp::_IIFListTypes,
+                            diversity::Union{<:AbstractVector, <:NTuple, <:DiscreteNonParametric}; 
+                            shuffle::Bool=true,
+                            serializeHollow::Bool=false ) where {P,ID,D,OD}
+  #
+  # must preserve order
+  allComp = OrderedDict{Symbol, Any}()
+  
+  # always add the Flux model first
+  allComp[:fluxnn] = FluxModelsDistribution(inDim,outDim,nnModels,data,shuffle,serializeHollow)
+  isNT = otherComp isa NamedTuple
+  for idx in 1:length(otherComp)
+    nm = isNT ? keys(otherComp)[idx] : Symbol("c$(idx+1)")
+    allComp[nm] = otherComp[idx]
+  end
+  # convert to named tuple
+  ntup = (;allComp...)
+  
+  # construct all the internal objects
+  return Mixture(F_, ntup, diversity)
+end
+
+MixtureFluxModels(::Type{F}, w...;kw...) where F <: FunctorInferenceType = MixtureFluxModels(F(LinearAlgebra.I), w...;kw...)
+
+
 
 
 

src/SerializingDistributions.jl

@@ -1,4 +1,28 @@
 
+
+export PackedUniform
+
+
+mutable struct PackedUniform <: PackedSamplableBelief
+  a::Float64
+  b::Float64
+  PackedSamplableTypeJSON::String
+end
+
+function convert(::Union{Type{<:PackedSamplableBelief},Type{<:PackedUniform}},
+                  obj::Distributions.Uniform)
+  #
+  packed = PackedUniform(obj.a, obj.b, 
+                        "Distributions.PackedUniform")
+  #
+  return JSON2.write(packed)
+end
+
+
+convert(::Type{<:SamplableBelief}, obj::PackedUniform) = return Uniform(obj.a, obj.b)
+
+
+
 # TODO stop-gap string storage of Distrubtion types, should be upgraded to more efficient storage
 function normalfromstring(str::AbstractString)
   meanstr = match(r"μ=[+-]?([0-9]*[.])?[0-9]+", str).match

test/testFluxModelsDistribution.jl

@@ -138,4 +138,46 @@ end
 
 
 
+@testset "MixtureFluxModels testing" begin
+
+# some made up data
+data = randn(10)
+# Flux models
+models = [Flux.Chain(softmax, Dense(10,5,σ), Dense(5,1, tanh)) for i in 1:20]
+# mixture with user defined names (optional) -- could also just pass Vector or Tuple of components
+mix = MixtureFluxModels(PriorSphere1, models, (10,), data, (1,), 
+                        (naiveNorm=Normal(),naiveUnif=Uniform()),
+                        [0.7; 0.2; 0.1],
+                        shuffle=false )
+#
+
+# test by add to simple graph
+fg = initfg()
+addVariable!(fg, :testmix, Sphere1)
+addFactor!(fg, [:testmix;], mix)
+
+
+pts = approxConv(fg, :testmixf1, :testmix);
+
+# look at proposal distribution from the only factor on :testmix
+_,pts,__, = localProduct(fg, :testmix);
+
+saveDFG("/tmp/fg_mfx", fg)
+
+# 
+fg_ = loadDFG("/tmp/fg_mfx")
+
+
+Base.rm("/tmp/fg_mfx.tar.gz")
+
+solveTree!(fg_);
+
+@test 10 < getBelief(fg_, :testmix) |> getPoints |> length
+
+end
+
+
+
+
+
 #

test/testgraphpackingconverters.jl

@@ -6,6 +6,21 @@ using DistributedFactorGraphs
 using Test
 
 
+@testset "Serialization of SamplableBelief types" begin
+
+td = Uniform()
+
+ptd = convert(PackedSamplableBelief, td)
+utd = convert(SamplableBelief, td)
+
+@test td.a - utd.a |> abs < 1e-10
+@test td.b - utd.b |> abs < 1e-10
+
+
+end
+
+
+
 dfg = initfg()
 
 @testset "hard-coded test of PackedPrior to Prior" begin