charles-river-analytics / figaro Goto Github PK

Look into possible division by zero errors with zero constraints

Define & publish project comment convention

Apply, CPD, Chain, RichCPD allow more than 5 arguments with appropriate constructors

Mention in the tutorial how to get reproducable results

When an element collection attempts to resolve a reference, it attempts to resolve the reference on all possible elements that could be referred to. In some cases, where the reference only exists in a subset of possible resolutions, we need to apply any evidence to only the resolutions where the reference exists. However, when an element collection attempts to resolve the reference, it cancels the application of any evidence on the first element that it fails to resolve the reference, even though on other elements it will be able to resolve it. This is incorrect. It should check through all possible resolutions of a reference before deciding that it cannot apply any evidence to a reference.

We should add a function to element collections that allows one to check if a reference is resolvable on that collection.

Look into Decision Policy usage interface

Investigate and minimize the repetition of RangeToElement in Decision.scala

The current implementation of Values does not terminate in some situations where it could, such as BLOG's Hurricane example. A fixpoint-based implementation would be better.

Consider making MultiValuedReferenceElement a public class

Style sheet for supported IDE(s) should include project settings, required file header, and required license.

Apply, CPD, Chain, RichCPD allow more than 5 arguments with appropriate constructors

There many cases in the Algorithm hierarchy where a class extends (mixes) both a trait and its parent. See ProbQueryVariableEliminationDecision in:

Refactor index code to improve efficiency

Using lazy val to delay generation of elements can lead to nasty surprises when those elements have not been generated at the time of inference. A Lazy element collection would be a better solution. It would delay generating its elements until the time of inference, at which point it would force all its elements.

Remove parent universe from universe

Figure out attributes of a general parameter learning algorithm including one time and any time versions

Apply, CPD, Chain, RichCPD allow more than 5 arguments with appropriate constructors

Define & publish project comment convention
a) /** / for Scaladoc,
b) / */ for general or semantic descriptions,
c) // for implementation details

Create general class of sufficient statistics algorithm and move doStart(), etc. to higher level trait

GitHub doesn't provide a good means for uploading files for later download (except by using Git). Find a new home for our Figaro binary distributions and link via ReadMe.MD (and other places as needed).

Need to update the figaro.cra.com email distribution following the OSS release of Figaro. Current distribution includes Avi and Lisa C. Lisa can be removed but who else should be added?

Examine whether arrays would be a useful data structure in Figaro or whether we can use Scala arrays. Arrays indexed by continuous variables would be an interesting feature.

Look into making factors for IntSelector

Make number of parameters explicit in Expectation Maximization and related classes

Self-generation of elements results in virtual methods being called during initialization, potentially resulting in null pointer exceptions. The current solution is to use lazy vals for fields that are required during generation, but this is risky and far from ideal.

Can IntElement be made to use + rather than ++

Fix unreachable code warnings in the Blind Monopoly demonstration applicaiton

The implemtations of different algorithm categories are inconsistent. For example, MPE algorithms do not provide separate methods for doing the work of producing the most likely value and actually returning the result. So, the anytime MPE doesn't use the standard message handling protocol for mostLikelyValue that other algorithms use. There are various other inconsistencies in different categories. It would be good to standardize the implementations.

Promote getLearnedElement from DirichletParameter to Parameter

Don't have element generate initial value and remove related lazy vals

Promote getLearnedElement from BetaParmeter to Parameter

Look into access control for Alpha, Beta, concentration parameters for DirichletParameters

If declaration of an element is declared lazily, then the creation of an element could occur inside a chain, possibly erroneously marking the element as temporary. This needs to be documented.

See if manage to observe observations without side affects

Currently, on each iteration of importance sampling, the algorithm grabs all non-temporary elements and resamples the elements. This does not resample temporary elements inside a chain. In most cases, this is not a problem since the result element of a chain will be resampled, and usually temporary elements in a chain are used by the result of the chain (an hence will be resampled). However, if there are conditions and constraints on temporary elements in the model (from a reference), then this problem will prevent the evidence from being applied, leading to an inaccurate result.

Publish a reference to project's coding style guide in the project WIKI

Add tests and error checking for parameter value ranges and types

Apply, CPD, Chain, RichCPD allow more than 5 arguments with appropriate constructors

Look into implementation of Dist as Chain

Look at lazy vals in language and library elements

See if the System.gc() can be safely removed in ParticleFilter