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