lanl-ansi / graphicalmodellearning.jl Goto Github PK

Is Gibbs the correct name for the samplers that we have implemented? They look more like brute force enumeration to me.

For now we assume discrete models. (something) indicates that something is optional, everything else is required.

A Julia data-structure that can be serialized to JSON as follows,

{
"order":<int>,
"variable_count":<int>,
"alphabet":[<int>,<int>,...,<int>],
"symmetric":<bool>,
("variable_names":[<string>,<string>,...,<string>],)
"terms":[
  {"weight":<float>, "variables":[<int>, <int>,...,<int>]},
  ...
]
}

All values in alphabet should be unique. For now we will require the alphabet to be [-1, 1].

The arrays variable_names must be the same length that is specified by variable_count. The length of variables should be less than or equal to the value of order.

if symmetric is true, then the values in variables should be increasing. All non-increasing orders can be added to the increasing one. Similarly, multiple references to the same variable can be collapsed into lower order terms.

Inside of Julia, it would be nice if the weights could be accessed using a multidimensional array syntax (gm[1,2,4,8]).

v0.1.0
@JuliaRegistrator register()

Use the value of gibbs_test_samples to correctly set the settings of isapprox on inverse ising formulations regression test.

In testings can correctness thresholds be set programmatically based on the number of samples?

I think this does the right thing. One question is when generalizing to higher dimensions, are (1,1,2) and (1,2,1) symmetric? Also maybe the logic of the asymmetric flag is revered...

permutations(items, order::Int; asymmetric::Bool = false) = sort(permutations([], items, order, asymmetric))

function permutations(partical_perm::Array{Any,1}, items, order::Int, asymmetric::Bool)
    if order == 0
        return [tuple(partical_perm...)]
    else
        perms = []
        for item in items
            if !asymmetric && length(partical_perm) > 0 
                if partical_perm[end] < item
                    continue
                end
            end
            perm = permutations(vcat([item], partical_perm), items, order-1, asymmetric)
            append!(perms, perm)
        end
        return perms
    end
end

At this line,
https://github.com/lanl-ansi/GraphicalModelLearning.jl/blob/master/src/GraphicalModelLearning.jl#L230

I am getting this error message,

Currently must provide 2nd order derivatives of univariate functions. Try setting autodiff=true.

@marc-vuffray has a proposal to eliminate common subexpressions to make the derivative computations much fasters.

Ensure that Factor Graph are symeterized always, use DiHypergraph for the current asymetetic data structure.

For now we assume discrete models. (something) indicates that something is optional, everything else is required.

A Julia data-structure that can be serialized to JSON as follows,

{
"variable_count":<int>,
"alphabet":[<int>,<int>,...,<int>],
("variable_names":[<string>,<string>,...,<string>],)
"samples":[
  {"count":<int>, "assignment":[<int>, <int>,...,<int>], ("value":<float>)},
  ...
]
}

All values in alphabet should be unique. For now we will require the alphabet to be [-1, 1].

The arrays variable_names, alphabet and assignment must all be the same length that is specified by variable_count. All values in assignment should be members of the alphabet.

value can be used to store an evaluation of the given assignment (e.g. the energy in a d-wave sample).

Figure out a clean way to make regularizers parametric, for example
regularizer*sqrt(log((num_spins^2)/0.05)/num_samples).

Consider adding a generic GMLFormulation, which includes functions that plug into the bigger JuMP model. Then RISE, logRISE, RPLE would be specific instances of this generic formulation.

by default should these be presented as symmetric or upper triangular?

Instead of having symmetrization in the formulation flag, all learning methods can return a DiHypergraph then calling a symmetrize function could turn them into FactorGraph. Consistent return types helps the compiler optimize the code.

How should we deal with float vs int data types?

The branch multi-interactions now contains the method multiRISE() that reconstruct binary models with arbitrary interactions. The ouptut is a dictionary of reconstructed interactions from each node perspective e.g. (1,2,3), (2,1,3), (3,1,2) are the reconstruction of the 3 body interaction between 1,2,3 from the perspective of node 1, 2 and 3 respectively.

The option for symmetrizing the output is still not implemented.

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!