Retorne uma fatia strided de `entrada`.
Note, a maioria dos usuários de Python vai querer usar o Python `Tensor .__ getitem__` ou` Variable .__ getitem__` ao invés desta op diretamente.
O objetivo desta operação é produzir um novo tensor com um subconjunto dos elementos do tensor `n` dimensional` input`. O subconjunto é escolhido usando uma sequência de especificações de intervalo esparso `m` codificadas nos argumentos desta função. Observe, em alguns casos, `m` pode ser igual a` n`, mas não precisa ser o caso. Cada entrada de especificação de intervalo pode ser uma das seguintes:
- Uma reticência (...). As elipses são usadas para implicar zero ou mais dimensões da seleção em dimensão total e são produzidas usando `ellipsis_mask`. Por exemplo, `foo [...]` é a fatia de identidade.
- Um novo eixo. Isso é usado para inserir uma nova forma = 1 dimensão e é produzido usando `new_axis_mask`. Por exemplo, `foo [:, ...]` onde `foo` é a forma` (3, 4) `produz um tensor` (1, 3, 4) `.
- Um intervalo `begin: end: stride`. Isso é usado para especificar quanto escolher de uma determinada dimensão. `stride` pode ser qualquer número inteiro, mas 0.` begin` é um número inteiro que representa o índice do primeiro valor a ser selecionado, enquanto `end` representa o índice do último valor a selecionar. O número de valores selecionados em cada dimensão é `end - begin` se` stride> 0` e `begin - end` se` stride <0`. `begin` e` end` podem ser negativos, onde `-1` é o último elemento,` -2` é o penúltimo. `begin_mask` controla se deve substituir o` begin` explicitamente fornecido por um valor efetivo implícito de `0` se` stride> 0` e `-1` se` stride <0`. `end_mask` é análogo, mas produz o número necessário para criar o maior intervalo aberto. Por exemplo, dada a forma `(3,)` tensor `foo [:]`, o `begin` e` end` efetivos são `0` e` 3`. Não assuma que isso é equivalente a `foo [0: -1]` que tem um `início` e um` fim` efetivos de `0` e` 2`. Outro exemplo é `foo [-2 :: - 1]` que inverte a primeira dimensão de um tensor enquanto elimina as duas últimas (nos elementos de ordem original). Por exemplo `foo = [1,2,3,4]; foo [-2 :: - 1] `é` [4,3] `.
- Um único índice. Isso é usado para manter apenas os elementos que possuem um determinado índice. Por exemplo (`foo [2,:]` em uma forma `(5,6)` tensor produz uma forma `(6,)` tensor. Isso é codificado em `begin` e` end` e `shrink_axis_mask`.
Cada especificação de intervalo conceitual é codificada no argumento do op. Esta codificação é melhor compreendida considerando um exemplo não trivial. Em particular, `foo [1, 2: 4, Nenhum, ...,: -3: -1,:]` será codificado como
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
Neste caso, se `foo.shape` for (5, 5, 5, 5, 5, 5) a forma final da fatia torna-se (2, 1, 5, 5, 2, 5). Vamos percorrer passo a passo cada especificação de argumento.1. O primeiro argumento na fatia de exemplo é transformado em `begin = 1` e` end = begin + 1 = 2`. Para tirar a ambigüidade da especificação original `2: 4`, também definimos o bit apropriado em` shrink_axis_mask`.
2. `2: 4` contribui com 2, 4, 1 para começar, terminar e dar passos largos. Todas as máscaras têm zero bits contribuídos.
3. Nenhum é sinônimo de `tf.newaxis`. Isso significa inserir uma dimensão de dimensão 1 na forma final. Valores fictícios são contribuídos para início, fim e passo, enquanto o bit new_axis_mask é definido.
4. `...` pegue os intervalos completos de tantas dimensões quantas forem necessárias para especificar totalmente uma fatia para cada dimensão da forma de entrada.
5. `: -3: -1` mostra o uso de índices negativos. Um índice negativo `i` associado a uma dimensão que tem a forma` s` é convertido em um índice positivo `s + i`. Portanto, `-1` torna-se` s-1` (ou seja, o último elemento). Essa conversão é feita internamente, portanto, o início, o fim e as passadas recebem x, -3 e -1. O bit begin_mask apropriado é definido para indicar que o intervalo inicial é o intervalo completo (ignorando o x).
6. `:` indica que todo o conteúdo da dimensão correspondente está selecionado. Isso é equivalente a `::` ou `0 :: 1`. início, fim e passos recebem 0, 0 e 1, respectivamente. Os bits apropriados em `begin_mask` e` end_mask` também são definidos.
Requisitos : `0! = Strides [i] para i em [0, m)` `ellipsis_mask deve ser uma potência de dois (apenas uma elipse)`
Classes aninhadas
aula | StridedSlice.Options | Atributos opcionais para StridedSlice |
Métodos Públicos
Saída <T> | asOutput () Retorna o identificador simbólico de um tensor. |
static StridedSlice.Options | beginMask (Long beginMask) |
static <T, U extends Number> StridedSlice <T> | |
static StridedSlice.Options | ellipsisMask ( ellipsisMask longa) |
static StridedSlice.Options | endMask (Long endMask) |
static StridedSlice.Options | newAxisMask (longo newAxisMask) |
Saída <T> | saída () |
static StridedSlice.Options | shrinkAxisMask (Long shrinkAxisMask) |
Métodos herdados
Métodos Públicos
public Output <T> asOutput ()
Retorna o identificador simbólico de um tensor.
As entradas para as operações do TensorFlow são saídas de outra operação do TensorFlow. Este método é usado para obter um identificador simbólico que representa o cálculo da entrada.
public static StridedSlice.Options beginMask (Long beginMask)
Parâmetros
beginMask | uma máscara de bits em que um bit i sendo 1 significa ignorar o valor inicial e, em vez disso, usar o maior intervalo possível. No início do tempo de execução [i] será substituído por `[0, n-1)` se `passo [i]> 0` ou` [-1, n-1] `se` passo [i] <0` |
---|
public static StridedSlice <T> create ( Scope escopo, Operando <T> entrada, Operando <U> começar, Operando <U> end, Operando <U> avanços, Options ... Opções)
Método de fábrica para criar uma classe envolvendo uma nova operação StridedSlice.
Parâmetros
alcance | escopo atual |
---|---|
começar | `begin [k]` especifica o deslocamento na especificação do intervalo `k`. A dimensão exata a que isso corresponde será determinada pelo contexto. Os valores fora dos limites serão silenciosamente fixados. Se o `k`ésimo bit de` begin_mask` então `begin [k]` é ignorado e toda a extensão da dimensão apropriada é usada em seu lugar. Valores negativos fazem com que a indexação comece a partir do elemento mais alto, por exemplo, se `foo == [1,2,3]` então `foo [-1] == 3`. |
fim | `end [i]` é como `begin` com a exceção de que` end_mask` é usado para determinar intervalos completos. |
passos largos | `strides [i]` especifica o incremento na `i`sima especificação após extrair um determinado elemento. Índices negativos inverterão a ordem original. Valores fora ou de intervalo são fixados em `[0, dim [i]) se fatia [i]> 0` ou` [-1, dim [i] -1] se fatia [i] <0` |
opções | carrega valores de atributos opcionais |
Devoluções
- uma nova instância de StridedSlice
public static StridedSlice.Options ellipsisMask (Long ellipsisMask)
Parâmetros
ellipsisMask | uma máscara de bits onde o bit `i` sendo 1 significa que a posição` i` é na verdade uma reticência. Um bit no máximo pode ser 1. Se `ellipsis_mask == 0`, então uma máscara de reticências implícita de` 1 << (m + 1) `é fornecida. Isso significa que `foo [3: 5] == foo [3: 5, ...]`. Uma reticência cria implicitamente quantas especificações de intervalo forem necessárias para especificar totalmente o intervalo fatiado para cada dimensão. Por exemplo, para um tensor 4-dimensional `foo` a fatia` foo [2, ..., 5: 8] `implica` foo [2,:,:, 5: 8] `. |
---|
public static StridedSlice.Options newAxisMask (Long newAxisMask)
Parâmetros
newAxisMask | uma máscara de bits em que o bit `i` sendo 1 significa que a` i`sima especificação cria uma nova dimensão da forma 1. Por exemplo, `foo [: 4, tf.newaxis,: 2]` produziria um tensor de forma `(4, 1, 2)`. |
---|
public static StridedSlice.Options shrinkAxisMask (Long shrinkAxisMask)
Parâmetros
shrinkAxisMask | uma máscara de bits onde o bit `i` implica que a especificação` i` deve reduzir a dimensionalidade. begin e end devem implicar uma fatia de tamanho 1 na dimensão. Por exemplo, em python, pode-se fazer `foo [:, 3,:]` que resultaria em `shrink_axis_mask` sendo 2. |
---|