Function does not compile with Greater in it

Question

I have to speed up a matrix-calculation and would like to use Compile for it, though it fails and produces an unknown error message:

compiledFunc = 
  Compile[{{w, _Real, 2}, {v, _Integer, 1}, {hb, _Real, 
     1}, {vb, _Real, 1}}, Module[{h, hs, vr, hr},
    h = 1./(1. + Exp[-(w.v + hb)]);
    hs = Boole@Thread[h > RandomReal[{0, 1}, {Length@hb}]];
    vr = 1./(1. + Exp[-((Transpose@w).hs + vb)]);
    hr = 1./(1. + Exp[-(w.vr + hb)]);
    w + (0.01*(Outer[Times, h, v] - Outer[Times, hr, vr]))
    ], Parallelization -> True];

(*
  ==> Compile::argcompten: The comparison, Greater, is invalid for tensor arguments. >>
*)

Any idea how I can overcome this and/or speed it up?

Update:

According to the answers, the problem is that Thread is not compilable. Substituting it with MapThread indeed allows compilation. But then running the code gives another error. (I thought that since it is about the same piece of code, I won't start a new post.)

cFunc = Compile[{{w, _Real, 2}, {v, _Integer, 1}, {hb, _Real, 
     1}, {vb, _Real, 1}}, Module[{h, hs, vr, hr},
    h = 1./(1. + Exp[-(w.v + hb)]);
    hs = Boole@
      MapThread[Greater, {h, RandomReal[{0, 1}, {Length@hb}]}];
    vr = 1./(1. + Exp[-((Transpose@w).hs + vb)]);
    hr = 1./(1. + Exp[-(w.vr + hb)]);
    w + (0.01*(Outer[Times, h, v] - Outer[Times, hr, vr]))],
   Parallelization -> True];

cFunc[w, v, hb, vb]

(*
   CompiledFunction::cfse: Compiled expression 1.7+3.2 I should be a machine-size real number. >>

   CompiledFunction::cfex: Could not complete external evaluation at instruction 2; proceeding with uncompiled evaluation. >>
*)

Answer 1

The following seems to work based on what I assumed would be valid input.

compiledFunc = 
  Compile[{{w, _Real, 2}, {v, _Integer, 1}, {hb, _Real, 
     1}, {vb, _Real, 1}}, 
   Module[{h, hs, vr, hr, rr}, h = 1./(1. + Exp[-(w.v + hb)]);
    rr = RandomReal[{0, 1}, Length@hb];
    rr = h - rr;
    hs = UnitStep[rr] Unitize[rr];
    vr = 1./(1. + Exp[-((Transpose@w).hs + vb)]);
    hr = 1./(1. + Exp[-(w.vr + hb)]);
    w + (0.01*(Outer[Times, h, v] - Outer[Times, hr, vr]))], 
   Parallelization -> True];

Edit:

Since you are comparing to random reals we can safely assume none of the elements of hb will ever equal the pseudo-random values and remove the Unitize[rr] from the code. The above is for a more general comparison where equality can occur. Here is the cleaned up but less general version.

compiledFunc = 
  Compile[{{w, _Real, 2}, {v, _Integer, 1}, {hb, _Real, 
     1}, {vb, _Real, 1}}, 
   Module[{h, hs, vr, hr}, h = 1./(1. + Exp[-(w.v + hb)]);
    hs = UnitStep[h-RandomReal[{0, 1}, Length@hb]];
    vr = 1./(1. + Exp[-((Transpose@w).hs + vb)]);
    hr = 1./(1. + Exp[-(w.vr + hb)]);
    w + (0.01*(Outer[Times, h, v] - Outer[Times, hr, vr]))], 
   Parallelization -> True];

As for the second part of the question, apparently Compile doesn't like Boole being applied outside of MapThread. OleksandrR explained why in the comments. Compile cannot work with the boolean tensor that is created by MapThread. You can replace the line with

MapThread[Boole[#1 > #2] &, {h, RandomReal[{0, 1}, Length@hb]}]

and it should work.

Answer 2

The problem is not because of Greater, but Thread, which is not compilable.

MemberQ[Compile`CompilerFunctions[], Thread]
Out[1]= False

However, MapThread is! So you just need to replace the offending line involving Thread with:

hs = MapThread[Greater, {h, RandomReal[{0, 1}, {Length@hb}]}];

and it compiles fine. Here's the complete function:

compiledFunc = 
    Compile[{{w, _Real, 2}, {v, _Integer, 1}, {hb, _Real, 1}, {vb, _Real, 1}}, 
        Module[{h, hs, vr, hr},
            h = 1./(1. + Exp[-(w.v + hb)]);
            hs = MapThread[Greater, {h, RandomReal[{0, 1}, {Length@hb}]}];
            vr = 1./(1. + Exp[-((Transpose@w).hs + vb)]);
            hr = 1./(1. + Exp[-(w.vr + hb)]);
            w + (0.01*(Outer[Times, h, v] - Outer[Times, hr, vr]))
        ], 
    Parallelization -> True
];

Answer 3

Thread isn't compilable.

There are at least two ways of being warned that something is not being compiled: The first is to set SetSystemOptions[ "CompileOptions" -> "CompileReportExternal"->True] (this gives Compile::extscalar messages upon compilation), and examination of the compiled function after the fact with Needs["CompiledFunctionTools`"] followed by CompilePrint[compiledFunc]. This will show calls to the main evaluator.

To get this to compile, I find threading by hand the most readable approach:

compiledFunc = 
 Compile[{{w, _Real, 2}, {v, _Integer, 1}, {hb, _Real, 1}, {vb, _Real,
     1}}, Module[{h, hs, vr, hr}, h = 1./(1. + Exp[-(w.v + hb)]);
   hs = Table[0., {i, Length@hb}];
   Do[
    hs[[i]] = Boole[h[[i]] > RandomReal[{0, 1}]],
    {i, Length@hb}
    ];
   vr = 1./(1. + Exp[-((Transpose@w).hs + vb)]);
   hr = 1./(1. + Exp[-(w.vr + hb)]);
   w + (0.01*(Outer[Times, h, v] - Outer[Times, hr, vr]))], 
  Parallelization -> True]

As for the rest of the code, I am sure it can be further optimised.