bruttenberg
commented
7 years ago Hi Subho,
This is an interesting one. It seems that in CASE 1, scala is doing something odd. When I bring this up in the debugger, the type returned by compute_sum in CASE 1 is a ((Boolean) => (Boolean)) => Element[Int]. I’m not sure what this is the case – I think it should just be an Element[Int], so not sure why it’s returning a function. In CASE 2, it does correctly return an Element[Int] (a Fold[Int] class, which is the same). To summarize, CASE 1 is doing nothing, but not sure why.
Now, for CASE 2, you’re doing the summation of a bunch of random values. The reason it’s slow is that this will probably result in some very large factors since there are many output combinations with 100 random numbers. However, since you’re not operating on the sum (just using it for output), it should still be feasible to run (albeit still slow, especially as time increases).
Brian
-
-
-
-
-
-
-
-
-
-
-
-
- + Brian Ruttenberg, PhD Senior Scientist Decision Management Systems Division Government Services Charles River Analytics Inc. 617.491.3474 x730 www.cra.comhttp://www.cra.com/
-
-
-
-
-
-
-
-
-
-
-
From: Subho Banerjee [mailto:notifications@github.com] Sent: Wednesday, November 30, 2016 7:01 PM To: p2t2/figaro figaro@noreply.github.com Subject: [p2t2/figaro] Performance in Filtering Algorithms (#633)
I am trying to figure out how to efficiently implement a factoring algorithm in Figaro. Please have a look at the following code:
import com.cra.figaro.language._
import com.cra.figaro.library.collection._
import com.cra.figaro.algorithm.filtering._
object test {
lazy val init = () => {
val u = Universe.createNew()
val a = new FixedSizeArray[Int](100, (i) => Constant[Int](0)("val"+i, u))
compute_sum(a, u)
u}
lazy val transition = (u: Universe) => {
val next = Universe.createNew()
val a = new FixedSizeArray[Int](100, (i) => Apply(u.getElementByReference[Int]("val"+i), Flip(0.5), (v: Int, f: Boolean) => {
if (f) v + 1 else v - 1
})("val"+i, next))
compute_sum(a, next)
next}
def compute_sum(a: FixedSizeArray[Int], u:Universe) = {
// CASE 1
a.map{(i) => i>0}.count(_)
// CASE 2
a.map{(i) => i>0}.count{(b) => b}("ANSWER1", u)}
def main(args: Array[String]): Unit = {
val inf = FactoredFrontier(init(), transition, 50)
inf.start
for (i <- 1 to 1000) {
inf.advanceTime()
println(i)
println(inf.computeCurrentExpectation[Int]("ANSWER1", (i:Int) => i))
}
inf.kill}
}
When I use CASE 1 in compute_sum, the program finishes in a few seconds. However when I use CASE 2 it takes much much more time.
— You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHubhttps://github.com/p2t2/figaro/issues/633, or mute the threadhttps://github.com/notifications/unsubscribe-auth/AFJOJYFovq3B-rTNzcCASnQ6hiHxM8pJks5rDg5RgaJpZM4LA195.
ssbanerje
I am trying to figure out how to efficiently implement a factoring algorithm in Figaro. Please have a look at the following code:
When I use
CASE 1incompute_sum, the program finishes in a few seconds. However when I useCASE 2it takes much much more time (~30 mins: 100x??). I dont quite understand why these two are different in performance.