NUMPY RANDOM PERMUTATION GENERATOR
Generator ( torch.Generator, optional) – a pseudorandom number generator for sampling N ( int) – the upper bound (exclusive) Keyword Arguments : Returns a random permutation of integers from 0 to n - 1. randperm ( n, *, generator = None, out = None, dtype = torch.int64, layout = torch.strided, device = None, requires_grad = False, pin_memory = False ) → Tensor ¶
Set_seed : Seed value if int >= 0, else seed is random.Īssert all(len(arr) = len(arrays) for arr in arrays) """Shuffles arrays in-place, in the same order, along axis=0 Shuffle any number of arrays together, in-place, using only NumPy. This solution could be adapted to the case that a and b have different dtypes. In production code, you would of course try to avoid creating the original a and b at all and right away create c, a2 and b2. To shuffle both arrays simultaneously, use (c).
Now we create views simulating the original a and b: a2 = c.reshape(a.shape)ī2 = c.reshape(b.shape) We can now construct a single array containing all the data: c = numpy.c_ You can use the single array for shuffling and the views for all other purposes.Įxample: Let's assume the arrays a and b look like this: a = numpy.array(, If you don't like this, a different solution would be to store your data in one array instead of two right from the beginning, and create two views into this single array simulating the two arrays you have now. By resetting the state, you ensure that the calls to the random number generator will give the same results in the second call to shuffle(), so the whole algorithm will generate the same permutation. Calling shuffle() for two sequences of the same length results in the same number of calls to the random number generator, and these are the only "random" elements in the shuffle algorithm. Your "scary" solution does not appear scary to me. This works.but it's a little scary, as I see little guarantee it'll continue to work - it doesn't look like the sort of thing that's guaranteed to survive across numpy version, for example. One other thought I had was this: def shuffle_in_unison_scary(a, b):
NUMPY RANDOM PERMUTATION CODE
Is there a better way to go about this? Faster execution and lower memory usage are my primary goals, but elegant code would be nice, too. However, this feels clunky, inefficient, and slow, and it requires making a copy of the arrays - I'd rather shuffle them in-place, since they'll be quite large. Permutation = (len(a))įor old_index, new_index in enumerate(permutation):įor example: > a = numpy.asarray(,, ]) Shuffled_b = numpy.empty(b.shape, dtype=b.dtype) Shuffled_a = numpy.empty(a.shape, dtype=a.dtype) This code works, and illustrates my goals: def shuffle_in_unison(a, b): shuffle them in unison with respect to their leading indices. I want to shuffle each of them, such that corresponding elements continue to correspond - i.e. I have two numpy arrays of different shapes, but with the same length (leading dimension).
0 kommentar(er)
