Aviso: esta API está obsoleta e será removida em uma versão futura do TensorFlow depois que a substituição estiver estável.

StridedSlice

public final class StridedSlice

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 que 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 `início` e o` fim` 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 o início, o fim e o passo. 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>
criar ( 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.
static StridedSlice.Options
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 de fora ou 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 endMask (Long endMask)

Parâmetros
endMask análogo a `begin_mask`

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)`.

output public Output <T> output ()

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 em 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.