doRNG | R package - Generic Reproducible Parallel Backend | Architecture library

If I set Beta=100 in the code above I can get a negative-infinite log-likelihood.

Replacing the measurement-error snippet with this:

I created a foreach loop in following code. There had to be some changes made. It is a lot easier to return a list then a matrix in foreach, since it's combined with rbind. Especially when you want to return multiple ones. My solution here is to save everything in a list and afterwards transform it into a matrix of length 100.

Note: there is one mistake in your code. summary( mod.lm.d)$coef[2,4] does not exist. I changed it to [2]. Adjust to your needing

I think the issue comes from the fact that doRNG gives you the random seed state and you're using that as the input of set.seed, which requires just an integer. I expect set.seed is only taking the first integer provided to the function to set the random seed state. Instead, what you should do is set the seed state in R. First I get the seed states and verify I can reproduce the error:

Modifying the "Hello World" example in the "getting started with doParallel" vignette to generate random numbers, I came up with:

In short, there is no implemented method in parallelSVM to handle this issue. However the package uses the foreach and doParallel packages to handle it's parallel operations. And digging hard enough on stackoverflow a solution is possible!

Credits to this answer, on the usage of the doRNG package, and this answer for giving me an idea for a simpler enclosed solution.

In the parallelSVM package the parallelization happens through the parallelSVM::registerCores functions. This function simply calls doParallel::registerDoParallel with the number of cores, and no further arguments. My idea is simply to change the parallelSVM::registerCores function, such that it automatically sets the seed at after creating a new cluster.

When performing parallel computation, in which you need a parallel seed, there are 2 things you need to ensure

1. The seed needs to be given to each node in the cluster
2. The generator needs to be one that is asymptotically random across clusters.

Luckily the doRNG package handles the first and uses a seed that which is alright on 2. Using a combination of unlockNamespace and assign we can overwrite the parallelSVM::registerCores, such that it includes a call to doRNG::registerDoRNG with the appropriate seed (function at the end of answer). Doing this we can actually get proper reproducibility as illstrated below:

install package doRNG and attach the library:

proc.time() is reset within clusters, so you are comparing how long your main R process has been running to how long your newly created clusters have been running, giving the negative values. It is better to use the Sys.time() function in this situation, which compares back to the central clock. So, to count time from starting the parallel process until each cluster finishes processing:

The future_lapply() function of the future package (I'm the author) provides parallel RNGs using L'Ecuyer-CMRG RNG streams, which is also what parallel::mclapply() uses. It works the same across all OSes and regardless of parallel backend.

The following works on all OSes, including Windows:

The solution is to use the following expression: