StridedSlice

StridedSlice kelas akhir publik

Kembalikan potongan langkah dari `input`.

Catatan, sebagian besar pengguna python ingin menggunakan Tensor.__getitem__ atau Variable.__getitem__ Python daripada operasi ini secara langsung.

Tujuan dari operasi ini adalah menghasilkan tensor baru dengan subset elemen dari tensor `input` dimensi `n`. Subset dipilih menggunakan rangkaian spesifikasi rentang renggang `m` yang dikodekan ke dalam argumen fungsi ini. Perhatikan, dalam beberapa kasus `m` bisa sama dengan `n`, namun tidak harus demikian. Setiap entri spesifikasi rentang dapat berupa salah satu dari berikut ini:

- Elipsis (...). Elips digunakan untuk menyiratkan nol atau lebih dimensi dari pemilihan dimensi penuh dan diproduksi menggunakan `ellipsis_mask`. Misalnya, `foo[...]` adalah potongan identitas.

- Sumbu baru. Ini digunakan untuk menyisipkan dimensi bentuk=1 baru dan diproduksi menggunakan `mask_sumbu_baru`. Misalnya, `foo[:, ...]` dengan `foo` berbentuk `(3, 4)` menghasilkan tensor `(1, 3, 4)`.

- Rentang `mulai:akhir:langkah`. Ini digunakan untuk menentukan berapa banyak yang harus dipilih dari dimensi tertentu. `stride` dapat berupa bilangan bulat apa pun kecuali 0. `begin` adalah bilangan bulat yang mewakili indeks nilai pertama yang dipilih, sedangkan `end` mewakili indeks nilai terakhir yang dipilih. Jumlah nilai yang dipilih di setiap dimensi adalah `akhir - mulai` jika `langkah > 0` dan `mulai - akhir` jika `langkah < 0`. `begin` dan `end` bisa bernilai negatif dengan `-1` adalah elemen terakhir, `-2` adalah elemen kedua dari terakhir. `begin_mask` mengontrol apakah akan mengganti `begin` yang diberikan secara eksplisit dengan nilai efektif implisit `0` jika `stride > 0` dan `-1` jika `stride < 0`. `end_mask` serupa tetapi menghasilkan angka yang diperlukan untuk membuat interval terbuka terbesar. Misalnya, dengan bentuk `(3,)` tensor `foo[:]`, `begin` dan `end` yang efektif adalah `0` dan `3`. Jangan berasumsi ini setara dengan `foo[0:-1]` yang memiliki `begin` dan `end` yang efektif dari `0` dan `2`. Contoh lainnya adalah `foo[-2::-1]` yang membalik dimensi pertama tensor sambil menghilangkan dua dimensi terakhir (dalam elemen urutan aslinya). Misalnya `foo = [1,2,3,4]; foo[-2::-1]` adalah `[4,3]`.

- Sebuah indeks tunggal. Ini digunakan untuk menyimpan hanya elemen yang memiliki indeks tertentu. Misalnya (`foo[2, :]` pada tensor bentuk `(5,6)` menghasilkan tensor bentuk `(6,)`. Ini dikodekan dalam `begin` dan `end` dan `shrink_axis_mask`.

Setiap spesifikasi rentang konseptual dikodekan dalam argumen operasi. Pengkodean ini paling baik dipahami dengan mempertimbangkan contoh yang tidak sepele. Secara khusus, `foo[1, 2:4, None, ..., :-3:-1, :]` akan dikodekan sebagai

begin = [1, 2, x, x, 0, x] # x denotes don't care (usually 0)
 end = [2, 4, x, x, -3, x]
 strides = [1, 1, x, x, -1, 1]
 begin_mask = 1&lt;&lt;4 | 1&lt;&lt;5 = 48
 end_mask = 1&lt;&lt;5 = 32
 ellipsis_mask = 1&lt;&lt;3 = 8
 new_axis_mask = 1&lt;&lt;2 = 4
 shrink_axis_mask = 1&lt;&lt;0 = 1
 
Dalam hal ini jika `foo.shape` adalah (5, 5, 5, 5, 5, 5) bentuk akhir irisan menjadi (2, 1, 5, 5, 2, 5). Mari kita telusuri langkah demi langkah melalui setiap spesifikasi argumen.

1. Argumen pertama pada contoh irisan diubah menjadi `begin = 1` dan `end = Begin + 1 = 2`. Untuk membedakan spesifikasi asli `2:4` kami juga menyetel bit yang sesuai di `shrink_axis_mask`.

2. `2:4` menyumbang 2, 4, 1 untuk memulai, mengakhiri, dan melangkah. Semua topeng tidak memiliki kontribusi sedikit pun.

3. Tidak ada yang merupakan sinonim untuk tf.newaxis . Artinya memasukkan dimensi berukuran 1 dimensi pada bentuk akhir. Nilai dummy dikontribusikan untuk memulai, mengakhiri dan melangkah, sedangkan bit new_axis_mask diatur.

4. `...` ambil rentang penuh dari sebanyak mungkin dimensi yang diperlukan untuk menentukan sepenuhnya irisan untuk setiap dimensi bentuk masukan.

5. `:-3:-1` menunjukkan penggunaan indeks negatif. Indeks negatif `i` yang terkait dengan dimensi berbentuk `s` diubah menjadi indeks positif `s + i`. Jadi `-1` menjadi `s-1` (yaitu elemen terakhir). Konversi ini dilakukan secara internal sehingga awal, akhir, dan langkah menerima x, -3, dan -1. Bit Begin_mask yang sesuai diatur untuk menunjukkan rentang awal adalah rentang penuh (mengabaikan x).

6. `:` menunjukkan bahwa seluruh isi dimensi terkait dipilih. Ini setara dengan `::` atau `0::1`. mulai, akhir, dan langkah masing-masing menerima 0, 0, dan 1. Bit yang sesuai di `begin_mask` dan `end_mask` juga disetel.

Persyaratan : `0 != langkah[i] untuk i di [0, m)` `ellipsis_mask harus pangkat dua (hanya satu elipsis)`

Kelas Bersarang

kelas StridedSlice.Opsi Atribut opsional untuk StridedSlice

Metode Publik

Keluaran <T>
sebagai Keluaran ()
Mengembalikan pegangan simbolik tensor.
StridedSlice.Options statis
beginMask (BeginMask panjang)
statis <T, U memperluas Angka> StridedSlice <T>
buat ( Lingkup lingkup, Operan <T> masukan, Operan <U> mulai, Operan <U> akhir, Operan <U> langkahnya, Opsi... opsi)
Metode pabrik untuk membuat kelas yang membungkus operasi StridedSlice baru.
StridedSlice.Options statis
ellipsisMask (Mask elipsis panjang)
StridedSlice.Options statis
endMask (Mask ujung panjang)
StridedSlice.Options statis
newAxisMask (Panjang newAxisMask)
Keluaran <T>
StridedSlice.Options statis
shrinkAxisMask (Penyusut panjangAxisMask)

Metode Warisan

Metode Publik

Keluaran publik <T> sebagai Keluaran ()

Mengembalikan pegangan simbolik tensor.

Masukan ke operasi TensorFlow adalah keluaran dari operasi TensorFlow lainnya. Metode ini digunakan untuk mendapatkan pegangan simbolis yang mewakili perhitungan input.

StridedSlice.Options BeginMask statis publik (BeginMask panjang)

Parameter
mulaiMask bitmask di mana sedikit i menjadi 1 berarti mengabaikan nilai awal dan sebagai gantinya menggunakan interval sebesar mungkin. Saat runtime, start[i] akan diganti dengan `[0, n-1)` jika `stride[i] > 0` atau `[-1, n-1]` jika `stride[i] < 0`

public static StridedSlice <T> buat ( Lingkup lingkup, masukan Operan <T>, Operan <U> mulai, Operan <U> akhir, langkah Operan <U>, Opsi... opsi)

Metode pabrik untuk membuat kelas yang membungkus operasi StridedSlice baru.

Parameter
cakupan ruang lingkup saat ini
mulai `begin[k]` menentukan offset ke dalam spesifikasi rentang ke-`k`. Dimensi pasti yang terkait dengan hal ini akan ditentukan oleh konteks. Nilai di luar batas akan dijepit secara diam-diam. Jika bit ke-k` dari `begin_mask` maka `begin[k]` diabaikan dan sebagai gantinya digunakan rentang penuh dimensi yang sesuai. Nilai negatif menyebabkan pengindeksan dimulai dari elemen tertinggi misalnya Jika `foo==[1,2,3]` maka `foo[-1]==3`.
akhir `end[i]` seperti `begin` dengan pengecualian bahwa `end_mask` digunakan untuk menentukan rentang penuh.
langkah `strides[i]` menentukan kenaikan dalam spesifikasi `i` setelah mengekstraksi elemen tertentu. Indeks negatif akan membalikkan urutan awal. Nilai di luar atau rentang dijepit ke `[0,dim[i]) jika irisan[i]>0` atau `[-1,dim[i]-1] jika irisan[i] < 0`
pilihan membawa nilai atribut opsional
Kembali
  • contoh baru dari StridedSlice

StridedSlice.Options ellipsisMask statis publik (EllipsisMask panjang)

Parameter
elipsisMask bitmask di mana bit `i` menjadi 1 berarti posisi `i`th sebenarnya adalah elipsis. Maksimal satu bit dapat berupa 1. Jika `ellipsis_mask == 0`, maka mask elipsis implisit `1 << (m+1)` disediakan. Artinya `foo[3:5] == foo[3:5, ...]`. Elipsis secara implisit menciptakan spesifikasi rentang sebanyak yang diperlukan untuk sepenuhnya menentukan rentang irisan untuk setiap dimensi. Misalnya untuk tensor 4 dimensi `foo` irisan `foo[2, ..., 5:8]` menyiratkan `foo[2, :, :, 5:8]`.

StridedSlice.Options endMask statis publik (Mask ujung panjang)

Parameter
endMask analog dengan `begin_mask`

StridedSlice.Options newAxisMask statis publik (Panjang newAxisMask)

Parameter
AxisMask baru bitmask di mana bit `i` menjadi 1 berarti spesifikasi `i`th menciptakan bentuk 1 dimensi baru. Misalnya `foo[:4, tf.newaxis, :2]` akan menghasilkan tensor bentuk `(4, 1, 2)`.

Keluaran publik <T> keluaran ()

StridedSlice.Options shrinkAxisMask statis publik (ShrinkAxisMask panjang)

Parameter
menyusutAxisMask bitmask di mana bit `i` menyiratkan bahwa spesifikasi `i`th harus mengecilkan dimensinya. awal dan akhir harus menyiratkan potongan berukuran 1 dalam dimensi. Misalnya dalam python seseorang mungkin melakukan `foo[:, 3, :]` yang akan menghasilkan `shrink_axis_mask` menjadi 2.