Wprowadzenie do cięcia tensorowego

Zobacz na TensorFlow.org Uruchom w Google Colab Wyświetl źródło na GitHub Pobierz notatnik

Podczas pracy z aplikacjami ML, takimi jak wykrywanie obiektów i NLP, czasami konieczna jest praca z podsekcjami (wycinkami) tensorów. Na przykład, jeśli architektura modelu obejmuje routing, w którym jedna warstwa może kontrolować, który przykład szkolenia jest kierowany do następnej warstwy. W takim przypadku możesz użyć tensor slicing ops, aby podzielić tensory i złożyć je z powrotem we właściwej kolejności.

W aplikacjach NLP można użyć dzielenia tensorowego, aby wykonać maskowanie słów podczas uczenia. Na przykład możesz wygenerować dane szkoleniowe z listy zdań, wybierając indeks słów do zamaskowania w każdym zdaniu, usuwając słowo jako etykietę, a następnie zastępując wybrane słowo tokenem maski.

Z tego przewodnika dowiesz się, jak używać interfejsów API TensorFlow do:

  • Wyodrębnij plastry z tensora
  • Wstawiaj dane pod określonymi indeksami w tensorze

W tym przewodniku założono znajomość indeksowania tensorów. Przeczytaj sekcje dotyczące indeksowania przewodników Tensor i TensorFlow NumPy przed rozpoczęciem korzystania z tego przewodnika.

Ustawiać

import tensorflow as tf
import numpy as np

Wyodrębnij plasterki tensora

Wykonaj cięcie tensorowe w stylu NumPy za pomocą tf.slice .

t1 = tf.constant([0, 1, 2, 3, 4, 5, 6, 7])

print(tf.slice(t1,
               begin=[1],
               size=[3]))

tf.Tensor([1 2 3], shape=(3,), dtype=int32)

Alternatywnie możesz użyć bardziej Pythonowej składni. Zwróć uwagę, że warstwy napinacza są równomiernie rozmieszczone w zakresie start-stop.

print(t1[1:4])

tf.Tensor([1 2 3], shape=(3,), dtype=int32)


print(t1[-3:])

tf.Tensor([5 6 7], shape=(3,), dtype=int32)

W przypadku tensorów dwuwymiarowych możesz użyć czegoś takiego:

t2 = tf.constant([[0, 1, 2, 3, 4],
                  [5, 6, 7, 8, 9],
                  [10, 11, 12, 13, 14],
                  [15, 16, 17, 18, 19]])

print(t2[:-1, 1:3])

tf.Tensor(
[[ 1  2]
 [ 6  7]
 [11 12]], shape=(3, 2), dtype=int32)

Możesz również użyć tf.slice na wyższych tensorach wymiarowych.

t3 = tf.constant([[[1, 3, 5, 7],
                   [9, 11, 13, 15]],
                  [[17, 19, 21, 23],
                   [25, 27, 29, 31]]
                  ])

print(tf.slice(t3,
               begin=[1, 1, 0],
               size=[1, 1, 2]))

tf.Tensor([[[25 27]]], shape=(1, 1, 2), dtype=int32)

Możesz również użyć tf.strided_slice , aby wyodrębnić fragmenty tensorów, „przechodząc” przez wymiary tensora.

Użyj tf.gather , aby wyodrębnić określone indeksy z pojedynczej osi tensora.

print(tf.gather(t1,
                indices=[0, 3, 6]))

# This is similar to doing

t1[::3]

tf.Tensor([0 3 6], shape=(3,), dtype=int32)
<tf.Tensor: shape=(3,), dtype=int32, numpy=array([0, 3, 6], dtype=int32)>

tf.gather nie wymaga równomiernego rozmieszczenia indeksów.

alphabet = tf.constant(list('abcdefghijklmnopqrstuvwxyz'))

print(tf.gather(alphabet,
                indices=[2, 0, 19, 18]))

tf.Tensor([b'c' b'a' b't' b's'], shape=(4,), dtype=string)

Aby wyodrębnić plasterki z wielu osi tensora, użyj tf.gather_nd . Jest to przydatne, gdy chcesz zebrać elementy macierzy, a nie tylko jej wiersze lub kolumny.

t4 = tf.constant([[0, 5],
                  [1, 6],
                  [2, 7],
                  [3, 8],
                  [4, 9]])

print(tf.gather_nd(t4,
                   indices=[[2], [3], [0]]))

tf.Tensor(
[[2 7]
 [3 8]
 [0 5]], shape=(3, 2), dtype=int32)


t5 = np.reshape(np.arange(18), [2, 3, 3])

print(tf.gather_nd(t5,
                   indices=[[0, 0, 0], [1, 2, 1]]))

tf.Tensor([ 0 16], shape=(2,), dtype=int64)

# Return a list of two matrices

print(tf.gather_nd(t5,
                   indices=[[[0, 0], [0, 2]], [[1, 0], [1, 2]]]))

tf.Tensor(
[[[ 0  1  2]
  [ 6  7  8]]

 [[ 9 10 11]
  [15 16 17]]], shape=(2, 2, 3), dtype=int64)

# Return one matrix

print(tf.gather_nd(t5,
                   indices=[[0, 0], [0, 2], [1, 0], [1, 2]]))

tf.Tensor(
[[ 0  1  2]
 [ 6  7  8]
 [ 9 10 11]
 [15 16 17]], shape=(4, 3), dtype=int64)

Wstaw dane do tensorów

Użyj tf.scatter_nd , aby wstawić dane w określonych wycinkach/indeksach tensora. Zauważ, że tensor, do którego wstawiasz wartości, jest inicjowany od zera.

t6 = tf.constant([10])
indices = tf.constant([[1], [3], [5], [7], [9]])
data = tf.constant([2, 4, 6, 8, 10])

print(tf.scatter_nd(indices=indices,
                    updates=data,
                    shape=t6))

tf.Tensor([ 0  2  0  4  0  6  0  8  0 10], shape=(10,), dtype=int32)

Metody takie jak tf.scatter_nd , które wymagają tensorów inicjowanych od zera, są podobne do rzadkich inicjatorów tensorów. Możesz użyć tf.gather_nd i tf.scatter_nd , aby naśladować zachowanie sparse tensor ops.

Rozważ przykład, w którym konstruujesz rzadki tensor, używając tych dwóch metod w połączeniu.

# Gather values from one tensor by specifying indices

new_indices = tf.constant([[0, 2], [2, 1], [3, 3]])
t7 = tf.gather_nd(t2, indices=new_indices)


# Add these values into a new tensor

t8 = tf.scatter_nd(indices=new_indices, updates=t7, shape=tf.constant([4, 5]))

print(t8)

tf.Tensor(
[[ 0  0  2  0  0]
 [ 0  0  0  0  0]
 [ 0 11  0  0  0]
 [ 0  0  0 18  0]], shape=(4, 5), dtype=int32)

To jest podobne do:

t9 = tf.SparseTensor(indices=[[0, 2], [2, 1], [3, 3]],
                     values=[2, 11, 18],
                     dense_shape=[4, 5])

print(t9)

SparseTensor(indices=tf.Tensor(
[[0 2]
 [2 1]
 [3 3]], shape=(3, 2), dtype=int64), values=tf.Tensor([ 2 11 18], shape=(3,), dtype=int32), dense_shape=tf.Tensor([4 5], shape=(2,), dtype=int64))

# Convert the sparse tensor into a dense tensor

t10 = tf.sparse.to_dense(t9)

print(t10)

tf.Tensor(
[[ 0  0  2  0  0]
 [ 0  0  0  0  0]
 [ 0 11  0  0  0]
 [ 0  0  0 18  0]], shape=(4, 5), dtype=int32)

Aby wstawić dane do tensora z wcześniej istniejącymi wartościami, użyj tf.tensor_scatter_nd_add .

t11 = tf.constant([[2, 7, 0],
                   [9, 0, 1],
                   [0, 3, 8]])

# Convert the tensor into a magic square by inserting numbers at appropriate indices

t12 = tf.tensor_scatter_nd_add(t11,
                               indices=[[0, 2], [1, 1], [2, 0]],
                               updates=[6, 5, 4])

print(t12)

tf.Tensor(
[[2 7 6]
 [9 5 1]
 [4 3 8]], shape=(3, 3), dtype=int32)

Podobnie użyj tf.tensor_scatter_nd_sub , aby odjąć wartości od tensora z wcześniej istniejącymi wartościami.

# Convert the tensor into an identity matrix

t13 = tf.tensor_scatter_nd_sub(t11,
                               indices=[[0, 0], [0, 1], [1, 0], [1, 1], [1, 2], [2, 1], [2, 2]],
                               updates=[1, 7, 9, -1, 1, 3, 7])

print(t13)

tf.Tensor(
[[1 0 0]
 [0 1 0]
 [0 0 1]], shape=(3, 3), dtype=int32)

Użyj tf.tensor_scatter_nd_min , aby skopiować minimalne wartości elementów z jednego tensora do drugiego.

t14 = tf.constant([[-2, -7, 0],
                   [-9, 0, 1],
                   [0, -3, -8]])

t15 = tf.tensor_scatter_nd_min(t14,
                               indices=[[0, 2], [1, 1], [2, 0]],
                               updates=[-6, -5, -4])

print(t15)

tf.Tensor(
[[-2 -7 -6]
 [-9 -5  1]
 [-4 -3 -8]], shape=(3, 3), dtype=int32)

Podobnie, użyj tf.tensor_scatter_nd_max , aby skopiować maksymalne wartości elementów z jednego tensora do drugiego.

t16 = tf.tensor_scatter_nd_max(t14,
                               indices=[[0, 2], [1, 1], [2, 0]],
                               updates=[6, 5, 4])

print(t16)

tf.Tensor(
[[-2 -7  6]
 [-9  5  1]
 [ 4 -3 -8]], shape=(3, 3), dtype=int32)

Dalsze czytanie i zasoby

W tym przewodniku dowiedziałeś się, jak korzystać z opcji tensor slicing dostępnych w TensorFlow, aby lepiej kontrolować elementy w swoich tensorach.