Question

问题：

假设我有一个2D数组，我想从中随机采样（使用蒙特卡罗）较小的2D子阵列，如下图中的黑色斑块所示。我正在寻找一种有效的方法。

预期（但部分）解决方案：

我遇到了一个function，它在部分搜索后部分实现了我想要做的事情，但它缺乏在随机位置采样补丁的能力。至少我不认为它可以根据其参数从随机位置进行采样，尽管它确实有一个我不理解的random_state参数。

sklearn.feature_extraction.image.extract_patches_2d(image, patch_size, max_patches=None, random_state=None)

问题：

选择随机贴片坐标（2D子阵列）并使用它们从较大的阵列切片，如上图所示。允许随机采样的补丁重叠。

Answer 1

这是一个采样器，可以从任何维度的数组中创建样本。它使用函数来控制切割的开始位置以及切割沿任何轴的宽度。

以下是参数说明：

arr - 输入numpy数组。
loc_sampler_fn - 这是您要用于设置框角的功能。如果您希望从轴的任何位置均匀地对框的角进行采样，请使用np.random.uniform。如果您希望角落更接近阵列的中心，请使用np.random.normal。但是，我们需要告诉函数要采样的范围。这将我们带到下一个参数。
loc_dim_param - 这会将每个轴的大小传递给loc_sampler_fn。如果我们使用np.random.uniform作为位置采样器，我们希望从轴的整个范围进行采样。 np.random.uniform有两个参数：low和high，因此通过将轴的长度传递给high，它会在整个轴上均匀采样。换句话说，如果轴的长度为120，我们需要np.random.uniform(low=0, high=120)，因此我们设置loc_dim_param='high'。
loc_params - 这会将任何其他参数传递给loc_sampler_fn。保持示例，我们需要将low=0传递给np.random.uniform，因此我们会传递字典loc_params={'low':0}。

从这里开始，盒子的形状基本相同。如果您希望将框高度和宽度从3到10均匀采样，请使用shape_sampler_fn=np.random.uniform传递shape_dim_param=None，因为我们没有使用轴的大小来表示任何内容，shape_params={'low':3, 'high':11}

def box_sampler(arr, 
                loc_sampler_fn, 
                loc_dim_param, 
                loc_params, 
                shape_sampler_fn, 
                shape_dim_param,
                shape_params):
    '''
    Extracts a sample cut from `arr`.

    Parameters:
    -----------
    loc_sampler_fn : function
        The function to determine the where the minimum coordinate
        for each axis should be placed.
    loc_dim_param : string or None
        The parameter in `loc_sampler_fn` that should use the axes
        dimension size
    loc_params : dict
        Parameters to pass to `loc_sampler_fn`.
    shape_sampler_fn : function
        The function to determine the width of the sample cut 
        along each axis.
    shape_dim_param : string or None
        The parameter in `shape_sampler_fn` that should use the
        axes dimension size.
    shape_params : dict
        Parameters to pass to `shape_sampler_fn`.

    Returns:
    --------
    (slices, x) : A tuple of the slices used to cut the sample as well as
    the sampled subsection with the same dimensionality of arr.
        slice :: list of slice objects
        x :: array object with the same ndims as arr
    '''
    slices = []
    for dim in arr.shape:
        if loc_dim_param:
            loc_params.update({loc_dim_param: dim})
        if shape_dim_param:
            shape_params.update({shape_dim_param: dim})
        start = int(loc_sampler_fn(**loc_params))
        stop = start + int(shape_sampler_fn(**shape_params))
        slices.append(slice(start, stop))
    return slices, arr[slices]

在宽度介于3和9之间的2D阵列上均匀切割的示例：

a = np.random.randint(0, 1+1, size=(100,150))
box_sampler(a, 
            np.random.uniform, 'high', {'low':0}, 
            np.random.uniform, None, {'low':3, 'high':10})
# returns:
([slice(49, 55, None), slice(86, 89, None)], 
 array([[0, 0, 1],
        [0, 1, 1],
        [0, 0, 0],
        [0, 0, 1],
        [1, 1, 1],
        [1, 1, 0]]))

从10x20x30 3D阵列中获取2x2x2块的示例：

a = np.random.randint(0,2,size=(10,20,30))
box_sampler(a, np.random.uniform, 'high', {'low':0}, 
               np.random.uniform, None, {'low':2, 'high':2})
# returns:
([slice(7, 9, None), slice(9, 11, None), slice(19, 21, None)], 
 array([[[0, 1],
         [1, 0]],
        [[0, 1],
         [1, 1]]]))

根据评论进行更新。

出于特定目的，您看起来想要一个矩形样本，其中起始角从阵列中的任何位置均匀采样，并且沿着每个轴的样本宽度均匀采样，但可以是有限的。

这是一个生成这些样本的函数。 min_width和max_width可以接受整数（例如元组）或单个整数的迭代。

def uniform_box_sampler(arr, min_width, max_width):
    '''
    Extracts a sample cut from `arr`.

    Parameters:
    -----------
    arr : array
        The numpy array to sample a box from
    min_width : int or tuple
        The minimum width of the box along a given axis.
        If a tuple of integers is supplied, it my have the
        same length as the number of dimensions of `arr`
    max_width : int or tuple
        The maximum width of the box along a given axis.
        If a tuple of integers is supplied, it my have the
        same length as the number of dimensions of `arr`

    Returns:
    --------
    (slices, x) : A tuple of the slices used to cut the sample as well as
    the sampled subsection with the same dimensionality of arr.
        slice :: list of slice objects
        x :: array object with the same ndims as arr
    '''
    if isinstance(min_width, (tuple, list)):
        assert len(min_width)==arr.ndim, 'Dimensions of `min_width` and `arr` must match'
    else:
        min_width = (min_width,)*arr.ndim
    if isinstance(max_width, (tuple, list)):
        assert len(max_width)==arr.ndim, 'Dimensions of `max_width` and `arr` must match'
    else:
        max_width = (max_width,)*arr.ndim

    slices = []
    for dim, mn, mx in zip(arr.shape, min_width, max_width):
        fn = np.random.uniform
        start = int(np.random.uniform(0,dim))
        stop = start + int(np.random.uniform(mn, mx+1))
        slices.append(slice(start, stop))
    return slices, arr[slices]

生成在数组中任意位置均匀开始的框切割的示例，高度是从1到4的随机均匀绘制，宽度是从2到6的随机均匀绘制（仅显示）。在这种情况下，盒子的大小是3乘4，从第66行和第19列开始。

x = np.random.randint(0,2,size=(100,100))
uniform_box_sampler(x, (1,2), (4,6))
# returns:
([slice(65, 68, None), slice(18, 22, None)], 
 array([[1, 0, 0, 0],
        [0, 0, 1, 1],
        [0, 1, 1, 0]]))

Answer 2

因此，sklearn.feature_extraction.image.extract_patches_2d的问题似乎是强制您指定单个补丁大小，而您正在寻找随机大小的不同补丁。

这里需要注意的一点是，您的结果不能是NumPy数组（与sklearn函数的结果不同），因为数组必须具有统一长度的行/列。因此，您的输出需要是包含不同形状数组的其他数据结构。

这是一个解决方法：

from itertools import product

def random_patches_2d(arr, n_patches):
    # The all possible row and column slices from `arr` given its shape
    row, col = arr.shape
    row_comb = [(i, j) for i, j in product(range(row), range(row)) if i < j]
    col_comb = [(i, j) for i, j in product(range(col), range(col)) if i < j]

    # Pick randomly from the possible slices.  The distribution will be
    #     random uniform from the given slices.  We can't use
    #     np.random.choice because it only samples from a 1d array.
    a = np.random.choice(np.arange(len(row_comb)), size=n_patches)
    b = np.random.choice(np.arange(len(col_comb)), size=n_patches)
    for i, j in zip(a, b):
        yield arr[row_comb[i][0]:row_comb[i][1], 
                  col_comb[i][0]:col_comb[i][1]]

示例：

np.random.seed(99)
arr = np.arange(49).reshape(7, 7)
res = list(random_patches_2d(arr, 5))
print(res[0])
print()
print(res[3])
[[0 1]
 [7 8]]

[[ 8  9 10 11]
 [15 16 17 18]
 [22 23 24 25]
 [29 30 31 32]]

冷凝的：

def random_patches_2d(arr, n_patches):
    row, col = arr.shape
    row_comb = [(i, j) for i, j in product(range(row), range(row)) if i < j]
    col_comb = [(i, j) for i, j in product(range(col), range(col)) if i < j]
    a = np.random.choice(np.arange(len(row_comb)), size=n_patches)
    b = np.random.choice(np.arange(len(col_comb)), size=n_patches)
    for i, j in zip(a, b):
        yield arr[row_comb[i][0]:row_comb[i][1], 
                  col_comb[i][0]:col_comb[i][1]]

解决您的评论：您可以连续添加1个补丁并在每个补丁后检查该区域。

# `size` is just row x col
area = arr.size
patch_area = 0
while patch_area <= area:  # or while patch_area <= 0.1 * area:
    patch = random_patches_2d(arr, n_patches=1)
    patch_area += patch

从python中的2D数组中随机采样子数组

问题：

预期（但部分）解决方案：

问题：

2 个答案:

根据评论进行更新。