API 参考#

模块配置#

输出数据类型配置#

cuml.internals.memory_utils.set_global_output_type(output_type)[source]#
用于设置 cuML 单 GPU 估计器的全局输出类型的方法。所有估计器都将使用此设置，除非在其初始化时通过自身的 output_type 参数覆盖。也可以通过上下文管理器方法 using_output_type() 覆盖。

参数:

output_type{‘input’, ‘cudf’, ‘cupy’, ‘numpy’} (默认 = ‘input’)
估计器结果和属性所需的输出类型。

'input' 意味着参数和方法将尽可能地模仿发送给估计器/方法的数据格式。具体来说

输入类型

输出类型

cuDF DataFrame 或 Series

cuDF DataFrame 或 Series

NumPy 数组

NumPy 数组

Pandas DataFrame 或 Series

NumPy 数组

Numba 设备数组

Numba 设备数组

CuPy 数组

CuPy 数组

其他 __cuda_array_interface__ 对象

CuPy 数组

'cudf' 将为一维结果返回 cuDF Series，为其余结果返回 DataFrame。

'cupy' 将返回 CuPy 数组。

'numpy' 将返回 NumPy 数组。

注意

'cupy' 和 'numba' 选项（以及使用 Numba 和 CuPy ndarray 作为输入时的 'input'）开销最小。cuDF 会增加构建 Series 和 DataFrame 所需的内存消耗和处理时间。'numpy' 的开销最大，因为它需要将数据传输到 CPU 内存。

示例
>>> import cuml
>>> import cupy as cp
>>> ary = [[1.0, 4.0, 4.0], [2.0, 2.0, 2.0], [5.0, 1.0, 1.0]]
>>> ary = cp.asarray(ary)
>>> prev_output_type = cuml.global_settings.output_type
>>> cuml.set_global_output_type('cudf')
>>> dbscan_float = cuml.DBSCAN(eps=1.0, min_samples=1)
>>> dbscan_float.fit(ary)
DBSCAN()
>>>
>>> # cuML output type
>>> dbscan_float.labels_
0    0
1    1
2    2
dtype: int32
>>> type(dbscan_float.labels_)
<class 'cudf.core.series.Series'>
>>> cuml.set_global_output_type(prev_output_type)
cuml.internals.memory_utils.using_output_type(output_type)[source]#
在 with 语句内部设置 cuML 全局输出类型的上下文管理器方法。一旦 with 代码块执行完毕，它就会重置为先前的值。

参数:

output_type{‘input’, ‘cudf’, ‘cupy’, ‘numpy’} (默认 = ‘input’)
估计器结果和属性所需的输出类型。

'input' 意味着参数和方法将尽可能地模仿发送给估计器/方法的数据格式。具体来说

输入类型

输出类型

cuDF DataFrame 或 Series

cuDF DataFrame 或 Series

NumPy 数组

NumPy 数组

Pandas DataFrame 或 Series

NumPy 数组

Numba 设备数组

Numba 设备数组

CuPy 数组

CuPy 数组

其他 __cuda_array_interface__ 对象

CuPy 数组

'cudf' 将为一维结果返回 cuDF Series，为其余结果返回 DataFrame。

'cupy' 将返回 CuPy 数组。

'numpy' 将返回 NumPy 数组。

示例
>>> import cuml
>>> import cupy as cp
>>> ary = [[1.0, 4.0, 4.0], [2.0, 2.0, 2.0], [5.0, 1.0, 1.0]]
>>> ary = cp.asarray(ary)
>>> with cuml.using_output_type('cudf'):
...     dbscan_float = cuml.DBSCAN(eps=1.0, min_samples=1)
...     dbscan_float.fit(ary)
...
...     print("cuML output inside 'with' context")
...     print(dbscan_float.labels_)
...     print(type(dbscan_float.labels_))
...
DBSCAN()
cuML output inside 'with' context
0    0
1    1
2    2
dtype: int32
<class 'cudf.core.series.Series'>
>>> # use cuml again outside the context manager
>>> dbscan_float2 = cuml.DBSCAN(eps=1.0, min_samples=1)
>>> dbscan_float2.fit(ary)
DBSCAN()
>>> # cuML default output
>>> dbscan_float2.labels_
array([0, 1, 2], dtype=int32)
>>> isinstance(dbscan_float2.labels_, cp.ndarray)
True

输入类型	输出类型
cuDF DataFrame 或 Series	cuDF DataFrame 或 Series
NumPy 数组	NumPy 数组
Pandas DataFrame 或 Series	NumPy 数组
Numba 设备数组	Numba 设备数组
CuPy 数组	CuPy 数组
其他 `__cuda_array_interface__` 对象	CuPy 数组

输入类型	输出类型
cuDF DataFrame 或 Series	cuDF DataFrame 或 Series
NumPy 数组	NumPy 数组
Pandas DataFrame 或 Series	NumPy 数组
Numba 设备数组	Numba 设备数组
CuPy 数组	CuPy 数组
其他 `__cuda_array_interface__` 对象	CuPy 数组

CPU / GPU 设备选择（实验性）#

cuML 为在 GPU 或 CPU 上运行选定的估计器和运算符提供了实验性支持。本文档涵盖了当前 nightly 软件包中支持 CPU/GPU 设备选择功能的运算符集。如果某个运算符未在此处列出，则只能在 GPU 上运行。cuML 的先前版本可能比下表所示的支持有所减少。

支持 CPU/GPU 设备选择和执行的运算符#
类别	运算符
聚类	HDBSCAN
降维与流形学习	PCA
降维与流形学习	TruncatedSVD
降维与流形学习	UMAP
近邻	NearestNeighbors
回归与分类	ElasticNet
回归与分类	Lasso
回归与分类	LinearRegression
回归与分类	LogisticRegression
回归与分类	Ridge

如果系统上存在支持 CUDA 的 GPU，cuML 将默认使用它。用户可以通过上下文管理器或全局配置为支持的运算符配置 CPU 或 GPU 执行。

from cuml.linear_model import Lasso
from cuml.common.device_selection import using_device_type, set_global_device_type

with using_device_type("CPU"): # Alternatively, using_device_type("GPU")
    model = Lasso()
    model.fit(X_train, y_train)
    predictions = model.predict(X_test)

# All operators supporting CPU execution will run on the CPU after this configuration
set_global_device_type("CPU")

model = Lasso()
model.fit(X_train, y_train)
predictions = model.predict(X_test)

有关更详细的示例，请参见用户指南中的执行设备互操作性 Notebook。

详细程度级别#

cuML 遵循类似于 Scikit-learn 的详细程度模型：verbose 参数可以是布尔值或数值，数值越高表示越详细。确切的值可以直接设置，或通过 cuml.common.logger 模块设置，它们是

详细程度级别#
数值	cuml.common.logger 值	详细程度级别
0	cuml.common.logger.level_enum.off	禁用所有日志消息
1	cuml.common.logger.level_enum.critical	仅启用关键消息
2	cuml.common.logger.level_enum.error	启用所有消息，包括错误消息。
3	cuml.common.logger.level_enum.warn	启用所有消息，包括警告消息。
4 或 False	cuml.common.logger.level_enum.info	启用所有消息，包括信息消息。
5 或 True	cuml.common.logger.level_enum.debug	启用所有消息，包括调试消息。
6	cuml.common.logger.level_enum.trace	启用所有消息，包括跟踪消息。

预处理、指标与工具#

模型选择与数据分割#

cuml.model_selection.train_test_split(X, y=None, test_size: float | int | None = None, train_size: float | int | None = None, shuffle: bool = True, random_state: int | RandomState | RandomState | None = None, stratify=None)[source]#
将设备数据分成四个整理后的对象，模仿 Scikit-learn 的 train_test_split。

参数:

Xcudf.DataFrame 或符合 cuda_array_interface 的设备数组
要分割的数据，形状为 (n_samples, n_features)

ystr, cudf.Series 或符合 cuda_array_interface 的设备数组
数据的标签集，可以是形状为 (n_samples) 的 Series，或者 X 中（如果 X 是 cuDF DataFrame）包含标签的列的字符串标签

train_sizefloat 或 int，可选
如果是浮点数，表示分配给训练集的数据比例 [0, 1]。如果是整数，表示分配给训练集的实例数量。默认为 0.8

shufflebool，可选
是否在分割前打乱输入

random_stateint, CuPy RandomState 或 NumPy RandomState，可选
如果 shuffle 为 true，则为生成器设定种子。默认为不设定种子

stratify: cudf.Series 或符合 cuda_array_interface 的设备数组,
可选参数。当传递时，输入将使用此作为分层依据的列进行分割。默认值=None

返回值:

X_train, X_test, y_train, y_testcudf.DataFrame 或 array-like 对象
如果 X 和 y 是 cuDF 对象，则返回分割后的 DataFrame。如果 y 作为列名提供，则该列已从 X 中删除。如果 X 和 y 是 Numba 设备数组，则返回分割后的 Numba 设备数组。对于任何其他输入，返回分割后的 CuPy 数组。

示例
>>> import cudf
>>> from cuml.model_selection import train_test_split
>>> # Generate some sample data
>>> df = cudf.DataFrame({'x': range(10),
...                      'y': [0, 1] * 5})
>>> print(f'Original data: {df.shape[0]} elements')
Original data: 10 elements
>>> # Suppose we want an 80/20 split
>>> X_train, X_test, y_train, y_test = train_test_split(df, 'y',
...                                                     train_size=0.8)
>>> print(f'X_train: {X_train.shape[0]} elements')
X_train: 8 elements
>>> print(f'X_test: {X_test.shape[0]} elements')
X_test: 2 elements
>>> print(f'y_train: {y_train.shape[0]} elements')
y_train: 8 elements
>>> print(f'y_test: {y_test.shape[0]} elements')
y_test: 2 elements

>>> # Alternatively, if our labels are stored separately
>>> labels = df['y']
>>> df = df.drop(['y'], axis=1)
>>> # we can also do
>>> X_train, X_test, y_train, y_test = train_test_split(df, labels,
...                                                     train_size=0.8)

特征与标签编码（单 GPU）#

class cuml.preprocessing.LabelEncoder.LabelEncoder(*, handle_unknown='error', handle=None, verbose=False, output_type=None)[source]#
基于 nvcategory 的有序标签编码实现

参数:

handle_unknown{‘error’, ‘ignore’}，默认值=’error’
在转换过程中是否存在未知分类特征时是否引发错误或忽略（默认为引发）。当此参数设置为 ‘ignore’ 并且在转换或逆转换过程中遇到未知类别时，结果编码将为 null。

handlecuml.Handle
指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。

verboseint 或 boolean，默认值=False
设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None
返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

方法

fit(y[, _classes])

将 LabelEncoder (nvcategory) 实例拟合到一组类别

fit_transform(y[, z])

同时拟合和转换输入

inverse_transform(y)

将有序标签恢复为原始标签

transform(y)

将输入转换为其类别键。

示例

将类别实现转换为数值实现
>>> from cudf import DataFrame, Series
>>> from cuml.preprocessing import LabelEncoder
>>> data = DataFrame({'category': ['a', 'b', 'c', 'd']})
>>> # There are two functionally equivalent ways to do this
>>> le = LabelEncoder()
>>> le.fit(data.category)  # le = le.fit(data.category) also works
LabelEncoder()
>>> encoded = le.transform(data.category)
>>> print(encoded)
0    0
1    1
2    2
3    3
dtype: uint8
>>> # This method is preferred
>>> le = LabelEncoder()
>>> encoded = le.fit_transform(data.category)
>>> print(encoded)
0    0
1    1
2    2
3    3
dtype: uint8
>>> # We can assign this to a new column
>>> data = data.assign(encoded=encoded)
>>> print(data.head())
category  encoded
0         a        0
1         b        1
2         c        2
3         d        3
>>> # We can also encode more data
>>> test_data = Series(['c', 'a'])
>>> encoded = le.transform(test_data)
>>> print(encoded)
0    2
1    0
dtype: uint8
>>> # After train, ordinal label can be inverse_transform() back to
>>> # string labels
>>> ord_label = cudf.Series([0, 0, 1, 2, 1])
>>> str_label = le.inverse_transform(ord_label)
>>> print(str_label)
0    a
1    a
2    b
3    c
4    b
dtype: object
fit(y, _classes=None)[source]#

将 LabelEncoder (nvcategory) 实例拟合到一组类别

参数:

ycudf.Series, pandas.Series, cupy.ndarray 或 numpy.ndarray
包含待编码类别的 Series。其元素可能唯一，也可能不唯一

_classes: int 或 None。
使用 dask LabelEncoder 时由 dask 客户端传递。

返回值:

selfLabelEncoder
一个已拟合的自身实例，允许方法链式调用

fit_transform(y, z=None)[source]#

同时拟合和转换输入

这在功能上等同于（但快于）LabelEncoder().fit(y).transform(y)

inverse_transform(y: Series)[source]#

将有序标签恢复为原始标签

参数:

ycudf.Series, pandas.Series, cupy.ndarray 或 numpy.ndarray
dtype=int32 待恢复的有序标签

返回值:

reverted与 y 类型相同
恢复的标签

transform(y)[source]#

将输入转换为其类别键。

这旨在用于相对于数据集大小较小的输入。对于拟合和转换整个数据集，首选 fit_transform。

参数:

ycudf.Series, pandas.Series, cupy.ndarray 或 numpy.ndarray
待转换的输入键。其值应与传递给 fit 的类别匹配

返回值:

encodedcudf.Series
经过有序编码的输入 Series

引发:

KeyError
如果出现了在 fit 中未见过的类别
class cuml.preprocessing.LabelBinarizer(*, neg_label=0, pos_label=1, sparse_output=False, handle=None, verbose=False, output_type=None)[source]#
多类别标签的虚拟编码器。

参数:

neg_label整数（默认值=0）
用作负二进制标签的标签值

pos_label整数（默认值=1）
用作正二进制标签的标签值

sparse_outputbool（默认值=False）
是否返回稀疏数组作为转换输出

handlecuml.Handle
指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。

verboseint 或 boolean，默认值=False
设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None
返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

属性:

classes_

方法

fit(y)

拟合标签二值化器

fit_transform(y)

拟合标签二值化器并将多类别标签转换为其虚拟编码表示。

inverse_transform(y[, threshold])

将二进制标签转换回原始多类别标签

transform(y)

将多类别标签转换为其虚拟编码表示标签。

示例

创建一个带有标签的数组并对其进行虚拟编码
>>> import cupy as cp
>>> import cupyx
>>> from cuml.preprocessing import LabelBinarizer

>>> labels = cp.asarray([0, 5, 10, 7, 2, 4, 1, 0, 0, 4, 3, 2, 1],
...                     dtype=cp.int32)

>>> lb = LabelBinarizer()
>>> encoded = lb.fit_transform(labels)
>>> print(str(encoded))
[[1 0 0 0 0 0 0 0]
[0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 1]
[0 0 0 0 0 0 1 0]
[0 0 1 0 0 0 0 0]
[0 0 0 0 1 0 0 0]
[0 1 0 0 0 0 0 0]
[1 0 0 0 0 0 0 0]
[1 0 0 0 0 0 0 0]
[0 0 0 0 1 0 0 0]
[0 0 0 1 0 0 0 0]
[0 0 1 0 0 0 0 0]
[0 1 0 0 0 0 0 0]]
>>> decoded = lb.inverse_transform(encoded)
>>> print(str(decoded))
[ 0  5 10  7  2  4  1  0  0  4  3  2  1]
fit(y) → LabelBinarizer[source]#

拟合标签二值化器

参数:

y形状为 [n_samples,] 或 [n_samples, n_classes] 的数组
目标值。2D 矩阵应仅包含 0 和 1，表示多标签分类。

返回值:

self返回自身的实例。

fit_transform(y) → SparseCumlArray[source]#

拟合标签二值化器并将多类别标签转换为其虚拟编码表示。

参数:

y形状为 [n_samples,] 或 [n_samples, n_classes] 的数组

返回值:

arr包含编码标签的数组

inverse_transform(y, threshold=None) → CumlArray[source]#

将二进制标签转换回原始多类别标签

参数:

y形状为 [n_samples, n_classes] 的数组

thresholdfloat，此值目前被忽略

返回值:

arr包含原始标签的数组

transform(y) → SparseCumlArray[source]#

将多类别标签转换为其虚拟编码表示标签。

参数:

y形状为 [n_samples,] 或 [n_samples, n_classes] 的数组

返回值:

arr包含编码标签的数组
cuml.preprocessing.label_binarize(y, classes, neg_label=0, pos_label=1, sparse_output=False) → SparseCumlArray[source]#

一个无状态的辅助函数，用于虚拟编码多类别标签。

参数:

y大小为 [n_samples,] 或 [n_samples, n_classes] 的 array-like 对象

classes输入中的唯一类别集合

neg_label整数，转换输出的负值

pos_label整数，转换输出的正值

sparse_outputbool，是否返回稀疏数组

class cuml.preprocessing.OneHotEncoder(*, categories='auto', drop=None, sparse='deprecated', sparse_output=True, dtype=<class 'numpy.float32'>, handle_unknown='error', handle=None, verbose=False, output_type=None)[source]#

将类别特征编码为独热数值数组。此估计器的输入应为 cuDF.DataFrame 或 cupy.ndarray，表示类别（离散）特征所取的唯一值。特征使用独热（也称为 ‘one-of-K’ 或 ‘dummy’）编码方案进行编码。这将为每个类别创建一个二进制列，并返回一个稀疏矩阵或密集数组（取决于 sparse 参数）。

默认情况下，编码器根据每个特征中的唯一值派生类别。或者，您也可以手动指定 categories。

注意

y 标签的独热编码应改用 LabelBinarizer。

参数:

categories‘auto’，一个 cupy.ndarray 或 cudf.DataFrame，默认值=’auto’

每个特征的类别（唯一值）

‘auto’ : 从训练数据中自动确定类别。

DataFrame/ndarray : categories[col] 包含特征列中预期的类别。

drop‘first’, None, dict 或 list，默认值=None
指定用于丢弃每个特征中一个类别的方法。这在完美共线特征导致问题的场景中非常有用，例如将结果数据馈送到神经网络或未正则化回归时。

None : 保留所有特征（默认）。

‘first’ : 丢弃每个特征中的第一个类别。如果只存在一个类别，则整个特征将被丢弃。

dict/list : drop[col] 是特征列中应丢弃的类别。

sparse_outputbool，默认值=True
此功能尚未完全由 cupy 支持，导致计算独热编码时出现不正确的值。参见 cupy/cupy#3223

版本 24.06 新增: sparse 已重命名为 sparse_output

sparsebool，默认值=True
如果设置为 True 则返回稀疏矩阵，否则返回一个数组。

自版本 24.06 起已废弃: sparse 在 24.06 版本中已废弃，并将在 25.08 版本中移除。请改用 sparse_output。

dtype数值类型，默认值=np.float
转换输出所需的数值类型。

handle_unknown{‘error’, ‘ignore’}，默认值=’error’
在转换过程中是否存在未知分类特征时是否引发错误或忽略（默认为引发）。当此参数设置为 ‘ignore’ 并且在转换过程中遇到未知类别时，该特征对应的独热编码列将全部为零。在逆转换中，未知类别将表示为 None。

handlecuml.Handle
指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。

verboseint 或 boolean，默认值=False
设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None
返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

属性:

drop_idx_形状为 (n_features,) 的数组
drop_idx_[i] 是 categories_[i] 中对于每个特征要丢弃的类别的索引。如果所有转换后的特征都将保留，则为 None。

方法

fit(X[, y])

将 OneHotEncoder 拟合到 X。

fit_transform(X[, y])

将 OneHotEncoder 拟合到 X，然后转换 X。等同于 fit(X).transform(X)。

get_feature_names([input_features])

返回输出特征的特征名称。

inverse_transform(X)

将数据转换回原始表示。

transform(X)

使用独热编码转换 X。

fit(X, y=None)[source]#

将 OneHotEncoder 拟合到 X。参数 ———-

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features)
密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。

yNone
忽略。此参数仅为兼容性而存在。

fit_transform(X, y=None)[source]#

将 OneHotEncoder 拟合到 X，然后转换 X。等同于 fit(X).transform(X)。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features)
密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。

yNone
忽略。此参数仅为兼容性而存在。

返回值:

X_out如果 sparse=True 则为稀疏矩阵，否则为 2D 数组
转换后的输入。

get_feature_names(input_features=None)[source]#

返回输出特征的特征名称。

参数:

input_features形状为 (n_features,) 的字符串列表
输入特征的字符串名称（如果可用）。默认使用 “x0”, “x1”, …, “xn_features”。

返回值:

output_feature_names形状为 (n_output_features,) 的 ndarray
特征名称数组。

inverse_transform(X)[source]#

将数据转换回原始表示。如果遇到未知类别（独热编码中全为零），则使用 None 表示该类别。

返回类型与此估计器实例上第一次调用 fit 时使用的输入类型相同。

参数:

Xarray-like 或稀疏矩阵，形状 [n_samples, n_encoded_features]
转换后的数据。

返回值:

X_trcudf.DataFrame 或 cupy.ndarray
逆转换后的数组。

transform(X)[source]#

使用独热编码转换 X。参数 ———-

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features)
密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。

返回值:

X_out如果 sparse=True 则为稀疏矩阵，否则为 2D 数组
转换后的输入。
class cuml.preprocessing.TargetEncoder.TargetEncoder(n_folds=4, smooth=0, seed=42, split_method='interleaved', output_type='auto', stat='mean')[source]#
基于 cudf 的目标编码 [1] 实现，它将一个或多个类别变量 'Xs' 转换为目标变量 'Y' 对应值的平均值。输入数据按列 Xs 分组，并计算每个分组的 Y 的汇总平均值来替换 Xs 的每个值。应用了多项优化来防止标签泄露并并行执行。

参数:

n_foldsint（默认值=4）
拟合训练数据的默认折叠数。为了防止在 fit 中发生标签泄露，我们将数据分割成 n_folds，并使用剩余折叠的目标变量对其中一个折叠进行编码。

smoothint 或 float（默认值=0）
用于平滑编码的样本计数。0 表示不进行平滑。

seedint（默认值=42）
随机种子

split_method{‘random’, ‘continuous’, ‘interleaved’}，（默认值=’interleaved’）
将训练数据分割成 n_folds 的方法。‘random’：随机分割。‘continuous’：连续样本分组到一个折叠中。‘interleaved’：样本以循环方式分配到每个折叠。‘customize’：通过在 fit() 或 fit_transform() 函数中提供 fold_ids 数组进行自定义分割。

output_type{‘cupy’, ‘numpy’, ‘auto’}，默认值 = ‘auto’
输出的数据类型。如果为 ‘auto’，则匹配输入数据。

stat{‘mean’,’var’,’median’}，默认值 = ‘mean’
编码中使用的统计量，目标变量的均值、方差或中位数。

方法

fit(x, y[, fold_ids])

将 TargetEncoder 实例拟合到一组类别

fit_transform(x, y[, fold_ids])

同时拟合和转换输入

get_params([deep])

返回此类拥有的所有参数的字典。

transform(x)

将输入转换为其类别键。

参考

[1]
https://maxhalford.github.io/blog/target-encoding/

示例

将类别实现转换为数值实现
>>> from cudf import DataFrame, Series
>>> from cuml.preprocessing import TargetEncoder
>>> train = DataFrame({'category': ['a', 'b', 'b', 'a'],
...                    'label': [1, 0, 1, 1]})
>>> test = DataFrame({'category': ['a', 'c', 'b', 'a']})
>>> encoder = TargetEncoder()
>>> train_encoded = encoder.fit_transform(train.category, train.label)
>>> test_encoded = encoder.transform(test.category)
>>> print(train_encoded)
[1. 1. 0. 1.]
>>> print(test_encoded)
[1.   0.75 0.5  1.  ]
fit(x, y, fold_ids=None)[source]#

将 TargetEncoder 实例拟合到一组类别

参数:

xcudf.Series 或 cudf.DataFrame 或 cupy.ndarray
待编码的类别。其元素可能唯一，也可能不唯一

ycudf.Series 或 cupy.ndarray
包含目标变量的 Series。

fold_idscudf.Series 或 cupy.ndarray
包含自定义折叠索引的 Series。其值应为范围 [0, N-1] 中的整数，用于将数据分割成 N 个折叠。如果为 None，则根据 split_method 生成 fold_ids。

返回值:

selfTargetEncoder
一个已拟合的自身实例，允许方法链式调用

fit_transform(x, y, fold_ids=None)[source]#

同时拟合和转换输入

这在功能上等同于（但快于）TargetEncoder().fit(y).transform(y)

参数:

xcudf.Series 或 cudf.DataFrame 或 cupy.ndarray
待编码的类别。其元素可能唯一，也可能不唯一

ycudf.Series 或 cupy.ndarray
包含目标变量的 Series。

fold_idscudf.Series 或 cupy.ndarray
包含自定义折叠索引的 Series。其值应为范围 [0, N-1] 中的整数，用于将数据分割成 N 个折叠。如果为 None，则根据 split_method 生成 fold_ids。

返回值:

encodedcupy.ndarray
经过有序编码的输入 Series

get_params(deep=False)[source]#

返回此类拥有的所有参数的字典。

返回此类拥有的所有参数的字典。

将输入转换为其类别键。

transform(x)[source]#

参数:

这适用于测试数据。对于拟合和转换训练数据，首选 fit_transform。
xcudf.Series

返回值:

encodedcupy.ndarray
经过有序编码的输入 Series

待转换的输入键。其值不必与传递给 `fit` 的类别匹配

特征缩放与归一化（单 GPU）#

class cuml.preprocessing.MaxAbsScaler(*args, **kwargs)[source]#

按每个特征的最大绝对值进行缩放。

此估计器单独缩放和转换每个特征，使得训练集中每个特征的最大绝对值为 1.0。它不移动/居中数据，因此不会破坏任何稀疏性。

参数:

此缩放器也可应用于稀疏的 CSR 或 CSC 矩阵。: copyboolean，可选，默认值是 True

属性:

是否会触发强制复制。如果 copy=False，复制可能会因转换而触发。: scale_ndarray，形状 (n_features,)
数据按特征的相对缩放比例。: max_abs_ndarray，形状 (n_features,)
每个特征的最大绝对值。: n_samples_seen_int

方法

估计器处理的样本数量。在新调用 fit 时会重置，但在 `partial_fit` 调用之间会递增。	`fit`(X[, y])
计算用于后续缩放的最大绝对值。	`inverse_transform`(X)
将数据缩放回原始表示	`partial_fit`(X[, y])
在线计算 X 的最大绝对值以便后续缩放。	`transform`(X)

缩放数据

另请参见: maxabs_scale

注意

没有估计器 API 的等效函数。

示例

>>> from cuml.preprocessing import MaxAbsScaler
>>> import cupy as cp
>>> X = [[ 1., -1.,  2.],
...      [ 2.,  0.,  0.],
...      [ 0.,  1., -1.]]
>>> X = cp.array(X)
>>> transformer = MaxAbsScaler().fit(X)
>>> transformer
MaxAbsScaler()
>>> transformer.transform(X)
array([[ 0.5, -1. ,  1. ],
       [ 1. ,  0. ,  0. ],
       [ 0. ,  1. , -0.5]])

NaNs 被视为缺失值：在 fit 中被忽略，在 transform 中被保留。

fit(X[, y])

参数:

fit(X, y=None) → MaxAbsScaler[source]#: X{array-like, 稀疏矩阵}，形状 [n_samples, n_features]

用于计算按特征轴进行后续缩放的每个特征的最小值和最大值的数据。

inverse_transform(X)

参数:

inverse_transform(X) → SparseCumlArray[source]#: X{array-like, 稀疏矩阵}

应被转换回原样的数据。

partial_fit(X[, y])

partial_fit(X, y=None) → MaxAbsScaler[source]#

参数:

fit(X, y=None) → MaxAbsScaler[source]#: X 的所有部分作为一个批次处理。这适用于 fit() 由于 n_samples 数量过大或 X 来自连续流而不可行的情况。
yNone: 用于计算按特征轴进行后续缩放的均值和标准差的数据。

返回值:

忽略。: selfobject

转换器实例。

transform(X)

参数:

inverse_transform(X) → SparseCumlArray[source]#: transform(X) → SparseCumlArray[source]#

应被缩放的数据。

class cuml.preprocessing.MinMaxScaler(*args, **kwargs)[source]#

通过将每个特征缩放到给定范围来转换特征。

此估计器单独缩放和转换每个特征，使其在训练集上位于给定范围（例如，零到一之间）。

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
X_scaled = X_std * (max - min) + min

转换由以下公式给出

此转换通常用作零均值、单位方差缩放的替代方案。

参数:

feature_rangetuple (min, max)，默认值=(0, 1): 转换后数据的期望范围。
copybool，默认值=True: copyboolean，可选，默认值是 True

属性:

min_形状为 (n_features,) 的 ndarray: 按特征的最小值调整。等同于 min - X.min(axis=0) * self.scale_
scale_形状为 (n_features,) 的 ndarray: 数据按特征的相对缩放比例。等同于 (max - min) / (X.max(axis=0) - X.min(axis=0))
data_min_形状为 (n_features,) 的 ndarray: 数据中按特征看到的最小值
data_max_形状为 (n_features,) 的 ndarray: 数据中按特征看到的最大值
data_range_形状为 (n_features,) 的 ndarray: 数据中按特征看到的范围 (data_max_ - data_min_)
每个特征的最大绝对值。: 估计器处理的样本数量。在新调用 fit 时会重置，但在 partial_fit 调用之间会递增。

方法

`fit`(X[, y])	计算用于后续缩放的最小值和最大值。
`inverse_transform`(X)	根据 feature_range 撤销 X 的缩放。
`partial_fit`(X[, y])	在线计算 X 的最小值和最大值以便后续缩放。
`transform`(X)	根据 feature_range 缩放 X 的特征。

缩放数据

minmax_scale: maxabs_scale

注意

没有估计器 API 的等效函数。

示例

>>> from cuml.preprocessing import MinMaxScaler
>>> import cupy as cp
>>> data = [[-1, 2], [-0.5, 6], [0, 10], [1, 18]]
>>> data = cp.array(data)
>>> scaler = MinMaxScaler()
>>> print(scaler.fit(data))
MinMaxScaler()
>>> print(scaler.data_max_)
[ 1. 18.]
>>> print(scaler.transform(data))
[[0.   0.  ]
 [0.25 0.25]
 [0.5  0.5 ]
 [1.   1.  ]]
>>> print(scaler.transform(cp.array([[2, 2]])))
[[1.5 0. ]]

fit(X, y=None) → MinMaxScaler[source]#

计算用于后续缩放的最小值和最大值。

参数:

X形状为 (n_samples, n_features) 的 array-like 对象: X{array-like, 稀疏矩阵}，形状 [n_samples, n_features]
yNone: 用于计算按特征轴进行后续缩放的均值和标准差的数据。

返回值:

忽略。: 已拟合的缩放器。

inverse_transform(X) → CumlArray[source]#

根据 feature_range 撤销 X 的缩放。

参数:

X形状为 (n_samples, n_features) 的 array-like 对象: 将被转换的输入数据。它不能是稀疏的。

返回值:

Xt形状为 (n_samples, n_features) 的 array-like 对象: 转换后的数据。

partial_fit(X, y=None) → MinMaxScaler[source]#

在线计算 X 的最小值和最大值以便后续缩放。

X 的所有部分作为一个批次处理。这适用于 fit() 由于 n_samples 数量过大或 X 来自连续流而不可行的情况。

参数:

X形状为 (n_samples, n_features) 的 array-like 对象: X 的所有部分作为一个批次处理。这适用于 fit() 由于 n_samples 数量过大或 X 来自连续流而不可行的情况。
yNone: 用于计算按特征轴进行后续缩放的均值和标准差的数据。

返回值:

忽略。: selfobject

transform(X) → CumlArray[source]#

根据 feature_range 缩放 X 的特征。

参数:

X形状为 (n_samples, n_features) 的 array-like 对象: 将被转换的输入数据。

返回值:

Xt形状为 (n_samples, n_features) 的 array-like 对象: 转换后的数据。

class cuml.preprocessing.Normalizer(*args, **kwargs)[source]#

将样本单独归一化到单位范数。

每个至少有一个非零分量的样本（即数据矩阵的每一行）会独立于其他样本进行重缩放，使其范数（l1、l2 或 inf）等于一。

此转换器能够处理密集 numpy 数组和稀疏矩阵

将输入缩放到单位范数是文本分类或聚类中的常见操作，例如。例如，两个 l2 归一化 TF-IDF 向量的点积是这些向量的余弦相似度，并且是信息检索社区常用的向量空间模型的基础相似度指标。

参数:

norm‘l1’, ‘l2’, 或 ‘max’，可选（默认为 ‘l2’）: 用于归一化每个非零样本的范数。如果使用 norm=’max’，则值将按绝对值的最大值进行重缩放。
copyboolean，可选，默认值 True: copyboolean，可选，默认值是 True

方法

`fit`(X[, y])	无操作并返回未更改的估计器
`transform`(X[, copy])	将 X 中每个非零行缩放为单位范数

缩放数据

normalize: maxabs_scale

注意

此估计器是无状态的（构造函数参数除外），fit 方法不做任何事情，但在管道中使用时很有用。

示例

>>> from cuml.preprocessing import Normalizer
>>> import cupy as cp
>>> X = [[4, 1, 2, 2],
...      [1, 3, 9, 3],
...      [5, 7, 5, 1]]
>>> X = cp.array(X)
>>> transformer = Normalizer().fit(X)  # fit does nothing.
>>> transformer
Normalizer()
>>> transformer.transform(X)
array([[0.8, 0.2, 0.4, 0.4],
       [0.1, 0.3, 0.9, 0.3],
       [0.5, 0.7, 0.5, 0.1]])

fit(X, y=None) → Normalizer[source]#

无操作并返回未更改的估计器

此方法仅用于实现常用 API，因此可在管道中工作。

参数:

X{array-like, CSR matrix}

transform(X, copy=None) → SparseCumlArray[source]#

将 X 中每个非零行缩放为单位范数

参数:

X{array-like, CSR matrix}, shape [n_samples, n_features]: 要逐行标准化的数据。
copybool, 可选（默认值：None）: copyboolean，可选，默认值是 True

class cuml.preprocessing.RobustScaler(*args, **kwargs)[source]#

使用对离群值具有鲁棒性的统计数据来缩放特征。

此缩放器移除中位数并根据分位数范围（默认为 IQR：四分位距）缩放数据。IQR 是第 1 四分位数（25% 分位数）和第 3 四分位数（75% 分位数）之间的范围。

居中和缩放独立地应用于每个特征，方法是计算训练集中样本的相关统计数据。然后存储中位数和四分位距，以便稍后使用 transform 方法用于后续数据。

数据集的标准化是许多机器学习估计器的常见要求。通常通过移除均值并缩放到单位方差来完成。然而，离群值常常会对样本均值/方差产生负面影响。在这种情况下，中位数和四分位距通常会产生更好的结果。

参数:

with_centering布尔值, 默认值=True: 如果为 True，则在缩放前居中数据。尝试对稀疏矩阵进行此操作时，transform 将引发异常，因为居中它们需要构建一个密集矩阵，这在常见用例中可能太大而无法放入内存。
with_scaling布尔值, 默认值=True: 如果为 True，则将数据缩放到四分位距。
quantile_rangetuple (q_min, q_max), 0.0 < q_min < q_max < 100.0: 默认值：(25.0, 75.0) = (第 1 四分位数, 第 3 四分位数) = IQR 用于计算 scale_ 的分位数范围。
copy布尔值, 可选, 默认值=True: copyboolean，可选，默认值是 True

属性:

center_浮点数数组: 训练集中每个特征的中位数。
scale_浮点数数组: 训练集中每个特征的（缩放后的）四分位距。

方法

`fit`(X[, y])	计算用于缩放的中位数和分位数。
`inverse_transform`(X)	`inverse_transform`(X)
`transform`(X)	居中并缩放数据。

缩放数据

robust_scale: maxabs_scale
cuml.decomposition.PCA: 通过 whiten=True 进一步移除特征间的线性相关性。

示例

>>> from cuml.preprocessing import RobustScaler
>>> import cupy as cp
>>> X = [[ 1., -2.,  2.],
...      [ -2.,  1.,  3.],
...      [ 4.,  1., -2.]]
>>> X = cp.array(X)
>>> transformer = RobustScaler().fit(X)
>>> transformer
RobustScaler()
>>> transformer.transform(X)
array([[ 0. , -2. ,  0. ],
       [-1. ,  0. ,  0.4],
       [ 1. ,  0. , -1.6]])

fit(X, y=None) → RobustScaler[source]#

计算用于缩放的中位数和分位数。

参数:

X{array-like, CSC matrix}, shape [n_samples, n_features]: 用于计算中位数和分位数的数据，以便稍后沿着特征轴进行缩放。

inverse_transform(X) → SparseCumlArray[source]#

inverse_transform(X)

参数:

inverse_transform(X) → SparseCumlArray[source]#: 用于沿着指定轴进行缩放的数据。

transform(X) → SparseCumlArray[source]#

居中并缩放数据。

参数:

inverse_transform(X) → SparseCumlArray[source]#: 用于沿着指定轴进行缩放的数据。

class cuml.preprocessing.StandardScaler(*args, **kwargs)[source]#

通过移除均值并将特征缩放到单位方差来标准化特征。

样本 x 的标准得分计算公式为

z = (x - u) / s

其中 u 是训练样本的均值，如果 with_mean=False 则为零；s 是训练样本的标准差，如果 with_std=False 则为一。

居中和缩放独立地应用于每个特征，方法是计算训练集中样本的相关统计数据。然后存储均值和标准差，以便稍后使用 transform() 用于后续数据。

数据集的标准化是许多机器学习估计器的常见要求：如果单个特征或多或少不像标准正态分布数据（例如，均值为 0、单位方差的高斯分布），它们的表现可能会很差。

例如，学习算法目标函数中使用的许多元素（例如支持向量机的 RBF 核或线性模型的 L1 和 L2 正则化器）假定所有特征都以 0 为中心，并且具有相同量级的方差。如果一个特征的方差比其他特征大几个数量级，它可能会主导目标函数，并使估计器无法按预期从其他特征中正确学习。

通过传入 with_mean=False，此缩放器也可以应用于稀疏的 CSR 或 CSC 矩阵，以避免破坏数据的稀疏结构。

参数:

copyboolean，可选，默认值 True: copyboolean，可选，默认值是 True
with_mean布尔值, 默认值 True: 如果为 True，则在缩放前居中数据。尝试对稀疏矩阵进行此操作时，此操作不起作用（并将引发异常），因为居中它们需要构建一个密集矩阵，这在常见用例中可能太大而无法放入内存。
with_std布尔值, 默认值 True: 如果为 True，则将数据缩放到单位方差（或等效地，单位标准差）。

属性:

scale_ndarray 或 None, shape (n_features,): 数据的每个特征的相对缩放。这是使用 sqrt(var_) 计算的。当 with_std=False 时等于 None。
mean_ndarray 或 None, shape (n_features,): 训练集中每个特征的均值。当 with_mean=False 时等于 None。
var_ndarray 或 None, shape (n_features,): 训练集中每个特征的方差。用于计算 scale_。当 with_std=False 时等于 None。
n_samples_seen_int 或 array, shape (n_features,): 估计器为每个特征处理的样本数。如果没有缺失样本，n_samples_seen 将是一个整数，否则将是一个数组。在新调用 fit 时会重置，但在 partial_fit 调用之间会增加。

方法

`fit`(X[, y])	计算用于后续缩放的均值和标准差。
`inverse_transform`(X[, copy])	`inverse_transform`(X)
`partial_fit`(X[, y])	在线计算 X 的均值和标准差，以便后续缩放。
`transform`(X[, copy])	通过居中和缩放执行标准化。

缩放数据

scale: maxabs_scale
cuml.decomposition.PCA: 通过 ‘whiten=True’ 进一步移除特征间的线性相关性。

注意

没有估计器 API 的等效函数。

我们使用标准差的有偏估计量，相当于 numpy.std(x, ddof=0)。请注意，ddof 的选择不太可能影响模型性能。

示例

>>> from cuml.preprocessing import StandardScaler
>>> import cupy as cp
>>> data = [[0, 0], [0, 0], [1, 1], [1, 1]]
>>> data = cp.array(data)
>>> scaler = StandardScaler()
>>> print(scaler.fit(data))
StandardScaler()
>>> print(scaler.mean_)
[0.5 0.5]
>>> print(scaler.transform(data))
[[-1. -1.]
 [-1. -1.]
 [ 1.  1.]
 [ 1.  1.]]
>>> print(scaler.transform(cp.array([[2, 2]])))
[[3. 3.]]

fit(X, y=None) → StandardScaler[source]#

计算用于后续缩放的均值和标准差。

参数:

fit(X, y=None) → MaxAbsScaler[source]#: X 的所有部分作为一个批次处理。这适用于 fit() 由于 n_samples 数量过大或 X 来自连续流而不可行的情况。
yNone: 忽略

inverse_transform(X, copy=None) → SparseCumlArray[source]#

inverse_transform(X)

参数:

fit(X, y=None) → MaxAbsScaler[source]#: 用于沿着特征轴进行缩放的数据。
copybool, 可选（默认值：None）: copyboolean，可选，默认值是 True

返回值:

X_tr{array-like, 稀疏矩阵}, shape [n_samples, n_features]: 转换后的数组。

partial_fit(X, y=None) → StandardScaler[source]#

在线计算 X 的均值和标准差，以便后续缩放。

X 的所有部分都作为单个批次处理。这适用于由于 n_samples 数量非常大或因为 X 是从连续流中读取而导致 fit() 不可行的情况。

增量均值和标准差的算法见 Chan, Tony F., Gene H. Golub 和 Randall J. LeVeque 在“Algorithms for computing the sample variance: Analysis and recommendations.”, The American Statistician 37.3 (1983): 242-247 中的公式 1.5a,b。

参数:

fit(X, y=None) → MaxAbsScaler[source]#: X 的所有部分作为一个批次处理。这适用于 fit() 由于 n_samples 数量过大或 X 来自连续流而不可行的情况。
yNone: 用于计算按特征轴进行后续缩放的均值和标准差的数据。

返回值:

忽略。: selfobject

transform(X, copy=None) → SparseCumlArray[source]#

通过居中和缩放执行标准化。

参数:

fit(X, y=None) → MaxAbsScaler[source]#: 用于沿着特征轴进行缩放的数据。
copybool, 可选（默认值：None）: copyboolean，可选，默认值是 True

cuml.preprocessing.maxabs_scale(X, *, axis=0, copy=True)[source]#

在不破坏稀疏性的情况下，将每个特征缩放到 [-1, 1] 范围。

此估计器单独缩放每个特征，使得训练集中每个特征的最大绝对值变为 1.0。

此估计器单独缩放和转换每个特征，使得训练集中每个特征的最大绝对值为 1.0。它不移动/居中数据，因此不会破坏任何稀疏性。

参数:

X{array-like, 稀疏矩阵}, shape (n_samples, n_features): 数据。
axisint（默认为 0）: 用于进行缩放的轴。如果为 0，则独立缩放每个特征，否则（如果为 1）缩放每个样本。
此缩放器也可应用于稀疏的 CSR 或 CSC 矩阵。: copyboolean，可选，默认值是 True

缩放数据

MaxAbsScaler: 使用 Transformer API 执行缩放到 [-1, 1] 范围。

注意

NaNs 被视为缺失值：计算统计数据时忽略，数据转换过程中保留。

cuml.preprocessing.minmax_scale(X, feature_range=(0, 1), *, axis=0, copy=True)[source]#

class cuml.preprocessing.MinMaxScaler(*args, **kwargs)[source]#

此估计器单独缩放并平移每个特征，使其在训练集的给定范围内，即在零和一之间。

转换公式为（当 axis=0 时）

X_std = (X - X.min(axis=0)) / (X.max(axis=0) - X.min(axis=0))
X_scaled = X_std * (max - min) + min

转换由以下公式给出

转换计算公式为（当 axis=0 时）

X_scaled = scale * X + min - X.min(axis=0) * scale
where scale = (max - min) / (X.max(axis=0) - X.min(axis=0))

此转换通常用作零均值、单位方差缩放的替代方案。

参数:

X形状为 (n_samples, n_features) 的 array-like 对象: 数据。
feature_rangetuple (min, max)，默认值=(0, 1): 转换后数据的期望范围。
axisint, 默认值=0: 用于进行缩放的轴。如果为 0，则独立缩放每个特征，否则（如果为 1）缩放每个样本。
copybool，默认值=True: copyboolean，可选，默认值是 True

缩放数据

MinMaxScaler: 使用 Transformer API 执行缩放到给定范围。

cuml.preprocessing.normalize(X, norm='l2', *, axis=1, copy=True, return_norm=False)[source]#

将输入向量单独缩放到单位范数（向量长度）。

参数:

fit(X, y=None) → MaxAbsScaler[source]#: 要逐元素标准化的数据。请提供 CSC 矩阵以在轴 0 上进行标准化，反之，提供 CSR 矩阵以在轴 1 上进行标准化。
norm‘l1’, ‘l2’, 或 ‘max’，可选（默认为 ‘l2’）: 用于标准化每个非零样本（如果轴为 0，则标准化每个非零特征）的范数。
axis0 或 1, 可选（默认为 1）: 用于沿着数据进行标准化的轴。如果为 1，则独立标准化每个样本，否则（如果为 0）标准化每个特征。
copyboolean，可选，默认值 True: copyboolean，可选，默认值是 True
return_norm布尔值, 默认值 False: 是否返回计算出的范数

返回值:

fit(X, y=None) → MaxAbsScaler[source]#: 标准化后的输入 X。
normsarray, shape [n_samples] 如果 axis=1 否则 [n_features]: X 沿着给定轴的范数数组。当 X 为稀疏时，对于范数 ‘l1’ 或 ‘l2’ 将引发 NotImplementedError。

缩放数据

Normalizer: 使用 Transformer API 执行标准化。

cuml.preprocessing.robust_scale(X, *, axis=0, with_centering=True, with_scaling=True, quantile_range=(25.0, 75.0), copy=True)[source]#

沿着任何轴标准化数据集。

以中位数为中心，并根据四分位距对组件进行缩放。

参数:

inverse_transform(X) → SparseCumlArray[source]#: 要居中和缩放的数据。
axisint（默认为 0）: 用于计算中位数和 IQR 的轴。如果为 0，则独立缩放每个特征，否则（如果为 1）缩放每个样本。
with_centering布尔值, 默认值 True: 如果为 True，则在缩放前居中数据。
with_scaling布尔值, 默认值 True: 如果为 True，则将数据缩放到单位方差（或等效地，单位标准差）。
quantile_rangetuple (q_min, q_max), 0.0 < q_min < q_max < 100.0: 默认值：(25.0, 75.0) = (第 1 四分位数, 第 3 四分位数) = IQR 用于计算 scale_ 的分位数范围。
此缩放器也可应用于稀疏的 CSR 或 CSC 矩阵。: copyboolean，可选，默认值是 True

缩放数据

RobustScaler: 使用 Transformer API 执行居中和缩放。

注意

此实现将拒绝居中稀疏矩阵，因为它会使它们变为非稀疏矩阵，并可能导致内存耗尽问题而使程序崩溃。

相反，调用者应显式设置 with_centering=False（在这种情况下，仅对 CSR 矩阵的特征执行方差缩放）或在预期具现化的密集数组能放入内存时将其密集化。

为了避免内存复制，调用者应传入一个 CSR 矩阵。

cuml.preprocessing.scale(X, *, axis=0, with_mean=True, with_std=True, copy=True)[source]#

沿着任何轴标准化数据集。

以均值为中心，并按组件缩放到单位方差。

参数:

inverse_transform(X) → SparseCumlArray[source]#: 要居中和缩放的数据。
axisint（默认为 0）: 用于计算均值和标准差的轴。如果为 0，则独立标准化每个特征，否则（如果为 1）标准化每个样本。
with_mean布尔值, 默认值 True: 如果为 True，则在缩放前居中数据。
with_std布尔值, 默认值 True: 如果为 True，则将数据缩放到单位方差（或等效地，单位标准差）。
copyboolean，可选，默认值 True: copyboolean，可选，默认值是 True

缩放数据

StandardScaler: 使用 Transformer API 执行缩放到单位方差。

注意

此实现将拒绝居中稀疏矩阵，因为它会使它们变为非稀疏矩阵，并可能导致内存耗尽问题而使程序崩溃。

相反，调用者应显式设置 with_mean=False（在这种情况下，仅对稀疏矩阵的特征执行方差缩放）或在预期具现化的密集数组能放入内存时将其密集化。

为了优化处理，调用者应传入一个 CSC 矩阵。

NaNs 被视为缺失值：计算统计数据时忽略，数据转换过程中保留。

我们使用标准差的有偏估计量，相当于 numpy.std(x, ddof=0)。请注意，ddof 的选择不太可能影响模型性能。

其他预处理方法（单 GPU）#

class cuml.preprocessing.Binarizer(*args, **kwargs)[source]#

根据阈值对数据进行二值化（将特征值设置为 0 或 1）。

大于阈值的值映射为 1，小于或等于阈值的值映射为 0。默认阈值为 0 时，只有正值映射为 1。

二值化是文本计数数据上的常见操作，分析师可以决定仅考虑特征是否存在，而不是量化的出现次数。

它也可以用作考虑布尔随机变量的估计器（例如，在贝叶斯设置中使用伯努利分布建模）的预处理步骤。

参数:

threshold浮点值, 可选（默认为 0.0）: 小于或等于此阈值的特征值替换为 0，大于此阈值的替换为 1。对于稀疏矩阵操作，阈值不能小于 0。
copyboolean，可选，默认值 True: copyboolean，可选，默认值是 True

方法

`fit`(X[, y])	无操作并返回未更改的估计器
`transform`(X[, copy])	对 X 的每个元素进行二值化。

缩放数据

binarize: maxabs_scale

注意

如果输入是稀疏矩阵，只有非零值会受到 Binarizer 类的更新影响。

此估计器是无状态的（构造函数参数除外），fit 方法不做任何事情，但在管道中使用时很有用。

示例

>>> from cuml.preprocessing import Binarizer
>>> import cupy as cp
>>> X = [[ 1., -1.,  2.],
...      [ 2.,  0.,  0.],
...      [ 0.,  1., -1.]]
>>> X = cp.array(X)
>>> transformer = Binarizer().fit(X)  # fit does nothing.
>>> transformer
Binarizer()
>>> transformer.transform(X)
array([[1., 0., 1.],
       [1., 0., 0.],
       [0., 1., 0.]])

fit(X, y=None) → Binarizer[source]#

无操作并返回未更改的估计器

此方法仅用于实现常用 API，因此可在管道中工作。

参数:

inverse_transform(X) → SparseCumlArray[source]#

transform(X, copy=None) → SparseCumlArray[source]#

对 X 的每个元素进行二值化。

参数:

fit(X, y=None) → MaxAbsScaler[source]#: 要逐元素进行二值化的数据。
copy布尔值: copyboolean，可选，默认值是 True

class cuml.preprocessing.FunctionTransformer(*args, **kwargs)[source]#

从任意可调用对象构造一个转换器。

FunctionTransformer 将其 X（以及可选的 y）参数转发给用户定义的函数或函数对象，并返回此函数的结果。这对于无状态转换很有用，例如计算频率的对数、执行自定义缩放等。

注意：如果使用 lambda 作为函数，则生成的转换器将不可被 pickle 化。

参数:

func可调用对象, 默认值=None: 用于执行转换的可调用对象。它将传递与 transform 相同的参数，并转发 args 和 kwargs。如果 func 为 None，则 func 将是恒等函数。
inverse_func可调用对象, 默认值=None: 用于执行逆转换的可调用对象。它将传递与 inverse transform 相同的参数，并转发 args 和 kwargs。如果 inverse_func 为 None，则 inverse_func 将是恒等函数。
accept_sparse布尔值, 默认值=False: 指示 func 是否接受稀疏矩阵作为输入。否则，如果 accept_sparse 为 false，稀疏矩阵输入将导致引发异常。
check_inverse布尔值, 默认值=True: 是否检查 func 后跟 inverse_func 是否会导致原始输入。这可用于健全性检查，当条件不满足时会引发警告。
kw_argsdict, 默认值=None: 要传递给 func 的额外关键字参数字典。
inv_kw_argsdict, 默认值=None: 要传递给 inverse_func 的额外关键字参数字典。

方法

`fit`(X[, y])	通过检查 X 拟合转换器。
`inverse_transform`(X)	使用逆函数转换 X。
`transform`(X)	使用前向函数转换 X。

示例

>>> import cupy as cp
>>> from cuml.preprocessing import FunctionTransformer
>>> transformer = FunctionTransformer(func=cp.log1p)
>>> X = cp.array([[0, 1], [2, 3]])
>>> transformer.transform(X)
array([[0.       , 0.6931...],
       [1.0986..., 1.3862...]])

fit(X, y=None) → FunctionTransformer[source]#

通过检查 X 拟合转换器。

参数:

X{array-like, 稀疏矩阵}, shape (n_samples, n_features): 输入数组。

返回值:

self

inverse_transform(X) → SparseCumlArray[source]#

使用逆函数转换 X。

参数:

X{array-like, 稀疏矩阵}, shape (n_samples, n_features): 输入数组。

返回值:

X_out{array-like, 稀疏矩阵}, shape (n_samples, n_features): 转换后的输入。

transform(X) → SparseCumlArray[source]#

使用前向函数转换 X。

参数:

X{array-like, 稀疏矩阵}, shape (n_samples, n_features): 输入数组。

返回值:

X_out{array-like, 稀疏矩阵}, shape (n_samples, n_features): 转换后的输入。

class cuml.preprocessing.KBinsDiscretizer(*args, **kwargs)[source]#

将连续数据分箱到区间中。

参数:

n_binsint 或 array-like, shape (n_features,)（默认值=5）

要生成的箱数。如果 n_bins < 2，则引发 ValueError。

encode{‘onehot’, ‘onehot-dense’, ‘ordinal’},（默认值=’onehot’）

用于编码转换结果的方法。

onehot: 使用独热编码（one-hot encoding）编码转换结果并返回稀疏矩阵。被忽略的特征始终堆叠在右侧。
onehot-dense: 使用独热编码（one-hot encoding）编码转换结果并返回密集数组。被忽略的特征始终堆叠在右侧。
ordinal: 返回编码为整数值的箱标识符。

strategy{‘uniform’, ‘quantile’, ‘kmeans’},（默认值=’quantile’）

用于定义箱宽度的策略。

uniform: 每个特征中的所有箱具有相同的宽度。
quantile: 每个特征中的所有箱包含相同数量的点。
kmeans: 每个箱中的值都与一维 k-means 聚类的最近中心相同。

属性:

n_bins_int array, shape (n_features,): 每个特征的箱数。宽度过小（即 <= 1e-8）的箱将被移除并发出警告。
bin_edges_数组的数组, shape (n_features, ): 每个箱的边界。包含不同形状的数组 (n_bins_, )。被忽略的特征将具有空数组。

方法

`fit`(X[, y])	拟合估计器。
`inverse_transform`(Xt)	将离散化数据转换回原始特征空间。
`transform`(X)	对数据进行离散化。

缩放数据

cuml.preprocessing.Binarizer: 用于根据参数 threshold 将值分箱为 0 或 1 的类。

注意

在特征 i 的箱边界中，第一个和最后一个值仅用于 inverse_transform。在 transform 期间，箱边界扩展为

np.concatenate([-np.inf, bin_edges_[i][1:-1], np.inf])

如果您只想预处理部分特征，可以将 KBinsDiscretizer 与 cuml.compose.ColumnTransformer 结合使用。

KBinsDiscretizer 可能会产生常数特征（例如，当 encode = 'onehot' 并且某些箱不包含任何数据时）。可以使用特征选择算法（例如 sklearn.feature_selection.VarianceThreshold）移除这些特征。

示例

>>> from cuml.preprocessing import KBinsDiscretizer
>>> import cupy as cp
>>> X = [[-2, 1, -4,   -1],
...      [-1, 2, -3, -0.5],
...      [ 0, 3, -2,  0.5],
...      [ 1, 4, -1,    2]]
>>> X = cp.array(X)
>>> est = KBinsDiscretizer(n_bins=3, encode='ordinal', strategy='uniform')
>>> est.fit(X)
KBinsDiscretizer(...)
>>> Xt = est.transform(X)
>>> Xt
array([[0, 0, 0, 0],
       [1, 1, 1, 0],
       [2, 2, 2, 1],
       [2, 2, 2, 2]], dtype=int32)

有时将数据转换回原始特征空间可能很有用。inverse_transform 函数将分箱数据转换回原始特征空间。每个值将等于两个箱边界的平均值。

>>> est.bin_edges_[0]
array([-2., -1.,  0.,  1.])
>>> est.inverse_transform(Xt)
array([[-1.5,  1.5, -3.5, -0.5],
       [-0.5,  2.5, -2.5, -0.5],
       [ 0.5,  3.5, -1.5,  0.5],
       [ 0.5,  3.5, -1.5,  1.5]])

fit(X, y=None) → KBinsDiscretizer[source]#

拟合估计器。

参数:

X数值型 array-like, shape (n_samples, n_features): 要离散化的数据。
yNone: 忽略。此参数仅为与 sklearn.pipeline.Pipeline 兼容而存在。

返回值:

self

inverse_transform(Xt) → SparseCumlArray[source]#

将离散化数据转换回原始特征空间。

请注意，由于离散化舍入，此函数不会重新生成原始数据。

参数:

Xt数值型 array-like, shape (n_sample, n_features): 分箱空间中的转换数据。

返回值:

Xinv数值型 array-like: 原始特征空间中的数据。

transform(X) → SparseCumlArray[source]#

对数据进行离散化。

参数:

X数值型 array-like, shape (n_samples, n_features): 要离散化的数据。

返回值:

Xt数值型 array-like 或稀疏矩阵: 分箱空间中的数据。

class cuml.preprocessing.KernelCenterer(*args, **kwargs)[source]#

居中核矩阵。

设 K(x, z) 是由 phi(x)^T phi(z) 定义的核，其中 phi 是将 x 映射到 Hilbert 空间的函数。KernelCenterer 在不显式计算 phi(x) 的情况下居中（即，标准化为零均值）数据。这等同于使用 cuml.preprocessing.StandardScaler(with_std=False) 对 phi(x) 进行居中处理。

属性:

K_fit_rows_array, shape (n_samples,): 核矩阵每列的平均值。
K_fit_all_浮点值: 核矩阵的平均值。

方法

`fit`(K[, y])	拟合 KernelCenterer。
`transform`(K[, copy])	居中核矩阵。

示例

>>> import cupy as cp
>>> from cuml.preprocessing import KernelCenterer
>>> from cuml.metrics import pairwise_kernels
>>> X = cp.array([[ 1., -2.,  2.],
...               [ -2.,  1.,  3.],
...               [ 4.,  1., -2.]])
>>> K = pairwise_kernels(X, metric='linear')
>>> K
array([[  9.,   2.,  -2.],
       [  2.,  14., -13.],
       [ -2., -13.,  21.]])
>>> transformer = KernelCenterer().fit(K)
>>> transformer
KernelCenterer()
>>> transformer.transform(K)
array([[  5.,   0.,  -5.],
       [  0.,  14., -14.],
       [ -5., -14.,  19.]])

fit(K, y=None) → KernelCenterer[source]#

拟合 KernelCenterer。

参数:

K形状为 [n_samples, n_samples] 的 numpy 数组: 核矩阵。

返回值:

self返回自身的实例。

transform(K, copy=True) → CumlArray[source]#

居中核矩阵。

参数:

K形状为 [n_samples1, n_samples2] 的 numpy 数组: 核矩阵。
copyboolean，可选，默认值 True: copyboolean，可选，默认值是 True

返回值:

K_new形状为 [n_samples1, n_samples2] 的 numpy 数组

class cuml.preprocessing.MissingIndicator(*args, **kwargs)[source]#

缺失值的二元指标。

请注意，此组件通常不应在由转换器和分类器组成的普通 Pipeline 中使用，而应使用 FeatureUnion 或 ColumnTransformer 添加。

参数:

missing_values数值, 字符串, np.nan (默认) 或 None

缺失值的占位符。所有 missing_values 的出现都将被填充。对于带有缺失值的可为空整数 dtypes 的 pandas 数据帧，应将 missing_values 设置为 np.nan，因为 pd.NA 将被转换为 np.nan。

featuresstr, 默认值=None

填充器掩码是否应表示全部或部分特征。

如果为“missing-only”（默认），填充器掩码仅在拟合期间表示包含缺失值的特征。
如果为“all”，填充器掩码将表示所有特征。

sparse布尔值或 “auto”, 默认值=None

填充器掩码格式应为稀疏还是密集。

如果为“auto”（默认），填充器掩码将与输入类型相同。
如果为 True，填充器掩码将是稀疏矩阵。
如果为 False，imputer 掩码将是一个 numpy 数组。

error_on_newboolean, default=None

如果为 True（默认），当转换中包含在拟合时没有缺失值但在转换时包含缺失值的特征时，转换将引发错误。这仅适用于 features="missing-only" 的情况。

属性:

features_ndarray, shape (n_missing_features,) or (n_features,): 调用 transform 时将返回的特征索引。它们在 fit 期间计算。对于 features='all'，它等于 range(n_features)。

方法

`fit`(X[, y])	在 X 上拟合转换器。
`fit_transform`(X[, y])	为 X 生成缺失值指示器。
`transform`(X)	为 X 生成缺失值指示器。

示例

>>> import numpy as np
>>> from sklearn.impute import MissingIndicator
>>> X1 = np.array([[np.nan, 1, 3],
...                [4, 0, np.nan],
...                [8, 1, 0]])
>>> X2 = np.array([[5, 1, np.nan],
...                [np.nan, 2, 3],
...                [2, 4, 0]])
>>> indicator = MissingIndicator()
>>> indicator.fit(X1)
MissingIndicator()
>>> X2_tr = indicator.transform(X2)
>>> X2_tr
array([[False,  True],
       [ True, False],
       [False, False]])

fit(X, y=None) → MissingIndicator[source]#

在 X 上拟合转换器。

参数:

X{array-like, 稀疏矩阵}, shape (n_samples, n_features): 输入数据，其中 n_samples 是样本数，n_features 是特征数。

返回值:

忽略。: 返回 self。

fit_transform(X, y=None) → SparseCumlArray[source]#

为 X 生成缺失值指示器。

参数:

X{array-like, 稀疏矩阵}, shape (n_samples, n_features): 要补全的输入数据。

返回值:

Xt{ndarray or sparse matrix}, shape (n_samples, n_features) or (n_samples, n_features_with_missing): 输入数据的缺失指示器。Xt 的数据类型将是布尔型。

transform(X) → SparseCumlArray[source]#

为 X 生成缺失值指示器。

参数:

X{array-like, 稀疏矩阵}, shape (n_samples, n_features): 要补全的输入数据。

返回值:

Xt{ndarray or sparse matrix}, shape (n_samples, n_features) or (n_samples, n_features_with_missing): 输入数据的缺失指示器。Xt 的数据类型将是布尔型。

class cuml.preprocessing.PolynomialFeatures(*args, **kwargs)[source]#

生成多项式和交互特征。

生成一个新的特征矩阵，该矩阵包含所有次数小于或等于指定次数的特征的多项式组合。例如，如果输入样本是二维的，形式为 [a, b]，则二次多项式特征是 [1, a, b, a^2, ab, b^2]。

参数:

degreeinteger: 多项式特征的次数。默认值 = 2。
interaction_onlyboolean, default = False: 如果为 true，则只生成交互特征：即最多由 degree 个不同输入特征乘积构成的特征（因此不包括 x[1] ** 2, x[0] * x[2] ** 3 等）。
include_biasboolean: 如果为 True（默认），则包含一个偏置列，即所有多项式幂都为零的特征（例如，全是 1 的列 - 在线性模型中用作截距项）。
orderstr in {‘C’, ‘F’}, default ‘C’: 密集情况下输出数组的顺序。'F' 顺序计算速度更快，但可能减慢后续估计器。

属性:

powers_array, shape (n_output_features, n_input_features): powers_[i, j] 是第 i 个输出中第 j 个输入的指数。
n_input_features_int: 输入特征的总数。
n_output_features_int: 多项式输出特征的总数。输出特征的数量通过迭代所有适当大小的输入特征组合来计算。

方法

`fit`(X[, y])	计算输出特征的数量。
`get_feature_names`([input_features])	返回输出特征的特征名称
`transform`(X)	将数据转换为多项式特征

注意

请注意，输出数组中的特征数量随输入数组的特征数量呈多项式增长，并随次数呈指数增长。高次数可能导致过拟合。

示例

>>> import numpy as np
>>> from cuml.preprocessing import PolynomialFeatures
>>> X = np.arange(6).reshape(3, 2)
>>> X
array([[0, 1],
       [2, 3],
       [4, 5]])
>>> poly = PolynomialFeatures(2)
>>> poly.fit_transform(X)
array([[ 1.,  0.,  1.,  0.,  0.,  1.],
       [ 1.,  2.,  3.,  4.,  6.,  9.],
       [ 1.,  4.,  5., 16., 20., 25.]])
>>> poly = PolynomialFeatures(interaction_only=True)
>>> poly.fit_transform(X)
array([[ 1.,  0.,  1.,  0.],
       [ 1.,  2.,  3.,  6.],
       [ 1.,  4.,  5., 20.]])

fit(X, y=None) → PolynomialFeatures[source]#

计算输出特征的数量。

参数:

Xarray-like, shape (n_samples, n_features): 数据。

返回值:

selfinstance

get_feature_names(input_features=None)[source]#

返回输出特征的特征名称

参数:

input_featureslist of string, length n_features, optional: 输入特征的字符串名称（如果可用）。默认使用 “x0”, “x1”, …, “xn_features”。

返回值:

output_feature_nameslist of string, length n_output_features

transform(X) → SparseCumlArray[source]#

将数据转换为多项式特征

参数:

fit(X, y=None) → MaxAbsScaler[source]#

要转换的数据，按行排列。

对于稀疏输入，优先使用 CSR 而不是 CSC（为了速度），但如果次数为 4 或更高，则需要 CSC。如果次数小于 4 且输入格式为 CSC，它将被转换为 CSR，生成多项式特征，然后转换回 CSC。因此，优先使用 CSR。

如果次数为 2 或 3，则使用 Andrew Nystrom 和 John Hughes 在“Leveraging Sparsity to Speed Up Polynomial Feature Expansions of CSR Matrices Using K-Simplex Numbers”中描述的方法，该方法比 CSC 输入使用的方法快得多。因此，CSC 输入将被转换为 CSR，输出在返回之前将转换回 CSC，因此优先使用 CSR。

返回值:

XP{array-like, sparse matrix}, shape [n_samples, NP]: 特征矩阵，其中 NP 是从输入组合生成的特征数量。

class cuml.preprocessing.PowerTransformer(*args, **kwargs)[source]#

对每个特征应用幂变换，使数据更接近高斯分布。

幂变换是一族参数化、单调的变换，用于使数据更接近高斯分布。这对于处理异方差性（非恒定方差）或需要正态性的其他情况很有用。

目前，PowerTransformer 支持 Box-Cox 变换和 Yeo-Johnson 变换。通过最大似然估计稳定方差和最小化偏度的最优参数。

Box-Cox 要求输入数据严格为正，而 Yeo-Johnson 支持正负数据。

默认情况下，对转换后的数据应用零均值、单位方差归一化。

参数:

methodstr, (default=’yeo-johnson’)

幂变换方法。可用方法有

‘yeo-johnson’ [1]，适用于正值和负值
‘box-cox’ [2]，仅适用于严格正值

standardizeboolean, default=True

设置为 True 以对转换后的输出应用零均值、单位方差归一化。

copy布尔值, 可选, 默认值=True

设置为 False 以在转换期间执行就地计算。

属性:

lambdas_array of float, shape (n_features,): 所选特征的幂变换参数。

方法

`fit`(X[, y])	估计每个特征的最优参数 lambda。
`fit_transform`(X[, y])	拟合数据，然后进行转换。
`inverse_transform`(X)	使用已拟合的 lambdas 应用逆幂变换。
`transform`(X)	使用已拟合的 lambdas 对每个特征应用幂变换。

缩放数据

power_transform: maxabs_scale
QuantileTransformer: 使用参数 output_distribution='normal' 将数据映射到标准正态分布。

注意

NaN 被视为缺失值：在 fit 中被忽略，在 transform 中被保留。

参考

[1]

I.K. Yeo and R.A. Johnson, “A new family of power transformations to improve normality or symmetry.” Biometrika, 87(4), pp.954-959, (2000)。

[2]

G.E.P. Box and D.R. Cox, “An Analysis of Transformations”, Journal of the Royal Statistical Society B, 26, 211-252 (1964)。

示例

>>> import cupy as cp
>>> from cuml.preprocessing import PowerTransformer
>>> pt = PowerTransformer()
>>> data = cp.array([[1, 2], [3, 2], [4, 5]])
>>> print(pt.fit(data))
PowerTransformer()
>>> print(pt.lambdas_)
[ 1.386... -3.100...]
>>> print(pt.transform(data))
[[-1.316... -0.707...]
 [ 0.209... -0.707...]
 [ 1.106...  1.414...]]

fit(X, y=None) → PowerTransformer[source]#

估计每个特征的最优参数 lambda。

通过最大似然法对每个特征独立地估计最小化偏度的最优 lambda 参数。

参数:

Xarray-like, shape (n_samples, n_features): 用于估计最优变换参数的数据。
yIgnored

返回值:

忽略。

fit_transform(X, y=None) → CumlArray[source]#

拟合数据，然后进行转换。

使用可选参数 fit_params 将转换器拟合到 X 和 y，并返回 X 的转换版本。

参数:

X{array-like, sparse matrix, dataframe} of shape (n_samples, n_features)
yndarray of shape (n_samples,), default=None: 目标值。
**fit_paramsdict: 额外的拟合参数。

返回值:

X_newndarray array of shape (n_samples, n_features_new): 转换后的数组。

inverse_transform(X) → CumlArray[source]#

使用已拟合的 lambdas 应用逆幂变换。

Box-Cox 变换的逆变换由以下公式给出

if lambda_ == 0:
    X = exp(X_trans)
else:
    X = (X_trans * lambda_ + 1) ** (1 / lambda_)

Yeo-Johnson 变换的逆变换由以下公式给出

if X >= 0 and lambda_ == 0:
    X = exp(X_trans) - 1
elif X >= 0 and lambda_ != 0:
    X = (X_trans * lambda_ + 1) ** (1 / lambda_) - 1
elif X < 0 and lambda_ != 2:
    X = 1 - (-(2 - lambda_) * X_trans + 1) ** (1 / (2 - lambda_))
elif X < 0 and lambda_ == 2:
    X = 1 - exp(-X_trans)

参数:

Xarray-like, shape (n_samples, n_features): 转换后的数据。

返回值:

Xarray-like, shape (n_samples, n_features): 原始数据

transform(X) → CumlArray[source]#

使用已拟合的 lambdas 对每个特征应用幂变换。

参数:

Xarray-like, shape (n_samples, n_features): 使用幂变换要转换的数据。

返回值:

X_transarray-like, shape (n_samples, n_features): 转换后的数据。

class cuml.preprocessing.QuantileTransformer(*args, **kwargs)[source]#

使用分位数信息转换特征。

此方法将特征转换为遵循均匀分布或正态分布。因此，对于给定的特征，这种转换倾向于分散最频繁的值。它还减少了（边缘）异常值的影响：因此这是一种鲁棒的预处理方案。

该变换独立应用于每个特征。首先，使用特征的累积分布函数估计将原始值映射到均匀分布。然后，使用关联的分位数函数将获得的值映射到所需的输出分布。落入拟合范围之外的新/未见数据的特征值将映射到输出分布的边界。请注意，此变换是非线性的。它可能会扭曲在同一尺度上测量的变量之间的线性相关性，但会使在不同尺度上测量的变量更具可比性。

参数:

n_quantilesint, optional (default=1000 or n_samples): 要计算的分位数数量。它对应于用于离散化累积分布函数的标志点数量。如果 n_quantiles 大于样本数量，n_quantiles 将被设置为样本数量，因为更大的分位数数量不能更好地近似累积分布函数估计器。
output_distributionstr, optional (default=’uniform’): 转换后数据的边际分布。选择包括“uniform”（均匀分布，默认）或“normal”（正态分布）。
ignore_implicit_zerosbool, optional (default=False): 仅适用于稀疏矩阵。如果为 True，则丢弃矩阵的稀疏条目以计算分位数统计。如果为 False，则这些条目被视为零。
subsampleint, optional (default=1e5): 用于估计分位数的最大样本数量，以提高计算效率。请注意，对于值相同的稀疏矩阵和密集矩阵，子采样过程可能不同。
random_stateint, RandomState instance or None, optional (default=None): 确定子采样和平滑噪声的随机数生成。详细信息请参阅 subsample。传入一个整数可在多次函数调用中获得可重现结果。参见词汇表
copyboolean, optional, (default=True): 设置为 False 可执行就地转换并避免复制（如果输入已经是 numpy 数组）。

属性:

n_quantiles_integer: 用于离散化累积分布函数的实际分位数数量。
quantiles_ndarray, shape (n_quantiles, n_features): 对应于参考分位数的值。
references_ndarray, shape(n_quantiles, ): 参考分位数。

方法

`fit`(X[, y])	计算用于转换的分位数。
`inverse_transform`(X)	反向投影到原始空间。
`transform`(X)	对数据进行特征级转换。

缩放数据

quantile_transform: maxabs_scale
PowerTransformer: 使用幂变换执行到正态分布的映射。
StandardScaler: 执行标准化，速度更快，但对异常值鲁棒性较低。
RobustScaler: 执行鲁棒标准化，消除异常值的影响，但不将异常值和正常值放在同一尺度上。

注意

没有估计器 API 的等效函数。

示例

>>> import cupy as cp
>>> from cuml.preprocessing import QuantileTransformer
>>> rng = cp.random.RandomState(0)
>>> X = cp.sort(rng.normal(loc=0.5, scale=0.25, size=(25, 1)), axis=0)
>>> qt = QuantileTransformer(n_quantiles=10, random_state=0)
>>> qt.fit_transform(X)
array([...])

fit(X, y=None) → QuantileTransformer[source]#

计算用于转换的分位数。

参数:

Xndarray or sparse matrix, shape (n_samples, n_features): 用于沿特征轴进行缩放的数据。如果提供了稀疏矩阵，它将被转换为稀疏的 csc_matrix。此外，如果 ignore_implicit_zeros 为 False，则稀疏矩阵需要是非负的。

返回值:

忽略。

inverse_transform(X) → SparseCumlArray[source]#

反向投影到原始空间。

参数:

Xndarray or sparse matrix, shape (n_samples, n_features): 用于沿特征轴进行缩放的数据。如果提供了稀疏矩阵，它将被转换为稀疏的 csc_matrix。此外，如果 ignore_implicit_zeros 为 False，则稀疏矩阵需要是非负的。

返回值:

Xtndarray or sparse matrix, shape (n_samples, n_features): 投影数据。

transform(X) → SparseCumlArray[source]#

对数据进行特征级转换。

参数:

Xndarray or sparse matrix, shape (n_samples, n_features): 用于沿特征轴进行缩放的数据。如果提供了稀疏矩阵，它将被转换为稀疏的 csc_matrix。此外，如果 ignore_implicit_zeros 为 False，则稀疏矩阵需要是非负的。

返回值:

Xtndarray or sparse matrix, shape (n_samples, n_features): 投影数据。

class cuml.preprocessing.SimpleImputer(*args, **kwargs)[source]#

用于补全缺失值的插补转换器。

参数:

missing_values数值, 字符串, np.nan (默认) 或 None

strategystring, default=’mean’

插补策略。

如果为“mean”，则使用每列的均值替换缺失值。只能用于数值数据。
如果为“median”，则使用每列的中位数替换缺失值。只能用于数值数据。
如果为“most_frequent”，则使用每列中最频繁的值替换缺失值。可用于字符串或数值数据。
如果为“constant”，则用 fill_value 替换缺失值。可用于字符串或数值数据。

strategy=”constant” 用于固定值插补。

fill_valuestring or numerical value, default=None

当 strategy == “constant” 时，fill_value 用于替换所有出现的 missing_values。如果保留默认值，当插补数值数据时 fill_value 将为 0，对于字符串或对象数据类型将为“missing_value”。

verboseinteger, default=0

控制 imputer 的详细程度。

copyboolean, default=True

如果为 True，将创建 X 的副本。如果为 False，则尽可能进行就地插补。请注意，在以下情况下，即使 copy=False，也始终会创建新的副本

如果 X 不是浮点数值数组；
如果 X 被编码为 CSR 矩阵；
如果 add_indicator=True。

add_indicatorboolean, default=False

如果为 True，一个 MissingIndicator 转换将堆叠在 imputer 转换的输出上。这允许预测估计器在插补后仍考虑缺失性。如果特征在拟合/训练时没有缺失值，即使在转换/测试时存在缺失值，该特征也不会出现在缺失指示器中。

属性:

statistics_array of shape (n_features,): 每个特征的插补填充值。计算统计数据可能导致 np.nan 值。在 transform() 期间，对应于 np.nan 统计数据的特征将被丢弃。

方法

`fit`(X[, y])	在 X 上拟合 imputer。
`transform`(X)	插补 X 中的所有缺失值。

缩放数据

IterativeImputer: 多变量缺失值插补。

注意

如果在 fit() 时只包含缺失值的列，如果在 transform() 时策略不是“constant”，则这些列将被丢弃。

示例

>>> import cupy as cp
>>> from cuml.preprocessing import SimpleImputer
>>> imp_mean = SimpleImputer(missing_values=cp.nan, strategy='mean')
>>> imp_mean.fit(cp.asarray([[7, 2, 3], [4, cp.nan, 6], [10, 5, 9]]))
SimpleImputer()
>>> X = [[cp.nan, 2, 3], [4, cp.nan, 6], [10, cp.nan, 9]]
>>> print(imp_mean.transform(cp.asarray(X)))
[[ 7.   2.   3. ]
 [ 4.   3.5  6. ]
 [10.   3.5  9. ]]

fit(X, y=None) → SimpleImputer[source]#

在 X 上拟合 imputer。

参数:

X{array-like, 稀疏矩阵}, shape (n_samples, n_features): 输入数据，其中 n_samples 是样本数，n_features 是特征数。

返回值:

selfSimpleImputer

transform(X) → SparseCumlArray[source]#

插补 X 中的所有缺失值。

参数:

X{array-like, 稀疏矩阵}, shape (n_samples, n_features): 要补全的输入数据。

cuml.preprocessing.add_dummy_feature(X, value=1.0)[source]#

用附加的虚拟特征扩充数据集。

这对于拟合不能直接拟合截距项的实现非常有用。

参数:

fit(X, y=None) → MaxAbsScaler[source]#: 数据。
valuefloat: 用于虚拟特征的值。

返回值:

X{array, sparse matrix}, shape [n_samples, n_features + 1]: 相同的数据集，虚拟特征添加为第一列。

示例

>>> from cuml.preprocessing import add_dummy_feature
>>> import cupy as cp
>>> add_dummy_feature(cp.array([[0, 1], [1, 0]]))
array([[1., 0., 1.],
       [1., 1., 0.]])

cuml.preprocessing.binarize(X, *, threshold=0.0, copy=True)[source]#

数组或稀疏矩阵的布尔阈值化

参数:

fit(X, y=None) → MaxAbsScaler[source]#: 要逐元素进行二值化的数据。
threshold浮点值, 可选（默认为 0.0）: 小于或等于此阈值的特征值替换为 0，大于此阈值的替换为 1。对于稀疏矩阵操作，阈值不能小于 0。
copyboolean，可选，默认值 True: copyboolean，可选，默认值是 True

缩放数据

Binarizer: 使用 Transformer API 执行二值化

class cuml.compose.ColumnTransformer(*args, **kwargs)[source]#

将转换器应用于数组或数据帧的列。

此估计器允许将输入的不同列或列子集分开转换，并且每个转换器生成的特征将被连接以形成单个特征空间。这对于异构或列式数据，将多种特征提取机制或转换组合成一个转换器非常有用。

参数:

transformerslist of tuples

指定要应用于数据子集的转换器对象的 (name, transformer, columns) 元组列表

namestr
与 Pipeline 和 FeatureUnion 一样，这允许使用 set_params 设置转换器及其参数并在网格搜索中进行搜索。
transformer{‘drop’, ‘passthrough’} or estimator
估计器必须支持 fit 和 transform。也接受特殊字符串 'drop' 和 'passthrough'，分别表示丢弃列或不进行转换直接传递列。
columnsstr, array-like of str, int, array-like of int, array-like of bool, slice or callable
在数据的第二轴上进行索引。整数被解释为位置列，而字符串可以按名称引用 DataFrame 列。当 transformer 期望 X 是一个一维类数组（向量）时，应使用标量字符串或整数，否则将向转换器传递一个二维数组。可调用对象将输入数据 X 作为参数，并可以返回上述任何类型。要按名称或 dtype 选择多个列，可以使用 make_column_selector。

remainder{‘drop’, ‘passthrough’} or estimator, default=’drop’

默认情况下，只有 transformers 中指定的列会被转换并合并到输出中，未指定的列将被丢弃（默认值为 'drop'）。通过指定 remainder='passthrough'，所有未在 transformers 中指定的剩余列将被自动直通。这个列子集将与转换器的输出连接。通过将 remainder 设置为一个估计器，剩余的未指定列将使用 remainder 估计器。该估计器必须支持 fit 和 transform。请注意，使用此功能要求在 fit 和 transform 时输入的 DataFrame 列具有相同的顺序。

sparse_thresholdfloat, default=0.3

如果不同转换器的输出包含稀疏矩阵，并且总体密度低于此值，则它们将堆叠为稀疏矩阵。使用 sparse_threshold=0 可始终返回密集矩阵。当转换后的输出全部由密集数据组成时，堆叠结果将是密集的，并且此关键字将被忽略。

n_jobsint, default=None

并行运行的作业数。None 表示 1，除非在 joblib.parallel_backend 上下文中。-1 表示使用所有处理器。更多详细信息。

transformer_weightsdict, default=None

每个转换器的特征乘法权重。转换器的输出乘以这些权重。键是转换器名称，值是权重。

verbosebool, default=False

如果为 True，则将在每个转换器完成拟合时打印其经过的时间。

属性:

transformers_list: 已拟合转换器的集合，以 (name, fitted_transformer, column) 元组形式表示。fitted_transformer 可以是估计器、'drop' 或 'passthrough'。如果没有选择任何列，这将是未拟合的转换器。如果存在剩余列，最后一个元素是以下形式的元组：('remainder', transformer, remaining_columns)，对应于 remainder 参数。如果存在剩余列，则 len(transformers_)==len(transformers)+1，否则 len(transformers_)==len(transformers)。
named_transformers_Bunch: 按名称访问已拟合的转换器。
sparse_output_bool: 布尔标志，指示 transform 的输出是稀疏矩阵还是密集的 numpy 数组，这取决于各个转换器的输出和 sparse_threshold 关键字。

缩放数据

make_column_transformer: 用于组合应用于原始特征空间的列子集的多个转换器对象输出的便利函数。
make_column_selector: 用于根据数据类型或使用正则表达式模式选择列的便利函数。

注意

转换后特征矩阵中列的顺序遵循 transformers 列表中指定列的顺序。原始特征矩阵中未指定的列将从生成的转换后特征矩阵中丢弃，除非在 passthrough 关键字中指定。使用 passthrough 指定的列将添加到转换器输出的右侧。

示例

>>> import cupy as cp
>>> from cuml.compose import ColumnTransformer
>>> from cuml.preprocessing import Normalizer
>>> ct = ColumnTransformer(
...     [("norm1", Normalizer(norm='l1'), [0, 1]),
...      ("norm2", Normalizer(norm='l1'), slice(2, 4))])
>>> X = cp.array([[0., 1., 2., 2.],
...               [1., 1., 0., 1.]])
>>> # Normalizer scales each row of X to unit norm. A separate scaling
>>> # is applied for the two first and two last elements of each
>>> # row independently.
>>> ct.fit_transform(X)
array([[0. , 1. , 0.5, 0.5],
       [0.5, 0.5, 0. , 1. ]])

fit(X, y=None) → ColumnTransformer[source]#

使用 X 拟合所有转换器。

参数:

X{array-like, dataframe} of shape (n_samples, n_features): 输入数据，其指定子集用于拟合转换器。
yarray-like of shape (n_samples,…), default=None: 用于监督学习的目标。

返回值:

selfColumnTransformer: 此估计器

fit_transform(X, y=None) → SparseCumlArray[source]#

拟合所有转换器，转换数据并连接结果。

参数:

X{array-like, dataframe} of shape (n_samples, n_features): 输入数据，其指定子集用于拟合转换器。
yarray-like of shape (n_samples,), default=None: 用于监督学习的目标。

返回值:

X_t{array-like, sparse matrix} of shape (n_samples, sum_n_components): 转换器结果的水平堆叠。sum_n_components 是转换器输出维度 (n_components) 的总和。如果任何结果是稀疏矩阵，所有结果都将转换为稀疏矩阵。

get_feature_names()[source]#

从所有转换器获取特征名称。

返回值:

feature_nameslist of strings: 由 transform 产生的特征名称。

get_params(deep=True)[source]#

获取此估计器的参数。

返回构造函数中给定的参数以及 ColumnTransformer 的 transformers 中包含的估计器。

参数:

deepbool, default=True: 如果为 True，将返回此估计器和包含的子对象（如果是估计器）的参数。

返回值:

paramsdict: 参数名称映射到其值。

property named_transformers_#

按名称访问已拟合的转换器。

只读属性，允许按给定的名称访问任何转换器。键是转换器名称，值是已拟合的转换器对象。

set_params(**kwargs)[source]#

设置此估计器的参数。

可以使用 get_params() 列出有效的参数键。请注意，您可以直接设置 ColumnTransformer 的 transformers 中包含的估计器的参数。

返回值:

self

transform(X) → SparseCumlArray[source]#

由每个转换器分别转换 X，并连接结果。

参数:

X{array-like, dataframe} of shape (n_samples, n_features): 要按子集转换的数据。

返回值:

X_t{array-like, sparse matrix} of shape (n_samples, sum_n_components): 转换器结果的水平堆叠。sum_n_components 是转换器输出维度 (n_components) 的总和。如果任何结果是稀疏矩阵，所有结果都将转换为稀疏矩阵。

class cuml.compose.make_column_selector(pattern=None, *, dtype_include=None, dtype_exclude=None)[source]#

创建可调用对象以选择与 ColumnTransformer 一起使用的列。

make_column_selector() 可以根据数据类型或使用正则表达式按列名选择列。当使用多个选择条件时，列必须匹配所有条件才能被选中。

参数:

patternstr, default=None: 包含此正则表达式模式的列名将被包括在内。如果为 None，则不会根据模式选择列。
dtype_includecolumn dtype or list of column dtypes, default=None: 要包括的数据类型选择。有关详细信息，请参阅 pandas.DataFrame.select_dtypes()。
dtype_excludecolumn dtype or list of column dtypes, default=None: 要排除的数据类型选择。有关详细信息，请参阅 pandas.DataFrame.select_dtypes()。

返回值:

selectorcallable: 用于 ColumnTransformer 的列选择可调用对象。

缩放数据

ColumnTransformer: 一个类，允许将应用于数据列子集的多个转换器对象的输出组合到单个特征空间中。

示例

>>> from cuml.preprocessing import StandardScaler, OneHotEncoder
>>> from cuml.compose import make_column_transformer
>>> from cuml.compose import make_column_selector
>>> import cupy as cp
>>> import cudf  
>>> X = cudf.DataFrame({'city': ['London', 'London', 'Paris', 'Sallisaw'],
...                    'rating': [5, 3, 4, 5]})  
>>> ct = make_column_transformer(
...       (StandardScaler(),
...        make_column_selector(dtype_include=cp.number)),  # rating
...       (OneHotEncoder(),
...        make_column_selector(dtype_include=object)))  # city
>>> ct.fit_transform(X)  
array([[ 0.90453403,  1.        ,  0.        ,  0.        ],
       [-1.50755672,  1.        ,  0.        ,  0.        ],
       [-0.30151134,  0.        ,  1.        ,  0.        ],
       [ 0.90453403,  0.        ,  0.        ,  1.        ]])

cuml.compose.make_column_transformer(*transformers, remainder='drop', sparse_threshold=0.3, n_jobs=None, verbose=False)[source]#

从给定的转换器构建 ColumnTransformer。

这是 ColumnTransformer 构造函数的简写形式；它不需要也不允许命名转换器。相反，它们将根据其类型自动命名。它也不允许使用 transformer_weights 进行加权。

参数:

*transformerstuples

(transformer, columns) 形式的元组，指定要应用于数据子集的转换器对象

transformer{‘drop’, ‘passthrough’} or estimator
估计器必须支持 fit 和 transform。也接受特殊字符串 'drop' 和 'passthrough'，分别表示丢弃列或不进行转换直接传递列。
columnsstr, array-like of str, int, array-like of int, slice, array-like of bool or callable
在数据的第二轴上进行索引。整数被解释为位置列，而字符串可以按名称引用 DataFrame 列。当 transformer 期望 X 是一个一维类数组（向量）时，应使用标量字符串或整数，否则将向转换器传递一个二维数组。可调用对象将输入数据 X 作为参数，并可以返回上述任何类型。要按名称或 dtype 选择多个列，可以使用 make_column_selector。

remainder{‘drop’, ‘passthrough’} or estimator, default=’drop’

sparse_thresholdfloat, default=0.3

如果转换后的输出包含稀疏和密集数据的混合，如果密度低于此值，它将被堆叠为稀疏矩阵。使用 sparse_threshold=0 可始终返回密集矩阵。当转换后的输出全部由稀疏或全部由密集数据组成时，堆叠结果将分别是稀疏或密集的，并且此关键字将被忽略。

n_jobsint, default=None

并行运行的作业数。None 表示 1，除非在 joblib.parallel_backend 上下文中。-1 表示使用所有处理器。有关详细信息，请参见 Glossary。

verbosebool, default=False

如果为 True，则将在每个转换器完成拟合时打印其经过的时间。

返回值:

ctColumnTransformer

缩放数据

ColumnTransformer: 一个类，允许将应用于数据列子集的多个转换器对象的输出组合到单个特征空间中。

示例

>>> from cuml.preprocessing import StandardScaler, OneHotEncoder
>>> from cuml.compose import make_column_transformer
>>> make_column_transformer(
...     (StandardScaler(), ['numerical_column']),
...     (OneHotEncoder(), ['categorical_column']))
ColumnTransformer(transformers=[('standardscaler', StandardScaler(...),
                                 ['numerical_column']),
                                ('onehotencoder', OneHotEncoder(...),
                                 ['categorical_column'])])

文本预处理 (单 GPU)#

class cuml.preprocessing.text.stem.PorterStemmer(mode='NLTK_EXTENSIONS')[source]#
基于 Porter 词干提取算法的词干提取器。

Porter, M. “An algorithm for suffix stripping.” Program 14.3 (1980): 130-137.

有关算法主页，请参见 http://www.tartarus.org/~martin/PorterStemmer/。

Martin Porter 在撰写原始论文后认可了对 Porter 算法的几项修改，这些扩展包含在他的网站上的实现中。此外，其他人也提出了对算法的进一步改进，包括 NLTK 贡献者。目前仅支持以下模式 PorterStemmer.NLTK_EXTENSIONS

包含 NLTK 贡献者设计的或从网络上其他修改的实现中获取的进一步改进的实现。

参数:

mode: 词干提取模式（目前仅支持 (NLTK_EXTENSIONS)）
默认值("NLTK_EXTENSIONS")

方法

stem(word_str_ser)

使用 Porter 词干提取器提取词干

示例
>>> import cudf
>>> from cuml.preprocessing.text.stem import PorterStemmer
>>> stemmer = PorterStemmer()
>>> word_str_ser =  cudf.Series(['revival','singing','adjustable'])
>>> print(stemmer.stem(word_str_ser))
0     reviv
1      sing
2    adjust
dtype: object
stem(word_str_ser)[source]#

使用 Porter 词干提取器提取词干

参数:

word_str_sercudf.Series
要提取词干的单词字符串系列

返回值:

stemmed_sercudf.Series
提取词干后的单词字符串系列

特征和标签编码 (基于 Dask 的多 GPU)#

class cuml.dask.preprocessing.LabelBinarizer(*, client=None, **kwargs)[source]#
用于对标签集合进行独热编码的分布式 LabelBinarizer 版本。

方法

fit(y)

拟合标签二值化器

fit_transform(y)

拟合标签编码器并返回转换后的标签

inverse_transform(y[, threshold])

将一组编码标签反向转换回原始标签

transform(y)

转换并返回编码标签

示例

创建一个带有标签的数组并对其进行虚拟编码
>>> import cupy as cp
>>> import cupyx
>>> from cuml.dask.preprocessing import LabelBinarizer

>>> from dask_cuda import LocalCUDACluster
>>> from dask.distributed import Client
>>> import dask

>>> cluster = LocalCUDACluster()
>>> client = Client(cluster)

>>> labels = cp.asarray([0, 5, 10, 7, 2, 4, 1, 0, 0, 4, 3, 2, 1],
...                     dtype=cp.int32)
>>> labels = dask.array.from_array(labels)

>>> lb = LabelBinarizer()
>>> encoded = lb.fit_transform(labels)
>>> print(encoded.compute())
[[1 0 0 0 0 0 0 0]
[0 0 0 0 0 1 0 0]
[0 0 0 0 0 0 0 1]
[0 0 0 0 0 0 1 0]
[0 0 1 0 0 0 0 0]
[0 0 0 0 1 0 0 0]
[0 1 0 0 0 0 0 0]
[1 0 0 0 0 0 0 0]
[1 0 0 0 0 0 0 0]
[0 0 0 0 1 0 0 0]
[0 0 0 1 0 0 0 0]
[0 0 1 0 0 0 0 0]
[0 1 0 0 0 0 0 0]]
>>> decoded = lb.inverse_transform(encoded)
>>> print(decoded.compute())
[ 0  5 10  7  2  4  1  0  0  4  3  2  1]
>>> client.close()
>>> cluster.close()
fit(y)[source]#

拟合标签二值化器

参数:

yDask.Array of shape [n_samples,] or [n_samples, n_classes]
按行分块。目标值。二维矩阵应只包含 0 和 1，表示多标签分类。

返回值:

self返回自身的实例。

fit_transform(y)[source]#

拟合标签编码器并返回转换后的标签

参数:

yDask.Array of shape [n_samples,] or [n_samples, n_classes]
目标值。二维矩阵应只包含 0 和 1，表示多标签分类。

返回值:

arrDask.Array backed by CuPy arrays containing encoded labels

由 CuPy 数组支持的 Dask.Array，包含编码标签

将一组编码标签反向转换回原始标签

参数:

inverse_transform(y, threshold=None)[source]#
标签的 Dask.Array，形状为 [n_samples, n_classes]，包含编码

thresholdfloat This value is currently ignored

返回值:

此值当前被忽略

arrDask.Array backed by CuPy arrays containing original labels

转换并返回编码标签

参数:

yDask.Array of shape [n_samples,] or [n_samples, n_classes]

返回值:

arrDask.Array backed by CuPy arrays containing encoded labels
class cuml.dask.preprocessing.LabelEncoder.LabelEncoder(*, client=None, verbose=False, **kwargs)[source]#
基于 cuDF 的有序标签编码实现

参数:

handle_unknown{‘error’, ‘ignore’}，默认值=’error’
在转换过程中是否存在未知分类特征时是否引发错误或忽略（默认为引发）。当此参数设置为 ‘ignore’ 并且在转换或逆转换过程中遇到未知类别时，结果编码将为 null。

方法

fit(y)

拟合 LabelEncoder 实例到一组类别

fit_transform(y[, delayed])

同时拟合和转换输入

inverse_transform(y[, delayed])

将数据转换回原始表示。

transform(y[, delayed])

将输入转换为其类别键。

示例

将类别实现转换为数值实现
>>> from dask_cuda import LocalCUDACluster
>>> from dask.distributed import Client
>>> import cudf
>>> import dask_cudf
>>> from cuml.dask.preprocessing import LabelEncoder

>>> import pandas as pd
>>> pd.set_option('display.max_colwidth', 2000)

>>> cluster = LocalCUDACluster(threads_per_worker=1)
>>> client = Client(cluster)
>>> df = cudf.DataFrame({'num_col':[10, 20, 30, 30, 30],
...                    'cat_col':['a','b','c','a','a']})
>>> ddf = dask_cudf.from_cudf(df, npartitions=2)

>>> # There are two functionally equivalent ways to do this
>>> le = LabelEncoder()
>>> le.fit(ddf.cat_col)  # le = le.fit(data.category) also works
<cuml.dask.preprocessing.LabelEncoder.LabelEncoder object at 0x...>
>>> encoded = le.transform(ddf.cat_col)
>>> print(encoded.compute())
0    0
1    1
2    2
3    0
4    0
dtype: uint8

>>> # This method is preferred
>>> le = LabelEncoder()
>>> encoded = le.fit_transform(ddf.cat_col)
>>> print(encoded.compute())
0    0
1    1
2    2
3    0
4    0
dtype: uint8

>>> # We can assign this to a new column
>>> ddf = ddf.assign(encoded=encoded.values)
>>> print(ddf.compute())
num_col cat_col  encoded
0       10       a        0
1       20       b        1
2       30       c        2
3       30       a        0
4       30       a        0
>>> # We can also encode more data
>>> test_data = cudf.Series(['c', 'a'])
>>> encoded = le.transform(dask_cudf.from_cudf(test_data,
...                                            npartitions=2))
>>> print(encoded.compute())
0    2
1    0
dtype: uint8

>>> # After train, ordinal label can be inverse_transform() back to
>>> # string labels
>>> ord_label = cudf.Series([0, 0, 1, 2, 1])
>>> ord_label = le.inverse_transform(
...    dask_cudf.from_cudf(ord_label,npartitions=2))

>>> print(ord_label.compute())
0    a
1    a
2    b
3    c
4    b
dtype: object
>>> client.close()
>>> cluster.close()
fit(y)[source]#

拟合 LabelEncoder 实例到一组类别

参数:

ydask_cudf.Series
包含待编码类别的 Series。其元素可以重复。

返回值:

selfLabelEncoder
一个已拟合的自身实例，允许方法链式调用

注意

将在客户端收集唯一类别数。它将消耗与唯一类别数成比例的内存。

fit_transform(y, delayed=True)[source]#

同时拟合和转换输入

此方法在功能上等同于 (但速度快于) LabelEncoder().fit(y).transform(y)

inverse_transform(y, delayed=True)[source]#

将数据转换回原始表示。如果遇到未知类别（独热编码中全为零），则使用 None 表示该类别。

参数:

Xdask_cudf Series
类别的字符串表示。

delayedbool (默认 = True)
是否作为延迟任务或立即执行。

返回值:

X_trdask_cudf.Series
包含反向转换后数组的分布式对象。

transform(y, delayed=True)[source]#

将输入转换为其类别键。

此方法旨在用于相对于数据集大小较小的输入。对于整个数据集的拟合和转换，优先使用fit_transform。

参数:

ydask_cudf.Series
待转换的输入键。其值应与提供给fit的类别匹配。

返回值:

encodeddask_cudf.Series
经过有序编码的输入 Series

引发:

KeyError
如果在fit中未见的类别出现
class cuml.dask.preprocessing.OneHotEncoder(*, client=None, verbose=False, **kwargs)[source]#

将类别特征编码为独热（one-hot）数字数组。此转换器的输入应为 dask_cuDF.DataFrame 或 cupy dask.Array，表示类别特征所取的值。这些特征使用独热（又称 'one-of-K' 或 'dummy'）编码方案进行编码。这将为每个类别创建一个二进制列，并返回一个稀疏矩阵或密集数组（取决于 sparse 参数）。默认情况下，编码器基于每个特征中的唯一值推导出类别。或者，您也可以手动指定 categories。

参数:

categories‘auto’, cupy.ndarray or cudf.DataFrame, default=’auto’
每个特征的类别（唯一值）。所有类别预计都能容纳在一块 GPU 上。

‘auto’ : 从训练数据中自动确定类别。

DataFrame/ndarray : categories[col] 包含特征列中预期的类别。

drop‘first’, None or a dict, default=None
指定用于丢弃每个特征中一个类别的方法。这在完美共线特征导致问题的场景中非常有用，例如将结果数据馈送到神经网络或未正则化回归时。

None : 保留所有特征（默认）。

‘first’ : 丢弃每个特征中的第一个类别。如果只存在一个类别，则整个特征将被丢弃。

字典：drop[col] 是特征 col 中应该被丢弃的类别。

sparsebool, default=False
此功能已停用，当设置为 True 时会引发异常。原因是稀疏矩阵尚未完全受 cupy 支持，导致计算独热编码时值不正确。参见 cupy/cupy#3223

dtype数值类型，默认值=np.float
转换输出所需的数值类型。

handle_unknown{‘error’, ‘ignore’}，默认值=’error’
在转换过程中是否存在未知分类特征时是否引发错误或忽略（默认为引发）。当此参数设置为 ‘ignore’ 并且在转换过程中遇到未知类别时，该特征对应的独热编码列将全部为零。在逆转换中，未知类别将表示为 None。

方法

fit(X)

拟合多节点多 GPU OneHotEncoder 到 X。

inverse_transform(X[, delayed])

将数据转换回原始表示。

transform(X[, delayed])

使用独热编码转换 X。

fit(X)[source]#

拟合多节点多 GPU OneHotEncoder 到 X。

参数:

XDask cuDF DataFrame 或 CuPy backed Dask Array
用于确定每个特征类别的输入数据。

返回值:

self

inverse_transform(X, delayed=True)[source]#

将数据转换回原始表示。如果遇到未知类别（独热编码中全为零），则使用 None 表示该类别。

参数:

XCuPy backed Dask Array, shape [n_samples, n_encoded_features]
转换后的数据。

delayedbool (默认 = True)
是否作为延迟任务或立即执行。

返回值:

X_trDask cuDF DataFrame 或 CuPy backed Dask Array
包含反向转换后数组的分布式对象。

transform(X, delayed=True)[source]#

使用独热编码转换 X。

参数:

XDask cuDF DataFrame 或 CuPy backed Dask Array
待编码的数据。

delayedbool (默认 = True)
是否作为延迟任务或立即执行。

返回值:

outDask cuDF DataFrame 或 CuPy backed Dask Array
包含转换后输入的分布式对象。

特征提取 (单 GPU)#

class cuml.feature_extraction.text.CountVectorizer(input=None, encoding=None, decode_error=None, strip_accents=None, lowercase=True, preprocessor=None, tokenizer=None, stop_words=None, token_pattern=None, ngram_range=(1, 1), analyzer='word', max_df=1.0, min_df=1, max_features=None, vocabulary=None, binary=False, dtype=<class 'numpy.float32'>, delimiter=' ')[source]#

将文本文档集合转换为词元计数矩阵

如果您未提供先验词典，则特征数量将等于通过分析数据找到的词汇表大小。

参数:

lowercaseboolean, 默认为 True
在分词前将所有字符转换为小写。

preprocessorcallable 或 None (默认)
在保留分词和 N-gram 生成步骤的同时，覆盖预处理（字符串转换）阶段。

stop_wordsstring {‘english’}, list, or None (默认)
如果为 ‘english’，则使用内置的英语停用词列表。如果为列表，则假定该列表包含停用词，所有这些停用词将从输入文档中移除。如果为 None，则不使用停用词。可以将 max_df 设置为一个值，以便根据语料库内词项的文档频率自动检测和过滤停用词。

ngram_rangetuple (min_n, max_n), 默认=(1, 1)
待提取的不同词 N-gram 或字符 N-gram 的 N 值范围的下限和上限。将使用所有满足 min_n <= n <= max_n 的 N 值。例如，ngram_range 为 (1, 1) 意味着只使用 unigrams，(1, 2) 意味着使用 unigrams 和 bigrams，而 (2, 2) 意味着只使用 bigrams。

analyzerstring, {‘word’, ‘char’, ‘char_wb’}
特征是应该由词 N-gram 构成还是字符 N-gram 构成。选项 ‘char_wb’ 仅从词边界内的文本创建字符 N-gram；词边界处的 N-gram 会用空格填充。

max_dffloat in range [0.0, 1.0] 或 int, 默认=1.0
构建词汇表时，忽略文档频率严格高于给定阈值（语料库特定停用词）的词项。如果为 float，则参数表示文档比例；如果为 int，则表示绝对计数。如果 vocabulary 不为 None，则忽略此参数。

min_dffloat in range [0.0, 1.0] 或 int, 默认=1
构建词汇表时，忽略文档频率严格低于给定阈值的词项。这个值在文献中也称为截止值。如果为 float，则参数表示文档比例；如果为 int，则表示绝对计数。如果 vocabulary 不为 None，则忽略此参数。

max_featuresint 或 None, 默认=None
如果不为 None，则构建一个只考虑在语料库中按词项频率排序的前 max_features 个词项的词汇表。如果 vocabulary 不为 None，则忽略此参数。

vocabularycudf.Series, 可选
如果未给出，则从输入文档中确定词汇表。

binaryboolean, 默认=False
如果为 True，所有非零计数都设置为 1。这对于对二进制事件而不是整数计数进行建模的离散概率模型很有用。

dtypetype, 可选
fit_transform() 或 transform() 返回的矩阵的类型。

delimiterstr, 默认为空格
如果 stop_words 不为 None，则用作停用词的替换字符串。通常，单词之间的分隔符是一个不错的选择。

属性:

vocabulary_cudf.Series[str]
将特征整数索引映射到特征名称的数组。

stop_words_cudf.Series[str]

被忽略的词项，因为它们

出现在太多文档中 (max_df)

出现在太少文档中 (min_df)

被特征选择 (max_features) 截断。

仅在未给定词汇表时可用。

方法

fit(raw_documents[, y])

构建原始文档中所有词元的词汇表。

fit_transform(raw_documents[, y])

构建词汇表并返回文档-词项矩阵。

get_feature_names()

将特征整数索引映射到特征名称的数组。

inverse_transform(X)

返回 X 中非零项对应的每文档词项。

transform(raw_documents)

将文档转换为文档-词项矩阵。

fit(raw_documents, y=None)[source]#

构建原始文档中所有词元的词汇表。

参数:

raw_documentscudf.Series or pd.Series
一系列字符串文档

yNone
用于计算按特征轴进行后续缩放的均值和标准差的数据。

返回值:

self

fit_transform(raw_documents, y=None)[source]#

构建词汇表并返回文档-词项矩阵。

等同于 self.fit(X).transform(X) 但只预处理 X 一次。

参数:

raw_documentscudf.Series or pd.Series
一系列字符串文档

yNone
用于计算按特征轴进行后续缩放的均值和标准差的数据。

返回值:

Xcupy csr array of shape (n_samples, n_features)
文档-词项矩阵。

get_feature_names()[source]#

将特征整数索引映射到特征名称的数组。

返回值:

feature_namesSeries
特征名称列表。

inverse_transform(X)[source]#

返回 X 中非零项对应的每文档词项。

参数:

X形状为 (n_samples, n_features) 的 array-like 对象
文档-词项矩阵。

返回值:

X_invlist of cudf.Series of shape (n_samples,)
词项 Series 列表。

transform(raw_documents)[source]#

将文档转换为文档-词项矩阵。

使用通过 fit 拟合的词汇表或构造函数提供的词汇表从原始文本文档中提取词元计数。

参数:

raw_documentscudf.Series or pd.Series
一系列字符串文档

返回值:

Xcupy csr array of shape (n_samples, n_features)
文档-词项矩阵。
class cuml.feature_extraction.text.HashingVectorizer(input=None, encoding=None, decode_error=None, strip_accents=None, lowercase=True, preprocessor=None, tokenizer=None, stop_words=None, token_pattern=None, ngram_range=(1, 1), analyzer='word', n_features=1048576, binary=False, norm='l2', alternate_sign=True, dtype=<class 'numpy.float32'>, delimiter=' ')[source]#
将文本文档集合转换为词元出现次数矩阵

它将文本文档集合转换为 cupyx.scipy.sparse 矩阵，该矩阵包含词元出现次数（或二进制出现信息），如果 norm='l1' 则可能归一化为词元频率，如果 norm='l2' 则投影到欧几里得单位球面。

此文本向量化器实现使用哈希技巧来查找词元字符串名称到特征整数索引的映射。

这种策略有几个优点

它内存占用非常低，可扩展到大型数据集，因为无需在内存中存储词汇表字典，这对于内存受限的 GPU 尤其重要

它序列化和反序列化速度很快，因为它除了构造函数参数外不持有任何状态

它可以在流式 (部分拟合) 或并行管道中使用，因为在拟合过程中不计算任何状态。

也有一些缺点 (相对于使用带内存词汇表的 CountVectorizer)

无法计算反向转换 (从特征索引到字符串特征名称)，这在尝试内省哪些特征对模型最重要时可能是一个问题。

可能存在冲突：不同的词元可以映射到相同的特征索引。然而，在实践中，如果 n_features 足够大 (例如，文本分类问题中为 2 ** 18)，这很少是问题。

没有 IDF 加权，因为这会使转换器变为有状态。

使用的哈希函数是 Murmurhash3 的带符号 32 位版本。

参数:

lowercasebool, 默认=True
在分词前将所有字符转换为小写。

preprocessorcallable 或 None (默认)
在保留分词和 N-gram 生成步骤的同时，覆盖预处理（字符串转换）阶段。

stop_wordsstring {‘english’}, list, 默认=None
如果为 ‘english’，则使用内置的英语停用词列表。已知 ‘english’ 存在一些问题，您应考虑替代方案。如果为列表，则假定该列表包含停用词，所有这些停用词将从生成的词元中移除。仅在 analyzer == 'word' 时适用。

ngram_rangetuple (min_n, max_n), 默认=(1, 1)
待提取的不同词 N-gram 或字符 N-gram 的 N 值范围的下限和上限。将使用所有满足 min_n <= n <= max_n 的 N 值。例如，ngram_range 为 (1, 1) 意味着只使用 unigrams，(1, 2) 意味着使用 unigrams 和 bigrams，而 (2, 2) 意味着只使用 bigrams。

analyzerstring, {‘word’, ‘char’, ‘char_wb’}
特征是应该由词 N-gram 构成还是字符 N-gram 构成。选项 ‘char_wb’ 仅从词边界内的文本创建字符 N-gram；词边界处的 N-gram 会用空格填充。

n_featuresint, 默认=(2 ** 20)
输出矩阵中的特征 (列) 数量。较小的特征数量可能导致哈希冲突，但较大的数量会导致线性学习器中的系数维度更大。

binarybool, 默认=False。
如果为 True，所有非零计数都设置为 1。这对于对二进制事件而不是整数计数进行建模的离散概率模型很有用。

norm{‘l1’, ‘l2’}, 默认=’l2’
用于归一化词项向量的范数。None 表示不进行归一化。

alternate_signbool, 默认=True
如果为 True，则在特征中添加一个交替符号，以便即使对于较小的 n_features，也能大致保留哈希空间中的内积。此方法类似于稀疏随机投影。

dtypetype, 可选
fit_transform() 或 transform() 返回的矩阵的类型。

delimiterstr, 默认为空格
如果 stop_words 不为 None，则用作停用词的替换字符串。通常，单词之间的分隔符是一个不错的选择。

方法

fit(X[, y])

此方法仅检查输入类型和模型参数。

fit_transform(X[, y])

将文档序列转换为文档-词项矩阵。

partial_fit(X[, y])

不执行任何操作：此转换器是无状态的。此方法仅用于标记此转换器可以在流式设置中工作。

transform(raw_documents)

将文档转换为文档-词项矩阵。

缩放数据

CountVectorizer, TfidfVectorizer

示例
>>> from cuml.feature_extraction.text import HashingVectorizer
>>> import pandas as pd
>>> corpus = [
...     'This is the first document.',
...     'This document is the second document.',
...     'And this is the third one.',
...     'Is this the first document?',
... ]
>>> vectorizer = HashingVectorizer(n_features=2**4)
>>> X = vectorizer.fit_transform(pd.Series(corpus))
>>> print(X.shape)
(4, 16)
fit(X, y=None)[source]#

此方法仅检查输入类型和模型参数。它不执行任何有意义的操作，因为此转换器是无状态的

参数:

Xcudf.Series or pd.Series
一系列字符串文档

fit_transform(X, y=None)[source]#

将文档序列转换为文档-词项矩阵。

参数:

Xiterable over raw text documents, length = n_samples
样本。每个样本必须是文本文档（根据构造函数参数，可以是字节串或 unicode 字符串、文件名或文件对象），将被分词和哈希。

yany
被忽略。此参数仅为与 sklearn.pipeline.Pipeline 兼容而存在。

返回值:

Xsparse CuPy CSR matrix of shape (n_samples, n_features)
文档-词项矩阵。

partial_fit(X, y=None)[source]#

不执行任何操作：此转换器是无状态的。此方法仅用于标记此转换器可以在流式设置中工作。

参数:

Xcudf.Series(一系列字符串文档).

transform(raw_documents)[source]#

将文档转换为文档-词项矩阵。

使用通过 fit 拟合的词汇表或构造函数提供的词汇表从原始文本文档中提取词元计数。

参数:

raw_documentscudf.Series or pd.Series
一系列字符串文档

返回值:

Xsparse CuPy CSR matrix of shape (n_samples, n_features)
文档-词项矩阵。
class cuml.feature_extraction.text.TfidfVectorizer(input=None, encoding=None, decode_error=None, strip_accents=None, lowercase=True, preprocessor=None, tokenizer=None, stop_words=None, token_pattern=None, ngram_range=(1, 1), analyzer='word', max_df=1.0, min_df=1, max_features=None, vocabulary=None, binary=False, dtype=<class 'numpy.float32'>, delimiter=' ', norm='l2', use_idf=True, smooth_idf=True, sublinear_tf=False)[source]#

将原始文档集合转换为 TF-IDF 特征矩阵。

等同于先执行 CountVectorizer，然后执行 TfidfTransformer。

参数:

lowercaseboolean, 默认为 True
在分词前将所有字符转换为小写。

preprocessorcallable 或 None (默认)
在保留分词和 N-gram 生成步骤的同时，覆盖预处理（字符串转换）阶段。

stop_wordsstring {‘english’}, list, or None (默认)
如果为 ‘english’，则使用内置的英语停用词列表。如果为列表，则假定该列表包含停用词，所有这些停用词将从输入文档中移除。如果为 None，则不使用停用词。可以将 max_df 设置为一个值，以便根据语料库内词项的文档频率自动检测和过滤停用词。

ngram_rangetuple (min_n, max_n), 默认=(1, 1)
待提取的不同词 N-gram 或字符 N-gram 的 N 值范围的下限和上限。将使用所有满足 min_n <= n <= max_n 的 N 值。例如，ngram_range 为 (1, 1) 意味着只使用 unigrams，(1, 2) 意味着使用 unigrams 和 bigrams，而 (2, 2) 意味着只使用 bigrams。

analyzerstring, {‘word’, ‘char’, ‘char_wb’}, 默认=’word’
特征是应该由词 N-gram 构成还是字符 N-gram 构成。选项 ‘char_wb’ 仅从词边界内的文本创建字符 N-gram；词边界处的 N-gram 会用空格填充。

max_dffloat in range [0.0, 1.0] 或 int, 默认=1.0
构建词汇表时，忽略文档频率严格高于给定阈值（语料库特定停用词）的词项。如果为 float，则参数表示文档比例；如果为 int，则表示绝对计数。如果 vocabulary 不为 None，则忽略此参数。

min_dffloat in range [0.0, 1.0] 或 int, 默认=1
构建词汇表时，忽略文档频率严格低于给定阈值的词项。这个值在文献中也称为截止值。如果为 float，则参数表示文档比例；如果为 int，则表示绝对计数。如果 vocabulary 不为 None，则忽略此参数。

max_featuresint 或 None, 默认=None
如果不为 None，则构建一个只考虑在语料库中按词项频率排序的前 max_features 个词项的词汇表。如果 vocabulary 不为 None，则忽略此参数。

vocabularycudf.Series, 可选
如果未给出，则从输入文档中确定词汇表。

binaryboolean, 默认=False
如果为 True，所有非零计数都设置为 1。这对于对二进制事件而不是整数计数进行建模的离散概率模型很有用。

dtypetype, 可选
fit_transform() 或 transform() 返回的矩阵的类型。

delimiterstr, 默认为空格
如果 stop_words 不为 None，则用作停用词的替换字符串。通常，单词之间的分隔符是一个不错的选择。

norm{‘l1’, ‘l2’}, 默认=’l2’

每个输出行将具有单位范数，或者

‘l2’：向量元素的平方和为 1。应用 l2 范数后，两个向量之间的余弦相似度等于它们的点积。

‘l1’：向量元素的绝对值之和为 1。

use_idfbool, 默认=True
启用逆文档频率重新加权。

smooth_idfbool, 默认=True
通过给文档频率加一来平滑 idf 权重，就像看到了一个额外的文档，其中包含集合中的每个词项恰好一次。防止零除。

sublinear_tfbool, 默认=False
应用次线性 tf 缩放，即用 1 + log(tf) 替换 tf。

属性:

idf_array of shape (n_features)
逆文档频率 (IDF) 向量；仅当 use_idf 为 True 时定义。

vocabulary_cudf.Series[str]
将特征整数索引映射到特征名称的数组。

stop_words_cudf.Series[str]

被忽略的词项，因为它们

出现在太多文档中 (max_df)

出现在太少文档中 (min_df)

被特征选择 (max_features) 截断。

仅在未给定词汇表时可用。

方法

fit(raw_documents)

从训练集中学习词汇表和 idf。

fit_transform(raw_documents[, y])

学习词汇表和 idf，返回文档-词项矩阵。

get_feature_names()

将特征整数索引映射到特征名称的数组。

transform(raw_documents)

将文档转换为文档-词项矩阵。

注意

stop_words_ 属性可能会变得很大，并在序列化时增加模型大小。此属性仅用于自省，在序列化之前可以使用 delattr 安全地移除或设置为 None。

此类主要基于 scikit-learn 0.23.1 的 TfIdfVectorizer 代码，该代码在 BSD-3 许可下提供。

fit(raw_documents)[source]#

从训练集中学习词汇表和 idf。

参数:

raw_documentscudf.Series or pd.Series
一系列字符串文档

返回值:

忽略。
拟合后的向量化器。

fit_transform(raw_documents, y=None)[source]#

学习词汇表和 idf，返回文档-词项矩阵。这等同于先 fit 再 transform，但实现更高效。

参数:

raw_documentscudf.Series or pd.Series
一系列字符串文档

yNone
用于计算按特征轴进行后续缩放的均值和标准差的数据。

返回值:

Xcupy csr array of shape (n_samples, n_features)
Tf-idf 加权的文档-词项矩阵。

get_feature_names()[source]#

将特征整数索引映射到特征名称的数组。

返回值:

feature_namesSeries
特征名称列表。

transform(raw_documents)[source]#

将文档转换为文档-词项矩阵。使用通过 fit（或 fit_transform）学习的词汇表和文档频率（df）。

参数:

raw_documentscudf.Series or pd.Series
一系列字符串文档

返回值:

Xcupy csr array of shape (n_samples, n_features)
Tf-idf 加权的文档-词项矩阵。

特征提取 (基于 Dask 的多 GPU)#

class cuml.dask.feature_extraction.text.TfidfTransformer(*, client=None, verbose=False, **kwargs)[source]#
分布式 TF-IDF 转换器

方法

fit(X[, y])

拟合分布式 TFIDF Transformer

fit_transform(X[, y])

拟合分布式 TFIDFTransformer，然后转换给定的数据集样本。

transform(X[, y])

使用分布式 TFIDFTransformer 转换给定的数据集样本。

示例
>>> import cupy as cp
>>> from sklearn.datasets import fetch_20newsgroups
>>> from sklearn.feature_extraction.text import CountVectorizer
>>> from dask_cuda import LocalCUDACluster
>>> from dask.distributed import Client
>>> from cuml.dask.common import to_sparse_dask_array
>>> from cuml.dask.naive_bayes import MultinomialNB
>>> import dask
>>> from cuml.dask.feature_extraction.text import TfidfTransformer

>>> # Create a local CUDA cluster
>>> cluster = LocalCUDACluster()
>>> client = Client(cluster)

>>> # Load corpus
>>> twenty_train = fetch_20newsgroups(subset='train',
...                         shuffle=True, random_state=42)
>>> cv = CountVectorizer()
>>> xformed = cv.fit_transform(twenty_train.data).astype(cp.float32)
>>> X = to_sparse_dask_array(xformed, client)

>>> y = dask.array.from_array(twenty_train.target, asarray=False,
...                     fancy=False).astype(cp.int32)

>>> multi_gpu_transformer = TfidfTransformer()
>>> X_transformed = multi_gpu_transformer.fit_transform(X)
>>> X_transformed.compute_chunk_sizes()
dask.array<...>

>>> model = MultinomialNB()
>>> model.fit(X_transformed, y)
<cuml.dask.naive_bayes.naive_bayes.MultinomialNB object at 0x...>
>>> result = model.score(X_transformed, y)
>>> print(result) 
array(0.93264981)
>>> client.close()
>>> cluster.close()
fit(X, y=None)[source]#

拟合分布式 TFIDF Transformer

参数:

Xdask.Array with blocks containing dense or sparse cupy arrays

返回值:

cuml.dask.feature_extraction.text.TfidfTransformer 实例

fit_transform(X, y=None)[source]#

拟合分布式 TFIDFTransformer，然后转换给定的数据集样本。

参数:

Xdask.Array with blocks containing dense or sparse cupy arrays

返回值:

包含转换后稀疏 cupy 数组块的 dask.Array

transform(X, y=None)[source]#

使用分布式 TFIDFTransformer 转换给定的数据集样本。

参数:

Xdask.Array with blocks containing dense or sparse cupy arrays

返回值:

包含转换后稀疏 cupy 数组块的 dask.Array

数据集生成 (单 GPU)#

random_state#
确定数据集生成的随机数生成。传入一个整数以在多次函数调用中获得可复现的输出。
cuml.datasets.make_blobs(n_samples=100, n_features=2, centers=None, cluster_std=1.0, center_box=(-10.0, 10.0), shuffle=True, random_state=None, return_centers=False, order='F', dtype='float32')[source]#
生成用于聚类的各向同性高斯斑点。

参数:

n_samplesint 或 array-like, optional (default=100)
如果为 int，则表示平均分配到簇的总点数。如果为 array-like，则序列中的每个元素表示每个簇的样本数。

n_featuresint, optional (default=2)
每个样本的特征数量。

centersint or array of shape [n_centers, n_features], optional
(default=None) 要生成的中心数量，或固定的中心位置。如果 n_samples 为 int 且 centers 为 None，则生成 3 个中心。如果 n_samples 为 array-like，则 centers 必须为 None 或长度等于 n_samples 长度的数组。

cluster_stdfloat or sequence of floats, optional (default=1.0)
簇的标准差。

center_boxpair of floats (min, max), optional (default=(-10.0, 10.0))
随机生成中心时，每个簇中心的边界框。

shuffleboolean, optional (default=True)
打乱样本。

random_stateint, RandomState instance, default=None
确定数据集生成的随机数生成。传入一个整数以在多次函数调用中获得可复现的输出。

return_centersbool, optional (default=False)
如果为 True，则返回每个簇的中心

order: str, optional (default=’F’)
生成样本的顺序

dtypestr, optional (default=’float32’)
生成样本的数据类型

返回值:

Xdevice array of shape [n_samples, n_features]
生成的样本。

ydevice array of shape [n_samples]
每个样本的簇成员资格的整数标签。

centersdevice array, shape [n_centers, n_features]
每个簇的中心。仅当 return_centers=True 时返回。

缩放数据

make_classification
一个更复杂的变体

示例
>>> from sklearn.datasets import make_blobs
>>> X, y = make_blobs(n_samples=10, centers=3, n_features=2,
...                   random_state=0)
>>> print(X.shape)
(10, 2)
>>> y
array([0, 0, 1, 0, 2, 2, 2, 1, 1, 0])
>>> X, y = make_blobs(n_samples=[3, 3, 4], centers=None, n_features=2,
...                   random_state=0)
>>> print(X.shape)
(10, 2)
>>> y
array([0, 1, 2, 0, 2, 2, 2, 1, 1, 0])
cuml.datasets.make_classification(n_samples=100, n_features=20, n_informative=2, n_redundant=2, n_repeated=0, n_classes=2, n_clusters_per_class=2, weights=None, flip_y=0.01, class_sep=1.0, hypercube=True, shift=0.0, scale=1.0, shuffle=True, random_state=None, order='F', dtype='float32', _centroids=None, _informative_covariance=None, _redundant_covariance=None, _repeated_indices=None)[source]#
生成随机的 n 类分类问题。这最初会在 n_informative 维超立方体的顶点周围创建正态分布（标准差=1）的点簇，超立方体的边长为 2*class_sep，并将相等数量的簇分配给每个类别。它在这些特征之间引入相互依赖性，并向数据添加各种类型的进一步噪声。不进行打乱时，X 按以下顺序水平堆叠特征：主要的 n_informative 特征，接着是信息特征的 n_redundant 个线性组合特征，接着是 n_repeated 个重复特征，这些重复特征从信息特征和冗余特征中随机有放回地抽取。其余特征填充随机噪声。因此，不进行打乱时，所有有用的特征都包含在列 X[:, :n_informative + n_redundant + n_repeated] 中。

参数:

n_samplesint, optional (default=100)
样本数量。

n_featuresint, optional (default=20)
总特征数量。这些特征包括 n_informative 个信息特征、n_redundant 个冗余特征、n_repeated 个重复特征以及随机抽取的 n_features-n_informative-n_redundant-n_repeated 个无用特征。

n_informativeint, optional (default=2)
信息特征的数量。每个类别由若干个高斯簇组成，每个簇围绕着一个 n_informative 维子空间中的超立方体顶点。对于每个簇，信息特征独立地从 N(0, 1) 抽取，然后在每个簇内进行随机线性组合以增加协方差。随后将簇放置在超立方体的顶点上。

n_redundantint, optional (default=2)
冗余特征的数量。这些特征是信息特征的随机线性组合。

n_repeatedint, optional (default=0)
重复特征的数量，从信息特征和冗余特征中随机有放回地抽取。

n_classesint, optional (default=2)
分类问题的类别（或标签）数量。

n_clusters_per_classint, optional (default=2)
每个类别的簇数量。

weightsarray-like of shape (n_classes,) or (n_classes - 1,), (default=None)
分配给每个类别的样本比例。如果为 None，则类别是平衡的。请注意，如果 len(weights) == n_classes - 1，则最后一个类别的权重会自动推断。如果 weights 的总和超过 1，则可能返回超过 n_samples 个样本。

flip_yfloat, optional (default=0.01)
其类别被随机分配的样本比例。值越大，标签中的噪声越多，分类任务越困难。

class_sepfloat, optional (default=1.0)
超立方体尺寸的乘法因子。值越大，簇/类别分布越分散，分类任务越容易。

hypercubeboolean, optional (default=True)
如果为 True，簇放置在超立方体的顶点上。如果为 False，簇放置在随机多边形的顶点上。

shiftfloat, array of shape [n_features] or None, optional (default=0.0)
按指定值偏移特征。如果为 None，则特征按在 [-class_sep, class_sep] 中抽取的随机值偏移。

scalefloat, array of shape [n_features] or None, optional (default=1.0)
按指定值缩放特征。如果为 None，则特征按在 [1, 100] 中抽取的随机值缩放。注意：缩放发生在偏移之后。

shuffleboolean, optional (default=True)
打乱样本和特征。

random_stateint, RandomState instance 或 None (默认)
确定数据集创建的随机数生成。传入一个整数以在多次函数调用中获得可复现的输出。参见术语表。

order: str, optional (default=’F’)
生成样本的顺序

dtypestr, optional (default=’float32’)
生成样本的数据类型

_centroids: array of centroids of shape (n_clusters, n_informative)

_informative_covariance: array for covariance between informative features
形状为 (n_clusters, n_informative, n_informative) 的信息特征间协方差数组

_redundant_covariance: array for covariance between redundant features
形状为 (n_informative, n_redundant) 的冗余特征间协方差数组

_repeated_indices: array of indices for the repeated features
形状为 (n_repeated, ) 的重复特征索引数组

返回值:

Xdevice array of shape [n_samples, n_features]
生成的样本。

ydevice array of shape [n_samples]
每个样本的类别成员资格的整数标签。

注意

该算法改编自 Guyon [1]，旨在生成“Madelon”数据集。我们如何针对 GPU 进行了优化：

首先，我们从标准的单变量而不是零生成 X。这节省了内存，因为我们不需要为每个特征类别（信息特征、重复特征等）每次生成单变量，同时也提供了在 GPU 上生成大矩阵的加速。

我们生成 order=F 结构。我们利用 X 是从单变量正态分布生成的这一事实，并且协方差是通过矩阵乘法引入的。这意味着，我们可以将 X 生成为一维数组，然后将其重塑为所需的顺序，这只会更新元数据并消除复制。

最后，我们还通过构造进行打乱。中心点索引会为每个样本进行排列，然后我们为每个中心点构造数据。这种打乱适用于 order=C 和 order=F，并消除了任何二次复制的需求。

参考

[1]
I. Guyon, “Design of experiments for the NIPS 2003 variable selection benchmark”, 2003.

示例
>>> from cuml.datasets.classification import make_classification

>>> X, y = make_classification(n_samples=10, n_features=4,
...                            n_informative=2, n_classes=2,
...                            random_state=10)

>>> print(X) 
[[-1.7974224   0.24425316  0.39062843 -0.38293394]
[ 0.6358963   1.4161923   0.06970507 -0.16085647]
[-0.22802866 -1.1827322   0.3525861   0.276615  ]
[ 1.7308872   0.43080002  0.05048406  0.29837844]
[-1.9465544   0.5704457  -0.8997551  -0.27898186]
[ 1.0575483  -0.9171263   0.09529338  0.01173469]
[ 0.7917619  -1.0638094  -0.17599393 -0.06420116]
[-0.6686142  -0.13951421 -0.6074711   0.21645583]
[-0.88968956 -0.914443    0.1302423   0.02924336]
[-0.8817671  -0.84549576  0.1845096   0.02556021]]

>>> print(y)
[1 0 1 1 1 1 1 1 1 0]
cuml.datasets.make_regression(n_samples=100, n_features=2, n_informative=2, n_targets=1, bias=0.0, effective_rank=None, tail_strength=0.5, noise=0.0, shuffle=True, coef=False, random_state=None, dtype='single', handle=None) → Tuple[CumlArray, CumlArray] | Tuple[CumlArray, CumlArray, CumlArray][source]#
生成随机回归问题。

参见 https://scikit-learn.cn/stable/modules/generated/sklearn.datasets.make_regression.html

参数:

n_samplesint, optional (default=100)
样本数量。

n_featuresint, optional (default=2)
特征数量。

n_informativeint, optional (default=2)
信息特征数量，即用于构建生成输出的线性模型的特征数量。

n_targetsint, optional (default=1)
回归目标数量，即与样本关联的 y 输出向量的维度。默认情况下，输出是标量。

biasfloat, optional (default=0.0)
底层线性模型中的偏置项。

effective_rankint 或 None, optional (default=None)

如果不为 None
解释大多数输入数据所需的近似奇异向量数量（通过线性组合）。在输入中使用这种奇异谱可以让生成器复现实践中经常观察到的相关性。

如果为 None
输入集条件良好，居中且是具有单位方差的高斯分布。

tail_strengthfloat between 0.0 and 1.0, optional (default=0.5)
如果 effective_rank 不为 None，则奇异值分布中“胖尾”部分相对重要性。

noisefloat, optional (default=0.0)
应用于输出的高斯噪声的标准差。

shuffleboolean, optional (default=True)
打乱样本和特征。

coefboolean, optional (default=False)
如果为 True，则返回底层线性模型的系数。

random_stateint, RandomState instance 或 None (默认)
数据集创建的随机数生成器种子。

dtype: string 或 numpy dtype (默认: ‘single’)
数据类型。可能的值：float32, float64, ‘single’, ‘float’ 或 ‘double’。

handle: cuml.Handle
如果为 None，则仅为此函数调用创建一个新的句柄。

返回值:

outdevice array of shape [n_samples, n_features]
输入样本。

valuesdevice array of shape [n_samples, n_targets]
输出值。

coefdevice array of shape [n_features, n_targets], optional
底层线性模型的系数。仅当 coef 为 True 时返回。

示例
>>> from cuml.datasets.regression import make_regression
>>> from cuml.linear_model import LinearRegression

>>> # Create regression problem
>>> data, values = make_regression(n_samples=200, n_features=12,
...                                n_informative=7, bias=-4.2,
...                                noise=0.3, random_state=10)

>>> # Perform a linear regression on this problem
>>> lr = LinearRegression(fit_intercept = True, normalize = False,
...                       algorithm = "eig")
>>> reg = lr.fit(data, values)
>>> print(reg.coef_) 
[-2.6980877e-02  7.7027252e+01  1.1498465e+01  8.5468025e+00
5.8548538e+01  6.0772545e+01  3.6876743e+01  4.0023815e+01
4.3908358e-03 -2.0275116e-02  3.5066366e-02 -3.4512520e-02]
cuml.datasets.make_arima(batch_size=1000, n_obs=100, order=(1, 1, 1), seasonal_order=(0, 0, 0, 0), intercept=False, random_state=None, dtype='double', handle=None)[source]#
通过模拟给定阶数的 ARIMA 过程生成时间序列数据集。

参数:

batch_size: int
要生成的时间序列数量

n_obs: int
每个序列的观测值数量

orderTuple[int, int, int]
模拟 ARIMA 过程的阶数 (p, d, q)

seasonal_order: Tuple[int, int, int, int]
模拟 ARIMA 过程的季节性 ARIMA 阶数 (P, D, Q, s)

intercept: bool 或 int
模拟 ARIMA 过程中是否包含常数趋势 mu

random_state: int, RandomState 实例或 None (默认)
数据集创建的随机数生成器种子。

dtype: string 或 numpy dtype (默认: ‘single’)
数据类型。可能的值：float32, float64, ‘single’, ‘float’ 或 ‘double’

handle: cuml.Handle
如果为 None，则仅为此函数调用创建一个新的句柄。

返回值:

out: array-like, shape (n_obs, batch_size)
包含生成数据集的请求类型的数组

示例
from cuml.datasets import make_arima
y = make_arima(1000, 100, (2,1,2), (0,1,2,12), 0)

数据集生成 (基于 Dask 的多 GPU)#

cuml.dask.datasets.blobs.make_blobs(n_samples=100, n_features=2, centers=None, cluster_std=1.0, n_parts=None, center_box=(-10, 10), shuffle=True, random_state=None, return_centers=False, verbose=False, order='F', dtype='float32', client=None, workers=None)[source]#
为随机生成的中心点创建包含斑点的带标签 Dask-Cupy 数组。

此函数在每个 Dask 工作器上调用 cuml.datasets 中的 make_blobs，并将其聚合到单个 Dask Dataframe 中。

有关 Scikit-learn 的 make_blobs 的更多信息。

参数:

n_samplesint
行数

n_featuresint
特征数量

centersint or array of shape [n_centers, n_features],
可选 (default=None) 要生成的中心数量，或固定的中心位置。如果 n_samples 为 int 且 centers 为 None，则生成 3 个中心。如果 n_samples 为 array-like，则 centers 必须为 None 或长度等于 n_samples 长度的数组。

cluster_stdfloat (default = 1.0)
点围绕中心点的标准差

n_partsint (default = None)
要生成的分区数量 (可以大于工作器数量)

center_boxtuple (int, int) (default = (-10, 10))
约束所有中心点的边界框

random_stateint (default = None)
设置随机种子 (或使用 None 以每次重新初始化)

return_centersbool, optional (default=False)
如果为 True，则返回每个簇的中心

verboseint or boolean (default = False)
日志级别。

shufflebool (default=False)
打乱每个工作器上的样本。

order: str, optional (default=’F’)
生成样本的顺序

dtypestr, optional (default=’float32’)
生成样本的数据类型

clientdask.distributed.Client (optional)
要使用的 Dask 客户端

workersoptional, list of strings
用于计算的工作器的 Dask 地址。如果为 None，将使用所有可用的 Dask 工作器。(例如: workers = list(client.scheduler_info()['workers'].keys()))

返回值:

Xdask.array backed by CuPy array of shape [n_samples, n_features]
输入样本。

ydask.array backed by CuPy array of shape [n_samples]
输出值。

centersdask.array backed by CuPy array of shape
[n_centers, n_features], optional 底层斑点的中心。仅当 return_centers 为 True 时返回。

示例
>>> from dask_cuda import LocalCUDACluster
>>> from dask.distributed import Client
>>> from cuml.dask.datasets import make_blobs

>>> cluster = LocalCUDACluster(threads_per_worker=1)
>>> client = Client(cluster)

>>> workers = list(client.scheduler_info()['workers'].keys())
>>> X, y = make_blobs(1000, 10, centers=42, cluster_std=0.1,
...                   workers=workers)

>>> client.close()
>>> cluster.close()
cuml.dask.datasets.classification.make_classification(n_samples=100, n_features=20, n_informative=2, n_redundant=2, n_repeated=0, n_classes=2, n_clusters_per_class=2, weights=None, flip_y=0.01, class_sep=1.0, hypercube=True, shift=0.0, scale=1.0, shuffle=True, random_state=None, order='F', dtype='float32', n_parts=None, client=None)[source]#
生成一个随机的 n 类分类问题。

该函数首先创建关于 n_informative 维超立方体顶点的标准正态分布（std=1）点簇，超立方体边长为 2 * class_sep，并为每个类别分配相等数量的簇。它在这些特征之间引入了相互依赖性，并向数据中添加了各种类型的噪声。

在不进行混洗（shuffling）的情况下，X 按以下顺序水平堆叠特征：首先是主要的 n_informative 个特征，接着是 n_redundant 个信息特征的线性组合，然后是从信息特征和冗余特征中随机有替换地抽取的 n_repeated 个重复特征。剩余的特征填充随机噪声。因此，在不进行混洗的情况下，所有有用特征都包含在列 X[:, :n_informative + n_redundant + n_repeated] 中。

参数:

n_samplesint, optional (default=100)
样本数量。

n_featuresint, optional (default=20)
总特征数量。这些特征包括 n_informative 个信息特征、n_redundant 个冗余特征、n_repeated 个重复特征以及随机抽取的 n_features-n_informative-n_redundant-n_repeated 个无用特征。

n_informativeint, optional (default=2)
信息特征的数量。每个类别由若干个高斯簇组成，每个簇围绕着一个 n_informative 维子空间中的超立方体顶点。对于每个簇，信息特征独立地从 N(0, 1) 抽取，然后在每个簇内进行随机线性组合以增加协方差。随后将簇放置在超立方体的顶点上。

n_redundantint, optional (default=2)
冗余特征的数量。这些特征是信息特征的随机线性组合。

n_repeatedint, optional (default=0)
重复特征的数量，从信息特征和冗余特征中随机有放回地抽取。

n_classesint, optional (default=2)
分类问题的类别（或标签）数量。

n_clusters_per_classint, optional (default=2)
每个类别的簇数量。

weights形状如 (n_classes,) 或 (n_classes - 1,) 的类数组对象，（默认=None）
分配给每个类别的样本比例。如果为 None，则类别是平衡的。请注意，如果 len(weights) == n_classes - 1，则最后一个类别的权重会自动推断。如果 weights 的总和超过 1，则可能返回超过 n_samples 个样本。

flip_yfloat, optional (default=0.01)
其类别被随机分配的样本比例。值越大，标签中的噪声越多，分类任务越困难。

class_sepfloat, optional (default=1.0)
超立方体尺寸的乘法因子。值越大，簇/类别分布越分散，分类任务越容易。

hypercubeboolean, optional (default=True)
如果为 True，簇放置在超立方体的顶点上。如果为 False，簇放置在随机多边形的顶点上。

shiftfloat, array of shape [n_features] or None, optional (default=0.0)
按指定值偏移特征。如果为 None，则特征按在 [-class_sep, class_sep] 中抽取的随机值偏移。

scalefloat, array of shape [n_features] or None, optional (default=1.0)
按指定值缩放特征。如果为 None，则特征按在 [1, 100] 中抽取的随机值缩放。注意：缩放发生在偏移之后。

shuffleboolean, optional (default=True)
打乱样本和特征。

random_stateint, RandomState instance 或 None (默认)
确定数据集创建的随机数生成。传入一个整数以在多次函数调用中获得可复现的输出。参见术语表。

order: str, optional (default=’F’)
生成样本的顺序

dtypestr, optional (default=’float32’)
生成样本的数据类型

n_partsint (default = None)
要生成的分区数量 (可以大于工作器数量)

返回值:

Xdask.array backed by CuPy array of shape [n_samples, n_features]
生成的样本。

ydask.array backed by CuPy array of shape [n_samples]
每个样本的类别成员资格的整数标签。

注意

我们如何从单 GPU 版本扩展 Dask MNMG 版本

我们生成形状为 (n_centroids, n_informative) 的质心

我们生成形状为 (n_centroids, n_informative, n_informative) 的信息协方差

我们生成形状为 (n_informative, n_redundant) 的冗余协方差

我们生成重复特征的索引。我们将上述数组的 futures 引用与每个部分一起传递给单 GPU cuml.datasets.classification.make_classification，以便每个部分（和工作器）都能访问正确的值，以从相同的协方差生成数据。

示例
>>> from dask.distributed import Client
>>> from dask_cuda import LocalCUDACluster
>>> from cuml.dask.datasets.classification import make_classification
>>> cluster = LocalCUDACluster()
>>> client = Client(cluster)
>>> X, y = make_classification(n_samples=10, n_features=4,
...                            random_state=1, n_informative=2,
...                            n_classes=2)
>>> print(X.compute()) 
[[-1.1273878   1.2844919  -0.32349187  0.1595734 ]
[ 0.80521786 -0.65946865 -0.40753683  0.15538901]
[ 1.0404129  -1.481386    1.4241115   1.2664981 ]
[-0.92821544 -0.6805706  -0.26001272  0.36004275]
[-1.0392245  -1.1977317   0.16345565 -0.21848428]
[ 1.2273135  -0.529214    2.4799604   0.44108105]
[-1.9163864  -0.39505136 -1.9588828  -1.8881643 ]
[-0.9788184  -0.89851004 -0.08339313  0.1130247 ]
[-1.0549078  -0.8993015  -0.11921967  0.04821599]
[-1.8388828  -1.4063598  -0.02838472 -1.0874642 ]]
>>> print(y.compute()) 
[1 0 0 0 0 1 0 0 0 0]
>>> client.close()
>>> cluster.close()
cuml.dask.datasets.regression.make_low_rank_matrix(n_samples=100, n_features=100, effective_rank=10, tail_strength=0.5, random_state=None, n_parts=1, n_samples_per_part=None, dtype='float32')[source]#

生成一个具有钟形奇异值的、主要低秩的矩阵

参数:

n_samplesint, optional (default=100)
样本数量。

n_featuresint, 可选 (默认=100)
特征数量。

effective_rankint, 可选 (默认=10)
解释大部分数据的线性组合所需的近似奇异向量数量。

tail_strengthfloat between 0.0 and 1.0, optional (default=0.5)
奇异值分布中胖噪声尾部的相对重要性。

random_stateint, CuPy RandomState 实例, Dask RandomState 实例或 None (默认)
确定数据集生成的随机数生成。传入一个整数以在多次函数调用中获得可复现的输出。

n_partsint, 可选 (默认=1)
工作部分的数量。

dtype: str, 可选 (默认=’float32’)
生成数据的 dtype

返回值:

X形状为 [n_samples, n_features] 的 Dask-CuPy 数组
生成的矩阵。

cuml.dask.datasets.regression.make_regression(n_samples=100, n_features=100, n_informative=10, n_targets=1, bias=0.0, effective_rank=None, tail_strength=0.5, noise=0.0, shuffle=False, coef=False, random_state=None, n_parts=1, n_samples_per_part=None, order='F', dtype='float32', client=None, use_full_low_rank=True)[source]#

生成随机回归问题。

输入集可以良好条件（默认为此）或具有低秩-胖尾奇异值分布。

通过对先前生成的输入应用一个带有“n_informative”个非零回归因子的（可能带偏差的）随机线性回归模型，并添加一些具有可调节尺度的中心高斯噪声来生成输出。

参数:

n_samplesint, optional (default=100)
样本数量。

n_featuresint, 可选 (默认=100)
特征数量。

n_informativeint, 可选 (默认=10)
信息特征数量，即用于构建生成输出的线性模型的特征数量。

n_targetsint, optional (default=1)
回归目标数量，即与样本关联的 y 输出向量的维度。默认情况下，输出是标量。

biasfloat, optional (default=0.0)
底层线性模型中的偏置项。

effective_rankint 或 None, optional (default=None)

如果不为 None
解释大多数输入数据所需的近似奇异向量数量（通过线性组合）。在输入中使用这种奇异谱可以让生成器复现实践中经常观察到的相关性。

如果为 None
输入集条件良好，居中且是具有单位方差的高斯分布。

tail_strengthfloat between 0.0 and 1.0, optional (default=0.5)
如果“effective_rank”不为 None，则表示奇异值分布中胖噪声尾部的相对重要性。

noisefloat, optional (default=0.0)
应用于输出的高斯噪声的标准差。

shuffleboolean, 可选 (默认=False)
打乱样本和特征。

coefboolean, optional (default=False)
如果为 True，则返回底层线性模型的系数。

random_stateint, CuPy RandomState 实例, Dask RandomState 实例或 None (默认)
确定数据集生成的随机数生成。传入一个整数以在多次函数调用中获得可复现的输出。

n_partsint, 可选 (默认=1)
工作部分的数量。

orderstr, 可选 (默认=’F’)
行主序或列主序

dtype: str, 可选 (默认=’float32’)
生成数据的 dtype

use_full_low_rankboolean (默认=True)
是否使用整个数据集生成低秩矩阵。如果为 False，则创建低秩协方差，并使用相应的协方差在剩余块上生成多元正态分布

返回值:

X形状为 [n_samples, n_features] 的 Dask-CuPy 数组
输入样本。

y形状为 [n_samples] 或 [n_samples, n_targets] 的 Dask-CuPy 数组
输出值。

coef形状为 [n_features] 或 [n_features, n_targets] 的 Dask-CuPy 数组, 可选
底层线性模型的系数。仅当 coef 为 True 时返回。

注意

已知性能限制

当设置了 effective_rank 且 use_full_low_rank 为 True 时，我们无法按构造生成 F 序，并且会在每个部分执行显式转置。这可能会导致内存飙升（其他参数按构造生成 F 序）

当 n_targets > 1 且 order = 'F' 如上所述时，我们必须显式转置 y 数组。如果 coef = True，则我们也会显式转置 ground_truth 数组

当 shuffle = True 且 order = F 时，混洗 F 序数组会引起内存飙升

注意

如果在上述任何配置中遇到内存不足错误，请尝试增加 n_parts 参数的值。

指标（回归、分类和距离）#

cuml.metrics.regression.mean_absolute_error(y_true, y_pred, sample_weight=None, multioutput='uniform_average')[source]#

平均绝对误差回归损失

当使用 float32 输入时，请小心使用此指标，如果输入足够大，由于浮点精度，结果可能会略有不准确。float64 将具有较低的数值误差。

参数:

y_true类数组对象 (设备或主机) 形状 = (n_samples,)
或 (n_samples, n_outputs) 基本真相（正确）目标值。

y_pred类数组对象 (设备或主机) 形状 = (n_samples,)
或 (n_samples, n_outputs) 估计目标值。

sample_weight类数组对象 (设备或主机) 形状 = (n_samples,), 可选
样本权重。

multioutput字符串，取值为 ['raw_values', 'uniform_average']
或形状为 (n_outputs) 的类数组对象。定义了多个输出值的聚合方式。类数组对象值定义了用于平均误差的权重。'raw_values' : 在多输出输入情况下返回完整的误差集。'uniform_average' : 所有输出的误差以均匀权重进行平均。

返回值:

lossfloat 或 floats 的 ndarray
如果 multioutput 是 'raw_values'，则分别返回每个输出的平均绝对误差。如果 multioutput 是 'uniform_average' 或权重 ndarray，则返回所有输出误差的加权平均值。

MAE 输出是非负浮点数。最佳值为 0.0。

cuml.metrics.regression.mean_squared_error(y_true, y_pred, sample_weight=None, multioutput='uniform_average', squared=True)[source]#

均方误差回归损失

当使用 float32 输入时，请小心使用此指标，如果输入足够大，由于浮点精度，结果可能会略有不准确。float64 将具有较低的数值误差。

参数:

y_true类数组对象 (设备或主机) 形状 = (n_samples,)
或 (n_samples, n_outputs) 基本真相（正确）目标值。

y_pred类数组对象 (设备或主机) 形状 = (n_samples,)
或 (n_samples, n_outputs) 估计目标值。

sample_weight类数组对象 (设备或主机) 形状 = (n_samples,), 可选
样本权重。

multioutput字符串，取值为 ['raw_values', 'uniform_average'] (默认='uniform_average')
或形状为 (n_outputs) 的类数组对象。定义了多个输出值的聚合方式。类数组对象值定义了用于平均误差的权重。'raw_values' : 在多输出输入情况下返回完整的误差集。'uniform_average' : 所有输出的误差以均匀权重进行平均。

squared布尔值, 可选 (默认 = True)
如果为 True，返回 MSE 值；如果为 False，返回 RMSE 值。

返回值:

lossfloat 或 floats 的 ndarray
一个非负浮点值（最佳值为 0.0），或者一个浮点值数组，每个单独目标对应一个值。

cuml.metrics.regression.mean_squared_log_error(y_true, y_pred, sample_weight=None, multioutput='uniform_average', squared=True)[source]#

均方对数误差回归损失

当使用 float32 输入时，请小心使用此指标，如果输入足够大，由于浮点精度，结果可能会略有不准确。float64 将具有较低的数值误差。

参数:

y_true类数组对象 (设备或主机) 形状 = (n_samples,)
或 (n_samples, n_outputs) 基本真相（正确）目标值。

y_pred类数组对象 (设备或主机) 形状 = (n_samples,)
或 (n_samples, n_outputs) 估计目标值。

sample_weight类数组对象 (设备或主机) 形状 = (n_samples,), 可选
样本权重。

multioutput字符串，取值为 ['raw_values', 'uniform_average']
或形状为 (n_outputs) 的类数组对象。定义了多个输出值的聚合方式。类数组对象值定义了用于平均误差的权重。'raw_values' : 在多输出输入情况下返回完整的误差集。'uniform_average' : 所有输出的误差以均匀权重进行平均。

squared布尔值, 可选 (默认 = True)
如果为 True，返回 MSE 值；如果为 False，返回 RMSE 值。

返回值:

lossfloat 或 floats 的 ndarray
一个非负浮点值（最佳值为 0.0），或者一个浮点值数组，每个单独目标对应一个值。

cuml.metrics.regression.r2_score(y_true, y_pred, *, sample_weight=None, multioutput='uniform_average', force_finite=True, **kwargs)[source]#

\(R^2\)（决定系数）回归评分函数。

最佳可能得分为 1.0，也可能为负（因为模型可能任意差）。在真实 y 非恒定的通用情况下，一个始终预测平均 y 而忽略输入特征的恒定模型将获得 \(R^2\) 评分为 0.0。

参数:

y_true形状为 (n_samples,) 或 (n_samples, n_outputs) 的类数组对象
基本真相（正确）目标值。

y_pred形状为 (n_samples,) 或 (n_samples, n_outputs) 的类数组对象
估计的目标值。

sample_weight形状为 (n_samples,) 的类数组对象
样本权重。

multioutput{'raw_values', 'uniform_average', 'variance_weighted'} 或形状为 (n_outputs,) 的类数组对象
如何聚合多输出分数。取以下之一：

‘uniform_average’：所有输出的分数以均匀权重进行平均。这是默认值。

‘variance_weighted’：所有输出的分数进行平均，并按每个单独输出的方差进行加权。

‘raw_values’：多输出输入情况下的完整分数集。

类数组对象：平均所有输出分数时使用的权重。

force_finitebool, 默认=True
标志，指示是否应将由恒定数据导致的 NaN 和 -Inf 分数替换为实数（如果预测完美则为 1.0，否则为 0.0）。默认为 True。

返回值:

zfloat 或 floats 的 ndarray
\(R^2\) 分数，如果“multioutput”为“raw_values”，则为分数 ndarray。

cuml.metrics.accuracy_score(y_true, y_pred, *, sample_weight=None, normalize=True, **kwargs)[source]#

准确率分类评分。

参数:

y_true形状为 (n_samples,) 的类数组对象
基本真相（正确）标签。

y_pred形状为 (n_samples,) 的类数组对象
预测的标签。

sample_weight形状为 (n_samples,) 的类数组对象
样本权重。

normalizebool
如果为 False，返回正确分类的样本数量。否则，返回正确分类样本的比例。

返回值:

scorefloat
正确分类样本的比例，或者如果 normalize == False，则为正确分类样本的数量。

cuml.metrics.confusion_matrix(y_true, y_pred, labels=None, sample_weight=None, normalize=None, convert_dtype=False) → CumlArray[source]#

计算混淆矩阵以评估分类的准确性。

参数:

y_true类数组对象 (设备或主机) 形状 = (n_samples,)
或 (n_samples, n_outputs) 基本真相（正确）目标值。

y_pred类数组对象 (设备或主机) 形状 = (n_samples,)
或 (n_samples, n_outputs) 估计目标值。

labels类数组对象 (设备或主机) 形状 = (n_classes,), 可选
用于索引矩阵的标签列表。可用于重新排序或选择标签子集。如果为 None，则使用 y_true 或 y_pred 中至少出现一次的标签，并按排序顺序排列。

sample_weight类数组对象 (设备或主机) 形状 = (n_samples,), 可选
样本权重。

normalize字符串，取值为 ['true', 'pred', 'all'] 或 None (默认=None)
根据真实值（行）、预测值（列）条件或所有样本对混淆矩阵进行归一化。如果为 None，混淆矩阵将不进行归一化。

convert_dtypebool, 可选 (默认=False)
设置为 True 时，混淆矩阵方法将自动将预测值、基本真相和标签数组转换为 np.int32。

返回值:

C类数组对象 (设备或主机) 形状 = (n_classes, n_classes)
混淆矩阵。

cuml.metrics.kl_divergence(P, Q, handle=None, convert_dtype=True)[source]#

计算“Kullback-Leibler”散度 KL 散度衡量概率分布 Q 对概率分布 P 的近似程度它也常被用作衡量两个概率分布之间的“距离度量”（非对称）

参数:

P对应于分布 P 的概率密集数组
形状 = (n_samples, 1) 可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy。

Q对应于分布 Q 的概率密集数组
形状 = (n_samples, 1) 可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy。

handlecuml.Handle

convert_dtypebool, 可选 (默认 = True)
设置为 True 时，方法会将 P 和 Q 转换为相同的数据类型：float32。这将增加方法使用的内存。

返回值:

float
KL 散度值
cuml.metrics.log_loss(y_true, y_pred, eps=1e-15, normalize=True, sample_weight=None) → float[source]#
对数损失，也称为逻辑损失或交叉熵损失。这是（多项式）逻辑回归及其扩展（如神经网络）中使用的损失函数，定义为返回训练数据 y_true 的 y_pred 概率的逻辑模型的负对数似然。对数损失仅定义于两个或更多标签的情况。

参数:

y_true类数组对象, 形状 = (n_samples,)

y_predfloat 的类数组对象,
形状 = (n_samples, n_classes) 或 (n_samples,)

epsfloat (默认=1e-15)
p=0 或 p=1 时，对数损失未定义，因此概率被截断到 max(eps, min(1 - eps, p))。

normalizebool, 可选 (默认=True)
如果为 true，返回每个样本的平均损失。否则，返回每个样本损失的总和。

sample_weight形状为 (n_samples,) 的类数组对象, 默认=None
样本权重。

返回值:

lossfloat

注意

使用的对数是自然对数（以 e 为底）。

参考

C.M. Bishop (2006). Pattern Recognition and Machine Learning. Springer, p. 209.

示例
>>> from cuml.metrics import log_loss
>>> import cupy as cp
>>> log_loss(cp.array([1, 0, 0, 1]),
...          cp.array([[.1, .9], [.9, .1], [.8, .2], [.35, .65]]))
0.21616...
cuml.metrics.roc_auc_score(y_true, y_score)[source]#
从预测分数计算接收者操作特征曲线下的面积 (ROC AUC)。

注意

此实现仅适用于二元分类。

参数:

y_true形状为 (n_samples,) 的类数组对象
真实标签。二元情况要求标签形状为 (n_samples,)

y_score形状为 (n_samples,) 的类数组对象
目标分数。在二元情况下，可以是概率估计或未设阈值的决策值（由某些分类器的 decision_function 返回）。二元情况要求形状为 (n_samples,)，并且分数必须是具有较大标签类别的分数。

返回值:

aucfloat

示例
>>> import numpy as np
>>> from cuml.metrics import roc_auc_score
>>> y_true = np.array([0, 0, 1, 1])
>>> y_scores = np.array([0.1, 0.4, 0.35, 0.8])
>>> print(roc_auc_score(y_true, y_scores))
0.75
cuml.metrics.precision_recall_curve(y_true, probs_pred) → Tuple[CumlArray, CumlArray, CumlArray][source]#
计算不同概率阈值下的精确率-召回率对

注意

此实现仅限于二元分类任务。精确率是 tp / (tp + fp) 的比率，其中 tp 是真阳性数量，fp 是假阳性数量。精确率直观地表示分类器不将阴性样本错误标记为阳性的能力。

召回率是 tp / (tp + fn) 的比率，其中 tp 是真阳性数量，fn 是假阴性数量。召回率直观地表示分类器找到所有阳性样本的能力。最后一个精确率和召回率值分别为 1. 和 0.，没有对应的阈值。这确保了曲线从 y 轴开始。

在 scikit-learn 的用户指南中阅读更多信息。

参数:

y_true数组, 形状 = [n_samples]
真实二元标签, {0, 1}。

probas_pred数组, 形状 = [n_samples]
估计的概率或决策函数。

返回值:

precision数组, 形状 = [n_thresholds + 1]
精确率值，其中元素 i 是得分 >= thresholds[i] 的预测的精确率，最后一个元素为 1。

recall数组, 形状 = [n_thresholds + 1]
递减的召回率值，其中元素 i 是得分 >= thresholds[i] 的预测的召回率，最后一个元素为 0。

thresholds数组, 形状 = [n_thresholds <= len(np.unique(probas_pred))]
用于计算精确率和召回率的决策函数上的递增阈值。

示例
>>> import cupy as cp
>>> from cuml.metrics import precision_recall_curve
>>> y_true = cp.array([0, 0, 1, 1])
>>> y_scores = cp.array([0.1, 0.4, 0.35, 0.8])
>>> precision, recall, thresholds = precision_recall_curve(
...     y_true, y_scores)
>>> print(precision)
[0.666... 0.5  1.  1. ]
>>> print(recall)
[1. 0.5 0.5 0. ]
>>> print(thresholds)
[0.35 0.4 0.8 ]
cuml.metrics.pairwise_distances.nan_euclidean_distances(X, Y=None, *, squared=False, missing_values=nan, convert_dtype=True)[source]#

在存在缺失值的情况下计算欧几里得距离。

计算 X 和 Y 中每对样本之间的欧几里得距离，其中如果 Y=None，则假定 Y=X。计算一对样本之间的距离时，此公式会忽略任一样本中包含缺失值的特征坐标，并按比例增加剩余坐标的权重。

dist(x,y) = sqrt(weight * sq. distance from present coordinates)，其中，weight = 总坐标数 / 现有坐标数

例如，[3, na, na, 6] 和 [1, na, 4, 5] 之间的距离是

\[\sqrt{\frac{4}{2}((3-1)^2 + (6-5)^2)}\]

如果所有坐标都缺失或没有共同的现有坐标，则该对返回 NaN。

参数:

X形状为 (n_samples_X, n_features) 的密集矩阵
可接受格式：cuDF DataFrame, Pandas DataFrame, NumPy ndarray, 支持 cuda array interface 的数组如 CuPy。

Y形状为 (n_samples_Y, n_features) 的类数组对象 (设备或主机), 默认=None
可接受格式：cuDF DataFrame, Pandas DataFrame, NumPy ndarray, 支持 cuda array interface 的数组如 CuPy。

squaredbool, 默认=False
返回平方欧几里得距离。

missing_valuesnp.nan 或 int, 默认=np.nan
缺失值的表示。

返回值:

distances形状为 (n_samples_X, n_samples_Y) 的 ndarray
返回 X 的行向量与 Y 的行向量之间的距离。
cuml.metrics.pairwise_distances.pairwise_distances(X, Y=None, metric='euclidean', handle=None, convert_dtype=True, metric_arg=2, **kwds)[source]#
计算向量数组 X 和可选数组 Y 的距离矩阵。

此方法接受一个或两个向量数组，并返回一个距离矩阵。

如果提供了 Y（默认值为 None），则返回的矩阵是 X 和 Y 中数组的成对距离。

metric 的有效值为：

来自 scikit-learn：['cityblock', 'cosine', 'euclidean', 'l1', 'l2', 'manhattan']。
支持稀疏矩阵，参见 'sparse_pairwise_distances'。

来自 scipy.spatial.distance：['sqeuclidean']
有关此度量的详细信息，请参阅 scipy.spatial.distance 文档。支持稀疏矩阵。

参数:

X密集或稀疏矩阵 (设备或主机)，形状为
(n_samples_x, n_features) 可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy, 或 cupyx.scipy.sparse 用于稀疏输入

Y形状为 (n_samples_y, n_features) 的类数组对象 (设备或主机), 可选
可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy

metric{"cityblock", "cosine", "euclidean", "l1", "l2", "manhattan", "sqeuclidean"}
计算特征数组中实例之间距离时使用的度量。

convert_dtypebool, 可选 (默认 = True)
设置为 True 时，方法会在必要时将 Y 转换为与 X 相同的数据类型（如果它们不同）。这将增加方法使用的内存。

返回值:

D数组 [n_samples_x, n_samples_x] 或 [n_samples_x, n_samples_y]
一个距离矩阵 D，其中 D_{i, j} 是给定矩阵 X 的第 i 个向量和第 j 个向量之间的距离（如果 Y 为 None）。如果 Y 不为 None，则 D_{i, j} 是来自 X 的第 i 个数组和来自 Y 的第 j 个数组之间的距离。

示例
>>> import cupy as cp
>>> from cuml.metrics import pairwise_distances
>>> X = cp.array([[2.0, 3.0], [3.0, 5.0], [5.0, 8.0]])
>>> Y = cp.array([[1.0, 0.0], [2.0, 1.0]])
>>> # Euclidean Pairwise Distance, Single Input:
>>> pairwise_distances(X, metric='euclidean')
array([[0.        , 2.236..., 5.830...],
    [2.236..., 0.        , 3.605...],
    [5.830..., 3.605..., 0.        ]])
>>> # Cosine Pairwise Distance, Multi-Input:
>>> pairwise_distances(X, Y, metric='cosine')
array([[0.445... , 0.131...],
    [0.485..., 0.156...],
    [0.470..., 0.146...]])
>>> # Manhattan Pairwise Distance, Multi-Input:
>>> pairwise_distances(X, Y, metric='manhattan')
array([[ 4.,  2.],
    [ 7.,  5.],
    [12., 10.]])
cuml.metrics.pairwise_distances.sparse_pairwise_distances(X, Y=None, metric='euclidean', handle=None, convert_dtype=True, metric_arg=2, **kwds)[source]#
计算向量数组 X 和可选数组 Y 的距离矩阵。

此方法接受一个或两个稀疏向量数组，并返回一个密集距离矩阵。

如果提供了 Y（默认值为 None），则返回的矩阵是 X 和 Y 中数组的成对距离。

metric 的有效值为：

来自 scikit-learn：['cityblock', 'cosine', 'euclidean', 'l1', 'l2', 'manhattan']。

来自 scipy.spatial.distance：['sqeuclidean', 'canberra', 'minkowski', 'jaccard', 'chebyshev', 'dice']
有关这些度量的详细信息，请参阅 scipy.spatial.distance 文档。

['inner_product', 'hellinger']

参数:

X形状为 (n_samples_x, n_features) 的类数组对象 (设备或主机)
可接受格式：SciPy 或 Cupy 稀疏数组

Y形状为 (n_samples_y, n_features) 的类数组对象 (设备或主机), 可选
可接受格式：SciPy 或 Cupy 稀疏数组

metric{"cityblock", "cosine", "euclidean", "l1", "l2", "manhattan", "sqeuclidean", "canberra", "lp", "inner_product", "minkowski", "jaccard", "hellinger", "chebyshev", "linf", "dice"}
计算特征数组中实例之间距离时使用的度量。

convert_dtypebool, 可选 (默认 = True)
设置为 True 时，方法会在必要时将 Y 转换为与 X 相同的数据类型（如果它们不同）。这将增加方法使用的内存。

metric_argfloat, 可选 (默认 = 2)
额外的度量特定参数。对于 Minkowski，它是应用的 p 范数。

返回值:

D数组 [n_samples_x, n_samples_x] 或 [n_samples_x, n_samples_y]
一个密集距离矩阵 D，其中 D_{i, j} 是给定矩阵 X 的第 i 个向量和第 j 个向量之间的距离（如果 Y 为 None）。如果 Y 不为 None，则 D_{i, j} 是来自 X 的第 i 个数组和来自 Y 的第 j 个数组之间的距离。

示例
>>> import cupyx
>>> from cuml.metrics import sparse_pairwise_distances

>>> X = cupyx.scipy.sparse.random(2, 3, density=0.5, random_state=9)
>>> Y = cupyx.scipy.sparse.random(1, 3, density=0.5, random_state=9)
>>> X.todense()
array([[0.8098..., 0.537..., 0. ],
    [0.        , 0.856..., 0. ]])
>>> Y.todense()
array([[0.        , 0.        , 0.993...]])
>>> # Cosine Pairwise Distance, Single Input:
>>> sparse_pairwise_distances(X, metric='cosine')
array([[0.      , 0.447...],
    [0.447..., 0.        ]])

>>> # Squared euclidean Pairwise Distance, Multi-Input:
>>> sparse_pairwise_distances(X, Y, metric='sqeuclidean')
array([[1.931...],
    [1.720...]])

>>> # Canberra Pairwise Distance, Multi-Input:
>>> sparse_pairwise_distances(X, Y, metric='canberra')
array([[3.],
    [2.]])
cuml.metrics.pairwise_kernels.pairwise_kernels(X, Y=None, metric='linear', *, filter_params=False, convert_dtype=True, **kwds)[source]#
计算数组 X 和可选数组 Y 之间的核函数。此方法接受一个向量数组或一个核矩阵，并返回一个核矩阵。如果输入是向量数组，则计算核函数。如果输入是核矩阵，则直接返回。此方法提供了一种安全的方式来接受核矩阵作为输入，同时保持与许多接受向量数组的其他算法的兼容性。如果提供了 Y（默认值为 None），则返回的矩阵是 X 和 Y 中数组的成对核函数。metric 的有效值为：['additive_chi2', 'chi2', 'linear', 'poly', 'polynomial', 'rbf', 'laplacian', 'sigmoid', 'cosine']

参数:

X形状为 (n_samples_X, n_samples_X) 或 (n_samples_X, n_features) 的密集矩阵 (设备或主机)
样本之间成对核函数的数组，或特征数组。如果 metric == "precomputed"，数组形状应为 (n_samples_X, n_samples_X)，否则为 (n_samples_X, n_features)。可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy

Y形状为 (n_samples_Y, n_features) 的密集矩阵 (设备或主机), 默认=None
只有当 X 的形状为 (n_samples_X, n_features) 时才提供的第二个特征数组。可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy

metricstr 或可调用对象 (numba device function), 默认="linear"
计算特征数组中实例之间核函数时使用的度量。如果 metric 为 "precomputed"，则假定 X 为核矩阵。或者，如果 metric 为可调用函数，则对每对实例（行）调用该函数，并记录结果值。该可调用函数应接受来自 X 的两行作为输入，并返回相应的核函数值作为单个数字。

filter_paramsbool, 默认=False
是否过滤无效参数。

convert_dtypebool, 可选 (默认 = True)
设置为 True 时，方法会在必要时将 Y 转换为与 X 相同的数据类型（如果它们不同）。这将增加方法使用的内存。

**kwds可选关键字参数
任何其他参数直接传递给核函数。

返回值:

K形状为 (n_samples_X, n_samples_X) 或 (n_samples_X, n_samples_Y) 的 ndarray
一个核矩阵 K，其中 K_{i, j} 是给定矩阵 X 的第 i 个向量和第 j 个向量之间的核函数（如果 Y 为 None）。如果 Y 不为 None，则 K_{i, j} 是来自 X 的第 i 个数组和来自 Y 的第 j 个数组之间的核函数。

注意

如果 metric 为 'precomputed'，则忽略 Y 并返回 X。

示例
>>> import cupy as cp
>>> from cuml.metrics import pairwise_kernels
>>> from numba import cuda
>>> import math

>>> X = cp.array([[2, 3], [3, 5], [5, 8]])
>>> Y = cp.array([[1, 0], [2, 1]])

>>> pairwise_kernels(X, Y, metric='linear')
array([[ 2,  7],
    [ 3, 11],
    [ 5, 18]])
>>> @cuda.jit(device=True)
... def custom_rbf_kernel(x, y, gamma=None):
...     if gamma is None:
...         gamma = 1.0 / len(x)
...     sum = 0.0
...     for i in range(len(x)):
...         sum += (x[i] - y[i]) ** 2
...     return math.exp(-gamma * sum)

>>> pairwise_kernels(X, Y, metric=custom_rbf_kernel) 
array([[6.73794700e-03, 1.35335283e-01],
    [5.04347663e-07, 2.03468369e-04],
    [4.24835426e-18, 2.54366565e-13]])

指标（聚类和流形学习）#

cuml.metrics.trustworthiness.trustworthiness(X, X_embedded, handle=None, n_neighbors=5, metric='euclidean', convert_dtype=True, batch_size=512) → float[source]#

表示嵌入保留局部结构的程度。分数的范围在 [0, 1] 内。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features)
可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy

X_embedded类数组对象 (设备或主机) 形状= (n_samples, n_features)
可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy

n_neighborsint, 可选 (默认=5)
考虑的邻居数量

metric字符串，取值为 ['euclidean'] (默认='euclidean')
用于计算信任度的度量。目前仅支持“欧几里得”。

convert_dtypebool, 可选 (默认=False)
设置为 True 时，trustworthiness 方法将自动将输入转换为 np.float32。

batch_sizeint (默认=512)
每个批次使用的样本数量。

返回值:

trustworthiness scoredouble
低维嵌入的信任度

cuml.metrics.cluster.adjusted_rand_index.adjusted_rand_score(labels_true, labels_pred, handle=None, convert_dtype=True) → float[source]#

Adjusted_rand_score 是基于 Rand 指数且经过机会校正的聚类相似性度量。

参数:

labels_true用作参考的基本真相标签

labels_pred用于评估模型的预测标签数组

handlecuml.Handle

返回值:

float
调整后的 Rand 指数，值介于 -1.0 和 1.0 之间

cuml.metrics.cluster.entropy.cython_entropy(clustering, base=None, handle=None) → float[source]#

计算给定概率值的分布熵。

参数:

clustering类数组对象 (设备或主机) 形状 = (n_samples,)
标签的聚类。概率基于标签的出现频率计算。例如，要表示一枚均匀硬币（2 个等可能结果），聚类可以是 [0,1]。对于一枚反面概率为 2/3 的有偏硬币，聚类可以是 [0, 0, 1]。

base: float, 可选
要使用的对数底数，默认为 e（自然对数）。

handlecuml.Handle
指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。

返回值:

Sfloat
计算出的熵。

cuml.metrics.cluster.homogeneity_score.cython_homogeneity_score(labels_true, labels_pred, handle=None) → float[source]#

计算给定基本真相的聚类标签的同质性度量。

如果一个聚类结果的所有簇只包含属于单个类别的数据点，则它满足同质性。

此度量独立于标签的绝对值：类别或簇标签值的排列不会以任何方式改变评分值。

此度量是非对称的：交换 label_true 和 label_pred 会返回 completeness_score，通常会有所不同。

labels_pred 和 labels_true 中的标签假定取自连续集合（例如：取自 {2, 3, 4}，而不是 {2, 4}）。如果您的标签集合看起来像 {2, 4}，请将其转换为 {0, 1} 之类。

参数:

labels_pred类数组对象 (设备或主机) 形状 = (n_samples,)
模型对测试数据集预测的标签。可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy

labels_true类数组对象 (设备或主机) 形状 = (n_samples,)
测试数据集的基本真相标签 (ints)。可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy

handlecuml.Handle
指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。

返回值:

float
给定基本真相的预测标签的同质性。分值介于 0.0 和 1.0 之间。1.0 表示完美同质标签。

cuml.metrics.cluster.silhouette_score.cython_silhouette_samples(X, labels, metric='euclidean', chunksize=None, convert_dtype=True, handle=None)[source]#

计算提供的数据中每个样本的轮廓系数。

对于提供的数据中每个样本的一组聚类标签，计算每个样本的平均簇内距离 (a) 和平均最近簇距离 (b)。样本的轮廓系数为 (b - a) / max(a, b)。

参数:

X类数组对象, 形状 = (n_samples, n_features)
所有样本的特征向量。

labels类数组对象, 形状 = (n_samples,)
为每个样本分配的聚类标签。

metric字符串
用于评估轮廓系数的距离度量的字符串表示。可用选项有 "cityblock", "cosine", "euclidean", "l1", "l2", "manhattan", 和 "sqeuclidean"。

chunksize整数 (默认 = None)
一个整数，1 <= chunksize <= n_samples，用于对成对距离矩阵计算进行分块，以减少将整个成对距离矩阵放入 GPU 内存所需的二次内存使用。如果为 None，chunksize 将自动设置为 40000，实验证明对于 16 GB 显存的 GPU 来说，这是一个安全的数值。

handlecuml.Handle
指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。

cuml.metrics.cluster.silhouette_score.cython_silhouette_score(X, labels, metric='euclidean', chunksize=None, convert_dtype=True, handle=None)[source]#

计算提供数据的平均轮廓系数。

对于提供的数据中每个样本的一组聚类标签，计算每个样本的平均簇内距离 (a) 和平均最近簇距离 (b)。样本的轮廓系数为 (b - a) / max(a, b)。

参数:

X类数组对象, 形状 = (n_samples, n_features)
所有样本的特征向量。

labels类数组对象, 形状 = (n_samples,)
为每个样本分配的聚类标签。

metric字符串
用于评估轮廓系数的距离度量的字符串表示。可用选项有 "cityblock", "cosine", "euclidean", "l1", "l2", "manhattan", 和 "sqeuclidean"。

chunksize整数 (默认 = None)
一个整数，1 <= chunksize <= n_samples，用于对成对距离矩阵计算进行分块，以减少将整个成对距离矩阵放入 GPU 内存所需的二次内存使用。如果为 None，chunksize 将自动设置为 40000，实验证明对于 16 GB 显存的 GPU 来说，这是一个安全的数值。

handlecuml.Handle
指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。

cuml.metrics.cluster.completeness_score.cython_completeness_score(labels_true, labels_pred, handle=None) → float[source]#

给定基本真相的聚类标签的完整性度量。

如果属于给定类别的所有数据点都是同一簇的元素，则聚类结果满足完整性。

此度量独立于标签的绝对值：类别或簇标签值的排列不会以任何方式改变评分值。

此指标不是对称的：将 label_true 与 label_pred 对调将返回 homogeneity_score，它通常是不同的。

labels_pred 和 labels_true 中的标签假定取自连续集合（例如：取自 {2, 3, 4}，而不是 {2, 4}）。如果您的标签集合看起来像 {2, 4}，请将其转换为 {0, 1} 之类。

参数:

labels_pred类数组对象 (设备或主机) 形状 = (n_samples,)
模型对测试数据集预测的标签。可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy

labels_true类数组对象 (设备或主机) 形状 = (n_samples,)
测试数据集的基本真相标签 (ints)。可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy

handlecuml.Handle
指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。

返回值:

float
给定真实标签，预测标签的完整性。得分介于 0.0 和 1.0 之间。1.0 表示完美的完整性标签。

cuml.metrics.cluster.mutual_info_score.cython_mutual_info_score(labels_true, labels_pred, handle=None) → float[source]#

计算两个聚类之间的互信息。

互信息是衡量同一数据的两个标签相似度的指标。

此度量独立于标签的绝对值：类别或簇标签值的排列不会以任何方式改变评分值。

此外，此指标是对称的：将 label_true 与 label_pred 对调将返回相同的得分值。这可用于在不知道真实地面真值的情况下，衡量同一数据集上两种独立标签分配策略的一致性。

labels_pred 和 labels_true 中的标签假定取自连续集合（例如：取自 {2, 3, 4}，而不是 {2, 4}）。如果您的标签集合看起来像 {2, 4}，请将其转换为 {0, 1} 之类。

参数:

handlecuml.Handle

labels_pred类数组对象 (设备或主机) 形状 = (n_samples,)
数据（整数）聚类为不相交的子集。可接受的格式：cuDF DataFrame、NumPy ndarray、Numba device ndarray、符合 CUDA 数组接口的数组，如 CuPy。

labels_true类数组对象 (设备或主机) 形状 = (n_samples,)
数据（整数）聚类为不相交的子集。可接受的格式：cuDF DataFrame、NumPy ndarray、Numba device ndarray、符合 CUDA 数组接口的数组，如 CuPy。

返回值:

float
互信息，一个非负值

给定地面真值，聚类标签的 V-measure 指标。

V-measure 是同质性（homogeneity）和完整性（completeness）的调和平均值
v = (1 + beta) * homogeneity * completeness
     / (beta * homogeneity + completeness)
此度量独立于标签的绝对值：类别或簇标签值的排列不会以任何方式改变评分值。

此外，此指标是对称的：将 label_true 与 label_pred 对调将返回相同的得分值。这可用于在不知道真实地面真值的情况下，衡量同一数据集上两种独立标签分配策略的一致性。

参数#

labels_pred类数组 (设备或主机) 形状 = (n_samples,)
模型对测试数据集预测的标签。可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy

labels_true类数组 (设备或主机) 形状 = (n_samples,)
测试数据集的基本真相标签 (ints)。可接受格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 支持 cuda array interface 的数组如 CuPy

beta浮点数, 默认值=1.0
homogeneity 与 completeness 权重的比率。如果 beta 大于 1，则在计算中 completeness 的权重更大。如果 beta 小于 1，则 homogeneity 的权重更大。

handlecuml.Handle
指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。

返回值#

v_measure_value浮点数
得分介于 0.0 和 1.0 之间。1.0 表示完美的完整性标签

基准测试#

class cuml.benchmark.algorithms.AlgorithmPair(cpu_class, cuml_class, shared_args, cuml_args={}, cpu_args={}, name=None, accepts_labels=True, cpu_data_prep_hook=None, cuml_data_prep_hook=None, accuracy_function=None, bench_func=<function fit>, setup_cpu_func=None, setup_cuml_func=None)[source]#

包装了一个 cuML 算法和一个（可选的）基于 CPU 的算法（通常是 scikit-learn，但只要它提供 fit 和 predict 或 transform 方法即可）。提供机制来运行每个版本的默认参数。如果算法没有基于 CPU 的版本，则在实例化时将 cpu_class 设置为 None

参数:

cpu_class类
算法的 CPU 版本类。如果不可用，设置为 None。

cuml_class类
cuML 算法类

shared_args字典
传递给两个实现的初始化器的参数

cuml_args字典
仅传递给 cuML 初始化器的参数

cpu_args dict
仅传递给 sklearn 初始化器的参数

accepts_labels布尔值
如果为 True，则 fit 方法需要 X 和 y 输入。否则，它只需要 X 输入。

data_prep_hook函数 (data -> data)
在传递给 fit 之前，对输入数据运行的可选函数

accuracy_function函数 (y_test, y_pred)
返回表示准确性的标量值的函数

bench_func用于执行 fit/predict/transform
调用的自定义函数。

方法

run_cpu(data[, bench_args])

在指定数据上运行基于 CPU 的算法的 fit 方法

run_cuml(data[, bench_args])

在指定数据上运行基于 cuML 的算法的 fit 方法

setup_cpu

setup_cuml

run_cpu(data, bench_args={}, **override_setup_args)[source]#

在指定数据上运行基于 CPU 的算法的 fit 方法

run_cuml(data, bench_args={}, **override_setup_args)[source]#

在指定数据上运行基于 cuML 的算法的 fit 方法

cuml.benchmark.algorithms.algorithm_by_name(name)[source]#

返回名称为“name”（不区分大小写）的算法对

cuml.benchmark.algorithms.all_algorithms()[source]#

返回所有定义的 AlgorithmPair 对象

运行 ML 基准测试的封装器

class cuml.benchmark.runners.AccuracyComparisonRunner(bench_rows, bench_dims, dataset_name='blobs', input_type='numpy', test_fraction=0.1, n_reps=1)[source]#

运行具有多种数据集大小的算法并计算 cuML 相对于 scikit-learn 基线的准确性和加速比的封装器。
class cuml.benchmark.runners.BenchmarkTimer(reps=1)[source]#
提供一个上下文管理器，该管理器运行代码块 reps 次并将结果记录到实例变量 timings 中。使用方法如下：
timer = BenchmarkTimer(rep=5)
for _ in timer.benchmark_runs():
    ... do something ...
print(np.min(timer.timings))
方法

benchmark_runs
class cuml.benchmark.runners.SpeedupComparisonRunner(bench_rows, bench_dims, dataset_name='blobs', input_type='numpy', n_reps=1)[source]#

运行具有多种数据集大小的算法并计算 cuML 相对于 scikit-learn 基线的加速比的封装器。

方法

run

cuml.benchmark.runners.run_variations(algos, dataset_name, bench_rows, bench_dims, param_override_list=[{}], cuml_param_override_list=[{}], cpu_param_override_list=[{}], dataset_param_override_list=[{}], dtype=<class 'numpy.float32'>, input_type='numpy', test_fraction=0.1, run_cpu=True, device_list=('gpu',), raise_on_error=False, n_reps=1)[source]#

对 algos 中的每个算法针对每个 bench_rows X bench_dims X params_override_list X cuml_param_override_list 组合运行一次，并返回包含时间和准确性数据的 dataframe。

参数:

algos字符串或列表
要运行和评估的算法名称

dataset_name字符串
要使用的数据集名称

bench_rows整数列表
要测试的数据集行计数

bench_dims整数列表
要测试的数据集列计数

param_override_list字典列表
包含要传递给 __init__ 的参数的字典。每个字典指定在算法的一次运行中要覆盖的参数。

cuml_param_override_list字典列表
仅包含要传递给 cuml 算法的 __init__ 的参数的字典。

cpu_param_override_list字典列表
仅包含要传递给 cpu 算法的 __init__ 的参数的字典。

dataset_param_override_list字典
包含要传递给数据集生成器函数的参数的字典

dtype: [np.float32|np.float64]
指定用于基准测试的数据集精度。

test_fraction浮点数
用于测试的数据比例。

run_cpu布尔值
如果为 True，则运行基于 CPU 的算法进行比较

cuML 基准测试的数据生成器

使用者主要入口是 gen_data，它封装了底层的数据生成器。

编写新生成器时的注意事项

每个生成器都是一个接受以下参数的函数：

n_samples（'default' 设置为 0）

n_features（'default' 设置为 0）

random_state

（以及可选的特定于生成器的参数）

该函数应返回一个 2 元组 (X, y)，其中 X 是一个 Pandas dataframe，y 是一个 Pandas series。如果生成器不生成标签，则可以返回 (X, None)

一组 helper 函数 (convert_*) 可以将这些转换为其他格式。未来的版本可能支持直接生成 cudf dataframes 或 GPU 数组。

cuml.benchmark.datagen.gen_data(dataset_name, dataset_format, n_samples=0, n_features=0, test_fraction=0.0, datasets_root_dir='.', dtype=<class 'numpy.float32'>, **kwargs)[source]#

从指定的生成器返回一个数据元组。

参数:

dataset_name字符串
要使用的数据集。可以是合成生成器（blobs 或 regression）或指定的数据集（目前是 higgs，其他即将推出）

dataset_format字符串
要返回的数据类型。（cudf、numpy、pandas、gpuarray 之一）

n_samplesint
加载的总样本数，包括训练样本和测试样本

test_fraction浮点数
将数据集随机划分为测试集的比例。如果为 0.0，则不会创建测试集。

返回值:

(train_features, train_labels, test_features, test_labels) 元组

包含请求格式的矩阵或 dataframe。

如果未进行分割，test_features 和 test_labels 可能为 None。

回归与分类#

线性回归#

class cuml.LinearRegression(*, algorithm='eig', fit_intercept=True, copy_X=True, normalize=False, handle=None, verbose=False, output_type=None)#

LinearRegression 是一种简单的机器学习模型，其中响应 y 通过 X 中的预测变量的线性组合进行建模。

cuML 的 LinearRegression 需要一个 cuDF DataFrame 或一个 NumPy 矩阵，并提供 SVD 和 Eig 两种算法来拟合线性模型。SVD 更稳定，但 Eig（默认）更快。

参数:

algorithm{'svd', 'eig', 'qr', 'svd-qr', 'svd-jacobi'}, (默认值 = 'eig')

选择一种算法

'svd' - svd-jacobi 的别名；

'eig' - 使用协方差矩阵的特征分解；

'qr' - 使用 QR 分解算法并求解 Rx = Q^T y

'svd-qr' - 使用 QR 算法计算 SVD 分解

'svd-jacobi' - 使用 Jacobi 迭代计算 SVD 分解。

在这些算法中，只有 'svd-jacobi' 支持特征数量大于样本大小的情况；在这种情况下会自动强制选择此算法。

对于大范围的输入，'eig' 和 'qr' 通常是最快的，其次是 'svd-jacobi'，然后是 'svd-qr'。理论上，基于 SVD 的算法更稳定。

fit_intercept布尔值 (默认值 = True)

如果为 True，LinearRegression 会尝试纠正 y 的全局均值。如果为 False，则模型期望您已对数据进行了中心化。

copy_X布尔值, 默认值=True

如果为 True，则保证创建 X 的副本，使原始 X 不变。但是，如果设置为 False，X 可能会被直接修改，这将减少估计器的内存使用量。

normalize布尔值 (默认值 = False)

当 fit_intercept 设置为 False 时，此参数将被忽略。如果为 True，则 X 中的预测变量将通过除以按列的标准差进行归一化。如果为 False，则不会进行缩放。注意：这与 scikit-learn 中已弃用的 normalize 标志相反，后者除以按列的 L2 范数；但这与使用 scikit-learn 的 StandardScaler 相同。

handlecuml.Handle

指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

属性:

coef_数组，形状 (n_features): 线性回归模型的估计系数。
intercept_数组: 截距项。如果 fit_intercept 为 False，则为 0。

方法

fit(X, y[, convert_dtype, sample_weight])

使用 X 和 y 拟合模型。

get_attr_names

注意

LinearRegression 存在多重共线性（当列之间相关时）和来自异常值的方差爆炸问题。考虑使用 Ridge 回归来解决多重共线性问题，并考虑先使用 DBSCAN 来去除异常值，或者使用统计分析来过滤可能的异常值。

LinearRegression 的应用

LinearRegression 用于回归任务，例如预测销售额或房价。它也用于外推法或时间序列任务、动态系统建模和许多其他机器学习任务。如果机器学习问题是回归任务（预测连续变量），则应首先尝试此模型。

有关更多信息，请参阅 scikit-learn 的 OLS 文档。

有关附加示例，请参阅 OLS notebook。

注意

从 23.08 版本开始，新的 'copy_X' 参数默认为 'True'，确保在将其传递给 fit() 后创建 X 的副本，防止对输入进行任何更改，但会增加内存使用量。这代表着与之前版本相比的行为变化。使用 copy_X=False 时，如有必要仍可能创建副本。

示例

>>> import cupy as cp
>>> import cudf

>>> # Both import methods supported
>>> from cuml import LinearRegression
>>> from cuml.linear_model import LinearRegression
>>> lr = LinearRegression(fit_intercept = True, normalize = False,
...                       algorithm = "eig")
>>> X = cudf.DataFrame()
>>> X['col1'] = cp.array([1,1,2,2], dtype=cp.float32)
>>> X['col2'] = cp.array([1,2,2,3], dtype=cp.float32)
>>> y = cudf.Series(cp.array([6.0, 8.0, 9.0, 11.0], dtype=cp.float32))
>>> reg = lr.fit(X,y)
>>> print(reg.coef_)
0   1.0
1   2.0
dtype: float32
>>> print(reg.intercept_)
3.0...

>>> X_new = cudf.DataFrame()
>>> X_new['col1'] = cp.array([3,2], dtype=cp.float32)
>>> X_new['col2'] = cp.array([5,5], dtype=cp.float32)
>>> preds = lr.predict(X_new)
>>> print(preds) 
0   15.999...
1   14.999...
dtype: float32

fit(X, y, convert_dtype=True, sample_weight=None) → LinearRegression[source]#

使用 X 和 y 拟合模型。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。
sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。

逻辑回归#

class cuml.LogisticRegression(*, penalty='l2', tol=0.0001, C=1.0, fit_intercept=True, class_weight=None, max_iter=1000, linesearch_max_iter=50, verbose=False, l1_ratio=None, solver='qn', handle=None, output_type=None)#

LogisticRegression 是一种线性模型，用于建模某些事件发生的概率，例如事件成功或失败的概率。

cuML 的 LogisticRegression 可以接受类数组对象，无论是在主机上的 NumPy 数组还是设备上的（作为 Numba 或 __cuda_array_interface__ compliant），此外还可以接受 cuDF 对象。它提供单类别（使用 sigmoid 损失）和多类别（使用 softmax 损失）变体，具体取决于输入变量

目前只有一个 solver 选项可用：Quasi-Newton (QN) 算法。尽管它作为一个单一选项呈现，但此 solver 在内部解析为两种不同的算法

如果有 l1 正则化，则使用 Orthant-Wise Limited Memory Quasi-Newton (OWL-QN)

否则使用 Limited Memory BFGS (L-BFGS)。

注意，就像在 Scikit-learn 中一样，偏差将不会被正则化。

参数:

penalty'none', 'l1', 'l2', 'elasticnet' (默认值 = 'l2')

用于指定惩罚中使用的范数。如果选择了 'none' 或 'l2'，则将使用 L-BFGS solver。如果选择了 'l1'，则将使用 solver OWL-QN。如果选择了 'elasticnet'，并且 l1_ratio > 0，则将使用 OWL-QN，否则将使用 L-BFGS。

tol浮点数 (默认值 = 1e-4)

停止标准的容忍度。精确的停止条件取决于所选的 solver。更多详细信息请查阅 solver 的文档

Quasi-Newton (L-BFGS/OWL-QN)

C浮点数 (默认值 = 1.0)

正则化强度的倒数；必须是正浮点数。

fit_intercept布尔值 (默认值 = True)

如果为 True，则模型会尝试纠正 y 的全局均值。如果为 False，则模型期望您已对数据进行了中心化。

class_weight字典或 'balanced', 默认值=None

默认情况下，所有类的权重都为一。但是，可以提供一个字典，其中包含与类关联的权重，形式为 {class_label: weight}。“balanced” 模式使用 y 的值自动调整权重，使其与输入数据中类频率成反比，计算方法为 n_samples / (n_classes * np.bincount(y))。请注意，如果指定了 sample_weight（通过 fit 方法传递），这些权重将与 sample_weight 相乘。

max_iter整数 (默认值 = 1000)

solver 收敛所需的最大迭代次数。

linesearch_max_iter整数 (默认值 = 50)

lbfgs 和 owl QN solvers 中每次外部迭代使用的最大线搜索迭代次数。

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

l1_ratio浮点数或 None, 可选 (默认值=None)

Elastic-Net 混合参数，其中 0 <= l1_ratio <= 1

solver'qn' (默认值='qn')

优化问题中使用的算法。目前仅支持 qn，它会根据上述 l1 正则化条件自动选择 L-BFGS 或 OWL-QN。

handlecuml.Handle

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

属性:

coef_: 设备数组, 维度 (n_classes, n_features) 或 (n_classes, n_features+1): 逻辑回归模型的估计系数。
intercept_: 设备数组 (n_classes, 1): 截距项。如果 fit_intercept 为 False，则为 0。

方法

`decision_function`(X[, convert_dtype])	给出 X 的置信度得分
`fit`(X, y[, sample_weight, convert_dtype])	使用 X 和 y 拟合模型。
`predict`(X[, convert_dtype])	预测 X 的 y。
`predict_log_proba`(X[, convert_dtype])	预测 X 中每个类的对数类概率
`predict_proba`(X[, convert_dtype])	预测 X 中每个类的类概率
`set_params`(**params)	为该估计器设置参数。

get_attr_names

注意

cuML 的 LogisticRegression 使用与等效的 Scikit-learn 不同的 solver，除非没有惩罚并且在 Scikit-learn 中使用了 solver=lbfgs。这可能导致模型系数和预测结果出现（较小的）差异，类似于在 Scikit-learn 中使用不同的 solver。

有关更多信息，请参阅 Scikit-learn 的 LogisticRegression。

示例

>>> import cudf
>>> import numpy as np

>>> # Both import methods supported
>>> # from cuml import LogisticRegression
>>> from cuml.linear_model import LogisticRegression

>>> X = cudf.DataFrame()
>>> X['col1'] = np.array([1,1,2,2], dtype = np.float32)
>>> X['col2'] = np.array([1,2,2,3], dtype = np.float32)
>>> y = cudf.Series(np.array([0.0, 0.0, 1.0, 1.0], dtype=np.float32))

>>> reg = LogisticRegression()
>>> reg.fit(X,y)
LogisticRegression()
>>> print(reg.coef_)
         0         1
0  0.69861  0.570058
>>> print(reg.intercept_)
0   -2.188...
dtype: float32

>>> X_new = cudf.DataFrame()
>>> X_new['col1'] = np.array([1,5], dtype = np.float32)
>>> X_new['col2'] = np.array([2,5], dtype = np.float32)

>>> preds = reg.predict(X_new)

>>> print(preds)
0    0.0
1    1.0
dtype: float32

decision_function(X, convert_dtype=True) → CumlArray[source]#

给出 X 的置信度得分

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 包含浮点数或双精度数的密集或稀疏矩阵。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，decision_function 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

返回值:

score取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, n_classes)

置信度得分

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

fit(X, y, sample_weight=None, convert_dtype=True) → LogisticRegression[source]#

使用 X 和 y 拟合模型。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 包含浮点数或双精度数的密集或稀疏矩阵。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

predict(X, convert_dtype=True) → CumlArray[source]#

预测 X 的 y。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 包含浮点数或双精度数的密集或稀疏矩阵。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

预测值

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

predict_log_proba(X, convert_dtype=True) → CumlArray[source]#

预测 X 中每个类的对数类概率

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 包含浮点数或双精度数的密集或稀疏矩阵。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，predict_log_proba 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, n_classes)

预测类别概率的对数

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

predict_proba(X, convert_dtype=True) → CumlArray[source]#

预测 X 中每个类的类概率

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 包含浮点数或双精度数的密集或稀疏矩阵。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，predict_proba 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, n_classes)

预测的类概率

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

set_params(**params)[source]#

为该估计器设置参数。

参数:

**params字典: 估计器参数

返回值:

self估计器实例: 估计器实例

岭回归#

class cuml.Ridge(*, alpha=1.0, solver='auto', fit_intercept=True, normalize=False, handle=None, output_type=None, verbose=False)#

Ridge 通过在预测响应 y 时对 X 中的预测变量的线性组合中的系数进行 L2 正则化来扩展 LinearRegression。它可以减少预测变量的方差，并改善问题的条件。

cuML 的 Ridge 可以接受类数组对象，无论是在主机上的 NumPy 数组还是设备上的（作为 Numba 或 __cuda_array_interface__ compliant），此外还可以接受 cuDF 对象。它提供 SVD、Eig 和 CD 三种算法来拟合线性模型。通常 SVD 比 Eig 使用更多的内存且速度更慢。如果使用 CUDA 10.1，内存差异甚至比其他支持的 CUDA 版本更大。然而，SVD 比 Eig（默认）更稳定。CD 使用 Coordinate Descent，在数据量大时速度更快。

参数:

alpha浮点数 (默认值 = 1.0): 正则化强度 - 必须是正浮点数。值越大表示正则化越强。数组输入将在稍后支持。
solver{'auto', 'eig', 'svd', 'cd'} (默认值 = 'auto'): Eig 使用协方差矩阵的特征分解，速度快得多。SVD 较慢，但保证稳定。CD 或 Coordinate Descent 速度非常快，适用于大型问题。
fit_intercept布尔值 (默认值 = True): 如果为 True，则 Ridge 会尝试纠正 y 的全局均值。如果为 False，则模型期望您已对数据进行了中心化。
normalize布尔值 (默认值 = False): 如果为 True，则 X 中的预测变量将通过除以按列的标准差进行归一化。如果为 False，则不会进行缩放。注意：这与 scikit-learn 中已弃用的 normalize 标志相反，后者除以按列的 L2 范数；但这与使用 scikit-learn 的 StandardScaler 相同。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

属性:

coef_数组，形状 (n_features): 线性回归模型的估计系数。
intercept_数组: 截距项。如果 fit_intercept 为 False，则为 0。

方法

fit(X, y[, convert_dtype, sample_weight])

使用 X 和 y 拟合模型。

get_attr_names

注意

Ridge 提供 L2 正则化。这意味着系数可以缩小到非常小，但不会变为零。这可能会导致系数的可解释性问题。考虑使用 Lasso 或将小系数阈值化为零。

Ridge 的应用

Ridge 回归与 LinearRegression 使用方式相同，但不存在多重共线性问题。Ridge 用于保险费预测、股市分析等等。

有关更多文档，请参阅 Scikit-learn 的 Ridge 回归。

示例

>>> import cupy as cp
>>> import cudf

>>> # Both import methods supported
>>> from cuml import Ridge
>>> from cuml.linear_model import Ridge

>>> alpha = 1e-5
>>> ridge = Ridge(alpha=alpha, fit_intercept=True, normalize=False,
...               solver="eig")

>>> X = cudf.DataFrame()
>>> X['col1'] = cp.array([1,1,2,2], dtype = cp.float32)
>>> X['col2'] = cp.array([1,2,2,3], dtype = cp.float32)

>>> y = cudf.Series(cp.array([6.0, 8.0, 9.0, 11.0], dtype=cp.float32))

>>> result_ridge = ridge.fit(X, y)
>>> print(result_ridge.coef_) 
0 1.000...
1 1.999...
>>> print(result_ridge.intercept_)
3.0...
>>> X_new = cudf.DataFrame()
>>> X_new['col1'] = cp.array([3,2], dtype=cp.float32)
>>> X_new['col2'] = cp.array([5,5], dtype=cp.float32)
>>> preds = result_ridge.predict(X_new)
>>> print(preds) 
0 15.999...
1 14.999...

fit(X, y, convert_dtype=True, sample_weight=None) → Ridge[source]#

使用 X 和 y 拟合模型。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。
sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。

Lasso 回归#

class cuml.Lasso(*, alpha=1.0, fit_intercept=True, normalize=False, max_iter=1000, tol=0.001, solver='cd', selection='cyclic', handle=None, output_type=None, verbose=False)[source]#

Lasso 通过在预测响应 y 时对 X 中的预测变量的线性组合中的系数进行 L1 正则化来扩展 LinearRegression。它可以将一些系数归零以进行特征选择，并改善问题的条件。

cuML 的 Lasso 可以接受类数组对象，无论是在主机上的 NumPy 数组还是设备上的（作为 Numba 或 __cuda_array_interface__ compliant），此外还可以接受 cuDF 对象。它使用坐标下降法来拟合线性模型。

此估计器支持 cuML 的实验性设备选择功能。它可以配置为在 CPU 或 GPU 上运行。要了解更多信息，请参阅 CPU / GPU 设备选择 (实验性)。

参数:

alpha浮点数 (默认值 = 1.0)

乘以 L1 项的常数。alpha = 0 等同于普通最小二乘，由 LinearRegression 对象求解。出于数值原因，不建议将 Lasso 对象的 alpha = 0。因此，您应该使用 LinearRegression 对象。

fit_intercept布尔值 (默认值 = True)

如果为 True，则 Lasso 会尝试纠正 y 的全局均值。如果为 False，则模型期望您已对数据进行了中心化。

normalize布尔值 (默认值 = False)

如果为 True，则 X 中的预测变量将通过除以按列的标准差进行归一化。如果为 False，则不会进行缩放。注意：这与 scikit-learn 中已弃用的 normalize 标志相反，后者除以按列的 L2 范数；但这与使用 scikit-learn 的 StandardScaler 相同。

max_iter整数 (默认值 = 1000)

最大迭代次数

tol浮点数 (默认值 = 1e-3)

优化的容忍度：如果更新小于 tol，优化代码会检查对偶间隙的 оптима性，并继续直到它小于 tol。

solver{'cd', 'qn'} (默认值='cd')

选择一种算法

'cd' - 坐标下降法

'qn' - 准牛顿法

当特征数量足够大但样本量很小的时候，您可能会发现替代的 'qn' 算法更快。

selection{'cyclic', 'random'} (默认值='cyclic')

如果设置为 'random'，则每次迭代更新一个随机系数，而不是默认情况下按顺序遍历特征。这（设置为 'random'）通常会导致显著更快的收敛，特别是当 tol 高于 1e-4 时。

handlecuml.Handle

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

属性:

coef_数组，形状 (n_features): 线性回归模型的估计系数。
intercept_数组: 截距项。如果 fit_intercept 为 False，则为 0。

注意

有关更多文档，请参阅 scikit-learn 的 Lasso。

示例

>>> import numpy as np
>>> import cudf
>>> from cuml.linear_model import Lasso
>>> ls = Lasso(alpha = 0.1, solver='qn')
>>> X = cudf.DataFrame()
>>> X['col1'] = np.array([0, 1, 2], dtype = np.float32)
>>> X['col2'] = np.array([0, 1, 2], dtype = np.float32)
>>> y = cudf.Series( np.array([0.0, 1.0, 2.0], dtype = np.float32) )
>>> result_lasso = ls.fit(X, y)
>>> print(result_lasso.coef_)
0   0.425
1   0.425
dtype: float32
>>> print(result_lasso.intercept_)
0.150000...

>>> X_new = cudf.DataFrame()
>>> X_new['col1'] = np.array([3,2], dtype = np.float32)
>>> X_new['col2'] = np.array([5,5], dtype = np.float32)
>>> preds = result_lasso.predict(X_new)
>>> print(preds)
0   3.549997
1   3.124997
dtype: float32

ElasticNet 回归#

class cuml.ElasticNet(*, alpha=1.0, l1_ratio=0.5, fit_intercept=True, normalize=False, max_iter=1000, tol=0.001, solver='cd', selection='cyclic', handle=None, output_type=None, verbose=False)#

ElasticNet 通过在预测响应 y 时对 X 中的预测变量的线性组合中的系数进行 L1 和 L2 联合正则化来扩展 LinearRegression。它可以减少预测变量的方差，强制一些系数变小，并改善问题的条件。

cuML 的 ElasticNet 可以接受类数组对象或 cuDF DataFrame，使用坐标下降法来拟合线性模型。

参数:

alpha浮点数 (默认值 = 1.0)

l1_ratio浮点数 (默认值 = 0.5)

ElasticNet 混合参数，范围为 0 <= l1_ratio <= 1。当 l1_ratio = 0 时，惩罚是 L2 惩罚。当 l1_ratio = 1 时，惩罚是 L1 惩罚。当 0 < l1_ratio < 1 时，惩罚是 L1 和 L2 的组合。

fit_intercept布尔值 (默认值 = True)

如果为 True，则 Lasso 会尝试纠正 y 的全局均值。如果为 False，则模型期望您已对数据进行了中心化。

normalize布尔值 (默认值 = False)

max_iter整数 (默认值 = 1000)

最大迭代次数

tol浮点数 (默认值 = 1e-3)

优化的容忍度：如果更新小于 tol，优化代码会检查对偶间隙的 оптима性，并继续直到它小于 tol。

solver{'cd', 'qn'} (默认值='cd')

选择一种算法

'cd' - 坐标下降法

'qn' - 准牛顿法

当特征数量足够大但样本量很小的时候，您可能会发现替代的 'qn' 算法更快。

selection{'cyclic', 'random'} (默认值='cyclic')

handlecuml.Handle

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

属性:

coef_数组，形状 (n_features): 线性回归模型的估计系数。
intercept_数组: 截距项。如果 fit_intercept 为 False，则为 0。

方法

`fit`(X, y[, convert_dtype, sample_weight])	使用 X 和 y 拟合模型。
`set_params`(**params)	为该估计器设置参数。

get_attr_names

注意

有关更多文档，请参阅 scikit-learn 的 ElasticNet。

示例

>>> import cupy as cp
>>> import cudf
>>> from cuml.linear_model import ElasticNet
>>> enet = ElasticNet(alpha = 0.1, l1_ratio=0.5, solver='qn')
>>> X = cudf.DataFrame()
>>> X['col1'] = cp.array([0, 1, 2], dtype = cp.float32)
>>> X['col2'] = cp.array([0, 1, 2], dtype = cp.float32)
>>> y = cudf.Series(cp.array([0.0, 1.0, 2.0], dtype = cp.float32) )
>>> result_enet = enet.fit(X, y)
>>> print(result_enet.coef_)
0    0.445...
1    0.445...
dtype: float32
>>> print(result_enet.intercept_)
0.108433...
>>> X_new = cudf.DataFrame()
>>> X_new['col1'] = cp.array([3,2], dtype = cp.float32)
>>> X_new['col2'] = cp.array([5,5], dtype = cp.float32)
>>> preds = result_enet.predict(X_new)
>>> print(preds)
0    3.674...
1    3.228...
dtype: float32

fit(X, y, convert_dtype=True, sample_weight=None) → ElasticNet[source]#

使用 X 和 y 拟合模型。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。
sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。

set_params(**params)[source]#

为该估计器设置参数。

参数:

**params字典: 估计器参数

返回值:

self估计器实例: 估计器实例

小批量 SGD 分类器#

class cuml.MBSGDClassifier(*, loss='hinge', penalty='l2', alpha=0.0001, l1_ratio=0.15, fit_intercept=True, epochs=1000, tol=0.001, shuffle=True, learning_rate='constant', eta0=0.001, power_t=0.5, batch_size=32, n_iter_no_change=5, handle=None, verbose=False, output_type=None)#

通过最小化正则化经验损失，使用小批量 SGD 拟合线性模型（线性 SVM、逻辑回归或线性回归）。MBSGD 分类器的实现是实验性的，并且使用的算法与 scikit-learn 的 SGDClassifier 不同。为了改进 cuML 的 MBSGDClassifier 获得的结果

减小批量大小
增加 eta0
增加迭代次数

由于 cuML 使用小批量分析数据，因此使用小的 eta0 可能无法让模型像 scikit-learn 那样学习。此外，减小批量大小可能会导致拟合模型所需时间增加。

参数:

loss{'hinge', 'log', 'squared_loss'} (默认值 = 'hinge')

'hinge' 使用线性 SVM

'log' 使用逻辑回归

'squared_loss' 使用线性回归

penalty{'none', 'l1', 'l2', 'elasticnet'} (默认值 = 'l2')

'none' 不执行任何正则化

'l1' 执行 L1 范数 (Lasso)，它最小化系数绝对值的和

'l2' 执行 L2 范数 (Ridge)，它最小化系数平方和

'elasticnet' 执行 Elastic Net 正则化，它是 L1 和 L2 范数的加权平均值

alpha浮点数 (默认值 = 0.0001)

决定正则化程度的常数值

l1_ratio浮点数 (默认值=0.15)

l1_ratio 仅当 penalty = elasticnet 时使用。l1_ratio 的值应在 0 <= l1_ratio <= 1 之间。当 l1_ratio = 0 时，penalty = 'l2'；如果 l1_ratio = 1，则 penalty = 'l1'。

batch_size整数 (默认值 = 32)

它设置了每个批次包含的样本数量。

fit_intercept布尔值 (默认值 = True)

如果为 True，则模型会尝试纠正 y 的全局均值。如果为 False，则模型期望您已对数据进行了中心化。

epochs整数 (默认值 = 1000)

训练过程中模型应该遍历整个数据集的次数（默认值 = 1000）

tol浮点数 (默认值 = 1e-3)

如果 current_loss > previous_loss - tol，训练过程将停止

shuffle布尔值 (默认值 = True)

True，每个 epoch 后打乱训练数据；False，每个 epoch 后不打乱训练数据

eta0浮点数 (默认值 = 0.001)

初始学习率

power_t浮点数 (默认值 = 0.5)

用于计算 invscaling 学习率的指数

learning_rate{'optimal', 'constant', 'invscaling', 'adaptive'} (默认值 = 'constant')

optimal 选项将在未来版本中支持

constant 保持学习率不变

adaptive 如果模型的训练损失或验证准确性在 n_iter_no_change 个 epoch 内没有改善，则改变学习率。新的学习率通常是旧学习率除以 5

n_iter_no_change整数 (默认值 = 5)

模型没有改进的训练 epoch 数

handlecuml.Handle

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

方法

`fit`(X, y[, convert_dtype])	使用 X 和 y 拟合模型。
`predict`(X[, convert_dtype])	预测 X 的 y。
`set_params`(**params)	接受一个参数字典并更新此类拥有的相应参数。

注意

有关更多文档，请参阅 scikit-learn 的 SGDClassifier。

示例

>>> import cupy as cp
>>> import cudf
>>> from cuml.linear_model import MBSGDClassifier
>>> X = cudf.DataFrame()
>>> X['col1'] = cp.array([1,1,2,2], dtype = cp.float32)
>>> X['col2'] = cp.array([1,2,2,3], dtype = cp.float32)
>>> y = cudf.Series(cp.array([1, 1, 2, 2], dtype=cp.float32))
>>> pred_data = cudf.DataFrame()
>>> pred_data['col1'] = cp.asarray([3, 2], dtype=cp.float32)
>>> pred_data['col2'] = cp.asarray([5, 5], dtype=cp.float32)
>>> cu_mbsgd_classifier = MBSGDClassifier(learning_rate='constant',
...                                       eta0=0.05, epochs=2000,
...                                       fit_intercept=True,
...                                       batch_size=1, tol=0.0,
...                                       penalty='l2',
...                                       loss='squared_loss',
...                                       alpha=0.5)
>>> cu_mbsgd_classifier.fit(X, y)
MBSGDClassifier()
>>> print("cuML intercept : ", cu_mbsgd_classifier.intercept_)
cuML intercept :  0.725...
>>> print("cuML coef : ", cu_mbsgd_classifier.coef_)
cuML coef :  0    0.273...
1    0.182...
dtype: float32
>>> cu_pred = cu_mbsgd_classifier.predict(pred_data)
>>> print("cuML predictions : ", cu_pred)
cuML predictions :  0   1.0
1    1.0
dtype: float32

fit(X, y, convert_dtype=True) → MBSGDClassifier[source]#

使用 X 和 y 拟合模型。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

predict(X, convert_dtype=True) → CumlArray[source]#

预测 X 的 y。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

预测值

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

set_params(**params)[source]#: 接受一个参数字典并更新该类拥有的相应参数。如果子类已适当重写了 _get_param_names 方法，并且不需要此方法中已有的其他任何内容，则无需重写此方法

Mini Batch SGD 回归器#

class cuml.MBSGDRegressor(*, loss='squared_loss', penalty='l2', alpha=0.0001, l1_ratio=0.15, fit_intercept=True, epochs=1000, tol=0.001, shuffle=True, learning_rate='constant', eta0=0.001, power_t=0.5, batch_size=32, n_iter_no_change=5, handle=None, verbose=False, output_type=None)#

使用 Mini Batch SGD 最小化正则化经验损失拟合的线性回归模型。MBSGD 回归器的实现是实验性的，它使用的算法与 sklearn 的 SGDClassifier 不同。为了改进 cuML 的 MBSGD 回归器获得的结果

减小批量大小
增加 eta0
增加迭代次数

由于 cuML 使用小批量分析数据，因此使用小的 eta0 可能无法让模型像 scikit-learn 那样学习。此外，减小批量大小可能会导致拟合模型所需时间增加。

参数:

loss'squared_loss' (默认值 = 'squared_loss')

'squared_loss' 使用线性回归

penalty'none', 'l1', 'l2', 'elasticnet' (默认值 = 'l2')

'none' 不执行任何正则化；'l1' 执行 L1 范数 (Lasso)，它使系数绝对值之和最小化；'l2' 执行 L2 范数 (Ridge)，它使系数平方和最小化；'elasticnet' 执行 Elastic Net 正则化，它是 L1 和 L2 范数的加权平均

alpha浮点数 (默认值 = 0.0001)

决定正则化程度的常数值

fit_intercept布尔值 (默认值 = True)

如果为 True，则模型会尝试纠正 y 的全局均值。如果为 False，则模型期望您已对数据进行了中心化。

l1_ratio浮点数 (默认值=0.15)

l1_ratio 仅当 penalty = elasticnet 时使用。l1_ratio 的值应在 0 <= l1_ratio <= 1 之间。当 l1_ratio = 0 时，penalty = 'l2'；如果 l1_ratio = 1，则 penalty = 'l1'。

batch_size整数 (默认值 = 32)

它设置了每个批次包含的样本数量。

epochs整数 (默认值 = 1000)

训练过程中模型应该遍历整个数据集的次数（默认值 = 1000）

tol浮点数 (默认值 = 1e-3)

如果 current_loss > previous_loss - tol，训练过程将停止

shuffle布尔值 (默认值 = True)

True，每个 epoch 后打乱训练数据；False，每个 epoch 后不打乱训练数据

eta0浮点数 (默认值 = 0.001)

初始学习率

power_t浮点数 (默认值 = 0.5)

用于计算 invscaling 学习率的指数

learning_rate{'optimal', 'constant', 'invscaling', 'adaptive'} (默认值 = 'constant')

optimal 选项将在未来版本中支持

constant 保持学习率不变

adaptive 如果模型的训练损失或验证准确性在 n_iter_no_change 个 epoch 内没有改善，则改变学习率。新的学习率通常是旧学习率除以 5

n_iter_no_change整数 (默认值 = 5)

模型没有改进的训练 epoch 数

handlecuml.Handle

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

方法

`fit`(X, y[, convert_dtype])	使用 X 和 y 拟合模型。
`predict`(X[, convert_dtype])	预测 X 的 y。
`set_params`(**params)	接受一个参数字典并更新此类拥有的相应参数。

注意

有关其他文档，请参阅 scikitlearn 的 SGDRegressor。

示例

>>> import cupy as cp
>>> import cudf
>>> from cuml.linear_model import MBSGDRegressor as cumlMBSGDRegressor
>>> X = cudf.DataFrame()
>>> X['col1'] = cp.array([1,1,2,2], dtype = cp.float32)
>>> X['col2'] = cp.array([1,2,2,3], dtype = cp.float32)
>>> y = cudf.Series(cp.array([1, 1, 2, 2], dtype=cp.float32))
>>> pred_data = cudf.DataFrame()
>>> pred_data['col1'] = cp.asarray([3, 2], dtype=cp.float32)
>>> pred_data['col2'] = cp.asarray([5, 5], dtype=cp.float32)
>>> cu_mbsgd_regressor = cumlMBSGDRegressor(learning_rate='constant',
...                                         eta0=0.05, epochs=2000,
...                                         fit_intercept=True,
...                                         batch_size=1, tol=0.0,
...                                         penalty='l2',
...                                         loss='squared_loss',
...                                         alpha=0.5)
>>> cu_mbsgd_regressor.fit(X, y)
MBSGDRegressor()
>>> print("cuML intercept : ", cu_mbsgd_regressor.intercept_)
cuML intercept :  0.725...
>>> print("cuML coef : ", cu_mbsgd_regressor.coef_)
cuML coef :  0    0.273...
1     0.182...
dtype: float32
>>> cu_pred = cu_mbsgd_regressor.predict(pred_data)
>>> print("cuML predictions : ", cu_pred)
cuML predictions :  0    2.456...
1    2.183...
dtype: float32

fit(X, y, convert_dtype=True) → MBSGDRegressor[source]#

使用 X 和 y 拟合模型。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

predict(X, convert_dtype=True) → CumlArray[source]#

预测 X 的 y。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

预测值

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

set_params(**params)[source]#: 接受一个参数字典并更新该类拥有的相应参数。如果子类已适当重写了 _get_param_names 方法，并且不需要此方法中已有的其他任何内容，则无需重写此方法

多类别分类#

class cuml.multiclass.MulticlassClassifier(estimator, *, handle=None, verbose=False, output_type=None, strategy='ovr')[source]#

scikit-learn 多类别分类器的包装器，允许选择不同的多类别策略。

输入可以是任何 cuML 兼容的数组类型，输出类型遵循 cuML 的输出类型配置规则。

在将数据传递给 scikit-learn 之前，它会被转换为主机 (numpy) 数组。在内部，数据被分区用于二元分类，然后由 cuML 估计器转换回设备。设备和主机之间的这些来回复制会产生一些开销。更多详细信息请参阅问题 rapidsai/cuml#2876。

参数:

estimatorcuML 估计器
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
strategy: 字符串 {'ovr', 'ovo'}，默认值='ovr': 多类别分类策略：'ovr'：一对多；'ovo'：一对一

属性:

classes_浮点型，形状 (n_classes_)类别标签数组。: n_classes_整型类别数量。
decision_function(X): 计算决策函数。

方法

`fit`(X, y)	拟合多类别分类器。
`predict`(X)	使用多类别分类器进行预测。
decision_function(X) → CumlArray[source]#	resultscuDF、CuPy 或 NumPy 对象，取决于 cuML 的输出类型配置，形状 = (n_samples, 1)决策函数值

示例

>>> from cuml.linear_model import LogisticRegression
>>> from cuml.multiclass import MulticlassClassifier
>>> from cuml.datasets.classification import make_classification

>>> X, y = make_classification(n_samples=10, n_features=6,
...                            n_informative=4, n_classes=3,
...                            random_state=137)

>>> cls = MulticlassClassifier(LogisticRegression(), strategy='ovo')
>>> cls.fit(X, y)
MulticlassClassifier(estimator=LogisticRegression())
>>> cls.predict(X)
array([1, 1, 1, 1, 1, 1, 2, 1, 1, 2])

fit(X, y) → MulticlassClassifier[source]#

拟合多类别分类器。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。

返回值:

任何 dtype 的密集矩阵。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。

predict(X) → CumlArray[source]#

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

class cuml.multiclass.OneVsOneClassifier(estimator, *args, handle=None, verbose=False, output_type=None)[source]#

使用多类别分类器进行预测。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 与 Scikit-learn 同名类的包装器。输入可以是任何 cuML 兼容的数组类型，输出类型遵循 cuML 的输出类型配置规则。

有关文档，请参阅 scikit-learn 的 OneVsOneClassifier。

resultscuDF、CuPy 或 NumPy 对象，取决于 cuML 的输出类型配置，形状 = (n_samples, 1)决策函数值

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

预测值

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

class cuml.multiclass.OneVsRestClassifier(estimator, *args, handle=None, verbose=False, output_type=None)[source]#

有关文档，请参阅 scikit-learn 的 OneVsRestClassifier。

朴素贝叶斯#

参数:

estimatorcuML 估计器
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

示例

>>> from cuml.linear_model import LogisticRegression
>>> from cuml.multiclass import OneVsOneClassifier
>>> from cuml.datasets.classification import make_classification

>>> X, y = make_classification(n_samples=10, n_features=6,
...                            n_informative=4, n_classes=3,
...                            random_state=137)

>>> cls = OneVsOneClassifier(LogisticRegression())
>>> cls.fit(X, y)
OneVsOneClassifier(estimator=LogisticRegression())
>>> cls.predict(X)
array([1, 1, 1, 1, 1, 1, 2, 1, 1, 2])

class cuml.naive_bayes.MultinomialNB(*, alpha=1.0, fit_prior=True, class_prior=None, output_type=None, handle=None, verbose=False)[source]#

有关文档，请参阅 scikit-learn 的 OneVsRestClassifier。

用于多项式模型的朴素贝叶斯分类器

参数:

estimatorcuML 估计器
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

示例

>>> from cuml.linear_model import LogisticRegression
>>> from cuml.multiclass import OneVsRestClassifier
>>> from cuml.datasets.classification import make_classification

>>> X, y = make_classification(n_samples=10, n_features=6,
...                            n_informative=4, n_classes=3,
...                            random_state=137)

>>> cls = OneVsRestClassifier(LogisticRegression())
>>> cls.fit(X, y)
OneVsRestClassifier(estimator=LogisticRegression())
>>> cls.predict(X)
array([1, 1, 1, 1, 1, 1, 2, 1, 1, 2])

多项式朴素贝叶斯分类器适用于具有离散特征的分类（例如，文本分类的词频）。

多项式分布通常需要整数特征计数。然而，在实践中，诸如 tf-idf 之类的分数计数也可能有效。

alpha浮点型 (默认值=1.0)加法（Laplace/Lidstone）平滑参数（0 表示无平滑）。

fit_prior布尔型 (默认值=True)是否学习类别先验概率。如果为 false，将使用均匀先验。

class_prior数组形式，大小 (n_classes) (默认值=None)类别的先验概率。如果指定，则先验不根据数据进行调整。

参数:

class_count_形状为 (n_classes) 的 ndarray拟合过程中遇到的每个类别的样本数量。: class_log_prior_形状为 (n_classes) 的 ndarray每个类别的对数概率（平滑后）。
classes_形状为 (n_classes,) 的 ndarray分类器已知的类别标签: feature_count_形状为 (n_classes, n_features) 的 ndarray拟合过程中遇到的每个（类别，特征）的样本数量。
feature_log_prob_形状为 (n_classes, n_features) 的 ndarray给定类别的特征经验对数概率，P(x_i|y)。: n_features_整型每个样本的特征数量。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

属性:

从 Scikit-learn 加载 20 个新闻组数据集并训练朴素贝叶斯分类器。: class cuml.naive_bayes.BernoulliNB(*, alpha=1.0, binarize=0.0, fit_prior=True, class_prior=None, output_type=None, handle=None, verbose=False)[source]#
用于多元伯努利模型的朴素贝叶斯分类器。与 MultinomialNB 一样，此分类器适用于离散数据。区别在于 MultinomialNB 处理出现计数，而 BernoulliNB 专为二元/布尔特征设计。: alpha浮点型，默认值=1.0
binarize浮点型或 None，默认值=0.0对样本特征进行二值化（映射到布尔值）的阈值。如果为 None，则假定输入已由二元向量组成。: fit_prior布尔型，默认值=True是否学习类别先验概率。如果为 false，将使用均匀先验。
class_prior形状为 (n_classes,) 的数组形式，默认值=None类别的先验概率。如果指定，则先验不根据数据进行调整。: C.D. Manning, P. Raghavan and H. Schuetze (2008). Introduction to Information Retrieval. Cambridge University Press, pp. 234-265. https://nlp.stanford.edu/IR-book/html/htmledition/the-bernoulli-model-1.html A. McCallum and K. Nigam (1998). A comparison of event models for naive Bayes text classification. Proc. AAAI/ICML-98 Workshop on Learning for Text Categorization, pp. 41-48. V. Metsis, I. Androutsopoulos and G. Paliouras (2006). Spam filtering with naive Bayes – Which naive Bayes? 3rd Conf. on Email and Anti-Spam (CEAS).
class cuml.naive_bayes.ComplementNB(*, alpha=1.0, fit_prior=True, class_prior=None, norm=False, output_type=None, handle=None, verbose=False)[source]#: Rennie 等人 (2003) 描述的互补朴素贝叶斯分类器。互补朴素贝叶斯分类器旨在纠正标准多项式朴素贝叶斯分类器所做的“严格假设”。它特别适用于不平衡数据集。
norm布尔型，默认值=False是否进行第二次权重归一化。默认行为与 Mahout 和 Weka 中的实现相似，它们没有遵循论文表 9 中描述的完整算法。: Rennie, J. D., Shih, L., Teevan, J., & Karger, D. R. (2003). Tackling the poor assumptions of naive bayes text classifiers. In ICML (Vol. 3, pp. 616-623). https://people.csail.mit.edu/jrennie/papers/icml03-nb.pdf

示例

class cuml.naive_bayes.GaussianNB(*, priors=None, var_smoothing=1e-09, output_type=None, handle=None, verbose=False)[source]#

>>> import cupy as cp
>>> import cupyx
>>> from sklearn.datasets import fetch_20newsgroups
>>> from sklearn.feature_extraction.text import CountVectorizer
>>> from cuml.naive_bayes import MultinomialNB

>>> # Load corpus
>>> twenty_train = fetch_20newsgroups(subset='train', shuffle=True,
...                                   random_state=42)

>>> # Turn documents into term frequency vectors

>>> count_vect = CountVectorizer()
>>> features = count_vect.fit_transform(twenty_train.data)

>>> # Put feature vectors and labels on the GPU

>>> X = cupyx.scipy.sparse.csr_matrix(features.tocsr(),
...                                   dtype=cp.float32)
>>> y = cp.asarray(twenty_train.target, dtype=cp.int32)

>>> # Train model

>>> model = MultinomialNB()
>>> model.fit(X, y)
MultinomialNB()

>>> # Compute accuracy on training set

>>> model.score(X, y)
0.9245...

高斯朴素贝叶斯 (GaussianNB) 可以通过 partial_fit() 方法在线更新模型参数。有关在线更新特征均值和方差所用算法的详细信息，请参阅 Chan、Golub 和 LeVeque 的 Stanford CS 技术报告 STAN-CS-79-773

http://i.stanford.edu/pub/cstr/reports/cs/tr/79/773/CS-TR-79-773.pdf

参数:

priors形状为 (n_classes,) 的数组形式: class_log_prior_形状为 (n_classes) 的 ndarray每个类别的对数概率（平滑后）。
var_smoothing浮点型，默认值=1e-9所有特征最大方差的一部分，添加到方差中以提高计算稳定性。: fit(X, y[, sample_weight])
根据 X, y 拟合高斯朴素贝叶斯分类器: partial_fit(X, y[, classes, sample_weight])
对一批样本进行增量拟合。: fit(X, y, sample_weight=None) → GaussianNB[source]#
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

属性:

从 Scikit-learn 加载 20 个新闻组数据集并训练朴素贝叶斯分类器。: class cuml.naive_bayes.BernoulliNB(*, alpha=1.0, binarize=0.0, fit_prior=True, class_prior=None, output_type=None, handle=None, verbose=False)[source]#
用于多元伯努利模型的朴素贝叶斯分类器。与 MultinomialNB 一样，此分类器适用于离散数据。区别在于 MultinomialNB 处理出现计数，而 BernoulliNB 专为二元/布尔特征设计。: alpha浮点型，默认值=1.0
binarize浮点型或 None，默认值=0.0对样本特征进行二值化（映射到布尔值）的阈值。如果为 None，则假定输入已由二元向量组成。: fit_prior布尔型，默认值=True是否学习类别先验概率。如果为 false，将使用均匀先验。
class_prior形状为 (n_classes,) 的数组形式，默认值=None类别的先验概率。如果指定，则先验不根据数据进行调整。: C.D. Manning, P. Raghavan and H. Schuetze (2008). Introduction to Information Retrieval. Cambridge University Press, pp. 234-265. https://nlp.stanford.edu/IR-book/html/htmledition/the-bernoulli-model-1.html A. McCallum and K. Nigam (1998). A comparison of event models for naive Bayes text classification. Proc. AAAI/ICML-98 Workshop on Learning for Text Categorization, pp. 41-48. V. Metsis, I. Androutsopoulos and G. Paliouras (2006). Spam filtering with naive Bayes – Which naive Bayes? 3rd Conf. on Email and Anti-Spam (CEAS).
class cuml.naive_bayes.ComplementNB(*, alpha=1.0, fit_prior=True, class_prior=None, norm=False, output_type=None, handle=None, verbose=False)[source]#: Rennie 等人 (2003) 描述的互补朴素贝叶斯分类器。互补朴素贝叶斯分类器旨在纠正标准多项式朴素贝叶斯分类器所做的“严格假设”。它特别适用于不平衡数据集。
norm布尔型，默认值=False是否进行第二次权重归一化。默认行为与 Mahout 和 Weka 中的实现相似，它们没有遵循论文表 9 中描述的完整算法。: Rennie, J. D., Shih, L., Teevan, J., & Karger, D. R. (2003). Tackling the poor assumptions of naive bayes text classifiers. In ICML (Vol. 3, pp. 616-623). https://people.csail.mit.edu/jrennie/papers/icml03-nb.pdf

参考

X{数组形式，cupy 稀疏矩阵}，形状为 (n_samples, n_features)训练向量，其中 n_samples 是样本数量，n_features 是特征数量。

示例

>>> import cupy as cp
>>> rng = cp.random.RandomState(1)
>>> X = rng.randint(5, size=(6, 100), dtype=cp.int32)
>>> Y = cp.array([1, 2, 3, 4, 4, 5])
>>> from cuml.naive_bayes import BernoulliNB
>>> clf = BernoulliNB()
>>> clf.fit(X, Y)
BernoulliNB()
>>> print(clf.predict(X[2:3]))
[3]

y数组形式，形状 (n_samples) 目标值。

sample_weight形状为 (n_samples) 的数组形式应用于单个样本的权重（非加权时为 1.）。当前样本权重被忽略。

参数:

priors形状为 (n_classes,) 的数组形式: class_log_prior_形状为 (n_classes) 的 ndarray每个类别的对数概率（平滑后）。
根据 X, y 拟合高斯朴素贝叶斯分类器: partial_fit(X, y[, classes, sample_weight])
对一批样本进行增量拟合。: fit(X, y, sample_weight=None) → GaussianNB[source]#
partial_fit(X, y, classes=None, sample_weight=None) → GaussianNB[source]#: 对一批样本进行增量拟合。该方法期望在数据集的不同块上连续调用多次，以实现核外或在线学习。当整个数据集过大无法一次性载入内存时，这尤其有用。该方法存在一些性能开销，因此最好在尽可能大的数据块（只要在内存预算内）上调用 partial_fit 以隐藏开销。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

属性:

从 Scikit-learn 加载 20 个新闻组数据集并训练朴素贝叶斯分类器。: class cuml.naive_bayes.BernoulliNB(*, alpha=1.0, binarize=0.0, fit_prior=True, class_prior=None, output_type=None, handle=None, verbose=False)[source]#
用于多元伯努利模型的朴素贝叶斯分类器。与 MultinomialNB 一样，此分类器适用于离散数据。区别在于 MultinomialNB 处理出现计数，而 BernoulliNB 专为二元/布尔特征设计。: alpha浮点型，默认值=1.0
binarize浮点型或 None，默认值=0.0对样本特征进行二值化（映射到布尔值）的阈值。如果为 None，则假定输入已由二元向量组成。: fit_prior布尔型，默认值=True是否学习类别先验概率。如果为 false，将使用均匀先验。
class_prior形状为 (n_classes,) 的数组形式，默认值=None类别的先验概率。如果指定，则先验不根据数据进行调整。: C.D. Manning, P. Raghavan and H. Schuetze (2008). Introduction to Information Retrieval. Cambridge University Press, pp. 234-265. https://nlp.stanford.edu/IR-book/html/htmledition/the-bernoulli-model-1.html A. McCallum and K. Nigam (1998). A comparison of event models for naive Bayes text classification. Proc. AAAI/ICML-98 Workshop on Learning for Text Categorization, pp. 41-48. V. Metsis, I. Androutsopoulos and G. Paliouras (2006). Spam filtering with naive Bayes – Which naive Bayes? 3rd Conf. on Email and Anti-Spam (CEAS).
class cuml.naive_bayes.ComplementNB(*, alpha=1.0, fit_prior=True, class_prior=None, norm=False, output_type=None, handle=None, verbose=False)[source]#: Rennie 等人 (2003) 描述的互补朴素贝叶斯分类器。互补朴素贝叶斯分类器旨在纠正标准多项式朴素贝叶斯分类器所做的“严格假设”。它特别适用于不平衡数据集。
norm布尔型，默认值=False是否进行第二次权重归一化。默认行为与 Mahout 和 Weka 中的实现相似，它们没有遵循论文表 9 中描述的完整算法。: Rennie, J. D., Shih, L., Teevan, J., & Karger, D. R. (2003). Tackling the poor assumptions of naive bayes text classifiers. In ICML (Vol. 3, pp. 616-623). https://people.csail.mit.edu/jrennie/papers/icml03-nb.pdf

参考

训练向量，其中 n_samples 是样本数量，n_features 是特征数量。COO 格式的稀疏矩阵是首选，其他格式将转换为 COO 格式。

示例

>>> import cupy as cp
>>> rng = cp.random.RandomState(1)
>>> X = rng.randint(5, size=(6, 100), dtype=cp.int32)
>>> Y = cp.array([1, 2, 3, 4, 4, 5])
>>> from cuml.naive_bayes import ComplementNB
>>> clf = ComplementNB()
>>> clf.fit(X, Y)
ComplementNB()
>>> print(clf.predict(X[2:3]))
[3]

y形状为 (n_samples) 的数组形式目标值。

classes形状为 (n_classes) 的数组形式可能出现在 y 向量中的所有类别列表。必须在第一次调用 partial_fit 时提供，后续调用中可以省略。

class cuml.naive_bayes.CategoricalNB(*, alpha=1.0, fit_prior=True, class_prior=None, output_type=None, handle=None, verbose=False)[source]#

参数:

用于分类特征的朴素贝叶斯分类器类别朴素贝叶斯分类器适用于具有类别分布离散特征的分类。每个特征的类别从类别分布中抽取。: fit(X, y, sample_weight=None) → GaussianNB[source]#
category_count_形状为 (n_features, n_classes, n_categories) 的 ndarray其中 n_categories 是所有特征中的最高类别。该数组提供了特定特征在每个特征、类别和类别中遇到的样本数量。: class_count_形状为 (n_classes,) 的 ndarray
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

方法

class_log_prior_形状为 (n_classes,) 的 ndarray每个类别的平滑经验对数概率。	feature_log_prob_形状为 (n_features, n_classes, n_categories) 的 ndarray其中 n_categories 是所有特征中的最高类别。每个形状为 (n_classes, n_categories) 的数组提供了给定相应特征和类别的类别的经验对数概率，`P(x_i\|y)`。当模型使用稀疏数据进行训练时，此属性不可用。
`fit`(X, y[, sample_weight])	根据 X, y 拟合朴素贝叶斯分类器

示例

>>> import cupy as cp
>>> X = cp.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1],
...                 [3, 2]], cp.float32)
>>> Y = cp.array([1, 1, 1, 2, 2, 2], cp.float32)
>>> from cuml.naive_bayes import GaussianNB
>>> clf = GaussianNB()
>>> clf.fit(X, Y)
GaussianNB()
>>> print(clf.predict(cp.array([[-0.8, -1]], cp.float32)))
[1]
>>> clf_pf = GaussianNB()
>>> clf_pf.partial_fit(X, Y, cp.unique(Y))
GaussianNB()
>>> print(clf_pf.predict(cp.array([[-0.8, -1]], cp.float32)))
[1]

partial_fit(X, y[, classes, sample_weight])

feature_log_prob_形状为 (n_features, n_classes, n_categories) 的 ndarray其中 n_categories 是所有特征中的最高类别。每个形状为 (n_classes, n_categories) 的数组提供了给定相应特征和类别的类别的经验对数概率，P(x_i|y)。当模型使用稀疏数据进行训练时，此属性不可用。

参数:

fit(X, y, sample_weight=None) → CategoricalNB[source]#: 训练向量，其中 n_samples 是样本数量，n_features 是特征数量。此处，X 的每个特征假定来自不同的类别分布。进一步假定每个特征的所有类别由数字 0, …, n - 1 表示，其中 n 指的是给定特征的总类别数量。例如，这可以通过 OrdinalEncoder 实现。
y形状为 (n_samples,) 的数组形式
sample_weight形状为 (n_samples) 的数组形式，默认值=None: partial_fit(X, y, classes=None, sample_weight=None) → CategoricalNB[source]#

y形状为 (n_samples) 的数组形式

classes形状为 (n_classes) 的数组形式，默认值=None

参数:

fit(X, y, sample_weight=None) → CategoricalNB[source]#: 随机梯度下降#
class cuml.SGD(*, loss='squared_loss', penalty='none', alpha=0.0001, l1_ratio=0.15, fit_intercept=True, epochs=1000, tol=0.001, shuffle=True, learning_rate='constant', eta0=0.001, power_t=0.5, batch_size=32, n_iter_no_change=5, handle=None, output_type=None, verbose=False)#
随机梯度下降是一种非常常见的机器学习算法，通过梯度步长来优化某个成本函数。这使得 SGD 对于难以甚至不可能找到精确解的大规模问题非常有吸引力。: cuML 的 SGD 算法接受 numpy 矩阵或 cuDF DataFrame 作为输入数据集。SGD 算法目前适用于线性回归、岭回归和 SVM 模型。
sample_weight形状为 (n_samples) 的数组形式，默认值=None: partial_fit(X, y, classes=None, sample_weight=None) → CategoricalNB[source]#

返回值:

忽略。

loss'hinge'，'log'，'squared_loss' (默认值 = 'squared_loss')

'hinge' 使用线性 SVM；'log' 使用逻辑回归；'squared_loss' 使用线性回归

参数:

priors形状为 (n_classes,) 的数组形式: class_log_prior_形状为 (n_classes) 的 ndarray每个类别的对数概率（平滑后）。
根据 X, y 拟合高斯朴素贝叶斯分类器: partial_fit(X, y[, classes, sample_weight])
对一批样本进行增量拟合。: fit(X, y, sample_weight=None) → GaussianNB[source]#
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

属性:

penalty'none'，'l1'，'l2'，'elasticnet' (默认值 = 'none'): batch_size整型 (默认值=32)
learning_rate'optimal'，'constant'，'invscaling'，'adaptive' (默认值 = 'constant'): class cuml.naive_bayes.BernoulliNB(*, alpha=1.0, binarize=0.0, fit_prior=True, class_prior=None, output_type=None, handle=None, verbose=False)[source]#
optimal 选项在下一版本中支持；constant 保持学习率不变；adaptive 在 n_iter_no_change 个 epoch 内训练损失或验证准确率没有提高时改变学习率。旧的学习率通常除以 5: 模型没有任何改进时的训练 epoch 数量
binarize浮点型或 None，默认值=0.0对样本特征进行二值化（映射到布尔值）的阈值。如果为 None，则假定输入已由二元向量组成。: fit_prior布尔型，默认值=True是否学习类别先验概率。如果为 false，将使用均匀先验。
coef_: fit(X, y[, convert_dtype])
norm布尔型，默认值=False是否进行第二次权重归一化。默认行为与 Mahout 和 Weka 中的实现相似，它们没有遵循论文表 9 中描述的完整算法。: Rennie, J. D., Shih, L., Teevan, J., & Karger, D. R. (2003). Tackling the poor assumptions of naive bayes text classifiers. In ICML (Vol. 3, pp. 616-623). https://people.csail.mit.edu/jrennie/papers/icml03-nb.pdf

方法

`predict`(X[, convert_dtype])	`predictClass`(X[, convert_dtype])
fit(X, y, convert_dtype=True) → SGD[source]#	根据 X, y 拟合朴素贝叶斯分类器

示例

>>> import cupy as cp
>>> rng = cp.random.RandomState(1)
>>> X = rng.randint(5, size=(6, 100), dtype=cp.int32)
>>> y = cp.array([1, 2, 3, 4, 5, 6])
>>> from cuml.naive_bayes import CategoricalNB
>>> clf = CategoricalNB()
>>> clf.fit(X, y)
CategoricalNB()
>>> print(clf.predict(X[2:3]))
[3]

predict(X, convert_dtype=True) → CumlArray[source]#

predictClass(X[, convert_dtype])

参数:

X形状为 (n_samples, n_features) 的 array-like 对象: predictClass(X, convert_dtype=True) → CumlArray[source]#
设置为 True 时，predictClass 方法在必要时会将输入转换为训练模型时使用的数据类型。这将增加方法使用的内存。: 目标值。
随机森林#: partial_fit(X, y, classes=None, sample_weight=None) → CategoricalNB[source]#

返回值:

忽略。

class cuml.ensemble.RandomForestClassifier(*, split_criterion=0, handle=None, verbose=False, output_type=None, **kwargs)#

classes形状为 (n_classes) 的数组形式，默认值=None

参数:

X形状为 (n_samples, n_features) 的 array-like 对象: predictClass(X, convert_dtype=True) → CumlArray[source]#
实现一个随机森林分类器模型，该模型在集成中拟合多个决策树分类器。: 目标值。
请注意，树节点分裂的底层算法与 scikit-learn 中使用的算法不同。默认情况下，cuML 随机森林使用基于分位数的算法来确定分裂，而不是精确计数。您可以使用 n_bins 参数调整分位数的大小。: cuML 的 SGD 算法接受 numpy 矩阵或 cuDF DataFrame 作为输入数据集。SGD 算法目前适用于线性回归、岭回归和 SVM 模型。
随机森林#: partial_fit(X, y, classes=None, sample_weight=None) → CategoricalNB[source]#

返回值:

忽略。

您可以导出 cuML 随机森林模型，并在没有 NVIDIA GPU 的机器上使用它们运行预测。有关更多详细信息，请参阅 https://docs.rapids.org.cn/api/cuml/stable/pickling_cuml_models.html。

n_estimators整型 (默认值 = 100)森林中的树数量。(默认值在 cuML 0.11 中更改为 100)

split_criterion整型或字符串 (默认值 = 0 ('gini'))用于分裂节点的准则。

0 或 'gini' 表示基尼不纯度

参数:

1 或 'entropy' 表示信息增益（熵）: 2 或 'mse' 表示均方误差
4 或 'poisson' 表示泊松半偏差: 'none' 不执行任何正则化；'l1' 执行 L1 范数 (Lasso)，它使系数绝对值之和最小化；'l2' 执行 L2 范数 (Ridge)，它使系数平方和最小化；'elasticnet' 执行 Elastic Net 正则化，它是 L1 和 L2 范数的加权平均
alpha浮点数 (默认值 = 0.0001): 决定正则化程度的常数值
fit_intercept布尔值 (默认值 = True): 如果为 True，则模型会尝试纠正 y 的全局均值。如果为 False，则模型期望您已对数据进行了中心化。
epochs整数 (默认值 = 1000): 训练过程中模型应该遍历整个数据集的次数（默认值 = 1000）
tol浮点数 (默认值 = 1e-3): 如果 current_loss > previous_loss - tol，训练过程将停止
shuffle布尔值 (默认值 = True): True，每个 epoch 后打乱训练数据；False，每个 epoch 后不打乱训练数据
eta0浮点数 (默认值 = 0.001): 初始学习率
power_t浮点数 (默认值 = 0.5): 用于计算 invscaling 学习率的指数
5 或 'gamma' 表示 gamma 半偏差: 每个批次使用的样本数量。
6 或 'inverse_gaussian' 表示逆高斯偏差: 只有 0/'gini' 和 1/'entropy' 对分类有效
n_iter_no_change整数 (默认值 = 5): bootstrap布尔型 (默认值 = True)控制自助采样。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

属性:

classes_
如果为 True，则森林中的每棵树都基于有放回的自助样本构建。

方法

如果为 `False`，则使用整个数据集构建每棵树。	使用 X 和 y 拟合模型。
max_samples浮点型 (默认值 = 1.0)拟合每棵树时使用的数据集行数的比例。	预测 X 的 y。
max_depth整型 (默认值 = 16)最大树深度。必须大于 0。不支持无限深度（即直到叶子节点纯净）。	预测 X 的 y。

示例

>>> import numpy as np
>>> import cudf
>>> from cuml.solvers import SGD as cumlSGD
>>> X = cudf.DataFrame()
>>> X['col1'] = np.array([1,1,2,2], dtype=np.float32)
>>> X['col2'] = np.array([1,2,2,3], dtype=np.float32)
>>> y = cudf.Series(np.array([1, 1, 2, 2], dtype=np.float32))
>>> pred_data = cudf.DataFrame()
>>> pred_data['col1'] = np.asarray([3, 2], dtype=np.float32)
>>> pred_data['col2'] = np.asarray([5, 5], dtype=np.float32)
>>> cu_sgd = cumlSGD(learning_rate='constant', eta0=0.005, epochs=2000,
...                  fit_intercept=True, batch_size=2,
...                  tol=0.0, penalty='none', loss='squared_loss')
>>> cu_sgd.fit(X, y)
SGD()
>>> cu_pred = cu_sgd.predict(pred_data).to_numpy()
>>> print(" cuML intercept : ", cu_sgd.intercept_) 
cuML intercept :  0.00418...
>>> print(" cuML coef : ", cu_sgd.coef_) 
cuML coef :  0      0.9841...
1      0.0097...
dtype: float32
>>> print("cuML predictions : ", cu_pred) 
cuML predictions :  [3.0055...  2.0214...]

此默认值与 scikit-learn 的随机森林不同，后者默认为无限深度。

使用 X 和 y 拟合模型。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

max_leaves整型 (默认值 = -1)每棵树的最大叶子节点数。软约束。如果为 -1，则无限制。

预测 X 的 y。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

预测值

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

max_features整型、浮点型或字符串 (默认值 = ‘sqrt’)每个节点分裂时考虑的特征（列）数量的比例。

预测 X 的 y。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 如果类型为 int，则 max_features 是要使用的特征的绝对数量

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

预测值

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

如果类型为 `float`，则 `max_features` 用作一个分数。

如果为 'sqrt'，则 max_features=1/sqrt(n_features)。

如果为 'log2'，则 max_features=log2(n_features)/n_features。

注意

在 24.06 版本中更改: max_features 的默认值从 "auto" 更改为 "sqrt"。

注意

n_bins整型 (默认值 = 128)每个特征分裂算法使用的最大 bin 数量。对于大型问题，特别是输入数据高度偏斜的问题，增加 bin 数量可能会提高准确性。

参数:

n_streams整型 (默认值 = 4)用于构建森林的并行流数量。

min_samples_leaf整型或浮点型 (默认值 = 1)每个叶子节点中的最小样本（行）数量。

如果类型为 int，则 min_samples_leaf 表示最小数量。

如果为 float，则 min_samples_leaf 表示一个分数，ceil(min_samples_leaf * n_rows) 是每个叶子节点的最小样本数量。

min_samples_split整型或浮点型 (默认值 = 2)分裂内部节点所需的最小样本数量。

如果类型为 int，则 min_samples_split 表示最小数量。

如果类型为 float，则 min_samples_split 表示一个分数，max(2, ceil(min_samples_split * n_rows)) 是每个分裂的最小样本数量。

min_impurity_decrease浮点型 (默认值 = 0.0)节点分裂所需的最小不纯度减少量。

max_batch_size整型 (默认值 = 4096)在给定批次中可以处理的最大节点数量。

随机数生成器的种子。默认情况下未设置种子。目前不能完全保证结果完全相同。

convert_to_fil_model([output_class, ...])

从已训练的 cuML 随机森林模型创建 Forest Inference (FIL) 模型。

convert_to_treelite_model

将 cuML RF 模型转换为 Treelite 模型

cpu_to_gpu

将属性从 CPU 估计器转移到 GPU 估计器。

fit(X, y[, convert_dtype])

对输入数据执行随机森林分类

get_detailed_text

注意

获取随机森林模型的详细信息（文本形式）

get_json

将随机森林模型导出为 JSON 字符串

get_summary_text

获取随机森林模型的文本摘要

predict(X[, predict_model, threshold, algo, ...])

预测 X 的标签。

predict_proba(X[, algo, convert_dtype, ...])

预测 X 的类别概率。

score(X, y[, threshold, algo, ...])

计算模型对 X 的准确率指标得分。

已知限制

这是 cuML 随机森林代码的早期版本。它包含一些已知限制

基于 GPU 的推理仅支持 32 位 (float32) 数据类型。替代方法是使用基于 CPU 的推理处理 64 位 (float64) 数据类型，或者在 GPU 推理期间让默认的自动数据类型转换发生。

在训练多类别分类问题的模型时，使用深层树或 max_features=1.0 可以提供更好的性能。

有关其他文档，请参阅 scikitlearn 的 RandomForestClassifier。

convert_to_fil_model(output_class=True, threshold=0.5, algo='auto', fil_sparse_format='auto')[source]#

output_class布尔型 (默认值 = True)这是可选的，仅在 GPU 上执行预测操作时需要。如果为 true，则根据原始预测是否超过阈值返回 1 或 0。如果为 false，则仅返回原始预测。

algo字符串 (默认值 = ‘auto’)这是可选的，仅在 GPU 上执行预测操作时需要。

'naive' - 使用共享内存进行简单推理

'tree_reorg' - 类似于 naive，但树经过重新组织以更适合合并

'batch_tree_reorg' - 类似于 tree_reorg，但在每个线程块中预测多行

'auto' - 自动选择算法。目前，'batch_tree_reorg' 用于密集存储，而 'naive' 用于稀疏存储

threshold浮点型 (默认值 = 0.5)用于分类的阈值。可选的，仅在 GPU 上执行预测操作时需要。如果 output_class == True 则应用，否则忽略

fil_sparse_format布尔型或字符串 (默认值 = auto)此变量用于选择将在 Forest Inference Library 中创建的森林类型。在使用 predict_model=’CPU’ 时不需要它。

'auto' - 自动选择存储类型（目前 auto 选择 True）

random_stateint (default = None)

False - 创建密集森林

handlecuml.Handle

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

方法

`True` - 创建稀疏森林，需要 algo=’naive’ 或 algo=’auto’	fil_model
`可用于对随机森林模型执行推理的 Forest Inference 模型。`()	convert_to_treelite_model()[source]#
`tl_to_fil_model此模型的 Treelite 版本`()	cpu_to_gpu()[source]#
fit(X, y, convert_dtype=True)[source]#	np.int32 类型的密集矩阵。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
`设置为 True 时，该方法将自动将输入转换为 np.float32。`()	设置为 True 时，fit 方法在必要时会将 y 转换为 int32 dtype。这将增加方法使用的内存。
`get_detailed_text()[source]#`()	get_json()[source]#
`get_summary_text()[source]#`()	predict(X, predict_model='GPU', threshold=0.5, algo='auto', convert_dtype=True, fil_sparse_format='auto') → CumlArray[source]#
predict_model字符串 (默认值 = ‘GPU’)'GPU' 表示使用 GPU 预测，否则为 'CPU'。	algo字符串 (默认值 = `'auto'`)用于分类的阈值。可选的，仅在 GPU 上执行预测操作时需要。
fil_sparse_format布尔型或字符串 (默认值 = `'auto'`)	ycuDF、CuPy 或 NumPy 对象，取决于 cuML 的输出类型配置，形状 =(n_samples, 1)
predict_proba(X, algo='auto', convert_dtype=True, fil_sparse_format='auto') → CumlArray[source]#	预测 X 的类别概率。此函数使用 GPU 实现的 predict。

get_attr_names

注意

score(X, y, threshold=0.5, algo='auto', predict_model='GPU', convert_dtype=True, fil_sparse_format='auto')[source]#

threshold浮点型threshold 用于分类。这是可选的，仅在 GPU 上执行预测操作时需要。

convert_dtype布尔型，默认值=True是否自动将输入数据转换为正确的 dtype

'GPU' 表示使用 GPU 进行预测，否则为 'CPU'。只有当模型在 float32 数据上训练且 X 为 float32 或 convert_dtype 设置为 True 时才能使用 'GPU'。此外，'GPU' 仅应用于分类问题。

accuracy浮点型模型的准确率 [0.0 - 1.0]

示例

>>> import cupy as cp
>>> from cuml.ensemble import RandomForestClassifier as cuRFC

>>> X = cp.random.normal(size=(10,4)).astype(cp.float32)
>>> y = cp.asarray([0,1]*5, dtype=cp.int32)

>>> cuml_model = cuRFC(max_features=1.0,
...                    n_bins=8,
...                    n_estimators=40)
>>> cuml_model.fit(X,y)
RandomForestClassifier()
>>> cuml_predict = cuml_model.predict(X)

>>> print("Predicted labels : ", cuml_predict)
Predicted labels :  [0. 1. 0. 1. 0. 1. 0. 1. 0. 1.]

class cuml.ensemble.RandomForestRegressor(*, split_criterion=2, accuracy_metric='r2', handle=None, verbose=False, output_type=None, **kwargs)#

fil_model

参数:

实现一个随机森林回归器模型，该模型在集成中拟合多个决策树。

请注意，树节点分裂的底层算法与 scikit-learn 中使用的算法不同。默认情况下，cuML 随机森林使用基于分位数的算法来确定分裂，而不是精确计数。您可以使用 n_bins 参数调整分位数的大小

split_criterion整型或字符串 (默认值 = 2 ('mse'))

0, 'gini', 1 和 'entropy' 对回归无效。

max_features整型、浮点型或字符串 (默认值 = 1.0)

如果类型为 int，则 max_features 是要使用的特征的绝对数量。

在 24.06 版本中更改: max_features 的默认值从 "auto" 更改为 1.0。

n_streams整型 (默认值 = 4 )用于构建森林的并行流数量

节点分裂所需的最小不纯度减少量

accuracy_metric字符串 (默认值 = ‘r2’)决定用于评估模型性能的指标。在 0.16 版本中，默认评分指标从均方误差更改为 r 平方。

对于 r 平方 : 'r2'

对于绝对误差中位数 : 'median_ae'

对于绝对误差平均值 : 'mean_ae'

对于均方误差 : 'mse'

convert_to_fil_model([output_class, algo, ...])

fit(X, y[, convert_dtype])

返回值:

对输入数据执行随机森林回归: predict(X[, predict_model, algo, ...])

score(X, y[, algo, convert_dtype, ...])

convert_to_treelite_model()[source]#

返回值:

基于 GPU 的推理仅支持 32 位 (float32) 数据类型。替代方法是使用基于 CPU 的推理处理 64 位 (float64) 数据类型，或者在 GPU 推理期间让默认的自动数据类型转换发生。

有关其他文档，请参阅 scikitlearn 的 RandomForestRegressor。: cpu_to_gpu()[source]#

fit(X, y, convert_dtype=True)[源代码]#

np.int32 类型的密集矩阵。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): np.int32 类型的密集矩阵。可接受的格式：符合 CUDA 数组接口的对象，例如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，该方法将自动把输入转换为 np.float32。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，fit 方法在必要时会将 y 转换为 int32 数据类型。这将增加方法使用的内存。

get_detailed_text()[源代码]#: 设置为 True 时，fit 方法在必要时会将 y 转换为 int32 dtype。这将增加方法使用的内存。

get_json()[源代码]#: get_json()[source]#

get_summary_text()[源代码]#: predict(X, predict_model='GPU', threshold=0.5, algo='auto', convert_dtype=True, fil_sparse_format='auto') → CumlArray[source]#

predict(X, predict_model='GPU', threshold=0.5, algo='auto', convert_dtype=True, fil_sparse_format='auto') → CumlArray[源代码]#

algo字符串 (默认值 = 'auto')用于分类的阈值。可选的，仅在 GPU 上执行预测操作时需要。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features)

密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。

predict_model字符串 (默认 = ‘GPU’)

‘GPU’ 表示使用 GPU 进行预测，否则使用 ‘CPU’。

algo字符串 (默认 = 'auto')

0, 'gini', 1 和 'entropy' 对回归无效。

max_features整型、浮点型或字符串 (默认值 = 1.0)

如果类型为 int，则 max_features 是要使用的特征的绝对数量。

在 24.06 版本中更改: max_features 的默认值从 "auto" 更改为 1.0。

n_streams整型 (默认值 = 4 )用于构建森林的并行流数量

节点分裂所需的最小不纯度减少量

accuracy_metric字符串 (默认值 = ‘r2’)决定用于评估模型性能的指标。在 0.16 版本中，默认评分指标从均方误差更改为 r 平方。

用于分类的阈值。可选，仅在使用 GPU 执行 predict 操作时需要。

convert_dtypebool, 可选 (默认 = True)

设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

fil_sparse_format布尔值或字符串 (默认 = 'auto')

对于绝对误差平均值 : 'mean_ae'

对于均方误差 : 'mse'

convert_to_fil_model([output_class, algo, ...])

fit(X, y[, convert_dtype])

返回值:

ycuDF、CuPy 或 NumPy 对象，取决于 cuML 的输出类型配置，形状为 (n_samples, 1)

predict_proba(X, algo='auto', convert_dtype=True, fil_sparse_format='auto') → CumlArray[源代码]#

预测 X 的类别概率。此函数使用 GPU 实现的 predict。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features)

split_criterion整型或字符串 (默认值 = 2 ('mse'))

0, 'gini', 1 和 'entropy' 对回归无效。

max_features整型、浮点型或字符串 (默认值 = 1.0)

如果类型为 int，则 max_features 是要使用的特征的绝对数量。

在 24.06 版本中更改: max_features 的默认值从 "auto" 更改为 1.0。

n_streams整型 (默认值 = 4 )用于构建森林的并行流数量

节点分裂所需的最小不纯度减少量

convert_dtypebool, 可选 (默认 = True)

设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

对于绝对误差中位数 : 'median_ae'

对于绝对误差平均值 : 'mean_ae'

对于均方误差 : 'mse'

convert_to_fil_model([output_class, algo, ...])

fit(X, y[, convert_dtype])

返回值:

ycuDF、CuPy 或 NumPy 对象，取决于 cuML 的输出类型配置，形状为 (n_samples, 1)

score(X, y, threshold=0.5, algo='auto', predict_model='GPU', convert_dtype=True, fil_sparse_format='auto')[源代码]#

预测 X 的类别概率。此函数使用 GPU 实现的 predict。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features)

y类数组 (设备或主机) 形状 = (n_samples, 1)

np.int32 类型的密集矩阵。可接受的格式：符合 CUDA 数组接口的对象，例如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。

split_criterion整型或字符串 (默认值 = 2 ('mse'))

0, 'gini', 1 和 'entropy' 对回归无效。

max_features整型、浮点型或字符串 (默认值 = 1.0)

如果类型为 int，则 max_features 是要使用的特征的绝对数量。

在 24.06 版本中更改: max_features 的默认值从 "auto" 更改为 1.0。

n_streams整型 (默认值 = 4 )用于构建森林的并行流数量

节点分裂所需的最小不纯度减少量

threshold浮点数

阈值用于分类。可选，仅在使用 GPU 执行 predict 操作时需要。

convert_dtype布尔值, 默认=True

是否自动将输入数据转换为正确的数据类型

predict_model字符串 (默认 = ‘GPU’)

‘GPU’ 表示使用 GPU 进行预测，否则使用 ‘CPU’。仅当模型使用 float32 数据训练且 X 为 float32 或 convert_dtype 设置为 True 时，才可以使用 ‘GPU’。此外，‘GPU’ 仅应用于分类问题。

对于绝对误差中位数 : 'median_ae'

对于绝对误差平均值 : 'mean_ae'

对于均方误差 : 'mse'

convert_to_fil_model([output_class, algo, ...])

fit(X, y[, convert_dtype])

返回值:

accuracy浮点数: 模型的准确率 [0.0 - 1.0]

类 cuml.ensemble.RandomForestRegressor(*, split_criterion=2, accuracy_metric='r2', handle=None, verbose=False, output_type=None, **kwargs)#

实现了一个随机森林回归器模型，该模型在一个集成中拟合多棵决策树。

注意

请注意，树节点分裂的基础算法与 scikit-learn 中使用的不同。默认情况下，cuML 随机森林使用基于分位数（quantile）的算法来确定分裂，而不是精确计数。您可以使用 n_bins 参数调整分位数的大小

注意

n_bins整型 (默认值 = 128)每个特征分裂算法使用的最大 bin 数量。对于大型问题，特别是输入数据高度偏斜的问题，增加 bin 数量可能会提高准确性。

参数:

n_streams整型 (默认值 = 4)用于构建森林的并行流数量。

min_samples_leaf整型或浮点型 (默认值 = 1)每个叶子节点中的最小样本（行）数量。

split_criterion整数或字符串 (默认 = 2 ('mse'))

如果为 float，则 min_samples_leaf 表示一个分数，ceil(min_samples_leaf * n_rows) 是每个叶子节点的最小样本数量。

min_samples_split整型或浮点型 (默认值 = 2)分裂内部节点所需的最小样本数量。

如果类型为 int，则 min_samples_split 表示最小数量。

如果类型为 float，则 min_samples_split 表示一个分数，max(2, ceil(min_samples_split * n_rows)) 是每个分裂的最小样本数量。

min_impurity_decrease浮点型 (默认值 = 0.0)节点分裂所需的最小不纯度减少量。

max_batch_size整型 (默认值 = 4096)在给定批次中可以处理的最大节点数量。

随机数生成器的种子。默认情况下未设置种子。目前不能完全保证结果完全相同。

0, 'gini', 1 和 'entropy' 对于回归无效。

从已训练的 cuML 随机森林模型创建 Forest Inference (FIL) 模型。

convert_to_treelite_model

将 cuML RF 模型转换为 Treelite 模型

cpu_to_gpu

将属性从 CPU 估计器转移到 GPU 估计器。

fit(X, y[, convert_dtype])

对输入数据执行随机森林分类

get_detailed_text

注意

获取随机森林模型的详细信息（文本形式）

get_json

将随机森林模型导出为 JSON 字符串

max_features整数, 浮点数, 或字符串 (默认 = 1.0)

获取随机森林模型的文本摘要

如果类型为 int，则 max_features 是要使用的特征的绝对数量。

预测 X 的标签。

predict_proba(X[, algo, convert_dtype, ...])

预测 X 的类别概率。

版本 24.06 中的更改：max_features 的默认值从 "auto" 更改为 1.0。

计算模型对 X 的准确率指标得分。

已知限制

n_streams整数 (默认 = 4 )

用于森林构建的并行流的数量

在训练多类别分类问题的模型时，使用深层树或 max_features=1.0 可以提供更好的性能。

有关其他文档，请参阅 scikitlearn 的 RandomForestClassifier。

convert_to_fil_model(output_class=True, threshold=0.5, algo='auto', fil_sparse_format='auto')[source]#

output_class布尔型 (默认值 = True)这是可选的，仅在 GPU 上执行预测操作时需要。如果为 true，则根据原始预测是否超过阈值返回 1 或 0。如果为 false，则仅返回原始预测。

algo字符串 (默认值 = ‘auto’)这是可选的，仅在 GPU 上执行预测操作时需要。

'naive' - 使用共享内存进行简单推理

'tree_reorg' - 类似于 naive，但树经过重新组织以更适合合并

'batch_tree_reorg' - 类似于 tree_reorg，但在每个线程块中预测多行

'auto' - 自动选择算法。目前，'batch_tree_reorg' 用于密集存储，而 'naive' 用于稀疏存储

节点分裂所需的最小不纯度下降

accuracy_metric字符串 (默认 = ‘r2’)

决定用于评估模型性能的指标。在 0.16 版本中，默认评分指标从均方误差更改为 r-squared。

r-squared 对应 : 'r2'

绝对误差中位数对应 : 'median_ae'

绝对误差均值对应 : 'mean_ae'

均方误差对应 : 'mse'

fil_sparse_format布尔型或字符串 (默认值 = auto)此变量用于选择将在 Forest Inference Library 中创建的森林类型。在使用 predict_model=’CPU’ 时不需要它。

'auto' - 自动选择存储类型（目前 auto 选择 True）

random_stateint (default = None)

False - 创建密集森林

handlecuml.Handle

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

方法

`convert_to_fil_model`([output_class, algo, ...])	fil_model
`可用于对随机森林模型执行推理的 Forest Inference 模型。`()	convert_to_treelite_model()[source]#
`tl_to_fil_model此模型的 Treelite 版本`()	cpu_to_gpu()[source]#
`fit`(X, y[, convert_dtype])	对输入数据执行随机森林回归
`设置为 True 时，该方法将自动将输入转换为 np.float32。`()	设置为 True 时，fit 方法在必要时会将 y 转换为 int32 dtype。这将增加方法使用的内存。
`get_detailed_text()[source]#`()	get_json()[source]#
`get_summary_text()[source]#`()	predict(X, predict_model='GPU', threshold=0.5, algo='auto', convert_dtype=True, fil_sparse_format='auto') → CumlArray[source]#
`predict`(X[, predict_model, algo, ...])	algo字符串 (默认值 = `'auto'`)用于分类的阈值。可选的，仅在 GPU 上执行预测操作时需要。
`score`(X, y[, algo, convert_dtype, ...])	预测 X 的类别概率。此函数使用 GPU 实现的 predict。

get_attr_names

注意

score(X, y, threshold=0.5, algo='auto', predict_model='GPU', convert_dtype=True, fil_sparse_format='auto')[source]#

threshold浮点型threshold 用于分类。这是可选的，仅在 GPU 上执行预测操作时需要。

基于 GPU 的推理仅支持 32 位 (float32) 数据类型。替代方案是使用基于 CPU 的推理处理 64 位 (float64) 数据类型，或允许在 GPU 推理期间进行默认的自动数据类型转换。

更多文档请参阅 scikit-learn 的 RandomForestRegressor。

示例

>>> import cupy as cp
>>> from cuml.ensemble import RandomForestRegressor as curfr
>>> X = cp.asarray([[0,10],[0,20],[0,30],[0,40]], dtype=cp.float32)
>>> y = cp.asarray([0.0,1.0,2.0,3.0], dtype=cp.float32)
>>> cuml_model = curfr(max_features=1.0, n_bins=128,
...                    min_samples_leaf=1,
...                    min_samples_split=2,
...                    n_estimators=40, accuracy_metric='r2')
>>> cuml_model.fit(X,y)
RandomForestRegressor()
>>> cuml_score = cuml_model.score(X,y)
>>> print("MSE score of cuml : ", cuml_score) 
MSE score of cuml :  0.9076250195503235

convert_to_fil_model(output_class=False, algo='auto', fil_sparse_format='auto')[源代码]#

fil_model

参数:

output_class布尔值 (默认 = False)

split_criterion整型或字符串 (默认值 = 2 ('mse'))

0, 'gini', 1 和 'entropy' 对回归无效。

max_features整型、浮点型或字符串 (默认值 = 1.0)

如果类型为 int，则 max_features 是要使用的特征的绝对数量。

在 24.06 版本中更改: max_features 的默认值从 "auto" 更改为 1.0。

n_streams整型 (默认值 = 4 )用于构建森林的并行流数量

节点分裂所需的最小不纯度减少量

fil_sparse_format布尔值或字符串 (默认 = ‘auto’)

对于绝对误差平均值 : 'mean_ae'

对于均方误差 : 'mse'

convert_to_fil_model([output_class, algo, ...])

fit(X, y[, convert_dtype])

返回值:

对输入数据执行随机森林回归: predict(X[, predict_model, algo, ...])

convert_to_treelite_model()[源代码]#

convert_to_treelite_model()[source]#

返回值:

基于 GPU 的推理仅支持 32 位 (float32) 数据类型。替代方法是使用基于 CPU 的推理处理 64 位 (float64) 数据类型，或者在 GPU 推理期间让默认的自动数据类型转换发生。

cpu_to_gpu()[源代码]#: cpu_to_gpu()[source]#

fit(X, y, convert_dtype=True)[源代码]#

对输入数据执行随机森林回归

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

get_detailed_text()[源代码]#: 设置为 True 时，fit 方法在必要时会将 y 转换为 int32 dtype。这将增加方法使用的内存。

get_json()[源代码]#: get_json()[source]#

get_summary_text()[源代码]#: predict(X, predict_model='GPU', threshold=0.5, algo='auto', convert_dtype=True, fil_sparse_format='auto') → CumlArray[source]#

predict(X, predict_model='GPU', algo='auto', convert_dtype=True, fil_sparse_format='auto') → CumlArray[源代码]#

algo字符串 (默认值 = 'auto')用于分类的阈值。可选的，仅在 GPU 上执行预测操作时需要。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features)

predict_model字符串 (默认 = ‘GPU’)

‘GPU’ 表示使用 GPU 进行预测，否则使用 ‘CPU’。

split_criterion整型或字符串 (默认值 = 2 ('mse'))

0, 'gini', 1 和 'entropy' 对回归无效。

max_features整型、浮点型或字符串 (默认值 = 1.0)

如果类型为 int，则 max_features 是要使用的特征的绝对数量。

在 24.06 版本中更改: max_features 的默认值从 "auto" 更改为 1.0。

n_streams整型 (默认值 = 4 )用于构建森林的并行流数量

节点分裂所需的最小不纯度减少量

convert_dtypebool, 可选 (默认 = True)

设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

对于绝对误差中位数 : 'median_ae'

对于绝对误差平均值 : 'mean_ae'

对于均方误差 : 'mse'

convert_to_fil_model([output_class, algo, ...])

fit(X, y[, convert_dtype])

返回值:

ycuDF、CuPy 或 NumPy 对象，取决于 cuML 的输出类型配置，形状为 (n_samples, 1)

score(X, y, algo='auto', convert_dtype=True, fil_sparse_format='auto', predict_model='GPU')[源代码]#

计算模型对于 X 的准确率指标得分。在 0.16 版本中，默认评分指标从均方误差更改为 r-squared。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features)

y类数组 (设备或主机) 形状 = (n_samples, 1)

split_criterion整型或字符串 (默认值 = 2 ('mse'))

0, 'gini', 1 和 'entropy' 对回归无效。

max_features整型、浮点型或字符串 (默认值 = 1.0)

如果类型为 int，则 max_features 是要使用的特征的绝对数量。

在 24.06 版本中更改: max_features 的默认值从 "auto" 更改为 1.0。

n_streams整型 (默认值 = 4 )用于构建森林的并行流数量

节点分裂所需的最小不纯度减少量

convert_dtype布尔值, 默认=True

是否自动将输入数据转换为正确的数据类型

predict_model字符串 (默认 = ‘GPU’)

‘GPU’ 表示使用 GPU 进行预测，否则使用 ‘CPU’。仅当模型使用 float32 数据训练且 X 为 float32 或 convert_dtype 设置为 True 时，才可以使用 GPU。

对于绝对误差中位数 : 'median_ae'

对于绝对误差平均值 : 'mean_ae'

对于均方误差 : 'mse'

convert_to_fil_model([output_class, algo, ...])

fit(X, y[, convert_dtype])

返回值:

mean_square_error浮点数或
median_abs_error浮点数或
mean_abs_error浮点数

森林推理#

类 cuml.ForestInference(*, treelite_model=None, handle=None, output_type=None, verbose=False, is_classifier=False, output_class=None, layout='depth_first', default_chunk_size=None, align_bytes=None, precision='single', device_id=0)[源代码]#

方法

`predict`(X, *[, preds, chunk_size, threshold])	对于分类模型，预测每一行的类别。
`predict_proba`(X, *[, preds, chunk_size])	预测 X 中每一行的类别概率。

apply(X, *, preds=None, chunk_size=None) → CumlArray[源代码]#

输出每棵树的叶子节点 ID。

参数:

X: 形状为行 X 特征的输入数据。这可以是 numpy 数组、cupy 数组、Pandas/cuDF Dataframe 或 cuML 接受的任何其他数组类型。FIL 针对 C-major 数组（例如 numpy/cupy 数组）进行了优化。数据类型与加载模型的精度（float/double）不匹配的输入将在推理前转换为正确的数据类型。如果此输入位于当前设备类型无法访问的内存位置（例如通过 using_device_type 上下文管理器设置），它将被复制到正确的位置。此复制操作将分配到模型 RAFT handle 的流池中所有可用的 CUDA 流。
preds: 如果不为 None，输出将原地写入到此数组中。因此，如果提供了此数组，它应该是一个形状为 n_rows * n_trees 的 C-major 数组。数据类型（float/double）应与模型的精度对应。如果为 None，将分配并返回一个具有正确形状和类型的新输出数组。
chunk_size整数: 推理算法一次迭代中同时处理的行数。在将可用线程分配给任务时，批次会进一步细分为此大小的“chunk”。chunk 大小的选择会对性能产生重大影响，但最佳选择取决于模型和硬件，并且难以事先预测。一般来说，较大的批次大小得益于较大的 chunk 大小，而较小的批次大小得益于较小的 chunk 大小。在 GPU 上，有效值是 1 到 32 之间的 2 的幂。在 CPU 上，有效值是任何 2 的幂，但超过 512 的 chunk 大小预计不会带来太多益处。

as_sklearn(deepcopy=False)[源代码]#

将当前的 GPU 加速估计器转换为 scikit-learn 估计器。

此方法导入并构建一个等效的 CPU 支持的 scikit-learn 模型，将所有必要的参数从 GPU 表示转移到 CPU 模型。转换后，返回的对象应是一个完全兼容的 scikit-learn 估计器，允许您在标准的 scikit-learn 管道和工作流中使用它。

参数:

deepcopy布尔值 (默认=False): 是否返回 cuML 模型内部 scikit-learn 估计器的深拷贝。cuML 模型内部有基于 CPU 的估计器，它们可能会被更新。如果您打算在使用此方法后并行使用 cuML 和 scikit-learn 估计器，建议将其设置为 True，以避免一个覆盖另一个的数据。

返回值:

sklearn.base.BaseEstimator: 一个与 scikit-learn 兼容的估计器实例，它反映了当前 GPU 加速估计器的训练状态。

属性 cpu_forest#: 加载到 CPU 可访问内存中的底层 FIL 森林模型

cpu_to_gpu()[源代码]#: cpu_to_gpu()[source]#

dispatch_func(func_name, gpu_func, *args, **kwargs)[源代码]#

此函数将根据全局配置分派训练和推理调用。它应该适用于所有与 scikit-learn 实现足够接近的估计器，因为它使用它在 host 上进行训练和推理。

参数:

func_name字符串: 要分派的函数的名称
gpu_func函数: 原始 cuML 函数
args参数: 调用时要传递给函数的参数
kwargs关键字参数: 调用时要传递给函数的关键字参数

属性 forest#: 加载到与当前全局 device_type 设置兼容的内存中的底层 FIL 森林模型

类方法 from_sklearn(model)[源代码]#

从 scikit-learn 估计器创建 GPU 加速估计器。

此类方法接受现有的 scikit-learn 估计器，并将其转换为相应的 GPU 支持的估计器。它导入任何所需的 CPU 模型定义，在内部存储给定的 scikit-learn 模型，然后将模型参数和状态转移到 GPU 上。

参数:

modelsklearn.base.BaseEstimator: 一个已拟合的 scikit-learn 估计器，用于创建 GPU 加速版本。

返回值:

cls: 一个新的 GPU 加速估计器类实例，它反映了输入 scikit-learn 估计器的状态。

注意

估计器的 output_type 默认设置为“numpy”
，因为这些无法从训练参数中推断出来。如果需要不同的设置，请使用 cuML 的 output_type 配置工具。

get_params(deep=True)[源代码]#

获取此估计器的参数。

参数:

deepbool, default=True: 如果为 True，将返回此估计器和包含的子对象（如果是估计器）的参数。

返回值:

paramsdict: 参数名称映射到其值。

属性 gpu_forest#: 加载到 GPU 可访问内存中的底层 FIL 森林模型

gpu_to_cpu()[源代码]#: 将属性从 GPU 估计器转移到 CPU 估计器。

类方法 load(path, *, output_class=False, threshold=None, algo=None, storage_type=None, blocks_per_sm=None, threads_per_tree=None, n_items=None, compute_shape_str=None, precision='single', model_type=None, output_type=None, verbose=False, default_chunk_size=None, align_bytes=None, layout='depth_first', device_id=0, handle=None)[源代码]#

从序列化模型文件加载模型到 FIL 中。

参数:

path字符串: 序列化模型文件的路径。这可以是 XGBoost 二进制文件或 JSON 文件、LightGBM 文本文件或 Treelite 检查点文件。如果未传递 model_type 参数，将尝试根据文件扩展名加载文件。
output_class布尔值, 默认=False: 分类模型为 True，回归模型为 False
threshold浮点数: 对于二分类器，高于此值的输出将被视为阳性检测。
algo: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。请参阅 layout 参数，它具有类似的功能。
storage_type: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。
blocks_per_sm: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。
threads_per_tree整数: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。请参阅 predict 方法的 chunk_size 参数以获得等效功能。
n_items: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。
compute_shape_str: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。
precision{‘single’, ‘double’, None}, 默认=’single’: 使用给定的浮点精度评估模型。如果为 None，则使用模型的原生精度。请注意，单精度执行比双精度执行快得多，因此双精度仅推荐用于双精度训练的模型，以及 FIL 结果与原始训练框架结果之间的精确一致性至关重要的情况。
model_type{‘xgboost_ubj’, ‘xgboost_json’, ‘xgboost’, ‘lightgbm’,: ‘treelite_checkpoint’, None }, 默认=None 模型文件的序列化格式。如果为 None，将根据文件扩展名进行尽力猜测。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
default_chunk_size整数或 None, 默认=None: 如果设置，未指定 chunk 大小的 predict 调用将使用此默认值。
align_bytes整数或 None, 默认=None: 用空节点填充每棵树，直到其内存中的大小是给定值的倍数。如果为 None，GPU 使用 0，CPU 使用 64。
layout{‘breadth_first’, ‘depth_first’, ‘layered’}, 默认=’depth_first’: 在推理过程中用于森林模型节点的内存中布局。此参数纯粹用于运行时优化。对于性能关键型应用程序，建议使用实际的批次大小测试可用的布局以确定最佳值。
device_id整数, 默认=0: 对于 GPU 执行，用于加载和执行此模型的设备 ID。对于 CPU 执行，此值当前被忽略。
handlepylibraft.common.handle 或 None: 对于 GPU 执行，包含加载和推理期间使用的流或流池的 RAFT handle。

类方法 load_from_sklearn(skl_model, *, output_class=False, threshold=None, algo=None, storage_type=None, blocks_per_sm=None, threads_per_tree=None, n_items=None, compute_shape_str=None, precision='single', model_type=None, output_type=None, verbose=False, default_chunk_size=None, align_bytes=None, layout='depth_first', device_id=0, handle=None)[源代码]#

加载 Scikit-Learn 森林模型到 FIL 中

参数:

skl_model: 要加载的 Scikit-Learn 森林模型。
output_class布尔值, 默认=False: 分类模型为 True，回归模型为 False
threshold浮点数: 对于二分类器，高于此值的输出将被视为阳性检测。
algo: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。请参阅 layout 参数，它具有类似的功能。
storage_type: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。
blocks_per_sm: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。
threads_per_tree整数: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。请参阅 chunk_size 参数，它具有等效功能。如果为此参数传递了值，它将暂时用作 chunk_size。
n_items: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。
compute_shape_str: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。
precision{‘single’, ‘double’, None}, 默认=’single’: 使用给定的浮点精度评估模型。如果为 None，则使用模型的原生精度。请注意，单精度执行比双精度执行快得多，因此双精度仅推荐用于双精度训练的模型，以及 FIL 结果与原始训练框架结果之间的精确一致性至关重要的情况。
model_type{‘xgboost’, ‘xgboost_json’, ‘lightgbm’,: ‘treelite_checkpoint’, None }, 默认=None 模型文件的序列化格式。如果为 None，将根据文件扩展名进行尽力猜测。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
default_chunk_size整数或 None, 默认=None: 如果设置，未指定 chunk 大小的 predict 调用将使用此默认值。
align_bytes整数或 None, 默认=None: 用空节点填充每棵树，直到其内存中的大小是给定值的倍数。如果为 None，GPU 使用 0，CPU 使用 64。
layout{‘breadth_first’, ‘depth_first’, ‘layered’}, 默认=’depth_first’: 在推理过程中用于森林模型节点的内存中布局。此参数纯粹用于运行时优化。对于性能关键型应用程序，建议使用实际的批次大小测试可用的布局以确定最佳值。
mem_type{‘device’, ‘host’, None}, 默认=’single’: 用于初始加载模型的内存类型。如果为 None，将使用当前的全局内存类型设置。如果模型使用一种内存类型加载，但后来请求使用不兼容的设备（例如设备内存和 CPU 执行）进行推理，模型将在那时惰性加载到正确的位置。一般来说，不应直接设置此参数（而是依赖于 using_device_type 上下文管理器），但对于某些超参数优化管道来说，它可能是一个有用的便利功能。
device_id整数, 默认=0: 对于 GPU 执行，用于加载和执行此模型的设备 ID。对于 CPU 执行，此值当前被忽略。
handlepylibraft.common.handle 或 None: 对于 GPU 执行，包含加载和推理期间使用的流或流池的 RAFT handle。

类方法 load_from_treelite_model(tl_model, *, output_class=False, threshold=None, algo=None, storage_type=None, blocks_per_sm=None, threads_per_tree=None, n_items=None, compute_shape_str=None, precision='single', model_type=None, output_type=None, verbose=False, default_chunk_size=None, align_bytes=None, layout='depth_first', device_id=0, handle=None)[源代码]#

加载 Treelite 模型到 FIL 中

参数:

tl_modeltreelite.model: 要加载的 Treelite 模型。
output_class布尔值, 默认=False: 分类模型为 True，回归模型为 False
threshold浮点数: 对于二分类器，高于此值的输出将被视为阳性检测。
algo: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。请参阅 layout 参数，它具有类似的功能。
storage_type: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。
blocks_per_sm: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。
threads_per_tree整数: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。请参阅 chunk_size 参数，它具有等效功能。如果为此参数传递了值，它将暂时用作 chunk_size。
n_items: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。
compute_shape_str: 此参数已弃用。目前保留它是为了与现有 FIL 兼容。
precision{‘single’, ‘double’, None}, 默认=’single’: 使用给定的浮点精度评估模型。如果为 None，则使用模型的原生精度。请注意，单精度执行比双精度执行快得多，因此双精度仅推荐用于双精度训练的模型，以及 FIL 结果与原始训练框架结果之间的精确一致性至关重要的情况。
model_type{‘xgboost’, ‘xgboost_json’, ‘lightgbm’,: ‘treelite_checkpoint’, None }, 默认=None 模型文件的序列化格式。如果为 None，将根据文件扩展名进行尽力猜测。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
default_chunk_size整数或 None, 默认=None: 如果设置，未指定 chunk 大小的 predict 调用将使用此默认值。
align_bytes整数或 None, 默认=None: 用空节点填充每棵树，直到其内存中的大小是给定值的倍数。如果为 None，GPU 使用 0，CPU 使用 64。
layout{‘breadth_first’, ‘depth_first’, ‘layered’}, 默认=’depth_first’: 在推理过程中用于森林模型节点的内存中布局。此参数纯粹用于运行时优化。对于性能关键型应用程序，建议使用实际的批次大小测试可用的布局以确定最佳值。
mem_type{‘device’, ‘host’, None}, 默认=’single’: 用于初始加载模型的内存类型。如果为 None，将使用当前的全局内存类型设置。如果模型使用一种内存类型加载，但后来请求使用不兼容的设备（例如设备内存和 CPU 执行）进行推理，模型将在那时惰性加载到正确的位置。一般来说，不应直接设置此参数（而是依赖于 using_device_type 上下文管理器），但对于某些超参数优化管道来说，它可能是一个有用的便利功能。
device_id整数, 默认=0: 对于 GPU 执行，用于加载和执行此模型的设备 ID。对于 CPU 执行，此值当前被忽略。
handlepylibraft.common.handle 或 None: 对于 GPU 执行，包含加载和推理期间使用的流或流池的 RAFT handle。

optimize(*, data=None, batch_size=1024, unique_batches=10, timeout=0.2, predict_method='predict', max_chunk_size=None, seed=0)[源代码]#

找到此模型的最佳布局和 chunk 大小

layout 和 chunk 大小的最优值取决于模型、批次大小和可用的硬件。为了获得最实际的性能分布，可以提供示例数据。如果未提供，将根据指示的批次大小生成随机数据。找到最佳布局后，如有必要，将重新加载模型。如果没有向 predict 调用传递 chunk 大小，则将使用找到的最优 chunk 大小作为默认值。

参数:

data: 示例数据，形状为 unique_batches x batch size x features 或 batch_size x features，或为 None。如果为 None，则代わりに生成随机数据。
batch_size整数: 如果未提供示例数据，将使用每批次具有这么多行的随机数据。
unique_batches整数: 如果使用随机数据，要生成的唯一批次数。增加此数量会降低最优配置因单个具有异常性能特征的批次而倾斜的可能性。
timeout浮点数: 优化目标时长（秒）。优化循环将按 1, 2, 5, 10, 20, 50, … 的序列重复运行多次，直到所用时间至少达到给定值。请注意，对于非常大的批次大小和大型模型，总耗时可能会超过此超时时间；它是一个软性目标。将超时设置为零将恰好运行指定的唯一批次数一次。默认为 0.2 秒。
predict_method字符串: 如果需要，可以在预测方法变体（例如 “predict_per_tree”）之一上进行优化，而不是使用默认的 predict 方法。要实现此目的，请在此处传递方法的名称。
max_chunk_size整数或 None: 优化期间探索的最大 chunk 大小。如果未设置，将根据当前设备类型选择一个值。将其设置为较低值将减少优化搜索时间，但可能不会获得最优性能。
seed整数: 如果未提供示例数据，用于生成随机数据的随机种子。

predict(X, *, preds=None, chunk_size=None, threshold=None) → CumlArray[源代码]#

对于分类模型，预测每一行的类别。对于回归模型，预测每一行的输出。

参数:

X: 形状为行 X 特征的输入数据。这可以是 numpy 数组、cupy 数组、Pandas/cuDF Dataframe 或 cuML 接受的任何其他数组类型。FIL 针对 C-major 数组（例如 numpy/cupy 数组）进行了优化。数据类型与加载模型的精度（float/double）不匹配的输入将在推理前转换为正确的数据类型。如果此输入位于当前设备类型无法访问的内存位置（例如通过 using_device_type 上下文管理器设置），它将被复制到正确的位置。此复制操作将分配到模型 RAFT handle 的流池中所有可用的 CUDA 流。
preds: 如果不为 None，输出将原地写入此数组。因此，如果给出，这应该是一个形状为 Rows x 1 的 C-major 数组，数据类型（float/double）对应于模型的精度。对于回归器，原地预测提供性能和内存双重益处。对于分类器，原地预测不提供性能或内存益处。如果为 None，将分配并返回一个具有正确形状和类型的新输出数组。
chunk_size整数: 推理算法一次迭代中同时处理的行数。在将可用线程分配给任务时，批次会进一步细分为此大小的“chunk”。chunk 大小的选择会对性能产生重大影响，但最佳选择取决于模型和硬件，并且难以事先预测。一般来说，较大的批次大小得益于较大的 chunk 大小，而较小的批次大小得益于较小的 chunk 大小。在 GPU 上，有效值是 1 到 32 之间的 2 的幂。在 CPU 上，有效值是任何 2 的幂，但超过 512 的 chunk 大小预计不会带来太多益处。
threshold浮点数: 对于二分类器，高于此阈值的输出概率将被视为阳性检测。如果为 None，二分类器将使用 0.5 的阈值。对于多分类器，无论阈值如何，都选择概率最高的类别。

predict_per_tree(X, *, preds=None, chunk_size=None) → CumlArray[源代码]#

输出每棵树的预测。此函数计算每棵树的一个或多个 margin scores。

参数:

X: 形状为行 X 特征的输入数据。这可以是 numpy 数组、cupy 数组、Pandas/cuDF Dataframe 或 cuML 接受的任何其他数组类型。FIL 针对 C-major 数组（例如 numpy/cupy 数组）进行了优化。数据类型与加载模型的精度（float/double）不匹配的输入将在推理前转换为正确的数据类型。如果此输入位于当前设备类型无法访问的内存位置（例如通过 using_device_type 上下文管理器设置），它将被复制到正确的位置。此复制操作将分配到模型 RAFT handle 的流池中所有可用的 CUDA 流。
preds: 如果不为 None，输出将原地写入此数组。因此，如果给出，这应该是一个形状为 n_rows * n_trees * n_outputs (如果使用向量叶子) 或形状为 n_rows * n_trees (如果使用标量叶子) 的 C-major 数组。数据类型（float/double）应与模型的精度对应。如果为 None，将分配并返回一个具有正确形状和类型的新输出数组。
chunk_size整数: 推理算法一次迭代中同时处理的行数。在将可用线程分配给任务时，批次会进一步细分为此大小的“chunk”。chunk 大小的选择会对性能产生重大影响，但最佳选择取决于模型和硬件，并且难以事先预测。一般来说，较大的批次大小得益于较大的 chunk 大小，而较小的批次大小得益于较小的 chunk 大小。在 GPU 上，有效值是 1 到 32 之间的 2 的幂。在 CPU 上，有效值是任何 2 的幂，但超过 512 的 chunk 大小预计不会带来太多益处。

predict_proba(X, *, preds=None, chunk_size=None) → CumlArray[源代码]#

预测 X 中每一行的类别概率。

参数:

X: 形状为行 X 特征的输入数据。这可以是 numpy 数组、cupy 数组、Pandas/cuDF Dataframe 或 cuML 接受的任何其他数组类型。FIL 针对 C-major 数组（例如 numpy/cupy 数组）进行了优化。数据类型与加载模型的精度（float/double）不匹配的输入将在推理前转换为正确的数据类型。如果此输入位于当前设备类型无法访问的内存位置（例如通过 using_device_type 上下文管理器设置），它将被复制到正确的位置。此复制操作将分配到模型 RAFT handle 的流池中所有可用的 CUDA 流。
preds: 如果不为 None，输出将原地写入此数组。因此，如果给出，这应该是一个形状为 Rows x Classes 的 C-major 数组，数据类型（float/double）对应于模型的精度。如果为 None，将分配并返回一个具有正确形状和类型的新输出数组。
chunk_size整数: 推理算法一次迭代中同时处理的行数。在将可用线程分配给任务时，批次会进一步细分为此大小的“chunk”。chunk 大小的选择会对性能产生重大影响，但最佳选择取决于模型和硬件，并且难以事先预测。一般来说，较大的批次大小得益于较大的 chunk 大小，而较小的批次大小得益于较小的 chunk 大小。在 GPU 上，有效值是 1 到 32 之间的 2 的幂。在 CPU 上，有效值是任何 2 的幂，但超过 512 的 chunk 大小预计不会带来太多益处。

set_params(**params)[源代码]#

为该估计器设置参数。

参数:

**params字典: 估计器参数

返回值:

self估计器实例: 估计器实例

坐标下降#

class cuml.CD(*, loss='squared_loss', alpha=0.0001, l1_ratio=0.15, fit_intercept=True, normalize=False, max_iter=1000, tol=0.001, shuffle=True, handle=None, output_type=None, verbose=False)#

坐标下降 (CD) 是一种非常常见的优化算法，它沿坐标方向最小化以找到函数的最小值。

cuML 的 CD 算法接受 numpy 矩阵或 cuDF DataFrame 作为输入数据集。CD 算法目前适用于线性回归以及 ridge、lasso 和 elastic-net 惩罚项。

参数:

损失 (loss)‘squared_loss’: 目前只支持 ‘squared_loss’。‘squared_loss’ 在预测步骤中使用线性回归。
alpha: 浮点型 (默认值 = 0.0001): 决定正则化程度的常数值。‘alpha = 0’ 等同于普通最小二乘法，由 LinearRegression 对象求解。
l1_ratio: 浮点型 (默认值 = 0.15): ElasticNet 混合参数，范围为 0 <= l1_ratio <= 1。当 l1_ratio = 0 时，惩罚是 L2 惩罚。当 l1_ratio = 1 时，惩罚是 L1 惩罚。当 0 < l1_ratio < 1 时，惩罚是 L1 和 L2 的组合。
fit_intercept布尔值 (默认值 = True): 如果为 True，则模型会尝试纠正 y 的全局均值。如果为 False，则模型期望您已对数据进行了中心化。
normalize布尔值 (默认值 = False): 是否对数据进行归一化。
max_iter整数 (默认值 = 1000): 模型在训练期间应遍历整个数据集的次数
tol浮点数 (默认值 = 1e-3): 优化的容差：如果更新小于 tol，则求解器停止。
shuffle布尔值 (默认值 = True): 如果设置为 ‘True’，则每次迭代会更新一个随机系数，而不是默认按顺序遍历特征。这（设置为 ‘True’）通常会显著加快收敛速度，特别是当 tol 高于 1e-4 时。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

属性:

如果为 True，则森林中的每棵树都基于有放回的自助样本构建。

方法

`fit`(X, y[, convert_dtype, sample_weight])	使用 X 和 y 拟合模型。
`predict`(X[, convert_dtype])	预测 X 的 y。

示例

>>> import cupy as cp
>>> import cudf
>>> from cuml.solvers import CD as cumlCD

>>> cd = cumlCD(alpha=0.0)

>>> X = cudf.DataFrame()
>>> X['col1'] = cp.array([1,1,2,2], dtype=cp.float32)
>>> X['col2'] = cp.array([1,2,2,3], dtype=cp.float32)

>>> y = cudf.Series(cp.array([6.0, 8.0, 9.0, 11.0], dtype=cp.float32))

>>> cd.fit(X,y)
CD()
>>> print(cd.coef_) 
0 1.001...
1 1.998...
dtype: float32
>>> print(cd.intercept_) 
3.00...
>>> X_new = cudf.DataFrame()
>>> X_new['col1'] = cp.array([3,2], dtype=cp.float32)
>>> X_new['col2'] = cp.array([5,5], dtype=cp.float32)

>>> preds = cd.predict(X_new)
>>> print(preds) 
0 15.997...
1 14.995...
dtype: float32

fit(X, y, convert_dtype=True, sample_weight=None) → CD[source]#

使用 X 和 y 拟合模型。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。
sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。

predict(X, convert_dtype=True) → CumlArray[source]#

预测 X 的 y。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

预测值

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

拟牛顿法 (Quasi-Newton)#

class cuml.QN(*, loss='sigmoid', fit_intercept=True, l1_strength=0.0, l2_strength=0.0, max_iter=1000, tol=0.0001, delta=None, linesearch_max_iter=50, lbfgs_memory=5, verbose=False, handle=None, output_type=None, warm_start=False, penalty_normalized=True)#

拟牛顿法用于寻找函数的零点、局部最大值和最小值，本类使用它来优化成本函数。

cuML 的 QN 类内部实现了两种算法，执行哪种算法取决于以下规则

如果有 l1 正则化，则使用 Orthant-Wise Limited Memory Quasi-Newton (OWL-QN)

否则使用 Limited Memory BFGS (L-BFGS)。

cuML 的 QN 类可以接受类数组对象，既可以是主机端的 NumPy 数组，也可以是设备端（Numba 或 __cuda_array_interface__ 兼容）的数组。

参数:

loss: ‘sigmoid’, ‘softmax’, ‘l1’, ‘l2’, ‘svc_l1’, ‘svc_l2’, ‘svr_l1’, ‘svr_l2’ (默认值 = ‘sigmoid’).

‘sigmoid’ 损失用于单类别逻辑回归；‘softmax’ 损失用于多类别逻辑回归；‘l1’/’l2’ 损失用于回归。

fit_intercept: 布尔型 (默认值 = True)

如果为 True，则模型会尝试纠正 y 的全局均值。如果为 False，则模型期望您已对数据进行了中心化。

l1_strength: 浮点型 (默认值 = 0.0)

L1 正则化强度（如果非零，将运行 OWL-QN，否则运行 L-BFGS）。使用 penalty_normalized 控制求解器是否将其除以样本大小。

l2_strength: 浮点型 (默认值 = 0.0)

L2 正则化强度。使用 penalty_normalized 控制求解器是否将其除以样本大小。

max_iter: 整型 (默认值 = 1000)

solver 收敛所需的最大迭代次数。

tol: 浮点型 (默认值 = 1e-4)

如果满足以下条件，训练过程将停止

norm(current_loss_grad) <= tol * max(current_loss, tol).

这与 scipy.optimize.minimize(method=’L-BFGS-B’) 中由 gtol 控制的停止条件略有不同

norm(current_loss_projected_grad) <= gtol.

注意，sklearn.LogisticRegression() 使用输入数据的 softmax/logistic 损失总和，而 cuML 使用平均值。因此，Scikit-learn 的损失通常是 cuML 的 sample_size 倍。为了弥补差异，您可以将 tol 除以样本大小；这将确保 cuML 求解器不会比 Scikit-learn 求解器更早停止。

delta: 可选[浮点型] (默认值 = None)

如果满足以下条件，训练过程将停止

abs(current_loss - previous_loss) <= delta * max(current_loss, tol).

当为 None 时，它被设置为 tol * 0.01；当为 0 时，此检查被禁用。给定当前步 k，这里的参数 previous_loss 是步 k - p 处的损失，其中 p 是内部设置的小正整数。

注意，此参数对应于 scipy.optimize.minimize(method=’L-BFGS-B’) 中的 ftol，后者默认设置为极小的 2.2e-9，并且未在 sklearn.LogisticRegression() 中暴露。此条件旨在保护求解器免于进行极小的线搜索步长或锯齿形前进。您可以选择设置 delta = 0 以确保 cuML 求解器不会比 Scikit-learn 求解器更早停止。

linesearch_max_iter: 整型 (默认值 = 50)

算法每次外迭代的最大线搜索迭代次数。

lbfgs_memory: 整型 (默认值 = 5)

lbfgs 逆 Hessian 近似的秩。方法将使用 O(lbfgs_memory * D) 的内存。

handlecuml.Handle

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

warm_start布尔型, 默认值=False

设置为 True 时，重用上次调用 fit 的解作为初始化，否则清除之前的解。

penalty_normalized布尔型, 默认值=True

设置为 True 时，l1 和 l2 参数将被样本大小除。此标志可用于实现与其他实现（如 sklearn）兼容的行为。

属性:

coef_数组, 形状 (n_classes, n_features): 线性回归模型的估计系数。注意：如果 fit_intercept = True，形状为 (n_classes, n_features + 1)。
intercept_数组 (n_classes, 1): 截距项。如果 fit_intercept 为 False，则为 0。

方法

`fit`(X, y[, sample_weight, convert_dtype])	使用 X 和 y 拟合模型。
`get_num_classes`(_num_classes_dim)	从系数中的类别维度检索类别数量。
`predict`(X[, convert_dtype])	预测 X 的 y。

score

注意

本类包含两种流行拟牛顿法的实现

有限内存 Broyden Fletcher Goldfarb Shanno (L-BFGS) [Nocedal, Wright - 数值优化 (1999)]

象限感知有限内存拟牛顿法 (OWL-QN) [Andrew, Gao - ICML 2007]

示例

>>> import cudf
>>> import cupy as cp

>>> # Both import methods supported
>>> # from cuml import QN
>>> from cuml.solvers import QN

>>> X = cudf.DataFrame()
>>> X['col1'] = cp.array([1,1,2,2], dtype=cp.float32)
>>> X['col2'] = cp.array([1,2,2,3], dtype=cp.float32)
>>> y = cudf.Series(cp.array([0.0, 0.0, 1.0, 1.0], dtype=cp.float32) )

>>> solver = QN()
>>> solver.fit(X,y)
QN()

>>> # Note: for now, the coefficients also include the intercept in the
>>> # last position if fit_intercept=True
>>> print(solver.coef_) 
0   37.371...
1   0.949...
dtype: float32
>>> print(solver.intercept_) 
0   -57.738...
>>> X_new = cudf.DataFrame()
>>> X_new['col1'] = cp.array([1,5], dtype=cp.float32)
>>> X_new['col2'] = cp.array([2,5], dtype=cp.float32)
>>> preds = solver.predict(X_new)
>>> print(preds)
0    0.0
1    1.0
dtype: float32

fit(X, y, sample_weight=None, convert_dtype=True) → QN[source]#

使用 X 和 y 拟合模型。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 包含浮点数或双精度数的密集或稀疏矩阵。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

get_num_classes(_num_classes_dim)[source]#: 从系数中的类别维度检索类别数量。

predict(X, convert_dtype=True) → CumlArray[source]#

预测 X 的 y。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 包含浮点数或双精度数的密集或稀疏矩阵。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

预测值

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

支持向量机 (Support Vector Machines)#

class cuml.svm.SVR(Epsilon Support Vector Regression)#

构建用于训练和预测的 SVC 分类器。

参数:

handlecuml.Handle

C浮点数 (默认值 = 1.0)

惩罚参数 C

核函数 (kernel)字符串 (默认值=’rbf’)

指定核函数。可选选项：‘linear’、‘poly’、‘rbf’、‘sigmoid’。目前不支持预计算的核函数。

degree整型 (默认值=3)

多项式核函数的次数。

gamma浮点型或字符串 (默认值 = ‘scale’)

用于 rbf、poly 和 sigmoid 核函数的系数。您可以指定数值，或使用以下选项之一

‘auto’：gamma 将设置为 1 / n_features
‘scale’：gamma 将设置为 1 / (n_features * X.var())

coef0浮点型 (默认值 = 0.0)

核函数中的独立项，仅对 poly 和 sigmoid 有意义

tol浮点数 (默认值 = 1e-3)

停止准则的容差。

epsilon: 浮点型 (默认值 = 0.1)

epsilon-SVR 模型的 epsilon 参数。对于在目标值周围的 epsilon-tube 内预测的点，没有相关的惩罚。

cache_size浮点型 (默认值 = 1024.0)

训练期间核缓存的大小（以 MiB 为单位）。增加它可以提高训练时间，但会消耗更多内存。训练后核缓存会被释放。在预测期间，我们还需要一个临时空间来存储核矩阵元素（如果 n_support 很大，这可能会很大）。cache_size 变量也为预测缓冲区设置了上限。

max_iter整型 (默认值 = -1)

限制求解器外迭代的次数。如果为 -1（默认值），则 max_iter=100*n_samples

nochange_steps整型 (默认值 = 1000)

我们监控外迭代期间停止准则的变化程度。如果连续 nochange_steps 次迭代变化不大（变化小于 1e-3*tol），则停止训练。

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

属性:

n_support_整型: 支持向量的总数。注意：将来这会改变，以表示每个类别的支持向量数量（如在 Sklearn 中，参见 Issue #956）
support_整型, 形状 = [n_support]: 支持向量索引的设备数组
support_vectors_浮点型, 形状 [n_support, n_cols]: 支持向量的设备数组
dual_coef_浮点型, 形状 = [1, n_support]: 支持向量系数的设备数组
intercept_整型: 决策函数中的常数项
fit_status_整型: 如果 SVM 正确拟合，则为 0
coef_浮点型, 形状 [1, n_cols]: 仅在线性核函数可用。它是超平面的法向量。coef_ = sum_k=1..n_support dual_coef_[k] * support_vectors[k,:]

方法

`tl_to_fil_model此模型的 Treelite 版本`()	cpu_to_gpu()[source]#
`fit`(X, y[, sample_weight, convert_dtype])	使用 X 和 y 拟合模型。
`predict`(X[, convert_dtype])	预测 X 的值。

get_attr_names

注意

有关更多文档，请参阅 Scikit-learn 的 SVR。

求解器使用 SMO 方法来拟合回归器。我们使用 SMO 算法的优化分层分解 (Optimized Hierarchical Decomposition) [1] 变体，类似于 [2]

参考

[1]

J. Vanek 等人. 面向 GPU 架构优化的支持向量机训练分层分解算法, IEEE Transactions on Parallel and Distributed Systems, 卷 28, 期 12, 3330, (2017)

[2]

Z. Wen 等人. ThunderSVM: 一个在 GPU 和 CPU 上快速的 SVM 库, Journal of Machine Learning Research, 19, 1-5 (2018)

示例

>>> import cupy as cp
>>> from cuml.svm import SVR
>>> X = cp.array([[1], [2], [3], [4], [5]], dtype=cp.float32)
>>> y = cp.array([1.1, 4, 5, 3.9, 1.], dtype = cp.float32)
>>> reg = SVR(kernel='rbf', gamma='scale', C=10, epsilon=0.1)
>>> reg.fit(X, y)
SVR()
>>> print("Predicted values:", reg.predict(X)) 
Predicted values: [1.200474 3.8999617 5.100488 3.7995374 1.0995375]

cpu_to_gpu()[source]#: cpu_to_gpu()[source]#

fit(X, y, sample_weight=None, convert_dtype=True) → SVR[source]#

使用 X 和 y 拟合模型。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

predict(X, convert_dtype=True) → CumlArray[source]#

预测 X 的值。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

预测值

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

class cuml.svm.SVC(C-Support Vector Classification)#

构建用于训练和预测的 SVC 分类器。

参数:

handlecuml.Handle

C浮点数 (默认值 = 1.0)

惩罚参数 C

核函数 (kernel)字符串 (默认值=’rbf’)

指定核函数。可选选项：‘linear’、‘poly’、‘rbf’、‘sigmoid’。目前不支持预计算的核函数。

degree整型 (默认值=3)

多项式核函数的次数。

gamma浮点型或字符串 (默认值 = ‘scale’)

用于 rbf、poly 和 sigmoid 核函数的系数。您可以指定数值，或使用以下选项之一

‘auto’：gamma 将设置为 1 / n_features
‘scale’：gamma 将设置为 1 / (n_features * X.var())

coef0浮点型 (默认值 = 0.0)

核函数中的独立项，仅对 poly 和 sigmoid 有意义

tol浮点数 (默认值 = 1e-3)

停止准则的容差。

cache_size浮点型 (默认值 = 1024.0)

class_weight字典或字符串 (默认值=None)

用于修改类别 i 的参数 C 的权重，修改后为 class_weight[i]*C。也接受字符串 ‘balanced’，在这种情况下 class_weight[i] = n_samples / (n_classes * n_samples_of_class[i])

max_iter整型 (默认值 = -1)

限制求解器外迭代的次数。如果为 -1（默认值），则 max_iter=100*n_samples

decision_function_shape字符串 (‘ovo’ 或 ‘ovr’, 默认值 ‘ovo’)

多类别分类策略。'ovo' 使用 OneVsOneClassifier，而 'ovr' 选择 OneVsRestClassifier

25.02 版本新增: 参数 multiclass_strategy 已重命名为 decision_function_shape。

nochange_steps整型 (默认值 = 1000)

我们监控外迭代期间停止准则的变化程度。如果连续 nochange_steps 次迭代变化不大（变化小于 1e-3*tol），则停止训练。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

probability: 布尔型 (默认值 = False)

启用或禁用概率估计。

random_state: 整型 (默认值 = None)

随机数生成器的种子（仅当 probability = True 时使用）。当前此参数未使用，如果用户提供，将打印警告。

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

multiclass_strategy

多类别分类策略。'ovo' 使用 OneVsOneClassifier，而 'ovr' 选择 OneVsRestClassifier

25.02 版本变更: 重命名为 decision_function_shape。将在后续版本中移除。

属性:

n_support_整型: 支持向量的总数。注意：将来这会改变，以表示每个类别的支持向量数量（如在 Sklearn 中，参见 rapidsai/cuml#956 ）
support_整型, 形状 = (n_support): 支持向量索引的设备数组
support_vectors_浮点型, 形状 (n_support, n_cols): 支持向量的设备数组
dual_coef_浮点型, 形状 = (1, n_support): 支持向量系数的设备数组
intercept_浮点型: 决策函数中的常数项
fit_status_整型: 如果 SVM 正确拟合，则为 0
coef_浮点型, 形状 (1, n_cols): 仅在线性核函数可用。它是超平面的法向量。
classes_形状 (n_classes_,): 类别标签数组
decision_function(X): 类别数量

方法

`tl_to_fil_model此模型的 Treelite 版本`()	cpu_to_gpu()[source]#
`decision_function`(X)	计算 X 的决策函数值。
`fit`(X, y[, sample_weight, convert_dtype])	使用 X 和 y 拟合模型。
`gpu_to_cpu`()	将属性从 GPU 估计器转移到 CPU 估计器。
`predict`(X[, convert_dtype])	预测 X 的类别标签。返回的 y 值是类别
`predict_log_proba`(X)	预测 X 的对数概率（返回 log(predict_proba(x))）。
`predict_proba`(X[, log])	预测 X 的类别概率。

get_attr_names

注意

求解器使用 SMO 方法来拟合分类器。我们使用 SMO 算法的优化分层分解 (Optimized Hierarchical Decomposition) [1] 变体，类似于 [2]。

有关更多文档，请参阅 scikitlearn 的 SVC。

参考

[1]

J. Vanek 等人. 面向 GPU 架构优化的支持向量机训练分层分解算法, IEEE Transactions on Parallel and Distributed Systems, 卷 28, 期 12, 3330, (2017)

[2]

Z. Wen 等人. ThunderSVM: 一个在 GPU 和 CPU 上快速的 SVM 库, Journal of Machine Learning Research, 19, 1-5 (2018)

示例

>>> import cupy as cp
>>> from cuml.svm import SVC
>>> X = cp.array([[1,1], [2,1], [1,2], [2,2], [1,3], [2,3]],
...              dtype=cp.float32);
>>> y = cp.array([-1, -1, 1, -1, 1, 1], dtype=cp.float32)
>>> clf = SVC(kernel='poly', degree=2, gamma='auto', C=1)
>>> clf.fit(X, y)
SVC()
>>> print("Predicted labels:", clf.predict(X))
Predicted labels: [-1. -1.  1. -1.  1.  1.]

class cuml.svm.LinearSVC(Support Vector Classification with the linear kernel)[source]#

构建用于训练和预测的线性 SVM 分类器。

参数:

handlecuml.Handle

penalty{‘l1’, ‘l2’} (默认值 = ‘l2’)

目标函数的正则化项。

loss{‘squared_hinge’, ‘hinge’} (默认值 = ‘squared_hinge’)

目标函数的损失项。

fit_intercept布尔型 (默认值 = True)

是否拟合偏置项。如果数据已中心化，则设置为 False。

penalized_intercept布尔型 (默认值 = False)

如果为 true，则偏置项与其他特征处理方式相同；即它受到目标函数的正则化项惩罚。启用此功能会强制额外复制输入数据 X。

max_iter整数 (默认值 = 1000)

底层求解器的最大迭代次数。

linesearch_max_iter整型 (默认值 = 100)

底层 (QN) 求解器的最大线搜索（内循环）迭代次数。

lbfgs_memory整型 (默认值 = 5)

用于底层 QN 求解器 (l-bfgs) 的近似 hessian 向量数量。

class_weight字典或字符串 (默认值=None)

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

C浮点数 (默认值 = 1.0)

目标公式中损失项的常数缩放因子: F(X, y) = penalty(X) + C * loss(X, y).

grad_tol浮点型 (默认值 = 0.0001)

底层 QN 求解器的梯度阈值。

change_tol浮点型 (默认值 = 1e-05)

底层 QN 求解器的函数变化阈值。

tol可选[浮点型] (默认值 = None)

停止准则的容差。这是一个辅助瞬态参数，当存在时，将 grad_tol 和 change_tol 都设置为相同的值。当同时传递这两个 ***_tol 参数中的任何一个时，它们优先。

probability: 布尔型 (默认值 = False)

启用或禁用概率估计。

multi_class{目前仅支持 ‘ovr’} (默认值 = ‘ovr’)

多类别分类策略。'ovo' 使用 OneVsOneClassifier，而 'ovr' 选择 OneVsRestClassifier

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

属性:

intercept_浮点型, 形状 (n_classes_,): 决策函数中的常数项
coef_浮点型, 形状 (n_classes_, n_cols): 定义分隔类别的超平面的向量。
classes_浮点型, 形状 (n_classes_,): n_classes_整型类别数量。
probScale_浮点型, 形状 (n_classes_, 2): 概率校准常数（用于概率输出）。
decision_function(X): 类别数量

方法

fit

注意

模型使用拟牛顿 (QN) 求解器在原始空间中找到解。因此，与通用 SVC 模型相比，它不计算支持系数/向量。

查看求解器的文档了解更多详情 拟牛顿法 (L-BFGS/OWL-QN)。

有关更多文档，请参阅 scikitlearn 的 LinearSVC。

示例

>>> import cupy as cp
>>> from cuml.svm import LinearSVC
>>> X = cp.array([[1,1], [2,1], [1,2], [2,2], [1,3], [2,3]],
...              dtype=cp.float32);
>>> y = cp.array([0, 0, 1, 0, 1, 1], dtype=cp.float32)
>>> clf = LinearSVC(loss='squared_hinge', penalty='l1', C=1)
>>> clf.fit(X, y)
LinearSVC()
>>> print("Predicted labels:", clf.predict(X))
Predicted labels: [0. 0. 1. 0. 1. 1.]

class cuml.svm.LinearSVR(Support Vector Regression with the linear kernel)[source]#

构建用于训练和预测的线性 SVM 回归器。

参数:

handlecuml.Handle

penalty{‘l1’, ‘l2’} (默认值 = ‘l2’)

目标函数的正则化项。

loss{‘squared_epsilon_insensitive’, ‘epsilon_insensitive’} (默认值 = ‘epsilon_insensitive’)

目标函数的损失项。

fit_intercept布尔型 (默认值 = True)

是否拟合偏置项。如果数据已中心化，则设置为 False。

penalized_intercept布尔型 (默认值 = False)

如果为 true，则偏置项与其他特征处理方式相同；即它受到目标函数的正则化项惩罚。启用此功能会强制额外复制输入数据 X。

max_iter整数 (默认值 = 1000)

底层求解器的最大迭代次数。

linesearch_max_iter整型 (默认值 = 100)

底层 (QN) 求解器的最大线搜索（内循环）迭代次数。

lbfgs_memory整型 (默认值 = 5)

用于底层 QN 求解器 (l-bfgs) 的近似 hessian 向量数量。

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

C浮点数 (默认值 = 1.0)

目标公式中损失项的常数缩放因子: F(X, y) = penalty(X) + C * loss(X, y).

grad_tol浮点型 (默认值 = 0.0001)

底层 QN 求解器的梯度阈值。

change_tol浮点型 (默认值 = 1e-05)

底层 QN 求解器的函数变化阈值。

tol可选[浮点型] (默认值 = None)

epsilon浮点型 (默认值 = 0.0)

SVR 损失函数的 epsilon-敏感参数。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

属性:

intercept_浮点型, 形状 (1,): 决策函数中的常数项
coef_浮点型, 形状 (1, n_cols): 线性决策函数的系数。

注意

模型使用拟牛顿 (QN) 求解器在原始空间中找到解。因此，与通用 SVC 模型相比，它不计算支持系数/向量。

查看求解器的文档了解更多详情 拟牛顿法 (L-BFGS/OWL-QN)。

有关更多文档，请参阅 scikitlearn 的 LinearSVR。

示例

>>> import cupy as cp
>>> from cuml.svm import LinearSVR
>>> X = cp.array([[1], [2], [3], [4], [5]], dtype=cp.float32)
>>> y = cp.array([1.1, 4, 5, 3.9, 8.], dtype=cp.float32)
>>> reg = LinearSVR(loss='epsilon_insensitive', C=10,
...                 epsilon=0.1, verbose=0)
>>> reg.fit(X, y)
LinearSVR()
>>> print("Predicted values:", reg.predict(X)) 
Predicted labels: [1.8993504 3.3995128 4.899675  6.399837  7.899999]

最近邻分类 (Nearest Neighbors Classification)#

class cuml.neighbors.KNeighborsClassifier(*, weights='uniform', handle=None, verbose=False, output_type=None, **kwargs)

K-最近邻分类器是一种基于实例的学习技术，它保留训练样本用于预测，而不是尝试学习一组可泛化的模型参数。

参数:

n_neighbors整型 (默认值=5): 要查询的默认邻居数量
algorithm字符串 (默认值=’auto’): 要使用的查询算法。目前仅支持 ‘brute’。
metric字符串 (默认值=’euclidean’)。: 要使用的距离度量。
weights字符串 (默认值=’uniform’): 要使用的样本权重。目前仅支持 uniform 策略。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

属性:

classes_
y

方法

`fit`(X, y[, convert_dtype])	为 k-最近邻分类器模型拟合 GPU 索引。
`predict`(X[, convert_dtype])	使用训练好的 k-最近邻分类器来
`predict_proba`(X[, convert_dtype])	使用训练好的 k-最近邻分类器来

注意

有关更多文档，请参阅 scikitlearn 的 KNeighborsClassifier。

示例

>>> from cuml.neighbors import KNeighborsClassifier
>>> from cuml.datasets import make_blobs
>>> from cuml.model_selection import train_test_split

>>> X, y = make_blobs(n_samples=100, centers=5,
...                   n_features=10, random_state=5)
>>> X_train, X_test, y_train, y_test = train_test_split(
...     X, y, train_size=0.80, random_state=5)

>>> knn = KNeighborsClassifier(n_neighbors=10)

>>> knn.fit(X_train, y_train)
KNeighborsClassifier()
>>> knn.predict(X_test) 
array([1., 2., 2., 3., 4., 2., 4., 4., 2., 3., 1., 4., 3., 1., 3., 4., 3., # noqa: E501
    4., 1., 3.], dtype=float32)

fit(X, y, convert_dtype=True) → KNeighborsClassifier[source]

为 k-最近邻分类器模型拟合 GPU 索引。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，该方法将自动把输入转换为 np.float32。

predict(X, convert_dtype=True) → CumlArray[source]

使用训练好的 k-最近邻分类器预测 X 的标签

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，该方法将自动把输入转换为 np.float32。

返回值:

X_new取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象, 形状 = (n_samples, 1)

预测的标签

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

predict_proba(X, convert_dtype=True) → CumlArray | Tuple[source]

使用训练好的 k-最近邻分类器预测 X 的标签概率

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，该方法将自动把输入转换为 np.float32。

返回值:

X_new取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象, 形状 = (n_samples, 1)

标签概率

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

最近邻回归 (Nearest Neighbors Regression)#

class cuml.neighbors.KNeighborsRegressor(*, weights='uniform', handle=None, verbose=False, output_type=None, **kwargs)

K-最近邻回归器是一种基于实例的学习技术，它保留训练样本用于预测，而不是尝试学习一组可泛化的模型参数。

K-最近邻回归器将计算 k 个最近邻居标签的平均值并将其用作标签。

参数:

n_neighbors整型 (默认值=5)

要查询的默认邻居数量

algorithm字符串 (默认值=’auto’)

要使用的查询算法。有效选项包括

'auto'：根据数据形状和度量自动选择暴力法或随机球覆盖法
'rbc'：随机球算法，它划分数据空间并使用三角不等式来减少潜在距离的数量。目前，此算法支持 2d Euclidean 和 Haversine。
'brute'：暴力法，速度慢但结果精确
'ivfflat'：倒排文件，将数据集分成多个分区，仅在相关分区上执行搜索
'ivfpq'：倒排文件和乘积量化，与倒排列表相同，此外向量被分解为 n_features/M 个子向量，这些子向量通过中间 k-means 聚类进行编码。这种编码提供部分信息，从而实现更快的距离计算

metric字符串 (默认值=’euclidean’)。

要使用的距离度量。

weights字符串 (默认值=’uniform’)

要使用的样本权重。目前仅支持 uniform 策略。

handlecuml.Handle

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

属性:

y

方法

`fit`(X, y[, convert_dtype])	为 k-最近邻回归模型拟合 GPU 索引。
`predict`(X[, convert_dtype])	使用训练好的 k-最近邻回归模型来

注意

有关更多文档，请参阅 scikitlearn 的 KNeighborsClassifier。

示例

>>> from cuml.neighbors import KNeighborsRegressor
>>> from cuml.datasets import make_regression
>>> from cuml.model_selection import train_test_split

>>> X, y = make_regression(n_samples=100, n_features=10,
...                        random_state=5)
>>> X_train, X_test, y_train, y_test = train_test_split(
...   X, y, train_size=0.80, random_state=5)

>>> knn = KNeighborsRegressor(n_neighbors=10)
>>> knn.fit(X_train, y_train)
KNeighborsRegressor()
>>> knn.predict(X_test) 
array([ 14.770798  ,  51.8834    ,  66.15657   ,  46.978275  ,
    21.589611  , -14.519918  , -60.25534   , -20.856869  ,
    29.869623  , -34.83317   ,   0.45447388, 120.39675   ,
    109.94834   ,  63.57794   , -17.956171  ,  78.77663   ,
    30.412262  ,  32.575233  ,  74.72834   , 122.276855  ],
dtype=float32)

fit(X, y, convert_dtype=True) → KNeighborsRegressor[source]

为 k-最近邻回归模型拟合 GPU 索引。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，该方法将自动把输入转换为 np.float32。

predict(X, convert_dtype=True) → CumlArray[source]

使用训练好的 k-最近邻回归模型预测 X 的标签

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，该方法将自动把输入转换为 np.float32。

返回值:

X_new取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象, 形状 = (n_samples, n_features)

预测值

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

核岭回归 (Kernel Ridge Regression)#

class cuml.KernelRidge(*, alpha=1, kernel='linear', gamma=None, degree=3, coef0=1, kernel_params=None, output_type=None, handle=None, verbose=False)#

核岭回归 (KRR) 使用核技巧执行 L2 正则化岭回归。核技巧允许估计器学习核诱导空间中的线性函数。这可能是在原始特征空间中的非线性函数（当使用非线性核函数时）。此估计器支持多输出回归（当 y 为 2 维时）。更多信息请参阅 sklearn 用户指南。

参数:

alpha浮点型或形状为 (n_targets,) 的类数组对象, 默认值=1.0: 正则化强度；必须是正浮点数。正则化改善了问题的条件性并降低了估计值的方差。较大的值指定更强的正则化。如果传递数组，则惩罚被假定为特定于目标的。
kernel字符串或可调用对象, 默认值=”linear”: 内部使用的核映射。此参数直接传递给 pairwise_kernel。如果 kernel 是字符串，则它必须是 cuml.metrics.PAIRWISE_KERNEL_FUNCTIONS 中的度量之一或 “precomputed”。如果 kernel 是 “precomputed”，则假定 X 是核矩阵。kernel 可以是可调用的 numba 设备函数。如果是，则在每对实例（行）上调用并记录结果值。
gamma浮点型, 默认值=None: 用于 RBF、laplacian、polynomial、exponential chi2 和 sigmoid 核函数的 Gamma 参数。默认值的解释取决于核函数；请参阅 sklearn.metrics.pairwise 的文档。其他核函数忽略此参数。
degree浮点型, 默认值=3: 多项式核函数的次数。其他核函数忽略此参数。
coef0浮点型, 默认值=1: 多项式和 sigmoid 核函数的零系数。其他核函数忽略此参数。
kernel_params字符串到任意类型的映射, 默认值=None: 作为可调用对象传递的核函数的附加参数（关键字参数）。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

属性:

dual_coef_形状为 (n_samples,) 或 (n_samples, n_targets) 的 ndarray: 核空间中权重向量的表示
X_fit_形状为 (n_samples, n_features) 的 ndarray: 训练数据，预测时也需要。如果 kernel == “precomputed”，则这是预计算的训练矩阵，形状为 (n_samples, n_samples)。

方法

`fit`(X, y[, sample_weight, convert_dtype])
`predict`(X)	使用核岭模型进行预测。

get_attr_names

示例

>>> import cupy as cp
>>> from cuml.kernel_ridge import KernelRidge
>>> from numba import cuda
>>> import math

>>> n_samples, n_features = 10, 5
>>> rng = cp.random.RandomState(0)
>>> y = rng.randn(n_samples)
>>> X = rng.randn(n_samples, n_features)

>>> model = KernelRidge(kernel="poly").fit(X, y)
>>> pred = model.predict(X)

>>> @cuda.jit(device=True)
... def custom_rbf_kernel(x, y, gamma=None):
...     if gamma is None:
...         gamma = 1.0 / len(x)
...     sum = 0.0
...     for i in range(len(x)):
...         sum += (x[i] - y[i]) ** 2
...     return math.exp(-gamma * sum)

>>> model = KernelRidge(kernel=custom_rbf_kernel,
...                     kernel_params={"gamma": 2.0}).fit(X, y)
>>> pred = model.predict(X)

fit(X, y, sample_weight=None, convert_dtype=True) → KernelRidge[source]#

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

predict(X)[source]#

使用核岭模型进行预测。

参数:

X形状为 (n_samples, n_features) 的 array-like 对象: 样本。如果 kernel == “precomputed”，则这是预计算的核矩阵，形状 = [n_samples, n_samples_fitted]，其中 n_samples_fitted 是用于此估计器拟合的样本数量。

返回值:

C形状为 (n_samples,) 或 (n_samples, n_targets) 的数组: 返回预测值。

聚类 (Clustering)#

K-均值聚类 (K-Means Clustering)#

class cuml.KMeans(*, handle=None, n_clusters=8, max_iter=300, tol=0.0001, verbose=False, random_state=1, init='scalable-k-means++', n_init='auto', oversampling_factor=2.0, max_samples_per_batch=32768, convert_dtype=True, output_type=None)#

KMeans 是一种基础但强大的聚类方法，通过期望最大化进行优化。它在 X 中随机选择 K 个数据点，并计算哪些样本靠近这些点。对于每个点簇，计算一个平均值（因此得名），这成为新的质心。

cuML 的 KMeans 期望一个类数组对象或 cuDF DataFrame 作为输入，并支持可伸缩的 KMeans++ 初始化方法。此方法比随机选择 K 个点更稳定。

参数:

handlecuml.Handle

n_clusters整型 (默认值 = 8)

您想要的质心或簇的数量。

max_iter整型 (默认值 = 300)

EM 迭代次数越多，精度越高，但速度越慢。

tolfloat64 (默认值 = 1e-4)

质心均值变化不大时的停止准则。

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

random_state整型 (默认值 = 1)

如果您希望在重新启动 Python 时结果保持一致，请选择一个状态。

init{‘scalable-kmeans++’, ‘k-means||’, ‘random’} 或 ndarray (默认值 = ‘scalable-k-means++’)

'scalable-k-means++' 或 'k-means||'：使用快速且稳定的可伸缩 kmeans++ 初始化。
'random'：从数据中随机选择 n_cluster 个观测值（行）作为初始质心。
如果传递的是 ndarray，其形状应为 (n_clusters, n_features)，并给出初始中心。

n_init: ‘auto’ 或整型 (默认值 = ‘auto’)

k-means 算法将用不同的种子调用的实例数量。最终结果将来自 n_init 个实例中产生最低惯性矩的实例。

当 n_init='auto' 时，运行次数取决于 init 的值：如果使用 init='"k-means||"' 或 init="scalable-k-means++"，则为 1；否则为 10。

25.02 版本新增: 为 n_init 添加了 ‘auto’ 选项。

25.04 版本变更: n_init 的默认值将在 25.04 版本中从 1 更改为 'auto'。

oversampling_factorfloat64 (默认值 = 2.0)

在可伸缩 k-means++ 初始化中采样用于潜在质点的点数量。增加此值可以获得更好的初始质点，但会消耗更多内存。可伸缩 k-means++ 中采样的质点总数是 oversampling_factor * n_clusters * 8。

max_samples_per_batch整型 (默认值 = 32768)

用于成对距离计算批次的样本数量。此计算贯穿 fit 和 predict。默认值适用于大多数情况。批处理成对距离计算中的元素总数是 max_samples_per_batch * n_clusters。当 n_clusters 过大时，可能需要降低此数字。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

属性:

cluster_centers_数组: 最终聚类的坐标。这表示每个数据簇的“平均值”。
labels_数组: 每个数据点所属的簇。

方法

`fit`(X[, y, sample_weight, convert_dtype])	对 X 进行 k-means 聚类计算。
`fit_predict`(X[, y, sample_weight])	计算簇中心并预测每个样本的簇索引。
`fit_transform`(X[, y, convert_dtype, ...])	计算聚类并将 X 转换为簇距离空间。
`predict`(X[, y, convert_dtype, ...])	预测 X 中每个样本所属的最近簇。
`score`(X[, y, sample_weight, convert_dtype])	X 在 K-means 目标函数上的值的相反数。
`transform`(X[, y, convert_dtype])	将 X 转换为簇距离空间。

get_attr_names

注意

KMeans 需要指定 n_clusters。这意味着需要大致猜测或知道数据集有多少个簇。如果不确定，可以从少量簇开始，并使用 PCA、UMAP 或 T-SNE 可视化结果簇，并验证它们看起来是否合适。

KMeans 的应用

KMeans 最大的优点是速度快且简单。这就是为什么 KMeans 是许多实践者的首选聚类算法。当簇的数量大致已知时，KMeans 已被广泛使用，例如在大数据聚类任务、图像分割和医学聚类中。

有关更多文档，请参阅 scikitlearn 的 Kmeans。

示例

>>> # Both import methods supported
>>> from cuml import KMeans
>>> from cuml.cluster import KMeans
>>> import cudf
>>> import numpy as np
>>> import pandas as pd
>>>
>>> a = np.asarray([[1.0, 1.0], [1.0, 2.0], [3.0, 2.0], [4.0, 3.0]],
...                dtype=np.float32)
>>> b = cudf.DataFrame(a)
>>> # Input:
>>> b
    0    1
0  1.0  1.0
1  1.0  2.0
2  3.0  2.0
3  4.0  3.0
>>>
>>> # Calling fit
>>> kmeans_float = KMeans(n_clusters=2, n_init="auto")
>>> kmeans_float.fit(b)
KMeans()
>>>
>>> # Labels:
>>> kmeans_float.labels_
0    0
1    0
2    1
3    1
dtype: int32
>>> # cluster_centers:
>>> kmeans_float.cluster_centers_
    0    1
0  1.0  1.5
1  3.5  2.5

fit(X, y=None, sample_weight=None, convert_dtype=True) → KMeans[source]#

对 X 进行 k-means 聚类计算。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

fit_predict(X, y=None, sample_weight=None) → CumlArray[source]#

计算簇中心并预测每个样本的簇索引。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

簇索引

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

fit_transform(X, y=None, convert_dtype=False, sample_weight=None) → CumlArray[source]#

计算聚类并将 X 转换为簇距离空间。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtype布尔型, 可选 (默认值 = False): 设置为 True 时，fit_transform 方法在必要时会将输入转换为用于训练模型的数据类型。这将增加该方法使用的内存。
sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。

返回值:

X_new取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象, 形状 = (n_samples, n_clusters)

转换后的数据

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

predict(X, y=None, convert_dtype=True, sample_weight=None, normalize_weights=True) → CumlArray[source]#

预测 X 中每个样本所属的最近簇。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。
sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

簇索引

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

score(X, y=None, sample_weight=None, convert_dtype=True)[source]#

X 在 K-means 目标函数上的值的相反数。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，score 方法在必要时会将输入转换为用于训练模型的数据类型。这将增加该方法使用的内存。

返回值:

scorefloat: X 在 K-means 目标函数上的值的相反数。

transform(X, y=None, convert_dtype=True) → CumlArray[source]#

将 X 转换为簇距离空间。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，transform 方法在必要时会将输入转换为用于训练模型的数据类型。这将增加该方法使用的内存。

返回值:

X_new取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象, 形状 = (n_samples, n_clusters)

转换后的数据

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

DBSCAN#

class cuml.DBSCAN(*, eps=0.5, handle=None, min_samples=5, metric='euclidean', algorithm='brute', verbose=False, max_mbytes_per_batch=None, output_type=None, calc_core_sample_indices=True)#

DBSCAN 是一种非常强大且快速的聚类技术，它能在数据密集的地方找到聚类。如果数据点倾向于聚集在更大的群体中，这使得 DBSCAN 能够泛化到许多问题。

cuML 的 DBSCAN 期望一个类似数组的对象或 cuDF DataFrame，并构建一个邻接图来计算邻近点之间的距离。

参数:

eps浮点数 (默认值 = 0.5): 两个点之间的最大距离，以便它们位于同一邻域中。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
min_samples整数 (默认值 = 5): 邻域中的样本数量，使得该组（包括点本身）可以被视为一个重要的核心点。
metric: {‘欧几里得’, ‘余弦’, ‘预计算’}，默认值 = ‘欧几里得’: 计算点之间距离时使用的度量标准。如果度量标准为“预计算”，则假定 X 是一个距离矩阵，且必须是方形的。使用余弦距离时，输入会被临时修改，并且由于数值舍入，恢复后的输入矩阵可能无法完全匹配。
algorithm: {‘brute’, ‘rbc’}，默认值 = ‘brute’: 用于最近邻计算的算法。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
max_mbytes_per_batch(可选) int64: 计算批量大小时，对成对距离计算使用的兆字节数不超过此值。这可以在运行时和内存使用之间进行权衡，使 N^2 成对距离计算对于大量样本更加易于处理。如果在运行 DBSCAN 时遇到内存不足错误，可以根据设备的内存大小设置此值。注意：此选项不会设置 DBSCAN 计算中使用的最大总内存，因此此值无法设置为设备上可用的总内存。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
calc_core_sample_indices(可选) 布尔值 (默认值 = True): 指示是否应该计算核心样本的索引。如果属性 core_sample_indices_ 将不被使用，将此设置为 False 将避免不必要的内核启动。

属性:

labels_类似数组的对象或 cuDF series: 每个数据点所属的聚类。噪声样本标记为 -1。格式取决于 cuml 全局输出类型和 estimator 的 output_type。
core_sample_indices_类似数组的对象或 cuDF series: 核心样本的索引。仅在 calc_core_sample_indices==True 时计算。

方法

`fit`(X[, y, out_dtype, sample_weight, ...])	从特征执行 DBSCAN 聚类。
`fit_predict`(X[, y, out_dtype, sample_weight])	在 X 上执行聚类并返回聚类标签。

get_attr_names

注意

DBSCAN 对其使用的距离度量非常敏感，并且一个重要的假设是数据点需要集中成群才能构建聚类。

DBSCAN 的应用

DBSCAN 的主要优点是聚类数量不是一个超参数，并且它可以找到非线性形状的聚类。这使得 DBSCAN 对噪声具有鲁棒性。DBSCAN 已被应用于分析大型强子对撞机中的粒子碰撞、营销分析中的客户细分等等。

更多文档请参阅 scikit-learn 的 DBSCAN。

示例

>>> # Both import methods supported
>>> from cuml import DBSCAN
>>> from cuml.cluster import DBSCAN
>>>
>>> import cudf
>>> import numpy as np
>>>
>>> gdf_float = cudf.DataFrame()
>>> gdf_float['0'] = np.asarray([1.0,2.0,5.0], dtype = np.float32)
>>> gdf_float['1'] = np.asarray([4.0,2.0,1.0], dtype = np.float32)
>>> gdf_float['2'] = np.asarray([4.0,2.0,1.0], dtype = np.float32)
>>>
>>> dbscan_float = DBSCAN(eps = 1.0, min_samples = 1)
>>> dbscan_float.fit(gdf_float)
DBSCAN()
>>> dbscan_float.labels_
0    0
1    1
2    2
dtype: int32

fit(X, y=None, out_dtype='int32', sample_weight=None, convert_dtype=True) → DBSCAN[source]#

从特征执行 DBSCAN 聚类。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features)

y类数组 (设备或主机) 形状 = (n_samples, 1)

sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None

X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。

convert_dtypebool, 可选 (默认 = True)

设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

out_dtype: dtype 决定输出标签数组的精度。

默认值：“int32”。有效值为 { “int32”, np.int32, “int64”, np.int64}。

sample_weight: 形状为 (n_samples,) 的类似数组的对象，默认值=None: 每个样本的权重，使得权重至少为 min_samples 的样本本身就是一个核心样本；权重为负的样本可能会阻止其 eps 邻居成为核心点。默认值：None（相当于所有样本的权重为 1）。

fit_predict(X, y=None, out_dtype='int32', sample_weight=None) → CumlArray[source]#

在 X 上执行聚类并返回聚类标签。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features)

y类数组 (设备或主机) 形状 = (n_samples, 1)

sample_weight类数组 (设备或主机) 形状 = (n_samples,), 默认值=None

out_dtype: dtype 决定输出标签数组的精度。

默认值：“int32”。有效值为 { “int32”, np.int32, “int64”, np.int64}。

sample_weight: 形状为 (n_samples,) 的类似数组的对象，默认值=None: 每个样本的权重，使得权重至少为 min_samples 的样本本身就是一个核心样本；权重为负的样本可能会阻止其 eps 邻居成为核心点。默认值：None（相当于所有样本的权重为 1）。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

聚类标签

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

层次聚类#

class cuml.AgglomerativeClustering(*, n_clusters=2, affinity='deprecated', metric=None, linkage='single', handle=None, verbose=False, connectivity='knn', n_neighbors=10, output_type=None)#

层次聚类

递归地合并使给定连接距离增加最小的一对聚类。

参数:

handlecuml.Handle

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

n_clusters整数 (默认值 = 2)

要找到的聚类数量。

affinity字符串，默认值=’euclidean’

用于计算连接距离的度量标准。可以是“欧几里得”、“l1”、“l2”、“曼哈顿”或“余弦”。如果 connectivity 为“knn”，则只接受“欧几里得”。

自 24.06 版本起已弃用：affinity 在 24.06 版本中已弃用，并将在 25.08 版本中重命名为 metric。

metric字符串，默认值=None

用于计算连接距离的度量标准。可以是“欧几里得”、“l1”、“l2”、“曼哈顿”或“余弦”。如果设置为 None，则使用“欧几里得”。如果 connectivity 为“knn”，则只接受“欧几里得”。 .. versionadded:: 24.06

linkage{“single”}，默认值=”single”

要使用的连接标准。连接标准决定了观测集之间使用哪种距离。算法将合并使此标准最小化的一对聚类。

‘single’ 使用两个集合中所有观测之间距离的最小值。

n_neighbors整数 (默认值 = 15)

当 connectivity = “knn” 时计算的邻居数量。

connectivity{“pairwise”, “knn”}，(默认值 = “knn”)

要计算的连接矩阵的类型。

‘pairwise’ 将计算每组点之间的所有成对距离的完整全连接图。这是计算最快的方法，对于较小的数据集来说可以非常快，但需要 O(n^2) 的空间。
‘knn’ 将对完全连接的连接矩阵进行稀疏化处理，以节省内存并支持更大的输入。“n_neighbors” 将控制使用的内存量，并且如果 “n_neighbors” 不够大无法连接图，图将自动连接。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

属性:

children_
labels_

方法

`fit`(X[, y, convert_dtype])	从特征执行层次聚类。
`fit_predict`(X[, y])	从特征执行层次聚类。

fit(X, y=None, convert_dtype=True) → AgglomerativeClustering[source]#

从特征执行层次聚类。

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类似数组的对象（设备或主机），形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtype布尔值，可选 (默认值 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

从特征执行层次聚类。

fit_predict(X, y=None) → CumlArray[source]#

从特征执行层次聚类。

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类似数组的对象（设备或主机），形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
从特征执行层次聚类并返回: 聚类标签。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

簇索引

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

HDBSCAN#

class cuml.cluster.hdbscan.HDBSCAN(*, min_cluster_size=5, min_samples=None, cluster_selection_epsilon=0.0, max_cluster_size=0, metric='euclidean', alpha=1.0, p=2, cluster_selection_method='eom', allow_single_cluster=False, gen_min_span_tree=False, handle=None, verbose=False, connectivity='knn', output_type=None, prediction_data=False)#

HDBSCAN 聚类

递归地合并使给定连接距离增加最小的一对聚类。

注意，虽然算法通常是确定性的，并且应该在 RAPIDS 和 Scikit-learn Contrib 版本之间提供匹配的结果，但 k 最近邻图和最小生成树的构建可能会在两种算法之间引入差异，特别是在一个点周围的几个最近邻可能具有相同距离时。虽然仅在最小生成树上的差异可能很细微，但它们可能（且通常会）导致在两种实现之间为某些点分配不同的聚类标签。

参数:

handlecuml.Handle

alpha浮点数，可选 (默认值=1.0)

用于鲁棒单连接的距离缩放参数。

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

min_cluster_size整数，可选 (默认值 = 5)

一个组被视为聚类所需的最小样本数；小于此大小的分组将被视为噪声。

min_samples整数，可选 (默认值=None)

一个点被视为核心点所需的邻域中的样本数量。这包括点本身。如果为‘None’，则默认为 min_cluster_size。

cluster_selection_epsilon浮点数，可选 (默认值=0.0)

一个距离阈值。小于此值的聚类将被合并。注意，如果将来想预测新点的聚类标签（例如使用 approximate_predict），则不应使用此参数，因为 approximate_predict 函数不知道此参数。

max_cluster_size整数，可选 (默认值=0)

对 eom 算法返回的聚类大小的限制。使用叶子聚类（无论如何聚类通常都很小）时无效，在极少数情况下，高值的 cluster_selection_epsilon 也可能覆盖此值。注意，如果将来想预测新点的聚类标签（例如使用 approximate_predict），则不应使用此参数，因为 approximate_predict 函数不知道此参数。

metric字符串，可选 (默认值=’euclidean’)

计算特征数组中实例之间距离时使用的度量标准。允许的值：“欧几里得”。

p整数，可选 (默认值=2)

使用 Minkowski 度量时使用的 p 值。

cluster_selection_method字符串，可选 (默认值=’eom’)

用于从 Condensed Tree 中选择聚类的方法。HDBSCAN* 的标准方法是使用 Excess of Mass 算法来寻找最持久的聚类。或者，您可以选择树的叶子上的聚类——这提供了最细粒度和同质的聚类。选项包括

eom

leaf

allow_single_cluster布尔值，可选 (默认值=False)

默认情况下，HDBSCAN* 不会产生单个聚类，将此设置为 True 将覆盖此设置，并在您认为这是数据集的有效结果时允许出现单个聚类结果。

gen_min_span_tree布尔值，可选 (默认值=False)

是否填充 minimum_spanning_tree_ 成员以利用绘图工具。这需要安装 hdbscan CPU Python 包。

gen_condensed_tree布尔值，可选 (默认值=False)

是否填充 condensed_tree_ 成员以利用绘图工具。这需要安装 hdbscan CPU Python 包。

gen_single_linkage_tree_布尔值，可选 (默认值=False)

是否填充 single_linkage_tree_ 成员以利用绘图工具。这需要安装 hdbscan CPU Python 包。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

prediction_data布尔值，可选 (默认值=False)

是否生成额外的缓存数据，用于后续预测少量新的、未见过的点的标签或成员向量。如果您希望持久化聚类对象以便后续重用，您可能希望将其设置为 True。

属性:

labels_ndarray，形状 (n_samples, ): 提供给 fit() 的数据集中每个点的聚类标签。噪声样本被赋予标签 -1。
probabilities_ndarray，形状 (n_samples, ): 每个样本属于其分配聚类的强度。噪声点的概率为零；聚类中的点被赋予与其作为聚类一部分的持久程度成比例的值。
cluster_persistence_ndarray，形状 (n_clusters, ): 每个聚类持久性的得分。得分为 1.0 表示一个在所有距离尺度上都持续存在的完美稳定聚类，而得分为 0.0 表示一个完美短暂的聚类。这些分数可用于衡量算法输出的聚类的相对一致性。
condensed_tree_CondensedTree 对象: HDBSCAN 生成的 Condensed Tree。该对象具有转换为 pandas、networkx 和进行绘图的方法。
single_linkage_tree_SingleLinkageTree 对象: HDBSCAN 生成的 Single Linkage Tree。该对象具有转换为 pandas、networkx 和进行绘图的方法。
minimum_spanning_tree_MinimumSpanningTree 对象: HDBSCAN 生成的互达可达图的最小生成树。注意，默认情况下不生成此属性，并且只有在创建对象时将 gen_min_span_tree 设置为 True 时才可用。即使如此，在某些优化情况下也可能不会生成树。

方法

`fit`(X[, y, convert_dtype])	从特征拟合 HDBSCAN 模型。
`fit_predict`(X[, y])	从特征拟合 HDBSCAN 模型并返回
`generate_prediction_data`()	创建缓存中间结果的数据，用于预测新的/未见过的点的标签。
`gpu_to_cpu`()	将属性从 GPU 估计器转移到 CPU 估计器。

build_minimum_spanning_tree
get_attr_names

fit(X, y=None, convert_dtype=True) → HDBSCAN[source]#

从特征拟合 HDBSCAN 模型。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

fit_predict(X, y=None) → CumlArray[source]#

从特征拟合 HDBSCAN 模型并返回聚类标签。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。

返回值:

preds取决于 cuML 输出类型配置的 cuDF、CuPy 或 NumPy 对象，形状 = (n_samples, 1)

簇索引

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

generate_prediction_data()[source]#: 创建缓存中间结果的数据，用于预测新的/未见过的点的标签。如果您打算使用 hdbscan.prediction 中的函数，这些数据才有用。

gpu_to_cpu()[source]#: 将属性从 GPU 估计器转移到 CPU 估计器。

cuml.cluster.hdbscan.all_points_membership_vectors(clusterer, batch_size=4096)[source]#

为训练聚类器所使用的原始数据集中的所有点预测软聚类成员向量。此函数通过利用所有点已存在于 Condensed Tree 中并批量处理这一事实，效率更高。

参数:

clustererHDBSCAN: 一个已经拟合过数据并且已将 prediction_data=True 设置为 True 的聚类对象。
batch_size整数，可选，默认值=min(4096, n_rows): 通过在训练数据中以较小的批量计算基于距离的成员关系来降低内存需求。例如，批量大小为 1,000 时，一次计算 1,000 个点的基于距离的成员关系。默认批量大小为 4,096。

返回值:

membership_vectors数组 (n_samples, n_clusters): 原始数据集中的点 i 属于聚类 j 的概率位于 membership_vectors[i, j] 中。

cuml.cluster.hdbscan.membership_vector(clusterer, points_to_predict, batch_size=4096, convert_dtype=True)[source]#

预测软聚类成员关系。结果为 points_to_predict 中的每个点生成一个向量，该向量给出给定点属于 clusterer 所选定的每个聚类的概率。

参数:

clustererHDBSCAN: 一个已经拟合过数据并且已将 prediction_data=True 设置为 True，或者之后调用了 generate_prediction_data 方法的聚类对象。
points_to_predict数组，或类似数组的对象 (n_samples, n_features): 用于预测聚类标签的新数据点。它们应该与训练聚类器所使用的原始数据集具有相同的维度。
batch_size整数，可选，默认值=min(4096, n_points_to_predict): 通过在预测数据中以较小的批量计算基于距离的成员关系来降低内存需求。例如，批量大小为 1,000 时，一次计算 1,000 个点的基于距离的成员关系。默认批量大小为 4,096。

返回值:

membership_vectors数组 (n_samples, n_clusters): 点 i 属于聚类 j 的概率位于 membership_vectors[i, j] 中。

cuml.cluster.hdbscan.approximate_predict(clusterer, points_to_predict, convert_dtype=True)[source]#

预测新点的聚类标签。返回的标签将是 clusterer 找到的原始聚类的标签，因此不（一定）是原始数据与 points_to_predict 结合聚类所找到的聚类标签，因此称为“近似”标签。

如果您只是希望以“最佳”方式将新点分配到现有聚类中，则应使用此函数。如果您想预测 points_to_predict 在 HDBSCAN 下与原始数据如何聚类，最有效的现有方法是简单地将新点添加到原始数据集后重新聚类。

参数:

clustererHDBSCAN: 一个已经拟合过数据并且已将 prediction_data=True 设置为 True 的聚类对象。
points_to_predict数组，或类似数组的对象 (n_samples, n_features): 用于预测聚类标签的新数据点。它们应该与训练聚类器所使用的原始数据集具有相同的维度。

返回值:

labels数组 (n_samples,): points_to_predict 的预测标签
probabilities数组 (n_samples,): points_to_predict 中每个点的软聚类得分

降维与流形学习#

主成分分析#

class cuml.PCA(*, copy=True, handle=None, iterated_power=15, n_components=None, svd_solver='auto', tol=1e-07, verbose=False, whiten=False, output_type=None)#

PCA（主成分分析）是一种基本的降维技术，用于通过线性组合结合 X 中的特征，使得每个新成分捕获数据中最多的信息或方差。N_components 通常很小，例如为 3，在这种情况下，它可用于数据可视化、数据压缩和探索性分析。

cuML 的 PCA 期望一个类似数组的对象或 cuDF DataFrame，并提供两种算法：Full 和 Jacobi。Full（默认）使用完整的特征分解，然后选择前 K 个特征向量。Jacobi 算法更快，因为它迭代地尝试校正前 K 个奇异向量，但可能精度较低。

参数:

copy布尔值 (默认值 = True): 如果为 True，则复制数据，然后从数据中移除均值。如果为 False，数据可能会被其均值中心化版本覆盖。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
iterated_power整数 (默认值 = 15): 在 Jacobi solver 中使用。迭代次数越多，精度越高，但速度越慢。
n_components整数 (默认值 = None): 您想要的前 K 个奇异向量/值的数量。必须小于或等于列数。如果未设置 n_components，则保留所有成分

n_components = min(n_samples, n_features)
svd_solver‘full’ 或 ‘jacobi’ 或 ‘auto’ (默认值 = ‘full’): Full 使用协方差矩阵的特征分解，然后丢弃成分。Jacobi 更快，因为它迭代地进行校正，但精度较低。
tol浮点数 (默认值 = 1e-7): 如果 algorithm = “jacobi” 则使用。较小的容差可以提高精度，但会减慢算法的收敛速度。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
whiten布尔值 (默认值 = False): 如果为 True，则使成分去相关。这是通过将它们除以相应的奇异值，然后乘以 sqrt(n_samples) 来完成的。白化使每个成分具有单位方差并消除多重共线性。对于 LinearRegression 等下游任务可能有利，因为相关特征会引起问题。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

属性:

components_数组: U, S, VT = svd(X) 中的前 K 个成分 (VT.T[:,:n_components])
explained_variance_数组: 每个成分解释的数据方差量，由 S**2 给出。
explained_variance_ratio_数组: 解释的方差占总方差的百分比，由 S**2/sum(S**2) 给出。
singular_values_数组: 前 K 个奇异值。请记住所有奇异值 >= 0
mean_数组: X 的列均值。首先用于对数据进行均值中心化。
noise_variance_浮点数: 来自 Bishop 1999 年的教科书。用于后续任务，例如计算 X 的估计协方差。

方法

`fit`(X[, y, convert_dtype])	使用 X 拟合模型。y 当前被忽略。
`fit_transform`(X[, y])	使用 X 拟合模型并在 X 上应用降维。
`inverse_transform`(X[, convert_dtype, ...])	将数据转换回其原始空间。
`transform`(X[, convert_dtype])	对 X 应用降维。

get_attr_names

注意

PCA 考虑特征的线性组合，特别是那些最大化全局方差结构的组合。这意味着 PCA 对于全局结构分析非常出色，但对于局部关系较弱。对于局部重要的嵌入，请考虑 UMAP 或 T-SNE。

PCA 的应用

PCA 在实践中广泛用于数据可视化和数据压缩。它已被用于在 2 或 3 维空间可视化 Word2Vec 和 GloVe 等超大词嵌入、日常对象和图像的大型数据集，以及用于区分癌细胞和健康细胞。

更多文档请参阅 scikit-learn 的 PCA。

示例

>>> # Both import methods supported
>>> from cuml import PCA
>>> from cuml.decomposition import PCA

>>> import cudf
>>> import cupy as cp

>>> gdf_float = cudf.DataFrame()
>>> gdf_float['0'] = cp.asarray([1.0,2.0,5.0], dtype = cp.float32)
>>> gdf_float['1'] = cp.asarray([4.0,2.0,1.0], dtype = cp.float32)
>>> gdf_float['2'] = cp.asarray([4.0,2.0,1.0], dtype = cp.float32)

>>> pca_float = PCA(n_components = 2)
>>> pca_float.fit(gdf_float)
PCA()

>>> print(f'components: {pca_float.components_}') 
components: 0           1           2
0  0.69225764  -0.5102837 -0.51028395
1 -0.72165036 -0.48949987  -0.4895003
>>> print(f'explained variance: {pca_float.explained_variance_}')
explained variance: 0   8.510...
1 0.489...
dtype: float32
>>> exp_var = pca_float.explained_variance_ratio_
>>> print(f'explained variance ratio: {exp_var}')
explained variance ratio: 0   0.9456...
1 0.054...
dtype: float32

>>> print(f'singular values: {pca_float.singular_values_}')
singular values: 0 4.125...
1 0.989...
dtype: float32
>>> print(f'mean: {pca_float.mean_}')
mean: 0 2.666...
1 2.333...
2 2.333...
dtype: float32
>>> print(f'noise variance: {pca_float.noise_variance_}') 
noise variance: 0   -7.377287e-08
dtype: float32
>>> trans_gdf_float = pca_float.transform(gdf_float)
>>> print(f'Inverse: {trans_gdf_float}') 
Inverse: 0           1
0   -2.8547091 -0.42891636
1 -0.121316016  0.80743366
2    2.9760244 -0.37851727
>>> input_gdf_float = pca_float.inverse_transform(trans_gdf_float)
>>> print(f'Input: {input_gdf_float}') 
Input: 0         1         2
0 1.0 4.0 4.0
1 2.0 2.0 2.0
2 5.0 1.0 1.0

fit(X, y=None, convert_dtype=True) → PCA[source]#

使用 X 拟合模型。y 当前被忽略。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 包含浮点数或双精度数的密集或稀疏矩阵。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

fit_transform(X, y=None) → CumlArray[source]#

使用 X 拟合模型并在 X 上应用降维。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 包含浮点数或双精度数的密集或稀疏矩阵。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。

返回值:

transcuDF, CuPy 或 NumPy 对象（取决于 cuML 的输出类型配置），稀疏输出为 cupyx.scipy.sparse，形状 = (n_samples, n_components)

转换后的值

有关如何配置 cuML 的密集输出类型的更多信息，请参阅：输出数据类型配置。

inverse_transform(X, convert_dtype=False, return_sparse=False, sparse_tol=1e-10) → CumlArray[source]#

将数据转换回其原始空间。

换句话说，返回一个输入 X_original，其变换结果为 X。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 包含浮点数或双精度数的密集或稀疏矩阵。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtype布尔型, 可选 (默认值 = False): 设置为 True 时，inverse_transform 方法在必要时会将输入转换为用于训练模型的数据类型。这将增加该方法使用的内存。
return_sparse布尔值，可选 (默认值 = False): 模型未在稀疏矩阵上拟合时忽略。如果为 True，该方法会将结果转换为 cupyx.scipy.sparse.csr_matrix 对象。注意：目前，转换为 csr 矩阵时存在信息丢失（cusolver bug）。解决此问题后，默认值将切换为 True。
sparse_tol浮点数，可选 (默认值 = 1e-10): 当 return_sparse=False 时忽略。如果为 True，inverse transform 中小于此参数的值将被截断为 0。

返回值:

X_invcuDF, CuPy 或 NumPy 对象（取决于 cuML 的输出类型配置），稀疏输出为 cupyx.scipy.sparse，形状 = (n_samples, n_features)

转换后的值

有关如何配置 cuML 的密集输出类型的更多信息，请参阅：输出数据类型配置。

transform(X, convert_dtype=True) → CumlArray[source]#

对 X 应用降维。

X 被投影到之前从训练集提取的前几个主成分上。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 包含浮点数或双精度数的密集或稀疏矩阵。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，transform 方法在必要时会将输入转换为用于训练模型的数据类型。这将增加该方法使用的内存。

返回值:

transcuDF, CuPy 或 NumPy 对象（取决于 cuML 的输出类型配置），稀疏输出为 cupyx.scipy.sparse，形状 = (n_samples, n_components)

转换后的值

有关如何配置 cuML 的密集输出类型的更多信息，请参阅：输出数据类型配置。

增量主成分分析#

class cuml.IncrementalPCA(*, handle=None, n_components=None, whiten=False, copy=True, batch_size=None, verbose=False, output_type=None)[source]#

基于 scikit-learn 0.23.1 中的 sklearn.decomposition.IncrementalPCA。

增量主成分分析 (IPCA)。使用数据的奇异值分解进行线性降维，只保留最重要的奇异向量将数据投影到较低维空间。输入数据在应用 SVD 之前对每个特征进行中心化但未缩放。根据输入数据的大小，此算法比 PCA 内存效率高得多，并允许稀疏输入。此算法具有恒定的内存复杂度，约为 batch_size * n_features，支持使用 np.memmap 文件而无需将整个文件加载到内存中。对于稀疏矩阵，输入按批量转换为密集格式（以便能够减去均值），这避免了一次性存储整个密集矩阵。每次 SVD 的计算开销是 O(batch_size * n_features ** 2)，但每次只有 2 * batch_size 个样本保留在内存中。将有 n_samples / batch_size 次 SVD 计算来获取主成分，而 PCA 的 1 次大型 SVD 的复杂度为 O(n_samples * n_features ** 2)。

参数:

handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
n_components整数或 None，(默认值=None): 要保留的成分数量。如果 n_components 为 None，则 n_components 被设置为 min(n_samples, n_features)。
whiten布尔值，可选: 如果为 True，则使成分去相关。这是通过将它们除以相应的奇异值，然后乘以 sqrt(n_samples) 来完成的。白化使每个成分具有单位方差并消除多重共线性。对于 LinearRegression 等下游任务可能有利，因为相关特征会引起问题。
copy布尔值，(默认值=True): 如果为 False，X 将被覆盖。copy=False 可用于节省内存，但不安全，不推荐通用使用。
batch_size整数或 None，(默认值=None): 每个批量使用的样本数量。仅在调用 fit 时使用。如果 batch_size 为 None，则 batch_size 从数据中推断并设置为 5 * n_features，以在近似精度和内存消耗之间取得平衡。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

属性:

components_数组，形状 (n_components, n_features): 方差最大的成分。
explained_variance_数组，形状 (n_components,): 每个选定成分解释的方差。
explained_variance_ratio_数组，形状 (n_components,): 每个选定成分解释的方差百分比。如果所有成分都已存储，解释方差的总和等于 1.0。
singular_values_数组，形状 (n_components,): 每个选定成分对应的奇异值。奇异值等于低维空间中 n_components 个变量的 2-范数。
mean_数组，形状 (n_features,): 每个特征的经验均值，在调用 partial_fit 时进行聚合。
var_数组，形状 (n_features,): 每个特征的经验方差，在调用 partial_fit 时进行聚合。
noise_variance_浮点数: 根据 [4] 中的概率 PCA 模型估计的噪声协方差。
n_components_整数: 估计的成分数量。在 n_components=None 时相关。
每个特征的最大绝对值。: estimator 处理的样本数量。在新的 fit 调用时会重置，但在 partial_fit 调用之间会递增。
batch_size_整数: 从 batch_size 推断的批量大小。

方法

`fit`(X[, y, convert_dtype])	使用 X 拟合模型，使用大小为 batch_size 的小批量。
`partial_fit`(X[, y, check_input])	使用 X 进行增量拟合。
`transform`(X[, convert_dtype])	对 X 应用降维。

注意

实现了 [1] 中的增量 PCA 模型。此模型是 [2] 中 Sequential Karhunen-Loeve Transform 的扩展。我们特意放弃了这两篇论文作者使用的一项优化：在特定情况下使用 QR 分解来降低 SVD 的算法复杂度。此技术的来源是 [3]。省略此技术是因为它仅在分解矩阵时才有利，其中 n_samples >= 5/3 * n_features，而 n_samples 和 n_features 分别是矩阵的行数和列数。此外，它会损害已实现算法的可读性。如果认为有必要，这可能是一个很好的未来优化机会。

参考

[1]

D. Ross, J. Lim, R. Lin, M. Yang. 鲁棒视觉跟踪的增量学习 (Incremental Learning for Robust Visual Tracking), International Journal of Computer Vision, Volume 77, Issue 1-3, pp. 125-141, 2008 年 5 月。

[2]

A. Levy 和 M. Lindenbaum, 序列 Karhunen-Loeve 基提取及其在图像中的应用 (Sequential Karhunen-Loeve Basis Extraction and its Application to Images), IEEE Transactions on Image Processing, Volume 9, Number 8, pp. 1371-1374, 2000 年 8 月。

[3]

G. Golub 和 C. Van Loan. 矩阵计算，第三版 (Matrix Computations, Third Edition), Chapter 5, Section 5.4.4, pp. 252-253。

[4]

C. Bishop, 1999. “模式识别与机器学习” (Pattern Recognition and Machine Learning), Section 12.2.1, pp. 574

示例

>>> from cuml.decomposition import IncrementalPCA
>>> import cupy as cp
>>> import cupyx
>>>
>>> X = cupyx.scipy.sparse.random(1000, 4, format='csr',
...                               density=0.07, random_state=5)
>>> ipca = IncrementalPCA(n_components=2, batch_size=200)
>>> ipca.fit(X)
IncrementalPCA()
>>>
>>> # Components:
>>> ipca.components_ 
array([[ 0.23698335, -0.06073393,  0.04310868,  0.9686547 ],
       [ 0.27040346, -0.57185116,  0.76248786, -0.13594291]])
>>>
>>> # Singular Values:
>>> ipca.singular_values_ 
array([5.06637586, 4.59406975])
>>>
>>> # Explained Variance:
>>> ipca.explained_variance_ 
array([0.02569386, 0.0211266 ])
>>>
>>> # Explained Variance Ratio:
>>> ipca.explained_variance_ratio_ 
array([0.30424536, 0.25016372])
>>>
>>> # Mean:
>>> ipca.mean_ 
array([0.02693948, 0.0326928 , 0.03818463, 0.03861492])
>>>
>>> # Noise Variance:
>>> ipca.noise_variance_.item() 
0.0037122774558343763

fit(X, y=None, convert_dtype=True) → IncrementalPCA[source]#

使用 X 拟合模型，使用大小为 batch_size 的小批量。

参数:

X类似数组的对象或稀疏矩阵，形状 (n_samples, n_features): 训练数据，其中 n_samples 是样本数量，n_features 是特征数量。
yIgnored

返回值:

忽略。: 返回实例本身。

partial_fit(X, y=None, check_input=True) → IncrementalPCA[source]#

使用 X 进行增量拟合。X 的所有部分都作为一个批次进行处理。

参数:

X类似数组的对象或稀疏矩阵，形状 (n_samples, n_features): 训练数据，其中 n_samples 是样本数量，n_features 是特征数量。
check_input布尔值: 在 X 上运行 check_array。
yIgnored

返回值:

忽略。: 返回实例本身。

transform(X, convert_dtype=False) → CumlArray[source]#

对 X 应用降维。

X 被投影到之前从训练集提取的前几个主成分上，如果 X 是稀疏的，则使用大小为 batch_size 的小批量。

参数:

X类似数组的对象或稀疏矩阵，形状 (n_samples, n_features): 新数据，其中 n_samples 是样本数量，n_features 是特征数量。
convert_dtype布尔型, 可选 (默认值 = False): 设置为 True 时，transform 方法将自动将输入转换为用于训练模型的数据类型。这将增加该方法使用的内存。

返回值:

X_new类似数组的对象，形状 (n_samples, n_components)

截断奇异值分解#

class cuml.TruncatedSVD(*, algorithm='full', handle=None, n_components=1, n_iter=15, random_state=None, tol=1e-07, verbose=False, output_type=None)#

TruncatedSVD 用于计算大型矩阵 X 的前 K 个奇异值和向量。当 n_components 很小时，它速度快得多，例如在使用 PCA 时，当使用 3 个成分进行 3D 可视化。

cuML 的 TruncatedSVD 期望一个类似数组的对象或 cuDF DataFrame，并提供两种算法：Full 和 Jacobi。Full（默认）使用完整的特征分解，然后选择前 K 个奇异向量。Jacobi 算法更快，因为它迭代地尝试校正前 K 个奇异向量，但可能精度较低。

参数:

algorithm‘full’ 或 ‘jacobi’ 或 ‘auto’ (默认值 = ‘full’): Full 使用协方差矩阵的特征分解，然后丢弃成分。Jacobi 更快，因为它迭代地进行校正，但精度较低。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
n_components整数 (默认值 = 1): 您想要的前 K 个奇异向量/值的数量。必须小于或等于列数。
n_iter整数 (默认值 = 15): 在 Jacobi solver 中使用。迭代次数越多，精度越高，但速度越慢。
random_state整数 / None (默认值 = None): 如果您希望在重新启动 Python 时结果保持一致，请选择一个状态。
tol浮点数 (默认值 = 1e-7): 如果 algorithm = “jacobi” 则使用。较小的容差可以提高精度，但会减慢算法的收敛速度。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

属性:

components_数组: U, S, VT = svd(X) 中的前 K 个成分 (VT.T[:,:n_components])
explained_variance_数组: 每个成分解释的数据方差量，由 S**2 给出。
explained_variance_ratio_数组: 解释的方差占总方差的百分比，由 S**2/sum(S**2) 给出。
singular_values_数组: 前 K 个奇异值。请记住所有奇异值 >= 0

方法

`fit`(X[, y])	在训练 cudf DataFrame X 上拟合 LSI 模型。y 当前被忽略。
`fit_transform`(X[, y, convert_dtype])	对 X 拟合 LSI 模型并在 X 上执行降维。
`inverse_transform`(X[, convert_dtype])	将 X 转换回其原始空间。
`transform`(X[, convert_dtype])	对 X 执行降维。

get_attr_names

注意

TruncatedSVD（随机化版本 [Jacobi]）在您想要的成分数量远小于特征数量时非常出色。对最大奇异值和向量的近似非常鲁棒，但是，当您想要很多很多成分时，此方法会损失大量精度。

TruncatedSVD 的应用

TruncatedSVD 也被称为 Latent Semantic Indexing (LSI)，它试图找到词计数矩阵的主题。如果 X 之前已经进行了均值移除中心化，则 TruncatedSVD 与 TruncatedPCA 相同。TruncatedSVD 也用于信息检索任务、推荐系统和数据压缩。

更多文档，请参阅 scikit-learn 的 TruncatedSVD 文档。

示例

>>> # Both import methods supported
>>> from cuml import TruncatedSVD
>>> from cuml.decomposition import TruncatedSVD

>>> import cudf
>>> import cupy as cp

>>> gdf_float = cudf.DataFrame()
>>> gdf_float['0'] = cp.asarray([1.0,2.0,5.0], dtype=cp.float32)
>>> gdf_float['1'] = cp.asarray([4.0,2.0,1.0], dtype=cp.float32)
>>> gdf_float['2'] = cp.asarray([4.0,2.0,1.0], dtype=cp.float32)

>>> tsvd_float = TruncatedSVD(n_components = 2, algorithm = "jacobi",
...                           n_iter = 20, tol = 1e-9)
>>> tsvd_float.fit(gdf_float)
TruncatedSVD()
>>> print(f'components: {tsvd_float.components_}') 
components:           0         1         2
0  0.587259  0.572331  0.572331
1  0.809399 -0.415255 -0.415255
>>> exp_var = tsvd_float.explained_variance_
>>> print(f'explained variance: {exp_var}')
explained variance: 0    0.494...
1    5.505...
dtype: float32
>>> exp_var_ratio = tsvd_float.explained_variance_ratio_
>>> print(f'explained variance ratio: {exp_var_ratio}')
explained variance ratio: 0    0.082...
1    0.917...
dtype: float32
>>> sing_values = tsvd_float.singular_values_
>>> print(f'singular values: {sing_values}')
singular values: 0    7.439...
1    4.081...
dtype: float32

>>> trans_gdf_float = tsvd_float.transform(gdf_float)
>>> print(f'Transformed matrix: {trans_gdf_float}') 
Transformed matrix:           0         1
0  5.165910 -2.512643
1  3.463844 -0.042223
2  4.080960  3.216484
>>> input_gdf_float = tsvd_float.inverse_transform(trans_gdf_float)
>>> print(f'Input matrix: {input_gdf_float}')
Input matrix:      0    1    2
0  1.0  4.0  4.0
1  2.0  2.0  2.0
2  5.0  1.0  1.0

fit(X, y=None) → TruncatedSVD[source]#

在训练 cudf DataFrame X 上拟合 LSI 模型。y 当前被忽略。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。

fit_transform(X, y=None, convert_dtype=True) → CumlArray[source]#

对 X 拟合 LSI 模型并在 X 上执行降维。y 当前被忽略。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，fit_transform 方法在必要时会将输入转换为用于训练模型的数据类型。这将增加该方法使用的内存。

返回值:

transcuDF, CuPy 或 NumPy 对象（取决于 cuML 的输出类型配置），形状 = (n_samples, n_components)

X 的降维版本

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

inverse_transform(X, convert_dtype=False) → CumlArray[source]#

将 X 转换回其原始空间。返回变换结果为 X 的 X_original。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtype布尔型, 可选 (默认值 = False): 设置为 True 时，inverse_transform 方法在必要时会将输入转换为用于训练模型的数据类型。这将增加该方法使用的内存。

返回值:

X_originalcuDF, CuPy 或 NumPy 对象（取决于 cuML 的输出类型配置），形状 = (n_samples, n_features)

原始空间中的 X

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

transform(X, convert_dtype=True) → CumlArray[source]#

对 X 执行降维。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，transform 方法在必要时会将输入转换为用于训练模型的数据类型。这将增加该方法使用的内存。

返回值:

X_newcuDF, CuPy 或 NumPy 对象（取决于 cuML 的输出类型配置），形状 = (n_samples, n_components)

X 的降维版本

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

UMAP#

class cuml.UMAP(*, n_neighbors=15, n_components=2, metric='euclidean', metric_kwds=None, n_epochs=None, learning_rate=1.0, min_dist=0.1, spread=1.0, set_op_mix_ratio=1.0, local_connectivity=1.0, repulsion_strength=1.0, negative_sample_rate=5, transform_queue_size=4.0, init='spectral', a=None, b=None, target_n_neighbors=-1, target_weight=0.5, target_metric='categorical', hash_input=False, random_state=None, precomputed_knn=None, callback=None, handle=None, verbose=False, build_algo='auto', build_kwds=None, output_type=None)#

均匀流形逼近和投影

找到数据的低维嵌入，以逼近底层流形。

改编自 lmcinnes/umap umap.py

UMAP 算法在 [1] 中概述。此实现遵循 [2] 中描述的 GPU 加速版本。

参数:

n_neighbors: float (可选, 默认 15)

用于流形逼近的局部邻域的大小（以邻近样本点的数量计）。较大的值会导致对流形有更全局的视图，而较小的值会保留更多局部数据。通常值应在 2 到 100 的范围内。

n_components: int (可选, 默认 2)

嵌入空间的维度。默认设置为 2 以方便可视化，但可以合理地设置为任意值

metric: string (默认=’euclidean’)。

使用的距离度量。支持的距离包括 [‘l1, ‘cityblock’, ‘taxicab’, ‘manhattan’, ‘euclidean’, ‘l2’, ‘sqeuclidean’, ‘canberra’, ‘minkowski’, ‘chebyshev’, ‘linf’, ‘cosine’, ‘correlation’, ‘hellinger’, ‘hamming’, ‘jaccard’] 需要参数（如 minkowski）的度量可以通过 metric_kwds 字典传递参数。注意：‘jaccard’ 距离度量仅支持稀疏输入。

metric_kwds: dict (可选, 默认 None)

度量参数

n_epochs: int (可选, 默认 None)

用于优化低维嵌入的训练 epoch 数。较大的值会产生更准确的嵌入。如果指定为 None，将根据输入数据集的大小选择一个值（大型数据集为 200，小型数据集为 500）。

learning_rate: float (可选, 默认 1.0)

嵌入优化的初始学习率。

init: string (可选, 默认 ‘spectral’)

如何初始化低维嵌入。选项有

‘spectral’：使用模糊 1-骨架的谱嵌入
‘random’：随机分配初始嵌入位置。

min_dist: float (可选, 默认 0.1)

嵌入点之间的有效最小距离。较小的值会产生更密集/簇状的嵌入，其中流形上附近的点被拉得更近，而较大的值会导致点分布更均匀。该值应相对于 spread 值设置，spread 值决定了嵌入点的散布尺度。

spread: float (可选, 默认 1.0)

嵌入点的有效尺度。与 min_dist 结合使用，这决定了嵌入点的密集/簇状程度。

set_op_mix_ratio: float (可选, 默认 1.0)

在用于组合局部模糊单纯形集以获得全局模糊单纯形集的集合运算中，插值（模糊）并集和交集之间。两种模糊集合运算都使用乘积 t-模。此参数的值应在 0.0 和 1.0 之间；1.0 的值将使用纯模糊并集，而 0.0 的值将使用纯模糊交集。

local_connectivity: int (可选, 默认 1)

所需的局部连通性——即在局部级别应假定连接的最近邻居数量。该值越高，流形在局部变得越连通。实际上，该值不应超过流形的局部内在维度。

repulsion_strength: float (可选, 默认 1.0)

在低维嵌入优化中应用于负样本的权重。大于 1 的值将导致负样本被赋予更大的权重。

negative_sample_rate: int (可选, 默认 5)

优化过程中每个正样本选择的负样本数量。增加此值将导致施加更大的排斥力，产生更大的优化成本，但准确性略有提高。

transform_queue_size: float (可选, 默认 4.0)

对于转换操作（使用训练模型嵌入新点），这将控制搜索最近邻居的积极程度。较大的值会导致性能变慢，但最近邻居评估更准确。

a: float (可选, 默认 None)

控制嵌入的更具体参数。如果为 None，这些值将根据 min_dist 和 spread 自动设置。

b: float (可选, 默认 None)

控制嵌入的更具体参数。如果为 None，这些值将根据 min_dist 和 spread 自动设置。

hash_input: bool, 可选 (默认 = False)

UMAP 可以对训练输入进行哈希处理，以便在对模型训练所用的相同数据调用 transform 时返回精确的嵌入。这使得调用 model.fit_transform(X) 和调用 model.fit(X).transform(X) 之间具有一致的行为。请注意，基于 CPU 的 UMAP 参考实现默认执行此操作。此功能在 GPU 版本中被设为可选，因为将内存复制到主机计算哈希会产生显著开销。

precomputed_knnarray / sparse array / tuple, 可选 (设备或主机)

可以是形状为 (n_samples, n_neighbors) 的数组元组 (indices, distances)，形状为 (n_samples, n_samples) 的成对距离密集数组，或 KNN 图稀疏数组（首选 CSR/COO）。此功能允许在 UMAP 外部预计算 KNN，也允许使用自定义距离函数。此函数应与训练 UMAP 嵌入所用的度量相匹配。

random_stateint, RandomState instance or None, optional (default=None)

random_state 是嵌入初始化期间和优化器使用的采样期间由随机数生成器使用的种子。注意：不幸的是，在优化阶段实现高度并行性通常会牺牲确定性，因为许多浮点加法是并行进行的，没有确定的顺序。这会导致跨训练会话的结果略有不同，即使使用相同的种子进行随机数生成也是如此。设置 random_state 将使训练后的嵌入具有一致性，允许结果精确到 3 位小数可复现，但这可能会牺牲训练速度并增加内存使用。

callback: GraphBasedDimRedCallback 类的一个实例

用于在嵌入训练期间拦截嵌入的内部状态。回调用法示例

from cuml.internals import GraphBasedDimRedCallback

class CustomCallback(GraphBasedDimRedCallback):
    def on_preprocess_end(self, embeddings):
        print(embeddings.copy_to_host())

    def on_epoch_end(self, embeddings):
        print(embeddings.copy_to_host())

    def on_train_end(self, embeddings):
        print(embeddings.copy_to_host())

handlecuml.Handle

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

build_algo: string (默认=’auto’)

如何构建 knn 图。支持的构建算法有 [‘auto’, ‘brute_force_knn’, ‘nn_descent’]。如果数据行数小于或等于 50K，‘auto’ 选择使用暴力 knn 运行。否则，使用 nn descent 运行。

build_kwds: dict (可选, 默认 None)

构建算法参数 {‘nnd_graph_degree’: 64, ‘nnd_intermediate_graph_degree’: 128, ‘nnd_max_iterations’: 20, ‘nnd_termination_threshold’: 0.0001, ‘nnd_return_distances’: True, ‘nnd_n_clusters’: 1} 请注意，nnd_n_clusters > 1 将导致使用 NN Descent 进行批量构建。

属性:

embedding_

方法

`fit`(X[, y, convert_dtype, knn_graph, ...])	将 X 拟合到嵌入空间。
`fit_transform`(X[, y, convert_dtype, ...])	将 X 拟合到嵌入空间并返回转换后的
`gpu_to_cpu`()	将属性从 GPU 估计器转移到 CPU 估计器。
`transform`(X[, convert_dtype])	T

find_ab_params
get_attr_names
validate_hyperparams

注意

此模块主要基于 Leland McInnes 的参考 UMAP 包。但是，cuml.umap 中尚有许多差异和未实现的功能

使用预计算的成对距离矩阵（未来版本考虑实现）
手动初始化初始嵌入位置

除了这些缺失的功能外，您应该会看到 cuml.umap 和参考 UMAP 之间的最终嵌入结果不同。

参考

[1]

Leland McInnes, John Healy, James Melville UMAP: 均匀流形逼近和投影用于降维

[2]

Corey Nolet, Victor Lafargue, Edward Raff, Thejaswi Nanditale, Tim Oates, John Zedlewski, Joshua Patterson 利用 GPU 加速使 UMAP 更接近光速

fit(X, y=None, convert_dtype=True, knn_graph=None, data_on_host=False) → UMAP[source]#

将 X 拟合到嵌入空间。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 包含浮点数或双精度数的密集或稀疏矩阵。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，该方法将自动把输入转换为 np.float32。
knn_grapharray / sparse array / tuple, 可选 (设备或主机): 可以是形状为 (n_samples, n_neighbors) 的数组元组 (indices, distances)，形状为 (n_samples, n_samples) 的成对距离密集数组，或 KNN 图稀疏数组（首选 CSR/COO）。此功能允许在 UMAP 外部预计算 KNN，也允许使用自定义距离函数。此函数应与训练 UMAP 嵌入所用的度量相匹配。此参数优先于 precomputed_knn 参数。

fit_transform(X, y=None, convert_dtype=True, knn_graph=None, data_on_host=False) → CumlArray[source]#

将 X 拟合到嵌入空间并返回转换后的输出。

调用 fit_transform(X) 和调用 fit().transform() 之间存在细微差异。调用 fit_transform(X) 将在 X 上训练嵌入并返回嵌入结果。调用 fit(X).transform(X) 将在 X 上训练嵌入，然后运行第二次优化。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，该方法将自动把输入转换为 np.float32。
knn_graphsparse array-like (设备或主机): 形状=(n_samples, n_samples) 包含 X 的 k-最近邻居的稀疏数组，其中列是每行的最近邻居索引，值是它们的距离。重要的是 k>=n_neighbors，这样 UMAP 就可以从该图建模邻居，而不是在内部构建自己的图。使用 knn_graph 参数的用户为 UMAP 提供了他们自己的 KNN 算法运行结果。这允许用户选择自定义距离函数（有时在某些数据集上很有用），而 UMAP 默认使用欧几里得距离。自定义距离函数应与训练 UMAP 嵌入所用的度量相匹配。存储和重用 knn_graph 在执行网格搜索时也会加快 UMAP 算法的速度。可接受的格式：稀疏 SciPy ndarray，CuPy 设备 ndarray，首选 CSR/COO，其他格式将转换为 CSR

返回值:

X_newcuDF, CuPy 或 NumPy 对象（取决于 cuML 的输出类型配置），形状 = (n_samples, n_components)

数据在低维空间中的嵌入。

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

gpu_to_cpu()[source]#: 将属性从 GPU 估计器转移到 CPU 估计器。

transform(X, convert_dtype=True) → CumlArray[source]#

T

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features)

convert_dtype布尔值，可选 (默认值 = True)

设置为 True 时，该方法将自动把输入转换为 np.float32。

将 X 转换到现有的嵌入空间并返回

转换后的输出。

有关 fit_transform() 和运行 fit() transform() 之间差异的信息，请参阅参考 UMAP 实现。

具体来说，transform() 函数是随机的：lmcinnes/umap#158

返回值:

X_newcuDF, CuPy 或 NumPy 对象（取决于 cuML 的输出类型配置），形状 = (n_samples, n_components)

数据在低维空间中的嵌入。

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

cuml.manifold.umap.fuzzy_simplicial_set(X, n_neighbors, random_state=None, metric='euclidean', metric_kwds=None, knn_indices=None, knn_dists=None, set_op_mix_ratio=1.0, local_connectivity=1.0, verbose=False)[source]#

给定数据集 X、邻域大小和距离度量，计算与数据关联的模糊单纯形集（此处表示为稀疏矩阵形式的模糊图）。这是通过在每个点局部逼近测地线距离，为每个点创建模糊单纯形集，然后通过模糊并集将所有局部模糊单纯形集组合成一个全局集来完成的。

参数:

X: 形状为 (n_samples, n_features) 的数组: 要建模为模糊单纯形集的数据。
n_neighbors: int: 用于逼近测地线距离的邻居数量。较大的数量会产生对流形更全局的估计，可能错过更精细的细节，而较小的值将侧重于精细的流形结构，但可能牺牲大局观。
random_state: numpy RandomState 或等效类型: 一个可用作 numpy random state 的状态。
metric: string (默认=’euclidean’)。: 使用的距离度量。支持的距离包括 [‘l1, ‘cityblock’, ‘taxicab’, ‘manhattan’, ‘euclidean’, ‘l2’, ‘sqeuclidean’, ‘canberra’, ‘minkowski’, ‘chebyshev’, ‘linf’, ‘cosine’, ‘correlation’, ‘hellinger’, ‘hamming’, ‘jaccard’] 需要参数（如 minkowski）的度量可以通过 metric_kwds 字典传递参数。注意：‘jaccard’ 距离度量仅支持稀疏输入。
metric_kwds: dict (可选, 默认 None): 度量参数
knn_indices: 形状为 (n_samples, n_neighbors) 的数组 (可选): 如果已经计算了每个点的 k-最近邻居，可以在此处传入以节省计算时间。这应该是一个数组，其中每一行是数据点的 k-最近邻居的索引。
knn_dists: 形状为 (n_samples, n_neighbors) 的数组 (可选): 如果已经计算了每个点的 k-最近邻居，可以在此处传入以节省计算时间。这应该是一个数组，其中每一行是数据点的 k-最近邻居的距离。
set_op_mix_ratio: float (可选, 默认 1.0): 在用于组合局部模糊单纯形集以获得全局模糊单纯形集的集合运算中，插值（模糊）并集和交集之间。两种模糊集合运算都使用乘积 t-模。此参数的值应在 0.0 和 1.0 之间；1.0 的值将使用纯模糊并集，而 0.0 的值将使用纯模糊交集。
local_connectivity: int (可选, 默认 1): 所需的局部连通性——即在局部级别应假定连接的最近邻居数量。该值越高，流形在局部变得越连通。实际上，该值不应超过流形的局部内在维度。
verbose: bool (可选, 默认 False): 是否报告算法当前进度信息。
返回值
——-
fuzzy_simplicial_set: coo_matrix: 表示为稀疏矩阵的模糊单纯形集。矩阵的 (i, j) 条目表示第 i 个和第 j 个样本点之间 1-单形的成员强度。

cuml.manifold.umap.simplicial_set_embedding(data, graph, n_components=2, initial_alpha=1.0, a=None, b=None, gamma=1.0, negative_sample_rate=5, n_epochs=None, init='spectral', random_state=None, metric='euclidean', metric_kwds=None, output_metric='euclidean', output_metric_kwds=None, convert_dtype=True, verbose=False)[source]#

执行模糊单纯形集嵌入，使用指定的初始化方法，然后最小化高维和低维模糊单纯形集 1-骨架之间的模糊集交叉熵。

参数:

data: 形状为 (n_samples, n_features) 的数组

UMAP 要嵌入的源数据。

graph: 稀疏矩阵

高维模糊单纯形集的 1-骨架，表示为一个图，我们需要其（加权）邻接矩阵的稀疏矩阵。

n_components: int

将数据嵌入到的欧几里得空间的维度。

initial_alpha: float

SGD 的初始学习率。

a: float

右伴随函子的可微逼近参数

b: float

右伴随函子的可微逼近参数

gamma: float

应用于负样本的权重。

negative_sample_rate: int (可选, 默认 5)

优化过程中每个正样本选择的负样本数量。增加此值将导致施加更大的排斥力，产生更大的优化成本，但准确性略有提高。

n_epochs: int (可选, 默认 0)

用于优化低维嵌入的训练 epoch 数。较大的值会产生更准确的嵌入。如果指定为 0，将根据输入数据集的大小选择一个值（大型数据集为 200，小型数据集为 500）。

init: string

如何初始化低维嵌入。选项有

‘spectral’：使用模糊 1-骨架的谱嵌入
‘random’：随机分配初始嵌入位置。
具有初始嵌入位置的类数组对象。

random_state: numpy RandomState 或等效类型

一个可用作 numpy random state 的状态。

metric: string (默认=’euclidean’)。

metric_kwds: dict (可选, 默认 None)

度量参数

output_metric: function

返回嵌入空间中两点之间距离以及距离对第一个参数的梯度的函数。

output_metric_kwds: dict

要传递给 output_metric 函数的关键字参数。

verbose: bool (可选, 默认 False)

是否报告算法当前进度信息。

返回值

——-

embedding: 形状为 (n_samples, n_components) 的数组

将 graph 优化到 n_components 维欧几里得空间。

随机投影#

class cuml.random_projection.GaussianRandomProjection(*, handle=None, n_components='auto', eps=0.1, random_state=None, verbose=False, output_type=None)#

衍生自 BaseRandomProjection 类的 Gaussian Random Projection 方法。

随机投影是一种降维技术。随机投影方法因其简单性、计算效率高和模型规模受限而闻名。该算法还具有良好地保留任意两个样本之间距离的优点，因此适用于具有此要求的方法。

随机矩阵的分量从 N(0, 1 / n_components) 中抽取。

参数:

handlecuml.Handle

n_componentsint (默认 = ‘auto’)

目标投影空间的维度。如果设置为 'auto'，该参数将根据 Johnson-Lindenstrauss 引理推导得出。自动推导利用了样本数量和 eps 参数。

Johnson-Lindenstrauss 引理可能产生非常保守的 n_components 参数，因为它对数据集结构不做任何假设。

epsfloat (默认 = 0.1)

投影期间的误差容忍度。当 n_components 设置为 'auto' 时，由 Johnson-Lindenstrauss 自动推导使用。

random_stateint (default = None)

用于初始化随机生成器的种子

verboseint 或 boolean，默认值=False

设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None

属性:

gaussian_methodboolean: 传递给基类以确定随机矩阵生成方法

注意

此类别无法与 sklearn.base.clone() 一起使用，调用时将引发异常。

灵感来自于 Scikit-learn 的实现：https://scikit-learn.cn/stable/modules/random_projection.html

示例

from cuml.random_projection import GaussianRandomProjection
from sklearn.datasets import make_blobs
from sklearn.svm import SVC

# dataset generation
data, target = make_blobs(n_samples=800, centers=400, n_features=3000,
                          random_state=42)

# model fitting
model = GaussianRandomProjection(n_components=5,
                                 random_state=42).fit(data)

# dataset transformation
transformed_data = model.transform(data)

# classifier training
classifier = SVC(gamma=0.001).fit(transformed_data, target)

# classifier scoring
score = classifier.score(transformed_data, target)

# measure information preservation
print("Score: {}".format(score))

输出

Score: 1.0

class cuml.random_projection.SparseRandomProjection(*, handle=None, n_components='auto', density='auto', eps=0.1, dense_output=True, random_state=None, verbose=False, output_type=None)#

衍生自 BaseRandomProjection 类的 Sparse Random Projection 方法。

稀疏随机矩阵是密集随机投影矩阵（例如高斯）的替代方法，它保证了相似的嵌入质量，同时内存效率更高，并允许更快地计算投影数据（对于足够稀疏的矩阵）。如果我们记 s = 1 / density，则随机矩阵的分量从中抽取

-sqrt(s) / sqrt(n_components) - 概率为 1 / 2s
0 - 概率为 1 - 1 / s
+sqrt(s) / sqrt(n_components) - 概率为 1 / 2s

参数:

handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
n_componentsint (默认 = ‘auto’): 目标投影空间的维度。如果设置为 'auto'，该参数将根据 Johnson-Lindenstrauss 引理推导得出。自动推导利用了样本数量和 eps 参数。Johnson-Lindenstrauss 引理可能产生非常保守的 n_components 参数，因为它对数据集结构不做任何假设。
densityfloat 在范围 (0, 1] 内 (默认 = ‘auto’): 随机投影矩阵中非零分量的比率。如果 density = ‘auto’，该值将设置为 Ping Li 等人推荐的最小密度：1 / sqrt(n_features)。
epsfloat (默认 = 0.1): 投影期间的误差容忍度。当 n_components 设置为 'auto' 时，由 Johnson-Lindenstrauss 自动推导使用。
dense_outputboolean (默认 = True): 如果设置为 True，转换后的矩阵将是密集的，否则是稀疏的。
random_stateint (default = None): 用于初始化随机生成器的种子
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

属性:

gaussian_methodboolean: 传递给基类以确定随机矩阵生成方法

注意

此类别无法与 sklearn.base.clone() 一起使用，调用时将引发异常。

灵感来自于 Scikit-learn 的实现。

示例

from cuml.random_projection import SparseRandomProjection
from sklearn.datasets import make_blobs
from sklearn.svm import SVC

# dataset generation
data, target = make_blobs(n_samples=800, centers=400, n_features=3000,
                          random_state=42)

# model fitting
model = SparseRandomProjection(n_components=5,
                               random_state=42).fit(data)

# dataset transformation
transformed_data = model.transform(data)

# classifier training
classifier = SVC(gamma=0.001).fit(transformed_data, target)

# classifier scoring
score = classifier.score(transformed_data, target)

# measure information preservation
print("Score: {}".format(score))

输出

Score: 1.0

cuml.random_projection.johnson_lindenstrauss_min_dim(n_samples, eps=0.1)[source]#

在数学中，Johnson-Lindenstrauss 引理指出，高维数据可以嵌入到较低维度空间，同时保持距离。

设 p 为随机投影：(1 - eps) ||u - v||^2 < ||p(u) - p(v)||^2 < (1 + eps) ||u - v||^2

此函数找到保证嵌入在 eps 误差容限内的最小分量数量。

参数:

n_samplesint: 样本数量。
epsfloat 在 (0,1) 范围内 (默认 = 0.1): 由 Johnson-Lindenstrauss 引理定义的最大失真率。

返回值:

n_componentsint: 为了以高概率保证 n_samples 的 eps-嵌入所需的最小分量数量。

TSNE#

class cuml.TSNE(*, n_components=2, perplexity=30.0, early_exaggeration=12.0, late_exaggeration=1.0, learning_rate=200.0, n_iter=1000, n_iter_without_progress=300, min_grad_norm=1e-07, metric='euclidean', metric_params=None, init='random', verbose=False, random_state=None, method='fft', angle=0.5, learning_rate_method='adaptive', n_neighbors=90, perplexity_max_iter=100, exaggeration_iter=250, pre_momentum=0.5, post_momentum=0.8, square_distances=True, precomputed_knn=None, handle=None, output_type=None)#

t-SNE (T 分布随机邻居嵌入) 是一种非常强大的降维技术，旨在保持数据点之间的局部距离。它对任何给定的数据集都非常鲁棒，并被用于许多领域，包括癌症研究、音乐分析和神经网络权重可视化。

cuML 的 t-SNE 支持三种算法：原始精确算法、Barnes-Hut 近似算法和快速傅里叶变换插值近似算法。后两种算法源自 CannyLabs 的开源 CUDA 代码，并在 n_components = 2 时产生极快的嵌入。精确算法更准确，但对于大型数据集来说太慢。

参数:

n_componentsint (默认 2): 输出维度大小。目前仅支持 2。
perplexityfloat (默认 30.0): 大型数据集需要较大的值。考虑选择 5 到 50 之间不同的 perplexity 值，并查看输出差异。
early_exaggerationfloat (默认 12.0): 控制簇之间的空间。调整此参数并非关键。
late_exaggerationfloat (默认 1.0): 控制簇之间的空间。适度增加此值可能有助于改善簇的分离。此参数将在 exaggeration_iter 迭代后应用（仅限 FFT）。
learning_ratefloat (默认 200.0): 学习率通常在 (10, 1000) 之间。如果学习率过高，t-SNE 结果可能看起来像一团点/一个球。
n_iterint (默认 1000): epoch 数越多，最终嵌入越稳定/准确。
n_iter_without_progressint (默认 300): 当前未使用。当 KL 散度在若干次迭代后变得过小时，提前终止 t-SNE。
min_grad_normfloat (默认 1e-07): t-SNE 提前终止的最小梯度范数。用于 ‘exact’ 和 ‘fft’ 算法。如果嵌入结果不令人满意，请考虑减小此值。建议对于较小的数据集使用较小的值。
metricstr (默认=’euclidean’)。: 使用的距离度量。支持的距离包括 [‘l1, ‘cityblock’, ‘manhattan’, ‘euclidean’, ‘l2’, ‘sqeuclidean’, ‘minkowski’, ‘chebyshev’, ‘cosine’, ‘correlation’]
initstr ‘random’ 或 ‘pca’ (默认 ‘random’): 目前支持 random 或 pca 初始化。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
random_stateint (默认 None): 设置此参数可以使重复运行的结果看起来更相似。但是请注意，即使使用相同的 random_state，此高度并行的 t-SNE 实现也不能完全保证多次运行结果完全确定。
methodstr ‘fft’, ‘barnes_hut’ 或 ‘exact’ (默认 ‘fft’): ‘barnes_hut’ 和 ‘fft’ 是快速近似算法。‘exact’ 更准确但速度较慢。
anglefloat (默认 0.5): 有效值在 0.0 到 1.0 之间，分别权衡速度和精度。通常，这些值设置在 0.2 到 0.8 之间。（仅限 Barnes-Hut。）
learning_rate_methodstr ‘adaptive’, ‘none’ 或 None (默认 ‘adaptive’): 可以是 adaptive 或 None。‘adaptive’ 根据输入大小自动调整学习率、early exaggeration、perplexity 和 n_neighbors。
n_neighborsint (默认 90): 在吸引力中要使用的数据点数量。较小的值更适合保留局部结构，而较大的值可以改善全局结构的保留。默认值为 3 * 30 (perplexity)
perplexity_max_iterint (默认 100): 找到最佳高斯波段的 epoch 数。
exaggeration_iterint (默认 250): 为了促进簇的增长，将此值设置得更高。
pre_momentumfloat (默认 0.5): 在 exaggeration 迭代期间，更有力地应用梯度。
post_momentumfloat (默认 0.8): 在后期阶段，较不强力地应用梯度。
square_distancesboolean, 默认=True: TSNE 是否应该对距离值进行平方。在内部，这将用于使用提供的度量计算 kNN 图，并在 True 时对其进行平方。如果将 knn_graph 传递给 fit 或 fit_transform 方法，当 True 时所有距离都会被平方。例如，如果使用 ‘sqeuclidean’ 度量获得了 knn_graph，当 True 时距离仍会被平方。注意：对于 ‘euclidean’ 和 ‘l2’ 以外的距离度量，此参数可能应设置为 False。
precomputed_knnarray / sparse array / tuple, 可选 (设备或主机): 可以是形状为 (n_samples, n_neighbors) 的数组元组 (indices, distances)，形状为 (n_samples, n_samples) 的成对距离密集数组，或 KNN 图稀疏数组（首选 CSR/COO）。此功能允许在 TSNE 外部预计算 KNN，也允许使用自定义距离函数。此函数应与训练 TSNE 嵌入所用的度量相匹配。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

属性:

kl_divergence_float: 优化后的 Kullback-Leibler 散度。目前是一个实验性功能。

方法

`fit`(X[, y, convert_dtype, knn_graph])	将 X 拟合到嵌入空间。
`fit_transform`(X[, y, convert_dtype, knn_graph])	从特征执行层次聚类。

get_attr_names

参考

[1]

van der Maaten, L.J.P. t-分布随机邻居嵌入

[2]

van der Maaten, L.J.P.; Hinton, G.E. 使用 t-SNE 可视化高维数据。Journal of Machine Learning Research 9:2579-2605, 2008.

[3]

George C. Linderman, Manas Rachh, Jeremy G. Hoskins, Stefan Steinerberger, Yuval Kluger t-分布随机邻居嵌入的高效算法

提示

Maaten 和 Linderman 展示了 t-SNE 如何对起始条件（即随机初始化）非常敏感，以及并行版本的 t-SNE 如何在多次运行之间产生巨大差异的结果。您可以多次运行 t-SNE 来确定最佳配置。请注意，即使在多次运行中使用相同的 random_state，也不能保证每次都获得相似的结果。

注意

CUDA 实现源自优秀的 CannyLabs 开源实现：CannyLab/tsne-cuda。CannyLabs 代码根据 cuml/cpp/src/tsne/cannylabs_tsne_license.txt 中的条件获得许可。他们方法的完整描述可在其文章 t-SNE-CUDA: GPU-Accelerated t-SNE and its Applications to Modern Data (https://arxiv.org/abs/1807.11824) 中找到。

fit(X, y=None, convert_dtype=True, knn_graph=None) → TSNE[source]#

将 X 拟合到嵌入空间。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 包含浮点数或双精度数的密集或稀疏矩阵。可接受的密集格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，该方法将自动把输入转换为 np.float32。
knn_grapharray / sparse array / tuple, 可选 (设备或主机): 可以是形状为 (n_samples, n_neighbors) 的数组元组 (indices, distances)，形状为 (n_samples, n_samples) 的成对距离密集数组，或 KNN 图稀疏数组（首选 CSR/COO）。此功能允许在 TSNE 外部预计算 KNN，也允许使用自定义距离函数。此函数应与训练 TSNE 嵌入所用的度量相匹配。此参数优先于 precomputed_knn 参数。

fit_transform(X, y=None, convert_dtype=True, knn_graph=None) → CumlArray[source]#

从特征执行层次聚类。

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类似数组的对象（设备或主机），形状 = (n_samples, 1): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
convert_dtype布尔值，可选 (默认值 = True): 设置为 True 时，该方法将自动把输入转换为 np.float32。

到嵌入空间并返回转换后的输出。

返回值:

X_newcuDF, CuPy 或 NumPy 对象（取决于 cuML 的输出类型配置），形状 = (n_samples, n_components)

数据在低维空间中的嵌入。

有关如何配置 cuML 输出类型的更多信息，请参阅：Output Data Type Configuration。

邻居#

核密度估计#

class cuml.neighbors.KernelDensity(*, bandwidth=1.0, kernel='gaussian', metric='euclidean', metric_params=None, output_type=None, handle=None, verbose=False)[source]#

核密度估计。从有限数据样本计算非参数密度估计，根据带宽参数平滑估计结果。

参数:

bandwidthfloat, default=1.0: 核的带宽。
kernel{‘gaussian’, ‘tophat’, ‘epanechnikov’, ‘exponential’, ‘linear’, ‘cosine’}, default=’gaussian’: 要使用的核。
metricstr, default=’euclidean’: 要使用的距离度量。请注意，并非所有度量都适用于所有算法。请注意，密度输出的归一化仅对于欧几里得距离度量是正确的。默认值为 'euclidean'。
metric_paramsdict, default=None: 要传递给树以与度量一起使用的附加参数。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

方法

`fit`(X[, y, sample_weight, convert_dtype])	在数据上拟合核密度模型。
`sample`([n_samples, random_state])	从模型生成随机样本。
`score`(X[, y])	计算模型下的总对数似然。
`score_samples`(X[, convert_dtype])	计算模型下每个样本的对数似然。

示例

>>> from cuml.neighbors import KernelDensity
>>> import cupy as cp
>>> rng = cp.random.RandomState(42)
>>> X = rng.random_sample((100, 3))
>>> kde = KernelDensity(kernel='gaussian', bandwidth=0.5).fit(X)
>>> log_density = kde.score_samples(X[:3])

fit(X, y=None, sample_weight=None, convert_dtype=True)[source]#

在数据上拟合核密度模型。

参数:

X形状为 (n_samples, n_features) 的 array-like 对象: n_features 维数据点的列表。每行对应一个数据点。
yNone: 用于计算按特征轴进行后续缩放的均值和标准差的数据。
sample_weight形状为 (n_samples,) 的类数组对象, 默认=None: 附加到数据 X 的样本权重列表。

返回值:

忽略。: 返回实例本身。

sample(n_samples=1, random_state=None)[source]#

从模型生成随机样本。目前，仅针对高斯核和顶帽核以及欧几里得度量实现了此功能。

参数:

n_samplesint, default=1: 要生成的样本数。
random_stateint, cupy RandomState instance or None, default=None

返回值:

Xcupy array of shape (n_samples, n_features): 样本列表。

score(X, y=None)[source]#

计算模型下的总对数似然。

参数:

X形状为 (n_samples, n_features) 的 array-like 对象: n_features 维数据点的列表。每行对应一个数据点。
yNone: 用于计算按特征轴进行后续缩放的均值和标准差的数据。

返回值:

logprobfloat: X 中数据的总对数似然。这被归一化为概率密度，因此对于高维数据，该值将较低。

score_samples(X, convert_dtype=True)[source]#

计算模型下每个样本的对数似然。

参数:

X形状为 (n_samples, n_features) 的 array-like 对象: 要查询的点数组。最后一个维度应与训练数据的维度（n_features）匹配。

返回值:

densityndarray of shape (n_samples,): X 中每个样本的对数似然。这些被归一化为概率密度，因此对于高维数据，值将较低。

时间序列#

霍尔特-温特斯 (HoltWinters)#

class cuml.ExponentialSmoothing(endog, *, seasonal='additive', seasonal_periods=2, start_periods=2, ts_num=1, eps=0.00224, handle=None, verbose=False, output_type=None)#

实现了霍尔特-温特斯时间序列分析模型，该模型用于预测时间序列中的未来条目以及提供指数平滑，其中权重按指数衰减的影响分配给历史数据。这是通过分析数据的三个组成部分来完成的：水平 (level)、趋势 (trend) 和季节性 (seasonality)。

参数:

endogarray-like (device or host): 可接受的格式：cuDF DataFrame, cuDF Series, NumPy ndarray, Numba device ndarray, 符合 cuda array interface 的数组（如 CuPy）。注意：cuDF.DataFrame 类型假定数据在列中，而所有其他数据类型假定数据在行中。要操作的内生数据集。
seasonal‘additive’, ‘add’, ‘multiplicative’, ‘mul’ (default = ‘additive’): 季节性趋势是应以加法还是乘法方式计算。
seasonal_periodsint (default=2): 数据的季节性（重复频率）。对于月度数据应为 12，对于周度数据应为 7。
start_periodsint (default=2): 用于季节性种子值的季节数量
ts_numint (default=1): 在 endog 参数中传递的不同时间序列的数量。
epsnp.number > 0 (default=2.24e-3): 梯度下降应达到的精度。请注意，更改此值可能会影响预测结果。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

属性:

SSE
forecasted_points
level
season
trend

方法

`fit`()	在给定的 `endog` 数据集上执行拟合。
`forecast`([h, index])	根据拟合模型预测未来点。
`get_level`([index])	返回模型的水平 (level) 组件。
`get_season`([index])	返回模型的季节性 (season) 组件。
`get_trend`([index])	返回模型的趋势 (trend) 组件。
`score`([index])	返回模型的评分。

注意

已知限制：与 statsmodels.holtwinters.ExponentialSmoothing 模型相比，此版本的 ExponentialSmoothing 当前仅提供有限的功能。显著地，它缺少

predict不支持样本内预测。
- rapidsai/cuml#875
hessian不支持返回 Hessian 矩阵。
- rapidsai/cuml#880
information不支持返回 Fisher 矩阵。
- rapidsai/cuml#880
loglike不支持返回对数似然。
- rapidsai/cuml#880

此外，请注意此模型可能存在浮点不稳定性问题。endog 中的小值可能导致错误结果。更多信息请参阅 rapidsai/cuml#888。

已知差异：此版本的 ExponentialSmoothing 在其他一些细微方面与 statsmodels 不同

无法传递趋势组件或阻尼趋势组件
此版本可以接受附加参数 eps, start_periods, ts_num 和 handle
Score 返回 SSE 而不是梯度 logL rapidsai/cuml#876
此版本提供 get_level(), get_trend(), get_season() 方法

示例

>>> from cuml import ExponentialSmoothing
>>> import cudf
>>> import cupy as cp
>>> data = cudf.Series([1, 2, 3, 4, 5, 6,
...                     7, 8, 9, 10, 11, 12,
...                     2, 3, 4, 5, 6, 7,
...                     8, 9, 10, 11, 12, 13,
...                     3, 4, 5, 6, 7, 8, 9,
...                     10, 11, 12, 13, 14],
...                     dtype=cp.float64)
>>> cu_hw = ExponentialSmoothing(data, seasonal_periods=12).fit()
>>> cu_pred = cu_hw.forecast(4)
>>> print('Forecasted points:', cu_pred) 
Forecasted points :
0    4.000143766093652
1    5.000000163513641
2    6.000000000174092
3    7.000000000000178

fit() → ExponentialSmoothing[source]#: 在给定的 endog 数据集上执行拟合。计算水平 (level)、趋势 (trend)、季节性 (season) 和 SSE 组件。

forecast(h=1, index=None)[source]#

根据拟合模型预测未来点。

参数:

hint (default=1): 每条序列要预测的点数。
indexint (default=None): 您想要预测点的时间序列的索引。如果为 None，则返回包含所有时间序列预测点的 cudf.DataFrame。

返回值:

predscudf.DataFrame or cudf.Series: 如果提供了索引，则返回预测点的 Series。如果 index=None，则返回所有预测点的 DataFrame。

get_level(index=None)[source]#

返回模型的水平 (level) 组件。

参数:

indexint (default=None): 将返回水平组件的时间序列的索引。如果为 None，则所有水平组件将在 cudf.Series 中返回。

返回值:

levelcudf.Series or cudf.DataFrame: 拟合模型的水平组件

get_season(index=None)[source]#

返回模型的季节性 (season) 组件。

参数:

indexint (default=None): 将返回季节性组件的时间序列的索引。如果为 None，则所有季节性组件将在 cudf.Series 中返回。

返回值:

season: cudf.Series or cudf.DataFrame: 拟合模型的季节性组件

get_trend(index=None)[source]#

返回模型的趋势 (trend) 组件。

参数:

indexint (default=None): 将返回趋势组件的时间序列的索引。如果为 None，则所有趋势组件将在 cudf.Series 中返回。

返回值:

trendcudf.Series or cudf.DataFrame: 拟合模型的趋势组件。

score(index=None)[source]#

返回模型的评分。

注意

目前返回 SSE，而不是对数似然的梯度。rapidsai/cuml#876

参数:

indexint (default=None): 将返回 SSE 的时间序列的索引。如果为 None，则所有 SSE 将在 cudf Series 中返回。

返回值:

scorenp.float32, np.float64, or cudf.Series: 拟合模型的 SSE。

自回归积分滑动平均 (ARIMA)#

class cuml.tsa.ARIMA(endog, *, order: Tuple[int, int, int] = (1, 1, 1), seasonal_order: Tuple[int, int, int, int] = (0, 0, 0, 0), exog=None, fit_intercept=True, simple_differencing=True, handle=None, verbose=False, output_type=None, convert_dtype=True)#

实现了一种批处理 ARIMA 模型，用于样本内和样本外的时间序列预测，并支持季节性（SARIMA）

ARIMA 代表自回归积分滑动平均。参见 https://en.wikipedia.org/wiki/Autoregressive_integrated_moving_average

此类可以将 ARIMA(p,d,q) 或 ARIMA(p,d,q)(P,D,Q)_s 模型拟合到长度相同（或不同长度，在开头使用缺失值进行填充）的一批时间序列。此实现旨在在使用大量时间序列批量时提供最佳性能。

参数:

endogdataframe or array-like (device or host): 内生变量，假定每个时间序列在列中。可接受的格式：cuDF DataFrame, cuDF Series, NumPy ndarray, Numba device ndarray, 符合 cuda array interface 的数组（如 CuPy）。接受缺失值，用 NaN 表示。
orderTuple[int, int, int] (default=(1,1,1)): 模型的 ARIMA 阶数 (p, d, q)
seasonal_orderTuple[int, int, int, int] (default=(0,0,0,0)): 模型的季节性 ARIMA 阶数 (P, D, Q, s)
exogdataframe or array-like (device or host) (default=None): 外生变量，假定每个时间序列在列中，使得与同一批次成员相关的变量相邻（列数：n_exog * batch_size）。可接受的格式：cuDF DataFrame, cuDF Series, NumPy ndarray, Numba device ndarray, 符合 cuda array interface 的数组（如 CuPy）。不支持缺失值。
fit_interceptbool or int (default = True): 是否在模型中包含常数趋势 mu
simple_differencingbool or int (default = True): 如果为 True，则在传递给卡尔曼滤波之前对数据进行差分。如果为 False，则差分是状态空间模型的一部分。在某些情况下，此设置可以忽略：计算带置信区间的预测将强制其为 False；使用 CSS 方法拟合将强制其为 True。注意：预测始终针对原始序列，而当 simple_differencing 为 True 时，statsmodels 计算差分序列的预测。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
convert_dtypeboolean: 设置为 True 时，模型将自动将输入转换为 np.float64。

属性:

orderARIMAOrder: 模型的 ARIMA 阶数 (p, d, q, P, D, Q, s, k, n_exog)
d_ydevice array: 设备上的时间序列数据
n_obsint: 观测值数量
batch_size整数: 批量中的时间序列数量
dtypenumpy.dtype: 数据和参数的浮点类型
niternumpy.ndarray: 拟合后，包含每个时间序列收敛前的迭代次数。

方法

`fit`([start_params, opt_disp, h, maxiter, ...])	将 ARIMA 模型拟合到每个时间序列。
`forecast`(nsteps[, level, exog])	将给定模型预测未来 `nsteps`。
`get_fit_params`()	获取所有拟合参数。
`get_params`([deep])
`pack`()	将模型的参数打包成线性化向量 `x`
`predict`([start, end, level, exog, convert_dtype])	计算每条序列的样本内和/或样本外预测
`set_fit_params`(params[, convert_dtype])	设置所有拟合参数。
`set_params`(**params)
`unpack`(x[, convert_dtype])	将线性化参数向量 `x` 解包到模型的单独参数数组中

注意

性能：令 \(r=max(p+s*P, q+s*Q+1)\)。大多数操作使用的设备内存为 :math: O(mathtt{batch_size}*mathtt{n_obs} + mathtt{batch_size}*r^2)。执行时间是 n_obs 和 batch_size（如果 batch_size 很大）的线性函数，但随 r 增长非常快。

性能针对超大批量（例如数千个序列）进行了优化。

参考

此类深受 Python 库 statsmodels 的影响，特别是 statsmodels.tsa.statespace.sarimax.SARIMAX。参见 https://statsmodels.pythonlang.cn/stable/statespace.html。

此外，以下书籍是很有用的参考资料：“Time Series Analysis by State Space Methods”，J. Durbin，S.J. Koopman，第 2 版 (2012)。

示例

>>> import cupy as cp
>>> from cuml.tsa.arima import ARIMA

>>> # Create seasonal data with a trend, a seasonal pattern and noise
>>> n_obs = 100
>>> cp.random.seed(12)
>>> x = cp.linspace(0, 1, n_obs)
>>> pattern = cp.array([[0.05, 0.0], [0.07, 0.03],
...                     [-0.03, 0.05], [0.02, 0.025]])
>>> noise = cp.random.normal(scale=0.01, size=(n_obs, 2))
>>> y = (cp.column_stack((0.5*x, -0.25*x)) + noise
...     + cp.tile(pattern, (25, 1)))

>>> # Fit a seasonal ARIMA model
>>> model = ARIMA(y,
...               order=(0,1,1),
...               seasonal_order=(0,1,1,4),
...               fit_intercept=False)
>>> model.fit()
ARIMA(...)
>>> # Forecast
>>> fc = model.forecast(10)
>>> print(fc) 
[[ 0.55204599 -0.25681163]
[ 0.57430705 -0.2262438 ]
[ 0.48120315 -0.20583011]
[ 0.535594   -0.24060046]
[ 0.57207541 -0.26695497]
[ 0.59433647 -0.23638713]
[ 0.50123257 -0.21597344]
[ 0.55562342 -0.25074379]
[ 0.59210483 -0.27709831]
[ 0.61436589 -0.24653047]]

property aic: CumlArray#: 赤池信息准则 (Akaike Information Criterion)

property aicc: CumlArray#: 修正赤池信息准则 (Corrected Akaike Information Criterion)

property bic: CumlArray#: 贝叶斯信息准则 (Bayesian Information Criterion)

property complexity#: 模型复杂度（参数数量）

fit(start_params: Mapping[str, object] | None = None, opt_disp: int = -1, h: float = 1e-08, maxiter: int = 1000, method='ml', truncate: int = 0, convert_dtype: bool = True) → ARIMA[source]#

将 ARIMA 模型拟合到每个时间序列。

参数:

start_paramsMapping[str, array-like] (optional)

参数名称和相关数组的映射（例如字典）。键名在 {“mu”, “ar”, “ma”, “sar”, “sma”, “sigma2”} 中。数组形状对于 mu 和 sigma2 参数是 (batch_size,)，对于任何其他类型是 (n, batch_size)，其中 n 是此类型对应参数的数量。传递 None 进行自动估计（推荐）

opt_dispint

拟合诊断级别（用于 L-BFGS 求解器）

-1 表示无输出（默认）
0<n<100 表示每隔 n 步输出
n>100 表示更详细的输出

hfloat (default=1e-8)

有限差分步长。使用前向有限差分计算梯度：\(g = \frac{f(x + \mathtt{h}) - f(x)}{\mathtt{h}} + O(\mathtt{h})\)

maxiterint (default=1000)

L-BFGS-B 的最大迭代次数

methodstr (default=”ml”)

估计方法 - “css”, “css-ml” 或 “ml”。CSS 使用平方和逼近。ML 使用状态空间方法估计对数似然。CSS-ML 从 CSS 开始，然后用 ML 精炼。

truncateint (default=0)

使用 CSS 时，在给定数量的观测值后开始计算平方和

forecast(nsteps: int, level=None, exog=None) → CumlArray | Tuple[CumlArray, CumlArray, CumlArray][source]#

将给定模型预测未来 nsteps。

参数:

nstepsint: 预测超过给定序列末端的步数
levelfloat or None (default = None): 预测区间的置信水平，或 None 表示仅返回点预测。0 < level < 1
exogdataframe or array-like (device or host) (default=None): 外生变量的未来值。假定每个时间序列在列中，使得与同一批次成员相关的变量相邻。形状 = (nsteps, n_exog * batch_size)

返回值:

y_fcarray-like: 预测结果。形状 = (nsteps, batch_size)
lowerarray-like (device) (optional): 如果 level != None，则为预测区间的下限。形状 = (end - start, batch_size)
upperarray-like (device) (optional): 如果 level != None，则为预测区间的上限。形状 = (end - start, batch_size)

示例

from cuml.tsa.arima import ARIMA
...
model = ARIMA(ys, order=(1,1,1))
model.fit()
y_fc = model.forecast(10)

get_fit_params() → Dict[str, CumlArray][source]#

获取所有拟合参数。不要与 get_params 混淆。注意：可以使用 pack() 获取参数的紧凑向量。

返回值:

params: Dict[str, array-like]: 参数名称和相关数组的字典。键名在 {“mu”, “ar”, “ma”, “sar”, “sma”, “sigma2”} 中。数组形状对于 mu 和 sigma2 是 (batch_size,)，对于任何其他类型是 (n, batch_size)，其中 n 是此类型对应参数的数量。

get_params(deep=True)[source]#: 警告

ARIMA 目前无法克隆。方法：_get_param_names()、get_params 和 set_params 将引发 NotImplementedError

property llf#: 拟合模型的对数似然。形状：(batch_size,)

pack() → ndarray[source]#

将模型的参数打包成线性化向量 x

返回值:

xnumpy ndarray: 打包的参数数组，按序列分组。形状：(n_params * batch_size,)

predict(start=0, end=None, level=None, exog=None, convert_dtype=True) → CumlArray | Tuple[CumlArray, CumlArray, CumlArray][source]#

计算每条序列的样本内和/或样本外预测

参数:

startint (default = 0): 开始预测的索引 (0 <= start <= num_samples)
endint (default = None): 结束预测的索引（不包含，end > start），或 None 表示预测到最后一个观测值
levelfloat or None (default = None): 预测区间的置信水平，或 None 表示仅返回点预测。0 < level < 1
exogdataframe or array-like (device or host): 外生变量的未来值。假定每个时间序列在列中，使得与同一批次成员相关的变量相邻。形状 = (end - n_obs, n_exog * batch_size)

返回值:

y_parray-like (device): 预测结果。形状 = (end - start, batch_size)
lower: array-like (device) (optional): 如果 level != None，则为预测区间的下限。形状 = (end - start, batch_size)
upper: array-like (device) (optional): 如果 level != None，则为预测区间的上限。形状 = (end - start, batch_size)

示例

from cuml.tsa.arima import ARIMA

model = ARIMA(ys, order=(1,1,1))
model.fit()
y_pred = model.predict()

set_fit_params(params: Mapping[str, object], convert_dtype=True)[source]#

设置所有拟合参数。不要与 set_params 混淆。注意：可以使用 unpack() 加载参数的紧凑向量。

参数:

params: Mapping[str, array-like]: 参数名称和相关数组的字典。键名在 {“mu”, “ar”, “ma”, “sar”, “sma”, “sigma2”} 中。数组形状对于 mu 和 sigma2 是 (batch_size,)，对于任何其他类型是 (n, batch_size)，其中 n 是此类型对应参数的数量。

set_params(**params)[source]#: 警告

ARIMA 目前无法克隆。方法：_get_param_names()、get_params 和 set_params 将引发 NotImplementedError

unpack(x: list | ndarray, convert_dtype=True)[source]#

将线性化参数向量 x 解包到模型的单独参数数组中

参数:

xarray-like: 打包的参数数组，按序列分组。形状：(n_params * batch_size,)

class cuml.tsa.auto_arima.AutoARIMA(endog, *, handle=None, simple_differencing=True, verbose=False, output_type=None, convert_dtype=True)#

实现了一种批处理的自动 ARIMA 模型，用于样本内和样本外的时间序列预测。

此接口提供了高度可定制的搜索功能，与 R 中的 forecast 和 fable 包的功能相似。它在底层 ARIMA 模型之上提供了一个抽象，使得预测和预报就像使用单个模型一样。

参数:

endogdataframe or array-like (device or host): 时间序列数据，假定每个时间序列在列中。可接受的格式：cuDF DataFrame, cuDF Series, NumPy ndarray, Numba device ndarray, 符合 cuda array interface 的数组（如 CuPy）。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
simple_differencing: bool or int, default=True: 如果为 True，则在传递给卡尔曼滤波之前对数据进行差分。如果为 False，则差分是状态空间模型的一部分。参见 ARIMA 文档中的其他注意事项。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
convert_dtypeboolean: 设置为 True 时，模型将自动将输入转换为 np.float64。

属性:

d_y

方法

`fit`([h, maxiter, method, truncate])	为每个序列拟合选定的模型
`forecast`(nsteps[, level])	预测未来 `nsteps`。
`predict`([start, end, level])	计算每条序列的样本内和/或样本外预测
`search`([s, d, D, p, q, P, Q, fit_intercept, ...])	在指定的模型空间中搜索，并将每个序列关联到最合适的模型。
`summary`()	显示由 `search` 选择的模型的快速摘要

注意

此接口受到 R fable 包的影响：参见 https://fable.tidyverts.org/reference/ARIMA.html

参考

一个有用的（尽管已过时）参考文献是这篇论文

[1]

Rob J. Hyndman, Yeasmin Khandakar, 2008. “Automatic Time Series Forecasting: The ‘forecast’ Package for R”, Journal of Statistical Software 27

示例

from cuml.tsa.auto_arima import AutoARIMA

model = AutoARIMA(y)
model.search(s=12, d=(0, 1), D=(0, 1), p=(0, 2, 4), q=(0, 2, 4),
             P=range(2), Q=range(2), method="css", truncate=100)
model.fit(method="css-ml")
fc = model.forecast(20)

fit(h: float = 1e-08, maxiter: int = 1000, method='ml', truncate: int = 0)[source]#

为每个序列拟合选定的模型

参数:

hfloat: 用于在 ARIMA 中计算梯度的有限差分步长
maxiterint: L-BFGS-B 的最大迭代次数
methodstr: 估计方法 - “css”, “css-ml” 或 “ml”。CSS 使用快速平方和逼近。ML 使用状态空间方法估计对数似然。CSS-ML 从 CSS 开始，然后用 ML 精炼。
truncateint: 使用 CSS 时，在给定数量的观测值后开始计算平方和，以获得更好的性能（但通常拟合效果更差）

forecast(nsteps: int, level=None) → CumlArray | Tuple[CumlArray, CumlArray, CumlArray][source]#

预测未来 nsteps。

参数:

nstepsint: 预测超过给定序列末端的步数
level: float or None (default = None): 预测区间的置信水平，或 None 表示仅返回点预测。0 < level < 1

返回值:

y_fcarray-like: 预测结果。形状 = (nsteps, batch_size)
lower: array-like (device) (optional): 如果 level != None，则为预测区间的下限。形状 = (end - start, batch_size)
upper: array-like (device) (optional): 如果 level != None，则为预测区间的上限。形状 = (end - start, batch_size)

predict(start=0, end=None, level=None) → CumlArray | Tuple[CumlArray, CumlArray, CumlArray][source]#

计算每条序列的样本内和/或样本外预测

参数:

start: int: 开始预测的索引 (0 <= start <= num_samples)
end: 结束预测的索引（不包含，end > start）
level: float or None (default = None): 预测区间的置信水平，或 None 表示仅返回点预测。0 < level < 1

返回值:

y_parray-like (device): 预测结果。形状 = (end - start, batch_size)
lower: array-like (device) (optional): 如果 level != None，则为预测区间的下限。形状 = (end - start, batch_size)
upper: array-like (device) (optional): 如果 level != None，则为预测区间的上限。形状 = (end - start, batch_size)

search(s=None, d=range(0, 3), D=range(0, 2), p=range(1, 4), q=range(1, 4), P=range(0, 3), Q=range(0, 3), fit_intercept='auto', ic='aicc', test='kpss', seasonal_test='seas', h: float = 1e-08, maxiter: int = 1000, method='auto', truncate: int = 0)[source]#

在指定的模型空间中搜索，并将每个序列关联到最合适的模型。

参数:

sint: 季节性周期。非季节性时间序列为 None 或 0
dint, sequence or generator: d 的可能值（简单差分）
Dint, sequence or generator: D 的可能值（季节性差分）
pint, sequence or generator: p 的可能值（AR 阶数）
qint, sequence or generator: q 的可能值（MA 阶数）
Pint, sequence or generator: P 的可能值（季节性 AR 阶数）
Qint, sequence or generator: Q 的可能值（季节性 MA 阶数）
fit_interceptint, sequence, generator or “auto”: 是否拟合截距。“auto” 根据模型参数选择：仅当 d + D <= 1 时使用截距
icstr: 用于模型选择的信息准则。目前支持：AIC, AICc, BIC
teststr: 用于选择 d 的平稳性检验。目前支持：KPSS
seasonal_teststr: 用于选择 D 的季节性检验。目前支持：seas
hfloat: 用于在 ARIMA 中计算梯度的有限差分步长
maxiterint: L-BFGS-B 的最大迭代次数
methodstr: 估计方法 - “auto”, “css”, “css-ml” 或 “ml”。CSS 使用快速平方和逼近。ML 使用状态空间方法估计对数似然。CSS-ML 从 CSS 开始，然后用 ML 精炼。“auto” 对于长季节性时间序列将使用 CSS，否则使用 ML。
truncateint: 使用 CSS 时，在给定数量的观测值后开始计算平方和，以获得更好的性能。对于长序列，当截断不会丢失太多信息时推荐使用。

summary()[source]#: 显示由 search 选择的模型的快速摘要

模型可解释性#

SHAP 核解释器#

class cuml.explainer.KernelExplainer(*, model, data, nsamples='auto', link='identity', verbose=False, random_state=None, is_gpu_model=None, handle=None, dtype=None, output_type=None)#

SHAP 核解释器的 GPU 加速实现。

cuML 基于 SHAP 的解释器加速了 SHAP 的算法部分。它们经过优化，可与快速的基于 GPU 的模型一起使用，例如 cuML 中的模型。通过创建数据集和内部计算，同时最大限度地减少数据复制和传输，它们可以显著加速解释。但它们也可以与基于 CPU 的模型一起使用，在这种情况下仍然可以实现加速，但速度可能会受到数据传输和模型速度等因素的限制。

KernelExplainer 基于 Python SHAP 包的 KernelExplainer 类：slundberg/shap

当前 GPU 版本的特性

与 SHAP 包不同，nsamples 是解释器初始化时的参数，并且有一个小的初始化时间。

目前仅支持表格数据，通过显式传递背景数据集。

稀疏数据支持计划在近期实现。

正在进行进一步优化。例如，如果背景数据集有常数值列，并且观测值在某些条目中具有相同的值，则可以减少函数评估的次数（这将在下一版本中实现）。

参数:

modelfunction: 一个函数，接受样本矩阵（n_samples, n_features）并计算这些样本的输出，输出形状为 (n_samples)。函数必须使用 CuPy 或 NumPy 数组作为输入/输出。
data包含 float 或 double 的密集矩阵。: cuML 的核 SHAP 目前支持表格数据，因此它需要一个背景数据集，而不是 shap.masker 对象。用于积分消除特征的背景数据集。为了确定某个特征的影响，将该特征设置为“缺失”并观察模型输出的变化。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
nsamplesint (default = 2 * data.shape[1] + 2048): 解释每次预测时重新评估模型的次数。更多的样本会产生方差更低的 SHAP 值估计。自动设置使用 nsamples = 2 * X.shape[1] + 2048。
linkfunction or str (default = ‘identity’): 用于映射模型输出单元和 SHAP 值单元之间的链接函数。摘自 SHAP 包：用于映射模型输出单元和 SHAP 值单元之间的链接函数。默认情况下它是 identity（恒等），但 logit 可能有用，以便在概率单元中计算期望值，而解释仍然在（更自然地具有加性）对数几率单元中。有关链接函数如何工作的更多详细信息，请参阅广义线性模型的任何链接函数概述。
random_state: int, RandomState 实例或 None (default = None): 用于数据集创建的随机数生成器的种子。注意：由于采样算法的设计，并发性可能会影响结果，因此目前不保证 100% 确定性执行。
gpu_modelbool 或 None (default = None): 如果为 None，Explainer 将尝试推断 model 是否可以接受 GPU 数据（如 CuPy 数组），否则它将使用 NumPy 数组调用 model。设置为 True 会强制 Explainer 使用 GPU 数据，设置为 False 会强制 Explainer 使用 NumPy 数据。
handlepylibraft.common.handle (default = None): 指定用于此模型中计算并持有内部 CUDA 状态的句柄，如果为 None，则会创建一个新句柄。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同的流中创建句柄来并发运行不同的模型。
dtypenp.float32 或 np.float64 (default = None): 指定用于生成数据以调用模型的精度参数。如果未指定，Explainer 将尝试获取模型的 dtype，如果无法查询，则默认为 np.float32。
output_type‘cupy’ 或 ‘numpy’ (default = ‘numpy’): 指定输出数据类型的参数。如果未指定，Explainer 目前将默认为 ‘numpy’ 以提高兼容性。

方法

shap_values(X[, l1_reg, as_list])

估算一组样本的 SHAP 值的接口。

示例

>>> from cuml import SVR
>>> from cuml import make_regression
>>> from cuml import train_test_split
>>>
>>> from cuml.explainer import KernelExplainer
>>>
>>> X, y = make_regression(
...     n_samples=102,
...     n_features=10,
...     noise=0.1,
...     random_state=42)
>>>
>>> X_train, X_test, y_train, y_test = train_test_split(
...     X,
...     y,
...     test_size=2,
...     random_state=42)
>>>
>>> model = SVR().fit(X_train, y_train)
>>>
>>> cu_explainer = KernelExplainer(
...     model=model.predict,
...     data=X_train,
...     is_gpu_model=True,
...     random_state=42)
>>>
>>> cu_shap_values = cu_explainer.shap_values(X_test)
>>> cu_shap_values  
array([[-0.41163236, -0.29839307, -0.31082764, -0.21910861, 0.20798518,
      1.525831  , -0.07726735, -0.23897147, -0.5901833 , -0.03319931],
    [-0.37491834, -0.22581327, -1.2146976 ,  0.03793442, -0.24420738,
      -0.4875331 , -0.05438256, 0.16568947, -1.9978098 , -0.19110584]],
    dtype=float32)

shap_values(X, l1_reg='auto', as_list=True)[source]#

估算一组样本的 SHAP 值的接口。对应于 SHAP 包的旧版接口，也是我们目前的主要 API。

参数:

X包含 floats 或 doubles 的密集矩阵。: 可接受的格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
l1_regstr (default: ‘auto’): 用于特征选择的 l1 正则化。
as_listbool (default = True): 设置为 True 可为多维模型（如 predict_proba 函数）返回数组列表，以匹配 SHAP 包的行为。设置为 False 可将它们作为数组的数组返回。

返回值:

shap_valuesarray 或 list

SHAP 置换解释器#

class cuml.explainer.PermutationExplainer(*, model, data, masker_type='independent', link='identity', handle=None, is_gpu_model=None, random_state=None, dtype=None, output_type=None, verbose=False)#

SHAP PermutationExplainer 的 GPU 加速版本

PermutationExplainer 在算法上与 Python SHAP 包的 kernel explainer 相似并基于它：slundberg/shap

此方法通过迭代输入数据的排列来近似 Shapley 值。摘自 SHAP 库文档：它通过在正向和反向方向上完全迭代特征的整个排列来保证局部准确性（可加性）。

当前 GPU 版本的特性

目前仅支持表格数据，通过显式传递背景数据集。

针对 Owen 值的层次聚类正在近期计划中。

稀疏数据支持计划在近期实现。

设置随机种子:

此解释器使用 CuPy 来生成所使用的排列，因此要获得可重复的结果，请使用 CuPy 的种子机制。

参数:

modelfunction: 一个可调用的 Python 对象，根据一组输入数据样本执行模型。
masker包含 floats 或 doubles 的密集矩阵。: cuML 的置换 SHAP 目前支持表格数据，因此它需要一个背景数据集，而不是 shap.masker 对象。为了遵循数据的层次结构，请使用（临时）参数 masker_type。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
masker_type: {‘independent’, ‘partition’} default = ‘independent’: 如果使用 ‘independent’，则等效于 SHAP 的 independent masker，并且算法是完全 GPU 加速的。如果使用 ‘partition’，则等效于 SHAP 的 Partition masker，它遵循背景数据中的层次结构。
linkfunction or str (default = ‘identity’): 用于映射模型输出单元和 SHAP 值单元之间的链接函数。摘自 SHAP 包：用于映射模型输出单元和 SHAP 值单元之间的链接函数。默认情况下它是 identity（恒等），但 logit 可能有用，以便在概率单元中计算期望值，而解释仍然在（更自然地具有加性）对数几率单元中。有关链接函数如何工作的更多详细信息，请参阅广义线性模型的任何链接函数概述。
gpu_modelbool 或 None (default = None): 如果为 None，Explainer 将尝试推断 model 是否可以接受 GPU 数据（如 CuPy 数组），否则它将使用 NumPy 数组调用 model。设置为 True 会强制 Explainer 使用 GPU 数据，设置为 False 会强制 Explainer 使用 NumPy 数据。
handlepylibraft.common.handle (default = None): 指定用于此模型中计算并持有内部 CUDA 状态的句柄，如果为 None，则会创建一个新句柄。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同的流中创建句柄来并发运行不同的模型。
dtypenp.float32 或 np.float64 (default = None): 指定用于生成数据以调用模型的精度参数。如果未指定，Explainer 将尝试获取模型的 dtype，如果无法查询，则默认为 np.float32。
output_type‘cupy’ 或 ‘numpy’ (default = ‘numpy’): 指定输出数据类型的参数。如果未指定，Explainer 目前将默认为 ‘numpy’ 以提高兼容性。

方法

shap_values(X[, npermutations, as_list])

估算一组样本的 SHAP 值的接口。

示例

>>> from cuml import SVR
>>> from cuml import make_regression
>>> from cuml import train_test_split

>>> from cuml.explainer import PermutationExplainer

>>> X, y = make_regression(
...     n_samples=102,
...     n_features=10,
...     noise=0.1,
...     random_state=42)
>>> X_train, X_test, y_train, y_test = train_test_split(
...     X,
...     y,
...     test_size=2,
...     random_state=42)
>>> model = SVR().fit(X_train, y_train)

>>> cu_explainer = PermutationExplainer(
...     model=model.predict,
...     data=X_train,
...     random_state=42)

>>> cu_shap_values = cu_explainer.shap_values(X_test)
>>> cu_shap_values  
array([[ 0.16611198, 0.74156773, 0.05906528,  0.30015892, 2.5425286 ,
        0.0970122 , 0.12258395, 2.1998262 , -0.02968234, -0.8669155 ],
    [-0.10587756,  0.77705824, -0.08259875, -0.71874434,  1.781551  ,
        -0.05454511, 0.11826539, -1.1734306 , -0.09629871, 0.4571011]],
    dtype=float32)

shap_values(X, npermutations=10, as_list=True, **kwargs)[source]#

估算一组样本的 SHAP 值的接口。对应于 SHAP 包的旧版接口，也是我们目前的主要 API。

参数:

X包含 floats 或 doubles 的密集矩阵。: 可接受的格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
npermutationsint (default = 10): 循环遍历所有特征并重新评估模型的次数。每个循环会在一个 (# background data samples) 行的数据矩阵上评估模型函数 2 * (# features + 1) 次。例外情况是当 PermutationExplainer 可以避免评估模型，因为特征值在 X 和背景数据集中相同（这在稀疏特征中很常见）。
as_listbool (default = True): 设置为 True 可为多维模型（如 predict_proba 函数）返回数组列表，以匹配 SHAP 包 shap_values API 的行为。设置为 False 可将它们作为数组的数组返回。

返回值:

shap_valuesarray 或 list

多节点、多 GPU 算法#

DBSCAN 聚类#

class cuml.dask.cluster.DBSCAN(*, client=None, verbose=False, **kwargs)[source]#

DBSCAN 的多节点多 GPU 实现。

整个数据集被复制到所有 worker，但工作通过将子集“所有权”分配给每个 worker 来划分：每个 worker 通过考虑这些点与数据集其余部分之间的关系来计算聚类，并在最后合并部分结果以获得最终聚类。

参数:

clientdask.distributed.Client: 要使用的 Dask 客户端
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
min_samples整数 (默认值 = 5): 邻域中的样本数量，使得该组（包括点本身）可以被视为一个重要的核心点。
max_mbytes_per_batch(可选) int64: 计算批量大小时，对成对距离计算使用的兆字节数不超过此值。这可以在运行时和内存使用之间进行权衡，使 N^2 成对距离计算对于大量样本更加易于处理。如果在运行 DBSCAN 时遇到内存不足错误，可以根据设备的内存大小设置此值。注意：此选项不会设置 DBSCAN 计算中使用的最大总内存，因此此值无法设置为设备上可用的总内存。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。
calc_core_sample_indices(可选) 布尔值 (默认值 = True): 指示是否应该计算核心样本的索引。如果属性 core_sample_indices_ 将不被使用，将此设置为 False 将避免不必要的内核启动。

方法

`fit`(X[, out_dtype])	拟合多节点多 GPU DBSCAN 模型
`fit_predict`(X[, out_dtype])	在 X 上执行聚类并返回聚类标签。

注意

有关更多文档，请参阅单 GPU DBSCAN 模型的文档

fit(X, out_dtype='int32')[source]#

拟合多节点多 GPU DBSCAN 模型

参数:

Xarray-like (设备或主机): 包含 floats 或 doubles 的密集矩阵。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
out_dtype: dtype 决定输出标签数组的精度。: 默认值：“int32”。有效值为 { “int32”, np.int32, “int64”, np.int64}。

fit_predict(X, out_dtype='int32')[source]#

在 X 上执行聚类并返回聚类标签。

参数:

Xarray-like (设备或主机): 包含 floats 或 doubles 的密集矩阵。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy、cuDF DataFrame/Series、NumPy ndarray 和 Pandas DataFrame/Series。
out_dtype: dtype 决定输出标签数组的精度。: 默认值：“int32”。有效值为 { “int32”, np.int32, “int64”, np.int64}。
返回值
——-
labels: array-like (设备或主机): 整数标签数组

K-Means 聚类#

class cuml.dask.cluster.KMeans(*, client=None, verbose=False, **kwargs)[source]#

KMeans 的多节点多 GPU 实现。

此版本通过在每次迭代中仅在 worker 之间共享质心来最小化数据传输。

预测是通过 embarrassingly parallel 的方式完成的，使用 cuML 的单 GPU 版本。

有关此实现的更多信息，请参阅单 GPU K-Means 的文档。

参数:

handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
n_clusters整型 (默认值 = 8): 您想要的质心或簇的数量。
max_iter整型 (默认值 = 300): EM 迭代次数越多，精度越高，但速度越慢。
tol浮点数 (默认值 = 1e-4): 质心均值变化不大时的停止准则。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
random_state整型 (默认值 = 1): 如果您希望在重新启动 Python 时结果保持一致，请选择一个状态。
init{‘scalable-kmeans++’, ‘k-means||’ , ‘random’ or an ndarray} (default = ‘scalable-k-means++’): ‘scalable-k-means++’ 或 ‘k-means||’：使用快速稳定的可伸缩 kmeans++ 初始化。‘random’：从数据中随机选择 ‘n_cluster’ 个观测值（行）作为初始质心。如果传递一个 ndarray，其形状应为 (n_clusters, n_features)，表示初始中心。
oversampling_factorint (default = 2): 在可伸缩 k-means++ 初始化中采样用于潜在质点的点数量。增加此值可以获得更好的初始质点，但会消耗更多内存。可伸缩 k-means++ 中采样的质点总数是 oversampling_factor * n_clusters * 8。
max_samples_per_batch整型 (默认值 = 32768): 用于分批计算成对距离的数据样本数量。此计算在 fit predict 过程中都会进行。默认值应适用于大多数情况。分批成对距离计算中的总元素数量为 max_samples_per_batch * n_clusters。当 n_clusters 变得非常大时，可能需要降低此数值。

属性:

cluster_centers_cuDF DataFrame 或 CuPy ndarray: 最终聚类的坐标。这表示每个数据簇的“平均值”。

方法

`fit`(X[, sample_weight])	拟合多节点多 GPU KMeans 模型
`fit_predict`(X[, sample_weight, delayed])	计算簇中心并预测每个样本的簇索引。
`fit_transform`(X[, sample_weight, delayed])	使用分布式 KMeans 模型，先调用 fit，再调用 transform
`predict`(X[, sample_weight, delayed])	预测输入的标签
`score`(X[, sample_weight])	计算训练好的 KMeans 质心的惯性得分。
`transform`(X[, delayed])	将输入转换到学习到的质心空间

fit(X, sample_weight=None)[source]#

拟合多节点多 GPU KMeans 模型

参数:

XDask cuDF DataFrame 或 CuPy backed Dask Array
用于聚类的训练数据。
sample_weightDask cuDF DataFrame 或 CuPy 支持的 Dask Array 形状 = (n_samples,), default=None # noqa: X 中每个观测值的权重。如果为 None，则所有观测值分配相同的权重。可接受的格式：cuDF DataFrame, NumPy ndarray, Numba device ndarray, 符合 cuda array interface 的数组，如 CuPy

fit_predict(X, sample_weight=None, delayed=True)[source]#

计算簇中心并预测每个样本的簇索引。

参数:

XDask cuDF DataFrame 或 CuPy backed Dask Array: 用于预测的数据

返回值:

result: Dask cuDF DataFrame 或 CuPy 支持的 Dask Array: 包含预测的分布式对象

fit_transform(X, sample_weight=None, delayed=True)[source]#

使用分布式 KMeans 模型，先调用 fit，再调用 transform

参数:

XDask cuDF DataFrame 或 CuPy backed Dask Array: 用于预测的数据
delayedbool (默认 = True): 是否作为延迟任务或立即执行。

返回值:

result: Dask cuDF DataFrame 或 CuPy 支持的 Dask Array: 包含转换后数据的分布式对象

predict(X, sample_weight=None, delayed=True)[source]#

预测输入的标签

参数:

XDask cuDF DataFrame 或 CuPy backed Dask Array: 用于预测的数据
delayedbool (默认 = True): 是否进行延迟预测（并返回 Delayed 对象）或立即执行的预测。

返回值:

result: Dask cuDF DataFrame 或 CuPy 支持的 Dask Array: 包含预测的分布式对象

score(X, sample_weight=None)[source]#

计算训练好的 KMeans 质心的惯性得分。

参数:

Xdask_cudf.Dataframe: 用于计算得分的 Dataframe

返回值:

惯性得分

transform(X, delayed=True)[source]#

将输入转换到学习到的质心空间

参数:

XDask cuDF DataFrame 或 CuPy backed Dask Array: 用于预测的数据
delayedbool (默认 = True): 是否作为延迟任务或立即执行。

返回值:

result: Dask cuDF DataFrame 或 CuPy 支持的 Dask Array: 包含转换后数据的分布式对象

主成分分析#

class cuml.dask.decomposition.PCA(*, client=None, verbose=False, **kwargs)[source]#

cuML 的多节点多 GPU (MNMG) PCA 需要 dask-cuDF 对象作为输入，并提供 2 种算法：Full 和 Jacobi。Full（默认）使用完整的特征分解然后选择前 K 个特征向量。Jacobi 算法可以快得多，因为它迭代地尝试校正前 K 个特征向量，但可能准确性较低。

参数:

handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
n_components整数 (默认值 = 1): 您想要的前 K 个奇异向量/值的数量。必须小于或等于列数。
svd_solver‘full’, ‘jacobi’, ‘auto’: ‘full’：运行精确的完整 SVD 并通过后处理选择组件 ‘jacobi’：迭代计算协方差矩阵的 SVD ‘auto’：为了与 Scikit-learn 兼容。‘jacobi’ 的别名。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
whiten布尔值 (默认值 = False): 如果为 True，则使成分去相关。这是通过将它们除以相应的奇异值，然后乘以 sqrt(n_samples) 来完成的。白化使每个成分具有单位方差并消除多重共线性。对于 LinearRegression 等下游任务可能有利，因为相关特征会引起问题。

属性:

components_数组: U, S, VT = svd(X) 中的前 K 个成分 (VT.T[:,:n_components])
explained_variance_数组: 每个成分解释的数据方差量，由 S**2 给出。
explained_variance_ratio_数组: 解释的方差占总方差的百分比，由 S**2/sum(S**2) 给出。
singular_values_数组: 前 K 个奇异值。请记住所有奇异值 >= 0
mean_数组: X 的列均值。首先用于对数据进行均值中心化。
noise_variance_浮点数: 来自 Bishop 1999 年的教科书。用于后续任务，例如计算 X 的估计协方差。

方法

`fit`(X)	用 X 拟合模型。
`fit_transform`(X)	使用 X 拟合模型并在 X 上应用降维。
`inverse_transform`(X[, delayed])	将数据转换回其原始空间。
`transform`(X[, delayed])	对 X 应用降维。

注意

PCA 的应用

PCA 在实践中广泛用于数据可视化和数据压缩。它已被用于在 2 或 3 维空间可视化 Word2Vec 和 GloVe 等超大词嵌入、日常对象和图像的大型数据集，以及用于区分癌细胞和健康细胞。

更多文档请参阅 scikit-learn 的 PCA。

示例

>>> from dask_cuda import LocalCUDACluster
>>> from dask.distributed import Client, wait
>>> import cupy as cp
>>> from cuml.dask.decomposition import PCA
>>> from cuml.dask.datasets import make_blobs

>>> cluster = LocalCUDACluster(threads_per_worker=1)
>>> client = Client(cluster)

>>> nrows = 6
>>> ncols = 3
>>> n_parts = 2

>>> X_cudf, _ = make_blobs(n_samples=nrows, n_features=ncols,
...                        centers=1, n_parts=n_parts,
...                        cluster_std=0.01, random_state=10,
...                        dtype=cp.float32)

>>> blobs = X_cudf.compute()
>>> print(blobs) 
[[8.688037  3.122401  1.2581943]
[8.705028  3.1070278 1.2705998]
[8.70239   3.1102846 1.2716919]
[8.695665  3.1042147 1.2635932]
[8.681095  3.0980906 1.2745825]
[8.705454  3.100002  1.2657361]]

>>> cumlModel = PCA(n_components = 1, whiten=False)
>>> XT = cumlModel.fit_transform(X_cudf)
>>> print(XT.compute()) 
[[-1.7516235e-02]
[ 7.8094802e-03]
[ 4.2757220e-03]
[-6.7228684e-05]
[-5.0618490e-03]
[ 1.0557819e-02]]
>>> client.close()
>>> cluster.close()

fit(X)[source]#

用 X 拟合模型。

参数:

Xdask cuDF 输入

fit_transform(X)[source]#

使用 X 拟合模型并在 X 上应用降维。

参数:

Xdask cuDF

返回值:

X_newdask cuDF

inverse_transform(X, delayed=True)[source]#

将数据转换回其原始空间。

换句话说，返回一个输入 X_original，其变换结果为 X。

参数:

Xdask cuDF

返回值:

X_originaldask cuDF

transform(X, delayed=True)[source]#

对 X 应用降维。

X 被投影到之前从训练集提取的前几个主成分上。

参数:

Xdask cuDF

返回值:

X_newdask cuDF

随机森林#

class cuml.dask.ensemble.RandomForestClassifier(*, workers=None, client=None, verbose=False, n_estimators=100, random_state=None, ignore_empty_partitions=False, **kwargs)[source]#

一个实验性 API，实现了一个多 GPU 随机森林分类模型，该模型在一个集成中拟合多个决策树分类器。它使用 Dask 将数据分区到多个 GPU（可能在不同的节点上）。

目前，此 API 做了以下假设

在实例化、拟合和预测之间使用的 Dask worker 集保持一致
训练数据以 cuDF dataframes 或 Dask Arrays 的形式传入，并分布以便每个 worker 至少有一个分区。
get_summary_text 和 get_detailed_text 函数提供了 worker 上森林的文本表示。

未来的 API 版本将支持更灵活的数据分布和额外的输入类型。

分布式算法使用一种极其并行（embarrassingly-parallel）的方法。对于在 w 个 worker 上构建的具有 N 棵树的森林，每个 worker 只需在本地可用的数据上构建 N/w 棵树。在许多情况下，将数据分区以便每个 worker 在整个数据集的一个子集上构建树效果很好，但这通常需要提前将数据充分洗牌。或者，调用者可以将所有数据复制到 worker 上，以便 rf.fit 接收到 w 个分区，每个分区包含相同的数据。这将产生与单 GPU 拟合近似相同的结果。

有关底层算法的更多信息，请查看随机森林分类器的单 GPU 实现。

参数:

n_streams整型 (默认值 = 4)用于构建森林的并行流数量。

森林中的总树数（不是每个 worker 的树数）

handlecuml.Handle

如果类型为 int，则 min_samples_leaf 表示最小数量。

如果为 float，则 min_samples_leaf 表示一个分数，ceil(min_samples_leaf * n_rows) 是每个叶子节点的最小样本数量。

min_samples_split整型或浮点型 (默认值 = 2)分裂内部节点所需的最小样本数量。

如果类型为 int，则 min_samples_split 表示最小数量。

如果类型为 float，则 min_samples_split 表示一个分数，max(2, ceil(min_samples_split * n_rows)) 是每个分裂的最小样本数量。

min_impurity_decrease浮点型 (默认值 = 0.0)节点分裂所需的最小不纯度减少量。

max_batch_size整型 (默认值 = 4096)在给定批次中可以处理的最大节点数量。

随机数生成器的种子。默认情况下未设置种子。目前不能完全保证结果完全相同。

2, 'mse', 4, 'poisson', 5, 'gamma', 6, 'inverse_gaussian' 对分类无效

从已训练的 cuML 随机森林模型创建 Forest Inference (FIL) 模型。

convert_to_treelite_model

如果为 True，则森林中的每棵树都基于带有替换的自举样本构建。

cpu_to_gpu

将属性从 CPU 估计器转移到 GPU 估计器。

fit(X, y[, convert_dtype])

对输入数据执行随机森林分类

get_detailed_text

注意

获取随机森林模型的详细信息（文本形式）

get_json

将随机森林模型导出为 JSON 字符串

max_featuresfloat (default = ‘auto’)

获取随机森林模型的文本摘要

如果类型为 int，则 max_features 是要使用的特征的绝对数量。

如果类型为 float，则 max_features 是一个分数。

如果为 'auto'，则 max_features=n_features = 1.0。

predict_proba(X[, algo, convert_dtype, ...])

预测 X 的类别概率。

如果为 None，则 max_features = 1.0。

计算模型对 X 的准确率指标得分。

每个特征分裂算法使用的最大 bin 数。

在训练多类别分类问题的模型时，使用深层树或 max_features=1.0 可以提供更好的性能。

有关其他文档，请参阅 scikitlearn 的 RandomForestClassifier。

convert_to_fil_model(output_class=True, threshold=0.5, algo='auto', fil_sparse_format='auto')[source]#

output_class布尔型 (默认值 = True)这是可选的，仅在 GPU 上执行预测操作时需要。如果为 true，则根据原始预测是否超过阈值返回 1 或 0。如果为 false，则仅返回原始预测。

algo字符串 (默认值 = ‘auto’)这是可选的，仅在 GPU 上执行预测操作时需要。

'naive' - 使用共享内存进行简单推理

如果类型为 int，则 min_samples_split 表示最小数量。

如果类型为 float，则 min_samples_split 表示一个分数，ceil(min_samples_split * n_rows) 是每次分裂所需的最小样本数。

n_streams整数 (默认 = 4 )

用于森林构建的并行流的数量

workersoptional, list of strings

用于计算的 worker 的 Dask 地址。如果为 None，则将使用所有可用的 Dask worker。

random_stateint (default = None)

随机数生成器的种子。默认未设置种子。

ignore_empty_partitions: Boolean (default = False)

指定 worker 在分裂时没有任何数据时的行为。当为 True 时，它返回有数据的 worker 的结果（训练的估计器数量将少于 n_estimators）。当为 False 时，抛出 RuntimeError。这是一个实验性参数，将来可能会被移除。

方法

`fit`(X, y[, convert_dtype, broadcast_data])	使用随机森林分类器拟合输入数据
`设置为 True 时，该方法将自动将输入转换为 np.float32。`()	设置为 True 时，fit 方法在必要时会将 y 转换为 int32 dtype。这将增加方法使用的内存。
`get_detailed_text()[source]#`()	get_json()[source]#
`get_params`([deep])	以字典形式返回配置此估计器所需的所有参数的值。
`get_summary_text()[source]#`()	predict(X, predict_model='GPU', threshold=0.5, algo='auto', convert_dtype=True, fil_sparse_format='auto') → CumlArray[source]#
`predict`(X[, algo, threshold, convert_dtype, ...])	algo字符串 (默认值 = `'auto'`)用于分类的阈值。可选的，仅在 GPU 上执行预测操作时需要。
`predict_model_on_cpu`(X[, convert_dtype])	algo字符串 (默认值 = `'auto'`)用于分类的阈值。可选的，仅在 GPU 上执行预测操作时需要。
`predict_proba`(X[, delayed])	预测 X 的每个类别的概率。
`set_params`(**params)	设置配置此估计器所需的参数值，其功能类似于 sklearn 的 set_params。

partial_inference
predict_using_fil

示例

有关用法示例，请参阅 RAPIDS notebooks 仓库：rapidsai/cuml

fit(X, y, convert_dtype=False, broadcast_data=False)[source]#

使用随机森林分类器拟合输入数据

重要：X 预计已分区，并且 forest (self.workers) 使用的每个 Dask worker 上至少有一个分区。

如果一个 worker 有多个数据分区，它们将在拟合之前被连接起来，这将导致额外的内存使用。为了最小化内存消耗，请确保每个 worker 恰好有一个分区。

持久化数据时，可以使用 cuml.dask.common.utils.persist_across_workers 来简化此过程

X_dask_cudf = dask_cudf.from_cudf(X_cudf, npartitions=n_workers)
y_dask_cudf = dask_cudf.from_cudf(y_cudf, npartitions=n_workers)
X_dask_cudf, y_dask_cudf = persist_across_workers(dask_client,
                                                  [X_dask_cudf,
                                                   y_dask_cudf])

这等同于使用数据和 worker 调用 persist

X_dask_cudf, y_dask_cudf = dask_client.persist([X_dask_cudf,
                                                y_dask_cudf],
                                               workers={
                                               X_dask_cudf:workers,
                                               y_dask_cudf:workers
                                               })

参数:

XDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, n_features): 形状为 (n_samples, n_features) 的分布式密集矩阵 (floats 或 doubles)。
yDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, 1): 训练样本的标签。y 的分区方式必须与 X 相同
convert_dtype布尔型, 可选 (默认值 = False): 设置为 True 时，fit 方法在必要时会将 y 转换为 int32 数据类型。这将增加方法使用的内存。
broadcast_databool, 可选 (default = False): 设置为 True 时，整个数据集将被广播以训练 worker，否则每个 worker 在其分区上进行训练

get_detailed_text()[source]#: 设置为 True 时，fit 方法在必要时会将 y 转换为 int32 dtype。这将增加方法使用的内存。

get_json()[source]#: get_json()[source]#

get_params(deep=True)[source]#

以字典形式返回配置此估计器所需的所有参数的值。

参数:

deepboolean (default = True)

get_summary_text()[source]#: predict(X, predict_model='GPU', threshold=0.5, algo='auto', convert_dtype=True, fil_sparse_format='auto') → CumlArray[source]#

predict(X, algo='auto', threshold=0.5, convert_dtype=True, predict_model='GPU', fil_sparse_format='auto', delayed=True, broadcast_data=False)[source]#

algo字符串 (默认值 = 'auto')用于分类的阈值。可选的，仅在 GPU 上执行预测操作时需要。

多节点、多 GPU 环境中的 GPU 预测工作原理是将每个 worker 的子森林发送到客户端，将这些子森林连接成一个包含完整 n_estimators 树集的森林，然后将此组合森林发送到 worker，每个 worker 将在其本地数据集上进行推断。在 worker 内部，这使用 cuML Forest Inference Library (cuml.fil) 进行高吞吐量预测。

这使得推断可以扩展到大型数据集，但森林传输对于非常大的树会产生开销。对于小型数据集上的推断，此开销可能主导预测时间。

“CPU” 回退方法就地使用子森林，将数据集广播到所有 worker 并最终通过投票方法组合预测。此方法在每行基础上较慢，但对于具有许多树和少量行的问题可能更快。

在 0.15 cuML 版本中，推断将更新，树传输速度会快得多。使用此更新方法的初步构建版本将从 rapids.ai 提供。

参数:

XDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, n_features)

形状为 (n_samples, n_features) 的分布式密集矩阵 (floats 或 doubles)。

split_criterion整型或字符串 (默认值 = 2 ('mse'))

0, 'gini', 1 和 'entropy' 对回归无效。

max_features整型、浮点型或字符串 (默认值 = 1.0)

如果类型为 int，则 max_features 是要使用的特征的绝对数量。

在 24.06 版本中更改: max_features 的默认值从 "auto" 更改为 1.0。

'auto' - 自动选择算法。(默认)

节点分裂所需的最小不纯度减少量

accuracy_metric字符串 (默认值 = ‘r2’)决定用于评估模型性能的指标。在 0.16 版本中，默认评分指标从均方误差更改为 r 平方。

用于分类的阈值。可选，仅在使用 GPU 执行预测操作时需要，即 predict_model=’GPU’。

convert_dtypebool, 可选 (默认 = True)

设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

predict_model字符串 (默认 = ‘GPU’)

‘GPU’ 表示使用 GPU 进行预测，否则使用 ‘CPU’。仅当模型使用 float32 数据训练且 X 为 float32 或 convert_dtype 设置为 True 时，才可以使用 GPU。

对于绝对误差中位数 : 'median_ae'

对于绝对误差平均值 : 'mean_ae'

对于均方误差 : 'mse'

convert_to_fil_model([output_class, algo, ...])

fit(X, y[, convert_dtype])

delayedbool (默认 = True)

是否执行延迟预测（并返回 Delayed 对象）或立即执行的预测。在使用 predict_model=’CPU’ 时不需要。

broadcast_databool (default = False)

如果 broadcast_data=False，树将在 worker 对其预测工作负载部分执行推断之前合并到一个模型中。当 broadcast_data=True 时，树不会合并。相反，每个 worker 会根据可用的树推断整个预测工作。结果在客户端上汇总。当模型大于用于推断的数据时，可能具有优势。

返回值:

yDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, 1)

predict_model_on_cpu(X, convert_dtype=True)[source]#

algo字符串 (默认值 = 'auto')用于分类的阈值。可选的，仅在 GPU 上执行预测操作时需要。

参数:

XDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, n_features): 形状为 (n_samples, n_features) 的分布式密集矩阵 (floats 或 doubles)。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

返回值:

yDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, 1)

predict_proba(X, delayed=True, **kwargs)[source]#

预测 X 的每个类别的概率。

有关性能的注意事项，请参阅 predict 的文档。

参数:

XDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, n_features)

形状为 (n_samples, n_features) 的分布式密集矩阵 (floats 或 doubles)。

predict_model字符串 (默认 = ‘GPU’)

split_criterion整型或字符串 (默认值 = 2 ('mse'))

0, 'gini', 1 和 'entropy' 对回归无效。

max_features整型、浮点型或字符串 (默认值 = 1.0)

如果类型为 int，则 max_features 是要使用的特征的绝对数量。

在 24.06 版本中更改: max_features 的默认值从 "auto" 更改为 1.0。

'auto' - 自动选择算法。(默认)

节点分裂所需的最小不纯度减少量

accuracy_metric字符串 (默认值 = ‘r2’)决定用于评估模型性能的指标。在 0.16 版本中，默认评分指标从均方误差更改为 r 平方。

用于分类的阈值。可选，仅在使用 GPU 执行 predict 操作时需要。

convert_dtypebool, 可选 (默认 = True)

设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

对于绝对误差中位数 : 'median_ae'

对于绝对误差平均值 : 'mean_ae'

对于均方误差 : 'mse'

convert_to_fil_model([output_class, algo, ...])

fit(X, y[, convert_dtype])

返回值:

yDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, n_classes)

set_params(**params)[source]#

设置配置此估计器所需的参数值，其功能类似于 sklearn 的 set_params。

参数:

params新的参数字典。

class cuml.dask.ensemble.RandomForestRegressor(*, workers=None, client=None, verbose=False, n_estimators=100, random_state=None, ignore_empty_partitions=False, **kwargs)[source]#

目前，此 API 做了以下假设

在实例化、拟合和预测之间使用的 Dask worker 集保持一致
训练数据以 cuDF dataframes 或 Dask Arrays 的形式传入，并分布以便每个 worker 至少有一个分区。
get_summary_text 和 get_detailed_text 函数提供了 worker 上森林的文本表示。

未来的 API 版本将支持更灵活的数据分布和额外的输入类型。面向用户的 API 在未来版本中可能会发生变化。

有关底层算法的更多信息，请查看随机森林分类器的单 GPU 实现。

参数:

n_streams整型 (默认值 = 4)用于构建森林的并行流数量。

森林中的总树数（不是每个 worker 的树数）

handlecuml.Handle

split_criterion整数或字符串 (默认 = 2 ('mse'))

如果为 float，则 min_samples_leaf 表示一个分数，ceil(min_samples_leaf * n_rows) 是每个叶子节点的最小样本数量。

min_samples_split整型或浮点型 (默认值 = 2)分裂内部节点所需的最小样本数量。

如果类型为 int，则 min_samples_split 表示最小数量。

如果类型为 float，则 min_samples_split 表示一个分数，max(2, ceil(min_samples_split * n_rows)) 是每个分裂的最小样本数量。

min_impurity_decrease浮点型 (默认值 = 0.0)节点分裂所需的最小不纯度减少量。

max_batch_size整型 (默认值 = 4096)在给定批次中可以处理的最大节点数量。

随机数生成器的种子。默认情况下未设置种子。目前不能完全保证结果完全相同。

0, 'gini', 1, 'entropy' 对回归无效

从已训练的 cuML 随机森林模型创建 Forest Inference (FIL) 模型。

convert_to_treelite_model

如果为 True，则森林中的每棵树都基于带有替换的自举样本构建。

cpu_to_gpu

将属性从 CPU 估计器转移到 GPU 估计器。

fit(X, y[, convert_dtype])

对输入数据执行随机森林分类

get_detailed_text

注意

获取随机森林模型的详细信息（文本形式）

get_json

将随机森林模型导出为 JSON 字符串

max_featuresfloat (default = ‘auto’)

获取随机森林模型的文本摘要

如果类型为 int，则 max_features 是要使用的特征的绝对数量。

如果类型为 float，则 max_features 是一个分数。

如果为 'auto'，则 max_features=n_features = 1.0。

predict_proba(X[, algo, convert_dtype, ...])

预测 X 的类别概率。

如果为 None，则 max_features = 1.0。

计算模型对 X 的准确率指标得分。

每个特征分裂算法使用的最大 bin 数。

在训练多类别分类问题的模型时，使用深层树或 max_features=1.0 可以提供更好的性能。

有关其他文档，请参阅 scikitlearn 的 RandomForestClassifier。

convert_to_fil_model(output_class=True, threshold=0.5, algo='auto', fil_sparse_format='auto')[source]#

output_class布尔型 (默认值 = True)这是可选的，仅在 GPU 上执行预测操作时需要。如果为 true，则根据原始预测是否超过阈值返回 1 或 0。如果为 false，则仅返回原始预测。

algo字符串 (默认值 = ‘auto’)这是可选的，仅在 GPU 上执行预测操作时需要。

'naive' - 使用共享内存进行简单推理

如果类型为 int，则 min_samples_split 表示最小数量。

如果类型为 float，则 min_samples_split 表示一个分数，ceil(min_samples_split * n_rows) 是每次分裂所需的最小样本数。

accuracy_metric字符串 (默认 = ‘r2’)

决定用于评估模型性能的指标。在 0.16 版本中，默认评分指标从均方误差更改为 r-squared。

r-squared 对应 : 'r2'

绝对误差中位数对应 : 'median_ae'

绝对误差均值对应 : 'mean_ae'

均方误差对应 : 'mse'

n_streams整数 (默认 = 4 )

用于森林构建的并行流的数量

workersoptional, list of strings

用于计算的 worker 的 Dask 地址。如果为 None，则将使用所有可用的 Dask worker。

random_stateint (default = None)

随机数生成器的种子。默认未设置种子。

ignore_empty_partitions: Boolean (default = False)

方法

`fit`(X, y[, convert_dtype, broadcast_data])	使用随机森林回归模型拟合输入数据
`设置为 True 时，该方法将自动将输入转换为 np.float32。`()	设置为 True 时，fit 方法在必要时会将 y 转换为 int32 dtype。这将增加方法使用的内存。
`get_detailed_text()[source]#`()	get_json()[source]#
`get_params`([deep])	以字典形式返回配置此估计器所需的所有参数的值。
`get_summary_text()[source]#`()	predict(X, predict_model='GPU', threshold=0.5, algo='auto', convert_dtype=True, fil_sparse_format='auto') → CumlArray[source]#
`predict`(X[, predict_model, algo, ...])	预测 X 的回归器输出。
`set_params`(**params)	设置配置此估计器所需的参数值，其功能类似于 sklearn 的 set_params。

partial_inference
predict_model_on_cpu
predict_using_fil

fit(X, y, convert_dtype=False, broadcast_data=False)[source]#

使用随机森林回归模型拟合输入数据

重要：X 预计已分区，并且 forest (self.workers) 使用的每个 Dask worker 上至少有一个分区。

持久化数据时，可以使用 cuml.dask.common.utils.persist_across_workers 来简化此过程

X_dask_cudf = dask_cudf.from_cudf(X_cudf, npartitions=n_workers)
y_dask_cudf = dask_cudf.from_cudf(y_cudf, npartitions=n_workers)
X_dask_cudf, y_dask_cudf = persist_across_workers(dask_client,
                                                  [X_dask_cudf,
                                                   y_dask_cudf])

这等同于使用数据和 worker 调用 persist)

X_dask_cudf, y_dask_cudf = dask_client.persist([X_dask_cudf,
                                                y_dask_cudf],
                                               workers={
                                               X_dask_cudf:workers,
                                               y_dask_cudf:workers
                                               })

参数:

XDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, n_features): 形状为 (n_samples, n_features) 的分布式密集矩阵 (floats 或 doubles)。
yDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, 1): 训练样本的标签。y 的分区方式必须与 X 相同
convert_dtype布尔型, 可选 (默认值 = False): 设置为 True 时，fit 方法会在必要时将 y 转换为与 X 相同的数据类型（如果它们不同）。这将增加方法使用的内存。
broadcast_databool, 可选 (default = False): 设置为 True 时，整个数据集将被广播以训练 worker，否则每个 worker 在其分区上进行训练

get_detailed_text()[source]#: 设置为 True 时，fit 方法在必要时会将 y 转换为 int32 dtype。这将增加方法使用的内存。

get_json()[source]#: get_json()[source]#

get_params(deep=True)[source]#

以字典形式返回配置此估计器所需的所有参数的值。

参数:

deepboolean (default = True)

get_summary_text()[source]#: predict(X, predict_model='GPU', threshold=0.5, algo='auto', convert_dtype=True, fil_sparse_format='auto') → CumlArray[source]#

predict(X, predict_model='GPU', algo='auto', convert_dtype=True, fil_sparse_format='auto', delayed=True, broadcast_data=False)[source]#

预测 X 的回归器输出。

多节点、多 GPU 环境中的基于 GPU 的预测通过将每个工作节点中的子森林发送到客户端，将这些子森林连接成一个包含完整 n_estimators 树集合的森林，然后将这个组合森林发送到工作节点，每个工作节点将在其本地数据集上进行推理。这使得推理可以扩展到大型数据集，但森林传输会为非常大的树带来开销。对于在小型数据集上进行推理，此开销可能会主导预测时间。在工作节点内部，这使用 cuML 森林推理库 (cuml.fil) 实现高吞吐量预测。

“CPU” 回退方法原地处理子森林，将数据集广播到所有工作节点，并在最后通过平均方法组合预测结果。这种方法按行计算速度较慢，但对于树木数量多、行数少的问题可能更快。

在 cuML 0.15 版本中，推理功能将通过更快的树传输进行更新。

参数:

XDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, n_features)

形状为 (n_samples, n_features) 的分布式密集矩阵 (floats 或 doubles)。

split_criterion整型或字符串 (默认值 = 2 ('mse'))

0, 'gini', 1 和 'entropy' 对回归无效。

max_features整型、浮点型或字符串 (默认值 = 1.0)

如果类型为 int，则 max_features 是要使用的特征的绝对数量。

在 24.06 版本中更改: max_features 的默认值从 "auto" 更改为 1.0。

'auto' - 自动选择算法。(默认)

节点分裂所需的最小不纯度减少量

convert_dtypebool, 可选 (默认 = True)

设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

predict_model字符串 (默认 = ‘GPU’)

‘GPU’ 表示使用 GPU 进行预测，否则使用 ‘CPU’。仅当模型使用 float32 数据训练且 X 为 float32 或 convert_dtype 设置为 True 时，才可以使用 GPU。

对于绝对误差中位数 : 'median_ae'

对于绝对误差平均值 : 'mean_ae'

对于均方误差 : 'mse'

convert_to_fil_model([output_class, algo, ...])

fit(X, y[, convert_dtype])

delayedbool (默认 = True)

是否进行延迟预测（并返回 Delayed 对象）或立即执行的预测。

broadcast_databool (default = False)

返回值:

yDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, 1)

set_params(**params)[source]#

设置配置此估计器所需的参数值，其功能类似于 sklearn 的 set_params。

参数:

params新的参数字典。

截断奇异值分解#

class cuml.dask.decomposition.TruncatedSVD(*, client=None, **kwargs)[source]#

参数:

handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
n_components整数 (默认值 = 1): 您想要的前 K 个奇异向量/值的数量。必须小于或等于列数。
svd_solver‘full’, ‘jacobi’: 仅支持完全 (Full) 算法，因为它在 GPU 上的速度明显快于包括随机 SVD 在内的其他求解器。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。

属性:

components_数组: U, S, VT = svd(X) 中的前 K 个成分 (VT.T[:,:n_components])
explained_variance_数组: 每个成分解释的数据方差量，由 S**2 给出。
explained_variance_ratio_数组: 解释的方差占总方差的百分比，由 S**2/sum(S**2) 给出。
singular_values_数组: 前 K 个奇异值。请记住所有奇异值 >= 0

方法

`fit`(X[, _transform])	用 X 拟合模型。
`fit_transform`(X)	使用 X 拟合模型并在 X 上应用降维。
`inverse_transform`(X[, delayed])	将数据转换回其原始空间。
`transform`(X[, delayed])	将 `X` 应用降维。

示例

>>> from dask_cuda import LocalCUDACluster
>>> from dask.distributed import Client, wait
>>> import cupy as cp
>>> from cuml.dask.decomposition import TruncatedSVD
>>> from cuml.dask.datasets import make_blobs

>>> cluster = LocalCUDACluster(threads_per_worker=1)
>>> client = Client(cluster)

>>> nrows = 6
>>> ncols = 3
>>> n_parts = 2

>>> X_cudf, _ = make_blobs(n_samples=nrows, n_features=ncols,
...                        centers=1, n_parts=n_parts,
...                        cluster_std=1.8, random_state=10,
...                        dtype=cp.float32)
>>> in_blobs = X_cudf.compute()
>>> print(in_blobs) 
[[ 6.953966    6.2313757   0.84974563]
[10.012338    3.4641726   3.0827546 ]
[ 9.537406    4.0504313   3.2793145 ]
[ 8.32713     2.957846    1.8215517 ]
[ 5.7044296   1.855514    3.7996366 ]
[10.089077    2.1995444   2.2072687 ]]
>>> cumlModel = TruncatedSVD(n_components = 1)
>>> XT = cumlModel.fit_transform(X_cudf)
>>> result = XT.compute()
>>> print(result) 
[[ 8.699628   0.         0.       ]
[11.018815   0.         0.       ]
[10.8554535  0.         0.       ]
[ 9.000192   0.         0.       ]
[ 6.7628784  0.         0.       ]
[10.40526    0.         0.       ]]
>>> client.close()
>>> cluster.close()

fit(X, _transform=False)[source]#

用 X 拟合模型。

参数:

Xdask cuDF 输入

fit_transform(X)[source]#

使用 X 拟合模型并在 X 上应用降维。

参数:

Xdask cuDF

返回值:

X_newdask cuDF

inverse_transform(X, delayed=True)[source]#

将数据转换回其原始空间。

换句话说，返回一个输入 X_original，其变换结果为 X。

参数:

Xdask cuDF

返回值:

X_originaldask cuDF

transform(X, delayed=True)[source]#

将 X 应用降维。

X 投影到之前从训练集中提取的前几个主成分上。

参数:

Xdask cuDF

返回值:

X_newdask cuDF

流形#

class cuml.dask.manifold.UMAP(*, model, client=None, **kwargs)[source]#

均匀流形逼近和投影

找到数据的低维嵌入，以逼近底层流形。

改编自 lmcinnes/umap umap.py

方法

transform(X[, convert_dtype])

将 X 转换为现有的嵌入空间并返回转换后的输出。

注意

此模块很大程度上基于 Leland McInnes 的参考 UMAP 包 [1]。

但是，cuml.umap 中尚未实现一些差异和功能

使用非欧几里得距离度量（计划在即将发布的版本中支持固定数量的非欧几里得度量）。
使用预计算的成对距离矩阵（未来版本考虑实现）
手动初始化初始嵌入位置

除了这些缺失的功能外，您应该会看到 cuml.umap 和参考 UMAP 之间的最终嵌入存在差异。

已知问题： 如果 UMAP 模型尚未拟合，则无法对其进行序列化

参考

[1]

Leland McInnes, John Healy, James Melville UMAP: Uniform Manifold Approximation and Projection for Dimension Reduction.

示例

>>> from dask_cuda import LocalCUDACluster
>>> from dask.distributed import Client
>>> import dask.array as da
>>> from cuml.datasets import make_blobs
>>> from cuml.manifold import UMAP
>>> from cuml.dask.manifold import UMAP as MNMG_UMAP
>>> import numpy as np

>>> cluster = LocalCUDACluster(threads_per_worker=1)
>>> client = Client(cluster)

>>> X, y = make_blobs(1000, 10, centers=42, cluster_std=0.1,
...                   dtype=np.float32, random_state=10)

>>> local_model = UMAP(random_state=10, verbose=0)

>>> selection = np.random.RandomState(10).choice(1000, 100)
>>> X_train = X[selection]
>>> y_train = y[selection]
>>> local_model.fit(X_train, y=y_train)
UMAP()

>>> distributed_model = MNMG_UMAP(model=local_model)
>>> distributed_X = da.from_array(X, chunks=(500, -1))
>>> embedding = distributed_model.transform(distributed_X)
>>> result = embedding.compute()
>>> print(result) 
[[  4.1684933    4.1890593 ]
[  5.0110254   -5.2143383 ]
[  1.7776365  -17.665699  ]
...
[ -6.6378727   -0.15353012]
[ -3.1891193   -0.83906937]
[ -0.5042019    2.1454725 ]]
>>> client.close()
>>> cluster.close()

transform(X, convert_dtype=True)[source]#

将 X 转换为现有的嵌入空间并返回转换后的输出。

有关 fit_transform() 和运行 fit() transform() 之间差异的信息，请参阅参考 UMAP 实现。

具体来说，transform() 函数是随机的：lmcinnes/umap#158

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 要转换的新数据。可接受的格式：dask cuDF, dask CuPy/NumPy/Numba Array

返回值:

X_newarray, shape (n_samples, n_components): 新数据在低维空间中的嵌入。

线性模型#

class cuml.dask.linear_model.LinearRegression(*, client=None, verbose=False, **kwargs)[source]#

LinearRegression 是一种简单的机器学习模型，其中响应 y 通过 X 中的预测变量的线性组合进行建模。

cuML 的 dask 线性回归（多节点多 GPU）需要 dask cuDF DataFrame，并提供 Eig 算法来拟合线性模型。它提供了一种基于特征分解的算法来拟合线性模型。（SVD，比 Eig 更稳定，将在即将发布的版本中添加。）当 X 是一个又高又瘦的矩阵时，通常首选 Eig 算法。随着 X 中特征数量的增加，Eig 算法的准确性会下降。

这是 dask 线性回归的实验性实现。它支持包含多于一列的输入 X。在添加 SVD 算法后，将支持单列输入 X。

参数:

algorithm‘eig’: Eig 使用协方差矩阵的特征分解，速度快得多。SVD 速度较慢，但保证稳定。
fit_intercept布尔值 (默认值 = True): LinearRegression 添加一个额外的项 c 来修正 y 的全局均值，将响应建模为 “x * beta + c”。如果为 False，模型期望您已经中心化了数据。
normalize布尔值 (默认值 = False): 如果为 True，X 中的预测变量将通过除以其 L2 范数进行归一化。如果为 False，则不进行缩放。

属性:

coef_cuDF series, shape (n_features): 线性回归模型的估计系数。
intercept_数组: 截距项。如果 fit_intercept 为 False，则为 0。

方法

`fit`(X, y)	使用 X 和 y 拟合模型。
`predict`(X[, delayed])	对 X 进行预测并返回一个 dask 集合。

fit(X, y)[source]#

使用 X 和 y 拟合模型。

参数:

XDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, n_features): 用于回归的特征
yDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, 1): 标签（结果值）

predict(X, delayed=True)[source]#

对 X 进行预测并返回一个 dask 集合。

参数:

XDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, n_features): 形状为 (n_samples, n_features) 的分布式密集矩阵 (floats 或 doubles)。
delayedbool (默认 = True): 是否进行延迟预测（并返回 Delayed 对象）或立即执行的预测。

返回值:

yDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, 1)

class cuml.dask.linear_model.Ridge(*, client=None, verbose=False, **kwargs)[source]#

Ridge 通过在预测响应 y 时对 X 中的预测变量的线性组合中的系数进行 L2 正则化来扩展 LinearRegression。它可以减少预测变量的方差，并改善问题的条件。

cuML 的 dask Ridge（多节点多 GPU）需要 dask cuDF DataFrame，并提供 Eig 算法来拟合线性模型。它提供了一种基于特征分解的算法来拟合线性模型。（SVD，比 Eig 更稳定，将在即将发布的版本中添加。）当 X 是一个又高又瘦的矩阵时，通常首选 Eig 算法。随着 X 中特征数量的增加，Eig 算法的准确性会下降。

这是 dask Ridge 回归的实验性实现。它支持包含多于一列的输入 X。在添加 SVD 算法后，将支持单列输入 X。

参数:

alpha浮点数 (默认值 = 1.0): 正则化强度 - 必须是正浮点数。值越大表示正则化越强。数组输入将在稍后支持。
solver{‘eig’}: Eig 使用协方差矩阵的特征分解，速度快得多。未来将支持其他求解器。
fit_intercept布尔值 (默认值 = True): 如果为 True，Ridge 添加一个额外的项 c 来修正 y 的全局均值，将响应建模为 “x * beta + c”。如果为 False，模型期望您已经中心化了数据。
normalize布尔值 (默认值 = False): 如果为 True，X 中的预测变量将通过除以其 L2 范数进行归一化。如果为 False，则不进行缩放。

属性:

coef_数组，形状 (n_features): 线性回归模型的估计系数。
intercept_数组: 截距项。如果 fit_intercept 为 False，则为 0。

方法

`fit`(X, y)	使用 X 和 y 拟合模型。
`predict`(X[, delayed])	对 X 进行预测并返回一个 dask 集合。

fit(X, y)[source]#

使用 X 和 y 拟合模型。

参数:

XDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, n_features): 用于回归的特征
yDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, 1): 标签（结果值）

predict(X, delayed=True)[source]#

对 X 进行预测并返回一个 dask 集合。

参数:

XDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, n_features): 形状为 (n_samples, n_features) 的分布式密集矩阵 (floats 或 doubles)。
delayedbool (默认 = True): 是否进行延迟预测（并返回 Delayed 对象）或立即执行的预测。

返回值:

yDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, 1)

class cuml.dask.linear_model.Lasso(*, client=None, **kwargs)[source]#

cuML 的 Lasso 接受数组类对象或 cuDF DataFrame，并使用坐标下降法来拟合线性模型。

参数:

alpha浮点数 (默认值 = 1.0): 乘以 L1 项的常数。alpha = 0 等效于由 LinearRegression 类求解的普通最小二乘法。出于数值原因，不建议将 alpha = 0 用于 Lasso 类。
fit_intercept布尔值 (默认值 = True): 如果为 True，则 Lasso 会尝试纠正 y 的全局均值。如果为 False，则模型期望您已对数据进行了中心化。
normalize布尔值 (默认值 = False): 如果为 True，X 中的预测变量将通过除以其 L2 范数进行归一化。如果为 False，则不进行缩放。
max_iter整数 (默认值 = 1000): 最大迭代次数
tol浮点数 (默认值 = 1e-3): 优化的容忍度：如果更新小于 tol，优化代码会检查对偶间隙的 оптима性，并继续直到它小于 tol。
selection{'cyclic', 'random'} (默认值='cyclic'): 如果设置为 'random'，则每次迭代更新一个随机系数，而不是默认情况下按顺序遍历特征。这（设置为 'random'）通常会导致显著更快的收敛，特别是当 tol 高于 1e-4 时。

属性:

coef_数组，形状 (n_features): 线性回归模型的估计系数。
intercept_数组: 截距项。如果 fit_intercept 为 False，则为 0。
因此，您应该使用 LinearRegression 类。更多文档请参阅 `scikitlearn 的 Lasso
<https://scikit-learn.cn/stable/modules/generated/sklearn.linear_model.Lasso.html>`_。

方法

`fit`(X, y)	使用 X 和 y 拟合模型。
`predict`(X[, delayed])	预测 X 的 y。

fit(X, y)[source]#

使用 X 和 y 拟合模型。

参数:

XDask cuDF DataFrame 或 CuPy backed Dask Array: 形状为 (n_samples, n_features) 的密集矩阵（浮点或双精度）。
yDask cuDF DataFrame or CuPy backed Dask Array: 形状为 (n_samples, n_features) 的密集矩阵（浮点或双精度）。

predict(X, delayed=True)[source]#

预测 X 的 y。

参数:

XDask cuDF DataFrame 或 CuPy backed Dask Array: 形状为 (n_samples, n_features) 的密集矩阵（浮点或双精度）。
delayedbool (默认 = True): 是否进行延迟预测（并返回 Delayed 对象）或立即执行的预测。

返回值:

yDask cuDF DataFrame or CuPy backed Dask Array: 形状为 (n_samples, n_features) 的密集矩阵（浮点或双精度）。

class cuml.dask.linear_model.ElasticNet(*, client=None, **kwargs)[source]#

cuML 的 ElasticNet 可以接受类数组对象或 cuDF DataFrame，使用坐标下降法来拟合线性模型。

参数:

alpha浮点数 (默认值 = 1.0): 乘以 L1 项的常数。alpha = 0 等同于普通最小二乘，由 LinearRegression 对象求解。出于数值原因，不建议将 Lasso 对象的 alpha = 0。因此，您应该使用 LinearRegression 对象。
l1_ratio: float (默认 = 0.5): ElasticNet 混合参数，范围为 0 <= l1_ratio <= 1。当 l1_ratio = 0 时，惩罚是 L2 惩罚。当 l1_ratio = 1 时，惩罚是 L1 惩罚。当 0 < l1_ratio < 1 时，惩罚是 L1 和 L2 的组合。
fit_intercept布尔值 (默认值 = True): 如果为 True，则 Lasso 会尝试纠正 y 的全局均值。如果为 False，则模型期望您已对数据进行了中心化。
normalize布尔值 (默认值 = False): 如果为 True，X 中的预测变量将通过除以其 L2 范数进行归一化。如果为 False，则不进行缩放。
max_iter整数 (默认值 = 1000): 最大迭代次数
tol浮点数 (默认值 = 1e-3): 优化的容忍度：如果更新小于 tol，优化代码会检查对偶间隙的 оптима性，并继续直到它小于 tol。
selection{'cyclic', 'random'} (默认值='cyclic'): 如果设置为 'random'，则每次迭代更新一个随机系数，而不是默认情况下按顺序遍历特征。这（设置为 'random'）通常会导致显著更快的收敛，特别是当 tol 高于 1e-4 时。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

属性:

coef_数组，形状 (n_features): 线性回归模型的估计系数。
intercept_数组: 截距项。如果 fit_intercept 为 False，则为 0。
更多文档请参阅 `scikitlearn 的 ElasticNet
<https://scikit-learn.cn/stable/modules/generated/sklearn.linear_model.ElasticNet.html>`_。

方法

`fit`(X, y)	使用 X 和 y 拟合模型。
`predict`(X[, delayed])	预测 X 的 y。

fit(X, y)[source]#

使用 X 和 y 拟合模型。

参数:

XDask cuDF DataFrame 或 CuPy backed Dask Array: 形状为 (n_samples, n_features) 的密集矩阵（浮点或双精度）。
yDask cuDF DataFrame or CuPy backed Dask Array: 形状为 (n_samples, n_features) 的密集矩阵（浮点或双精度）。

predict(X, delayed=True)[source]#

预测 X 的 y。

参数:

XDask cuDF DataFrame 或 CuPy backed Dask Array: 形状为 (n_samples, n_features) 的密集矩阵（浮点或双精度）。
delayedbool (默认 = True): 是否进行延迟预测（并返回 Delayed 对象）或立即执行的预测。

返回值:

yDask cuDF DataFrame or CuPy backed Dask Array: 形状为 (n_samples, n_features) 的密集矩阵（浮点或双精度）。

朴素贝叶斯#

class cuml.dask.naive_bayes.MultinomialNB(*, client=None, verbose=False, **kwargs)[source]#

用于多项式模型的分布式朴素贝叶斯分类器

方法

`fit`(X, y[, classes])	拟合分布式朴素贝叶斯分类器模型
`predict`(X)	使用分布式朴素贝叶斯模型预测给定数据集样本的类别。
`score`(X, y)	计算准确率得分

示例

class cuml.naive_bayes.GaussianNB(*, priors=None, var_smoothing=1e-09, output_type=None, handle=None, verbose=False)[source]#

>>> import cupy as cp

>>> from sklearn.datasets import fetch_20newsgroups
>>> from sklearn.feature_extraction.text import CountVectorizer

>>> from dask_cuda import LocalCUDACluster
>>> from dask.distributed import Client
>>> import dask
>>> from cuml.dask.common import to_sparse_dask_array
>>> from cuml.dask.naive_bayes import MultinomialNB

>>> # Create a local CUDA cluster
>>> cluster = LocalCUDACluster()
>>> client = Client(cluster)

>>> # Load corpus
>>> twenty_train = fetch_20newsgroups(subset='train',
...                           shuffle=True, random_state=42)

>>> cv = CountVectorizer()
>>> xformed = cv.fit_transform(twenty_train.data).astype(cp.float32)
>>> X = to_sparse_dask_array(xformed, client)
>>> y = dask.array.from_array(twenty_train.target, asarray=False,
...                       fancy=False).astype(cp.int32)

>>> # Train model
>>> model = MultinomialNB()
>>> model.fit(X, y)
<cuml.dask.naive_bayes.naive_bayes.MultinomialNB object at 0x...>

>>> # Compute accuracy on training set
>>> model.score(X, y)
array(0.924...)
>>> client.close()
>>> cluster.close()

fit(X, y, classes=None)[source]#

拟合分布式朴素贝叶斯分类器模型

参数:

Xdask.Array with blocks containing dense or sparse cupy arrays
ydask.Array with blocks containing cupy.ndarray
classes包含唯一类别标签的数组类对象

返回值:

cuml.dask.naive_bayes.MultinomialNB 当前模型实例

predict(X)[source]#

使用分布式朴素贝叶斯模型预测给定数据集样本的类别。

参数:

Xdask.Array with blocks containing dense or sparse cupy arrays

返回值:

包含预测类别的 dask.Array

score(X, y)[source]#

计算准确率得分

参数:

XDask.Array: 要预测的特征。注意 - 假设 X 的块大小和形状是已知的。对于完全延迟的 Array，可以通过调用 X.compute_chunks_sizes() 来完成。
yDask.Array: 用于计算准确率的标签。注意 - 假设 X 的块大小和形状是已知的。对于完全延迟的 Array，可以通过调用 X.compute_chunks_sizes() 来完成。

返回值:

score结果准确率得分的浮点数

求解器#

class cuml.dask.solvers.CD(*, client=None, **kwargs)[source]#

模型并行多 GPU 线性回归模型。

方法

`fit`(X, y)	使用 X 和 y 拟合模型。
`predict`(X[, delayed])	对 X 进行预测并返回一个 dask 集合。

fit(X, y)[source]#

使用 X 和 y 拟合模型。

参数:

XDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, n_features): 用于回归的特征
yDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, 1): 标签（结果值）

predict(X, delayed=True)[source]#

对 X 进行预测并返回一个 dask 集合。

参数:

XDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, n_features): 形状为 (n_samples, n_features) 的分布式密集矩阵 (floats 或 doubles)。
delayedbool (默认 = True): 是否进行延迟预测（并返回 Delayed 对象）或立即执行的预测。

返回值:

yDask cuDF dataframe 或 CuPy 支持的 Dask Array (n_rows, 1)

Dask 基础类和 Mixin#

class cuml.dask.common.base.BaseEstimator(*, client=None, verbose=False, **kwargs)[source]#

方法

get_combined_model()

返回单 GPU 模型用于序列化

get_combined_model()[source]#

返回单 GPU 模型用于序列化

返回值:

model训练好的单 GPU 模型；如果模型尚未训练，则为 None。: yet been trained.

class cuml.dask.common.base.DelayedParallelFunc[source]#

class cuml.dask.common.base.DelayedPredictionMixin[source]#

class cuml.dask.common.base.DelayedTransformMixin[source]#

class cuml.dask.common.base.DelayedInverseTransformMixin[source]#

实验性#

警告

模块 cuml.experimental 包含仍在开发中的功能。不建议依赖此模块中的功能，因为它们在未来版本中可能会发生变化。

注意

由于此模块的性质，根 cuml 包默认不会导入它。每个 experimental 子模块必须单独导入。

线性模型#

class cuml.experimental.linear_model.Lars(*, fit_intercept=True, normalize=True, handle=None, verbose=False, output_type=None, copy_X=True, fit_path=True, n_nonzero_coefs=500, eps=None, precompute='auto')#

最小角回归

最小角回归 (LAR 或 LARS) 是一种模型选择算法。它使用以下算法构建模型

我们从所有系数都等于零开始。
在每一步，我们选择与残差具有最大绝对相关性的预测变量。
我们在与迄今为止选择的所有预测变量等角的方向上迈出最大可能的步长。最大步长确定为使用此步长时，新预测变量与残差的相关性将与当前任何活动预测变量的相关性相等。
如果达到 max_iter 或使用了所有预测变量，或者任何未使用预测变量与残差之间的相关性低于某个容差，则停止。

该求解器基于 [1]。注释中引用的方程式对应于论文中的方程式。

注意

该算法假设 X 和 y 中已移除偏移量，并且每个特征都已归一化

\[sum_i y_i = 0, sum_i x_{i,j} = 0,sum_i x_{i,j}^2=1 for j=0..n_{col}-1\]

参数:

fit_intercept布尔值 (默认值 = True): 如果为 True，Lars 会尝试校正 y 的全局均值。如果为 False，模型期望您已经中心化了数据。
normalize布尔值 (默认值 = False): 当 fit_intercept 设置为 False 时，此参数将被忽略。如果为 True，X 中的预测变量将通过移除其均值并除以其方差进行归一化。如果为 False，则求解器期望数据已经归一化。

24.06 版本中的变化： normalize 的默认值从 True 更改为 False。
copy_X布尔型 (默认 = True): 求解器会置换 X 的列。将 copy_X 设置为 True 可防止改变输入数据。
fit_path布尔型 (默认 = True): 是否在 coef_path_ 属性中返回正则化路径上的所有系数。
precompute布尔型，‘auto’，或形状为 (n_features, n_features) 的数组类对象。(默认 = ‘auto’): 是否预计算 Gram 矩阵。用户可以提供 Gram 矩阵作为参数。
n_nonzero_coefs整型 (默认 500): 要拟合的最大系数数量。这给出了我们选择用于预测的特征数量的上限。
handlecuml.Handle: 指定用于保存此模型计算内部 CUDA 状态的 cuml.handle。最重要的是，这指定了将用于模型计算的 CUDA 流，因此用户可以通过在不同流中创建 handle 来同时运行不同的模型。如果为 None，则会创建一个新的。
verboseint 或 boolean，默认值=False: 设置日志记录级别。它必须是 cuml.common.logger.level_* 之一。更多信息请参见详细程度级别。
output_type{‘input’, ‘array’, ‘dataframe’, ‘series’, ‘df_obj’, ‘numba’, ‘cupy’, ‘numpy’, ‘cudf’, ‘pandas’}，默认值=None: 返回结果并将估计器属性设置为指示的输出类型。如果为 None，则使用模块级别 (cuml.global_settings.output_type) 设置的输出类型。更多信息请参见输出数据类型配置。

属性:

alphas_浮点或双精度数组，形状 = [n_alphas + 1]: 每一步的最大相关性。
active_整型数组形状 = [n_alphas]: 路径末尾活动变量的索引。
beta_浮点或双精度数组 [n_asphas]: 活动回归系数（与 coef_ 相同，但省略了零）。
coef_path_浮点或双精度数组，形状 = [n_alphas, n_alphas + 1]: 正则化路径上的系数。仅在 fit_path 为 True 时存储。请注意，我们只存储活动集中的索引对应的系数（即 coef_path_[:,-1] == coef_[active_]）
coef_数组，形状 (n_features): 回归模型的估计系数。
intercept_标量，浮点或双精度: 独立项。如果 fit_intercept_ 为 False，则为 0。
n_iter_整型: 求解器所用的迭代次数。

方法

`fit`(self, X, y[, convert_dtype])	使用 X 和 y 拟合模型。
`predict`(self, X[, convert_dtype])	预测 X 的 `y` 值。

注意

更多信息请参阅 scikitlearn 的 OLS 文档。

参考

[1]

B. Efron, T. Hastie, I. Johnstone, R Tibshirani, Least Angle Regression The Annals of Statistics (2004) Vol 32, No 2, 407-499

fit(self, X, y, convert_dtype=True) → 'Lars'[source]#

使用 X 和 y 拟合模型。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 密集矩阵。如果数据类型不是 float 或 double，数据将转换为 float，这会增加内存使用。将参数 convert_dtype 设置为 False 可避免此情况，此时方法将抛出错误。可接受的格式：符合 CUDA 数组接口的对象，如 CuPy, cuDF DataFrame/Series, NumPy ndarray 和 Pandas DataFrame/Series。
y类数组 (设备或主机) 形状 = (n_samples, 1): 与 Scikit-learn 同名类的包装器。输入可以是任何 cuML 兼容的数组类型，输出类型遵循 cuML 的输出类型配置规则。
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，如果 X 和 y 的数据类型不同，train 方法会在必要时将 y 转换为与 X 相同的数据类型。这会增加该方法使用的内存。

predict(self, X, convert_dtype=True) → CumlArray[source]#

预测 X 的 y 值。

参数:

Xarray-like 对象（设备或主机），形状 = (n_samples, n_features): 形状为 (n_samples, n_features) 的密集矩阵（浮点或双精度）。可接受的格式：cuDF DataFrame、NumPy ndarray、Numba device ndarray、符合 cuda array interface 标准的数组（如 CuPy）
convert_dtypebool, 可选 (默认 = True): 设置为 True 时，predict 方法会在必要时将输入转换为用于训练模型的数据类型。这会增加该方法使用的内存。

返回值:

y: cuDF DataFrame: 形状为 (n_samples, 1) 的密集向量（浮点或双精度）

模型可解释性#

class cuml.explainer.TreeExplainer#

模型解释器，计算基于树的模型预测的 Shapley 值。Shapley 值是一种将各种输入特征归因于给定模型预测的方法。

使用 GPUTreeShap [1] 作为后端，利用 GPU 加速计算。

Shapley 值存在不同的变体，基于对特征进行边缘化（或条件化）的不同解释。对于 “tree_path_dependent” 方法，请参阅 [2]。

对于 “interventional” 方法，请参阅 [3]。

我们还提供了两种特征交互的变体。对于交互的 “shapley-interactions” 变体，请参阅 [2]，对于 “shapley-taylor” 变体，请参阅 [4]。

[1]

Mitchell, Rory, Eibe Frank, and Geoffrey Holmes. “GPUTreeShap: massively parallel exact calculation of SHAP scores for tree ensembles.” PeerJ Computer Science 8 (2022): e880.

[2] (1,2)

Lundberg, Scott M., et al. “From local explanations to global understanding with explainable AI for trees.” Nature machine intelligence 2.1 (2020): 56-67.

[3]

Janzing, Dominik, Lenon Minorics, and Patrick Blöbaum. “Feature relevance quantification in explainable AI: A causal problem.” International Conference on artificial intelligence and statistics. PMLR, 2020.

[4]

Sundararajan, Mukund, Kedar Dhamdhere, and Ashish Agarwal. “The Shapley Taylor Interaction Index.” International Conference on Machine Learning. PMLR, 2020.

参数:

model模型对象: 基于树的机器学习模型。支持 XGBoost、LightGBM、cuml 随机森林和 sklearn 随机森林模型。原生支持 XGBoost 或 LightGBM 模型中的类别特征。
data数组或 DataFrame: 可选的背景数据集，用于边缘化特征。如果提供此参数，则使用 “interventional” 方法。计算时间随此背景数据集的大小增加而增加，考虑从 100-1000 个样本开始。如果未提供此参数，则使用树模型中的统计信息来边缘化特征（“tree_path_dependent”）。

属性:

expected_value: 当所有输入特征都被边缘化后的模型预测。对于多类别问题，这是一个向量。

方法

`shap_interaction_values`(X[, method, ...])	估计一组样本的 SHAP 交互值。
`shap_values`(X[, convert_dtype])	估计一组样本的 SHAP 值。

示例

>>> import numpy as np
>>> import cuml
>>> from cuml.explainer import TreeExplainer
>>> X = np.array([[0.0, 2.0], [1.0, 0.5]])
>>> y = np.array([0, 1])
>>> model = cuml.ensemble.RandomForestRegressor().fit(X, y)
>>> explainer = TreeExplainer(model=model)
>>> shap_values = explainer.shap_values(X)

shap_interaction_values(X, method='shapley-interactions', convert_dtype=True) → CumlArray[source]#

估计一组样本的 SHAP 交互值。对于给定行，SHAP 值加上 expected_value 属性之和等于原始模型预测。“原始模型预测” 是指应用链接函数之前的预测，例如，XGBoost 二分类的 SHAP 值是在加性 logit 空间中，而不是概率空间中。

不支持 Interventional 特征边缘化。

参数:

X: 一个样本矩阵（# 样本 x # 特征），用于解释模型的输出。
method: 其中之一 ['shapley-interactions', 'shapley-taylor']

返回值:

array: 返回一个形状为 (# 类别 x # 样本 x # 特征 x # 特征) 的 SHAP 值矩阵。

shap_values(X, convert_dtype=True) → CumlArray[source]#

估计一组样本的 SHAP 值。对于给定行，SHAP 值加上 expected_value 属性之和等于原始模型预测。“原始模型预测” 是指应用链接函数之前的预测，例如，XGBoost 二分类的 SHAP 值将在加性 logit 空间中，而不是概率空间中。

参数:

X: 一个样本矩阵（# 样本 x # 特征），用于解释模型的输出。

返回值:

array: 返回一个形状为 (# 类别 x # 样本 x # 特征) 的 SHAP 值矩阵。

`fit`(y[, _classes])	将 LabelEncoder (nvcategory) 实例拟合到一组类别
`fit_transform`(y[, z])	同时拟合和转换输入
`inverse_transform`(y)	将有序标签恢复为原始标签
`transform`(y)	将输入转换为其类别键。

`fit`(y)	拟合标签二值化器
`fit_transform`(y)	拟合标签二值化器并将多类别标签转换为其虚拟编码表示。
`inverse_transform`(y[, threshold])	将二进制标签转换回原始多类别标签
`transform`(y)	将多类别标签转换为其虚拟编码表示标签。

`fit`(X[, y])	将 OneHotEncoder 拟合到 X。
`fit_transform`(X[, y])	将 OneHotEncoder 拟合到 X，然后转换 X。等同于 fit(X).transform(X)。
`get_feature_names`([input_features])	返回输出特征的特征名称。
`inverse_transform`(X)	将数据转换回原始表示。
`transform`(X)	使用独热编码转换 X。

`fit`(x, y[, fold_ids])	将 TargetEncoder 实例拟合到一组类别
`fit_transform`(x, y[, fold_ids])	同时拟合和转换输入
`get_params`([deep])	返回此类拥有的所有参数的字典。
`transform`(x)	将输入转换为其类别键。

`fit`(y)	拟合 LabelEncoder 实例到一组类别
`fit_transform`(y[, delayed])	同时拟合和转换输入
`inverse_transform`(y[, delayed])	将数据转换回原始表示。
`transform`(y[, delayed])	将输入转换为其类别键。

`fit`(X)	拟合多节点多 GPU OneHotEncoder 到 X。
`inverse_transform`(X[, delayed])	将数据转换回原始表示。
`transform`(X[, delayed])	使用独热编码转换 X。

`fit`(raw_documents[, y])	构建原始文档中所有词元的词汇表。
`fit_transform`(raw_documents[, y])	构建词汇表并返回文档-词项矩阵。
`get_feature_names`()	将特征整数索引映射到特征名称的数组。
`inverse_transform`(X)	返回 X 中非零项对应的每文档词项。
`transform`(raw_documents)	将文档转换为文档-词项矩阵。

`fit`(X[, y])	此方法仅检查输入类型和模型参数。
`fit_transform`(X[, y])	将文档序列转换为文档-词项矩阵。
`partial_fit`(X[, y])	不执行任何操作：此转换器是无状态的。此方法仅用于标记此转换器可以在流式设置中工作。
`transform`(raw_documents)	将文档转换为文档-词项矩阵。

`fit`(raw_documents)	从训练集中学习词汇表和 idf。
`fit_transform`(raw_documents[, y])	学习词汇表和 idf，返回文档-词项矩阵。
`get_feature_names`()	将特征整数索引映射到特征名称的数组。
`transform`(raw_documents)	将文档转换为文档-词项矩阵。

`fit`(X[, y])	拟合分布式 TFIDF Transformer
`fit_transform`(X[, y])	拟合分布式 TFIDFTransformer，然后转换给定的数据集样本。
`transform`(X[, y])	使用分布式 TFIDFTransformer 转换给定的数据集样本。

`run_cpu`(data[, bench_args])	在指定数据上运行基于 CPU 的算法的 fit 方法
`run_cuml`(data[, bench_args])	在指定数据上运行基于 cuML 的算法的 fit 方法

`fit`(X[, y, convert_dtype])	拟合 GPU 索引以执行最近邻查询。
`kneighbors`([X, n_neighbors, ...])	查询 GPU 索引以获取 X 中列向量的 k 个最近邻居。
`kneighbors_graph`([X, n_neighbors, mode])	查找 X 中列向量的 k 个最近邻居，并以 CSR 格式稀疏矩阵形式返回。

`fit`(X)	拟合多节点多 GPU 最近邻索引
`get_neighbors`(n_neighbors)	如果 n_neighbors 为 None，则返回从构造函数初始化的默认 n_neighbors。
`kneighbors`([X, n_neighbors, ...])	查询分布式最近邻索引

`fit`(X, y)	拟合多节点多 GPU K-Nearest Neighbors 回归索引
`predict`(X[, convert_dtype])	从先前存储的索引和输出预测查询的输出。
`score`(X, y)	通过比较预测和真实值提供得分。

`fit`(X, y)	拟合多节点多 GPU K-Nearest Neighbors 分类索引
`predict`(X[, convert_dtype])	从先前存储的索引和索引标签预测查询的标签。
`predict_proba`(X[, convert_dtype])	通过比较预测和真实值提供得分。
`score`(X, y[, convert_dtype])	从先前存储的索引和索引标签预测查询的标签。

API 参考#

模块配置#

输出数据类型配置#

CPU / GPU 设备选择（实验性）#

详细程度级别#

预处理、指标与工具#

模型选择与数据分割#

特征与标签编码（单 GPU）#

待转换的输入键。其值不必与传递给 fit 的类别匹配

其他预处理方法（单 GPU）#

文本预处理 (单 GPU)#

特征和标签编码 (基于 Dask 的多 GPU)#

特征提取 (单 GPU)#

特征提取 (基于 Dask 的多 GPU)#

数据集生成 (单 GPU)#

数据集生成 (基于 Dask 的多 GPU)#

指标（回归、分类和距离）#

指标（聚类和流形学习）#

参数#

返回值#

基准测试#

回归与分类#

线性回归#

逻辑回归#

岭回归#

Lasso 回归#

ElasticNet 回归#

小批量 SGD 分类器#

Mini Batch SGD 回归器#

多类别分类#

多项式朴素贝叶斯分类器适用于具有离散特征的分类（例如，文本分类的词频）。

您可以导出 cuML 随机森林模型，并在没有 NVIDIA GPU 的机器上使用它们运行预测。有关更多详细信息，请参阅 https://docs.rapids.org.cn/api/cuml/stable/pickling_cuml_models.html。

如果类型为 float，则 max_features 用作一个分数。

森林推理#

坐标下降#

拟牛顿法 (Quasi-Newton)#

支持向量机 (Support Vector Machines)#

最近邻分类 (Nearest Neighbors Classification)#

最近邻回归 (Nearest Neighbors Regression)#

核岭回归 (Kernel Ridge Regression)#

聚类 (Clustering)#

K-均值聚类 (K-Means Clustering)#

DBSCAN#

层次聚类#

HDBSCAN#

降维与流形学习#

主成分分析#

增量主成分分析#

截断奇异值分解#

UMAP#

随机投影#

TSNE#

邻居#

最近邻#

最近邻分类#

最近邻回归#

核密度估计#

时间序列#

霍尔特-温特斯 (HoltWinters)#

自回归积分滑动平均 (ARIMA)#

模型可解释性#

SHAP 核解释器#

SHAP 置换解释器#

多节点、多 GPU 算法#

DBSCAN 聚类#

K-Means 聚类#

最近邻#

主成分分析#

随机森林#

截断奇异值分解#

流形#

线性模型#

朴素贝叶斯#

求解器#

Dask 基础类和 Mixin#

实验性#

线性模型#

模型可解释性#

本页

待转换的输入键。其值不必与传递给 `fit` 的类别匹配

如果类型为 `float`，则 `max_features` 用作一个分数。