Renvoie une tranche striée depuis `input`.
Notez que la plupart des utilisateurs de Python souhaiteront utiliser Python Tensor.__getitem__ ou Variable.__getitem__ plutôt que cette opération directement.
Le but de cette opération est de produire un nouveau tenseur avec un sous-ensemble d'éléments du tenseur « d'entrée » à « n » dimensions. Le sous-ensemble est choisi à l'aide d'une séquence de spécifications de plage clairsemée `m` codées dans les arguments de cette fonction. Notez que dans certains cas, « m » peut être égal à « n », mais ce n'est pas nécessairement le cas. Chaque entrée de spécification de plage peut être l'une des suivantes :
- Des points de suspension (...). Les ellipses sont utilisées pour impliquer zéro ou plusieurs dimensions de sélection pleine dimension et sont produites à l'aide de `ellipsis_mask`. Par exemple, `foo[...]` est la tranche d'identité.
- Un nouvel axe. Ceci est utilisé pour insérer une nouvelle dimension shape=1 et est produit en utilisant `new_axis_mask`. Par exemple, `foo[:, ...]` où `foo` est la forme `(3, 4)` produit un tenseur `(1, 3, 4)`.
- Une plage `begin:end:stride`. Ceci est utilisé pour spécifier combien choisir dans une dimension donnée. `stride` peut être n'importe quel entier sauf 0. `begin` est un entier qui représente l'index de la première valeur à sélectionner tandis que `end` représente l'index de la dernière valeur à sélectionner. Le nombre de valeurs sélectionnées dans chaque dimension est « fin - début » si « foulée > 0 » et « début - fin » si « foulée < 0 ». `begin` et `end` peuvent être négatifs où `-1` est le dernier élément, `-2` est l'avant-dernier. `begin_mask` contrôle s'il faut remplacer le `begin` explicitement donné par une valeur effective implicite de `0` si `stride > 0` et `-1` si `stride < 0`. `end_mask` est analogue mais produit le nombre requis pour créer le plus grand intervalle ouvert. Par exemple, étant donné un tenseur de forme `(3,)` `foo[:]`, les `begin` et `end` effectifs sont `0` et `3`. Ne présumez pas que cela équivaut à « foo[0:-1] » qui a un « début » et une « fin » effectifs de « 0 » et « 2 ». Un autre exemple est `foo[-2::-1]` qui inverse la première dimension d'un tenseur tout en supprimant les deux dernières (dans l'ordre d'origine des éléments). Par exemple `foo = [1,2,3,4] ; foo[-2::-1]` est `[4,3]`.
- Un seul index. Ceci est utilisé pour conserver uniquement les éléments qui ont un index donné. Par exemple (`foo[2, :]` sur un tenseur de forme `(5,6)` produit un tenseur de forme `(6,)`. Ceci est codé dans `begin` et `end` et `shrink_axis_mask`.
Chaque spécification de plage conceptuelle est codée dans l'argument de l'opération. Ce codage est mieux compris en considérant un exemple non trivial. En particulier, `foo[1, 2:4, None, ..., :-3:-1, :]` sera codé comme
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<<4 | 1<<5 = 48
end_mask = 1<<5 = 32
ellipsis_mask = 1<<3 = 8
new_axis_mask = 1<<2 = 4
shrink_axis_mask = 1<<0 = 1
1. Le premier argument de l'exemple de tranche est transformé en `begin = 1` et `end = start + 1 = 2`. Pour lever l'ambiguïté de la spécification originale « 2:4 », nous définissons également le bit approprié dans « shrink_axis_mask ».
2. « 2 : 4 » contribue 2, 4, 1 au début, à la fin et à la foulée. Tous les masques n'ont aucun bit contribué.
3. Aucun n'est synonyme de tf.newaxis . Cela signifie insérer une dimension de taille 1 dans la forme finale. Des valeurs factices sont ajoutées au début, à la fin et à la foulée, tandis que le bit new_axis_mask est défini.
4. `...` récupérez les plages complètes d'autant de dimensions que nécessaire pour spécifier complètement une tranche pour chaque dimension de la forme d'entrée.
5. `:-3:-1` montre l'utilisation d'indices négatifs. Un index négatif « i » associé à une dimension qui a la forme « s » est converti en un index positif « s + i ». Ainsi `-1` devient `s-1` (c'est-à-dire le dernier élément). Cette conversion est effectuée en interne, donc le début, la fin et les foulées reçoivent x, -3 et -1. Le bit Begin_mask approprié est défini pour indiquer que la plage de début est la plage complète (en ignorant le x).
6. `:` indique que tout le contenu de la dimension correspondante est sélectionné. Ceci équivaut à `::` ou `0::1`. le début, la fin et les foulées reçoivent respectivement 0, 0 et 1. Les bits appropriés dans `begin_mask` et `end_mask` sont également définis.
Exigences : `0 != strides[i] for i in [0, m)` `ellipsis_mask doit être une puissance de deux (une seule points de suspension)`
Classes imbriquées
| classe | StridedSlice.Options | Attributs facultatifs pour StridedSlice | |
Méthodes publiques
| Sortie <T> | comme Sortie () Renvoie le handle symbolique d'un tenseur. |
| StridedSlice.Options statique | commencerMask (Long commencerMask) |
| statique <T, U étend le nombre> StridedSlice <T> | créer ( Portée de la portée , Entrée de l'opérande <T>, Début de l'opérande <U>, Fin de l'opérande <U>, Foulées de l'opérande <U>, Options... options) Méthode d'usine pour créer une classe encapsulant une nouvelle opération StridedSlice. |
| StridedSlice.Options statique | ellipsisMask (Masque ellipse long) |
| StridedSlice.Options statique | endMask (Masque de fin long) |
| StridedSlice.Options statique | newAxisMask (Long newAxisMask) |
| Sortie <T> | sortir () |
| StridedSlice.Options statique | ShrinkAxisMask (ShrinkAxisMask long) |
Méthodes héritées
Méthodes publiques
sortie publique <T> asOutput ()
Renvoie le handle symbolique d'un tenseur.
Les entrées des opérations TensorFlow sont les sorties d'une autre opération TensorFlow. Cette méthode est utilisée pour obtenir un handle symbolique qui représente le calcul de l’entrée.
public statique StridedSlice.OptionsbeginMask ( LongbeginMask)
Paramètres
| commencerMasque | un masque de bits où un bit i étant 1 signifie ignorer la valeur de début et utiliser à la place le plus grand intervalle possible. Au moment de l'exécution, start[i] sera remplacé par `[0, n-1)` si `stride[i] > 0` ou `[-1, n-1]` si `stride[i] < 0` |
|---|
public static StridedSlice <T> créer (portée de la portée , entrée de l'opérande <T>, début de l'opérande <U>, fin de l'opérande <U>, foulées de l'opérande <U>, options... options)
Méthode d'usine pour créer une classe encapsulant une nouvelle opération StridedSlice.
Paramètres
| portée | portée actuelle |
|---|---|
| commencer | `begin[k]` spécifie le décalage dans la `k`ème spécification de plage. La dimension exacte à laquelle cela correspond sera déterminée par le contexte. Les valeurs hors limites seront bloquées silencieusement. Si le `k`ième bit de `begin_mask` alors `begin[k]` est ignoré et la plage complète de la dimension appropriée est utilisée à la place. Les valeurs négatives font que l'indexation commence à partir de l'élément le plus élevé, par exemple si `foo==[1,2,3]` alors `foo[-1]==3`. |
| fin | `end[i]` est comme `begin` à l'exception du fait que `end_mask` est utilisé pour déterminer des plages complètes. |
| foulées | `strides[i]` spécifie l'incrément dans la `i`ième spécification après l'extraction d'un élément donné. Les indices négatifs inverseront l’ordre initial. Les valeurs hors ou plage sont limitées à `[0,dim[i]) si slice[i]>0` ou `[-1,dim[i]-1] si slice[i] < 0` |
| choix | porte des valeurs d'attributs facultatifs |
Retour
- une nouvelle instance de StridedSlice
public statique StridedSlice.Options ellipsisMask (ellipsisMask long)
Paramètres
| points de suspensionMasque | un masque de bits où le bit « i » étant 1 signifie que la « i » position est en fait des points de suspension. Un bit au maximum peut être 1. Si `ellipsis_mask == 0`, alors un masque de points de suspension implicite de `1 << (m+1)` est fourni. Cela signifie que `foo[3:5] == foo[3:5, ...]`. Les points de suspension créent implicitement autant de spécifications de plage que nécessaire pour spécifier entièrement la plage découpée pour chaque dimension. Par exemple, pour un tenseur à 4 dimensions `foo`, la tranche `foo[2, ..., 5:8]` implique `foo[2, :, :, 5:8]`. |
|---|
public statique StridedSlice.Options endMask (Long endMask)
Paramètres
| masque de fin | analogue à `begin_mask` |
|---|
public statique StridedSlice.Options newAxisMask (Long newAxisMask)
Paramètres
| nouveauAxisMask | un masque de bits où le bit « i » étant 1 signifie que la « i » spécification crée une nouvelle forme à 1 dimension. Par exemple `foo[:4, tf.newaxis, :2]` produirait un tenseur de forme `(4, 1, 2)`. |
|---|
public statique StridedSlice.Options ShrinkAxisMask (Long ShrinkAxisMask)
Paramètres
| rétrécirAxisMask | un masque de bits où le bit « i » implique que la « i » spécification doit réduire la dimensionnalité. Le début et la fin doivent impliquer une tranche de taille 1 dans la dimension. Par exemple, en python, on pourrait faire `foo[:, 3, :]` ce qui donnerait à `shrink_axis_mask` la valeur 2. |
|---|