Question

我正在做一些自然语言处理，并且我有一个看起来像这样的MultiIndexed DataFrame（除了实际上大约有3000行）：

                             Title                                              N-grams
Period  Date                                                                                                                     
2015-01 2015-01-01 22:00:10  SIRF: Simultaneous Image Registration and Fusi...  [@SENTBEGIN paper, paper propose, propose nove...    
        2015-01-02 16:54:13  Generic construction of scale-invariantly coar...  [@SENTBEGIN encode, encode temporal, temporal ...
        2015-01-04 00:07:00  Understanding Trajectory Behavior: A Motion Pa...  [@SENTBEGIN mining, mining underlie, underlie ...
        2015-01-04 09:07:45  Hostile Intent Identification by Movement Patt...  [@SENTBEGIN the, the recent, recent year, year...
        2015-01-04 14:35:58  A New Method for Signal and Image Analysis: Th...  [@SENTBEGIN brief, brief review, review provid...

我想做的是计算每个n-gram在每个月出现多少次（因此第一个索引为“ Period”）。这样做很简单，如果很耗时的话（因为“ N-grams”列中的每个单元格都是一个列表，所以我不确定可以做很多事情来加快速度）。我使用以下代码创建一个新的DataFrame来保存计数：

# Create the frequencies DataFrame.
period_index = ngrams.index.unique(level = "Period")
freqs = DataFrame(index = period_index)

# Count the n-grams in each period.
for period in period_index:
    for ngrams_list in ngrams.loc[period, "N-grams"]:
        for ngram in ngrams_list:
            if not ngram in freqs.columns:
                freqs[ngram] = 0
            freqs.loc[period, ngram] += 1

逻辑很简单：如果已经看到了相关的n-gram（“频率”中有对应的列），则将计数加1。如果未看到，则创建一个新的该n-gram的0列，然后正常增加。在大多数情况下，这可以正常工作，但是对于一小部分的n克，当循环碰到增量线时，我会收到此错误：

KeyError: u'the label [7 85.40] is not in the [index]'

（很抱歉，缺少正确的堆栈跟踪信息-我正在Zeppelin笔记本中进行此操作，而Zeppelin没有提供正确的堆栈跟踪信息。）

更多的调试表明，在这些情况下，新列的创建会以静默方式失败（也就是说，它不起作用，但也不会返回异常）。

可能值得注意的是，在早期版本的代码中，我使用“ loc”直接分配给新创建的列中的单元格，而不是像这样先创建列：

if not ngram in freqs.columns:
    freqs.loc[period, ngram] = 1

我更改了此设置，是因为它通过将该n-gram的NaN分配给所有其他时间段而引起了问题，但是直接分配与新代码完全相同的n-gram阻塞了。

通过将增量行包装在try / except块中，我发现该错误非常罕见：错误发生在总共100,000多个n-gram中约20个错误语料库。以下是一些示例：

"7 85.40"
"2014 july"
"2010 3.4"
"and 77"
"1997 and"
"and 2014"
"6 2008"
"879 --"
"-- 894"
"2003 -"
"- 2014"

20个中的大多数都包含数字，但是至少一个完全是字母（两个单词之间用空格隔开-它不在上面的列表中，因为我在键入此问题时重新运行了脚本，但没有一直到这一点），并且只有数字的n-gram不会引起问题。大部分有问题的年份涉及几年，从表面上看，这可能暗示与DataFrame的DatetimeIndex发生某种混淆（假设DatetimeIndex接受部分匹配），但这并不能解释非日期，特别是那些非日期以字母开头。

尽管DatetimeIndex冲突不太可能，但我尝试使用另一种方法来创建每个新列（如对Adding new column to existing DataFrame in Python pandas的回答所建议），使用“ loc”来避免行和列之间的任何混淆：

freqs.loc[:, ngram] = Series(0, index = freqs.index)

...但是与我的原始代码完全一样的命运，该原始代码通过分配给不存在的列来隐式创建每个新列：

KeyError: u'7 85.40'

接下来，我尝试了DataFrame.assign方法（与上面引用的答案相同，尽管我需要添加对pandas assign with new column name as string的答案建议的解决方法）：

kwarg = {ngram: 0}
freqs = freqs.assign(**kwarg)

A，这会产生完全相同的错误。

有人对为什么会发生有任何见解吗？考虑到稀有性，我想我可以忽略有问题的n-gram，但是最好了解发生了什么。

Answer 1

不建议也不要求使用嵌套for循环。您可以使用MultiLabelBinarizer库中的sklearn.preprocessing提供一键编码，然后对结果使用groupby + sum并加入原始数据帧。

这是一个示范：

df = df.set_index(['L1', 'L2'])

row_counts = df['values'].apply(pd.Series.value_counts).fillna(0).astype(int)

# alternative if above does not work
row_counts = df['values'].apply(lambda x: pd.Series(x).value_counts(sort=False))\
                         .fillna(0).astype(int)

row_counts_grouped = row_counts.groupby(level='L1').sum()

df = df.join(row_counts_grouped, how='inner')

print(df)

          values  a  b  c  d  e  g
L1 L2                             
1  1   [a, a, c]  3  2  2  1  1  0
   2   [b, c, d]  3  2  2  1  1  0
   3   [a, b, e]  3  2  2  1  1  0
2  1   [a, e, g]  1  2  1  2  2  1
   2   [b, d, d]  1  2  1  2  2  1
   3   [e, b, c]  1  2  1  2  2  1

设置/原始解决方案

使用此解决方案，我们不会考虑重复的值：

from sklearn.preprocessing import MultiLabelBinarizer

df = pd.DataFrame([[1,1,['a','a','c']], [1,2,['b','c','d']], [1,3,['a','b','e']],
                   [2,1,['a','e','g']], [2,2,['b','d','d']], [2,3,['e','b','c']]],
                  columns=['L1', 'L2', 'values'])

df = df.set_index(['L1', 'L2'])

mlb = MultiLabelBinarizer()

onehot = pd.DataFrame(mlb.fit_transform(df['values']),
                      columns=mlb.classes_,
                      index=df.index.get_level_values('L1'))

onehot_grouped = onehot.groupby(level='L1').sum()

df = df.join(onehot_grouped, how='inner')

print(df)

          values  a  b  c  d  e  g
L1 L2                             
1  1   [a, a, c]  2  2  2  1  1  0
   2   [b, c, d]  2  2  2  1  1  0
   3   [a, b, e]  2  2  2  1  1  0
2  1   [a, e, g]  1  2  1  1  2  1
   2   [b, d, d]  1  2  1  1  2  1
   3   [e, b, c]  1  2  1  1  2  1

Answer 2

对于我的大约3,000个简短文档的原始数据集，jpp's答案运行良好，并且在我正在测试的服务器上的Zeppelin中运行了大约10分钟-比以前快了一个数量级。我一直在使用的代码（除了解决KeyError问题之外）。但是，当我尝试使用大约10,000个更大的数据集时，该代码在运行18小时后仍未完成-我怀疑它与使用apply时将所有内容保留在内存中有关（请参阅{{3 }}，以便对此问题有所思考。

得知apply只是创建嵌套循环的一种优雅方式，我决定通过显式编写循环来避免明显的内存问题，同时仍然使用Series.value_counts方法，该方法应该是实际效率收益的来源。由于数据类型存在问题，这有点棘手，但这是最终结果：

period_index = ngrams.index.unique(level = "Period")
freqs = DataFrame()

for period in period_index:
    period_ngrams = ngrams.loc[period]
    period_freqs = DataFrame(index = period_ngrams.index)
    for i, doc in period_ngrams.iterrows():
        period_freqs = period_freqs.append(Series(doc["N-grams"]). \
                           value_counts(sort = False), ignore_index = True)
    period_sums = period_freqs.sum()
    period_sums.name = period
    freqs = freqs.append(period_sums)
    print "Processed period " + str(period) + "."

freqs["Totals"] = freqs.sum(axis = 1)
freqs = freqs.fillna(0).astype(int)

事实证明，这不仅适用于较大的数据集，而且实际上更快：10,000个文档需要5分钟。

分配给pandas DataFrame中的新列时令人费解的KeyError

2 个答案:

设置/原始解决方案