python - Pandas : Merge hierarchical data

Question

我正在寻找一种将具有复杂层次结构的数据合并到pandas DataFrame中的方法。这种层次结构是由数据中不同的相互依存关系引起的。例如。有一些参数定义了数据的生成方式，然后有时间相关的可观测值，空间相关的可观测值以及取决于时间和空间的可观测值。

更明确地说:假设我有以下数据。

#  Parameters
t_max = 2
t_step = 15
sites = 4

# Purely time-dependent
t = np.linspace(0, t_max, t_step)
f_t = t**2 - t

# Purely site-dependent
position = np.array([[0, 0], [1, 0], [0, 1], [1, 1]])  # (x, y)
site_weight = np.arange(sites)

# Time-, and site-dependent.
occupation = np.arange(t_step*sites).reshape((t_step, sites))

# Time-, and site-, site-dependent
correlation = np.arange(t_step*sites*sites).reshape((t_step, sites, sites))

(最后，我当然会拥有许多这样的数据集。每组参数一个。)

现在，我想将所有这些信息存储到pandas DataFrame中。我想象最终结果看起来像这样:

| ----- parameters ----- | -------------------------------- observables --------------------------------- |
|                        |                                        | ---------- time-dependent ----------- |
|                        | ----------- site-dependent --- )       ( ------------------------ |            |
|                        |                                | - site2-dependent - |                         |
| sites | t_max | t_step | site | r_x | r_y | site weight | site2 | correlation | occupation | f_t | time |

我认为部分重叠的层次结构可能无法实现。如果它们是隐式的，就可以了，例如通过以特定方式为DataFrame编制索引来获取所有与站点相关的数据。

另外，如果您认为有更好的方法可以在 Pandas 中安排此数据，请随时告诉我。

题

如何构造包含上述所有数据的 DataFrame，并以某种方式反射(reflect)相互依赖关系(例如 f_t取决于 time，而不取决于 site)。以及所有这些以足够通用的方式进行，因此很容易添加或删除某些可观察对象，并且可能具有新的相互依赖关系。 (例如，取决于第二时间轴的数量，例如时间-时间相关性。)

我到目前为止所得到的

在下文中，我将向您展示我已经走了多远。但是，我认为这不是实现上述目标的理想方法。特别是，由于缺乏关于添加或删除某些可观察对象的通用性。

指标

鉴于以上数据，我首先定义了我需要的所有多索引。

ind_time = pd.Index(t, name='time')
ind_site = pd.Index(np.arange(sites), name='site')
ind_site_site = pd.MultiIndex.from_product([ind_site, ind_site], names=['site', 'site2'])
ind_time_site = pd.MultiIndex.from_product([ind_time, ind_site], names=['time', 'site'])
ind_time_site_site = pd.MultiIndex.from_product([ind_time, ind_site, ind_site], names=['time', 'site', 'site2'])

单个 DataFrame
接下来，我创建了各个数据块的数据帧。

df_parms = pd.DataFrame({'t_max': t_max, 't_step': t_step, 'sites': sites}, index=[0])
df_time = pd.DataFrame({'f_t': f_t}, index=ind_time)
df_position = pd.DataFrame(position, columns=['r_x', 'r_y'], index=ind_site)
df_weight = pd.DataFrame(site_weight, columns=['site weight'], index=ind_site)
df_occupation = pd.DataFrame(occupation.flatten(), index=ind_time_site, columns=['occupation'])
df_correlation = pd.DataFrame(correlation.flatten(), index=ind_time_site_site, columns=['correlation'])

index=[0]中的 df_parms似乎是必需的，因为否则Pandas只会提示标量值。实际上，我可能会用运行此特定模拟的时间戳来代替它。那至少会传达一些有用的信息。

合并可观察对象

有了可用的数据帧，我将所有可观察的对象合并为一个大 DataFrame。

df_all_but_parms = pd.merge(
  pd.merge(
    pd.merge(
      df_time.reset_index(),
      df_occupation.reset_index(),
      how='outer'
    ),
    df_correlation.reset_index(),
    how='outer'
  ),
  pd.merge(
    df_position.reset_index(),
    df_weight.reset_index(),
    how='outer'
  ),
  how='outer'
)

这是我目前最不喜欢的一点。 merge函数仅适用于成对的数据帧，并且要求它们至少具有一个公共(public)列。因此，我必须注意连接数据框的顺序，如果要添加一个正交的可观察对象，则无法将其与其他数据合并，因为它们不会共享公共(public)列。是否有一个函数可以仅通过一次调用数据帧列表就可以达到相同的结果？我尝试了 concat，但它不会合并普通列。因此，最后我得到了很多重复的 time和 site列。

合并所有数据

最后，我将数据与参数合并。

pd.concat([df_parms, df_all_but_parms], axis=1, keys=['parameters', 'observables'])

到目前为止，最终结果如下所示:

         parameters                 observables                                                                       
              sites  t_max  t_step         time       f_t  site  occupation  site2  correlation  r_x  r_y  site weight
    0             4      2      15     0.000000  0.000000     0           0      0            0    0    0            0
    1           NaN    NaN     NaN     0.000000  0.000000     0           0      1            1    0    0            0
    2           NaN    NaN     NaN     0.000000  0.000000     0           0      2            2    0    0            0
    3           NaN    NaN     NaN     0.000000  0.000000     0           0      3            3    0    0            0
    4           NaN    NaN     NaN     0.142857 -0.122449     0           4      0           16    0    0            0
    ..          ...    ...     ...          ...       ...   ...         ...    ...          ...  ...  ...          ...
    235         NaN    NaN     NaN     1.857143  1.591837     3          55      3          223    1    1            3
    236         NaN    NaN     NaN     2.000000  2.000000     3          59      0          236    1    1            3
    237         NaN    NaN     NaN     2.000000  2.000000     3          59      1          237    1    1            3
    238         NaN    NaN     NaN     2.000000  2.000000     3          59      2          238    1    1            3
    239         NaN    NaN     NaN     2.000000  2.000000     3          59      3          239    1    1            3

如您所见，这并不是很好，因为实际上只给第一行分配了参数。其他所有行仅使用 NaN代替参数。但是，由于这些是所有数据的参数，因此它们也应包含在此数据帧的所有其他行中。

一个小问题:如果将上述数据帧存储在hdf5中， Pandas 会变得多么聪明。我最终会得到很多重复的数据，还是会避免重复存储？

更新资料

多亏了 Jeff's answer，我能够使用通用合并将所有数据推送到一个数据帧中。基本思想是，我所有的可观测对象都已经有一些通用列。即参数。

首先，我将参数添加到所有可观测数据的数据帧中。

all_observables = [ df_time, df_position, df_weight, df_occupation, df_correlation ]
flat = map(pd.DataFrame.reset_index, all_observables)
for df in flat:
    for c in df_parms:
        df[c] = df_parms.loc[0,c]

然后，我可以通过归约将它们全部合并在一起。

df_all = reduce(lambda a, b: pd.merge(a, b, how='outer'), flat)

其结果具有所需的形式:

         time       f_t  sites  t_max  t_step  site  r_x  r_y  site weight  occupation  site2  correlation
0    0.000000  0.000000      4      2      15     0    0    0            0           0      0            0
1    0.000000  0.000000      4      2      15     0    0    0            0           0      1            1
2    0.000000  0.000000      4      2      15     0    0    0            0           0      2            2
3    0.000000  0.000000      4      2      15     0    0    0            0           0      3            3
4    0.142857 -0.122449      4      2      15     0    0    0            0           4      0           16
5    0.142857 -0.122449      4      2      15     0    0    0            0           4      1           17
6    0.142857 -0.122449      4      2      15     0    0    0            0           4      2           18
..        ...       ...    ...    ...     ...   ...  ...  ...          ...         ...    ...          ...
233  1.857143  1.591837      4      2      15     3    1    1            3          55      1          221
234  1.857143  1.591837      4      2      15     3    1    1            3          55      2          222
235  1.857143  1.591837      4      2      15     3    1    1            3          55      3          223
236  2.000000  2.000000      4      2      15     3    1    1            3          59      0          236
237  2.000000  2.000000      4      2      15     3    1    1            3          59      1          237
238  2.000000  2.000000      4      2      15     3    1    1            3          59      2          238
239  2.000000  2.000000      4      2      15     3    1    1            3          59      3          239

通过重新索引数据，层次结构变得更加明显:

df_all.set_index(['t_max', 't_step', 'sites', 'time', 'site', 'site2'], inplace=True)

导致

                                             f_t  r_x  r_y  site weight  occupation  correlation
t_max t_step sites time     site site2                                                          
2     15     4     0.000000 0    0      0.000000    0    0            0           0            0
                                 1      0.000000    0    0            0           0            1
                                 2      0.000000    0    0            0           0            2
                                 3      0.000000    0    0            0           0            3
                   0.142857 0    0     -0.122449    0    0            0           4           16
                                 1     -0.122449    0    0            0           4           17
                                 2     -0.122449    0    0            0           4           18
...                                          ...  ...  ...          ...         ...          ...
                   1.857143 3    1      1.591837    1    1            3          55          221
                                 2      1.591837    1    1            3          55          222
                                 3      1.591837    1    1            3          55          223
                   2.000000 3    0      2.000000    1    1            3          59          236
                                 1      2.000000    1    1            3          59          237
                                 2      2.000000    1    1            3          59          238
                                 3      2.000000    1    1            3          59          239

Answer 1

我认为您应该这样做，将df_parms用作索引。这样，您可以轻松地用不同的格式连接更多帧。

In [67]: pd.set_option('max_rows',10)

In [68]: dfx = df_all_but_parms.copy()

您需要将列分配给框架(您也可以直接构造多索引，但这是从您的数据开始的)。

In [69]: for c in df_parms.columns:
             dfx[c] = df_parms.loc[0,c]

In [70]: dfx
Out[70]: 
         time       f_t  site  occupation  site2  correlation  r_x  r_y  site weight  sites  t_max  t_step
0    0.000000  0.000000     0           0      0            0    0    0            0      4      2      15
1    0.000000  0.000000     0           0      1            1    0    0            0      4      2      15
2    0.000000  0.000000     0           0      2            2    0    0            0      4      2      15
3    0.000000  0.000000     0           0      3            3    0    0            0      4      2      15
4    0.142857 -0.122449     0           4      0           16    0    0            0      4      2      15
..        ...       ...   ...         ...    ...          ...  ...  ...          ...    ...    ...     ...
235  1.857143  1.591837     3          55      3          223    1    1            3      4      2      15
236  2.000000  2.000000     3          59      0          236    1    1            3      4      2      15
237  2.000000  2.000000     3          59      1          237    1    1            3      4      2      15
238  2.000000  2.000000     3          59      2          238    1    1            3      4      2      15
239  2.000000  2.000000     3          59      3          239    1    1            3      4      2      15

[240 rows x 12 columns]

设置索引(这将返回一个新对象)

In [71]: dfx.set_index(['sites','t_max','t_step'])
Out[71]: 
                        time       f_t  site  occupation  site2  correlation  r_x  r_y  site weight
sites t_max t_step                                                                                 
4     2     15      0.000000  0.000000     0           0      0            0    0    0            0
            15      0.000000  0.000000     0           0      1            1    0    0            0
            15      0.000000  0.000000     0           0      2            2    0    0            0
            15      0.000000  0.000000     0           0      3            3    0    0            0
            15      0.142857 -0.122449     0           4      0           16    0    0            0
...                      ...       ...   ...         ...    ...          ...  ...  ...          ...
            15      1.857143  1.591837     3          55      3          223    1    1            3
            15      2.000000  2.000000     3          59      0          236    1    1            3
            15      2.000000  2.000000     3          59      1          237    1    1            3
            15      2.000000  2.000000     3          59      2          238    1    1            3
            15      2.000000  2.000000     3          59      3          239    1    1            3

[240 rows x 9 columns]