Partilhar via

CNTK v2.2 Notas de lançamento

Mudança de rutura

  • Esta iteração requer cuDNN 6.0 para suportar convolução dilatada e agrupamento determinístico. Por favor, atualize o seu cuDNN.
  • Esta iteração requer openCV para suportar a funcionalidade de imagem TensorBoard. Por favor, instale o OpenCV antes de instalar CNTK.

Documentação

Adicione versão HTML de tutoriais e manuais para que possam ser pesjáveis

Adicionámos versões HTML dos tutoriais e manuais com a documentação Python. Isto torna os cadernos e manuais tutoriais pesjáveis também.

Documentos de avaliação atualizados

Foram atualizados documentos relacionados com a avaliação modelo. Por favor, verifique os documentos mais recentes aqui.

Sistema

Suporte de 16bits para a formação em Volta GPU (funcionalidade limitada)

Este trabalho é lançado para o próximo lançamento devido à dependência das atualizações das infraestruturas de teste.

Apoio ao NCCL 2

Agora o NCCL pode ser usado através de máquinas. O utilizador precisa de ativar o NCCL na configuração de construção como aqui. Nota:

  • Depois de instalado o pacote NCCL 2 descarregado, existem dois pacotes:
/var/nccl-repo-2.0.4-ga/libnccl2_2.0.4-1+cuda8.0_amd64.deb
/var/nccl-repo-2.0.4-ga/libnccl-dev_2.0.4-1+cuda8.0_amd64.deb.

Instale ambos para a construção CNTK com o NCCL 2.

  • Devido a problemas na configuração do sistema, o utilizador pode encontrar falhas durante a inicialização do NCCL. Para obter informações detalhadas sobre a falha, por favor, desaprote a variável ambiente NCCL_DEBUG=INFO.
  • Existem problemas conhecidos na versão atual do NCCL 2 no sistema configurado com dispositivos InfiniBand em modos IB e IPoIB mistos. Para utilizar apenas dispositivos do modo IB, por favor, defina a variável NCCL_IB_HCA=devices ambiente em execução no modo IB, por exemplo:
export NCCL_IB_HCA=mlx5_0,mlx5_2

CNTK atualização da interface do aprendiz

Esta atualização simplifica as APIs do aprendiz e deprecia os conceitos de unitType.minibatch e UnitType.sample. O objetivo é tornar a API intuitiva para especificar os hiper-parâmetros do aluno, preservando ao mesmo tempo as técnicas únicas de atualização modelo em CNTK --- os gradientes médios de cada amostra de N contribui aproximadamente o mesmo para as atualizações modelo, independentemente dos tamanhos reais do minibatch de dados. Uma explicação detalhada pode ser encontrada no manual sobre como usar CNTK Aprendizes.

Na nova API, todos os alunos apoiados, incluindo AdaDelta, AdaGrad, FSAdaGrad, Adam, MomentumSGD, Nesterov, RMSProp e SGD, podem agora ser especificados por

cntk.<cntk_supporting_learner>(parameters=model.parametes,
    lr=<float or list>,
    [momentum=<float or list>], [variance_momentum=<float or list>],
    minibatch_size=<None, int, or cntk.learners.IGNORE>,
    ...other learner parameters)

Há duas grandes mudanças:

  • lr: o calendário de taxa de aprendizagem pode ser especificado como um flutuador, uma lista de boias ou uma lista de pares (flutuar, int) (ver definição de parâmetro em learning_parameter_schedule). A mesma especificação aplica-se ao impulso e variance_moment dos alunos, FSAdaGrad, Adam, MomentumSGD, Nesterov, onde tais hipermetrões são necessários.

  • minibatch_size: pode especificar-se um minibatch_size para garantir que o gradiente médio de cada amostra de N (minibatch_size=N) contribua para as atualizações modelo com a mesma taxa de aprendizagem, mesmo que o tamanho real dos dados seja diferente de N. Isto é útil quando o tamanho da minibatch de dados varia, especialmente em cenários de treino com sequências de comprimento variável, e/ou partição de dados irregulares no treino distribuído.

    • Se definirmosminibatch_size=cntk.learners.IGNORE, então recuperamos o comportamento na literatura: O gradiente médio de todo o minibatch contribui para a atualização modelo com a mesma taxa de aprendizagem. O comportamento de ignorar o tamanho dos dados minibatch de dados é o mesmo que especificar um tamanho de minibatch para o aluno quando o tamanho da minibatch de dados é igual ao tamanho de minibatch especificado.

Com a nova API:

  • Para ter modelo atualizações da mesma forma que na literatura clássica de deep learning, podemos especificar o aluno definindo minibatch_size=cntk.learners.IGNORE para ignorar o tamanho da minibatch, por exemplo.
sgd_learner_m = C.sgd(z.parameters, lr = 0.5, minibatch_size = C.learners.IGNORE)

nota

  • Para permitir CNTK técnicas específicas que apliquem a mesma taxa de aprendizagem ao gradiente médio de cada amostra de N, independentemente dos tamanhos reais das minibatchs, podemos especificar o aluno definindominibatch_size=N, por exemplo, a definiçãominibatch_size=2,
sgd_learner_s2 = C.sgd(z.parameters, lr = 0.5, minibatch_size = 2)

No que diz respeito à momentum_schedule dos alunos FSAdaGrad, Adam, MomentumSGD e Nesterov, pode ser especificado de forma semelhante. Vamos usar momentum_sgd como exemplo:

momentum_sgd(parameters, lr=float or list of floats, momentum=float or list of floats,
             minibatch_size=C.learners.IGNORE, epoch_size=epoch_size)
momentum_sgd(parameters, lr=float or list of floats, momentum=float or list of floats,
             minibatch_size=N, epoch_size=epoch_size)

Similares, learning_rate_scheduleos argumentos são interpretados da mesma forma:

  • Com minibatch_size=C.learners.IGNORE, a decadência momentum=beta é aplicada ao gradiente médio de toda a minibatch, independentemente do seu tamanho. Por exemplo, independentemente do tamanho da minibatch seja N ou 2N (ou qualquer tamanho), o gradiente médio de tal minibatch terá o mesmo fator de decadência beta.

  • Com minibatch_size=N, a decadência momentum=beta é aplicada ao gradiente médio de cada amostra N. Por exemplo, os minibatches dos tamanhos N, 2N, 3N e kN terão decomposição de beta, pow(beta, 2), pow(beta, 3) e pow(beta, k) respectivamente --- a decadência é exponencial na proporção do tamanho real da minibatch para o tamanho de minibatch especificado.

Uma API C#/.NET que permite que as pessoas construam e treinem redes.

O apoio à formação é adicionado à API C#/.NET.

Com esta adição à CNTK API de avaliação de avaliação C# existente, os desenvolvedores .NET podem desfrutar plenamente de uma experiência de deep learning integrada. Uma rede neural profunda pode ser construída, treinada e validada totalmente em C# enquanto ainda aproveita CNTK força de desempenho. Os utilizadores podem depurar diretamente para CNTK código fonte para ver como um DNN é treinado e avaliado. As novas funcionalidades incluem:

API de Formação Básica C.

Mais de 100 funções básicas são suportadas para construir uma rede de cálculo. Estas funções incluem Sigmoid, Tanh, ReLU, Plus, Minus, Convolution, Pooling, BatchNormalization, para citar alguns.

Como exemplo, para construir uma função de perda de regressão logística:

Function z = CNTKLib.Times(weightParam, input) + biasParam;
Function loss = CNTKLib.CrossEntropyWithSoftmax(z, labelVariable);
CNTK função como um elemento primitivo para construir um DNN

Um DNN é construído através da composição básica da operação. Por exemplo, para construir um nó ResNet:

Function conv = CNTKLib.Pooling(CNTKLib.Convolution(convParam, input),
                                PoolingType.Average, poolingWindowShape);
Function resNetNode = CNTKLib.ReLU(CNTKLib.Plus(conv, input));
Suporte de loteamento

Fornecemos utilitários MinibatchSource e MinibacthData para ajudar a eficiente carga de dados e loting.

Apoio à Formação

Apoiamos muitos otimizadores de descida de gradiente stochastic geralmente vistos na literatura DNN: MomentumSGDLearner, AdamLearner, AdaGradLearner, etc. Por exemplo, treinar um modelo com um Adam Stochastic Optimizer:

var parameterLearners = new List<Learner>() { Learner.AdamLearner(classifierOutput.Parameters(),
                                                                  learningRate, momentum) };
var trainer = Trainer.CreateTrainer(classifierOutput, trainingLoss,
                                    prediction, parameterLearners);

Os exemplos de formação abrangem uma ampla gama de casos de utilização de DNN:

R-binding para CNTK

A r-binding para CNTK, que permite tanto a formação como a avaliação, será publicada num repositório separado muito em breve.

Exemplos

Deteção de Objetos com R-CNN rápida e R-CNN mais rápido

Novos exemplos de Eval C++

Adicionámos novos exemplos CNTKLibraryCPPEvalCPUOnlyExamples C++ e CNTKLibraryCPPEvalGPUExamples. Ilustram como utilizar a Biblioteca de CNTK C++ para avaliação modelo cpu e GPU. Outro exemplo novo é o UWPImageRecognition, que é um exemplo que usa CNTK biblioteca UWP para avaliação modelo.

Novos exemplos C# Eval

Acrescentámos um exemplo para uma avaliação assíncronea: EvaluationSingleImageAsync(). Uma coisa que devemos salientar é CNTK API C# não tem um método assíncrono para avaliar(), porque a avaliação é uma operação ligada ao CPU (por favor, consulte este artigo para uma explicação detalhada). No entanto, é desejado fazer uma avaliação assíncrona em alguns casos de utilização, por exemplo, descarregamento para capacidade de resposta, mostramos no exemplo EvaluationSingleImageAsync() como fazê-lo utilizando o método EvaluateAsync()de extensão . Consulte a secção Executar a avaliação assíncrona na página Usando a API gerida C#/.NET para obter mais detalhes.

Operações

Nó de estimativa contrastiva de ruído

Isto fornece uma função de perda eficiente (mas aproximada) incorporada usada para treinar redes quando o número de classes é muito grande. Por exemplo, podes usá-lo quando quiseres prever a próxima palavra de um vocabulário de dezenas ou centenas de milhares de palavras.

Para usá-la defina a sua perda como:

loss = nce_loss(weights, biases, inputs, labels, noise_distribution)

e uma vez que você termina o treino você pode fazer previsões como esta

logits = C.times(weights, C.reshape(inputs, (1,), 1)) + biases

Note-se que a perda de estimativa contrastiva do ruído não pode ajudar na redução dos custos de inferência; as economias de custos são apenas durante o treino.

Melhor Modelo de atenção

Um bug na nossa camada DeModel attention foi corrigido e agora implementamos fielmente o papel

Tradução da máquina neural por Aprendizagem para alinhar e traduzir (Bahdanau et. al.)

Além disso, os argumentos attention_span e attention_axis o Modelo de Atenção foram deprecados. Devem ser deixados aos seus valores predefinidos, caso em que a atenção é calculada ao longo de toda a sequência e a saída é uma sequência de vetores da mesma dimensão que o primeiro argumento sobre o eixo do segundo argumento. Isto também leva a ganhos de velocidade substanciais (o nosso tutorial de CNTK 204 agora corre mais de 2x mais rápido).

Agregação no gradiente escasso para camada incorporada

Esta alteração poupa a conversão dispendiosa de escasso para denso antes da agregação gradiente ao incorporar o tamanho do vocabulário é enorme. Atualmente está habilitado para a construção de GPU quando treina em GPU com dados não quantificizados paralelos SGD. Para outros alunos distribuídos e construção de CPU, é desativado por padrão. Pode ser desligado manualmente em python, ligando cntk.cntk_py.use_sparse_gradient_aggregation_in_data_parallel_sgd(False). Note que para um caso raro de execução de treino distribuído com dispositivo CPU em uma construção GPU, você precisa desligá-lo manualmente para evitar exceção não simplificada

Classificação reduzida para convolução em C++ para permitir a convolução em dados 1D

Agora convolution e convolution_transpose apoiar os dados sem dimensão de canal ou profundidade, definindo reductionRank para 0 em vez de 1. A motivação para esta mudança é adicionar a capacidade de apoiar de forma nativa dados geométricos sem a necessidade de inserir uma dimensão de canal falso através da remodelação.

Convolução dilatada (apenas GPU)

Adicionámos suporte para a convolução de dilatação na GPU, exposta por BrainScript, C++ e Python API. A convolução da dilatação aumenta efetivamente o tamanho do núcleo, sem realmente exigir um grande núcleo. Para utilizar a convolução da dilatação, precisa de pelo menos cuDNN 6.0. A convolução dilatada melhorou o resultado da segmentação da imagem, https://arxiv.org/pdf/1511.07122.pdfalém disso, aumenta exponencialmente o campo recetivo sem aumentar a memória necessária. Uma coisa a notar é que não existe atualmente uma implementação de convolução dilatada na CPU, pelo que não é possível avaliar uma modelo que contenha convolução dilatada no CPU.

Suporte de eixos estáticos gratuitos para a convolução

  • Adicionámos apoio a eixos estáticos gratuitos FreeDimension para a convolução. Isto permite alterar o tamanho do tensor de entrada de minibatch para minibatch. Por exemplo, no caso de CNNs isto permite que cada minibatch tenha potencialmente um tamanho de imagem subjacente diferente. Foi também ativado um suporte semelhante para o nó de agrupamento.
  • Note que o exemplo R-CNN mais rápido para deteção de objetos ainda não alavanca o suporte de eixos estáticos livres para convolução (isto é, escalas e almofadas de entrada para um tamanho fixo). Este exemplo está a ser atualizado para utilizar eixos estáticos gratuitos para tamanhos de imagem de entrada arbitrária, e é direcionado para a próxima versão.

Pooling determinístico

Agora a chamada cntk.debug.force_deterministic() tornará o máximo e médio pooling determinístico, este comportamento depende da versão 6 ou posterior do cuDNN.

Adicione nó de colheita à API Python

Motivação para suportar alguma rede de segmentação de imagem, adicionámos nó de colheita a C++ e Python API. O nó de culturas cultiva a sua primeira entrada ao longo de eixos espaciais de modo a que o resultado corresponda ao tamanho espacial da sua segunda entrada (referência). Todas as dimensões não espaciais são inalteradas. As compensações de culturas podem ser especificadas diretamente, ou calculadas automaticamente, através da rede, e centros de correspondência de campos recetivos entre ativações nas duas entradas

Desempenho

Atualização da Intel MKL para melhorar velocidade de inferência no CPU em cerca de 2x no AlexNet

Este trabalho é revirado para o próximo lançamento devido à dependência das atualizações das infraestruturas de teste.

Keras e Tensorboard

Suporte multi-GPU para Keras na CNTK.

Acrescentámos um artigo para elaborar como realizar treinos paralelos em CNTK com Keras. Os detalhes estão aqui.

Suporte de imagem tensorboard para CNTK.

Adicionámos o suporte de funcionalidade de imagem para o TensorBoard. Agora CNTK os utilizadores podem usar o TensorBoard para exibir imagens. Mais detalhes e exemplos podem ser encontrados aqui.

Agradecimentos

Agradecemos aos seguintes membros da comunidade as suas contribuições:+

Pedimos desculpa por quaisquer contribuições comunitárias que possamos ter ignorado nestas notas de lançamento.

Outros

Continue o trabalho no curso deep Aprendizagem Explicou no edX.