• 12.1 分类数据
    • 背景和目的
    • pandas的分类类型
    • 用分类进行计算
    • 用分类提高性能
    • 分类方法
    • 为建模创建虚拟变量

    12.1 分类数据

    这一节介绍的是pandas的分类类型。我会向你展示通过使用它,提高性能和内存的使用率。我还会介绍一些在统计和机器学习中使用分类数据的工具。

    背景和目的

    表中的一列通常会有重复的包含不同值的小集合的情况。我们已经学过了unique和value_counts,它们可以从数组提取出不同的值,并分别计算频率:

    1. In [10]: import numpy as np; import pandas as pd
    2. In [11]: values = pd.Series(['apple', 'orange', 'apple',
    3. ....: 'apple'] * 2)
    4. In [12]: values
    5. Out[12]:
    6. 0 apple
    7. 1 orange
    8. 2 apple
    9. 3 apple
    10. 4 apple
    11. 5 orange
    12. 6 apple
    13. 7 apple
    14. dtype: object
    15. In [13]: pd.unique(values)
    16. Out[13]: array(['apple', 'orange'], dtype=object)
    17. In [14]: pd.value_counts(values)
    18. Out[14]:
    19. apple 6
    20. orange 2
    21. dtype: int64

    许多数据系统(数据仓库、统计计算或其它应用)都发展出了特定的表征重复值的方法,以进行高效的存储和计算。在数据仓库中,最好的方法是使用所谓的包含不同值的维表(Dimension Table),将主要的参数存储为引用维表整数键:

    1. In [15]: values = pd.Series([0, 1, 0, 0] * 2)
    2. In [16]: dim = pd.Series(['apple', 'orange'])
    3. In [17]: values
    4. Out[17]:
    5. 0 0
    6. 1 1
    7. 2 0
    8. 3 0
    9. 4 0
    10. 5 1
    11. 6 0
    12. 7 0
    13. dtype: int64
    14. In [18]: dim
    15. Out[18]:
    16. 0 apple
    17. 1 orange
    18. dtype: object

    可以使用take方法存储原始的字符串Series:

    1. In [19]: dim.take(values)
    2. Out[19]:
    3. 0 apple
    4. 1 orange
    5. 0 apple
    6. 0 apple
    7. 0 apple
    8. 1 orange
    9. 0 apple
    10. 0 apple
    11. dtype: object

    这种用整数表示的方法称为分类或字典编码表示法。不同值得数组称为分类、字典或数据级。本书中,我们使用分类的说法。表示分类的整数值称为分类编码或简单地称为编码。

    分类表示可以在进行分析时大大的提高性能。你也可以在保持编码不变的情况下,对分类进行转换。一些相对简单的转变例子包括:

    • 重命名分类。
    • 加入一个新的分类,不改变已经存在的分类的顺序或位置。

    pandas的分类类型

    pandas有一个特殊的分类类型,用于保存使用整数分类表示法的数据。看一个之前的Series例子:

    1. In [20]: fruits = ['apple', 'orange', 'apple', 'apple'] * 2
    2. In [21]: N = len(fruits)
    3. In [22]: df = pd.DataFrame({'fruit': fruits,
    4. ....: 'basket_id': np.arange(N),
    5. ....: 'count': np.random.randint(3, 15, size=N),
    6. ....: 'weight': np.random.uniform(0, 4, size=N)},
    7. ....: columns=['basket_id', 'fruit', 'count', 'weight'])
    8. In [23]: df
    9. Out[23]:
    10. basket_id fruit count weight
    11. 0 0 apple 5 3.858058
    12. 1 1 orange 8 2.612708
    13. 2 2 apple 4 2.995627
    14. 3 3 apple 7 2.614279
    15. 4 4 apple 12 2.990859
    16. 5 5 orange 8 3.845227
    17. 6 6 apple 5 0.033553
    18. 7 7 apple 4 0.425778

    这里,df[‘fruit’]是一个Python字符串对象的数组。我们可以通过调用它,将它转变为分类:

    1. In [24]: fruit_cat = df['fruit'].astype('category')
    2. In [25]: fruit_cat
    3. Out[25]:
    4. 0 apple
    5. 1 orange
    6. 2 apple
    7. 3 apple
    8. 4 apple
    9. 5 orange
    10. 6 apple
    11. 7 apple
    12. Name: fruit, dtype: category
    13. Categories (2, object): [apple, orange]

    fruit_cat的值不是NumPy数组,而是一个pandas.Categorical实例:

    1. In [26]: c = fruit_cat.values
    2. In [27]: type(c)
    3. Out[27]: pandas.core.categorical.Categorical

    分类对象有categories和codes属性:

    1. In [28]: c.categories
    2. Out[28]: Index(['apple', 'orange'], dtype='object')
    3. In [29]: c.codes
    4. Out[29]: array([0, 1, 0, 0, 0, 1, 0, 0], dtype=int8)

    你可将DataFrame的列通过分配转换结果,转换为分类:

    1. In [30]: df['fruit'] = df['fruit'].astype('category')
    2. In [31]: df.fruit
    3. Out[31]:
    4. 0 apple
    5. 1 orange
    6. 2 apple
    7. 3 apple
    8. 4 apple
    9. 5 orange
    10. 6 apple
    11. 7 apple
    12. Name: fruit, dtype: category
    13. Categories (2, object): [apple, orange]

    你还可以从其它Python序列直接创建pandas.Categorical:

    1. In [32]: my_categories = pd.Categorical(['foo', 'bar', 'baz', 'foo', 'bar'])
    2. In [33]: my_categories
    3. Out[33]:
    4. [foo, bar, baz, foo, bar]
    5. Categories (3, object): [bar, baz, foo]

    如果你已经从其它源获得了分类编码,你还可以使用from_codes构造器:

    1. In [34]: categories = ['foo', 'bar', 'baz']
    2. In [35]: codes = [0, 1, 2, 0, 0, 1]
    3. In [36]: my_cats_2 = pd.Categorical.from_codes(codes, categories)
    4. In [37]: my_cats_2
    5. Out[37]:
    6. [foo, bar, baz, foo, foo, bar]
    7. Categories (3, object): [foo, bar, baz]

    与显示指定不同,分类变换不认定指定的分类顺序。因此取决于输入数据的顺序,categories数组的顺序会不同。当使用from_codes或其它的构造器时,你可以指定分类一个有意义的顺序:

    1. In [38]: ordered_cat = pd.Categorical.from_codes(codes, categories,
    2. ....: ordered=True)
    3. In [39]: ordered_cat
    4. Out[39]:
    5. [foo, bar, baz, foo, foo, bar]
    6. Categories (3, object): [foo < bar < baz]

    输出[foo < bar < baz]指明‘foo’位于‘bar’的前面,以此类推。无序的分类实例可以通过as_ordered排序:

    1. In [40]: my_cats_2.as_ordered()
    2. Out[40]:
    3. [foo, bar, baz, foo, foo, bar]
    4. Categories (3, object): [foo < bar < baz]

    最后要注意,分类数据不需要字符串,尽管我仅仅展示了字符串的例子。分类数组可以包括任意不可变类型。

    用分类进行计算

    与非编码版本(比如字符串数组)相比,使用pandas的Categorical有些类似。某些pandas组件,比如groupby函数,更适合进行分类。还有一些函数可以使用有序标志位。

    来看一些随机的数值数据,使用pandas.qcut面元函数。它会返回pandas.Categorical,我们之前使用过pandas.cut,但没解释分类是如何工作的:

    1. In [41]: np.random.seed(12345)
    2. In [42]: draws = np.random.randn(1000)
    3. In [43]: draws[:5]
    4. Out[43]: array([-0.2047, 0.4789, -0.5194, -0.5557, 1.9658])

    计算这个数据的分位面元,提取一些统计信息:

    1. In [44]: bins = pd.qcut(draws, 4)
    2. In [45]: bins
    3. Out[45]:
    4. [(-0.684, -0.0101], (-0.0101, 0.63], (-0.684, -0.0101], (-0.684, -0.0101], (0.63,
    5. 3.928], ..., (-0.0101, 0.63], (-0.684, -0.0101], (-2.95, -0.684], (-0.0101, 0.63
    6. ], (0.63, 3.928]]
    7. Length: 1000
    8. Categories (4, interval[float64]): [(-2.95, -0.684] < (-0.684, -0.0101] < (-0.010
    9. 1, 0.63] <
    10. (0.63, 3.928]]

    虽然有用,确切的样本分位数与分位的名称相比,不利于生成汇总。我们可以使用labels参数qcut,实现目的:

    1. In [46]: bins = pd.qcut(draws, 4, labels=['Q1', 'Q2', 'Q3', 'Q4'])
    2. In [47]: bins
    3. Out[47]:
    4. [Q2, Q3, Q2, Q2, Q4, ..., Q3, Q2, Q1, Q3, Q4]
    5. Length: 1000
    6. Categories (4, object): [Q1 < Q2 < Q3 < Q4]
    7. In [48]: bins.codes[:10]
    8. Out[48]: array([1, 2, 1, 1, 3, 3, 2, 2, 3, 3], dtype=int8)

    加上标签的面元分类不包含数据面元边界的信息,因此可以使用groupby提取一些汇总信息:

    1. In [49]: bins = pd.Series(bins, name='quartile')
    2. In [50]: results = (pd.Series(draws)
    3. ....: .groupby(bins)
    4. ....: .agg(['count', 'min', 'max'])
    5. ....: .reset_index())
    6. In [51]: results
    7. Out[51]:
    8. quartile count min max
    9. 0 Q1 250 -2.949343 -0.685484
    10. 1 Q2 250 -0.683066 -0.010115
    11. 2 Q3 250 -0.010032 0.628894
    12. 3 Q4 250 0.634238 3.927528

    分位数列保存了原始的面元分类信息,包括排序:

    1. In [52]: results['quartile']
    2. Out[52]:
    3. 0 Q1
    4. 1 Q2
    5. 2 Q3
    6. 3 Q4
    7. Name: quartile, dtype: category
    8. Categories (4, object): [Q1 < Q2 < Q3 < Q4]

    用分类提高性能

    如果你是在一个特定数据集上做大量分析,将其转换为分类可以极大地提高效率。DataFrame列的分类使用的内存通常少的多。来看一些包含一千万元素的Series,和一些不同的分类:

    1. In [53]: N = 10000000
    2. In [54]: draws = pd.Series(np.random.randn(N))
    3. In [55]: labels = pd.Series(['foo', 'bar', 'baz', 'qux'] * (N // 4))

    现在,将标签转换为分类:

    1. In [56]: categories = labels.astype('category')

    这时,可以看到标签使用的内存远比分类多:

    1. In [57]: labels.memory_usage()
    2. Out[57]: 80000080
    3. In [58]: categories.memory_usage()
    4. Out[58]: 10000272

    转换为分类不是没有代价的,但这是一次性的代价:

    1. In [59]: %time _ = labels.astype('category')
    2. CPU times: user 490 ms, sys: 240 ms, total: 730 ms
    3. Wall time: 726 ms

    GroupBy使用分类操作明显更快,是因为底层的算法使用整数编码数组,而不是字符串数组。

    分类方法

    包含分类数据的Series有一些特殊的方法,类似于Series.str字符串方法。它还提供了方便的分类和编码的使用方法。看下面的Series:

    1. In [60]: s = pd.Series(['a', 'b', 'c', 'd'] * 2)
    2. In [61]: cat_s = s.astype('category')
    3. In [62]: cat_s
    4. Out[62]:
    5. 0 a
    6. 1 b
    7. 2 c
    8. 3 d
    9. 4 a
    10. 5 b
    11. 6 c
    12. 7 d
    13. dtype: category
    14. Categories (4, object): [a, b, c, d]

    特别的cat属性提供了分类方法的入口:

    1. In [63]: cat_s.cat.codes
    2. Out[63]:
    3. 0 0
    4. 1 1
    5. 2 2
    6. 3 3
    7. 4 0
    8. 5 1
    9. 6 2
    10. 7 3
    11. dtype: int8
    12. In [64]: cat_s.cat.categories
    13. Out[64]: Index(['a', 'b', 'c', 'd'], dtype='object')

    假设我们知道这个数据的实际分类集,超出了数据中的四个值。我们可以使用set_categories方法改变它们:

    1. In [65]: actual_categories = ['a', 'b', 'c', 'd', 'e']
    2. In [66]: cat_s2 = cat_s.cat.set_categories(actual_categories)
    3. In [67]: cat_s2
    4. Out[67]:
    5. 0 a
    6. 1 b
    7. 2 c
    8. 3 d
    9. 4 a
    10. 5 b
    11. 6 c
    12. 7 d
    13. dtype: category
    14. Categories (5, object): [a, b, c, d, e]

    虽然数据看起来没变,新的分类将反映在它们的操作中。例如,如果有的话,value_counts表示分类:

    1. In [68]: cat_s.value_counts()
    2. Out[68]:
    3. d 2
    4. c 2
    5. b 2
    6. a 2
    7. dtype: int64
    8. In [69]: cat_s2.value_counts()
    9. Out[69]:
    10. d 2
    11. c 2
    12. b 2
    13. a 2
    14. e 0
    15. dtype: int64

    在大数据集中,分类经常作为节省内存和高性能的便捷工具。过滤完大DataFrame或Series之后,许多分类可能不会出现在数据中。我们可以使用remove_unused_categories方法删除没看到的分类:

    1. In [70]: cat_s3 = cat_s[cat_s.isin(['a', 'b'])]
    2. In [71]: cat_s3
    3. Out[71]:
    4. 0 a
    5. 1 b
    6. 4 a
    7. 5 b
    8. dtype: category
    9. Categories (4, object): [a, b, c, d]
    10. In [72]: cat_s3.cat.remove_unused_categories()
    11. Out[72]:
    12. 0 a
    13. 1 b
    14. 4 a
    15. 5 b
    16. dtype: category
    17. Categories (2, object): [a, b]

    表12-1列出了可用的分类方法。

    表12-1 pandas的Series的分类方法

    为建模创建虚拟变量

    当你使用统计或机器学习工具时,通常会将分类数据转换为虚拟变量,也称为one-hot编码。这包括创建一个不同类别的列的DataFrame;这些列包含给定分类的1s,其它为0。

    看前面的例子:

    1. In [73]: cat_s = pd.Series(['a', 'b', 'c', 'd'] * 2, dtype='category')

    前面的第7章提到过,pandas.get_dummies函数可以转换这个分类数据为包含虚拟变量的DataFrame:

    1. In [74]: pd.get_dummies(cat_s)
    2. Out[74]:
    3. a b c d
    4. 0 1 0 0 0
    5. 1 0 1 0 0
    6. 2 0 0 1 0
    7. 3 0 0 0 1
    8. 4 1 0 0 0
    9. 5 0 1 0 0
    10. 6 0 0 1 0
    11. 7 0 0 0 1