mirror of
https://github.com/wassname/catalyst.git
synced 2026-06-30 09:02:58 +08:00
Scott Sanderson
458 lines
14 KiB
Python
458 lines
14 KiB
Python
from operator import or_
|
|
|
|
import numpy as np
|
|
|
|
from zipline.lib.labelarray import LabelArray
|
|
from zipline.pipeline import Classifier
|
|
from zipline.testing import parameter_space
|
|
from zipline.utils.numpy_utils import (
|
|
categorical_dtype,
|
|
coerce_to_dtype,
|
|
int64_dtype,
|
|
)
|
|
|
|
from .base import BasePipelineTestCase
|
|
|
|
|
|
bytes_dtype = np.dtype('S3')
|
|
unicode_dtype = np.dtype('U3')
|
|
|
|
|
|
class ClassifierTestCase(BasePipelineTestCase):
|
|
|
|
@parameter_space(mv=[-1, 0, 1, 999])
|
|
def test_integral_isnull(self, mv):
|
|
|
|
class C(Classifier):
|
|
dtype = int64_dtype
|
|
missing_value = mv
|
|
inputs = ()
|
|
window_length = 0
|
|
|
|
c = C()
|
|
|
|
# There's no significance to the values here other than that they
|
|
# contain a mix of missing and non-missing values.
|
|
data = np.array([[-1, 1, 0, 2],
|
|
[3, 0, 1, 0],
|
|
[-5, 0, -1, 0],
|
|
[-3, 1, 2, 2]], dtype=int64_dtype)
|
|
|
|
self.check_terms(
|
|
terms={
|
|
'isnull': c.isnull(),
|
|
'notnull': c.notnull()
|
|
},
|
|
expected={
|
|
'isnull': data == mv,
|
|
'notnull': data != mv,
|
|
},
|
|
initial_workspace={c: data},
|
|
mask=self.build_mask(self.ones_mask(shape=data.shape)),
|
|
)
|
|
|
|
@parameter_space(mv=['0', None])
|
|
def test_string_isnull(self, mv):
|
|
|
|
class C(Classifier):
|
|
dtype = categorical_dtype
|
|
missing_value = mv
|
|
inputs = ()
|
|
window_length = 0
|
|
|
|
c = C()
|
|
|
|
# There's no significance to the values here other than that they
|
|
# contain a mix of missing and non-missing values.
|
|
raw = np.asarray(
|
|
[['', 'a', 'ab', 'ba'],
|
|
['z', 'ab', 'a', 'ab'],
|
|
['aa', 'ab', '', 'ab'],
|
|
['aa', 'a', 'ba', 'ba']],
|
|
dtype=categorical_dtype,
|
|
)
|
|
data = LabelArray(raw, missing_value=mv)
|
|
|
|
self.check_terms(
|
|
terms={
|
|
'isnull': c.isnull(),
|
|
'notnull': c.notnull()
|
|
},
|
|
expected={
|
|
'isnull': np.equal(raw, mv),
|
|
'notnull': np.not_equal(raw, mv),
|
|
},
|
|
initial_workspace={c: data},
|
|
mask=self.build_mask(self.ones_mask(shape=data.shape)),
|
|
)
|
|
|
|
@parameter_space(compval=[0, 1, 999])
|
|
def test_eq(self, compval):
|
|
|
|
class C(Classifier):
|
|
dtype = int64_dtype
|
|
missing_value = -1
|
|
inputs = ()
|
|
window_length = 0
|
|
|
|
c = C()
|
|
|
|
# There's no significance to the values here other than that they
|
|
# contain a mix of the comparison value and other values.
|
|
data = np.array([[-1, 1, 0, 2],
|
|
[3, 0, 1, 0],
|
|
[-5, 0, -1, 0],
|
|
[-3, 1, 2, 2]], dtype=int64_dtype)
|
|
|
|
self.check_terms(
|
|
terms={
|
|
'eq': c.eq(compval),
|
|
},
|
|
expected={
|
|
'eq': (data == compval),
|
|
},
|
|
initial_workspace={c: data},
|
|
mask=self.build_mask(self.ones_mask(shape=data.shape)),
|
|
)
|
|
|
|
@parameter_space(
|
|
__fail_fast=True,
|
|
compval=['a', 'ab', 'not in the array'],
|
|
labelarray_dtype=(bytes_dtype, categorical_dtype, unicode_dtype),
|
|
)
|
|
def test_string_eq(self, compval, labelarray_dtype):
|
|
|
|
compval = labelarray_dtype.type(compval)
|
|
|
|
class C(Classifier):
|
|
dtype = categorical_dtype
|
|
missing_value = ''
|
|
inputs = ()
|
|
window_length = 0
|
|
|
|
c = C()
|
|
|
|
# There's no significance to the values here other than that they
|
|
# contain a mix of the comparison value and other values.
|
|
data = LabelArray(
|
|
np.asarray(
|
|
[['', 'a', 'ab', 'ba'],
|
|
['z', 'ab', 'a', 'ab'],
|
|
['aa', 'ab', '', 'ab'],
|
|
['aa', 'a', 'ba', 'ba']],
|
|
dtype=labelarray_dtype,
|
|
),
|
|
missing_value='',
|
|
)
|
|
|
|
self.check_terms(
|
|
terms={
|
|
'eq': c.eq(compval),
|
|
},
|
|
expected={
|
|
'eq': (data == compval),
|
|
},
|
|
initial_workspace={c: data},
|
|
mask=self.build_mask(self.ones_mask(shape=data.shape)),
|
|
)
|
|
|
|
@parameter_space(
|
|
missing=[-1, 0, 1],
|
|
dtype_=[int64_dtype, categorical_dtype],
|
|
)
|
|
def test_disallow_comparison_to_missing_value(self, missing, dtype_):
|
|
missing = coerce_to_dtype(dtype_, missing)
|
|
|
|
class C(Classifier):
|
|
dtype = dtype_
|
|
missing_value = missing
|
|
inputs = ()
|
|
window_length = 0
|
|
|
|
with self.assertRaises(ValueError) as e:
|
|
C().eq(missing)
|
|
errmsg = str(e.exception)
|
|
self.assertEqual(
|
|
errmsg,
|
|
"Comparison against self.missing_value ({v!r}) in C.eq().\n"
|
|
"Missing values have NaN semantics, so the requested comparison"
|
|
" would always produce False.\n"
|
|
"Use the isnull() method to check for missing values.".format(
|
|
v=missing,
|
|
),
|
|
)
|
|
|
|
@parameter_space(compval=[0, 1, 999], missing=[-1, 0, 999])
|
|
def test_not_equal(self, compval, missing):
|
|
|
|
class C(Classifier):
|
|
dtype = int64_dtype
|
|
missing_value = missing
|
|
inputs = ()
|
|
window_length = 0
|
|
|
|
c = C()
|
|
|
|
# There's no significance to the values here other than that they
|
|
# contain a mix of the comparison value and other values.
|
|
data = np.array([[-1, 1, 0, 2],
|
|
[3, 0, 1, 0],
|
|
[-5, 0, -1, 0],
|
|
[-3, 1, 2, 2]], dtype=int64_dtype)
|
|
|
|
self.check_terms(
|
|
terms={
|
|
'ne': c != compval,
|
|
},
|
|
expected={
|
|
'ne': (data != compval) & (data != C.missing_value),
|
|
},
|
|
initial_workspace={c: data},
|
|
mask=self.build_mask(self.ones_mask(shape=data.shape)),
|
|
)
|
|
|
|
@parameter_space(
|
|
__fail_fast=True,
|
|
compval=['a', 'ab', '', 'not in the array'],
|
|
missing=['a', 'ab', '', 'not in the array'],
|
|
labelarray_dtype=(bytes_dtype, unicode_dtype, categorical_dtype),
|
|
)
|
|
def test_string_not_equal(self, compval, missing, labelarray_dtype):
|
|
|
|
compval = labelarray_dtype.type(compval)
|
|
|
|
class C(Classifier):
|
|
dtype = categorical_dtype
|
|
missing_value = missing
|
|
inputs = ()
|
|
window_length = 0
|
|
|
|
c = C()
|
|
|
|
# There's no significance to the values here other than that they
|
|
# contain a mix of the comparison value and other values.
|
|
data = LabelArray(
|
|
np.asarray(
|
|
[['', 'a', 'ab', 'ba'],
|
|
['z', 'ab', 'a', 'ab'],
|
|
['aa', 'ab', '', 'ab'],
|
|
['aa', 'a', 'ba', 'ba']],
|
|
dtype=labelarray_dtype,
|
|
),
|
|
missing_value=missing,
|
|
)
|
|
|
|
expected = (
|
|
(data.as_int_array() != data.reverse_categories.get(compval, -1)) &
|
|
(data.as_int_array() != data.reverse_categories[C.missing_value])
|
|
)
|
|
|
|
self.check_terms(
|
|
terms={
|
|
'ne': c != compval,
|
|
},
|
|
expected={
|
|
'ne': expected,
|
|
},
|
|
initial_workspace={c: data},
|
|
mask=self.build_mask(self.ones_mask(shape=data.shape)),
|
|
)
|
|
|
|
@parameter_space(
|
|
__fail_fast=True,
|
|
compval=['a', 'b', 'ab', 'not in the array'],
|
|
missing=['a', 'ab', '', 'not in the array'],
|
|
labelarray_dtype=(categorical_dtype, bytes_dtype, unicode_dtype),
|
|
)
|
|
def test_string_elementwise_predicates(self,
|
|
compval,
|
|
missing,
|
|
labelarray_dtype):
|
|
|
|
missing = labelarray_dtype.type(missing)
|
|
compval = labelarray_dtype.type(compval)
|
|
|
|
class C(Classifier):
|
|
dtype = categorical_dtype
|
|
missing_value = missing
|
|
inputs = ()
|
|
window_length = 0
|
|
|
|
c = C()
|
|
|
|
# There's no significance to the values here other than that they
|
|
# contain a mix of the comparison value and other values.
|
|
data = LabelArray(
|
|
np.asarray(
|
|
[['', 'a', 'ab', 'ba'],
|
|
['z', 'ab', 'a', 'ab'],
|
|
['aa', 'ab', '', 'ab'],
|
|
['aa', 'a', 'ba', 'ba']],
|
|
dtype=labelarray_dtype,
|
|
),
|
|
missing_value=missing,
|
|
)
|
|
|
|
terms = {
|
|
'startswith': c.startswith(compval),
|
|
'endswith': c.endswith(compval),
|
|
'has_substring': c.has_substring(compval),
|
|
# Equivalent filters using regex matching.
|
|
'startswith_re': c.matches('^' + compval + '.*'),
|
|
'endswith_re': c.matches('.*' + compval + '$'),
|
|
'has_substring_re': c.matches('.*' + compval + '.*'),
|
|
}
|
|
|
|
expected = {
|
|
'startswith': (data.startswith(compval) & (data != missing)),
|
|
'endswith': (data.endswith(compval) & (data != missing)),
|
|
'has_substring': (data.has_substring(compval) & (data != missing)),
|
|
}
|
|
for key in list(expected):
|
|
expected[key + '_re'] = expected[key]
|
|
|
|
self.check_terms(
|
|
terms=terms,
|
|
expected=expected,
|
|
initial_workspace={c: data},
|
|
mask=self.build_mask(self.ones_mask(shape=data.shape)),
|
|
)
|
|
|
|
@parameter_space(
|
|
__fail_fast=True,
|
|
container_type=(set, list, tuple, frozenset),
|
|
labelarray_dtype=(categorical_dtype, bytes_dtype, unicode_dtype),
|
|
)
|
|
def test_element_of_strings(self, container_type, labelarray_dtype):
|
|
|
|
missing = labelarray_dtype.type("not in the array")
|
|
|
|
class C(Classifier):
|
|
dtype = categorical_dtype
|
|
missing_value = missing
|
|
inputs = ()
|
|
window_length = 0
|
|
|
|
c = C()
|
|
|
|
raw = np.asarray(
|
|
[['', 'a', 'ab', 'ba'],
|
|
['z', 'ab', 'a', 'ab'],
|
|
['aa', 'ab', '', 'ab'],
|
|
['aa', 'a', 'ba', 'ba']],
|
|
dtype=labelarray_dtype,
|
|
)
|
|
data = LabelArray(raw, missing_value=missing)
|
|
|
|
choices = [
|
|
container_type(choices) for choices in [
|
|
[],
|
|
['a', ''],
|
|
['a', 'a', 'a', 'ab', 'a'],
|
|
set(data.reverse_categories) - {missing},
|
|
['random value', 'ab'],
|
|
['_' * i for i in range(30)],
|
|
]
|
|
]
|
|
|
|
def make_expected(choice_set):
|
|
return np.vectorize(choice_set.__contains__, otypes=[bool])(raw)
|
|
|
|
terms = {str(i): c.element_of(s) for i, s in enumerate(choices)}
|
|
expected = {str(i): make_expected(s) for i, s in enumerate(choices)}
|
|
|
|
self.check_terms(
|
|
terms=terms,
|
|
expected=expected,
|
|
initial_workspace={c: data},
|
|
mask=self.build_mask(self.ones_mask(shape=data.shape)),
|
|
)
|
|
|
|
def test_element_of_integral(self):
|
|
"""
|
|
Element of is well-defined for integral classifiers.
|
|
"""
|
|
class C(Classifier):
|
|
dtype = int64_dtype
|
|
missing_value = -1
|
|
inputs = ()
|
|
window_length = 0
|
|
|
|
c = C()
|
|
|
|
# There's no significance to the values here other than that they
|
|
# contain a mix of missing and non-missing values.
|
|
data = np.array([[-1, 1, 0, 2],
|
|
[3, 0, 1, 0],
|
|
[-5, 0, -1, 0],
|
|
[-3, 1, 2, 2]], dtype=int64_dtype)
|
|
|
|
terms = {}
|
|
expected = {}
|
|
for choices in [(0,), (0, 1), (0, 1, 2)]:
|
|
terms[str(choices)] = c.element_of(choices)
|
|
expected[str(choices)] = reduce(
|
|
or_,
|
|
(data == elem for elem in choices),
|
|
np.zeros_like(data, dtype=bool),
|
|
)
|
|
|
|
self.check_terms(
|
|
terms=terms,
|
|
expected=expected,
|
|
initial_workspace={c: data},
|
|
mask=self.build_mask(self.ones_mask(shape=data.shape)),
|
|
)
|
|
|
|
def test_element_of_rejects_missing_value(self):
|
|
"""
|
|
Test that element_of raises a useful error if we attempt to pass it an
|
|
array of choices that include the classifier's missing_value.
|
|
"""
|
|
missing = "not in the array"
|
|
|
|
class C(Classifier):
|
|
dtype = categorical_dtype
|
|
missing_value = missing
|
|
inputs = ()
|
|
window_length = 0
|
|
|
|
c = C()
|
|
|
|
for bad_elems in ([missing], [missing, 'random other value']):
|
|
with self.assertRaises(ValueError) as e:
|
|
c.element_of(bad_elems)
|
|
errmsg = str(e.exception)
|
|
expected = (
|
|
"Found self.missing_value ('not in the array') in choices"
|
|
" supplied to C.is_element().\n"
|
|
"Missing values have NaN semantics, so the requested"
|
|
" comparison would always produce False.\n"
|
|
"Use the isnull() method to check for missing values.\n"
|
|
"Received choices were {}.".format(bad_elems)
|
|
)
|
|
self.assertEqual(errmsg, expected)
|
|
|
|
@parameter_space(dtype_=Classifier.ALLOWED_DTYPES)
|
|
def test_element_of_rejects_unhashable_type(self, dtype_):
|
|
|
|
class C(Classifier):
|
|
dtype = dtype_
|
|
missing_value = ''
|
|
inputs = ()
|
|
window_length = 0
|
|
|
|
c = C()
|
|
|
|
with self.assertRaises(TypeError) as e:
|
|
c.element_of([{'a': 1}])
|
|
|
|
errmsg = str(e.exception)
|
|
expected = (
|
|
"Expected `choices` to be an iterable of hashable values,"
|
|
" but got [{'a': 1}] instead.\n"
|
|
"This caused the following error: "
|
|
"TypeError(\"unhashable type: 'dict'\",)."
|
|
)
|
|
self.assertEqual(errmsg, expected)
|