def _choose_structured_to_unstructured() -> bool:
"""
Decides which implementation of ``structured_to_unstructured`` to use.
See :func:`fatf.utils.tools.structured_to_unstructured` function
description for details on how the choice is made.
Returns
-------
use_local_implementation : boolean
``True`` if local implementation
(:func:`fatf.utils.tools.fatf_structured_to_unstructured) is to be
used. ``False`` if numpy's implementation
(:func:`numpy.lib.recfunctions.structured_to_unstructured`) is to be
used.
"""
use_local_implementation = True
np_ver = [int(i) for i in np.version.version.split('.')]
# Use builtin numpy if it is implemented therein
if fut.at_least_verion([1, 16], np_ver):
logger.info("Using numpy's numpy.lib.recfunctions."
'structured_to_unstructured as fatf.utils.array.tools.'
'structured_to_unstructured and fatf.utils.array.tools.'
'structured_to_unstructured_row.')
use_local_implementation = False
else:
logger.info("Using fatf's fatf.utils.array.tools."
'fatf_structured_to_unstructured as fatf.utils.'
'array.tools.structured_to_unstructured and fatf.utils.'
'array.tools.fatf_structured_to_unstructured_row as '
'fatf.utils.array.tools.structured_to_unstructured_row.')
use_local_implementation = True
return use_local_implementation
# License: new BSD
import csv
import os
from typing import Dict, List, Tuple, Union
import numpy as np
import fatf.utils.tools as fut
import fatf.utils.array.validation as fuav
__all__ = ['load_data', 'load_health_records', 'load_iris']
_NUMPY_VERSION = [int(i) for i in np.version.version.split('.')]
_NUMPY_1_14 = fut.at_least_verion([1, 14], _NUMPY_VERSION)
_DATA_PATH = os.path.join(os.path.dirname(__file__), 'datasets')
def _validate_data_header(X: np.ndarray, y: np.ndarray, n_samples: int,
n_features: int, y_names: np.ndarray) -> bool:
"""
Checks if reading in data is consistent by ... the csv header.
For details on valid header formatting see the
:func:`fatf.utils.datasets.load_data` documentation.
Parameters
----------
X : numpy.ndarray
def test_at_least_verion():
"""
Tests :func:`fatf.utils.tools.at_least_verion` function.
"""
# pylint: disable=too-many-locals,too-many-branches,too-many-statements
# Wrong outer input types
min_type_error = 'minimum_requirement parameter has to be a list.'
min_element_type_error = ('{} element ({}) of the minimum_requirement '
'list is not an integer.')
curr_element_type_error = ('{} element ({}) of the package_version list '
'is not an integer.')
current_type_error = 'package_version parameter has to be a list.'
min_value_error = 'Minimum version for a package is not specified.'
current_value_error = 'Current version for a package is not specified.'
length_value_error = ('The minimum requirement should not be more precise '
'(longer) than the current version.')
wrong_outer_types = [None, 0, '0', {}, range(5)]
wrong_inner_types = [[None, None], ['0', '0'], [1., '0'], [2., 2.],
[1. + 0j, 6 + 1j, 2.]]
partially_wrong_inner_type_1 = [[None, 0], ['0', 0]]
partially_wrong_inner_type_2 = [[0, '0'], [0, None]]
correct_inner_types = [[0], [0, 0]]
empty_inner_type = [[]]
for i in wrong_outer_types:
for j in wrong_outer_types:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_type_error
for j in wrong_inner_types:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_type_error
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == min_element_type_error.format(0, j[0])
for j in partially_wrong_inner_type_1:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_type_error
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == min_element_type_error.format(0, j[0])
for j in partially_wrong_inner_type_2:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_type_error
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == min_element_type_error.format(1, j[1])
for j in correct_inner_types:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_type_error
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == current_type_error
for j in empty_inner_type:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_type_error
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == current_type_error
for i in wrong_inner_types:
for j in wrong_inner_types:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_element_type_error.format(0, i[0])
for j in partially_wrong_inner_type_1:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_element_type_error.format(0, i[0])
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == min_element_type_error.format(0, j[0])
for j in partially_wrong_inner_type_2:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_element_type_error.format(0, i[0])
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == min_element_type_error.format(1, j[1])
for j in correct_inner_types:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_element_type_error.format(0, i[0])
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == curr_element_type_error.format(0, i[0])
for j in empty_inner_type:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_element_type_error.format(0, i[0])
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == curr_element_type_error.format(0, i[0])
for i in partially_wrong_inner_type_1:
for j in partially_wrong_inner_type_1:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_element_type_error.format(0, i[0])
for j in partially_wrong_inner_type_2:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_element_type_error.format(0, i[0])
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == min_element_type_error.format(1, j[1])
for j in correct_inner_types:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_element_type_error.format(0, i[0])
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == curr_element_type_error.format(0, i[0])
for j in empty_inner_type:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_element_type_error.format(0, i[0])
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == curr_element_type_error.format(0, i[0])
for i in partially_wrong_inner_type_2:
for j in partially_wrong_inner_type_2:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_element_type_error.format(1, i[1])
for j in correct_inner_types:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_element_type_error.format(1, i[1])
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == curr_element_type_error.format(1, i[1])
for j in empty_inner_type:
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_element_type_error.format(1, i[1])
with pytest.raises(TypeError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == curr_element_type_error.format(1, i[1])
assert len(correct_inner_types) == 2, \
'Testing correct_inner_types just for 2 elements.'
assert fut.at_least_verion(correct_inner_types[0], correct_inner_types[1])
with pytest.raises(ValueError) as exin:
assert fut.at_least_verion(correct_inner_types[1],
correct_inner_types[0])
assert str(exin.value) == length_value_error
for i in correct_inner_types:
assert fut.at_least_verion(i, i)
for j in empty_inner_type:
with pytest.raises(ValueError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == current_value_error
with pytest.raises(ValueError) as exin:
assert fut.at_least_verion(j, i)
assert str(exin.value) == min_value_error
for i in empty_inner_type:
for j in empty_inner_type:
with pytest.raises(ValueError) as exin:
assert fut.at_least_verion(i, j)
assert str(exin.value) == min_value_error
# Correct outer, correct inner, different lengths
# Current shorter than required and satisfies
assert fut.at_least_verion([1], [1, 4, 2])
assert fut.at_least_verion([1, 6], [1, 6, 0])
# Current shorter than required and does not satisfy
assert not fut.at_least_verion([1], [0, 4, 2])
# Current longer than required and satisfies
with pytest.raises(ValueError) as exin:
assert fut.at_least_verion([1, 0, 0], [1, 0])
assert str(exin.value) == length_value_error
# Current longer than required and does not satisfy
with pytest.raises(ValueError) as exin:
assert fut.at_least_verion([1, 4, 2], [0, 5])
assert str(exin.value) == length_value_error
# Correct outer, correct inner, same lengths
# Correct
assert fut.at_least_verion([1, 4, 2], [1, 4, 2])
assert fut.at_least_verion([1, 6, 2], [1, 7, 1])
assert fut.at_least_verion([1, 6, 2], [2, 0, 0])
# Incorrect
assert not fut.at_least_verion([2, 0, 0], [1, 9, 9])
# License: new BSD
from typing import Union
import sklearn.linear_model
import sklearn.utils.validation
import numpy as np
import fatf.transparency.sklearn.tools as ftst
import fatf.utils.tools as fut
__all__ = ['linear_classifier_coefficients', 'SKLearnLinearModelExplainer']
_SKLEARN_VERSION = [int(i) for i in sklearn.__version__.split('.')[:2]]
_SKLEARN_0_22 = fut.at_least_verion([0, 22], _SKLEARN_VERSION)
if _SKLEARN_0_22: # pragma: nocover
# pylint: disable=invalid-name,protected-access,no-member
_linear_base = sklearn.linear_model._base
_linear_coordinate_descent = sklearn.linear_model._coordinate_descent
_lienar_stochastic_gradient = sklearn.linear_model._stochastic_gradient
_linear_bayes = sklearn.linear_model._bayes
_linear_theil = sklearn.linear_model._theil_sen
_linear_omp = sklearn.linear_model._omp
_linear_ridge = sklearn.linear_model._ridge
_linear_angles = sklearn.linear_model._least_angle
else: # pragma: nocover
_linear_base = sklearn.linear_model.base # pylint: disable=invalid-name
# pylint: disable=invalid-name
_linear_coordinate_descent = sklearn.linear_model.coordinate_descent
"""
# Author: Kacper Sokol <*****@*****.**>
# Rafael Poyiadzi <*****@*****.**>
# License: new BSD
import pytest
import numpy as np
import fatf.transparency.data.describe_functions as ftddf
import fatf.utils.tools as fut
from fatf.exceptions import IncorrectShapeError
_NUMPY_VERSION = [int(i) for i in np.version.version.split('.')]
_NUMPY_1_16 = fut.at_least_verion([1, 16], _NUMPY_VERSION)
_NUMPY_1_14_4 = fut.at_least_verion([1, 14, 4], _NUMPY_VERSION)
_NUMPY_1_11 = fut.at_least_verion([1, 11], _NUMPY_VERSION)
_NUMPY_1_10 = fut.at_least_verion([1, 10], _NUMPY_VERSION)
NUMERICAL_KEYS = [
'count', 'mean', 'std', 'max', 'min', '25%', '50%', '75%', 'nan_count'
]
CATEGORICAL_KEYS = [
'count', 'unique', 'unique_counts', 'top', 'freq', 'is_top_unique'
]
def test_describe_numerical_array():
"""
Tests :func:`fatf.transparency.data.describe.describe_numerical_array`.
import sklearn.exceptions
import sklearn.linear_model
import sklearn.naive_bayes
import sklearn.neighbors
import sklearn.svm
import sklearn.tree
import numpy as np
import fatf
import fatf.transparency.sklearn.linear_model as ftsl
import fatf.utils.tools as fut
_SKLEARN_VERSION = [int(i) for i in sklearn.__version__.split('.')[:2]]
_SKLEARN_0_20 = fut.at_least_verion([0, 20], _SKLEARN_VERSION)
_SKLEARN_0_22 = fut.at_least_verion([0, 22], _SKLEARN_VERSION)
_SKLEARN_0_23 = fut.at_least_verion([0, 23], _SKLEARN_VERSION)
# yapf: disable
LINEAR_CLASSIFIERS = [
sklearn.svm.LinearSVC,
sklearn.linear_model.RidgeClassifier,
sklearn.linear_model.RidgeClassifierCV,
sklearn.discriminant_analysis.LinearDiscriminantAnalysis,
#
sklearn.linear_model.LogisticRegression,
sklearn.linear_model.LogisticRegressionCV
]
# These three linear models get different results in different Python versions,
# hence will not be tested for parameters.
'is_textual_dtype',
'is_base_dtype',
'is_flat_dtype',
'are_similar_dtypes',
'are_similar_dtype_arrays',
'is_numerical_array',
'is_textual_array',
'is_base_array',
'is_1d_array',
'is_2d_array',
'is_structured_row',
'is_1d_like',
'is_structured_array'] # yapf: disable
_NUMPY_VERSION = [int(i) for i in np.version.version.split('.')]
_NUMPY_1_13 = fut.at_least_verion([1, 13], _NUMPY_VERSION)
# Unsigned byte, Boolean, (signed) byte -- Boolean, unsigned integer,
# (signed) integer, floating-point and complex-floating point.
_NUMPY_NUMERICAL_KINDS = set('B?buifc')
# Unicode string
_NUMPY_TEXTUAL_KINDS = set('U')
# Zero-terminated bytes
_NUMPY_TEXTUAL_KINDS_UNSUPPORTED = set('Sa')
# O, M, m and V are considered complex objects
_NUMPY_BASE_KINDS = set('?buifcBSaU')
def is_numerical_dtype(dtype: np.dtype) -> bool:
"""
Determines whether a numpy dtype object is of numerical type.
