Можно ли numpy.vectorize метод экземпляра?
Я обнаружил, что numpy.vectorizeпозволяет преобразовывать "обычные" функции, которые ожидают одно число в качестве входных данных для функции, которая также может преобразовывать список входных данных в список, в котором функция была сопоставлена с каждым входным параметром. Например, следующие тесты проходят:
import numpy as np
import pytest
@np.vectorize
def f(x):
if x == 0:
return 1
else:
return 2
def test_1():
assert list(f([0, 1, 2])) == [1, 2, 2]
def test_2():
assert f(0) == 1
if __name__ == "__main__":
pytest.main([__file__])
Однако я не смог заставить это работать для метода экземпляра, который использует атрибут экземпляра. Например:
class Dummy(object):
def __init__(self, val=1):
self.val = val
@np.vectorize
def f(self, x):
if x == 0:
return self.val
else:
return 2
def test_3():
assert list(Dummy().f([0, 1, 2])) == [1, 2, 2]
Этот тест не проходит:
=================================== FAILURES ===================================
____________________________________ test_3 ____________________________________
def test_3():
> assert list(Dummy().f([0, 1, 2])) == [1, 2, 2]
test_numpy_vectorize.py:31:
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/numpy/lib/function_base.py:2739: in __call__
return self._vectorize_call(func=func, args=vargs)
/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/numpy/lib/function_base.py:2809: in _vectorize_call
ufunc, otypes = self._get_ufunc_and_otypes(func=func, args=args)
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
self = <numpy.lib.function_base.vectorize object at 0x106546470>
func = <function Dummy.f at 0x10653a2f0>, args = [array([0, 1, 2])]
def _get_ufunc_and_otypes(self, func, args):
"""Return (ufunc, otypes)."""
# frompyfunc will fail if args is empty
if not args:
raise ValueError('args can not be empty')
if self.otypes is not None:
otypes = self.otypes
nout = len(otypes)
# Note logic here: We only *use* self._ufunc if func is self.pyfunc
# even though we set self._ufunc regardless.
if func is self.pyfunc and self._ufunc is not None:
ufunc = self._ufunc
else:
ufunc = self._ufunc = frompyfunc(func, len(args), nout)
else:
# Get number of outputs and output types by calling the function on
# the first entries of args. We also cache the result to prevent
# the subsequent call when the ufunc is evaluated.
# Assumes that ufunc first evaluates the 0th elements in the input
# arrays (the input values are not checked to ensure this)
args = [asarray(arg) for arg in args]
if builtins.any(arg.size == 0 for arg in args):
raise ValueError('cannot call `vectorize` on size 0 inputs '
'unless `otypes` is set')
inputs = [arg.flat[0] for arg in args]
> outputs = func(*inputs)
E TypeError: f() missing 1 required positional argument: 'x'
Можно ли применить numpy.vectorize к методу экземпляра?
4 ответа
Простое решение без изменения класса
Ты можешь использовать np.vectorize непосредственно на метод в экземпляре:
class Dummy(object):
def __init__(self, val=1):
self.val = val
def f(self, x):
if x == 0:
return self.val
else:
return 2
vec_f = np.vectorize(Dummy().f)
def test_3():
assert list(vec_f([0, 1, 2])) == [1, 2, 2]
test_3()
Вы также можете создать векторизованную функцию vec_f в вашем __init__:
Добавление векторизованной версии в экземпляр
class Dummy(object):
def __init__(self, val=1):
self.val = val
self.vec_f = np.vectorize(self.f)
def f(self, x):
if x == 0:
return self.val
else:
return 2
def test_3():
assert list(Dummy().vec_f([0, 1, 2])) == [1, 2, 2]
или с другой схемой именования:
class Dummy(object):
def __init__(self, val=1):
self.val = val
self.f = np.vectorize(self.scalar_f)
def scalar_f(self, x):
if x == 0:
return self.val
else:
return 2
def test_3():
assert list(Dummy().f([0, 1, 2])) == [1, 2, 2]
test_3()
test_3()
Вот обобщенный декоратор, который работает как с методами экземпляра, так и с функциями (см. Документацию Numpy для otypes а также signature):
from functools import wraps
import numpy as np
def vectorize(otypes=None, signature=None):
"""Numpy vectorization wrapper that works with instance methods."""
def decorator(fn):
vectorized = np.vectorize(fn, otypes=otypes, signature=signature)
@wraps(fn)
def wrapper(*args):
return vectorized(*args)
return wrapper
return decorator
Вы можете использовать его для векторизации вашего метода следующим образом:
class Dummy(object):
def __init__(self, val=1):
self.val = val
@vectorize(signature="(),()->()")
def f(self, x):
if x == 0:
return self.val
else:
return 2
def test_3():
assert list(Dummy().f([0, 1, 2])) == [1, 2, 2]
Ключ должен использовать signature kwarg. Значения в скобках слева от -> укажите входные параметры и значения справа укажите выходные значения. () представляет скаляр (0-мерный вектор); (n) представляет одномерный вектор; (m,n) представляет 2-мерный вектор; (m,n,p) представляет 3-мерный вектор; и т.д. здесь, signature="(),()->()" Numpy указывает, что первый параметр (self) это скаляр, второй (x) также является скаляром, и метод возвращает скаляр (либо self.val или же 2, в зависимости от x).
$ pytest /tmp/instance_vectorize.py
======================= test session starts ========================
platform linux -- Python 3.6.5, pytest-3.5.1, py-1.5.3, pluggy-0.6.0
rootdir: /tmp, inifile:
collected 1 item
../../tmp/instance_vectorize.py . [100%]
==================== 1 passed in 0.08 seconds ======================
Если вы хотите использовать векторизованную реализацию вашего метода, вы можете использовать excluded параметр вроде следующего:
class MyClass:
def __init__(self, data):
self.data = data
self.my_vectorized_func = np.vectorize(self.my_func, excluded='self')
def my_func(self, x):
return pow(x, self.data)
При этом вы можете использовать свой метод как не векторизованный:
In[1]: myclass = MyClass(3) # '3' will be the power factor of our function
In[2]: myclass.my_vectorized_func([1, 2, 3, 4, 5])
Out[3]: array([ 1, 8, 27, 64, 125])
Вспоминая технику, которую я видел в memoized декоратор, мне удалось заставить декоратор работать также для методов экземпляра путем создания подклассов numpy.vectorize следующее:
import numpy as np
import functools
class vectorize(np.vectorize):
def __get__(self, obj, objtype):
return functools.partial(self.__call__, obj)
Теперь, если я украшу Dummy учебный класс' f метод с vectorize вместо np.vectorize Тест проходит:
class Dummy(object):
def __init__(self, val=1):
self.val = val
@vectorize
def f(self, x):
if x == 0:
return self.val
else:
return 2
def test_3():
assert list(Dummy().f([0, 1, 2])) == [1, 2, 2]
if __name__ == "__main__":
pytest.main([__file__])
с выходом
test_numpy_vectorize.py .
=========================== 1 passed in 0.01 seconds ===========================
[Finished in 0.7s]
Из документов:
Тип данных вывода векторизации определяется путем вызова функции с первым элементом ввода. Этого можно избежать, указав аргумент otypes.
Первый вход в вашу функцию f(self, x) является self, Может быть, вы можете сделать эту функцию оберткой вокруг staticmethod функционировать?