Compartilhar via

Parâmetros e constantes

  • Artigo

{} ParameterTensor

Cria um escalar, vetor, matriz ou tensor de parâmetros aprendizes.

ParameterTensor {shape,
                 init='uniform'/*|heNormal|...*/, initOutputRank=1, initValueScale=1.0,
                 randomSeed=-1,
                 initValue=0.0, initFromFilePath='',
                 learningRateMultiplier=1.0}

Parâmetros

  • shape: forma (dimensões) do parâmetro como uma matriz. Por exemplo, (13:42) criar uma matriz com 13 linhas e 42 colunas. Para algumas operações, as dimensões fornecidas como 0 são inferidas automaticamente (veja aqui)
  • init (padrão 'uniforme'): especifica a inicialização aleatória, por exemplo, init='heNormal'(veja aqui)
  • initOutputRank (padrão 1): especifica o número de eixos de saída de ventilador à esquerda. Se negativo, -number de eixos à direita (veja aqui)
  • initValueScale (padrão 1): fator de dimensionamento adicional aplicado a valores aleatórios de inicialização
  • randomSeed (padrão -1): se positivo, use essa semente aleatória para inicialização aleatória. Se for negativo, use um contador que seja aumentado para cada ParameterTensor{}
  • initValue: especifica a inicialização com um valor constante, por exemplo, initValue=0
  • initFromFilePath: especifica a inicialização carregando valores iniciais de um arquivo. Por exemplo, initFromFilePath="my_init_vals.txt"
  • learningRateMultiplier: a taxa de aprendizado do sistema será dimensionada por este (0 para desabilitar o aprendizado) (veja aqui)

Valor retornado

Um tensor de parâmetros aprendizes.

Descrição

Essa função de fábrica cria um escalar, vetor, matriz ou tensor de parâmetros aprendizes, ou seja, um tensor reconhecido pela ação "train" como contendo parâmetros que devem ser atualizados durante o treinamento.

Os valores serão inicializados, dependendo de qual parâmetro opcional é fornecido, para

  • números aleatórios, se init for fornecida;
  • uma constante se initValue for fornecida; ou
  • uma leitura tensor de um arquivo de entrada externo se initFromFilePath for fornecida. O padrão é init="uniform".

Para criar um escalar, vetor, matriz ou tensor com classificação>2, passe o seguinte como o parâmetro shape:

  • (1) para um escalar;
  • (M) para um vetor de coluna com elementos M;
  • (1:N) para um vetor de linha com elementos N. Vetores de linha são matrizes de uma linha;
  • (M:N) para uma matriz com linhas N e colunas I;
  • (I:J:K...) para um tensor de classificação arbitrária>2 (observação: a classificação máxima permitida é 12); e
  • (W:H:C) para um tensor que corresponde às dimensões de uma imagem [W x H] com canais de C.

Inferência automática de dimensão

Quando um ParameterTensor é usado para pesos como uma entrada imediata de operações específicas, é permitido especificar algumas dimensões como Inferred. Por exemplo, a do produto de matriz inferirá automaticamente a segunda dimensão como igual à dimensão de .

Isso é extremamente útil para entradas de camadas, pois libera o código BrainScript do usuário da carga de passar as dimensões de entrada. Além disso, em algumas situações, é muito complicado determinar as dimensões de entrada precisas de uma camada, por exemplo, para a primeira camada totalmente conectada sobre uma pirâmide de combinações de convolução/pooling sem preenchimento, em que cada operação de convolução e pooling pode soltar linhas ou colunas de pixels de limite e os passos dimensionam as dimensões.

Esse recurso é o que permite que as camadas predefinidas do CNTK sejam especificadas apenas pela dimensão de saída (por exemplo, DenseLayer{1024}).

Inicialização aleatória

A inicialização aleatória é selecionada pelo parâmetro init, que escolhe entre distribuição uniforme e normal, em que o desvio de intervalo/padrão é computado como uma função de fan-in e fan-out:

valor de init distribuição intervalo/desvio padrão
'heNormal' normal sqrt (2/fanIn)
'heUniform' uniforme sqrt (6/fanIn)
'glorotNormal' normal sqrt (2 / (fanIn+fanOut))
'glorotUniform' uniforme sqrt (6 / (fanIn+fanOut))
'xavier' uniforme sqrt (3/fanIn)
'uniforme' uniforme 1/20
'gaussian' normal sqrt (0.04 /fanIn)
'zero' n/a 0

(Onde zero é uma alternativa às vezes conveniente para especificar initValue=0.) Para distribuição uniforme, os parâmetros serão inicializados uniformemente em [-intervalo, intervalo]; para distribuição normal, a média é sempre zero.

Observe que o padrão para init é uniform ao usar ParameterTensor{} diretamente. No entanto, o padrão é glorotUniform para camadas que contêm parâmetros dentro, como DenseLayer{} e ConvolutionalLayer{}.

Fan-in e fan-out para inicialização aleatória

A inicialização aleatória pressupõe que os parâmetros fazem parte de alguma forma de operação de matriz-produto, que tem um fan-in e fan-out bem definidos, que são usados para determinar o dimensionamento dos valores aleatórios por tabela acima. Por padrão, o primeiro eixo é considerado fan-out e os eixos/eixos restantes são semânticos correspondentes do produto de matriz regular.

O parâmetro opcional initOutputRank pode ser usado para especificar o número de eixos à esquerda que devem ser considerados fan-out. Por exemplo, para um produto de matriz no de interpretação estendida do tensor do CNTK que mapeia um vetor [K]-dimensional x para um objeto de classificação 2 [I x J]dimensional pode ser escrito como Times (W, x, outputRank=2), em que W tem a forma [I x J x K]. Aqui, initOutputRank=2 especifica que, ao dimensionar os valores de inicialização aleatória, o fan-out é I*J e o fan-in K.

Valores negativos para initOutputRank indicam que os eixos de saída são eixos à direita. Por exemplo, o kernel de filtro do ConvolutionalLayer{} e a operação de Convolution() subjacente para uma configuração típica de processamento de imagem tem uma forma [W x H x C x K], em que K é o fan-out, enquanto o fan-in é W*H*C. Isso é especificado por initOutputRank=-1.

Lendo valores iniciais de arquivos

Os valores iniciais podem ser lidos de um arquivo de texto. Para fazer isso, passe um nome de caminho para o parâmetro opcional initFromFilePath. Espera-se que o arquivo de texto consista em uma linha por linhas de matriz, que consistem em números separados por espaço, um por coluna. As dimensões de linha e coluna no arquivo devem corresponder shape.

Taxa de aprendizagem específica do parâmetro

As taxas de aprendizagem específicas do parâmetro podem ser realizadas com o parâmetro learningRateMultiplier opcional. Esse fator é multiplicado com a taxa de aprendizado real ao executar atualizações de parâmetro. Por exemplo, se especificado como 0, o parâmetro não será atualizado, ele é constante.

Exemplos

Uma matriz de parâmetros regular que será inicializada como heUniform (o padrão seria heNormal):

W = ParameterTensor {(outDim:inDim), init=`heUniform`}

Um parâmetro de viés regular que será inicializado como zero:

b = ParameterTensor {outDim, initValue=0}

Uma matriz de inserção que deve ser lida de um arquivo e mantida constante:

E = ParameterTensor {(embedDim:vocabSize),
                     initFromFilePath='./EmbeddingMatrix.txt',
                     learningRateMultiplier=0}  # prevents learning

Um parâmetro de viés do tamanho total de uma imagem de tamanho [width x height]com planos de cor numChannels:

bFull = ParameterTensor {(width:height:numChannels)}

{} constante

Crie um tensor constante.

Constant {scalarValue, rows=1, cols=1}

Parâmetros

  • scalarValue: valor dessa constante
  • rows (padrão: 1): número de linhas, se constante não for escalar
  • cols (padrão: 1): número de cols, se constante não for escalar

Valor retornado

Uma constante, um objeto escalar ou um objeto rank-1 ou rank-2 de dimensão [rows x cols], em que todos os elementos são preenchidos com scalarValue.

Descrição

Um valor constante. Pode ser um objeto escalar ou um objeto rank-1 (vector) ou um objeto rank-2 (matriz) inicializado com um único valor (como 0). Observe que, como para constantes vetoriais e matrizes todos os valores são idênticos, as constantes usadas em conjunto com operações em termos de elementos geralmente podem ser especificadas como escalares, aproveitando de difusão.

Observação de implementação:

Um Constant() é um ParameterTensor{} com learningRateMultiplier=0.

Exemplos

Interpolação entre dois valores com peso de interpolação alpha no intervalo 0..1 ("multiplexer suave"):

SoftMUX (x, y, alpha) = Constant (1-alpha) .* x + Constant (alpha) .* y

Perda de rede (cf. aqui):

HammingLoss (y, p) = ReduceSum (BS.Boolean.Xor (y, Greater (p, Constant(0.5))))
hl = HammingLoss (multiLabels, probabilities)