【问题标题】:Converting numpy structured array subset to numpy array without copy将numpy结构化数组子集转换为numpy数组而不复制
【发布时间】:2016-12-27 19:58:37
【问题描述】:

假设我有以下 numpy 结构化数组:

In [250]: x
Out[250]: 
array([(22, 2, -1000000000, 2000), (22, 2, 400, 2000),
       (22, 2, 804846, 2000), (44, 2, 800, 4000), (55, 5, 900, 5000),
       (55, 5, 1000, 5000), (55, 5, 8900, 5000), (55, 5, 11400, 5000),
       (33, 3, 14500, 3000), (33, 3, 40550, 3000), (33, 3, 40990, 3000),
       (33, 3, 44400, 3000)], 
       dtype=[('f1', '<i4'), ('f2', '<f4'), ('f3', '<f4'), ('f4', '<i4')])

我正在尝试将上述数组的子集修改为常规的 numpy 数组。 对于我的应用程序来说,不创建任何副本(仅视图)是必不可少的。

使用以下函数从上述结构化数组中检索字段:

def fields_view(array, fields):
    return array.getfield(numpy.dtype(
        {name: array.dtype.fields[name] for name in fields}
    ))

如果我对“f2”和“f3”字段感兴趣,我会执行以下操作:

In [251]: y=fields_view(x,['f2','f3'])
In [252]: y
Out [252]:
array([(2.0, -1000000000.0), (2.0, 400.0), (2.0, 804846.0), (2.0, 800.0),
       (5.0, 900.0), (5.0, 1000.0), (5.0, 8900.0), (5.0, 11400.0),
       (3.0, 14500.0), (3.0, 40550.0), (3.0, 40990.0), (3.0, 44400.0)], 
       dtype={'names':['f2','f3'], 'formats':['<f4','<f4'], 'offsets':[4,8], 'itemsize':12})

有一种方法可以直接从原始结构化数组的“f2”和“f3”字段中获取 ndarray。但是,对于我的应用程序,有必要构建这个中间结构化数组,因为这个数据子集是一个类的属性。

如果不进行复制,我无法将中间结构化数组转换为常规的 numpy 数组。

In [253]: y.view(('<f4', len(y.dtype.names)))
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-54-f8fc3a40fd1b> in <module>()
----> 1 y.view(('<f4', len(y.dtype.names)))

ValueError: new type not compatible with array.

该函数也可用于将记录数组转换为ndarray:

def recarr_to_ndarr(x,typ):

    fields = x.dtype.names
    shape = x.shape + (len(fields),)
    offsets = [x.dtype.fields[name][1] for name in fields]
    assert not any(np.diff(offsets, n=2))
    strides = x.strides + (offsets[1] - offsets[0],)
    y = np.ndarray(shape=shape, dtype=typ, buffer=x,
               offset=offsets[0], strides=strides)
    return y

但是,我收到以下错误:

In [254]: recarr_to_ndarr(y,'<f4')
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-65-2ebda2a39e9f> in <module>()
----> 1 recarr_to_ndarr(y,'<f4')

<ipython-input-62-8a9eea8e7512> in recarr_to_ndarr(x, typ)
      8     strides = x.strides + (offsets[1] - offsets[0],)
      9     y = np.ndarray(shape=shape, dtype=typ, buffer=x,
---> 10                offset=offsets[0], strides=strides)
     11     return y
     12 

TypeError: expected a single-segment buffer object

如果我创建一个副本,该功能可以正常工作:

In [255]: recarr_to_ndarr(np.array(y),'<f4')
Out[255]: 
array([[  2.00000000e+00,  -1.00000000e+09],
       [  2.00000000e+00,   4.00000000e+02],
       [  2.00000000e+00,   8.04846000e+05],
       [  2.00000000e+00,   8.00000000e+02],
       [  5.00000000e+00,   9.00000000e+02],
       [  5.00000000e+00,   1.00000000e+03],
       [  5.00000000e+00,   8.90000000e+03],
       [  5.00000000e+00,   1.14000000e+04],
       [  3.00000000e+00,   1.45000000e+04],
       [  3.00000000e+00,   4.05500000e+04],
       [  3.00000000e+00,   4.09900000e+04],
       [  3.00000000e+00,   4.44000000e+04]], dtype=float32)

这两个数组似乎没有区别:

In [66]: y
Out[66]: 
array([(2.0, -1000000000.0), (2.0, 400.0), (2.0, 804846.0), (2.0, 800.0),
       (5.0, 900.0), (5.0, 1000.0), (5.0, 8900.0), (5.0, 11400.0),
       (3.0, 14500.0), (3.0, 40550.0), (3.0, 40990.0), (3.0, 44400.0)], 
      dtype={'names':['f2','f3'], 'formats':['<f4','<f4'], 'offsets':[4,8], 'itemsize':12})

In [67]: np.array(y)
Out[67]: 
array([(2.0, -1000000000.0), (2.0, 400.0), (2.0, 804846.0), (2.0, 800.0),
       (5.0, 900.0), (5.0, 1000.0), (5.0, 8900.0), (5.0, 11400.0),
       (3.0, 14500.0), (3.0, 40550.0), (3.0, 40990.0), (3.0, 44400.0)], 
      dtype={'names':['f2','f3'], 'formats':['<f4','<f4'], 'offsets':[4,8], 'itemsize':12})

【问题讨论】:

    标签: python numpy view structured-array


    【解决方案1】:

    这个答案有点长而且漫无边际。我从之前的工作中了解的关于获取数组视图的知识开始,然后尝试将其与您的函数联系起来。

    =================

    在您的情况下,所有字段都是 4 个字节长,包括浮点数和整数。然后我可以将其视为所有整数或所有浮点数:

    In [1431]: x
    Out[1431]: 
    array([(22, 2.0, -1000000000.0, 2000), (22, 2.0, 400.0, 2000),
           (22, 2.0, 804846.0, 2000), (44, 2.0, 800.0, 4000),
           (55, 5.0, 900.0, 5000), (55, 5.0, 1000.0, 5000),
           (55, 5.0, 8900.0, 5000), (55, 5.0, 11400.0, 5000),
           (33, 3.0, 14500.0, 3000), (33, 3.0, 40550.0, 3000),
           (33, 3.0, 40990.0, 3000), (33, 3.0, 44400.0, 3000)], 
          dtype=[('f1', '<i4'), ('f2', '<f4'), ('f3', '<f4'), ('f4', '<i4')])
    In [1432]: x.view('i4')
    Out[1432]: 
    array([        22, 1073741824, -831624408,       2000,         22,
           1073741824, 1137180672,       2000,         22, 1073741824,
           1229225696,       2000,         44, 1073741824, 1145569280,
          ....     3000])
    In [1433]: x.view('f4')
    Out[1433]: 
    array([  3.08285662e-44,   2.00000000e+00,  -1.00000000e+09,
             2.80259693e-42,   3.08285662e-44,   2.00000000e+00,
      ....   4.20389539e-42], dtype=float32)
    

    这个视图是一维的。我可以对 2 个浮动列进行整形和切片

    In [1434]: x.shape
    Out[1434]: (12,)
    In [1435]: x.view('f4').reshape(12,-1)
    Out[1435]: 
    array([[  3.08285662e-44,   2.00000000e+00,  -1.00000000e+09,
              2.80259693e-42],
           [  3.08285662e-44,   2.00000000e+00,   4.00000000e+02,
              2.80259693e-42],
             ...
           [  4.62428493e-44,   3.00000000e+00,   4.44000000e+04,
              4.20389539e-42]], dtype=float32)
    
    In [1437]: x.view('f4').reshape(12,-1)[:,1:3]
    Out[1437]: 
    array([[  2.00000000e+00,  -1.00000000e+09],
           [  2.00000000e+00,   4.00000000e+02],
           [  2.00000000e+00,   8.04846000e+05],
           [  2.00000000e+00,   8.00000000e+02],
           ...
           [  3.00000000e+00,   4.44000000e+04]], dtype=float32)
    

    可以通过做一些就地数学来验证这是一个视图,并在x 中查看结果:

    In [1439]: y=x.view('f4').reshape(12,-1)[:,1:3]
    In [1440]: y[:,0] += .5
    In [1441]: y
    Out[1441]: 
    array([[  2.50000000e+00,  -1.00000000e+09],
           [  2.50000000e+00,   4.00000000e+02],
           ...
           [  3.50000000e+00,   4.44000000e+04]], dtype=float32)
    In [1442]: x
    Out[1442]: 
    array([(22, 2.5, -1000000000.0, 2000), (22, 2.5, 400.0, 2000),
           (22, 2.5, 804846.0, 2000), (44, 2.5, 800.0, 4000),
           (55, 5.5, 900.0, 5000), (55, 5.5, 1000.0, 5000),
           (55, 5.5, 8900.0, 5000), (55, 5.5, 11400.0, 5000),
           (33, 3.5, 14500.0, 3000), (33, 3.5, 40550.0, 3000),
           (33, 3.5, 40990.0, 3000), (33, 3.5, 44400.0, 3000)], 
          dtype=[('f1', '<i4'), ('f2', '<f4'), ('f3', '<f4'), ('f4', '<i4')])
    

    如果字段大小不同,这可能是不可能的。例如,如果浮点数为 8 个字节。关键是描绘结构化数据的存储方式,并想象是否可以将其视为多列的简单 dtype。并且字段选择必须等同于基本切片。使用 ['f1','f4'] 相当于使用 [:,[0,3] 进行高级索引,它必须是一个副本。

    ===========

    “直接”字段索引是:

    z = x[['f2','f3']].view('f4').reshape(12,-1)
    z -= .5
    

    修改z,但使用futurewarning。它也不会修改xz 已成为副本。通过查看z.__array_interface__['data'],数据缓冲区位置(并与xy 的比较),我也可以看到这一点。

    ==================

    您的 fields_view 确实创建了结构化视图:

    In [1480]: w=fields_view(x,['f2','f3'])
    In [1481]: w.__array_interface__['data']
    Out[1481]: (151950184, False)
    In [1482]: x.__array_interface__['data']
    Out[1482]: (151950184, False)
    

    可用于修改xw['f2'] -= .5。所以它比“直接”x[['f2','f3']] 更通用。

    w dtype 是

    dtype({'names':['f2','f3'], 'formats':['<f4','<f4'], 'offsets':[4,8], 'itemsize':12})
    

    print(shape, typ, offsets, strides) 添加到您的recarr_to_ndarr,我得到 (py3)

    In [1499]: recarr_to_ndarr(w,'<f4')
    (12, 2) <f4 [4, 8] (16, 4)
    ....
    ValueError: ndarray is not contiguous
    
    In [1500]: np.ndarray(shape=(12,2), dtype='<f4', buffer=w.data, offset=4, strides=(16,4))
    ...
    BufferError: memoryview: underlying buffer is not contiguous
    

    那个contiguous的问题一定是指w.flags中显示的值:

    In [1502]: w.flags
    Out[1502]: 
      C_CONTIGUOUS : False
      F_CONTIGUOUS : False
      ....
    

    有趣的是w.dtype.descr 将“偏移量”转换为一个未命名的字段:

    In [1506]: w.__array_interface__
    Out[1506]: 
    {'data': (151950184, False),
     'descr': [('', '|V4'), ('f2', '<f4'), ('f3', '<f4')],
     'shape': (12,),
     'strides': (16,),
     'typestr': '|V12',
     'version': 3}
    

    不管怎样,w 有一个不连续的数据缓冲区,不能用于创建新数组。展平后,数据缓冲区看起来像

    xoox|xoox|xoox|...   
    # x 4 bytes we want to skip
    # o 4 bytes we want to use
    # | invisible bdry between records in x
    

    我上面构造的y有:

    In [1511]: y.__array_interface__
    Out[1511]: 
    {'data': (151950188, False),
     'descr': [('', '<f4')],
     'shape': (12, 2),
     'strides': (16, 4),
     'typestr': '<f4',
     'version': 3}
    

    所以它使用 4 字节偏移量访问 o 字节,然后是 (16,4) 步幅和 (12,2) 形状。

    如果我修改您的ndarray 调用以使用原始x.data,它可以工作:

    In [1514]: xx=np.ndarray(shape=(12,2), dtype='<f4', buffer=x.data, offset=4, strides=(16,4))
    In [1515]: xx
    Out[1515]: 
    array([[  2.00000000e+00,  -1.00000000e+09],
           [  2.00000000e+00,   4.00000000e+02],
               ....
           [  3.00000000e+00,   4.44000000e+04]], dtype=float32)
    

    与我的y具有相同的array_interface:

    In [1516]: xx.__array_interface__
    Out[1516]: 
    {'data': (151950188, False),
     'descr': [('', '<f4')],
     'shape': (12, 2),
     'strides': (16, 4),
     'typestr': '<f4',
     'version': 3}
    

    【讨论】:

    • 非常感谢您的详细回答!它帮助我弄清楚如何解决我的问题,请参阅更新后的帖子。
    【解决方案2】:

    hpaulj 说得对,问题在于结构化数组的子集不连续。有趣的是,我想出了一种使数组子集与以下函数连续的方法:

      def view_fields(a, fields):
            """
            `a` must be a numpy structured array.
            `names` is the collection of field names to keep.
    
            Returns a view of the array `a` (not a copy).
            """
            dt = a.dtype
            formats = [dt.fields[name][0] for name in fields]
            offsets = [dt.fields[name][1] for name in fields]
            itemsize = a.dtype.itemsize
            newdt = np.dtype(dict(names=fields,
                                  formats=formats,
                                  offsets=offsets,
                                  itemsize=itemsize))
            b = a.view(newdt)
            return b
    
    In [5]: view_fields(x,['f2','f3']).flags
    Out[5]: 
      C_CONTIGUOUS : True
      F_CONTIGUOUS : True
      OWNDATA : False
      WRITEABLE : True
      ALIGNED : True
      UPDATEIFCOPY : False
    

    旧功能:

    In [10]: fields_view(x,['f2','f3']).flags
    Out[10]: 
      C_CONTIGUOUS : False
      F_CONTIGUOUS : False
      OWNDATA : False
      WRITEABLE : True
      ALIGNED : True
      UPDATEIFCOPY : False
    

    【讨论】:

      猜你喜欢
      • 2021-12-01
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2020-06-25
      • 2018-12-31
      • 2013-04-10
      • 1970-01-01
      • 2023-03-18
      相关资源
      最近更新 更多