Examples with Factor com.sri.ai.praise.core.representation.interfacebased.factor.api.Factor used on opensource projects

Example 46 with Factor

use of com.sri.ai.praise.core.representation.interfacebased.factor.api.Factor in project aic-praise by aic-sri-international.

the class TableFactor method sumOut.

/**
 * Sums out given variables from factor.
 *
 * @param variablesToSumOut (variables to sum out)
 * @return new factor with given variables summed out
 */
@Override
public Factor sumOut(List<? extends Variable> variablesToSumOutList) {
    // TODO: Error check for if variablesToSumOut is of type List<? extends TableVarable>
    // TODO: Error check for if a variable listed to SumOut exists in the factor
    LinkedHashSet<TableVariable> variablesToSumOut = new LinkedHashSet<>((List<TableVariable>) variablesToSumOutList);
    LinkedHashSet<TableVariable> variablesNotToSumOut = new LinkedHashSet<>();
    variablesNotToSumOut = (LinkedHashSet<TableVariable>) setDifference(this.variableSet, variablesToSumOut, variablesNotToSumOut);
    Factor result;
    // if every variable is summed out, return the sum of all the parameters in a constant factor
    if (variablesNotToSumOut.isEmpty()) {
        result = new ConstantFactor(sumOfParameters());
    } else {
        result = sumOutEverythingExcept(variablesNotToSumOut);
    }
    return result;
}

Example 47 with Factor

use of com.sri.ai.praise.core.representation.interfacebased.factor.api.Factor in project aic-praise by aic-sri-international.

the class TestCases method gridModelWithRandomFactors.

/**
 * An Ising model is a N dimensional lattice (like a N-dimensional grid), where each node interact with its nearest neighbors.
 * Each node can assume the values +1 or -1, and has an index "i" associated to its position. We usually represent the node
 * at position i by <math>\sigma_i</math>. The indexes are usually given so that sigma 0 is in teh center of the hyper-cube
 * <p>
 * If N = 2, the Ising model is simply a squared grid. Below we represent a 3X3 s dimension Ising model
 *  <p>
 *
 *  <table style="width:10%">
 * <tr>
 *      <th>sig2</th><th>--</th><th>sig3 </th><th>--</th><th>sig4</th>
 * </tr>
 * <tr>
 * 		<th>|</th><th>		   </th><th>|</th><th>	 	 </th><th>|</th>
 * </tr>
 * <tr>
 *   	<th>sig-1</th><th>--</th><th>sig0</th><th>--</th><th>sig1</th>
 * </tr>
 * <tr>
 *   	<th>|</th><th>		   </th><th>|</th><th>	 	 </th><th>|</th>
 * </tr>
 * <tr>
 * 	 	<th>sig-4</th><th>--</th><th>sig-3</th><th>--</th><th>sig-2</th>
 * </tr>
 * </table>
 *
 *  <p>
 * If N = 1, the model is a line (sig1 -- sig2 -- sig3 -- sig4 -- sig5 ...)<p>
 *
 * we define <math>\sigma = (\sigma_1,\sigma_2,...,\sigma_n)</math>.<p>
 *
 * The Ising model is represented by the following equation:<p>
 *
 * :<math>\tilde{P}(\sigma) = exp(-\beta H(\sigma)) </math><p>
 *
 * Where beta is the POTENTIAL<p>
 * :<math>H(\sigma) = - \sum_{\langle i~j\rangle} J_{ij} \sigma_i \sigma_j -\mu \sum_{j} h_j\sigma_j</math>
 *
 * Simplifications usually consider  <math> J_{ij} = \mu_j = 1 </math>. That way, the grid model can be represented in the following way: <p>
 *
 * :<math>\tilde{P}(\sigma) = (\prod_{<ij>}\phi(\sigma_i,\sigma_j))(\prod_i\phi'(\simga_i)) </math>
 *
 * Where <ij> mean the set of (i,j) that are directly neighbors, and the factors are defined as follows:<p>
 *
 * :<math>\phi(X,Y)= exp(\beta X Y),\phi'(X) = exp(h X) </math>
 *
 * If we don't consider the simplification, the network correspond to a markov random field  grid with arbitrary factors
 *
 * <p>-----------------------------------------------------------------------------------<p>
 * Important results about the Ising model:<p>
 *
 * - Suppose we take as evidence that all the nodes in the frontier of the lattice (surface of the hypercube)
 * are equal +1. There exists a <math>\beta_c</math>, such that,
 * <math>P(\sigma_0 = True) > \alpha > 0.5</math> for ARBITRARYLY LARGE number of odes on the lattice   <p>
 *
 * - This means that AEBP is going to converge to an interval of size 2*alpha, and then suddenly drops to \ero in the frontier;
 *
 * @param gridSize : gridSize X gridSize is the dimension of the grid
 * @param potential : Beta, Inverse temperature
 * @param weight: Theta
 * @return
 */
public static List<? extends Factor> gridModelWithRandomFactors(int gridSize, boolean TableOrExpression) {
    Random randomGenerator = new Random();
    BiFunction<Pair<Integer, Integer>, Pair<Integer, Integer>, ArrayList<Double>> entries = (i, j) -> arrayList(0.001 * randomGenerator.nextInt(1000), 0.001 * randomGenerator.nextInt(1000), 0.001 * randomGenerator.nextInt(1000), 0.001 * randomGenerator.nextInt(1000));
    if (TableOrExpression) {
        ArrayList<TableFactor> result = tableFactorIsingModel(gridSize, entries, (i) -> null);
        return result;
    } else {
        ArrayList<ExpressionFactor> result = expressionFactorIsingModel(gridSize, entries, (i) -> null);
        return result;
    }
}

Example 48 with Factor

use of com.sri.ai.praise.core.representation.interfacebased.factor.api.Factor in project aic-praise by aic-sri-international.

the class TestCases method isingModelGridWithWeigthsAndPotetialNormalyDistributed.

/*tilde(P)(\sigma) = \frac{1}{Z} exp(\sum_{i}\theta_i \sigma_i + \sum_{<< i j >>}J_{i,j}\sigma_i\sigma_j),
	  * <p>
	  * where \sigma_i \in \{+1,-1\}, J_{i,j},\theta{i} ~ N(0,\beta^2)  
	  * @param beta
	  */
public static List<? extends Factor> isingModelGridWithWeigthsAndPotetialNormalyDistributed(int gridSize, double beta, boolean TableOrExpression) {
    Function<Double, ArrayList<Double>> JPotentialEntries = (J) -> arrayList(exp(J), exp(-1. * J), exp(-1. * J), exp(J));
    Function<Double, ArrayList<Double>> thetaPotentialEntries = (theta) -> arrayList(exp(theta), exp(-1. * theta), exp(-1. * theta), exp(theta));
    Random gen = new Random();
    BiFunction<Pair<Integer, Integer>, Pair<Integer, Integer>, ArrayList<Double>> parwiseEntries = (i, j) -> JPotentialEntries.apply(gen.nextGaussian() * beta);
    Function<Pair<Integer, Integer>, ArrayList<Double>> singleEntries = (i) -> thetaPotentialEntries.apply(gen.nextGaussian());
    if (TableOrExpression) {
        ArrayList<TableFactor> result = tableFactorIsingModel(gridSize, parwiseEntries, singleEntries);
        return result;
    } else {
        ArrayList<ExpressionFactor> result = expressionFactorIsingModel(gridSize, parwiseEntries, singleEntries);
        return result;
    }
}

Example 49 with Factor

use of com.sri.ai.praise.core.representation.interfacebased.factor.api.Factor in project aic-praise by aic-sri-international.

the class AnytimeExactBP method function.

@Override
public Approximation<Factor> function(List<Approximation<Factor>> subsApproximations) {
    Polytope product = getProductOfAllIncomingPolytopesAndFactorAtRoot(subsApproximations);
    Collection<? extends Variable> freeVariables = product.getFreeVariables();
    List<? extends Variable> variablesSummedOut = getBase().determinedVariablesToBeSummedOut(freeVariables);
    Approximation<Factor> result = sumOut(variablesSummedOut, product);
    return result;
}

Example 50 with Factor

use of com.sri.ai.praise.core.representation.interfacebased.factor.api.Factor in project aic-praise by aic-sri-international.

the class AnytimeExactBP method getFactorAtRootPolytope.

private IntensionalConvexHullOfFactors getFactorAtRootPolytope() {
    Factor factorAtRoot = Factor.multiply(getBase().getFactorsAtRoot());
    IntensionalConvexHullOfFactors singletonConvexHullOfFactorAtRoot = new IntensionalConvexHullOfFactors(list(), factorAtRoot);
    return singletonConvexHullOfFactorAtRoot;
}