R devel - Feb 2008 - Best way to reset random seed when using set.seed() in a function?

Hi,

this is related to a question just raised on Bioconductor where one
function sets the random seed internally but never resets it, which
results in enforced down streams random samples being deterministic.

What is the best way to reset the random seed when you use set.seed()
within a function?  Is it still to re-assign '.Random.seed' in the
global environment as following example illustrates?  I'm not too kind
of having function modifying the global environment, if not really
necessary.

foo <- function(n) {
  # Pop random seed
  if (!exists(".Random.seed", mode="numeric"))
    sample(NA);
  oldSeed <- .Random.seed;

  # Fixed seed to get reproducible samples here
  set.seed(0xbeef);
  x <- sample(5);

  # Proof of concept: 'x' should be the same all the time
  stopifnot(identical( x, as.integer(c(4,2,5,1,3)) ));

  # Push random seed to old state
  assign(".Random.seed", oldSeed, envir=globalenv())

  # Continue as nothing happened
  sample(n);
}
> foo(5)
[1] 4 2 3 5 1
> foo(5)
[1] 4 2 3 1 5
> foo(5)
[1] 5 3 1 4 2
> foo(5)
[1] 5 3 2 4 1
> foo(5)
Is this the way to do it?

Thanks

Henrik

On Wed, 13 Feb 2008, Henrik Bengtsson wrote:
> Hi,
>
> this is related to a question just raised on Bioconductor where one
> function sets the random seed internally but never resets it, which
> results in enforced down streams random samples being deterministic.
>
> What is the best way to reset the random seed when you use set.seed()
> within a function?  Is it still to re-assign '.Random.seed' in the
> global environment as following example illustrates?  I'm not too kind
> of having function modifying the global environment, if not really
> necessary.
It is necessary.  Of course, any use of random numbers modifies this 
variable in the global environment, so many, many functions already do.

There is a write-up in 'R Internals' of what is permissible in 
modifying the base and global environments.
> foo <- function(n) {
>  # Pop random seed
>  if (!exists(".Random.seed", mode="numeric"))
>    sample(NA);
>  oldSeed <- .Random.seed;
>
>  # Fixed seed to get reproducible samples here
>  set.seed(0xbeef);
>  x <- sample(5);
>
>  # Proof of concept: 'x' should be the same all the time
>  stopifnot(identical( x, as.integer(c(4,2,5,1,3)) ));
>
>  # Push random seed to old state
>  assign(".Random.seed", oldSeed, envir=globalenv())
>
>  # Continue as nothing happened
>  sample(n);
> }
>
>> foo(5)
> [1] 4 2 3 5 1
>> foo(5)
> [1] 4 2 3 1 5
>> foo(5)
> [1] 5 3 1 4 2
>> foo(5)
> [1] 5 3 2 4 1
>> foo(5)
>
> Is this the way to do it?
>
> Thanks
>
> Henrik
>
> ______________________________________________
> R-devel at r-project.org mailing list
> https://stat.ethz.ch/mailman/listinfo/r-devel
>
-- 
Brian D. Ripley,                  ripley at stats.ox.ac.uk
Professor of Applied Statistics,  http://www.stats.ox.ac.uk/~ripley/
University of Oxford,             Tel:  +44 1865 272861 (self)
1 South Parks Road,                     +44 1865 272866 (PA)
Oxford OX1 3TG, UK                Fax:  +44 1865 272595

When is this really necessary? I have seen functions that do this, I  
have never seen any usage where I think it is necessary. Usually it  
is because the functions do say mcmc or cross-validation and wants  
repeatable behaviour. But if the user really wants that, he/she can  
just do it outside the functions. On the other hand, if functions  
play with the random generator they are in peril or destroying a  
possible outer loop which also uses random numbers.

Kasper

On Feb 13, 2008, at 8:57 AM, Henrik Bengtsson wrote:
> Hi,
>
> this is related to a question just raised on Bioconductor where one
> function sets the random seed internally but never resets it, which
> results in enforced down streams random samples being deterministic.
>
> What is the best way to reset the random seed when you use set.seed()
> within a function?  Is it still to re-assign '.Random.seed' in the
> global environment as following example illustrates?  I'm not too kind
> of having function modifying the global environment, if not really
> necessary.
>
> foo <- function(n) {
>   # Pop random seed
>   if (!exists(".Random.seed", mode="numeric"))
>     sample(NA);
>   oldSeed <- .Random.seed;
>
>   # Fixed seed to get reproducible samples here
>   set.seed(0xbeef);
>   x <- sample(5);
>
>   # Proof of concept: 'x' should be the same all the time
>   stopifnot(identical( x, as.integer(c(4,2,5,1,3)) ));
>
>   # Push random seed to old state
>   assign(".Random.seed", oldSeed, envir=globalenv())
>
>   # Continue as nothing happened
>   sample(n);
> }
>
>> foo(5)
> [1] 4 2 3 5 1
>> foo(5)
> [1] 4 2 3 1 5
>> foo(5)
> [1] 5 3 1 4 2
>> foo(5)
> [1] 5 3 2 4 1
>> foo(5)
>
> Is this the way to do it?
>
> Thanks
>
> Henrik
>
> ______________________________________________
> R-devel at r-project.org mailing list
> https://stat.ethz.ch/mailman/listinfo/r-devel

I think in general it is a good idea to use  on.exit()  to reset the 
seed if you mess with it. Otherwise you can generate unintended 
consequences for other programs. Something like:
    old.seed <- setRNG(kind = "default", seed = test.seed,
normal.kind =
"default")
    on.exit(setRNG(old.seed))

(BTW, setRNG is a simple little utility in the setRNG package, to help 
set and save some of the other things you need besides the seed, if you 
are going to try to reproduce results.)

Paul

Henrik Bengtsson wrote:
> Hi,
>
> this is related to a question just raised on Bioconductor where one
> function sets the random seed internally but never resets it, which
> results in enforced down streams random samples being deterministic.
>
> What is the best way to reset the random seed when you use set.seed()
> within a function?  Is it still to re-assign '.Random.seed' in the
> global environment as following example illustrates?  I'm not too kind
> of having function modifying the global environment, if not really
> necessary.
>
> foo <- function(n) {
>   # Pop random seed
>   if (!exists(".Random.seed", mode="numeric"))
>     sample(NA);
>   oldSeed <- .Random.seed;
>
>   # Fixed seed to get reproducible samples here
>   set.seed(0xbeef);
>   x <- sample(5);
>
>   # Proof of concept: 'x' should be the same all the time
>   stopifnot(identical( x, as.integer(c(4,2,5,1,3)) ));
>
>   # Push random seed to old state
>   assign(".Random.seed", oldSeed, envir=globalenv())
>
>   # Continue as nothing happened
>   sample(n);
> }
>
>   
>> foo(5)
>>     
> [1] 4 2 3 5 1
>   
>> foo(5)
>>     
> [1] 4 2 3 1 5
>   
>> foo(5)
>>     
> [1] 5 3 1 4 2
>   
>> foo(5)
>>     
> [1] 5 3 2 4 1
>   
>> foo(5)
>>     
>
> Is this the way to do it?
>
> Thanks
>
> Henrik
>
> ______________________________________________
> R-devel at r-project.org mailing list
> https://stat.ethz.ch/mailman/listinfo/r-devel
>   
===================================================================================
La version fran?aise suit le texte anglais.

------------------------------------------------------------------------------------

This email may contain privileged and/or confidential in...{{dropped:26}}