Tranche plusieurs images du tableau numpy avec plusieurs y1: y2, x1: x2
J'ai un tableau numpy de plusieurs cadres (multiple_frames) et je veux trancher la hauteur et la largeur de chaque cadre avec différents y1, y2, x1, x2 pour dessiner un carré de "1" dans chaque cadre. (slice_yyxx) est un tableau numpy et contient un tableau de y1, y2, x1, x2 pour chaque image.
slice_yyxx = np.array(slice_yyxx).astype(int)
nbr_frame = slice_yyxx.shape[0]
multiple_frames = np.zeros(shape=(nbr_frame, target_shape[0], target_shape[1], target_shape[2]))
print(multiple_frames.shape)
# (5, 384, 640, 1)
print(slice_yyxx)
# Value ok
print(slice_yyxx.shape)
# (5, 4)
# Then 5 array of coord like [y1, y2, x1, x2] for slice each frames
print(slice_yyxx.dtype)
# np.int64
multiple_frames[:, slice_yyxx[:,0]:slice_yyxx[:,1], slice_yyxx[:,2]:slice_yyxx[:,3]] = 1
# ERROR: TypeError: only integer scalar arrays can be converted to a scalar index
Réponses
La vraie question ici est de savoir comment convertir des tranches arbitraires en quelque chose que vous pouvez utiliser sur plusieurs dimensions sans boucle. Je dirais que l’astuce consiste à utiliser une combinaison intelligente d’indexation sophistiquée arange, et repeat.
L'objectif est de créer un tableau d'index de ligne et de colonne correspondant à chaque dimension. Prenons un cas simple qui est facile à visualiser: un ensemble de 3 images de matrices 3x3, où nous voulons affecter aux sous-tableaux 2x2 supérieur gauche et inférieur droit les deux premières images, et le tout à la dernière image :
multi_array = np.zeros((3, 3, 3))
slice_rrcc = np.array([[0, 2, 0, 2], [1, 3, 1, 3], [0, 3, 0, 3]])
Imaginons les indices qui correspondent à chacun, ainsi que les tailles et les formes:
nframes = slice_rrcc.shape[0] # 3
nrows = np.diff(slice_rrcc[:, :2], axis=1).ravel() # [2, 2, 3]
ncols = np.diff(slice_rrcc[:, 2:], axis=1).ravel() # [2, 2, 3]
sizes = nrows * ncols # [4, 4, 9]
Nous avons besoin des indices fantaisie suivants pour pouvoir effectuer la mission:
frame_index = np.array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2])
row_index = np.array([0, 0, 1, 1, 1, 1, 2, 2, 0, 0, 0, 1, 1, 1, 2, 2, 2])
col_index = np.array([0, 1, 0, 1, 1, 2, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2])
Si nous pouvons obtenir les tableaux frame_index, row_indexet col_index, nous pouvons définir les données pour chaque segment comme suit:
multi_array[frame_index, row_index, col_index] = 1
frame_index index est facile à obtenir:
frame_index = np.repeat(np.arange(nframes), sizes)
row_indexdemande un peu plus de travail. Vous devez générer un ensemble d' nrowsindices pour chaque image individuelle et les répéter plusieurs ncolsfois. Vous pouvez le faire en générant une plage continue et en redémarrant le comptage à chaque image à l'aide de la soustraction:
row_range = np.arange(nrows.sum())
row_offsets = np.zeros_like(row_range)
row_offsets[np.cumsum(nrows[:-1])] = nrows[:-1]
row_index = row_range - np.cumsum(row_offsets) + np.repeat(slice_rrcc[:, 0], nrows)
segments = np.repeat(ncols, nrows)
row_index = np.repeat(row_index, segments)
col_indexsera encore moins trivial. Vous devez générer une séquence pour chaque ligne avec le bon décalage, et la répéter en morceaux pour chaque ligne, puis pour chaque image. L'approche est similaire à celle pour row_index, avec un index supplémentaire pour obtenir la bonne commande:
col_index_index = np.arange(sizes.sum())
col_index_resets = np.cumsum(segments[:-1])
col_index_offsets = np.zeros_like(col_index_index)
col_index_offsets[col_index_resets] = segments[:-1]
col_index_offsets[np.cumsum(sizes[:-1])] -= ncols[:-1]
col_index_index -= np.cumsum(col_index_offsets)
col_range = np.arange(ncols.sum())
col_offsets = np.zeros_like(col_range)
col_offsets[np.cumsum(ncols[:-1])] = ncols[:-1]
col_index = col_range - np.cumsum(col_offsets) + np.repeat(slice_rrcc[:, 2], ncols)
col_index = col_index[col_index_index]
En utilisant cette formulation, vous pouvez même l'intensifier et spécifier une valeur différente pour chaque image. Si vous vouliez attribuer values = [1, 2, 3]les cadres de mon exemple, faites simplement
multi_array[frame_index, row_index, col_index] = np.repeat(values, sizes)
Nous verrons s'il existe un moyen plus efficace de le faire. Une partie que j'ai posée est ici .
Référence
Une comparaison de votre boucle par rapport à ma solution vectorisée pour nframesin {10, 100, 1000} et largeur et hauteur de multi_arrayin {100, 1000, 10000}:
def set_slices_loop(arr, slice_rrcc):
for a, s in zip(arr, slice_rrcc):
a[s[0]:s[1], s[2]:s[3]] = 1
np.random.seed(0xABCDEF)
for nframes in [10, 100, 1000]:
for dim in [10, 32, 100]:
print(f'Size = {nframes}x{dim}x{dim}')
arr = np.zeros((nframes, dim, dim), dtype=int)
slice = np.zeros((nframes, 4), dtype=int)
slice[:, ::2] = np.random.randint(0, dim - 1, size=(nframes, 2))
slice[:, 1::2] = np.random.randint(slice[:, ::2] + 1, dim, size=(nframes, 2))
%timeit set_slices_loop(arr, slice)
arr[:] = 0
%timeit set_slices(arr, slice)
Les résultats sont majoritairement en faveur de la boucle, à la seule exception d'un très grand nombre de cadres et de petites tailles de cadre. La plupart des cas "normaux" sont un ordre de grandeur plus rapides avec la boucle:
Boucle
| Dimension |
| 100 | 1000 | 10000 |
--------+---------+---------+---------+
F 10 | 33.8 µs | 35.8 µs | 43.4 µs |
r -----+---------+---------+---------+
a 100 | 310 µs | 331 µs | 401 µs |
m -----+---------+---------+---------+
e 1000 | 3.09 ms | 3.31 ms | 4.27 ms |
--------+---------+---------+---------+
Vectorisé
| Dimension |
| 100 | 1000 | 10000 |
--------+---------+---------+---------+
F 10 | 225 µs | 266 µs | 545 µs |
r -----+---------+---------+---------+
a 100 | 312 µs | 627 µs | 4.11 ms |
m -----+---------+---------+---------+
e 1000 | 1.07 ms | 4.63 ms | 48.5 ms |
--------+---------+---------+---------+
TL; DR
Peut être fait, mais pas recommandé:
def set_slices(arr, slice_rrcc, value):
nframes = slice_rrcc.shape[0]
nrows = np.diff(slice_rrcc[:, :2], axis=1).ravel()
ncols = np.diff(slice_rrcc[:, 2:], axis=1).ravel()
sizes = nrows * ncols
segments = np.repeat(ncols, nrows)
frame_index = np.repeat(np.arange(nframes), sizes)
row_range = np.arange(nrows.sum())
row_offsets = np.zeros_like(row_range)
row_offsets[np.cumsum(nrows[:-1])] = nrows[:-1]
row_index = row_range - np.cumsum(row_offsets) + np.repeat(slice_rrcc[:, 0], nrows)
row_index = np.repeat(row_index, segments)
col_index_index = np.arange(sizes.sum())
col_index_resets = np.cumsum(segments[:-1])
col_index_offsets = np.zeros_like(col_index_index)
col_index_offsets[col_index_resets] = segments[:-1]
col_index_offsets[np.cumsum(sizes[:-1])] -= ncols[:-1]
col_index_index -= np.cumsum(col_index_offsets)
col_range = np.arange(ncols.sum())
col_offsets = np.zeros_like(col_range)
col_offsets[np.cumsum(ncols[:-1])] = ncols[:-1]
col_index = col_range - np.cumsum(col_offsets) + np.repeat(slice_rrcc[:, 2], ncols)
col_index = col_index[col_index_index]
if values.size == 1:
arr[frame_index, row_index, col_index] = value
else:
arr[frame_index, row_index, col_index] = np.repeat(values, sizes)
Ceci est un article de benchmarking utilisant un benchitpackage (quelques outils de benchmarking regroupés; avertissement: je suis son auteur) pour comparer les solutions proposées.
Nous effectuons une analyse comparative set_slicesde la solution de @Mad Physicist avec arr[frame_index, row_index, col_index] = 1et set_slices_loopsans aucun changement pour obtenir le temps d'exécution (sec).
np.random.seed(0xABCDEF)
in_ = {}
for nframes in [10, 100, 1000]:
for dim in [10, 32, 100]:
arr = np.zeros((nframes, dim, dim), dtype=int)
slice = np.zeros((nframes, 4), dtype=int)
slice[:, ::2] = np.random.randint(0, dim - 1, size=(nframes, 2))
slice[:, 1::2] = np.random.randint(slice[:, ::2] + 1, dim, size=(nframes, 2))
in_[(nframes, dim)] = [arr, slice]
import benchit
funcs = [set_slices, set_slices_loop]
t = benchit.timings(funcs, in_, input_name=['NumFrames', 'Dim'], multivar=True)
t.plot(sp_argID=1, logx=True, save='timings.png')
