如何将不规则间隔的 x & y 坐标张量平均到具有特定单元格大小的网格中？

如何解决如何将不规则间隔的 x & y 坐标张量平均到具有特定单元格大小的网格中？

我有一个算法可以生成不规则间隔的 x 和 y 坐标张量（例如：torch.size([3600,2])），我需要将点平均到特定大小的网格单元中（例如： 8 乘 8）。生成的网格必须是数组或张量。

这不是必需的，但我也希望能够确定是否有任何生成的单元格中的点数少于指定数量。

例如，我可以使用 matplotlib 的 plt.scatter 绘制张量的图形，它看起来像这样：

在上面的示例中，存在 100,000 个点，但点的数量有时可能达到数千万个。

我尝试过使用直方图方法，其中大多数使用特定数量的单元格与特定的单元格大小。 Matplotlib 似乎可以在图形中完成，但这并不能帮助我获得数组或张量。

编辑：

如果可以正常工作，此代码可能会起作用。

def grid_torch(x_coords,y_coords,grid_size=(8,8),x_extent=(0.,1.),y_extent=(0.,1.)):
    x_coords = ((x_coords - x_extent[0]) / (x_extent[1] - x_extent[0])) * grid_size[0]
    y_coords = ((y_coords - y_extent[0]) / (y_extent[1] - y_extent[0])) * grid_size[1]

    x_list = []
    for x in range(grid_size[0]):
        x = torch.ones_like(x_coords) * x
        y_list = []
        for y in range(grid_size[1]):
            y = torch.ones_like(y_coords) * y
            in_bounds_x = torch.logical_and(x <= x_coords,x_coords <= x + 1)
            in_bounds_y = torch.logical_and(y <= y_coords,y_coords <= y + 1)
            in_bounds = torch.logical_and(in_bounds_x,in_bounds_y)

            in_bounds_indices = torch.where(in_bounds)
            print(in_bounds_indices)
            y_list.append(in_bounds_indices)
        x_list.append(torch.stack(y_list))
    return torch.stack(x_list)



out = grid_torch(xy_tensor[:,0],xy_tensor[:,1])

print(out.shape)

def create_grid(grid_layout,activ,min_density=8):
    cells = []
    for x in range(grid_size[0]):
        for y in range(grid_size[1]):
            indices = grid_layout[x,y]
            if len(indices) > min_density:
                average_activation = torch.mean(activ[indices])
                cells.append((average_activation,x,y))
                print(average_activation,y)
    return torch.stack(cells)



grid_test = create_grid(out,xy_tensor,8))

解决方法

我认为这段代码会给你一个很好的起点。

def grid_torch(x_coords,y_coords,grid_size=(8,8),x_extent=(0.,1.),y_extent=(0.,1.)):
    # This part converts coordinates to bin numbers (like (2,5),(7,7) etc)
    x_bin = (((x_coords - x_extent[0]) / (x_extent[1] - x_extent[0])) * grid_size[0]).int()
    y_bin = (((y_coords - y_extent[0]) / (y_extent[1] - y_extent[0])) * grid_size[1]).int()
    
    counts = torch.zeros(grid_size)
    means = torch.zeros(list(grid_size) + [2])
    for x in range(grid_size[0]):
        for y in range(grid_size[1]):
            # these tensors are 1 where (x_bin == x and y_bin == y),0 else where
            x_where = 1 * (x_bin == x)
            y_where = 1 * (y_bin == y)
            p_where = (x_where * y_where)
            cnt = p_where.sum()
            counts[x,y] = cnt
            
            # we'll average both x and y coords seperately.
            # you can embed min_density logic here. 
            if cnt > 0:
                means[x,y,0] = (x_coords * p_where).sum() / p_where.sum()
                means[x,1] = (y_coords * p_where).sum() / p_where.sum()
    
    return counts,means


# Generate sample points
points = torch.tensor(np.concatenate([
    np.random.normal(loc=0.2,scale=0.1,size=(1000,2)),np.random.normal(loc=0.6,2))
]).clip(0,1)).float()
# plt.scatter(points[:,0],points[:,1])
# plt.grid()

counts,means = grid_torch(points[:,1])
counts

>>>
tensor([[ 47.,114.,75.,10.,0.,0.],[102.,204.,141.,27.,[ 60.,101.,74.,16.,7.,4.,1.,[  5.,17.,9.,23.,72.,51.,[  1.,54.,186.,28.,3.],[  0.,3.,47.,154.,117.,14.,37.,24.,2.,0.]])