Partilhar via

Parâmetros e constantes

  • Artigo

ParameterTensor{}

Cria um escalar, vetor, matriz ou tensor de parâmetros aprendíveis.

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 dadas como 0 são automaticamente inferidas (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 distribuição à esquerda. Se negativo, -number de eixos de fan-out à direita (veja aqui)
  • initValueScale (padrão 1): fator de escala adicional aplicado a valores de inicialização aleatórios
  • randomSeed (-1padrão): se positivo, use esta semente aleatória para inicialização aleatória. Se 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 aprendizagem do sistema será dimensionada por este (0 para desativar a aprendizagem) (veja aqui)

Valor de retorno

Um tensor de parâmetros aprendíveis.

Descrição

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

Os valores serão inicializados, dependendo do parâmetro opcional fornecido, para

  • números aleatórios, se init for dado;
  • uma constante se initValue for dado; quer
  • um tensor lido de um arquivo de entrada externo, se initFromFilePath for dado. 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 M elementos;
  • (1:N) para um vetor de linha com elementos N. Os vetores de linha são matrizes de uma linha;
  • (M:N) para uma matriz com N linhas e I colunas;
  • (I:J:K...) para um tensor de classificação arbitrária>2 (nota: a classificação máxima permitida é 12); e ainda
  • (W:H:C) para um tensor que corresponde às dimensões de uma imagem [W x H] com C canais.

Inferência automática de dimensões

Quando um ParameterTensor é usado para pesos como entrada imediata de operações específicas, é permitido especificar algumas dimensões como Inferred. Por exemplo, o produto da matriz ParameterTensor{42:Inferred} * x) irá automaticamente inferir a segunda dimensão como sendo igual à dimensão de x.

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 precisas de entrada de uma camada, por exemplo, para a primeira camada totalmente conectada no topo de uma pirâmide de combinações de convolução/agrupamento sem preenchimento, onde cada operação de convolução e agrupamento pode soltar linhas ou colunas de pixels de limite e escala as dimensões.

Este recurso é o que permite que as camadas predefinidas da CNTK sejam especificadas apenas por sua 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, onde o intervalo/desvio padrão é calculado em função de fan-in e fan-out:

valor da 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
'Gaussiano' normal sqrt (0.04 / fanIn)
'zero' n/a 0

(Onde zero é uma alternativa às vezes conveniente para especificar initValue=0.) Para uma distribuição uniforme, os parâmetros serão inicializados uniformemente em [-range, range]; para a 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 matricial-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 fan-in, combinando semântica do produto de matriz regular.

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

Valores negativos para initOutputRank indicam que os eixos de fan-out 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], onde K é o fan-out, enquanto o fan-in é W*H*C. Isso é especificado por initOutputRank=-1.

Leitura de valores iniciais de arquivos

Os valores iniciais podem ser lidos a partir 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 a shape.

Taxa de aprendizagem específica do parâmetro

As taxas de aprendizagem específicas de parâmetros podem ser realizadas com o parâmetro learningRateMultiplier opcional. Este fator é multiplicado com a taxa de aprendizagem real ao realizar atualizações de parâmetros. Por exemplo, se especificado como 0, o parâmetro não será atualizado, é 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 incorporaçã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 numChannels planos de cores:

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

{} constante

Crie um tensor constante.

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

Parâmetros

  • scalarValue: valor desta 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 de retorno

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

Descrição

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

Nota de execução:

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

Exemplos

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

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

Perda de Hamming (cf. aqui):

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