Estamos entusiasmados em anunciar que o pacote Keras agora está disponível em Cran. O pacote fornece uma interface R para Kerasuma API de redes neurais de alto nível desenvolvida com foco em permitir a experimentação rápida. Keras tem os seguintes recursos importantes:
Permite que o mesmo código seja executado na CPU ou na GPU, perfeitamente.
API fácil de usar, o que facilita a prototipo rapidamente de modelos de aprendizado profundo.
Suporte interno para redes convolucionais (para visão computacional), redes recorrentes (para processamento de sequência) e qualquer combinação de ambos.
Suporta arquiteturas de rede arbitrárias: modelos de entrada múltipla ou multi-saída, compartilhamento de camadas, compartilhamento de modelos and many others. Isso significa que as Keras são apropriadas para criar essencialmente qualquer modelo de aprendizado profundo, de uma rede de memória a uma máquina de Turing neural.
É capaz de correr em cima de vários back-ends, incluindo TensorflowAssim, Cntkou Theano.
Se você já está familiarizado com as Keras e deseja pular direto, confira https://tensorflow.rstudio.com/keras que tem tudo o que você precisa para começar, incluindo mais de 20 exemplos completos para aprender.
Para aprender um pouco mais sobre Keras e por que estamos tão empolgados em anunciar a interface Keras para R, proceed lendo!
Keras e aprendizado profundo
O interesse pela aprendizagem profunda vem se acelerar rapidamente nos últimos anos, e várias estruturas de aprendizado profundo surgiram ao mesmo tempo. De todas as estruturas disponíveis, Keras se destacou por sua produtividade, flexibilidade e API amigável. Ao mesmo tempo, o TensorFlow emergiu como uma plataforma de aprendizado de máquina de próxima geração que é extremamente flexível e adequada para a implantação de produção.
Não é de surpreender que Keras e Tensorflow ultimamente se afastassem de outras estruturas de aprendizado profundo:
Google Net Pesquisa juros sobre estruturas de aprendizado profundo ao longo do tempo. Se você se lembra do quarto trimestre de 2015 e do Q1-2 2016 como confuso, você não estava sozinho. pic.twitter.com/1f1vqvgr8n
– François Chollet (@fChollet) 3 de junho de 2017
A boa notícia sobre Keras e Tensorflow é que você não precisa escolher entre eles! O again -end padrão para Keras é Tensorflow e as Keras podem ser integrado perfeitamente com fluxos de trabalho do tensorflow. Há também uma implementação pura-tensorflow de Keras com integração mais profunda no roteiro para o ultimate deste ano.
Keras e Tensorflow são o estado da arte em ferramentas de aprendizado profundo e, com o pacote Keras, agora você pode acessar ambos com uma interface R fluente.
Começando
Instalação
Para começar, instale o pacote Keras R de Cran da seguinte forma:
A interface Keras R usa o Tensorflow Motor de again -end por padrão. Para instalar a biblioteca do núcleo e o again -end do tensorflow, use o install_keras() função:
Isso fornecerá a você instalações baseadas em CPU padrão de Keras e Tensorflow. Se você deseja uma instalação mais personalizada, por exemplo install_keras().
Exemplo mnist
Podemos aprender o básico de Keras, passando por um exemplo simples: reconhecendo dígitos manuscritos do Mnist conjunto de dados. O MNIST consiste em 28 x 28 imagens em escala de cinza de dígitos manuscritos como estes:
O conjunto de dados também inclui rótulos para cada imagem, dizendo que é o dígito. Por exemplo, os rótulos para as imagens acima são 5, 0, 4 e 1.
Preparando os dados
O conjunto de dados MNIST está incluído no Keras e pode ser acessado usando o dataset_mnist() função. Aqui carregamos o conjunto de dados e criamos variáveis para nossos dados de teste e treinamento:
O x dados são uma matriz 3D (pictures,width,peak) de valores em escala de cinza. Para preparar os dados para o treinamento, convertemos as matrizes 3D em matrizes, reformulando a largura e a altura em uma única dimensão (as imagens de 28×28 são achatadas em 784 vetores de comprimento). Em seguida, convertemos os valores de escala de cinza de números inteiros que variam entre 0 a 255 em valores de ponto flutuante que variam entre 0 e 1:
O y Os dados são um vetor inteiro com valores que variam de 0 a 9. Para preparar esses dados para o treinamento nós codificação de um scorching os vetores em matrizes de classe binária usando as keras to_categorical() função:
y_train <- to_categorical(y_train, 10)
y_test <- to_categorical(y_test, 10)Definindo o modelo
A estrutura de dados principal do Keras é um modelo, uma maneira de organizar camadas. O tipo mais simples de modelo é o modelo seqüencialuma pilha linear de camadas.
Começamos criando um modelo seqüencial e adicionando camadas usando o tubo (%>%) Operador:
mannequin <- keras_model_sequential()
mannequin %>%
layer_dense(models = 256, activation = "relu", input_shape = c(784)) %>%
layer_dropout(fee = 0.4) %>%
layer_dense(models = 128, activation = "relu") %>%
layer_dropout(fee = 0.3) %>%
layer_dense(models = 10, activation = "softmax")O input_shape O argumento da primeira camada especifica a forma dos dados de entrada (um vetor numérico de comprimento 784 representando uma imagem em escala de cinza). A camada ultimate produz um comprimento 10 vetor numérico (probabilidades para cada dígito) usando um Função de ativação do softmax.
Use o abstract() função para imprimir os detalhes do modelo:
Mannequin
________________________________________________________________________________
Layer (kind) Output Form Param #
================================================================================
dense_1 (Dense) (None, 256) 200960
________________________________________________________________________________
dropout_1 (Dropout) (None, 256) 0
________________________________________________________________________________
dense_2 (Dense) (None, 128) 32896
________________________________________________________________________________
dropout_2 (Dropout) (None, 128) 0
________________________________________________________________________________
dense_3 (Dense) (None, 10) 1290
================================================================================
Complete params: 235,146
Trainable params: 235,146
Non-trainable params: 0
________________________________________________________________________________Em seguida, compilar o modelo com função de perda, otimizador e métricas apropriadas:
mannequin %>% compile(
loss = "categorical_crossentropy",
optimizer = optimizer_rmsprop(),
metrics = c("accuracy")
)Treinamento e avaliação
Use o match() função para treinar o modelo para 30 épocas usando lotes de 128 imagens:
historical past <- mannequin %>% match(
x_train, y_train,
epochs = 30, batch_size = 128,
validation_split = 0.2
)O historical past objeto devolvido por match() Inclui métricas de perda e precisão que podemos plotar:
Avalie o desempenho do modelo nos dados de teste:
mannequin %>% consider(x_test, y_test,verbose = 0)$loss
(1) 0.1149
$acc
(1) 0.9807Gerar previsões em novos dados:
mannequin %>% predict_classes(x_test) (1) 7 2 1 0 4 1 4 9 5 9 0 6 9 0 1 5 9 7 3 4 9 6 6 5 4 0 7 4 0 1 3 1 3 4 7 2 7 1 2
(40) 1 1 7 4 2 3 5 1 2 4 4 6 3 5 5 6 0 4 1 9 5 7 8 9 3 7 4 6 4 3 0 7 0 2 9 1 7 3 2
(79) 9 7 7 6 2 7 8 4 7 3 6 1 3 6 9 3 1 4 1 7 6 9
( reached getOption("max.print") -- omitted 9900 entries )Keras fornece um vocabulário para a construção de modelos de aprendizado profundo que são simples, elegantes e intuitivos. Construir um sistema de resposta a perguntas, um modelo de classificação de imagens, uma máquina de Turing neural ou qualquer outro modelo é igualmente direto.
O Guia para o modelo seqüencial O artigo descreve o básico dos modelos seqüenciais de Keras em mais profundidade.
Exemplos
Mais de 20 exemplos completos estão disponíveis (agradecimentos especiais a (@dfalbel)(https://github.com/dfalbel) por seu trabalho sobre isso!). Os exemplos cobrem a classificação da imagem, a geração de texto com LSTMs empilhados, a resposta a perguntas com redes de memória, aprendizado de transferência, codificação variacional e muito mais.
| Adicionar_rnn | Implementação da sequência ao aprendizado de sequência para realizar a adição de dois números (como strings). |
| babi_memnn | Treina uma rede de memória no conjunto de dados BABI para compreensão de leitura. |
| babi_rnn | Treina uma rede recorrente de duas ramos no conjunto de dados BABI para a compreensão de leitura. |
| cifar10_cnn | Treina uma CNN profunda simples no conjunto de dados de imagens pequenas do CIFAR10. |
| conv_lstm | Demonstra o uso de uma rede LSTM convolucional. |
| Deep_Dream | Sonhos profundos em Keras. |
| imdb_bidirectional_lstm | Treina um LSTM bidirecional na tarefa de classificação de sentimentos do IMDB. |
| imdb_cnn | Demonstra o uso de convolution1d para classificação de texto. |
| IMDB_CNN_LSTM | Treina uma pilha convolucional seguida de uma rede de pilha recorrente na tarefa de classificação do Sentimento do IMDB. |
| imdb_fasttext | Treina um modelo FastText na tarefa de classificação de sentimentos do IMDB. |
| imdb_lstm | Treina um LSTM na tarefa de classificação de sentimentos do IMDB. |
| lstm_text_generation | Gera texto dos escritos de Nietzsche. |
| mnist_acgan | Implementação de AC-GAN (Classificador Auxiliar GaN) no conjunto de dados MNIST |
| mnist_antirectifier | Demonstra como escrever camadas personalizadas para keras |
| mnist_cnn | Treina um convite simples no conjunto de dados MNIST. |
| mnist_irnn | Reprodução do experimento IRNN com mnist seqüencial de pixel por pixel em “uma maneira simples de inicializar redes recorrentes de unidades lineares retificadas” por Le et al. |
| mnist_mlp | Treina um perceptron de várias camadas simples e profundo no conjunto de dados MNIST. |
| mnist_hierchical_rnn | Treina um RNN hierárquico (HRNN) para classificar dígitos MNIST. |
| mnist_transfer_cnn | Transferir exemplo de brinquedo de aprendizado. |
| neural_style_transfer | Transferência de estilo neural (gerando uma imagem com o mesmo “conteúdo” que uma imagem base, mas com o “estilo” de uma imagem diferente). |
| reuters_mlp | Treina e avalia um MLP simples na tarefa de classificação de tópicos da Reuters Newswire. |
| stateful_lstm | Demonstra como usar RNNs com estado de Estado para modelar sequências longas com eficiência. |
| variational_autoEncoder | Demonstra como construir um autoencoder variacional. |
| variational_autoEncoder_deconv | Demonstra como construir um autoencoder variacional com Keras usando camadas de deconvolução. |
Aprendendo mais
Depois de se familiarizar com o básico, esses artigos são um bom próximo passo:
Guia para o modelo seqüencial. O modelo seqüencial é uma pilha linear de camadas e é a API que a maioria dos usuários deve começar.
Guia para a API funcional. A API funcional de Keras é o caminho a seguir para definir modelos complexos, como modelos de saída multi-saída, gráficos acíclicos direcionados ou modelos com camadas compartilhadas.
Visualização de treinamento. Há uma grande variedade de ferramentas disponíveis para visualizar o treinamento. Isso inclui a plotagem das métricas de treinamento, a exibição em tempo actual das métricas dentro do RSTUDIO IDE e a integração com a ferramenta de visualização do Tensorboard incluída no TensorFlow.
Usando modelos pré-treinados. O Keras inclui vários modelos de aprendizado profundo (Xception, VGG16, VGG19, Resnet50, InCceptionVV3 e MobileNet) que são disponibilizados ao lado de pesos pré-treinados. Esses modelos podem ser usados para previsão, extração de recursos e ajuste fino.
Perguntas frequentes. Abrange muitos tópicos adicionais, incluindo dados de treinamento de streaming, modelos de economia, treinamento em GPUs e muito mais.
O Keras fornece uma estrutura produtiva e altamente flexível para o desenvolvimento de modelos de aprendizado profundo. Mal podemos esperar para ver o que a comunidade R fará com essas ferramentas!