用ufunc映射numpy数组

Question

I'm trying to efficiently map a N * 1 numpy array of ints to a N * 3 numpy array of floats using a ufunc.

What I have so far:

map = {1: (0, 0, 0), 2: (0.5, 0.5, 0.5), 3: (1, 1, 1)}
ufunc = numpy.frompyfunc(lambda x: numpy.array(map[x], numpy.float32), 1, 1)

input = numpy.array([1, 2, 3], numpy.int32)

ufunc(input) gives a 3 * 3 array with dtype object. I'd like this array but with dtype float32.

Answer 1

You could use np.hstack :

import numpy as np
mapping = {1: (0, 0, 0), 2: (0.5, 0.5, 0.5), 3: (1, 1, 1)}
ufunc = np.frompyfunc(lambda x: np.array(mapping[x], np.float32), 1, 1, dtype = np.float32)

data = np.array([1, 2, 3], np.int32)
result = np.hstack(ufunc(data))
print(result)
# [ 0.   0.   0.   0.5  0.5  0.5  1.   1.   1. ]
print(result.dtype)
# float32
print(result.shape)
# (9,)

Answer 2

You can use ndarray fancy index to get the same result, I think it should be faster than frompyfunc:

map_array = np.array([[0,0,0],[0,0,0],[0.5,0.5,0.5],[1,1,1]], dtype=np.float32)
index = np.array([1,2,3,1])
map_array[index]

Or you can just use list comprehension:

map = {1: (0, 0, 0), 2: (0.5, 0.5, 0.5), 3: (1, 1, 1)}
np.array([map[i] for i in [1,2,3,1]], dtype=np.float32)    

Answer 3

If your mapping is a numpy array, you can just use fancy indexing for this:

>>> valmap = numpy.array([(0, 0, 0), (0.5, 0.5, 0.5), (1, 1, 1)])
>>> input = numpy.array([1, 2, 3], numpy.int32)
>>> valmap[input-1]
array([[ 0. ,  0. ,  0. ],
       [ 0.5,  0.5,  0.5],
       [ 1. ,  1. ,  1. ]])

Answer 4

Unless I misread the doc, the output of np.frompyfunc on a scalar a object indeed: when using a ndarray as input, you'll get a ndarray with dtype=obj .

A workaround is to use the np.vectorize function:

F = np.vectorize(lambda x: mapper.get(x), 'fff')

Here, we force the dtype of F 's output to be 3 floats (hence the 'fff' ).

>>> mapper = {1: (0, 0, 0), 2: (0.5, 1.0, 0.5), 3: (1, 2, 1)}
>>> inp = [1, 2, 3]
>>> F(inp)
(array([ 0. ,  0.5,  1. ], dtype=float32), array([ 0.,  0.5,  1.], dtype=float32), array([ 0. ,  0.5,  1. ], dtype=float32))

OK, not quite what we want: it's a tuple of three float arrays (as we gave 'fff'), the first array being equivalent to [mapper[i][0] for i in inp] . So, with a bit of manipulation:

>>> np.array(F(inp)).T
array([[ 0. ,  0. ,  0. ],
       [ 0.5,  0.5,  0.5],
       [ 1. ,  1. ,  1. ]], dtype=float32)