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

StridedSlice

classe final pública StridedSlice

Retorne uma fatia em strided de `input`.

Observe que a maioria dos usuários de python desejará usar o Python Tensor.__getitem__ ou Variable.__getitem__ em vez deste 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 esparsas `m` codificadas nos argumentos desta função. Observe que, em alguns casos, `m` pode ser igual a `n`, mas isso 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 indicar zero ou mais dimensões de seleção de 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 dimensão shape=1 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 menos 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 ser selecionado. 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 o `begin` fornecido explicitamente deve ser substituído 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 uma forma `(3,)` tensor `foo[:]`, os efetivos `begin` e `end` são `0` e `3`. Não assuma que isso é equivalente a `foo[0:-1]` que tem um `begin` e `end` efetivos de `0` e `2`. Outro exemplo é `foo[-2::-1]` que inverte a primeira dimensão de um tensor enquanto descarta 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 um tensor de forma `(5,6)` produz um tensor de forma `(6,)`. Isso é codificado em `begin` e `end` e `shrink_axis_mask`.

Cada especificação de intervalo conceitual é codificada no argumento do op. Essa codificação é melhor compreendida considerando um exemplo não trivial. Em particular, `foo[1, 2:4, None, ..., :-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 se torna (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 desambiguar da especificação original `2:4`, também configuramos o bit apropriado em `shrink_axis_mask`.

2. `2:4` contribui com 2, 4, 1 para começar, terminar e andar. Todas as máscaras têm zero bits contribuídos.

3. Nenhum é sinônimo de tf.newaxis . Isso significa inserir uma dimensão de tamanho 1 na forma final. Valores fictícios são contribuídos para começar, terminar e avançar, enquanto o bit new_axis_mask é definido.

4. `...` pegue os intervalos completos de quantas dimensões 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`. Então `-1` se torna `s-1` (ou seja, o último elemento). Esta conversão é feita internamente, então início, fim e passos 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`. begin, end e strides 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 reticência)`

Classes aninhadas

classe StridedSlice.Options Atributos opcionais para StridedSlice

Métodos públicos

Saída <T>
comoSaída ()
Retorna o identificador simbólico de um tensor.
static StridedSlice.Options
beginMask (Long beginMask)
estático <T, U estende Número> StridedSlice <T>
create ( Escopo do escopo, Entrada do Operando <T>, Início do Operando <U>, Fim do Operando <U>, Passos do Operando <U>, Opções... opções)
Método de fábrica para criar uma classe envolvendo uma nova operação StridedSlice.
static StridedSlice.Options
ellipsisMask (Long ellipsisMask)
static StridedSlice.Options
endMask (Long endMask)
static StridedSlice.Options
newAxisMask (Long 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 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
começarMáscara 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. Em tempo de execução, begin[i] será substituído por `[0, n-1)` se `stride[i] > 0` ou `[-1, n-1]` se `stride[i] < 0`

public static StridedSlice <T> create ( Escopo do escopo, Operando <T> entrada, Operando <U> início, Operando <U> final, Operando <U> passos, Opções... 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 de intervalo `k`th. A dimensão exata a que isso corresponde será determinada pelo contexto. Os valores fora dos limites serão bloqueados silenciosamente. Se o `k`ésimo bit de `begin_mask`, então `begin[k]` é ignorado e o intervalo completo da dimensão apropriada é usado. Valores negativos fazem com que a indexação comece 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`th especificação após extrair um determinado elemento. Índices negativos reverterão a ordem original. Os valores de fora ou intervalo são fixados em `[0,dim[i]) se slice[i]>0` ou `[-1,dim[i]-1] se slice[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
máscara de reticências uma máscara de bits onde o bit `i` sendo 1 significa que a `i`ésima posição é na verdade uma reticência. Um bit no máximo pode ser 1. Se `ellipsis_mask == 0`, 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 de 4 dimensões `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 onde o bit `i` sendo 1 significa que a especificação `i`th cria uma nova dimensão de forma 1. Por exemplo, `foo[:4, tf.newaxis, :2]` produziria um tensor de forma `(4, 1, 2)`.

saída pública <T> saída ()

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