图 5-1。哈希函数将键映射到容器

def hash_features(word_list, m):
    output = [0] * m
    for word in word_list:
        index = hash_fcn(word) % m
        output[index] += 1
    return output

 特征的另一种变体哈希添加一个符号组件，以便将计数添加到散列 bin 中或从中减去（参见示例 5-4）。从统计学上讲，这确保了散列特征之间的内积在期望上与原始特征的内积相等。

>>> import pandas as pd
>>> import json

# Load the first 10,000 reviews
>>> f = open('yelp_academic_dataset_review.json')
>>> js = []
>>> for i in range(10000):
...     js.append(json.loads(f.readline()))
>>> f.close()
>>> review_df = pd.DataFrame(js)

# Define m as equal to the unique number of business_ids
>>> m = len(review_df.business_id.unique())
>>> m
528

>>> from sklearn.feature_extraction import FeatureHasher
>>> h = FeatureHasher(n_features=m, input_type='string')
>>> f = h.transform(review_df['business_id'])

# How does this affect feature interpretability?
>>> review_df['business_id'].unique().tolist()[0:5]
['vcNAWiLM4dR7D2nwwJ7nCA',
 'UsFtqoBl7naz8AVUBZMjQQ',
 'cE27W9VPgO88Qxe4ol6y_g',
 'HZdLhv6COCleJMo7nPl-RA',
 'mVHrayjG3uZ_RLHkLj-AMg']

>>> f.toarray()
array([[ 0.,  0.,  0., ...,  0.,  0.,  0.],
       [ 0.,  0.,  0., ...,  0.,  0.,  0.],
       [ 0.,  0.,  0., ...,  0.,  0.,  0.],
       ...,
       [ 0.,  0.,  0., ...,  0.,  0.,  0.],
       [ 0.,  0.,  0., ...,  0.,  0.,  0.],
       [ 0.,  0.,  0., ...,  0.,  0.,  0.]])

# Not great. BUT, let's see the storage size of our features.
>>> from sys import getsizeof
>>> print('Our pandas Series, in bytes: ', getsizeof(review_df['business_id']))
>>> print('Our hashed numpy array, in bytes: ', getsizeof(f))
Our pandas Series, in bytes:  790104
Our hashed numpy array, in bytes:  56

我们可以清楚地看到使用特征散列将如何在计算上使我们受益，同时牺牲即时的用户可解释性。当从数据探索和可视化发展到大型数据集的机器学习管道时，这是一个容易接受的权衡。

箱计数的优势比和对数优势比

比值比通常定义在两个二元变量之间。它通过提问“当X为真时Y为真的可能性有多大？”来考察他们的关联强度。例如，我们可能会问，“与一般人群相比，爱丽丝点击广告的可能性有多大？” 这里，X是二进制变量“Alice 是当前用户”，Y是变量“是否点击广告”。计算使用所谓的双向列联表（基本上，四个数字对应于X和Y的四种可能组合），如表 5-7所示。

表 5-7。广告点击和用户的列联表

	Click	Nonclick	Total
Alice	5	120	125
Not Alice	995	18,880	19,875
Total	1,000	19,000	20,000

给定输入变量X和目标变量Y，优势比定义为：

 在我们的示例中，这转化为“爱丽丝点击广告而不是不点击的可能性有多大”与“其他人点击而不是不点击的可能性有多大”之间的比率。在这种情况下，数字是：

 更简单地说，我们可以只看分子，它检查单个用户 (Alice) 点击广告与不点击的可能性有多大。这适用于具有许多值的大型分类变量，而不仅仅是两个：

 概率比很容易变得非常小或非常大。（例如，有些用户几乎从不点击广告，也许有些用户更频繁地点击广告。）日志转换再次为我们提供了帮助。对数的另一个有用的特性是它将除法变成减法：

 简而言之，bin counting 将分类变量转换为有关值的统计信息。它变成了一个大而稀疏的，二进制表示将分类变量（例如由单热编码生成的变量）转换为非常小的、密集的实数值表示（图 5-2）。

示例 5-6。计数示例

>>> import pandas as pd

# train_subset data is first 10K rows of 6+GB set
>>> df = pd.read_csv('data/train_subset.csv')

# How many unique features should we have after?
>>> len(df['device_id'].unique())
7201

# For each category, we want to calculate:
# Theta = [counts, p(click), p(no click), p(click)/p(no click)]

>>> def click_counting(x, bin_column):
...     clicks = pd.Series(x[x['click'] > 0][bin_column].value_counts(), 
...                        name='clicks')
...     no_clicks = pd.Series(x[x['click'] < 1][bin_column].value_counts(), 
...                           name='no_clicks')
    
...     counts = pd.DataFrame([clicks,no_clicks]).T.fillna('0')
...     counts['total_clicks'] = counts['clicks'].astype('int64') +
...                              counts['no_clicks'].astype('int64')
...     return counts

>>> def bin_counting(counts):
...     counts['N+'] = counts['clicks']
...                    .astype('int64')
...                    .divide(counts['total_clicks'].astype('int64'))
...     counts['N-'] = counts['no_clicks']
...                    .astype('int64')
...                    .divide(counts['total_clicks'].astype('int64'))
...     counts['log_N+'] = counts['N+'].divide(counts['N-'])
...     # If we wanted to only return bin-counting properties, 
...     # we would filter here
...     bin_counts = counts.filter(items= ['N+', 'N-', 'log_N+'])
...     return counts, bin_counts

# Bin counts example: device_id
>>> bin_column = 'device_id'
>>> device_clicks = click_counting(df.filter(items=[bin_column, 'click']), 
...                                bin_column)
>>> device_all, device_bin_counts = bin_counting(device_clicks)

# Check to make sure we have all the devices
>>> len(device_bin_counts)
7201

>>> device_all.sort_values(by = 'total_clicks', ascending=False).head(4)

         clicks  no_clicks  total  N+        N-        log_N+
a99f214a 15729   71206      86935  0.180928  0.819072  0.220894
c357dbff 33      134        167    0.197605  0.802395  0.246269
31da1bd0 0       62         62     0.000000  1.000000  0.000000
936e92fb 5       54         59     0.084746  0.915254  0.092593

稀有类别呢？

就像稀有的话，稀有类别需要特殊处理。想一想每年登录一次的用户：几乎没有数据可以可靠地估计该用户的广告点击率。此外，稀有类别会浪费计数表中的空间。

单程解决这个问题的方法是通过回退，这是一种简单的技术，可以将所有稀有类别的计数累积到一个特殊的容器中（见图 5-3）。如果计数大于某个阈值，则该类别将获得自己的计数统计信息。否则，我们使用来自 back-off bin 的统计数据。这实质上将单个稀有类别的统计数据还原为对所有稀有类别计算的统计数据。使用退避方法时，还可以添加一个二进制指示符来指示统计信息是否来自退避仓。

还有一种处理方法这个问题，称为count-min sketch（Cormode 和 Muthukrishnan，2005）。在这种方法中，所有类别，无论是稀有类别还是常见类别，都通过输出范围m远小于类别数量k的多个哈希函数进行映射。检索统计信息时，重新计算该类别的所有哈希值并返回最小的统计信息。拥有多个散列函数可以降低单个散列函数内发生冲突的可能性。该方案之所以有效，是因为散列函数的数量乘以m，即散列表的大小，可以小于k，类别的数量，并且仍然保持较低的整体冲突概率。

图 5-4说明了这一点。每个项目 i 都映射到计数数组每一行中的一个单元格。当 c t对项目 i t的更新到达时，c t被添加到这些单元格中的每一个，并使用函数 h 1 … h d进行散列。

图 5-4。计数分钟草图

防止数据泄露

由于 bin counting 依赖于历史数据来生成必要的统计数据，因此它需要等待一个数据收集期，从而导致学习管道中的轻微延迟。此外，当数据分布发生变化时，需要更新计数。数据变化越快，需要重新计算的次数就越频繁。这对于定向广告等应用尤为重要，在这些应用中，用户偏好和热门查询变化非常快，无法适应当前的分布可能意味着广告平台的巨大损失。

事实证明，还有另一种解决方案，基于差分隐私。如果统计数据的分布在有或没有任何一个数据点的情况下保持大致相同，则该统计数据几乎是防泄漏的。实际上，添加分布为 Laplace(0,1) 的小随机噪声足以掩盖来自单个数据点的任何潜在泄漏。这个想法可以与留一法相结合，对当前数据进行统计（Zhang，2015）。

计数无界限

如果根据越来越多的历史数据不断更新统计数据，原始计数将无限增长。这可能是模型的问题。训练有素的模型“知道”输入数据直至观察到的规模。训练有素的决策树可能会说：“当x大于 3 时，预测 1。” 训练有素的线性模型可能会说，“将x乘以0.7，看看结果是否大于全球平均水平。” 当x介于 0 和 5 之间时，这些可能是正确的决定。但除此之外会发生什么？没人知道。

这两种方法都无法防止输入分布的变化（例如，去年的芭比娃娃现在已经过时了，人们将不再点击这些广告）。该模型将需要重新训练以适应输入数据分布中这些更根本的变化，或者整个管道将需要转移到模型连续不断的在线学习环境适应到输入。