构建一个表示 3D 平面的 2D 数组存储其 Z 值，由 3 个点和所需的数组大小定义 简短详情问题

编程问答 2022-04-21

问题描述

简短

我需要找到一种优化的方法来构建表示 3D 平面（即存储其 Z 值）的 2D numpy 数组，给定三个点（以数学方式定义平面）和所需的数组大小。

详情

给定三个点 p0、p1、p2 和一个 size 变量：

import numpy as np
import pylab as plt

p0 = [0.2,-0.4,-0.2]
p1 = [-0.6,0.1,-0.8]
p2 = [-0.1,0.3,-0.6]
size = (12000,17000)

以下函数展示了如何利用这 3 个点构建平面：

def plane(p0,p1,p2,size):
    p0 = np.array(p0)
    p1 = np.array(p1)
    p2 = np.array(p2)
    ux,uy,uz = [p1[0] - p0[0],p1[1] - p0[1],p1[2] - p0[2]]
    vx,vy,vz = [p2[0] - p0[0],p2[1] - p0[1],p2[2] - p0[2]]
    uv = [uy * vz - uz * vy,uz * vx - ux * vz,ux * vy - uy * vx]
    norm = np.array(uv)    
    d = -np.array(p0).dot(norm)    
    xx,yy = np.meshgrid(range(size[1]),range(size[0]))    
    z = np.array((-norm[0] * xx - norm[1] * yy - d) * 1. / norm[2])
    return(z)

结果 z 如下所示：

resulting image

这个实现在几秒钟​​内吞噬了我的记忆：

memory usage

问题

您将如何优化它以在尽可能低的内存使用量下实现完全相同的结果（快速也不是可选的......）？

注意：size 可能在两个维度上都大 10 倍 -> 这显然会使我的 Python 在 2016 年主流笔记本电脑上崩溃。

（使用最常见的科学图书馆完全没问题）

我在 Ubuntu linux 18.04.5 上使用 Python 3.6.9（默认，2021 年 1 月 26 日，15:33:00）[GCC 8.4.0]。

解决方法

在计算 d 之前，您的数组很小。之后的一切都是为操作的每个部分创建一个单独的 1.5GiB（12k * 17k * 8bytes/float）临时数组。您可以完全摆脱这些数组中的大部分，并就地完成其余的工作。例如：

xx,yy = np.meshgrid(...)

您真的不需要网格：在 np.arange(size[0])[:,None] 和 np.arange(size[1]) 上广播将制作您需要的所有数组。这将您的数据大小从 ~3GiB 减少到 ~230KiB：

xx = np.arange(size[1],dtype=float)
yy = np.arange(size[0],dtype=float)[:,None]

表达式 z = ... 包含大约七个临时数组，每个数组的大小为 1.5GiB：

  1. t1 = -norm[0] * xx
  2. t2 = norm[1] * yy
  3. t3 = t1 - t2
  4. t4 = t3 - d
  5. t5 = t4 * 1
  6. t6 = t5 / norm[2]
  7. t7 = np.array(t6)

这些数组中的一些可能在计算过程中被垃圾收集，但它们都需要在某个时候分配。您可以使用广播和 in-place operators 或 out 参数到适当的 ufuncs:

所以：

d /= norm[2]
norm /= norm[2]
xx *= -norm[0]
yy *= -norm[1]
yy -= d
z = xx + yy

即使在代码的紧凑部分，你也在做一堆不必要的操作。例如，您调用 np.array(p0) 两次。这是您的函数的更好版本：

def plane2(p0,p1,p2,size):
    u = np.subtract(p1,p0)
    v = np.subtract(p2,p0)
    uxv = np.cross(u,v)
    d = -np.dot(p0,uxv)
    d /= uxv[2]
    uxv /= uxv[2]
    xx = np.arange(size[1],dtype=float)
    xx *= -uxv[0]
    yy = np.arange(size[0],None]
    yy *= -uxv[1]
    yy -= d
    return xx + yy

对于比您建议的小 10 倍的尺寸：

%timeit plane(p0,size)
70.1 ms ± 329 µs per loop (mean ± std. dev. of 7 runs,10 loops each)

%timeit plane2(p0,size)
8.29 ms ± 302 µs per loop (mean ± std. dev. of 7 runs,100 loops each)

当我将大小增加到您问题中的大小时，您的实现会崩溃，而我的会在合理的时间内完成：

%timeit plane(p0,size)
...
MemoryError: Unable to allocate 1.52 GiB for an array with shape (12000,17000) and data type float64

%timeit plane2(p0,size)
819 ms ± 37.6 ms per loop (mean ± std. dev. of 7 runs,1 loop each)

根据您拥有多少 RAM，以及 Python 进程中空闲内存的设置是什么，您可能无法将数组大小增加 100 倍到 152GiB，无论您执行操作的效率如何。

memorynumpyoptimizationoptimizationplanepython