Trouble running agent-based model using UnaryOpLambda

[ld-archer]

I am trying to integrate keanu with an agent-based model that uses the MASON toolkit, but having trouble with building the UnaryOpLambda to run the model and the arguments it needs.

The current state of my model (state) can be represented by a vector of all the agents' x and y locations and their max speed ([x0,y0,s0,x1,y1,s1,...,]). We represent this as a ConstantDoubleVertex[].

The UnaryOpLambda should take the current state and call a predict function, which itself takes a state and returns a new state after iterating the model. predict is defined like:

public static ConstantDoubleVertex[] predict(ConstantDoubleVertex[] state) {

  // take 'state' and run the model forward x iterations
  
  return state
}

Here is the problem:

UnaryOpLambda<ConstantDoubleVertex[], ConstantDoubleVertex[]> box =
  new UnaryOpLambda<ConstantDoubleVertex[], ConstantDoubleVertex[]>(
    new long[]{state.length}, state, StationTransition::predict);

Which returns the error:

Error:(153, 113) java: incompatible types: io.improbable.keanu.vertices.dbl.nonprobabilistic.ConstantDoubleVertex[] cannot be converted to io.improbable.keanu.vertices.Vertex<io.improbable.keanu.vertices.dbl.nonprobabilistic.ConstantDoubleVertex[]>

The problem as I understand it is that UnaryOpLambda accepts only a single vertex as its argument. How can I pass an array as the input to UnaryOpLambda? Or is there a better way of doing this?

[christophernorth]

Hey - thanks for raising this. Let me take a think about what you're trying to do and then I'll get back to you.

[gordoncaleb]

Hi @ld-archer

There's a few ways to do this depending on what you're trying to achieve. One way, similar to what you're doing above, is to make the predict be a single operation on an array of values. This approach is:

    public static Vertex<DoubleTensor[]> predict(int stepCount, Vertex<DoubleTensor[]> state) {

        // take 'state' and run the model forward x iterations

        UnaryOpLambda<DoubleTensor[], DoubleTensor[]> op = new UnaryOpLambda<>(
            new long[0],
            state,
            (currentState) -> step(stepCount, currentState)
        );

        return op;
    }

    private static DoubleTensor[] step(int stepCount, DoubleTensor[] initialState) {

        DoubleTensor[] steppedState = new DoubleTensor[initialState.length];

        for (int i = 0; i < stepCount; i++) {

            steppedState = initialState; //actually update the state here
        }

        return steppedState;
    }

The other way to approach this is to have the predict be an array of operations on an array of values:

    public static DoubleVertex[] predict(int stepCount, DoubleVertex[] currentState) {


        for (int i = 0; i < stepCount; i++) {
            DoubleVertex x1 = currentState[0];
            DoubleVertex x2 = currentState[1];

            currentState[0] = x1.plus(2);
            currentState[1] = x2.times(x1);

        }

        return currentState;
    }

If you're feeding the array of values into a single point of integration with MASON then you should probably go for the first approach. Meaning, the UnaryOpLambda would call out to MASON and return its result. Unfortunately, if you want to use Keanu's algorithms, you still need to define your inputs (e.g. x0, y0, etc) as DoubleVertex and then combine them all into a Vertex<DoubleTensor[]>. There's not really good support for this but it looks something like:

    public static class CombineDoubles extends Vertex<DoubleTensor[]> implements NonProbabilistic<DoubleTensor[]> {

        private DoubleVertex[] vertices;

        public CombineDoubles(DoubleVertex x0, DoubleVertex x1) {
            super(new long[0]);
            setParents(x0, x1);
            vertices = new DoubleVertex[]{x0, x1};
        }


        @Override
        public DoubleTensor[] sample(KeanuRandom random) {
            //ignore this
            return null;
        }

        @Override
        public DoubleTensor[] calculate() {
            DoubleTensor[] values = new DoubleTensor[vertices.length];

            for (int i = 0; i < values.length; i++) {
                values[i] = vertices[i].getValue();
            }

            return values;
        }
    }

and if you want to use the output values from your UnaryOp then you'll have to split them again like:

    public static Vertex<DoubleTensor> getAtElement(int element, Vertex<DoubleTensor[]> input) {

        return new UnaryOpLambda<>(
            new long[0],
            input,
            (currentState) -> currentState[element]
        );
    }

I hope this helps :)

[ld-archer]

Hi both

Thanks very much for the reply and the solution, sorry I've been so long in replying myself. We implemented the first solution (predict being single op on range of values) which gave us some output that looked correct, but now we're beginning to think that issues downstream are related to this method.

Would it be possible to talk to someone on slack? Particularly about the UnaryOpLambda object and the related step() function, I'm not completely clear on how they are working behind the scenes. I'm already on the Improbable-eng workspace on slack as Luke Archer, just unsure who to talk to.

Thanks again for the support.