StridedSlice

classe final pública StridedSlice

Retorna uma fatia escalonada de `input`.

Observe que a maioria dos usuários de python desejará usar Python Tensor.__getitem__ ou Variable.__getitem__ em vez desta operação 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 esse o caso. Cada entrada de especificação de intervalo pode ser uma das seguintes:

- Uma reticência (...). Elipses são usadas para implicar 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 em uma determinada dimensão. `stride` pode ser qualquer número inteiro, exceto 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 - start` 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` fornecido explicitamente 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, dado um tensor de forma `(3,)` `foo[:]`, os `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 `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 da 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 da operação. 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&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
 
Neste caso, se `foo.shape` for (5, 5, 5, 5, 5, 5) o formato final da fatia passa a ser (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 a 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 avançar. Todas as máscaras têm contribuição de zero bits.

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 início, fim e passada, 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 possui forma `s` é convertido em um índice positivo `s + i`. Então `-1` se torna `s-1` (ou seja, o último elemento). Essa conversão é feita internamente, então início, fim e passadas recebem x, -3 e -1. O bit start_mask apropriado é definido para indicar que o intervalo inicial é o intervalo completo (ignorando x).

6. `:` indica que todo o conteúdo da dimensão correspondente está selecionado. Isso é equivalente a `::` ou `0::1`. início, fim e passadas recebem 0, 0 e 1, respectivamente. Os bits apropriados em `begin_mask` e `end_mask` também são definidos.

Requisitos : `0!= passadas[i] para i em [0, m)` `máscara_reticências deve ser uma potência de dois (apenas uma reticências)`

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.
StridedSlice.Options estático
BeginMask (máscara de início longa)
estático <T, U estende número> StridedSlice <T>
criar (escopo do escopo , entrada do operando <T>, início do operando <U>, final do operando <U>, avanços do operando <U>, opções... opções)
Método de fábrica para criar uma classe que envolve uma nova operação StridedSlice.
StridedSlice.Options estático
ellipsisMask (máscara de reticências longas)
StridedSlice.Options estático
endMask (máscara final longa)
StridedSlice.Options estático
newAxisMask (longo newAxisMask)
Saída <T>
saída ()
StridedSlice.Options estático
ShrinkAxisMask (Long ShrinkAxisMask)

Métodos herdados

Métodos Públicos

Saída pública <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.

público estático StridedSlice.Options BeginMask (Long BeginMask)

Parâmetros
máscara de início uma máscara de bits onde 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, start[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 , entrada do operando <T>, início do operando <U>, fim do operando <U>, avanços do operando <U>, opções... opções)

Método de fábrica para criar uma classe que envolve uma nova operação StridedSlice.

Parâmetros
escopo escopo atual
começar `begin[k]` especifica o deslocamento na especificação de intervalo `k`. A dimensão exata a que isto corresponde será determinada pelo contexto. Valores fora dos limites serão fixados silenciosamente. Se o `k`ésimo bit de `begin_mask` então `begin[k]` será ignorado e todo o intervalo da dimensão apropriada será usado em seu lugar. Valores negativos fazem com que a indexação comece no 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.
avanços `strides[i]` especifica o incremento na `i`ésima especificação após extrair um determinado elemento. Os índices negativos reverterão a ordem original. Os valores out ou range 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

público estático 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. No máximo um bit 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 completamente o intervalo fatiado para cada dimensão. Por exemplo, para um tensor quadridimensional `foo` a fatia `foo[2, ..., 5:8]` implica `foo[2, :, :, 5:8]`.

público estático StridedSlice.Options endMask (Long endMask)

Parâmetros
máscara final análogo a `begin_mask`

público estático StridedSlice.Options newAxisMask (longo newAxisMask)

Parâmetros
novaAxisMask uma máscara de bits onde o bit `i` sendo 1 significa que a `i`-ésima especificação 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 ()

público estático StridedSlice.Options ShridedAxisMask (Long ShridedAxisMask)

Parâmetros
encolherAxisMask uma máscara de bits onde o bit `i` implica que a `i`-ésima especificação deve diminuir a dimensionalidade. início e fim 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.