数据检查#

数据检查。

包内容#

类摘要#

`ClassImbalanceDataCheck`	检查任何目标标签是否不平衡，或者每个目标的数值是否小于交叉验证折叠次数的2倍。用于分类问题。
`DataCheck`	所有数据检查的基类。
`DataCheckAction`	DataCheck 返回的推荐操作。
`DataCheckActionCode`	数据检查操作代码的枚举。
`DataCheckActionOption`	DataCheck 返回的推荐操作选项。
`DataCheckError`	DataCheckMessage 的子类，用于数据检查返回的错误。
`DataCheckMessage`	DataCheck 返回的消息的基类，按名称标记。
`DataCheckMessageCode`	数据检查消息代码的枚举。
`DataCheckMessageType`	数据检查消息类型的枚举：WARNING 或 ERROR。
`DataChecks`	数据检查的集合。
`DataCheckWarning`	DataCheckMessage 的子类，用于数据检查返回的警告。
`DateTimeFormatDataCheck`	检查日期时间列是否具有等间隔并且是单调递增或递减的，以便时间序列估计器支持。
`DCAOParameterAllowedValuesType`	数据检查操作选项参数允许值类型的枚举。
`DCAOParameterType`	数据检查操作选项参数类型的枚举。
`DefaultDataChecks`	AutoML 默认使用的一组基本数据检查。
`IDColumnsDataCheck`	检查是否有任何特征可能是 ID 列。
`InvalidTargetDataCheck`	检查目标数据是否被认为是无效的。
`MismatchedSeriesLengthDataCheck`	检查多序列数据集中的一个或多个唯一序列的长度是否与其他序列不同。
`MulticollinearityDataCheck`	检查任何一组特征是否可能存在多重共线性。
`NoVarianceDataCheck`	检查目标或任何特征是否没有方差。
`NullDataCheck`	检查输入中是否存在高度为空的数值、布尔、分类、自然语言和未知列以及行。
`OutliersDataCheck`	使用 IQR 检测输入数据中是否存在异常值，以确定得分异常。
`SparsityDataCheck`	检查输入中是否存在值填充稀疏的列。
`TargetDistributionDataCheck`	检查目标数据是否包含可能需要在训练前转换以提高模型性能的特定分布。当数据集样本数小于等于 5000 时使用 Shapiro-Wilks 检验，否则使用 Jarque-Bera 检验。
`TargetLeakageDataCheck`	通过使用互信息、Pearson 相关系数和其他相关指标，检查任何特征是否与目标高度相关。
`TimeSeriesParametersDataCheck`	检查时间序列参数是否与数据拆分兼容。
`TimeSeriesSplittingDataCheck`	检查时间序列目标数据是否与拆分兼容。
`UniquenessDataCheck`	检查输入中是否存在对于分类问题来说过于唯一或对于回归问题来说不够唯一的列。

目录#

class evalml.data_checks.ClassImbalanceDataCheck(threshold=0.1, min_samples=100, num_cv_folds=3, test_size=None)[source]#

检查任何目标标签是否不平衡，或者每个目标的数值是否小于交叉验证折叠次数的2倍。用于分类问题。

参数

threshold (float) – 在发出警告之前允许的类别不平衡的最小阈值。此阈值是通过将每个类别中的样本数与该类别和多数类别中的样本总和进行比较来计算的。例如，一个多类别的例子，类别 0、1 和 2 分别有 [900, 900, 100] 个样本，类别 2 的阈值为 0.10 (100 / (900 + 100))。默认为 0.10。
min_samples (int) – 每个可接受类别的最小样本数。如果少数类别同时低于阈值和 min_samples，则我们认为这是严重不平衡。必须大于 0。默认为 100。
num_cv_folds (int) – 交叉验证折叠的次数。必须是正数。选择 0 可忽略此警告。默认为 3。
test_size (None, float, int) – 测试集大小的百分比。用于在将数据拆分为训练集和验证/测试集之前计算类别不平衡。

引发

ValueError – 如果阈值不在 0 到 0.5 之间
ValueError – 如果 min_samples 不大于 0
ValueError – 如果交叉验证折叠次数为负数
ValueError – 如果 test_size 不在 0 到 1 之间

方法

`name`	返回描述数据检查的名称。
`validate`	检查二分类和多分类问题的任何目标标签是否超出阈值不平衡。

name(cls)#: 返回描述数据检查的名称。

validate(self, X, y)[source]#

检查二分类和多分类问题的任何目标标签是否超出阈值不平衡。

如果目标标签中出现 NaN 值，则忽略。

参数

X (pd.DataFrame, np.ndarray) – 特征。被忽略。
y (pd.Series, np.ndarray) – 用于检查不平衡数据的目标标签。

返回

如果类别不平衡小于阈值，则返回包含 DataCheckWarnings 的字典，: 如果每个目标的数值小于 2 * num_cv_folds，则返回 DataCheckErrors。

返回类型

dict (DataCheckMessage)

示例

>>> import pandas as pd
...
>>> X = pd.DataFrame()
>>> y = pd.Series([0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])

在此二分类示例中，目标类别 0 在少于 10% (threshold=0.10) 的实例中出现，且少于交叉折叠次数的 2 倍 (2 * 3 = 6)。因此，Class Imbalance Data Check 将同时返回警告和错误。此外，如果目标的出现次数少于 min_samples (默认为 100) 且低于阈值，将引发严重类别不平衡警告。

>>> class_imb_dc = ClassImbalanceDataCheck(threshold=0.10)
>>> assert class_imb_dc.validate(X, y) == [
...     {
...         "message": "The number of instances of these targets is less than 2 * the number of cross folds = 6 instances: [0]",
...         "data_check_name": "ClassImbalanceDataCheck",
...         "level": "error",
...         "code": "CLASS_IMBALANCE_BELOW_FOLDS",
...         "details": {"target_values": [0], "rows": None, "columns": None},
...         "action_options": []
...     },
...     {
...         "message": "The following labels fall below 10% of the target: [0]",
...         "data_check_name": "ClassImbalanceDataCheck",
...         "level": "warning",
...         "code": "CLASS_IMBALANCE_BELOW_THRESHOLD",
...         "details": {"target_values": [0], "rows": None, "columns": None},
...         "action_options": []
...     },
...     {
...         "message": "The following labels in the target have severe class imbalance because they fall under 10% of the target and have less than 100 samples: [0]",
...         "data_check_name": "ClassImbalanceDataCheck",
...         "level": "warning",
...         "code": "CLASS_IMBALANCE_SEVERE",
...         "details": {"target_values": [0], "rows": None, "columns": None},
...         "action_options": []
...     }
... ]

在此多分类示例中，目标类别 0 在少于 30% 的观测值中出现，但对于 1 个交叉折叠，所需的最小实例数为 2 * 1 = 2。因此，将引发警告，但不是错误。

>>> y = pd.Series([0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2])
>>> class_imb_dc = ClassImbalanceDataCheck(threshold=0.30, min_samples=5, num_cv_folds=1)
>>> assert class_imb_dc.validate(X, y) == [
...     {
...         "message": "The following labels fall below 30% of the target: [0]",
...         "data_check_name": "ClassImbalanceDataCheck",
...         "level": "warning",
...         "code": "CLASS_IMBALANCE_BELOW_THRESHOLD",
...         "details": {"target_values": [0], "rows": None, "columns": None},
...         "action_options": []
...     },
...     {
...         "message": "The following labels in the target have severe class imbalance because they fall under 30% of the target and have less than 5 samples: [0]",
...         "data_check_name": "ClassImbalanceDataCheck",
...         "level": "warning",
...         "code": "CLASS_IMBALANCE_SEVERE",
...         "details": {"target_values": [0], "rows": None, "columns": None},
...         "action_options": []
...     }
... ]
...
>>> y = pd.Series([0, 0, 1, 1, 1, 1, 2, 2, 2, 2])
>>> class_imb_dc = ClassImbalanceDataCheck(threshold=0.30, num_cv_folds=1)
>>> assert class_imb_dc.validate(X, y) == []

class evalml.data_checks.DataCheck[source]#

所有数据检查的基类。

数据检查是一套用于确定输入数据是否存在问题的启发式方法。

方法

`name`	返回描述数据检查的名称。
`validate`	检查和验证输入数据，运行任何必要的计算或算法，并在适用时返回警告和错误列表。

name(cls)#: 返回描述数据检查的名称。

abstract validate(self, X, y=None)[source]#

检查和验证输入数据，运行任何必要的计算或算法，并在适用时返回警告和错误列表。

参数

X (pd.DataFrame) – 输入数据，形状为 [n_samples, n_features]
y (pd.Series, optional) – 目标数据，长度为 [n_samples]

返回

包含 DataCheckError 和 DataCheckWarning 消息的字典

返回类型

dict (DataCheckMessage)

class evalml.data_checks.DataCheckAction(action_code, data_check_name, metadata=None)[source]#

DataCheck 返回的推荐操作。

参数

action_code (str, DataCheckActionCode) – 与操作关联的操作代码。
data_check_name (str) – 数据检查的名称。
metadata (dict, optional) – 与操作关联的其他有用信息。默认为 None。

方法

`convert_dict_to_action`	将字典转换为 DataCheckAction。
`to_dict`	返回数据检查操作的字典形式。

static convert_dict_to_action(action_dict)[source]#

将字典转换为 DataCheckAction。

参数: action_dict – 要转换为操作的字典。应包含键“code”、“data_check_name”和“metadata”。
引发: ValueError – 如果输入字典不包含键 code 和 metadata，并且如果 metadata 字典不包含键 columns 和 rows。
返回: 从输入字典生成的 DataCheckAction 对象。

to_dict(self)[source]#: 返回数据检查操作的字典形式。

class evalml.data_checks.DataCheckActionCode[source]#

数据检查操作代码的枚举。

属性

DROP_COL	用于删除列的操作代码。
DROP_ROWS	用于删除行的操作代码。
IMPUTE_COL	用于填充列的操作代码。
REGULARIZE_AND_IMPUTE_DATASET	用于规范化和填充所有特征和目标时间序列数据的操作代码。
SET_FIRST_COL_ID	用于将第一列设置为 ID 列的操作代码。
TRANSFORM_TARGET	用于转换目标数据的操作代码。

方法

`name`	枚举成员的名称。
`value`	枚举成员的值。

name(self)#: 枚举成员的名称。

value(self)#: 枚举成员的值。

class evalml.data_checks.DataCheckActionOption(action_code, data_check_name, parameters=None, metadata=None)[source]#

DataCheck 返回的推荐操作选项。

它包含一个指示应执行何种操作的操作代码，一个指示用于生成该操作的数据检查的名称，以及可用于进一步细化操作的参数和元数据。

参数

action_code (DataCheckActionCode) – 与操作选项关联的操作代码。
data_check_name (str) – 生成此选项的数据检查的名称。
parameters (dict) – 与操作选项关联的参数。默认为 None。
metadata (dict, optional) – 与操作选项关联的其他有用信息。默认为 None。

示例

>>> parameters = {
...     "global_parameter_name": {
...         "parameter_type": "global",
...         "type": "float",
...         "default_value": 0.0,
...     },
...     "column_parameter_name": {
...         "parameter_type": "column",
...         "columns": {
...             "a": {
...                 "impute_strategy": {
...                     "categories": ["mean", "most_frequent"],
...                     "type": "category",
...                     "default_value": "mean",
...                 },
...             "constant_fill_value": {"type": "float", "default_value": 0},
...             },
...         },
...     },
... }
>>> data_check_action = DataCheckActionOption(DataCheckActionCode.DROP_COL, None, metadata={}, parameters=parameters)

方法

`convert_dict_to_option`	将字典转换为 DataCheckActionOption。
`get_action_from_defaults`	根据默认参数返回一个操作。
`to_dict`	返回数据检查操作选项的字典形式。

static convert_dict_to_option(action_dict)[source]#

将字典转换为 DataCheckActionOption。

参数: action_dict – 要转换为操作选项的字典。应包含键“code”、“data_check_name”和“metadata”。
引发: ValueError – 如果输入字典不包含键 code 和 metadata，并且如果 metadata 字典不包含键 columns 和 rows。
返回: 从输入字典生成的 DataCheckActionOption 对象。

get_action_from_defaults(self)[source]#

根据默认参数返回一个操作。

返回: 基于选项的默认参数的操作。
返回类型: DataCheckAction

to_dict(self)[source]#: 返回数据检查操作选项的字典形式。

class evalml.data_checks.DataCheckError(message, data_check_name, message_code=None, details=None, action_options=None)[source]#

DataCheckMessage 的子类，用于数据检查返回的错误。

属性

message_type

DataCheckMessageType.ERROR

方法

to_dict

返回数据检查消息的字典形式。

to_dict(self)#: 返回数据检查消息的字典形式。

class evalml.data_checks.DataCheckMessage(message, data_check_name, message_code=None, details=None, action_options=None)[source]#

DataCheck 返回的消息的基类，按名称标记。

参数

message (str) – 消息字符串。
data_check_name (str) – 相关联的数据检查的名称。
message_code (DataCheckMessageCode, optional) – 与消息关联的消息代码。默认为 None。
details (dict, optional) – 与消息关联的其他有用信息。默认为 None。
action_options (list, optional) – 与消息关联的 `DataCheckActionOption`s 列表。默认为 None。

属性

message_type

无

方法

to_dict

返回数据检查消息的字典形式。

to_dict(self)[source]#: 返回数据检查消息的字典形式。

class evalml.data_checks.DataCheckMessageCode[source]#

数据检查消息代码的枚举。

属性

CLASS_IMBALANCE_BELOW_FOLDS	当每个目标的数值小于 2 * 交叉验证折叠次数时的消息代码。
CLASS_IMBALANCE_BELOW_THRESHOLD	当类别平衡小于阈值时的消息代码。
CLASS_IMBALANCE_SEVERE	当类别平衡小于阈值且最小类别小于最小可接受样本数时的消息代码。
COLS_WITH_NULL	列包含空值时的消息代码。
DATETIME_HAS_MISALIGNED_VALUES	当日期时间信息的值与推断的频率不一致时的消息代码。
DATETIME_HAS_NAN	当输入日期时间列包含 NaN 值时的消息代码。
DATETIME_HAS_REDUNDANT_ROW	当日期时间信息每个日期时间包含多行时的消息代码。
DATETIME_HAS_UNEVEN_INTERVALS	当日期时间值间隔不均匀时的消息代码。
DATETIME_INFORMATION_NOT_FOUND	当找不到日期时间信息或其格式不被接受时的消息代码。
DATETIME_IS_MISSING_VALUES	当日期时间特征在开始和结束日期之间缺少值时的消息代码。
DATETIME_IS_NOT_MONOTONIC	当日期时间值非单调递增时的消息代码。
DATETIME_NO_FREQUENCY_INFERRED	通过 Woodwork 的 infer_frequency 无法推断日期时间值频率时的消息代码。
HAS_ID_COLUMN	数据包含 ID 列时的消息代码。
HAS_ID_FIRST_COLUMN	数据将 ID 列作为第一列时的消息代码。
HAS_OUTLIERS	检测到异常值时的消息代码。
HIGH_VARIANCE	交叉验证检测到高方差时的消息代码。
HIGHLY_NULL_COLS	高度空列的消息代码。
HIGHLY_NULL_ROWS	高度空行的消息代码。
INVALID_SERIES_ID_COL	给定 series_id 无效时的消息代码
IS_MULTICOLLINEAR	数据可能存在多重共线性时的消息代码。
MISMATCHED_INDICES	当输入目标和特征索引不匹配时的消息代码。
MISMATCHED_INDICES_ORDER	当输入目标和特征索引顺序不匹配时的消息代码。两个输入的索引值相同，但顺序被打乱。
MISMATCHED_LENGTHS	当输入目标和特征长度不同时的消息代码。
MISMATCHED_SERIES_LENGTH	多序列数据集中的一个或多个唯一序列长度与其他序列不同时的消息代码
NATURAL_LANGUAGE_HAS_NAN	当输入自然语言列包含 NaN 值时的消息代码。
NO_VARIANCE	当数据没有方差（1 个唯一值）时的消息代码。
NO_VARIANCE_WITH_NULL	当数据有一个唯一值和 NaN 值时的消息代码。
NO_VARIANCE_ZERO_UNIQUE	当数据没有方差（0 个唯一值）时的消息代码
NOT_UNIQUE_ENOUGH	当数据不具有足够的唯一值时的消息代码。
TARGET_BINARY_NOT_TWO_UNIQUE_VALUES	二分类问题目标数据不包含两个唯一值时的消息代码。
TARGET_HAS_NULL	目标数据包含空值时的消息代码。
TARGET_INCOMPATIBLE_OBJECTIVE	目标数据与指定目标值不兼容时的消息代码
TARGET_IS_EMPTY_OR_FULLY_NULL	目标数据为空或全部为空值时的消息代码。
TARGET_IS_NONE	目标为 None 时的消息代码。
TARGET_LEAKAGE	检测到目标泄漏时的消息代码。
TARGET_LOGNORMAL_DISTRIBUTION	具有对数正态分布的目标数据的消息代码。
TARGET_MULTICLASS_HIGH_UNIQUE_CLASS	多分类问题目标数据唯一类别数量相对于目标值数量异常大时的消息代码。
TARGET_MULTICLASS_NOT_ENOUGH_CLASSES	多分类问题目标数据唯一类别数量不超过两个时的消息代码。
TARGET_MULTICLASS_NOT_TWO_EXAMPLES_PER_CLASS	多分类问题目标数据每个类别样本数不足两个时的消息代码。
TARGET_UNSUPPORTED_PROBLEM_TYPE	针对不受支持的问题类型检查目标数据时的消息代码。
TARGET_UNSUPPORTED_TYPE	目标数据类型不受支持时的消息代码。
TARGET_UNSUPPORTED_TYPE_REGRESSION	目标数据与回归不兼容时的消息代码
TIMESERIES_PARAMETERS_NOT_COMPATIBLE_WITH_SPLIT	当时间序列参数对于最小数据拆分过大时的消息代码。
TIMESERIES_TARGET_NOT_COMPATIBLE_WITH_SPLIT	当时间序列目标的任何训练集和验证集拆分不包含所有类别时的消息代码。
TOO_SPARSE	当多类别数据值填充过于稀疏时的消息代码。
TOO_UNIQUE	当数据唯一值过多时的消息代码。

方法

`name`	枚举成员的名称。
`value`	枚举成员的值。

name(self)#: 枚举成员的名称。

value(self)#: 枚举成员的值。

class evalml.data_checks.DataCheckMessageType[source]#

数据检查消息类型的枚举：WARNING 或 ERROR。

属性

ERROR	数据检查返回的错误消息。
WARNING	数据检查返回的警告消息。

方法

`name`	枚举成员的名称。
`value`	枚举成员的值。

name(self)#: 枚举成员的名称。

value(self)#: 枚举成员的值。

class evalml.data_checks.DataChecks(data_checks=None, data_check_params=None)[source]#

数据检查的集合。

参数

data_checks (list (DataCheck)) – DataCheck 对象的列表。
data_check_params (dict) – 传入的 DataCheck 对象的参数。

方法

validate

根据数据检查检查和验证输入数据，并在适用时返回警告和错误列表。

validate(self, X, y=None)[source]#

根据数据检查检查和验证输入数据，并在适用时返回警告和错误列表。

参数

X (pd.DataFrame, np.ndarray) – 输入数据，形状为 [n_samples, n_features]
y (pd.Series, np.ndarray) – 目标数据，长度为 [n_samples]

返回

包含 DataCheckMessage 对象的字典

返回类型

dict (DataCheckMessage)

class evalml.data_checks.DataCheckWarning(message, data_check_name, message_code=None, details=None, action_options=None)[source]#

DataCheckMessage 的子类，用于数据检查返回的警告。

属性

message_type

DataCheckMessageType.WARNING

方法

to_dict

返回数据检查消息的字典形式。

to_dict(self)#: 返回数据检查消息的字典形式。

class evalml.data_checks.DateTimeFormatDataCheck(datetime_column='index', nan_duplicate_threshold=0.75, series_id=None)[source]#

检查日期时间列是否具有等间隔并且是单调递增或递减的，以便时间序列估计器支持。

如果用于多序列问题，特别适用于堆叠数据集。

参数

datetime_column (str, int) – 日期时间列的名称。如果日期时间值在索引中，则传入“index”。
nan_duplicate_threshold (float) – 在返回 DATETIME_NO_FREQUENCY_INFERRED 而不是 DATETIME_HAS_UNEVEN_INTERVALS 之前，datetime_column 中必须不重复或不为 nan 的值的百分比。例如，如果设置为 0.80，则 datetime_column 中只有 20% 的值可以是重复或 nan。默认为 0.75。
series_id (str) – 多序列数据集的 series_id 列的名称。默认为 None

方法

`name`	返回描述数据检查的名称。
`validate`	检查目标数据是否具有等间隔且单调递增。

name(cls)#: 返回描述数据检查的名称。

validate(self, X, y)[source]#

检查目标数据是否具有等间隔且单调递增。

如果数据不是日期时间类型、非递增、包含冗余或缺失行、包含无效（NaN 或 None）值或值与假定频率不一致，则将返回 DataCheckError。

如果用于多序列问题，特别适用于堆叠数据集。

参数

X (pd.DataFrame, np.ndarray) – 特征。
y (pd.Series, np.ndarray) – 目标数据。

返回

如果在日期时间列中发现间隔不均，则返回包含 DataCheckErrors 的列表。

返回类型

dict (DataCheckError)

示例

>>> import pandas as pd

列‘dates’包含两组每日频率日期、两组每小时频率日期和两组每月频率日期。

>>> X = pd.DataFrame(pd.date_range("2015-01-01", periods=2).append(pd.date_range("2015-01-08", periods=2, freq="H").append(pd.date_range("2016-03-02", periods=2, freq="M"))), columns=["dates"])
>>> y = pd.Series([0, 1, 0, 1, 1, 0])
>>> datetime_format_dc = DateTimeFormatDataCheck(datetime_column="dates")
>>> assert datetime_format_dc.validate(X, y) == [
...     {
...         "message": "No frequency could be detected in column 'dates', possibly due to uneven intervals or too many duplicate/missing values.",
...         "data_check_name": "DateTimeFormatDataCheck",
...         "level": "error",
...         "code": "DATETIME_NO_FREQUENCY_INFERRED",
...         "details": {"columns": None, "rows": None},
...         "action_options": []
...      }
... ]

列“dates”的值中存在间隙，这意味着缺少许多日期。

>>> X = pd.DataFrame(pd.date_range("2021-01-01", periods=9).append(pd.date_range("2021-01-31", periods=50)), columns=["dates"])
>>> y = pd.Series([0, 1, 0, 1, 1, 0, 0, 0, 1, 0])
>>> ww_payload = infer_frequency(X["dates"], debug=True, window_length=5, threshold=0.8)
>>> datetime_format_dc = DateTimeFormatDataCheck(datetime_column="dates")
>>> assert datetime_format_dc.validate(X, y) == [
...     {
...         "message": "Column 'dates' has datetime values missing between start and end date.",
...         "data_check_name": "DateTimeFormatDataCheck",
...         "level": "error",
...         "code": "DATETIME_IS_MISSING_VALUES",
...         "details": {"columns": None, "rows": None},
...         "action_options": []
...      },
...     {
...         "message": "A frequency was detected in column 'dates', but there are faulty datetime values that need to be addressed.",
...         "data_check_name": "DateTimeFormatDataCheck",
...         "level": "error",
...         "code": "DATETIME_HAS_UNEVEN_INTERVALS",
...         "details": {'columns': None, 'rows': None},
...         "action_options": [
...             {
...                 'code': 'REGULARIZE_AND_IMPUTE_DATASET',
...                 'data_check_name': 'DateTimeFormatDataCheck',
...                 'metadata': {
...                         'columns': None,
...                         'is_target': True,
...                         'rows': None
...                 },
...                 'parameters': {
...                         'time_index': {
...                             'default_value': 'dates',
...                             'parameter_type': 'global',
...                             'type': 'str'
...                         },
...                         'frequency_payload': {
...                             'default_value': ww_payload,
...                             'parameter_type': 'global',
...                             'type': 'tuple'
...                         }
...                 }
...             }
...         ]
...     }
... ]

列“dates”在末尾重复了日期 2021-01-09，这被认为是冗余的，将引发错误。

>>> X = pd.DataFrame(pd.date_range("2021-01-01", periods=9).append(pd.date_range("2021-01-09", periods=1)), columns=["dates"])
>>> y = pd.Series([0, 1, 0, 1, 1, 0, 0, 0, 1, 0])
>>> ww_payload = infer_frequency(X["dates"], debug=True, window_length=5, threshold=0.8)
>>> datetime_format_dc = DateTimeFormatDataCheck(datetime_column="dates")
>>> assert datetime_format_dc.validate(X, y) == [
...     {
...         "message": "Column 'dates' has more than one row with the same datetime value.",
...         "data_check_name": "DateTimeFormatDataCheck",
...         "level": "error",
...         "code": "DATETIME_HAS_REDUNDANT_ROW",
...         "details": {"columns": None, "rows": None},
...         "action_options": []
...      },
...     {
...         "message": "A frequency was detected in column 'dates', but there are faulty datetime values that need to be addressed.",
...         "data_check_name": "DateTimeFormatDataCheck",
...         "level": "error",
...         "code": "DATETIME_HAS_UNEVEN_INTERVALS",
...         "details": {'columns': None, 'rows': None},
...         "action_options": [
...             {
...                 'code': 'REGULARIZE_AND_IMPUTE_DATASET',
...                 'data_check_name': 'DateTimeFormatDataCheck',
...                 'metadata': {
...                         'columns': None,
...                         'is_target': True,
...                         'rows': None
...                 },
...                 'parameters': {
...                         'time_index': {
...                             'default_value': 'dates',
...                             'parameter_type': 'global',
...                             'type': 'str'
...                         },
...                         'frequency_payload': {
...                             'default_value': ww_payload,
...                             'parameter_type': 'global',
...                             'type': 'tuple'
...                         }
...                 }
...             }
...         ]
...     }
... ]

列“Weeks”包含不符合每周模式的日期，这被认为是不对齐的。

>>> X = pd.DataFrame(pd.date_range("2021-01-01", freq="W", periods=12).append(pd.date_range("2021-03-22", periods=1)), columns=["Weeks"])
>>> ww_payload = infer_frequency(X["Weeks"], debug=True, window_length=5, threshold=0.8)
>>> datetime_format_dc = DateTimeFormatDataCheck(datetime_column="Weeks")
>>> assert datetime_format_dc.validate(X, y) == [
...     {
...         "message": "Column 'Weeks' has datetime values that do not align with the inferred frequency.",
...         "data_check_name": "DateTimeFormatDataCheck",
...         "level": "error",
...         "details": {"columns": None, "rows": None},
...         "code": "DATETIME_HAS_MISALIGNED_VALUES",
...         "action_options": []
...      },
...     {
...         "message": "A frequency was detected in column 'Weeks', but there are faulty datetime values that need to be addressed.",
...         "data_check_name": "DateTimeFormatDataCheck",
...         "level": "error",
...         "code": "DATETIME_HAS_UNEVEN_INTERVALS",
...         "details": {'columns': None, 'rows': None},
...         "action_options": [
...             {
...                 'code': 'REGULARIZE_AND_IMPUTE_DATASET',
...                 'data_check_name': 'DateTimeFormatDataCheck',
...                 'metadata': {
...                         'columns': None,
...                         'is_target': True,
...                         'rows': None
...                 },
...                 'parameters': {
...                         'time_index': {
...                             'default_value': 'Weeks',
...                             'parameter_type': 'global',
...                             'type': 'str'
...                         },
...                         'frequency_payload': {
...                             'default_value': ww_payload,
...                             'parameter_type': 'global',
...                             'type': 'tuple'
...                         }
...                 }
...             }
...         ]
...     }
... ]

列“Weeks”传入的是整数而不是日期时间数据，这将引发错误。

>>> X = pd.DataFrame([1, 2, 3, 4], columns=["Weeks"])
>>> y = pd.Series([0] * 4)
>>> datetime_format_dc = DateTimeFormatDataCheck(datetime_column="Weeks")
>>> assert datetime_format_dc.validate(X, y) == [
...     {
...         "message": "Datetime information could not be found in the data, or was not in a supported datetime format.",
...         "data_check_name": "DateTimeFormatDataCheck",
...         "level": "error",
...         "details": {"columns": None, "rows": None},
...         "code": "DATETIME_INFORMATION_NOT_FOUND",
...         "action_options": []
...      }
... ]

但是，将相同的整数数据转换为日期时间是有效的。

>>> X = pd.DataFrame(pd.to_datetime([1, 2, 3, 4]), columns=["Weeks"])
>>> datetime_format_dc = DateTimeFormatDataCheck(datetime_column="Weeks")
>>> assert datetime_format_dc.validate(X, y) == []

>>> X = pd.DataFrame(pd.date_range("2021-01-01", freq="W", periods=10), columns=["Weeks"])
>>> datetime_format_dc = DateTimeFormatDataCheck(datetime_column="Weeks")
>>> assert datetime_format_dc.validate(X, y) == []

虽然传入的数据是日期时间类型，但时间序列要求 datetime_column 中的日期时间信息单调递增（升序）。

>>> X = X.iloc[::-1]
>>> datetime_format_dc = DateTimeFormatDataCheck(datetime_column="Weeks")
>>> assert datetime_format_dc.validate(X, y) == [
...     {
...         "message": "Datetime values must be sorted in ascending order.",
...         "data_check_name": "DateTimeFormatDataCheck",
...         "level": "error",
...         "details": {"columns": None, "rows": None},
...         "code": "DATETIME_IS_NOT_MONOTONIC",
...         "action_options": []
...      }
... ]

列“index”中的第一个值被替换为 NaT，这将在本次数据检查中引发错误。

>>> dates = [["2-1-21", "3-1-21"],
...         ["2-2-21", "3-2-21"],
...         ["2-3-21", "3-3-21"],
...         ["2-4-21", "3-4-21"],
...         ["2-5-21", "3-5-21"],
...         ["2-6-21", "3-6-21"],
...         ["2-7-21", "3-7-21"],
...         ["2-8-21", "3-8-21"],
...         ["2-9-21", "3-9-21"],
...         ["2-10-21", "3-10-21"],
...         ["2-11-21", "3-11-21"],
...         ["2-12-21", "3-12-21"]]
>>> dates[0][0] = None
>>> df = pd.DataFrame(dates, columns=["days", "days2"])
>>> ww_payload = infer_frequency(pd.to_datetime(df["days"]), debug=True, window_length=5, threshold=0.8)
>>> datetime_format_dc = DateTimeFormatDataCheck(datetime_column="days")
>>> assert datetime_format_dc.validate(df, y) == [
...     {
...         "message": "Input datetime column 'days' contains NaN values. Please impute NaN values or drop these rows.",
...         "data_check_name": "DateTimeFormatDataCheck",
...         "level": "error",
...         "details": {"columns": None, "rows": None},
...         "code": "DATETIME_HAS_NAN",
...         "action_options": []
...      },
...     {
...         "message": "A frequency was detected in column 'days', but there are faulty datetime values that need to be addressed.",
...         "data_check_name": "DateTimeFormatDataCheck",
...         "level": "error",
...         "code": "DATETIME_HAS_UNEVEN_INTERVALS",
...         "details": {'columns': None, 'rows': None},
...         "action_options": [
...             {
...                 'code': 'REGULARIZE_AND_IMPUTE_DATASET',
...                 'data_check_name': 'DateTimeFormatDataCheck',
...                 'metadata': {
...                         'columns': None,
...                         'is_target': True,
...                         'rows': None
...                 },
...                 'parameters': {
...                         'time_index': {
...                             'default_value': 'days',
...                             'parameter_type': 'global',
...                             'type': 'str'
...                         },
...                         'frequency_payload': {
...                             'default_value': ww_payload,
...                             'parameter_type': 'global',
...                             'type': 'tuple'
...                         }
...                 }
...             }
...         ]
...     }
... ]

对于多序列，数据检查将遍历每个序列并执行与单序列情况类似的检查。要表示数据检查正在检查多序列，请将 series_id 列的名称传递给数据检查。

>>> X = pd.DataFrame(
...     {
...         "date": pd.date_range("2021-01-01", periods=15).repeat(2),
...         "series_id": pd.Series(list(range(2)) * 15, dtype="str")
...     }
... )
>>> X = X.drop([15])
>>> dc = DateTimeFormatDataCheck(datetime_column="date", series_id="series_id")
>>> ww_payload_expected_series1 = infer_frequency((X[X["series_id"] == "1"]["date"].reset_index(drop=True)), debug=True, window_length=4, threshold=0.4)
>>> xd = dc.validate(X,y)
>>> assert dc.validate(X, y) == [
...     {
...         "message": "Column 'date' for series '1' has datetime values missing between start and end date.",
...         "data_check_name": "DateTimeFormatDataCheck",
...         "level": "error",
...         "details": {"columns": None, "rows": None},
...         "code": "DATETIME_IS_MISSING_VALUES",
...         "action_options": []
...      },
...     {
...         "message": "A frequency was detected in column 'date' for series '1', but there are faulty datetime values that need to be addressed.",
...         "data_check_name": "DateTimeFormatDataCheck",
...         "level": "error",
...         "code": "DATETIME_HAS_UNEVEN_INTERVALS",
...         "details": {'columns': None, 'rows': None},
...         "action_options": [
...             {
...                 'code': 'REGULARIZE_AND_IMPUTE_DATASET',
...                 'data_check_name': 'DateTimeFormatDataCheck',
...                 'metadata': {
...                         'columns': None,
...                         'is_target': True,
...                         'rows': None
...                 },
...                 'parameters': {
...                         'time_index': {
...                             'default_value': 'date',
...                             'parameter_type': 'global',
...                             'type': 'str'
...                         },
...                         'frequency_payload': {
...                             'default_value': ww_payload_expected_series1,
...                             'parameter_type': 'global',
...                             'type': 'tuple'
...                         }
...                 }
...             }
...         ]
...     }
... ]

class evalml.data_checks.DCAOParameterAllowedValuesType[source]#

数据检查操作选项参数允许值类型的枚举。

属性

CATEGORICAL	分类允许值类型。参数具有一组允许值。
NUMERICAL	数值允许值类型。参数具有一个允许值范围。

方法

`name`	枚举成员的名称。
`value`	枚举成员的值。

name(self)#: 枚举成员的名称。

value(self)#: 枚举成员的值。

class evalml.data_checks.DCAOParameterType[source]#

数据检查操作选项参数类型的枚举。

属性

COLUMN	列参数类型。适用于数据集中特定列的参数。
GLOBAL	全局参数类型。适用于整个数据集的参数。

方法

`all_parameter_types`	获取所有已定义参数类型的列表。
`handle_dcao_parameter_type`	通过返回 DCAOParameterType 枚举或从字符串转换来处理数据检查操作选项参数类型。
`name`	枚举成员的名称。
`value`	枚举成员的值。

all_parameter_types(cls)#

获取所有已定义参数类型的列表。

返回: 所有已定义参数类型的列表。
返回类型: list(DCAOParameterType)

static handle_dcao_parameter_type(dcao_parameter_type)[source]#

通过返回 DCAOParameterType 枚举或从字符串转换来处理数据检查操作选项参数类型。

参数

dcao_parameter_type (str or DCAOParameterType) – 需要处理的数据检查操作选项参数类型。

返回

DCAOParameterType 枚举

引发

KeyError – 如果输入不是有效的 DCAOParameterType 枚举值。
ValueError – 如果输入不是字符串或 DCAOParameterType 对象。

name(self)#: 枚举成员的名称。

value(self)#: 枚举成员的值。

class evalml.data_checks.DefaultDataChecks(problem_type, objective, n_splits=3, problem_configuration=None)[source]#

AutoML 默认使用的一组基本数据检查。

包括

NullDataCheck

HighlyNullRowsDataCheck

IDColumnsDataCheck

TargetLeakageDataCheck

InvalidTargetDataCheck

NoVarianceDataCheck

ClassImbalanceDataCheck（用于分类问题类型）

TargetDistributionDataCheck（用于回归问题类型）

DateTimeFormatDataCheck（用于时间序列问题类型）

‘TimeSeriesParametersDataCheck’（用于时间序列问题类型）

TimeSeriesSplittingDataCheck（用于时间序列分类问题类型）

参数

problem_type (str) – 正在验证的问题类型。可以是 regression、binary 或 multiclass。
objective (str or ObjectiveBase) – 目标类的名称或实例。
n_splits (int) – 由所使用的数据拆分器确定的拆分次数。默认为 3。
problem_configuration (dict) – 时间序列问题类型必需。应为 time_index 传入值，
gap –
forecast_horizon –
max_delay. (and) –

方法

validate

根据数据检查检查和验证输入数据，并在适用时返回警告和错误列表。

validate(self, X, y=None)#

根据数据检查检查和验证输入数据，并在适用时返回警告和错误列表。

参数

X (pd.DataFrame, np.ndarray) – 输入数据，形状为 [n_samples, n_features]
y (pd.Series, np.ndarray) – 目标数据，长度为 [n_samples]

返回

包含 DataCheckMessage 对象的字典

返回类型

dict (DataCheckMessage)

class evalml.data_checks.IDColumnsDataCheck(id_threshold=1.0, exclude_time_index=True)[source]#

检查是否有任何特征可能是 ID 列。

参数

id_threshold (float) – 被视为 ID 列的概率阈值。默认为 1.0。
exclude_time_index (bool) – 如果为 True，则设置为时间索引的列将不包含在数据检查中。默认为 True。

方法

`name`	返回描述数据检查的名称。
`validate`	检查任何特征是否可能成为 ID 列。目前执行多项简单检查。

name(cls)#: 返回描述数据检查的名称。

validate(self, X, y=None)[source]#

检查任何特征是否可能成为 ID 列。目前执行多项简单检查。

执行的检查包括

列名称为“id”

列名称以“_id”结尾

列包含所有唯一值（并且是分类/整数类型）

参数

X (pd.DataFrame, np.ndarray) – 要检查的输入特征。
y (pd.Series) – 目标。默认为 None。被忽略。

返回

包含特征及其作为 ID 列的概率的字典，键为列名或索引

返回类型

dict (DataCheckMessage)

示例

>>> import pandas as pd

以“_id”结尾且完全唯一的列很可能是 ID 列。

>>> df = pd.DataFrame({
...     "profits": [25, 15, 15, 31, 19],
...     "customer_id": [123, 124, 125, 126, 127],
...     "Sales": [10, 42, 31, 51, 61]
... })
...
>>> id_col_check = IDColumnsDataCheck()
>>> assert id_col_check.validate(df) == [
...     {
...         "message": "Columns 'customer_id' are 100.0% or more likely to be an ID column",
...         "data_check_name": "IDColumnsDataCheck",
...         "level": "warning",
...         "code": "HAS_ID_COLUMN",
...         "details": {"columns": ["customer_id"], "rows": None},
...         "action_options": [
...             {
...                 "code": "DROP_COL",
...                 "data_check_name": "IDColumnsDataCheck",
...                 "parameters": {},
...                 "metadata": {"columns": ["customer_id"], "rows": None}
...             }
...         ]
...    }
... ]

名称为“ID”且所有值唯一的列也将被识别为 ID 列。

>>> df = df.rename(columns={"customer_id": "ID"})
>>> id_col_check = IDColumnsDataCheck()
>>> assert id_col_check.validate(df) == [
...     {
...         "message": "Columns 'ID' are 100.0% or more likely to be an ID column",
...         "data_check_name": "IDColumnsDataCheck",
...         "level": "warning",
...         "code": "HAS_ID_COLUMN",
...         "details": {"columns": ["ID"], "rows": None},
...         "action_options": [
...            {
...                 "code": "DROP_COL",
...                 "data_check_name": "IDColumnsDataCheck",
...                 "parameters": {},
...                 "metadata": {"columns": ["ID"], "rows": None}
...             }
...         ]
...     }
... ]

尽管所有值都是唯一的，但“Country_Rank”不会被识别为 ID 列，因为 id_threshold 默认设置为 1.0，并且其名称并未表明它是 ID 列。

>>> df = pd.DataFrame({
...    "humidity": ["high", "very high", "low", "low", "high"],
...    "Country_Rank": [1, 2, 3, 4, 5],
...    "Sales": ["very high", "high", "high", "medium", "very low"]
... })
...
>>> id_col_check = IDColumnsDataCheck()
>>> assert id_col_check.validate(df) == []

但是，降低阈值将导致此列被识别为 ID 列。

>>> id_col_check = IDColumnsDataCheck()
>>> id_col_check = IDColumnsDataCheck(id_threshold=0.95)
>>> assert id_col_check.validate(df) == [
...     {
...         "message": "Columns 'Country_Rank' are 95.0% or more likely to be an ID column",
...         "data_check_name": "IDColumnsDataCheck",
...         "level": "warning",
...         "details": {"columns": ["Country_Rank"], "rows": None},
...         "code": "HAS_ID_COLUMN",
...         "action_options": [
...             {
...                 "code": "DROP_COL",
...                 "data_check_name": "IDColumnsDataCheck",
...                 "parameters": {},
...                 "metadata": {"columns": ["Country_Rank"], "rows": None}
...             }
...         ]
...     }
... ]

如果 dataframe 的第一列具有所有唯一值，并且名称为“ID”或以“_id”结尾，则它很可能是主键。其他 ID 列应该被删除。

>>> df = pd.DataFrame({
...     "sales_id": [0, 1, 2, 3, 4],
...     "customer_id": [123, 124, 125, 126, 127],
...     "Sales": [10, 42, 31, 51, 61]
... })
...
>>> id_col_check = IDColumnsDataCheck()
>>> assert id_col_check.validate(df) == [
...     {
...         "message": "The first column 'sales_id' is likely to be the primary key",
...         "data_check_name": "IDColumnsDataCheck",
...         "level": "warning",
...         "code": "HAS_ID_FIRST_COLUMN",
...         "details": {"columns": ["sales_id"], "rows": None},
...         "action_options": [
...             {
...                 "code": "SET_FIRST_COL_ID",
...                 "data_check_name": "IDColumnsDataCheck",
...                 "parameters": {},
...                 "metadata": {"columns": ["sales_id"], "rows": None}
...             }
...         ]
...    },
...    {
...        "message": "Columns 'customer_id' are 100.0% or more likely to be an ID column",
...         "data_check_name": "IDColumnsDataCheck",
...         "level": "warning",
...         "code": "HAS_ID_COLUMN",
...         "details": {"columns": ["customer_id"], "rows": None},
...         "action_options": [
...             {
...                 "code": "DROP_COL",
...                 "data_check_name": "IDColumnsDataCheck",
...                 "parameters": {},
...                 "metadata": {"columns": ["customer_id"], "rows": None}
...             }
...         ]
...    }
... ]

class evalml.data_checks.InvalidTargetDataCheck(problem_type, objective, n_unique=100, null_strategy='drop')[source]#

检查目标数据是否被认为是无效的。

目标数据被认为是无效的，如果

目标为 None。
目标包含 NaN 或 None 值。
目标是 Woodwork 不支持的逻辑类型。
目标和特征具有不同的长度或索引。
分类问题中目标类的实例不足。
回归问题中目标不包含数值数据。

参数

problem_type (str or ProblemTypes) – 要进行数据检查的特定问题类型。例如 ‘binary’、‘multiclass’、‘regression’、‘time series regression’
objective (str or ObjectiveBase) – 目标类的名称或实例。
n_unique (int) – 当问题类型为 binary 且目标错误地包含多于 2 个唯一值时，存储的唯一目标值数量。非负整数。如果为 None，则存储所有唯一值。默认为 100。
null_strategy (str) – 如果目标部分为空，应返回的操作选项类型。选项包括 impute 和 drop（默认）。impute - 将返回一个 DataCheckActionOption 以进行目标列填充。drop - 将返回一个 DataCheckActionOption 以删除目标列中的空行。

属性

multiclass_continuous_threshold

0.05

方法

`name`	返回描述数据检查的名称。
`validate`	检查目标数据是否被认为是无效的。如果输入特征参数不为 None，则将用于检查目标和特征是否具有相同的维度和索引。

name(cls)#: 返回描述数据检查的名称。

validate(self, X, y)[source]#

检查目标数据是否被认为是无效的。如果输入特征参数不为 None，则将用于检查目标和特征是否具有相同的维度和索引。

目标数据被认为是无效的，如果

目标为 None。
目标包含 NaN 或 None 值。
目标是 Woodwork 不支持的逻辑类型。
目标和特征具有不同的长度或索引。
分类问题中目标类的实例不足。
回归问题中目标不包含数值数据。

参数

X (pd.DataFrame, np.ndarray) – 特征。如果不是 None，将用于检查目标和特征是否具有相同的维度和索引。
y (pd.Series, np.ndarray) – 用于检查无效值的目标数据。

返回

如果在目标数据中发现任何无效值，则返回包含 DataCheckErrors 的列表。

返回类型

dict (DataCheckError)

示例

>>> import pandas as pd

目标值必须是整数、双精度浮点数或布尔值。

>>> X = pd.DataFrame({"col": [1, 2, 3, 1]})
>>> y = pd.Series(["cat_1", "cat_2", "cat_1", "cat_2"])
>>> target_check = InvalidTargetDataCheck("regression", "R2", null_strategy="impute")
>>> assert target_check.validate(X, y) == [
...     {
...         "message": "Target is unsupported Unknown type. Valid Woodwork logical types include: integer, double, boolean, age, age_fractional, integer_nullable, boolean_nullable, age_nullable",
...         "data_check_name": "InvalidTargetDataCheck",
...         "level": "error",
...         "details": {"columns": None, "rows": None, "unsupported_type": "unknown"},
...         "code": "TARGET_UNSUPPORTED_TYPE",
...         "action_options": []
...     },
...     {
...         "message": "Target data type should be numeric for regression type problems.",
...         "data_check_name": "InvalidTargetDataCheck",
...         "level": "error",
...         "details": {"columns": None, "rows": None},
...         "code": "TARGET_UNSUPPORTED_TYPE_REGRESSION",
...         "action_options": []
...     }
... ]

目标不能包含空值。

>>> y = pd.Series([None, pd.NA, pd.NaT, None])
>>> assert target_check.validate(X, y) == [
...     {
...         "message": "Target is either empty or fully null.",
...         "data_check_name": "InvalidTargetDataCheck",
...         "level": "error",
...         "details": {"columns": None, "rows": None},
...         "code": "TARGET_IS_EMPTY_OR_FULLY_NULL",
...         "action_options": []
...     }
... ]
...
...
>>> y = pd.Series([1, None, 3, None])
>>> assert target_check.validate(None, y) == [
...     {
...         "message": "2 row(s) (50.0%) of target values are null",
...         "data_check_name": "InvalidTargetDataCheck",
...         "level": "error",
...         "details": {
...             "columns": None,
...             "rows": [1, 3],
...             "num_null_rows": 2,
...             "pct_null_rows": 50.0
...         },
...         "code": "TARGET_HAS_NULL",
...         "action_options": [
...            {
...                 "code": "IMPUTE_COL",
...                 "data_check_name": "InvalidTargetDataCheck",
...                 "parameters": {
...                     "impute_strategy": {
...                         "parameter_type": "global",
...                         "type": "category",
...                         "categories": ["mean", "most_frequent"],
...                         "default_value": "mean"
...                     }
...                 },
...                 "metadata": {"columns": None, "rows": None, "is_target": True},
...             }
...         ],
...     }
... ]

如果目标值与传入的问题类型不匹配，将引发错误。在此情况下，目标列中只有两个值，但传入的问题类型是 multiclass。

>>> X = pd.DataFrame([i for i in range(50)])
>>> y = pd.Series([i%2 for i in range(50)])
>>> target_check = InvalidTargetDataCheck("multiclass", "Log Loss Multiclass")
>>> assert target_check.validate(X, y) == [
...     {
...         "message": "Target has two or less classes, which is too few for multiclass problems.  Consider changing to binary.",
...         "data_check_name": "InvalidTargetDataCheck",
...         "level": "error",
...         "details": {"columns": None, "rows": None, "num_classes": 2},
...         "code": "TARGET_MULTICLASS_NOT_ENOUGH_CLASSES",
...         "action_options": []
...     }
... ]

如果 X 和 y 的长度不同，将引发警告。对于不匹配的索引，也将引发警告。

>>> target_check = InvalidTargetDataCheck("regression", "R2")
>>> X = pd.DataFrame([i for i in range(5)])
>>> y = pd.Series([1, 2, 4, 3], index=[1, 2, 4, 3])
>>> assert target_check.validate(X, y) == [
...     {
...         "message": "Input target and features have different lengths",
...         "data_check_name": "InvalidTargetDataCheck",
...         "level": "warning",
...         "details": {"columns": None, "rows": None, "features_length": 5, "target_length": 4},
...         "code": "MISMATCHED_LENGTHS",
...         "action_options": []
...     },
...     {
...         "message": "Input target and features have mismatched indices. Details will include the first 10 mismatched indices.",
...         "data_check_name": "InvalidTargetDataCheck",
...         "level": "warning",
...         "details": {
...             "columns": None,
...             "rows": None,
...             "indices_not_in_features": [],
...             "indices_not_in_target": [0]
...         },
...         "code": "MISMATCHED_INDICES",
...         "action_options": []
...     }
... ]

class evalml.data_checks.MismatchedSeriesLengthDataCheck(series_id)[source]#

检查多序列数据集中的一个或多个唯一序列的长度是否与其他序列不同。

目前专门处理堆叠数据

参数: series_id (str) – 数据集的 series_id 列的名称。

方法

`name`	返回描述数据检查的名称。
`validate`	检查多序列数据集中的一个或多个唯一序列的长度是否与其他序列不同。

name(cls)#: 返回描述数据检查的名称。

validate(self, X, y=None)[source]#

检查多序列数据集中的一个或多个唯一序列的长度是否与其他序列不同。

目前专门处理堆叠数据

参数

X (pd.DataFrame, np.ndarray) – 要检查的输入特征。必须包含 series_id 列。
y (pd.Series) – 目标。默认为 None。被忽略。

返回

如果数据集中存在序列长度不匹配，则返回包含 DataCheckWarning 的列表: 如果给定 series_id 不在数据集中，则返回包含 DataCheckError 的列表

返回类型

dict (DataCheckWarning, DataCheckError)

示例

>>> import pandas as pd

对于多序列时间序列数据集，理想情况下每个 seriesID 应具有相同数量的日期时间条目。如果不一致，则将引发警告，指示哪些 seriesID 的长度不匹配。

>>> X = pd.DataFrame(
...     {
...         "date": pd.date_range(start="1/1/2018", periods=20).repeat(5),
...         "series_id": pd.Series(list(range(5)) * 20, dtype="str"),
...         "feature_a": range(100),
...         "feature_b": reversed(range(100)),
...     },
... )
>>> X = X.drop(labels=0, axis=0)
>>> mismatched_series_length_check = MismatchedSeriesLengthDataCheck("series_id")
>>> assert mismatched_series_length_check.validate(X) == [
...      {
...         "message": "Series ID ['0'] do not match the majority length of the other series, which is 20",
...         "data_check_name": "MismatchedSeriesLengthDataCheck",
...         "level": "warning",
...         "details": {
...             "columns": None,
...             "rows": None,
...             "series_id": ['0'],
...             "majority_length": 20
...         },
...         "code": "MISMATCHED_SERIES_LENGTH",
...         "action_options": [],
...     }
... ]

如果 MismatchedSeriesLengthDataCheck 传入了无效的 series_id 列名，则将引发错误。

>>> X = pd.DataFrame(
...     {
...         "date": pd.date_range(start="1/1/2018", periods=20).repeat(5),
...         "series_id": pd.Series(list(range(5)) * 20, dtype="str"),
...         "feature_a": range(100),
...         "feature_b": reversed(range(100)),
...     },
... )
>>> X = X.drop(labels=0, axis=0)
>>> mismatched_series_length_check = MismatchedSeriesLengthDataCheck("not_series_id")
>>> assert mismatched_series_length_check.validate(X) == [
...      {
...         "message": "series_id 'not_series_id' is not in the dataset.",
...         "data_check_name": "MismatchedSeriesLengthDataCheck",
...         "level": "error",
...         "details": {
...             "columns": None,
...             "rows": None,
...             "series_id": "not_series_id",
...         },
...         "code": "INVALID_SERIES_ID_COL",
...         "action_options": [],
...     }
... ]

如果存在多个长度具有相同数量的序列（例如，两个序列长度为 20，另两个序列长度为 19），则此数据检查会将较长的长度视为多数长度（例如，在前面的例子中，长度 20 将是多数长度） >>> X = pd.DataFrame( … { … “date”: pd.date_range(start=”1/1/2018”, periods=20).repeat(4), … “series_id”: pd.Series(list(range(4)) * 20, dtype=”str”), … “feature_a”: range(80), … “feature_b”: reversed(range(80)), … }, … ) >>> X = X.drop(labels=[0, 1], axis=0) >>> mismatched_series_length_check = MismatchedSeriesLengthDataCheck(“series_id”) >>> assert mismatched_series_length_check.validate(X) == [ … { … “message”: “Series ID [‘0’, ‘1’] do not match the majority length of the other series, which is 20”, … “data_check_name”: “MismatchedSeriesLengthDataCheck”, … “level”: “warning”, … “details”: { … “columns”: None, … “rows”: None, … “series_id”: [‘0’, ‘1’], … “majority_length”: 20 … }, … “code”: “MISMATCHED_SERIES_LENGTH”, … “action_options”: [], … } … ]

class evalml.data_checks.MulticollinearityDataCheck(threshold=0.9)[source]#

检查任何一组特征是否可能存在多重共线性。

参数: threshold (float) – 要考虑的阈值。默认为 0.9。

方法

`name`	返回描述数据检查的名称。
`validate`	检查任何一组特征是否可能存在多重共线性。

name(cls)#: 返回描述数据检查的名称。

validate(self, X, y=None)[source]#

检查任何一组特征是否可能存在多重共线性。

参数

X (pd.DataFrame) – 要检查的输入特征。
y (pd.Series) – 目标。被忽略。

返回

如果存在任何潜在的多重共线性列，则返回包含 DataCheckWarning 的字典。

返回类型

dict (DataCheckMessage)

示例

>>> import pandas as pd

使用互信息识别 X 中彼此高度相关的列。

>>> col = pd.Series([1, 0, 2, 3, 4] * 15)
>>> X = pd.DataFrame({"col_1": col, "col_2": col * 3})
>>> y = pd.Series([1, 0, 0, 1, 0] * 15)
...
>>> multicollinearity_check = MulticollinearityDataCheck(threshold=1.0)
>>> assert multicollinearity_check.validate(X, y) == [
...     {
...         "message": "Columns are likely to be correlated: [('col_1', 'col_2')]",
...         "data_check_name": "MulticollinearityDataCheck",
...         "level": "warning",
...         "code": "IS_MULTICOLLINEAR",
...         "details": {"columns": [("col_1", "col_2")], "rows": None},
...         "action_options": []
...     }
... ]

class evalml.data_checks.NoVarianceDataCheck(count_nan_as_value=False)[source]#

检查目标或任何特征是否没有方差。

参数: count_nan_as_value (bool) – 如果为 True，缺失值将被计为自身的唯一值。此外，如果为 True，如果特征主要包含缺失数据且只有一个唯一值，则将返回 DataCheckWarning 而不是错误。默认为 False。

方法

`name`	返回描述数据检查的名称。
`validate`	检查目标或任何特征是否没有方差（1 个唯一值）。

name(cls)#: 返回描述数据检查的名称。

validate(self, X, y=None)[source]#

检查目标或任何特征是否没有方差（1 个唯一值）。

参数

X (pd.DataFrame, np.ndarray) – 输入特征。
y (pd.Series, np.ndarray) – 可选，目标数据。

返回

针对没有方差的特征或目标的警告/错误的字典。

返回类型

dict (DataCheckMessage)

示例

>>> import pandas as pd

只有唯一值的列或目标数据将引发错误。

>>> X = pd.DataFrame([2, 2, 2, 2, 2, 2, 2, 2], columns=["First_Column"])
>>> y = pd.Series([1, 1, 1, 1, 1, 1, 1, 1])
...
>>> novar_dc = NoVarianceDataCheck()
>>> assert novar_dc.validate(X, y) == [
...     {
...         "message": "'First_Column' has 1 unique value.",
...         "data_check_name": "NoVarianceDataCheck",
...         "level": "warning",
...         "details": {"columns": ["First_Column"], "rows": None},
...         "code": "NO_VARIANCE",
...         "action_options": [
...             {
...                 "code": "DROP_COL",
...                 "data_check_name": "NoVarianceDataCheck",
...                 "parameters": {},
...                 "metadata": {"columns": ["First_Column"], "rows": None}
...             },
...         ]
...     },
...     {
...         "message": "Y has 1 unique value.",
...         "data_check_name": "NoVarianceDataCheck",
...         "level": "warning",
...         "details": {"columns": ["Y"], "rows": None},
...         "code": "NO_VARIANCE",
...         "action_options": []
...     }
... ]

默认情况下，NaNs 不会被计为不同值。在第一个示例中，除了 None 外，仍有两个不同值。在第二个示例中，没有不同值，因为目标完全为空。

>>> X["First_Column"] = [2, 2, 2, 3, 3, 3, None, None]
>>> y = pd.Series([1, 1, 1, 2, 2, 2, None, None])
>>> assert novar_dc.validate(X, y) == []
...
...
>>> y = pd.Series([None] * 7)
>>> assert novar_dc.validate(X, y) == [
...     {
...         "message": "Y has 0 unique values.",
...         "data_check_name": "NoVarianceDataCheck",
...         "level": "warning",
...         "details": {"columns": ["Y"], "rows": None},
...         "code": "NO_VARIANCE_ZERO_UNIQUE",
...         "action_options":[]
...     }
... ]

由于 None 默认不被视为不同值，因此 X 和 y 中只有一个唯一值。

>>> X["First_Column"] = [2, 2, 2, 2, None, None, None, None]
>>> y = pd.Series([1, 1, 1, 1, None, None, None, None])
>>> assert novar_dc.validate(X, y) == [
...     {
...         "message": "'First_Column' has 1 unique value.",
...         "data_check_name": "NoVarianceDataCheck",
...         "level": "warning",
...         "details": {"columns": ["First_Column"], "rows": None},
...         "code": "NO_VARIANCE",
...         "action_options": [
...             {
...                 "code": "DROP_COL",
...                  "data_check_name": "NoVarianceDataCheck",
...                  "parameters": {},
...                  "metadata": {"columns": ["First_Column"], "rows": None}
...             },
...         ]
...     },
...     {
...         "message": "Y has 1 unique value.",
...         "data_check_name": "NoVarianceDataCheck",
...         "level": "warning",
...         "details": {"columns": ["Y"], "rows": None},
...         "code": "NO_VARIANCE",
...         "action_options": []
...     }
... ]

如果 count_nan_as_value 设置为 True，则 NaNs 被计为唯一值。如果仅因为 count_nan_as_value 设置为 True 而存在足够的唯一值，将引发警告，以便用户可以对这些值进行编码。

>>> novar_dc = NoVarianceDataCheck(count_nan_as_value=True)
>>> assert novar_dc.validate(X, y) == [
...     {
...         "message": "'First_Column' has two unique values including nulls. Consider encoding the nulls for this column to be useful for machine learning.",
...         "data_check_name": "NoVarianceDataCheck",
...         "level": "warning",
...         "details": {"columns": ["First_Column"], "rows": None},
...         "code": "NO_VARIANCE_WITH_NULL",
...         "action_options": [
...             {
...                 "code": "DROP_COL",
...                  "data_check_name": "NoVarianceDataCheck",
...                  "parameters": {},
...                  "metadata": {"columns": ["First_Column"], "rows": None}
...             },
...         ]
...     },
...     {
...         "message": "Y has two unique values including nulls. Consider encoding the nulls for this column to be useful for machine learning.",
...         "data_check_name": "NoVarianceDataCheck",
...         "level": "warning",
...         "details": {"columns": ["Y"], "rows": None},
...         "code": "NO_VARIANCE_WITH_NULL",
...         "action_options": []
...     }
... ]

class evalml.data_checks.NullDataCheck(pct_null_col_threshold=0.95, pct_moderately_null_col_threshold=0.2, pct_null_row_threshold=0.95)[source]#

检查输入中是否存在高度为空的数值、布尔、分类、自然语言和未知列以及行。

参数

pct_null_col_threshold (float) – 如果输入特征中 NaN 值的百分比超过此数值，则该列将被视为高度为空。默认为 0.95。
pct_moderately_null_col_threshold (float) – 如果输入特征中 NaN 值的百分比超过此数值但小于 pct_null_col_threshold 中指定的百分比，则该列将被视为中度为空。默认为 0.20。
pct_null_row_threshold (float) – 如果输入行中 NaN 值的百分比超过此数值，则该行将被视为高度为空。默认为 0.95。

方法

`get_null_column_information`	查找被视为高度为空的列（空值百分比大于阈值），并返回列名到空值百分比的字典以及列名到该列中空值索引的字典。
`get_null_row_information`	查找被视为高度为空的行（空值百分比大于阈值）。
`name`	返回描述数据检查的名称。
`validate`	检查输入中是否存在任何高度为空的列或行。

static get_null_column_information(X, pct_null_col_threshold=0.0)[source]#

查找被视为高度为空的列（空值百分比大于阈值），并返回列名到空值百分比的字典以及列名到该列中空值索引的字典。

参数

X (pd.DataFrame) – 用于检查高度空列的 DataFrame。
pct_null_col_threshold (float) – 列被视为空的百分比阈值。默认为 0.0。

返回

包含以下内容的元组：将列名映射到其空值百分比的字典，以及将列名映射到该列中空值索引的字典。

返回类型

tuple

static get_null_row_information(X, pct_null_row_threshold=0.0)[source]#

查找被视为高度为空的行（空值百分比大于阈值）。

参数

X (pd.DataFrame) – 用于检查包含大量空值的行的 DataFrame。
pct_null_row_threshold (float) – 行被视为包含空值的百分比阈值。默认为 0.0。

返回

包含每行空值百分比的 Series。

返回类型

pd.Series

name(cls)#: 返回描述数据检查的名称。

validate(self, X, y=None)[source]#

检查输入中是否存在任何高度为空的列或行。

参数

X (pd.DataFrame, np.ndarray) – 特征。
y (pd.Series, np.ndarray) – 忽略。默认为 None。

返回

如果存在任何包含大量空值的列或行，则返回带有 DataCheckWarning 的字典。

返回类型

dict (DataCheckMessage)

示例

>>> import pandas as pd
...
>>> class SeriesWrap():
...     def __init__(self, series):
...         self.series = series
...
...     def __eq__(self, series_2):
...         return all(self.series.eq(series_2.series))

将 pct_null_col_threshold 设置为 0.50 时，任何具有 50% 或更多观测值为 null 的列将包含在警告中，以及已识别的 null 值百分比（“all_null”：1.0，“lots_of_null”：0.8）。

>>> df = pd.DataFrame({
...     "all_null": [None, pd.NA, None, None, None],
...     "lots_of_null": [None, None, None, None, 5],
...     "few_null": [1, 2, None, 2, 3],
...     "no_null": [1, 2, 3, 4, 5]
... })
...
>>> highly_null_dc = NullDataCheck(pct_null_col_threshold=0.50)
>>> assert highly_null_dc.validate(df) == [
...     {
...         "message": "Column(s) 'all_null', 'lots_of_null' are 50.0% or more null",
...         "data_check_name": "NullDataCheck",
...         "level": "warning",
...         "details": {
...             "columns": ["all_null", "lots_of_null"],
...             "rows": None,
...             "pct_null_rows": {"all_null": 1.0, "lots_of_null": 0.8}
...         },
...         "code": "HIGHLY_NULL_COLS",
...         "action_options": [
...             {
...                 "code": "DROP_COL",
...                 "data_check_name": "NullDataCheck",
...                 "parameters": {},
...                 "metadata": {"columns": ["all_null", "lots_of_null"], "rows": None}
...             }
...         ]
...     },
...     {
...         "message": "Column(s) 'few_null' have between 20.0% and 50.0% null values",
...         "data_check_name": "NullDataCheck",
...         "level": "warning",
...         "details": {"columns": ["few_null"], "rows": None},
...         "code": "COLS_WITH_NULL",
...         "action_options": [
...             {
...                 "code": "IMPUTE_COL",
...                 "data_check_name": "NullDataCheck",
...                 "metadata": {"columns": ["few_null"], "rows": None, "is_target": False},
...                 "parameters": {
...                     "impute_strategies": {
...                         "parameter_type": "column",
...                         "columns": {
...                             "few_null": {
...                                 "impute_strategy": {"categories": ["mean", "most_frequent"], "type": "category", "default_value": "mean"}
...                             }
...                         }
...                     }
...                 }
...             }
...         ]
...     }
... ]

将 pct_null_row_threshold 设置为 0.50 时，任何其相应列值有 50% 或更多设置为 null 的行将包含在警告中，以及有问题的行（“rows”：[0, 1, 2, 3]）。由于 pct_null_col_threshold 的默认值为 0.95，“all_null”也包含在警告中，因为该行中的 null 值百分比超过 95%。由于 pct_moderately_null_col_threshold 的默认值为 0.20，“few_null”作为“中度空值”列包含在内，因为它具有 20% 的 null 列百分比。

>>> highly_null_dc = NullDataCheck(pct_null_row_threshold=0.50)
>>> validation_messages = highly_null_dc.validate(df)
>>> validation_messages[0]["details"]["pct_null_cols"] = SeriesWrap(validation_messages[0]["details"]["pct_null_cols"])
>>> highly_null_rows = SeriesWrap(pd.Series([0.5, 0.5, 0.75, 0.5]))
>>> assert validation_messages == [
...     {
...         "message": "4 out of 5 rows are 50.0% or more null",
...         "data_check_name": "NullDataCheck",
...         "level": "warning",
...         "details": {
...             "columns": None,
...             "rows": [0, 1, 2, 3],
...             "pct_null_cols": highly_null_rows
...         },
...         "code": "HIGHLY_NULL_ROWS",
...         "action_options": [
...             {
...                 "code": "DROP_ROWS",
...                  "data_check_name": "NullDataCheck",
...                  "parameters": {},
...                  "metadata": {"columns": None, "rows": [0, 1, 2, 3]}
...              }
...         ]
...     },
...     {
...         "message": "Column(s) 'all_null' are 95.0% or more null",
...         "data_check_name": "NullDataCheck",
...         "level": "warning",
...         "details": {
...             "columns": ["all_null"],
...             "rows": None,
...             "pct_null_rows": {"all_null": 1.0}
...         },
...        "code": "HIGHLY_NULL_COLS",
...        "action_options": [
...             {
...                 "code": "DROP_COL",
...                 "data_check_name": "NullDataCheck",
...                 "metadata": {"columns": ["all_null"], "rows": None},
...                 "parameters": {}
...             }
...         ]
...     },
...     {
...         "message": "Column(s) 'lots_of_null', 'few_null' have between 20.0% and 95.0% null values",
...         "data_check_name": "NullDataCheck",
...         "level": "warning",
...         "details": {"columns": ["lots_of_null", "few_null"], "rows": None},
...         "code": "COLS_WITH_NULL",
...         "action_options": [
...             {
...                "code": "IMPUTE_COL",
...                "data_check_name": "NullDataCheck",
...                "metadata": {"columns": ["lots_of_null", "few_null"], "rows": None, "is_target": False},
...                "parameters": {
...                    "impute_strategies": {
...                        "parameter_type": "column",
...                        "columns": {
...                            "lots_of_null": {"impute_strategy": {"categories": ["mean", "most_frequent"], "type": "category", "default_value": "mean"}},
...                            "few_null": {"impute_strategy": {"categories": ["mean", "most_frequent"], "type": "category", "default_value": "mean"}}
...                        }
...                    }
...                }
...             }
...         ]
...     }
... ]

class evalml.data_checks.OutliersDataCheck[source]#

使用 IQR 检测输入数据中是否存在异常值，以确定得分异常。

具有分数异常的列被认为包含离群值。

方法

`get_boxplot_data`	返回给定数据的箱线图信息。
`name`	返回描述数据检查的名称。
`validate`	通过使用 IQR 确定列异常来检查 dataframe 中是否存在任何离群值。具有异常的列被认为包含离群值。

static get_boxplot_data(data_)[source]#

返回给定数据的箱线图信息。

参数: data (pd.Series, np.ndarray) – 输入数据。
返回: 箱线图统计数据的负载。
返回类型: dict (DataCheckMessage)

示例

>>> import pandas as pd
...
>>> df = pd.DataFrame({
...     "x": [1, 2, 3, 4, 5],
...     "y": [6, 7, 8, 9, 10],
...     "z": [-1, -2, -3, -1201, -4]
... })
>>> box_plot_data = OutliersDataCheck.get_boxplot_data(df["z"])
>>> box_plot_data["score"] = round(box_plot_data["score"], 2)
>>> assert box_plot_data == {
...     "score": 0.89,
...     "pct_outliers": 0.2,
...     "values": {"q1": -4.0,
...                "median": -3.0,
...                "q3": -2.0,
...                "low_bound": -7.0,
...                "high_bound": -1.0,
...                "low_values": [-1201],
...                "high_values": [],
...                "low_indices": [3],
...                "high_indices": []}
...     }

name(cls)#: 返回描述数据检查的名称。

validate(self, X, y=None)[source]#

通过使用 IQR 确定列异常来检查 dataframe 中是否存在任何离群值。具有异常的列被认为包含离群值。

参数

X (pd.DataFrame, np.ndarray) – 输入特征。
y (pd.Series, np.ndarray) – 忽略。默认为 None。

返回

如果任何列存在离群值，则返回带有警告的字典。

返回类型

dict (DataCheckMessage)

示例

>>> import pandas as pd

列“z”有一个离群值，因此会添加一个警告来提醒用户其位置。

>>> df = pd.DataFrame({
...     "x": [1, 2, 3, 4, 5],
...     "y": [6, 7, 8, 9, 10],
...     "z": [-1, -2, -3, -1201, -4]
... })
...
>>> outliers_check = OutliersDataCheck()
>>> assert outliers_check.validate(df) == [
...     {
...         "message": "Column(s) 'z' are likely to have outlier data.",
...         "data_check_name": "OutliersDataCheck",
...         "level": "warning",
...         "code": "HAS_OUTLIERS",
...         "details": {"columns": ["z"], "rows": [3], "column_indices": {"z": [3]}},
...         "action_options": [
...             {
...                 "code": "DROP_ROWS",
...                  "data_check_name": "OutliersDataCheck",
...                  "parameters": {},
...                  "metadata": {"rows": [3], "columns": None}
...             }
...         ]
...     }
... ]

class evalml.data_checks.SparsityDataCheck(problem_type, threshold, unique_count_threshold=10)[source]#

检查输入中是否存在值填充稀疏的列。

参数

problem_type (str or ProblemTypes) – 要进行数据检查的特定问题类型。“multiclass”或“time series multiclass”是唯一接受的问题类型。
threshold (float) – 阈值，或每列唯一值的百分比，低于该百分比时，列表现出稀疏性。应介于 0 和 1 之间。
unique_count_threshold (int) – 唯一值在列中必须出现的最小次数，低于此次数则被视为“稀疏”。默认为 10。

方法

`name`	返回描述数据检查的名称。
`sparsity_score`	通过计算超出 count_threshold 的唯一值百分比来计算给定值计数的稀疏度分数。
`validate`	计算每列唯一值中超出计数阈值的百分比，并将该百分比与存储在类实例中的稀疏度阈值进行比较。

name(cls)#: 返回描述数据检查的名称。

static sparsity_score(col, count_threshold=10)[source]#

通过计算超出 count_threshold 的唯一值百分比来计算给定值计数的稀疏度分数。

参数

col (pd.Series) – 特征值。
count_threshold (int) – 值被视为稀疏的实例数阈值。默认为 10。

返回

稀疏度分数，即超出 count_threshold 的唯一值的百分比。

返回类型

(float)

validate(self, X, y=None)[source]#

计算每列唯一值中超出计数阈值的百分比，并将该百分比与存储在类实例中的稀疏度阈值进行比较。

参数

X (pd.DataFrame, np.ndarray) – 特征。
y (pd.Series, np.ndarray) – 忽略。

返回

如果存在任何稀疏列，则返回带有 DataCheckWarning 的字典。

返回类型

dict (DataCheckMessage)

示例

>>> import pandas as pd

对于多类问题，如果列中唯一值的表示不足，则将被视为稀疏。

>>> df = pd.DataFrame({
...    "sparse": [float(x) for x in range(100)],
...    "not_sparse": [float(1) for x in range(100)]
... })
...
>>> sparsity_check = SparsityDataCheck(problem_type="multiclass", threshold=0.5, unique_count_threshold=10)
>>> assert sparsity_check.validate(df) == [
...     {
...         "message": "Input columns ('sparse') for multiclass problem type are too sparse.",
...         "data_check_name": "SparsityDataCheck",
...         "level": "warning",
...         "code": "TOO_SPARSE",
...         "details": {
...             "columns": ["sparse"],
...             "sparsity_score": {"sparse": 0.0},
...             "rows": None
...         },
...         "action_options": [
...             {
...                 "code": "DROP_COL",
...                  "data_check_name": "SparsityDataCheck",
...                  "parameters": {},
...                  "metadata": {"columns": ["sparse"], "rows": None}
...             }
...         ]
...     }
... ]

… >>> df[“sparse”] = [float(x % 10) for x in range(100)] >>> sparsity_check = SparsityDataCheck(problem_type=”multiclass”, threshold=1, unique_count_threshold=5) >>> assert sparsity_check.validate(df) == [] … >>> sparse_array = pd.Series([1, 1, 1, 2, 2, 3] * 3) >>> assert SparsityDataCheck.sparsity_score(sparse_array, count_threshold=5) == 0.6666666666666666

class evalml.data_checks.TargetDistributionDataCheck[source]#

检查目标数据是否包含可能需要在训练前转换以提高模型性能的特定分布。当数据集样本数小于等于 5000 时使用 Shapiro-Wilks 检验，否则使用 Jarque-Bera 检验。

方法

`name`	返回描述数据检查的名称。
`validate`	检查目标数据是否具有特定分布。

name(cls)#: 返回描述数据检查的名称。

validate(self, X, y)[source]#

检查目标数据是否具有特定分布。

参数

X (pd.DataFrame, np.ndarray) – 特征。被忽略。
y (pd.Series, np.ndarray) – 要检查底层分布的目标数据。

返回

如果在目标数据中发现特定分布，则返回带有 DataCheckErrors 的列表。

返回类型

dict (DataCheckError)

示例

>>> import pandas as pd

呈现对数正态分布的目标将引发警告，提示用户对目标进行转换。

>>> y = [0.946, 0.972, 1.154, 0.954, 0.969, 1.222, 1.038, 0.999, 0.973, 0.897]
>>> target_check = TargetDistributionDataCheck()
>>> assert target_check.validate(None, y) == [
...     {
...         "message": "Target may have a lognormal distribution.",
...         "data_check_name": "TargetDistributionDataCheck",
...         "level": "warning",
...         "code": "TARGET_LOGNORMAL_DISTRIBUTION",
...         "details": {"normalization_method": "shapiro", "statistic": 0.8, "p-value": 0.045, "columns": None, "rows": None},
...         "action_options": [
...             {
...                 "code": "TRANSFORM_TARGET",
...                 "data_check_name": "TargetDistributionDataCheck",
...                 "parameters": {},
...                 "metadata": {
...                     "transformation_strategy": "lognormal",
...                     "is_target": True,
...                     "columns": None,
...                     "rows": None
...                 }
...             }
...         ]
...     }
... ]
...
>>> y = pd.Series([1, 1, 1, 2, 2, 3, 4, 4, 5, 5, 5])
>>> assert target_check.validate(None, y) == []
...
...
>>> y = pd.Series(pd.date_range("1/1/21", periods=10))
>>> assert target_check.validate(None, y) == [
...     {
...         "message": "Target is unsupported datetime type. Valid Woodwork logical types include: integer, double, age, age_fractional",
...         "data_check_name": "TargetDistributionDataCheck",
...         "level": "error",
...         "details": {"columns": None, "rows": None, "unsupported_type": "datetime"},
...         "code": "TARGET_UNSUPPORTED_TYPE",
...         "action_options": []
...     }
... ]

class evalml.data_checks.TargetLeakageDataCheck(pct_corr_threshold=0.95, method='all')[source]#

通过使用互信息、Pearson 相关系数和其他相关指标，检查任何特征是否与目标高度相关。

如果 method=’mutual_info’，则此数据检查使用互信息并支持所有目标和特征类型。其他相关性指标仅支持带有数值和布尔 dtype 的二元数据。如果选择了其他相关性指标，此方法将返回 [-1, 1] 范围内的值；如果选择了互信息，则返回 [0, 1] 范围内的值。可用的相关性指标可以在 Woodwork 的 dependence_dict 方法中找到。

参数

pct_corr_threshold (float) – 被视为数据泄露的相关性阈值。默认为 0.95。
method (string) – 确定相关性的方法。使用“all”或“max”获取最大相关性，或对于特定的相关性指标，使用其名称（例如，互信息使用“mutual_info”，Pearson 相关性使用“pearson”等）。可用的方法可以在 Woodwork 的配置中找到，在 correlation_metrics 下。默认为“all”。

方法

`name`	返回描述数据检查的名称。
`validate`	通过使用互信息、Pearson 相关性或 Spearman 相关性，检查任何特征是否与目标高度相关。

name(cls)#: 返回描述数据检查的名称。

validate(self, X, y)[source]#

通过使用互信息、Pearson 相关性或 Spearman 相关性，检查任何特征是否与目标高度相关。

如果 method='mutual_info' 或 method='max'，支持所有目标和特征类型。其他相关性指标仅支持带有数值和布尔 dtype 的二元数据。如果选择了其他相关性指标，此方法将返回 [-1, 1] 范围内的值；如果选择了互信息，则返回 [0, 1] 范围内的值。

参数

X (pd.DataFrame, np.ndarray) – 要检查的输入特征。
y (pd.Series, np.ndarray) – 目标数据。

返回

如果检测到目标数据泄露，则返回带有 DataCheckWarning 的字典。

返回类型

dict (DataCheckWarning)

示例

>>> import pandas as pd

任何与目标强相关的列将引发警告。这可能表明存在数据泄露。

>>> X = pd.DataFrame({
...    "leak": [10, 42, 31, 51, 61] * 15,
...    "x": [42, 54, 12, 64, 12] * 15,
...    "y": [13, 5, 13, 74, 24] * 15,
... })
>>> y = pd.Series([10, 42, 31, 51, 40] * 15)
...
>>> target_leakage_check = TargetLeakageDataCheck(pct_corr_threshold=0.95)
>>> assert target_leakage_check.validate(X, y) == [
...     {
...         "message": "Column 'leak' is 95.0% or more correlated with the target",
...         "data_check_name": "TargetLeakageDataCheck",
...         "level": "warning",
...         "code": "TARGET_LEAKAGE",
...         "details": {"columns": ["leak"], "rows": None},
...         "action_options": [
...             {
...                 "code": "DROP_COL",
...                 "data_check_name": "TargetLeakageDataCheck",
...                 "parameters": {},
...                 "metadata": {"columns": ["leak"], "rows": None}
...             }
...         ]
...     }
... ]

默认方法可以从 mutual_info 更改为 pearson。

>>> X["x"] = y / 2
>>> target_leakage_check = TargetLeakageDataCheck(pct_corr_threshold=0.8, method="pearson")
>>> assert target_leakage_check.validate(X, y) == [
...     {
...         "message": "Columns 'leak', 'x' are 80.0% or more correlated with the target",
...         "data_check_name": "TargetLeakageDataCheck",
...         "level": "warning",
...         "details": {"columns": ["leak", "x"], "rows": None},
...         "code": "TARGET_LEAKAGE",
...         "action_options": [
...             {
...                 "code": "DROP_COL",
...                  "data_check_name": "TargetLeakageDataCheck",
...                  "parameters": {},
...                  "metadata": {"columns": ["leak", "x"], "rows": None}
...             }
...         ]
...     }
... ]

class evalml.data_checks.TimeSeriesParametersDataCheck(problem_configuration, n_splits)[source]#

检查时间序列参数是否与数据拆分兼容。

如果 gap + max_delay + forecast_horizon > X.shape[0] // (n_splits + 1)

则特征工程窗口大于最小的分割块。这将导致管道从不存在的数据创建特征，从而导致错误。

参数

problem_configuration (dict) – 包含 problem_configuration 参数的字典。
n_splits (int) – 时间序列分割数。

方法

`name`	返回描述数据检查的名称。
`validate`	检查时间序列参数是否与数据分割兼容。

name(cls)#: 返回描述数据检查的名称。

validate(self, X, y=None)[source]#

检查时间序列参数是否与数据分割兼容。

参数

X (pd.DataFrame, np.ndarray) – 特征。
y (pd.Series, np.ndarray) – 忽略。默认为 None。

返回

如果参数对于分割大小过大，则返回带有 DataCheckError 的字典。

返回类型

dict (DataCheckMessage)

示例

>>> import pandas as pd

时间序列参数必须与传入的数据兼容。如果窗口大小 (gap + max_delay + forecast_horizon) 大于或等于分割大小，则会引发错误。

>>> X = pd.DataFrame({
...    "dates": pd.date_range("1/1/21", periods=100),
...    "first": [i for i in range(100)],
... })
>>> y = pd.Series([i for i in range(100)])
...
>>> problem_config = {"gap": 7, "max_delay": 2, "forecast_horizon": 12, "time_index": "dates"}
>>> ts_parameters_check = TimeSeriesParametersDataCheck(problem_configuration=problem_config, n_splits=7)
>>> assert ts_parameters_check.validate(X, y) == [
...     {
...         "message": "Since the data has 100 observations, n_splits=7, and a forecast horizon of 12, the smallest "
...                    "split would have 16 observations. Since 21 (gap + max_delay + forecast_horizon)"
...                    " >= 16, then at least one of the splits would be empty by the time it reaches "
...                    "the pipeline. Please use a smaller number of splits, reduce one or more these "
...                    "parameters, or collect more data.",
...         "data_check_name": "TimeSeriesParametersDataCheck",
...         "level": "error",
...         "code": "TIMESERIES_PARAMETERS_NOT_COMPATIBLE_WITH_SPLIT",
...         "details": {
...             "columns": None,
...             "rows": None,
...             "max_window_size": 21,
...             "min_split_size": 16,
...             "n_obs": 100,
...             "n_splits": 7
...         },
...         "action_options": []
...     }
... ]

class evalml.data_checks.TimeSeriesSplittingDataCheck(problem_type, n_splits)[source]#

检查时间序列目标数据是否与拆分兼容。

如果每次分割的训练和验证中的目标数据没有包含所有类别的代表（对于时间序列分类问题），这将阻止估计器在所有潜在结果上进行训练，从而在预测过程中导致错误。

参数

problem_type (str or ProblemTypes) – 问题类型。
n_splits (int) – 时间序列分割数。

方法

`name`	返回描述数据检查的名称。
`validate`	检查训练和验证目标是否与时间序列数据分割兼容。

name(cls)#: 返回描述数据检查的名称。

validate(self, X, y)[source]#

检查训练和验证目标是否与时间序列数据分割兼容。

参数

X (pd.DataFrame, np.ndarray) – 忽略。特征。
y (pd.Series, np.ndarray) – 目标数据。

返回

如果分割会导致类别表示不足，则返回带有 DataCheckError 的字典。

返回类型

dict (DataCheckMessage)

示例

>>> import pandas as pd

将 n_splits 传递为 3 意味着数据将被分成 4 部分，用于训练和验证分割的迭代。第一次分割的训练索引为 [0:25]，验证索引为 [25:50]。第一次分割的训练索引仅产生一个唯一值 (0)。第三次分割的训练索引为 [0:75]，验证索引为 [75:100]。第三次分割的验证索引仅产生一个唯一值 (1)。

>>> X = None
>>> y = pd.Series([0 if i < 45 else i % 2 if i < 55 else 1 for i in range(100)])
>>> ts_splitting_check = TimeSeriesSplittingDataCheck("time series binary", 3)
>>> assert ts_splitting_check.validate(X, y) == [
...     {
...         "message": "Time Series Binary and Time Series Multiclass problem "
...                    "types require every training and validation split to "
...                    "have at least one instance of all the target classes. "
...                    "The following splits are invalid: [1, 3]",
...         "data_check_name": "TimeSeriesSplittingDataCheck",
...         "level": "error",
...         "details": {
...             "columns": None, "rows": None,
...             "invalid_splits": {
...                 1: {"Training": [0, 25]},
...                 3: {"Validation": [75, 100]}
...             }
...         },
...         "code": "TIMESERIES_TARGET_NOT_COMPATIBLE_WITH_SPLIT",
...         "action_options": []
...     }
... ]

class evalml.data_checks.UniquenessDataCheck(problem_type, threshold=0.5)[source]#

检查输入中是否存在对于分类问题来说过于唯一或对于回归问题来说不够唯一的列。

参数

problem_type (str or ProblemTypes) – 要进行数据检查的特定问题类型。例如 ‘binary’、‘multiclass’、‘regression’、‘time series regression’
threshold (float) – 对于分类问题，设置为唯一性的上限阈值；对于回归问题，设置为下限阈值。默认为 0.50。

方法

`name`	返回描述数据检查的名称。
`uniqueness_score`	计算所提供字段的唯一性分数。在计算中不将 NaN 值视为唯一值。
`validate`	检查输入中是否存在对于分类问题来说过于唯一或对于回归问题来说不够唯一的列。

name(cls)#: 返回描述数据检查的名称。

static uniqueness_score(col, drop_na=True)[source]#

计算所提供字段的唯一性分数。在计算中不将 NaN 值视为唯一值。

基于赫芬达尔-赫希曼指数。

参数

col (pd.Series) – 特征值。
drop_na (bool) – 计算唯一性分数时是否删除 null 值。默认为 True。

返回

唯一性分数。

返回类型

(float)

validate(self, X, y=None)[source]#

检查输入中是否存在对于分类问题来说过于唯一或对于回归问题来说不够唯一的列。

参数

X (pd.DataFrame, np.ndarray) – 特征。
y (pd.Series, np.ndarray) – 忽略。默认为 None。

返回

如果存在任何过于唯一或不: 够唯一的列，则返回带有 DataCheckWarning 的字典。

返回类型

dict (DataCheckMessage)

示例

>>> import pandas as pd

由于问题类型是回归，“regression_not_unique_enough”列因为只有一个值而引发警告。

>>> df = pd.DataFrame({
...    "regression_unique_enough": [float(x) for x in range(100)],
...    "regression_not_unique_enough": [float(1) for x in range(100)]
... })
...
>>> uniqueness_check = UniquenessDataCheck(problem_type="regression", threshold=0.8)
>>> assert uniqueness_check.validate(df) == [
...     {
...         "message": "Input columns 'regression_not_unique_enough' for regression problem type are not unique enough.",
...         "data_check_name": "UniquenessDataCheck",
...         "level": "warning",
...         "code": "NOT_UNIQUE_ENOUGH",
...         "details": {"columns": ["regression_not_unique_enough"], "uniqueness_score": {"regression_not_unique_enough": 0.0}, "rows": None},
...         "action_options": [
...             {
...                 "code": "DROP_COL",
...                 "parameters": {},
...                 "data_check_name": "UniquenessDataCheck",
...                 "metadata": {"columns": ["regression_not_unique_enough"], "rows": None}
...             }
...         ]
...     }
... ]

对于多类问题，“regression_unique_enough”列具有太多唯一值，将引发相应的警告。 >>> y = pd.Series([1, 1, 1, 2, 2, 3, 3, 3]) >>> uniqueness_check = UniquenessDataCheck(problem_type=”multiclass”, threshold=0.8) >>> assert uniqueness_check.validate(df) == [ … { … “message”: “Input columns ‘regression_unique_enough’ for multiclass problem type are too unique.”, … “data_check_name”: “UniquenessDataCheck”, … “level”: “warning”, … “details”: { … “columns”: [“regression_unique_enough”], … “rows”: None, … “uniqueness_score”: {“regression_unique_enough”: 0.99} … }, … “code”: “TOO_UNIQUE”, … “action_options”: [ … { … “code”: “DROP_COL”, … “data_check_name”: “UniquenessDataCheck”, … “parameters”: {}, … “metadata”: {“columns”: [“regression_unique_enough”], “rows”: None} … } … ] … } … ] … >>> assert UniquenessDataCheck.uniqueness_score(y) == 0.65625

数据检查#

子模块#

包内容#

类摘要#

目录#