聚合分组#

group aggregation_groupby
struct aggregation_request#
#include <groupby.hpp>

请求对列执行groupby聚合操作。

每个value[i]的组成员关系由用于构建groupby的keys的原始顺序中的相应行i确定。即，对于每个aggregation，values[i]与所有其他values[j]进行聚合，其中keys中的行i和j是等价的。

values.size() 列必须等于 keys.num_rows()。

公共成员

column_view values#

要聚合的元素。

std::vector<std::unique_ptr<groupby_aggregation>> aggregations#

期望的聚合。

struct scan_request#
#include <groupby.hpp>

请求对列进行分组聚合扫描。

每个value[i]的组成员关系由用于构造groupby的keys的原始顺序中的相应行i决定。即，对于每个aggregation，values[i]与所有其他values[j]进行聚合，其中keys中的行i和j是等价的。

values.size() 列必须等于 keys.num_rows()。

公共成员

column_view values#

要聚合的元素。

std::vector<std::unique_ptr<groupby_scan_aggregation>> aggregations#

期望的聚合。

struct aggregation_result#
#include <groupby.hpp>

aggregation_request 的结果

对于每一个提供给aggregation_request的groupby::aggregate，都会返回一个aggregation_result。aggregation_result保存了每个请求的聚合操作在request值上的结果列。

公共成员

std::vector<std::unique_ptr<column>> results = {}#

来自aggregation_request的结果列

class groupby#
#include <groupby.hpp>

按键分组值并计算这些组的聚合。

公共函数

explicit groupby(table_view const &keys, null_policy null_handling = null_policy::EXCLUDE, sorted keys_are_sorted = sorted::NO, std::vector<order> const &column_order = {}, std::vector<null_order> const &null_precedence = {})#

使用指定的keys构造一个groupby对象

如果 keys 已经排序，通过传递 keys_are_sorted == true 并分别在 column_order 和 null_precedence 中指示每列的升序/降序和空值顺序，可能会获得更好的性能。

注意

此对象不维护keys的生命周期。用户有责任确保groupby对象不会超过keys所查看的数据的生命周期table_view。

Parameters:

  • keys – 表的行作为分组键

  • null_handling – 表示是否应包含keys中包含NULL值的行

  • keys_are_sorted – 表示keys中的行是否已经排序

  • column_order – 如果 keys_are_sorted == YES，表示每列是升序/降序。如果为空，则假定所有列都是升序。如果 keys_are_sorted == false，则忽略此参数。

  • null_precedence – 如果 keys_are_sorted == YES，表示每列中空值的排序方式。否则，忽略。如果为空，则假定所有列使用 null_order::AFTER。如果 keys_are_sorted == false，则忽略。

std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> aggregate(host_span<aggregation_request const> requests, rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

对指定的值执行分组聚合。

要聚合的值和要执行的聚合操作在aggregation_request中指定。每个请求包含一个column_view的聚合值集合和一组要在这些元素上执行的aggregation操作。

对于请求中的每个aggregation，values[i]将与所有其他values[j]进行聚合，其中keys中的行i和j是等价的。

请求列的size()必须等于keys.num_rows()。

对于每一个aggregation_request，都会返回一个aggregation_result。aggregation_result包含了每个请求的聚合操作在request值上的结果列。每个结果中的列顺序与请求中指定的顺序相同。

返回的table包含每个组的组标签，即keys中的唯一行。所有聚合结果中的元素i属于组标签表中第i行的组。

组标签中的行顺序是任意的。此外，连续的groupby::aggregate调用可能会以不同的顺序返回结果。

示例：

Input:
keys:     {1 2 1 3 1}
          {1 2 1 4 1}
request:
  values: {3 1 4 9 2}
  aggregations: {{SUM}, {MIN}}

result:

keys:  {3 1 2}
       {4 1 2}
values:
  SUM: {9 9 1}
  MIN: {9 2 1}

Throws:

cudf::logic_error – 如果 requests[i].values.size() != keys.num_rows()。

Parameters:

  • requests – 要聚合的列集以及要执行的聚合操作

  • mr – 用于分配返回表和列的设备内存的设备内存资源

Returns:

包含每个组的唯一键的表和每个请求的聚合结果向量的对，顺序与requests中指定的顺序相同。

std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> aggregate(host_span<aggregation_request const> requests, rmm::cuda_stream_view stream, rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

对指定的值执行分组聚合。

要聚合的值和要执行的聚合操作在aggregation_request中指定。每个请求包含一个column_view的聚合值集合和一组要在这些元素上执行的aggregation操作。

对于请求中的每个aggregation，values[i]将与所有其他values[j]进行聚合，其中keys中的行i和j是等价的。

请求列的size()必须等于keys.num_rows()。

对于每一个aggregation_request，都会返回一个aggregation_result。aggregation_result包含了每个请求的聚合操作在request值上的结果列。每个结果中的列的顺序与请求中指定的顺序相同。

返回的table包含每个组的组标签，即keys中的唯一行。所有聚合结果中的元素i属于组标签表中第i行的组。

组标签中的行顺序是任意的。此外，连续的groupby::aggregate调用可能会以不同的顺序返回结果。

示例：

Input:
keys:     {1 2 1 3 1}
          {1 2 1 4 1}
request:
  values: {3 1 4 9 2}
  aggregations: {{SUM}, {MIN}}

result:

keys:  {3 1 2}
       {4 1 2}
values:
  SUM: {9 9 1}
  MIN: {9 2 1}

Throws:

cudf::logic_error – 如果 requests[i].values.size() != keys.num_rows()。

Parameters:

  • requests – 要聚合的列集以及要执行的聚合操作

  • mr – 用于分配返回表和列的设备内存的设备内存资源

  • stream – 用于设备内存操作和内核启动的CUDA流。

Returns:

包含每个组的唯一键的表和每个请求的聚合结果向量的对，顺序与requests中指定的顺序相同。

std::pair<std::unique_ptr<table>, std::vector<aggregation_result>> scan(host_span<scan_request const> requests, rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

对指定值执行分组扫描。

要聚合的值和要执行的聚合操作在aggregation_request中指定。每个请求包含一个column_view的聚合值集合和一组要在这些元素上执行的aggregation操作。

对于请求中的每个aggregation，values[i]会与所有之前的values[j]进行扫描聚合，其中keys中的行i和j是等价的。

请求列的size()必须等于keys.num_rows()。

对于每一个aggregation_request，都会返回一个aggregation_result。aggregation_result包含了每个请求的聚合操作在request值上的结果列。每个结果中的列的顺序与请求中指定的顺序相同。

返回的 table 包含每行的组标签，即提供给 groupby 对象的 keys。所有聚合结果中的元素 i 属于组标签表中第 i 行的组。

组标签中的行顺序是任意的。此外，连续的groupby::scan调用可能会以不同的顺序返回结果。

示例：

Input:
keys:     {1 2 1 3 1}
          {1 2 1 4 1}
request:
  values: {3 1 4 9 2}
  aggregations: {{SUM}, {MIN}}

result:

keys:  {3 1 1 1 2}
       {4 1 1 1 2}
values:
  SUM: {9 3 7 9 1}
  MIN: {9 3 3 2 1}

Throws:

cudf::logic_error – 如果 requests[i].values.size() != keys.num_rows()。

Parameters:

  • requests – 要扫描的列集和要执行的扫描

  • mr – 用于分配返回表和列的设备内存的设备内存资源

Returns:

包含每个组的键的表和每个请求的聚合结果向量的对，顺序与requests中指定的顺序相同。

std::pair<std::unique_ptr<table>, std::unique_ptr<table>> shift(table_view const &values, host_span<size_type const> offsets, std::vector<std::reference_wrapper<scalar const>> const &fill_values, rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

对指定值执行分组移位。

在第j列中，对于每个组，第i个元素由该组的第i - offsets[j]个元素决定。如果i - offsets[j] < 0 or >= group_size，则该值由fill_values[j]决定。

示例：

keys:    {1 4 1 3 4 4 1}
         {1 2 1 3 2 2 1}
values:  {3 9 1 4 2 5 7}
         {"a" "c" "bb" "ee" "z" "x" "d"}
offset:  {2, -1}
fill_value: {@, @}
result (group order maybe different):
   keys:   {3 1 1 1 4 4 4}
           {3 1 1 1 2 2 2}
   values: {@ @ @ 3 @ @ 9}
           {@ "bb" "d" @ "z" "x" @}

-------------------------------------------------
keys:    {1 4 1 3 4 4 1}
         {1 2 1 3 2 2 1}
values:  {3 9 1 4 2 5 7}
         {"a" "c" "bb" "ee" "z" "x" "d"}
offset:  {-2, 1}
fill_value: {-1, "42"}
result (group order maybe different):
   keys:   {3 1 1 1 4 4 4}
           {3 1 1 1 2 2 2}
   values: {-1 7 -1 -1 5 -1 -1}
           {"42" "42" "a" "bb" "42" "c" "z"}

注意

第一个返回的表存储传递给groupby对象的键。键表的第i行对应于移位列中第i行的组标签。每个组中的键顺序与输入顺序匹配。每个组的顺序是任意的。在连续调用groupby::shifts时，组的顺序可能不同。

Parameters:

  • values – 需要移动列的表格

  • offsets – 用于移动输入的偏移量

  • fill_values – 用于无法确定输出的填充值

  • mr – 用于分配返回表和列的设备内存的设备内存资源

Throws:

cudf::logic_error – 如果 fill_value[i] 的数据类型与 values[i] 的数据类型不匹配，对于第 i 列

Returns:

包含每个组的键和移动的列的表格对

groups get_groups(cudf::table_view values = {}, rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

获取与一组值上的groupby操作相对应的分组键和值。

返回一个表示分组键和值的groups对象。如果未提供值，则仅对键进行分组，并且groups对象的values将为nullptr。

Parameters:

  • values – 表示要在其上执行分组操作的表

  • mr – 用于分配返回组中返回表的设备内存的设备内存资源

Returns:

一个表示分组键和值的 groups 对象

std::pair<std::unique_ptr<table>, std::unique_ptr<table>> replace_nulls(table_view const &values, host_span<cudf::replace_policy const> replace_policies, rmm::device_async_resource_ref mr = cudf::get_current_device_resource_ref())#

对value执行分组替换空值。

对于组 j 中的每个 value[i] == NULL，value[i] 将被替换为组 j 中在 value[i] 之前或之后的第一个非空值。如果在指定方向上未找到非空值，则 value[i] 保持为 NULL。

返回的对包含一列排序的键和结果列。在结果列中，同一组的值在连续的内存中。在每组中，值的顺序保持其原始顺序。组的顺序不保证。

示例：

//Inputs:
keys:    {3 3 1 3 1 3 4}
         {2 2 1 2 1 2 5}
values:  {3 4 7 @ @ @ @}
         {@ @ @ "x" "tt" @ @}
replace_policies:    {FORWARD, BACKWARD}

//Outputs (group orders may be different):
keys:    {3 3 3 3 1 1 4}
         {2 2 2 2 1 1 5}
result:  {3 4 4 4 7 7 @}
         {"x" "x" "x" @ "tt" "tt" @}

Parameters:

  • values – [in] 一个表格，其列中的空值将被替换

  • replace_policies – [in] 指定替换值相对于空值的位置，每列一个

  • mr – [in] 用于分配返回列的设备内存的设备内存资源

Returns:

包含一个带有排序键和结果列的表的对

struct groups#
#include <groupby.hpp>

对应于一组值的groupby操作的分组数据。

一个groups对象包含两个行数相同的表：一个分组键表和一个分组值表。此外，它还包含一个整数偏移量的向量，指向表的行，使得offsets[i+1] - offsets[i]给出组i的大小。

公共成员

std::unique_ptr<table> keys#

分组键表。

std::vector<size_type> offsets#

分组偏移量。

std::unique_ptr<table> values#

分组值的表格。