discretize

将数据划分为 bin 或类别

全页折叠

语法

Y = discretize(X,edges)
[Y,E] = discretize(X,N)
[Y,E] = discretize(X,dur)
[___] = discretize(___,values)
[___] = discretize(___,'categorical')
[___] = discretize(___,'categorical',displayFormat)
[___] = discretize(___,'categorical',categoryNames)
[___] = discretize(___,'IncludedEdge',side)

说明

Y = discretize(X,edges) 返回包含 X 的元素的 bin 索引。假定 N 是 bin 数量，length(edges) = N+1，则当 1 <= j < N 且 edges(j) <= X(i) < edges(j+1) 时，第 j 个 bin 将包含元素 X(i)。最后一个 bin 同时包含左右边界，满足 edges(N) <= X(i) <= edges(N+1)。

示例

[Y,E] = discretize(X,N) 将 X 中的数据分成宽度一致的 N 个 bin，还会返回 bin 边界 E。

示例

[Y,E] = discretize(X,dur)，其中 X 是日期时间或持续时间数组，将 X 分成时间长度为 dur 的均匀的 bin。dur 可以为标量、duration 或 calendarDuration，或者是时间单位。例如，[Y,E] = discretize(X,'hour') 将 X 分成持续时间统一为 1 小时的 bin。

示例

[___] = discretize(___,values) 使用任何上述输入或输出参量组合返回 values 中对应的元素，而非 bin 编号。例如，如果 X(1) 位于第 5 个 bin 内，则 Y(1) 为 values(5)，而非 5。values 必须是长度等于 bin 数量的向量。

示例

[___] = discretize(___,'categorical') 创建一个分类数组，一个 bin 代表一个类别。大多数情况下，默认类别名称的格式为“[A,B)”（或对于最后一个 bin 为“[A,B]”），其中 A 和 B 是连续 bin 边界。如果您指定 dur 为字符向量，则默认类别名称可能具有特殊格式。请参阅 Y 获取显示格式的列表。

示例

[___] = discretize(___,'categorical',displayFormat)，对于日期时间或持续时间数组输入，在输出的类别名称中使用指定的日期时间或持续时间显示格式。

示例

[___] = discretize(___,'categorical',categoryNames) 还使用字符向量 categoryNames 的元胞数组命名 Y 中的类别。categoryNames 的长度必须等于 bin 的数量。

示例

[___] = discretize(___,'IncludedEdge',side)，其中 side 是 'left' 或 'right'，指定是否每个 bin 都包含其左或右 bin 边界。例如，如果 side 为 'right'，则每个 bin 都包含 bin 的右边界，同时包含左右边界的第一个 bin 除外。在这种情况下，如果 edges(j) < X(i) <= edges(j+1)（其中 1 < j <= N，N 是 bin 的数量），则第 j 个 bin 将包含元素 X(i)。第一个 bin 包含左边界，因此它包含 edges(1) <= X(i) <= edges(2)。side 的默认值为 'left'。

示例

示例

全部折叠

打开实时脚本

使用 discretize 将数值分组到离散 bin。edges 定义五个 bin 边界，因此有四个 bin。

data = [1 1 2 3 6 5 8 10 4 4]
data = 1×10

     1     1     2     3     6     5     8    10     4     4


edges = 2:2:10
edges = 1×5

     2     4     6     8    10


Y = discretize(data,edges)
Y = 1×10

   NaN   NaN     1     1     3     2     4     4     2     2

Y 表示数据的每个元素属于哪个 bin。由于值 1 超出了 bin 范围，因此 Y 会在这些元素位置包含 NaN 值。

打开实时脚本

将随机数据分组到三个 bin 中。指定第二个输出返回通过 discretize 计算的 bin 边界。

X = randn(10,1);
[Y,E] = discretize(X,3)
Y = 10×1

     2
     2
     1
     2
     2
     1
     1
     2
     3
     2


E = 1×4

    -3     0     3     6
打开实时脚本

使用 2016 年的随机日期创建 10×1 日期时间向量。然后，按月组合日期时间值，并作为分类数组返回结果。

X = datetime(2016,1,randi(365,10,1))
X = 10×1 datetime
   24-Oct-2016
   26-Nov-2016
   16-Feb-2016
   29-Nov-2016
   18-Aug-2016
   05-Feb-2016
   11-Apr-2016
   18-Jul-2016
   15-Dec-2016
   18-Dec-2016


Y = discretize(X,'month','categorical')
Y = 10×1 categorical
     Oct-2016 
     Nov-2016 
     Feb-2016 
     Nov-2016 
     Aug-2016 
     Feb-2016 
     Apr-2016 
     Jul-2016 
     Dec-2016 
     Dec-2016
打开实时脚本

按小时对持续时间值进行分组，并以各种显示格式返回结果。

按小时对一些随机的持续时间值进行分组，并作为分类数组返回结果。

X = hours(abs(randn(1,10)))'
X = 10×1 duration
   0.53767 hr
    1.8339 hr
    2.2588 hr
   0.86217 hr
   0.31877 hr
    1.3077 hr
   0.43359 hr
   0.34262 hr
    3.5784 hr
    2.7694 hr


Y = discretize(X,'hour','categorical')
Y = 10×1 categorical
     [0 hr, 1 hr) 
     [1 hr, 2 hr) 
     [2 hr, 3 hr) 
     [0 hr, 1 hr) 
     [0 hr, 1 hr) 
     [1 hr, 2 hr) 
     [0 hr, 1 hr) 
     [0 hr, 1 hr) 
     [3 hr, 4 hr] 
     [2 hr, 3 hr)

将显示的结果更改为分钟数。

Y = discretize(X,'hour','categorical','m')
Y = 10×1 categorical
     [0 min, 60 min) 
     [60 min, 120 min) 
     [120 min, 180 min) 
     [0 min, 60 min) 
     [0 min, 60 min) 
     [60 min, 120 min) 
     [0 min, 60 min) 
     [0 min, 60 min) 
     [180 min, 240 min] 
     [120 min, 180 min)

再次更改格式以显示为小时、分钟和秒数。

Y = discretize(X,'hour','categorical','hh:mm:ss')
Y = 10×1 categorical
     [00:00:00, 01:00:00) 
     [01:00:00, 02:00:00) 
     [02:00:00, 03:00:00) 
     [00:00:00, 01:00:00) 
     [00:00:00, 01:00:00) 
     [01:00:00, 02:00:00) 
     [00:00:00, 01:00:00) 
     [00:00:00, 01:00:00) 
     [03:00:00, 04:00:00] 
     [02:00:00, 03:00:00)
打开实时脚本

将每个 bin 的右边界用作 values 输入。每个 bin 中的元素的值始终少于该 bin 的值。

X = randi(100,1,10);
edges = 0:25:100;
values = edges(2:end);
Y = discretize(X,edges,values)
Y = 1×10

   100   100    25   100    75    25    50    75   100   100
打开实时脚本

使用 'IncludedEdge' 输入指定每个 bin 都包含 bin 的右边界。第一个 bin 同时包含左右边界。将结果与默认包含左边界的 bin 结果进行比较。

X = 1:2:11;
edges = [1 3 4 7 10 11];
Y = discretize(X,edges,'IncludedEdge','right')
Y = 1×6

     1     1     3     3     4     5


Z = discretize(X,edges)
Z = 1×6

     1     2     3     4     4     5
打开实时脚本

将数值数据分组到分类数组。使用结果确认落在均值的一个标准差范围之内的数据量。

根据到均值的距离（用标准差测量所得）将正态分布数据划分为 bin。

X = randn(1000,1);
edges = std(X)*(-3:3);
Y = discretize(X,edges, 'categorical', ...
    {'-3sigma', '-2sigma', '-sigma', 'sigma', '2sigma', '3sigma'});

对于 X 中比均值大 3 个标准差的元素，Y 包含未定义的分类值。

预览 Y 中的值。 

Y(1:15)
ans = 15×1 categorical
     sigma 
     2sigma 
     -3sigma 
     sigma 
     sigma 
     -2sigma 
     -sigma 
     sigma 
     <undefined> 
     3sigma 
     -2sigma 
     <undefined> 
     sigma 
     -sigma 
     sigma

确认大约 68% 的数据落在均值的一个标准差范围之内。

nnz(Y=='-sigma' | Y=='sigma')/numel(Y)
ans = 
0.6910

输入参数

全部折叠

输入数组，指定为向量、矩阵或多维数组。X 包含您希望分布到 bin 中的数据。

数据类型: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical | datetime | duration

bin 边界，指定为值递增的数值向量。bin 边界可以包含连续的重复元素。edges 中的连续元素形成离散的 bin，discretize 使用这些 bin 对 X 中的数据进行分区。默认情况下，每个 bin 都包括 bin 的左边界，除了最后一个 bin，它包含 bin 的左右边界。

edges 必须包含至少两个元素，因为 edges(1) 是第一个 bin 的左边界，edges(end) 是最后一个 bin 的右边界。

示例: Y = discretize([1 3 5],[0 2 4 6]) 将值 1、3 和 5 分布到三个 bin 中，它们的边界分别为 [0,2)、[2,4) 和 [4,6]。

数据类型: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical | datetime | duration

bin 数量，指定为整数标量。

discretize 将数据分为 N 个宽度一致的 bin，从而选择与数据范围重叠“良好”的 bin 边界。X 中最大和最小的元素通常不会正好落在 bin 边界上。如果数据分布不均匀，则一些中间 bin 可能为空。但是，第一个和最后一个 bin 始终至少包含一段数据。

示例: [Y,E] = discretize(X,5) 将 X 中的数据划分为 5 个具有均匀宽度的 bin。

统一的 bin 持续时间，指定为标量 duration 或 calendarDuration，或指定为下表中的值之一。

如果指定 dur，则 discretize 最多可以使用 65,536（即 216）个 bin。如果指定的 bin 持续时间需要多个 bin，则 discretize 使用与最大 bin 数对应的较大的 bin 宽度。

值适用于...描述
'second'

日期时间或持续时间值

每个 bin 是 1 秒。

'minute'

日期时间或持续时间值

每个 bin 是 1 分钟。

'hour'

日期时间或持续时间值

每个 bin 是 1 小时。

'day'

日期时间或持续时间值

  • 对于日期时间输入，每个 bin 是 1 个日历日。此值将夏令时变化考虑在内。

  • 对于持续时间输入，每个 bin 是固定长度的 1 天（24 小时）。

'week'

日期时间值

每个 bin 是 1 个日历周。
'month'

日期时间值

每个 bin 是 1 个日历月。
'quarter'

日期时间值

每个 bin 是 1 个日历季度。
'year'

日期时间或持续时间值

  • 对于日期时间输入，每个 bin 是 1 个日历年。此值将闰日考虑在内。

  • 对于持续时间输入，每个 bin 是固定长度的 1 年（365.2425 天）。

'decade'

日期时间值

每个 bin 是 1 个十年（10 个日历年）。
'century'

日期时间值

每个 bin 是 1 个世纪（100 个日历年）。

示例: [Y,E] = discretize(X,'hour') 将 X 分成持续时间统一为 1 小时的 bin。

数据类型: char | duration | calendarDuration

bin 值，指定为任何数据类型的向量。values 的长度必须与 bin 数量 length(edges)-1 相同。由 values 中的元素替换输出中的普通 bin 索引。即，如果 X(1) 属于 bin 2 内，则 discretize 会将 Y(1) 返回为 values(2)，而不是 2。

如果 values 是元胞数组，则所有输入数据必须都属于 bin。

示例: Y = discretize(randi(5,10,1),[1 1.5 3 5],diff([1 1.5 3 5])) 返回 bin 的宽度，而非范围从 1 到 3 的索引。

日期时间和持续时间显示格式，指定为字符向量。displayFormat 值并不更改 Y 中的值，只会更改它们的显示格式。您可以使用日期时间和持续时间数组的任何有效显示格式指定 displayFormat。有关可用选项的详细信息，请参阅设置日期时间显示格式。

示例: discretize(X,'day','categorical','h') 指定持续时间数组的显示格式。

示例: discretize(X,'day','categorical','yyyy-MM-dd') 指定日期时间数组的显示格式。

数据类型: char

分类数组的类别名称，指定为字符向量元胞数组。categoryNames 的长度必须等于 bin 数量。

示例: Y = discretize(randi(5,10,1),[1 1.5 3 5],'categorical',{'A' 'B' 'C'}) 将数据分布到三个类别中：A、B 和 C。

数据类型: cell

每个 bin 中包含的边界，指定为下列值之一：

  • 'left' - 所有 bin 都包含左边界，但最后一个 bin 除外，它同时包含左右边界。这是默认设置。

  • 'right' - 所有 bin 都包含右边界，但第一个 bin 除外，它同时包含左右边界。

示例: Y = discretize(randi(11,10,1),1:2:11,'IncludedEdge','right') 在每个 bin 都包含 bin 的右边界。

输出参量

全部折叠

bin，以数值向量、矩阵、多维数组或有序分类数组形式返回。Y 的大小与 X 相同，并且每个元素用于指定 X 中对应元素所在的 bin。如果指定 values，则 Y 与 values 具有相同的数据类型。超出范围的元素以不同方式表示，具体取决于输出的数据类型：

  • 对于数值输出，针对 X 中超出范围的元素（即 X(i) < edges(1) 或 X(i) > edges(end)），或者 X 包含 NaN 时，Y 将包含 NaN 值。

  • 如果 Y 为分类数组，对于超出范围的元素或 NaN 输入，它将包含未定义元素。

  • 如果 values 是整数数据类型的向量，对于超出范围的元素或 NaN 输入，Y 将包含 0。

对于语法 discretize(X,dur,'categorical')，Y 中默认的类别名称格式有：

dur 的值默认类别名称格式格式示例
'second'

全局默认格式

28-Jan-2016 10:32:06

'minute'
'hour'
'day'

全局默认日期格式

28-Jan-2016

'week'

[global_default_date_format, global_default_date_format)

[24-Jan-2016, 30-Jan-2016)

'month'

'MMM-uuuu'

Jun-2016

'quarter'

'QQQ uuuu'

Q4 2015

'year'

'uuuu'

2016

'decade'

'[uuuu, uuuu)'

[2010, 2020)

'century'

bin 边界，以向量形式返回。指定此输出，以便在未显式传入 bin 边界的情况下查看 discretize 计算的 bin 边界。

每当 discretize 计算 bin 边界时，E 以行向量形式返回。如果您传入 bin 边界，则 E 保留 edges 输入的方向。

提示

  • discretize 的行为与 histcounts 函数的行为类似。使用 histcounts 查找每个 bin 中的元素数量。另一方面，使用 discretize 可查找每个元素所属的 bin（不计数）。

扩展功能

全部展开

C/C++ 代码生成
使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

版本历史记录

在 R2015a 中推出

另请参阅

| |

主题