在pandas（子）数据框中查找最大和最小值

Question

在pandas（子）数据框中查找最大和最小值

3

我有以下数据帧 - df：

                     crs         Band1 level
lat       lon                               
34.595694 32.929028  b''  4.000000e+00  1000
          32.937361  b''  1.200000e+01  950
          32.945694  b''  2.900000e+01  925
34.604028 32.929028  b''  7.000000e+00  1000
          32.937361  b''  1.300000e+01  950
                 ...           ...   ...
71.179028 25.679028  b''  6.000000e+01  750
71.187361 25.662361  b''  1.000000e+00  725
          25.670694  b''  6.000000e+01  1000
          25.679028  b''  4.000000e+01  800
71.529028 19.387361  b''  1.843913e-38  1000

[17671817 rows x 3 columns]

以及两个数组：

lon1=np.arange(-11,47,0.25)
lat1=np.arange(71.5,34.5,-0.25)

这两个数组（lat1，lon1）生成坐标对，间隔为0.25度。

数据框 df 包含点(lat，lon)，这些点在 lon1 和 lat1 数组定义的点内密集分布。我想做的是：

找到所有距离 lat1，lon1 定义的点 0.125 度以内的 df 中的所有点。
从这个子数据框中获取 level 的 max 和 min 值，并将它们存储在与 lon1 和 lat1 相同大小的单独数组中。

到目前为止，我已经过滤了数据框：

for x1 in lon1:
    for y1 in lat1:
        df3=df[(df.index.get_level_values('lon')>x1-0.125) & (df.index.get_level_values('lon')<x1+0.125)]
        df3=df3[(df3.index.get_level_values('lat')>y1-0.125) & (df3.index.get_level_values('lat')<y1+0.125)]

但是这种方法的性能非常慢。我相信有更快的方法。我已经标记了scikit-learn，因为可能可以使用它来解决问题，但我对这个包缺乏经验。任何帮助将不胜感激。

- user2727167

lon1和lat1之间的关系是什么？它是笛卡尔积（lat1的每个值与lon1的所有值）还是匹配索引？（lon1 [0]与lat1 [0]相同，索引1等等） - Roim

lon1和lat1是点的经度和纬度。 lon1 [0]，lat1 [0]描述了一个具有经度和纬度的点。 - user2727167

也许这个可以帮助提高速度方面的问题；显然，对数据进行排序应该已经有所帮助了。 - scleronomic

还有一个问题：您想要一个子数据框，还是多个子数据框（与lon1数组的大小相同），用于每次查找最大值和最小值？我的意思是，您想要范围内所有点的最大值和最小值，还是每对数据框的最大值和最小值？ - Roim

1

df1（30k条记录）的快照链接：https://1drv.ms/u/s!Aj5DfuTWg1OMjtskbyjp5bR-Ga6tbg?e=Zfq5oZ - user2727167

显示剩余3条评论

3个回答

1

首先，让我们回顾一下您的解决方案：对于lon1和lat1中的每个值（如果它们的大小为n，则是n^2次迭代），您尝试过滤数据框，这导致扫描整个df：您的代码运行了n^2次数据框，这是低效的。

我的解决方案仅需要扫描数据框一次，每次扫描执行n个操作。它使用Pandas的apply函数，这并不是很高效，但我找不到不使用它的方法。我很想听听不使用apply进行筛选的解决方案。

我使用了一个小的可重复示例，您可能需要调整索引以匹配您的代码。我相信这个示例更容易理解。

import pandas as pd
import numpy as np

df = pd.DataFrame({"lat":[22.5, 10.76, 7.341, 22.5], "log":[3.64, 7.234, 135, 3.644], "level":[2, 8, 19, 9]})

lat1 = np.array([22.51, 7.33])
lon1 = np.array([3.6, 135.02])

下面的代码创建了一个元组列表，每个元组都包含一个 pandas.Interval 对象。这里的元组表示 (lat1[i]+-x, lon1[i]+-x)。需要注意的是，我并不一定要使用 pandas.Interval - 我可以只建立另一个元组 (lat1[i]-x, lat1[i]+x)。但我决定使用 pandas interval，这并不重要。结果：对于每一对 [lat1, lon1]，我们有一个元组包含两个 pandas interval，每个间隔为 +-0.125。

interval_list = []
const_add = 0.125
for i, item in enumerate(lat1):
    interval_list.append((pd.Interval(left=lat1[i]-const_add, right=lat1[i]+const_add),pd.Interval(left=lon1[i]-const_add, right=lon1[i]+const_add)))

现在我们想要过滤数据框。为了使用apply，我创建了一个自定义函数：它检查当前行是否在元组内，如果是，则返回lat1数组中的索引（稍后您会看到为什么这很有用）。

def within_range(row, interval_list):
    for i, item in enumerate(interval_list):
        if row[0] in item[0] and row[1] in item[1]:
            return i
    return np.nan

df["point"] = df.apply(lambda x: within_range(x, interval_list), axis=1)

在代码的那一部分，我们有一个列名为'point'。它的值如下：如果行接近点i（其中i是lat1[i]和lon1[i]中的索引），则该值为i。如果没有接近的点，则该值为nan。

现在只需使用groupby轻松找到每个点的最大和最小值即可。

max_series = df.groupby(by="point")["level"].max()
min_series = df.groupby(by="point")["level"].min()

你有两个序列，索引与lat1和lon[1]的索引相同。你可以使用Series.array将它们轻松转换为数组。值得一提的是，你没有说明如何处理缺失值——如果在df中没有点接近点(lat1[50], lon1[50])，最大和最小数组中的值是什么？这就是为什么我把它留作系列，我相信在将其转换为数组之前进行操作更容易。整个代码如下:

import pandas as pd
import numpy as np

df = pd.DataFrame({"lat":[22.5, 10.76, 7.341, 22.5], "log":[3.64, 7.234, 135, 3.644], "level":[2, 8, 19, 9]})

lat1 = np.array([22.51, 7.33])
lon1 = np.array([3.6, 135.02])

interval_list = []
const_add = 0.125

for i, item in enumerate(lat1):
    interval_list.append((pd.Interval(left=lat1[i]-const_add, right=lat1[i]+const_add),pd.Interval(left=lon1[i]-const_add, right=lon1[i]+const_add)))

def within_range(row, interval_list):
    for i, item in enumerate(interval_list):
        if row[0] in item[0] and row[1] in item[1]:
            return i
    return np.nan

df["point"] = df.apply(lambda x: within_range(x, interval_list), axis=1)
max_arr = df.groupby(by="point")["level"].max()
min_arr = df.groupby(by="point")["level"].min()
# or:
# max_arr = df.groupby(by="point")["level"].max().array

- Roim

由于apply实际上是一个伪装成for循环的函数，因此这似乎可能非常慢。 - John Zwinck

我知道，我找不到更好的解决方案。我看到你的没有使用它，我很快会检查一下。 - Roim

1

我使用this答案中描述的技巧，有效地获得与1D中bin对应的索引，然后循环遍历lon和lat组以获取两者的交集。我在这里使用numpy，而不是直接应用min / max，而是专注于索引。

import numpy as np
from scipy.sparse import csr_matrix

def digitize_group(x, bins):
    idx_x = np.digitize(x, bins)
    n, m = len(x), len(bins) + 1
    s = csr_matrix((np.arange(n), [idx_x, np.arange(n)]), shape=(m, n))
    return [group for group in np.split(s.data, s.indptr[1:-1])]

# Create dummy data
n = 100000  # 17671817
step = 0.25  # Note the shift by step/2 to transform your arrays to bins
bins_lon = np.arange(-11-step/2, 47+step/2, step) 
bins_lat = np.arange(71.5+step/2, 34.5-step/2, -step)
lon = np.random.uniform(low=bins_lon.min(), high=bins_lon.max(), size=n)
lat = np.random.uniform(low=bins_lat.min(), high=bins_lat.max(), size=n)

# Get the 1D groups
group_lon = digitize_group(lon, bins_lon)
group_lat = digitize_group(lat, bins_lat)

# Combine to 2D groups
group_lonlat = np.zeros((len(group_lon), len(group_lat)), dtype=object)
for i, lo in enumerate(group_lon):
    for j, la in enumerate(group_lat):
        group_lonlat[i, j] = np.intersect1d(lo, la, assume_unique=True)

print(group_lonlat[13, 17])
# array([   15606,   131039,   168479,   171734,   174281,   266717,   ....

通过访问group_lonlat[i, j]，您可以获得一个索引列表K，其中每个元素k都满足：

bins_lon[i] < lon[k] < bins_lon[i+1] & bins_lat[j] < lat[k] < bins_lat[j+1]

通过这些索引，您可以访问您的数据框并执行所有进一步的计算。

在我的笔记本电脑上，计算 n=17671817 的指数花费了 180s。

这种方法的一个瓶颈是交集搜索的次优处理。sortednp 保证在这里比 numpy 更好。对于大的 n ，删除已使用的索引以加速搜索更有效率。

import sortednp as snp
for i in range(len(group_lon)):
    for j in range(len(group_lat)):
        group_lonlat[i, j], (ii, jj) = snp.intersect(group_lon[i], group_lat[j], 
                                                     indices=True)
        group_lon[i] = np.delete(group_lon[i], ii)
        group_lat[j] = np.delete(group_lat[j], jj)

这使得对于 n=17671817 大约需要 20秒，而对于 n=30000 则需要 0.3秒。

- scleronomic

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- John Zwinck · Accepted Answer

在开始之前，让我们将您的箱子转换为每个箱子的起始点，而不是中心点：

lon1=np.arange(-11.125,47.125,0.25)
lat1=np.arange(71.625,34.125,-0.25)

对每一行分配纬度和经度的范围（注意lat1的顺序被颠倒了，否则您需要向pd.cut()传递ordered=False参数）。

df['latcat'] = pd.cut(df.index.get_level_values(0), lat1[::-1])
df['loncat'] = pd.cut(df.index.get_level_values(1), lon1)

对于您的示例数据，我们现在有：

                     crs         Band1  level            latcat            loncat
lat       lon                                                                    
34.595694 32.929028  b''  4.000000e+00   1000  (34.375, 34.625]  (32.875, 33.125]
          32.937361  b''  1.200000e+01    950  (34.375, 34.625]  (32.875, 33.125]
          32.945694  b''  2.900000e+01    925  (34.375, 34.625]  (32.875, 33.125]
34.604028 32.929028  b''  7.000000e+00   1000  (34.375, 34.625]  (32.875, 33.125]
          32.937361  b''  1.300000e+01    950  (34.375, 34.625]  (32.875, 33.125]
71.179028 25.679028  b''  6.000000e+01    750  (71.125, 71.375]  (25.625, 25.875]
71.187361 25.662361  b''  1.000000e+00    725  (71.125, 71.375]  (25.625, 25.875]
          25.670694  b''  6.000000e+01   1000  (71.125, 71.375]  (25.625, 25.875]
          25.679028  b''  4.000000e+01    800  (71.125, 71.375]  (25.625, 25.875]
71.529028 19.387361  b''  1.843913e-38   1000  (71.375, 71.625]  (19.375, 19.625]

现在使用groupby获取每个地区的最小和最大等级：

res = df.groupby([df.latcat.cat.codes, df.loncat.cat.codes])['level'].agg(['min', 'max'])

这将给您：

          min   max
0   176   925  1000
147 147   725  1000
148 122  1000  1000

索引的第一级是反转lat1数组中的位置，-1表示“超出范围”，你的一些示例数据是这样的。第二级是lon1数组中的位置。

按照要求转换为矩阵:

minlevel = np.full((len(lat1), len(lon1)), np.nan)
maxlevel = np.full((len(lat1), len(lon1)), np.nan)
x = len(lat1) - res.index.get_level_values(0) - 1 # reverse to original order
y = res.index.get_level_values(1)
minlevel[x, y] = res['min']
maxlevel[x, y] = res['max']