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